Moved around some items to prepare for the intellisense implementation

Author: justinwilaby

package-lock.json

@@ -20,6 +20,7 @@
     "vscode.git"
   ],
   "main": "./out/extension/index.js",
+  "l10n": "./l10n",
   "contributes": {
     "viewsWelcome": [
       {
@@ -192,7 +193,6 @@
     "format": "prettier . --write --config ./.prettier.mjs"
   },
   "devDependencies": {
-    "@oclif/config": "^1.18.17",
     "@types/mocha": "^10.0.7",
     "@types/mvdan-sh": "^0.10.9",
     "@types/node": "18.x",
@@ -222,8 +222,9 @@
     "@heroku-cli/schema": "file:heroku-cli-schema-1.0.25.tgz",
     "@microsoft/fast-element": "^1.13.0",
     "@vscode/codicons": "^0.0.36",
-    "@vscode/l10n": "0.0.x",
+    "@vscode/l10n": "0.0.18",
     "@vscode/webview-ui-toolkit": "^1.4.0",
+    "@oclif/core": "2.16.0",
     "marked": "^13.0.3",
     "mvdan-sh": "^0.10.1",
     "resolve.exports": "^2.0.2",

package.json

@@ -7,6 +7,10 @@
     "message": "It looks like this project is not a Heroku app.\n[Get started on Heroku](https://devcenter.heroku.com/start)"
   },
 
+  "heroku.cli.description": {
+    "message": "The Heroku CLI is used to manage Heroku apps from the command line. It is built using [oclif](https://oclif.io).\nFor more about Heroku see <https://www.heroku.com/home>\nTo get started see <https://devcenter.heroku.com/start>"
+  },
+
   "view.heroku.name": {
     "message": "Heroku"
   },

package.nls.json

@@ -0,0 +1,57 @@
+import type { Command } from '@oclif/core/lib/command';
+import { herokuCommand } from '../../meta/command';
+import { HerokuCommand } from '../heroku-command';
+
+export declare namespace GetHerokuCommandsJson {
+  export type ManifestMeta = Map<Command.Cached['id'], Command.Cached>;
+}
+
+@herokuCommand()
+/**
+ * The GetHerokuCommandsJson retrieves command meta data
+ * from the heroku cli and returns it as a Map of
+ * command id to command meta data.
+ *
+ * This data is used for the hover, intellisense, autocomplete and
+ * error checking when authoring a shell script that uses the
+ * heroku cli.
+ */
+export class GetHerokuCommandsJson extends HerokuCommand<GetHerokuCommandsJson.ManifestMeta> {
+  public static COMMAND_ID = 'heroku:cli:get-commands' as const;
+  private static manifestPromise: Promise<GetHerokuCommandsJson.ManifestMeta>;
+
+  /**
+   * Gets the heroku commands json based on
+   * the current heroku cli installed on the
+   * user's machine.
+   *
+   * @returns Command.Cached
+   */
+  public async run(): Promise<GetHerokuCommandsJson.ManifestMeta> {
+    if (GetHerokuCommandsJson.manifestPromise !== undefined) {
+      return GetHerokuCommandsJson.manifestPromise;
+    }
+    GetHerokuCommandsJson.manifestPromise = this.getManifest();
+    return GetHerokuCommandsJson.manifestPromise;
+  }
+
+  /**
+   * Gets the manifest of the heroku cli commands.
+   *
+   * @returns Promise<GetHerokuCommandsJson.ManifestMeta>
+   */
+  private async getManifest(): Promise<GetHerokuCommandsJson.ManifestMeta> {
+    using commandsJsonProcess = HerokuCommand.exec('heroku commands --json', {
+      signal: this.signal,
+      timeout: 120 * 1000
+    });
+    const result = await HerokuCommand.waitForCompletion(commandsJsonProcess);
+    const json = JSON.parse(result.output) as Command.Cached[];
+    const manifest = new Map<Command.Cached['id'], Command.Cached>();
+    for (const element of json) {
+      manifest.set(element.id, element);
+    }
+
+    return manifest;
+  }
+}

src/extension/commands/cli/get-heroku-commands-json.ts

@@ -21,6 +21,28 @@ export function isHerokuCallExpression(node: sh.Node | undefined): node is sh.Ca
   );
 }
 
+/**
+ * Determines if the specified node is a partial heroku
+ * command call expression. This test is true
+ * if the node is a sh.CallExpr and contains a
+ * string literal as the first argument which
+ * is a partial match to "heroku" and contains
+ * at least the chars "her".
+ *
+ * @param node The node to test.
+ * @returns boolean
+ */
+export function isPartialHerokuCallExpression(node: sh.Node | undefined): node is sh.CallExpr {
+  return (
+    !!node &&
+    isCallExpr(node) &&
+    !!node.Args.length &&
+    !!node.Args[0]?.Parts?.length &&
+    isLiteral(node.Args[0].Parts[0]) &&
+    /^(?:her)(?:o|$)(?:k|$)(?:u|$)/.test(node.Args[0].Parts[0].Value)
+  );
+}
+
 /**
  * Determines if the specified node is a sh.CallExpr.
  *

src/extension/lexers/lexer-utils.ts

@@ -1,6 +1,26 @@
 import sh from 'mvdan-sh';
 import * as vscode from 'vscode';
-import { isInsideRangeBoundary } from './lexer-utils.js';
+import { isHerokuCallExpression, isInsideRangeBoundary, isPartialHerokuCallExpression } from './lexer-utils.js';
+
+export type HerokuCommandEntity =
+  | {
+      type: 'heroku' | 'command';
+      node: sh.Node;
+      command?: never;
+      flagKey?: never;
+    }
+  | {
+      node: sh.Node;
+      type: 'flag';
+      flagKey: string;
+      command: sh.Word;
+    }
+  | {
+      node: sh.Node;
+      type: 'arg';
+      command: sh.Word;
+      argIndex: number;
+    };
 
 /**
  * The ShellScriptLexer class provides functionality
@@ -47,4 +67,78 @@ export class ShellScriptLexer {
     });
     return targets;
   }
+
+  /**
+   * Finds the heroku command entity at the specified position.
+   *
+   * @param position The position of the cursor in the document.
+   * @param includePartialHerokuCallExpression Whether to include partial heroku call expressions.
+   * @returns sh.Node | null
+   */
+  public findEntityAtPosition(
+    position: vscode.Position,
+    includePartialHerokuCallExpression = false
+  ): HerokuCommandEntity | null {
+    const nodes = this.findNodesAtPosition(position);
+    const node = nodes.find(
+      includePartialHerokuCallExpression ? isPartialHerokuCallExpression : isHerokuCallExpression
+    );
+    if (!node) {
+      return null;
+    }
+    const { Args: args } = node;
+    const [heroku, command, ...flagsOrArgs] = args;
+    // -----------------------------------
+    // We're over a heroku call expression
+    // -----------------------------------
+    if (isInsideRangeBoundary(heroku, position)) {
+      return { type: 'heroku', node: heroku as sh.Word };
+    }
+    // ---------------------------
+    // We're over a heroku command
+    // ---------------------------
+    if (isInsideRangeBoundary(command, position)) {
+      return { type: 'command', node: command as sh.Word };
+    }
+    // -------------------------------
+    // we're over a heroku flag or arg
+    // -------------------------------
+    const [targetFlagOrArg] = flagsOrArgs.filter((flagOrArg) => isInsideRangeBoundary(flagOrArg, position));
+    if (!targetFlagOrArg) {
+      return null;
+    }
+
+    const id = targetFlagOrArg.Lit();
+    let flagKey: string = '';
+    // This is either a command argument or a flag value.
+    if (!id.startsWith('-')) {
+      const idx = flagsOrArgs.indexOf(targetFlagOrArg);
+      // back up in the list of flags or args
+      // until we find the associated flag or
+      // we determine this is a command arg.
+      let i = idx;
+      while (i-- > -1) {
+        const maybeFlag = flagsOrArgs[i];
+        const maybeFladId = maybeFlag?.Lit() ?? '';
+        if (maybeFladId.startsWith('-')) {
+          flagKey = maybeFladId.replace(/^[-]+/, '');
+          break;
+        }
+      }
+      // We didn't find a flag so this
+      // must be a command argument
+      if (!flagKey) {
+        // args occur in the order in which the
+        // properties are defined. Indexed
+        // keys will be accurately mapped.
+
+        return { node: targetFlagOrArg, type: 'arg', command: command as sh.Word, argIndex: idx };
+      }
+    } else if (id.startsWith('-')) {
+      // might be in the format --flag=flag-value
+      const [flagId] = id.split('=');
+      flagKey = flagId.replace(/^[-]+/, '');
+    }
+    return { node: targetFlagOrArg, type: 'flag', flagKey, command: command as sh.Word };
+  }
 }