@microsoft/inshellisense 0.0.1-rc.1 → 0.0.1-rc.10

package/build/isterm/commandManager.js

@@ -0,0 +1,262 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import convert from "color-convert";
+import os from "node:os";
+import { Shell } from "../utils/shell.js";
+import log from "../utils/log.js";
+import { getConfig } from "../utils/config.js";
+const maxPromptPollDistance = 10;
+export class CommandManager {
+    #activeCommand;
+    #previousCommandLines;
+    #terminal;
+    #shell;
+    #supportsProperOscPlacements = os.platform() !== "win32";
+    constructor(terminal, shell) {
+        this.#terminal = terminal;
+        this.#shell = shell;
+        this.#activeCommand = {};
+        this.#previousCommandLines = new Set();
+        if (this.#supportsProperOscPlacements) {
+            this.#terminal.parser.registerCsiHandler({ final: "J" }, (params) => {
+                if (params.at(0) == 3 || params.at(0) == 2) {
+                    this.handleClear();
+                }
+                return false;
+            });
+        }
+    }
+    handlePromptStart() {
+        if (this.#activeCommand.promptStartMarker?.line == -1) {
+            this.#previousCommandLines = new Set();
+        }
+        this.#activeCommand = { promptStartMarker: this.#terminal.registerMarker(0), hasOutput: false, cursorTerminated: false };
+    }
+    handlePromptEnd() {
+        this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
+        if (this.#activeCommand.promptEndMarker?.line === this.#terminal.buffer.active.cursorY) {
+            this.#activeCommand.promptEndX = this.#terminal.buffer.active.cursorX;
+        }
+        if (this.#supportsProperOscPlacements) {
+            this.#activeCommand.promptText = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker?.line ?? 0)?.translateToString(true);
+            this.#previousCommandLines.add(this.#activeCommand.promptEndMarker?.line ?? -1);
+        }
+    }
+    handleClear() {
+        this.handlePromptStart();
+        this.#previousCommandLines = new Set();
+    }
+    _getWindowsPrompt(y) {
+        const line = this.#terminal.buffer.active.getLine(y);
+        if (!line) {
+            return;
+        }
+        const lineText = line.translateToString(true);
+        if (!lineText) {
+            return;
+        }
+        // User defined prompt
+        const inshellisenseConfig = getConfig();
+        if (this.#shell == Shell.Bash) {
+            if (inshellisenseConfig?.prompt?.bash != null) {
+                for (const { regex, postfix } of inshellisenseConfig.prompt.bash) {
+                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
+                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
+                    if (adjustedPrompt) {
+                        return adjustedPrompt;
+                    }
+                }
+            }
+            const bashPrompt = lineText.match(/^(?<prompt>.*\$\s?)/)?.groups?.prompt;
+            if (bashPrompt) {
+                const adjustedPrompt = this._adjustPrompt(bashPrompt, lineText, "$");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Xonsh) {
+            if (inshellisenseConfig?.prompt?.xonsh != null) {
+                for (const { regex, postfix } of inshellisenseConfig.prompt.xonsh) {
+                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
+                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
+                    if (adjustedPrompt) {
+                        return adjustedPrompt;
+                    }
+                }
+            }
+            let xonshPrompt = lineText.match(/(?<prompt>.*@\s?)/)?.groups?.prompt;
+            if (xonshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(xonshPrompt, lineText, "@");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+            xonshPrompt = lineText.match(/(?<prompt>.*>\s?)/)?.groups?.prompt;
+            if (xonshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(xonshPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Powershell || this.#shell == Shell.Pwsh) {
+            if (inshellisenseConfig?.prompt?.powershell != null) {
+                for (const { regex, postfix } of inshellisenseConfig.prompt.powershell) {
+                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
+                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
+                    if (adjustedPrompt) {
+                        return adjustedPrompt;
+                    }
+                }
+            }
+            if (inshellisenseConfig?.prompt?.pwsh != null) {
+                for (const { regex, postfix } of inshellisenseConfig.prompt.pwsh) {
+                    const customPrompt = lineText.match(new RegExp(regex))?.groups?.prompt;
+                    const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, postfix);
+                    if (adjustedPrompt) {
+                        return adjustedPrompt;
+                    }
+                }
+            }
+            const pwshPrompt = lineText.match(/(?<prompt>(\(.+\)\s)?(?:PS.+>\s?))/)?.groups?.prompt;
+            if (pwshPrompt) {
+                const adjustedPrompt = this._adjustPrompt(pwshPrompt, lineText, ">");
+                if (adjustedPrompt) {
+                    return adjustedPrompt;
+                }
+            }
+        }
+        if (this.#shell == Shell.Cmd) {
+            return lineText.match(/^(?<prompt>(\(.+\)\s)?(?:[A-Z]:\\.*>)|(> ))/)?.groups?.prompt;
+        }
+        // Custom prompts like starship end in the common \u276f character
+        const customPrompt = lineText.match(/.*\u276f(?=[^\u276f]*$)/g)?.[0];
+        if (customPrompt) {
+            const adjustedPrompt = this._adjustPrompt(customPrompt, lineText, "\u276f");
+            if (adjustedPrompt) {
+                return adjustedPrompt;
+            }
+        }
+    }
+    _adjustPrompt(prompt, lineText, char) {
+        if (!prompt) {
+            return;
+        }
+        // Conpty may not 'render' the space at the end of the prompt
+        if (lineText === prompt && prompt.endsWith(char)) {
+            prompt += " ";
+        }
+        return prompt;
+    }
+    _getFgPaletteColor(cell) {
+        if (cell?.isFgDefault())
+            return 0;
+        if (cell?.isFgPalette())
+            return cell.getFgColor();
+        if (cell?.isFgRGB())
+            return convert.hex.ansi256(cell.getFgColor().toString(16));
+    }
+    _isSuggestion(cell) {
+        const color = this._getFgPaletteColor(cell);
+        const dim = (cell?.isDim() ?? 0) > 0;
+        const italic = (cell?.isItalic() ?? 0) > 0;
+        const dullColor = color == 8 || color == 7 || (color ?? 0) > 235 || (color == 15 && dim);
+        const dullItalic = (color ?? 0) > 235 || (dullColor && italic);
+        if (this.#shell == Shell.Powershell) {
+            return false;
+        }
+        else if (this.#shell == Shell.Pwsh) {
+            return dullItalic;
+        }
+        return dullColor;
+    }
+    getState() {
+        return {
+            promptText: this.#activeCommand.promptText,
+            commandText: this.#activeCommand.commandText,
+            suggestionsText: this.#activeCommand.suggestionsText,
+            hasOutput: this.#activeCommand.hasOutput,
+            cursorTerminated: this.#activeCommand.cursorTerminated,
+        };
+    }
+    termSync() {
+        if (this.#activeCommand.promptEndMarker == null || this.#activeCommand.promptStartMarker == null) {
+            return;
+        }
+        const globalCursorPosition = this.#terminal.buffer.active.baseY + this.#terminal.buffer.active.cursorY;
+        const withinPollDistance = globalCursorPosition < this.#activeCommand.promptEndMarker.line + 5;
+        if (globalCursorPosition < this.#activeCommand.promptStartMarker.line) {
+            this.handleClear();
+            this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(0);
+        }
+        if (this.#activeCommand.promptEndMarker == null)
+            return;
+        // if we haven't fond the prompt yet, poll over the next 5 lines searching for it
+        if (this.#activeCommand.promptText == null && withinPollDistance) {
+            for (let i = globalCursorPosition; i < this.#activeCommand.promptEndMarker.line + maxPromptPollDistance; i++) {
+                if (this.#previousCommandLines.has(i))
+                    continue;
+                const promptResult = this._getWindowsPrompt(i);
+                if (promptResult != null) {
+                    this.#activeCommand.promptEndMarker = this.#terminal.registerMarker(i - globalCursorPosition);
+                    this.#activeCommand.promptEndX = promptResult.length;
+                    this.#activeCommand.promptText = promptResult;
+                    this.#previousCommandLines.add(i);
+                    break;
+                }
+            }
+        }
+        // if the prompt is set, now parse out the values from the terminal
+        if (this.#activeCommand.promptText != null) {
+            let lineY = this.#activeCommand.promptEndMarker.line;
+            let line = this.#terminal.buffer.active.getLine(this.#activeCommand.promptEndMarker.line);
+            let command = "";
+            let suggestions = "";
+            for (;;) {
+                for (let i = lineY == this.#activeCommand.promptEndMarker.line ? this.#activeCommand.promptText.length : 0; i < this.#terminal.cols; i++) {
+                    const cell = line?.getCell(i);
+                    if (cell == null)
+                        continue;
+                    const chars = cell.getChars();
+                    const cleanedChars = chars == "" ? " " : chars;
+                    if (!this._isSuggestion(cell) && suggestions.length == 0) {
+                        command += cleanedChars;
+                    }
+                    else {
+                        suggestions += cleanedChars;
+                    }
+                }
+                lineY += 1;
+                line = this.#terminal.buffer.active.getLine(lineY);
+                if (!line?.isWrapped) {
+                    break;
+                }
+            }
+            const cursorAtEndOfInput = (this.#activeCommand.promptText.length + command.trim().length) % this.#terminal.cols <= this.#terminal.buffer.active.cursorX;
+            let hasOutput = false;
+            let cell = undefined;
+            for (let i = 0; i < this.#terminal.cols; i++) {
+                cell = line?.getCell(i, cell);
+                if (cell == null)
+                    continue;
+                hasOutput = cell.getChars() != "";
+                if (hasOutput) {
+                    break;
+                }
+            }
+            const commandPostfix = this.#activeCommand.promptText.length + command.trim().length < this.#terminal.buffer.active.cursorX ? " " : "";
+            this.#activeCommand.persistentOutput = this.#activeCommand.hasOutput && hasOutput;
+            this.#activeCommand.hasOutput = hasOutput;
+            this.#activeCommand.suggestionsText = suggestions.trim();
+            this.#activeCommand.commandText = command.trim() + commandPostfix;
+            this.#activeCommand.cursorTerminated = cursorAtEndOfInput;
+        }
+        log.debug({
+            msg: "cmd manager state",
+            ...this.#activeCommand,
+            promptEndMarker: this.#activeCommand.promptEndMarker?.line,
+            promptStartMarker: this.#activeCommand.promptStartMarker?.line,
+        });
+    }
+}

package/build/isterm/index.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { spawn } from "./pty.js";
+export default { spawn };

package/build/isterm/pty.js

@@ -0,0 +1,270 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { EventEmitter } from "node:events";
+import process from "node:process";
+import os from "node:os";
+import path from "node:path";
+import url from "node:url";
+import fs from "node:fs";
+import pty from "@homebridge/node-pty-prebuilt-multiarch";
+import { Shell, getPythonPath, userZdotdir, zdotdir } from "../utils/shell.js";
+import { IsTermOscPs, IstermOscPt, IstermPromptStart, IstermPromptEnd } from "../utils/ansi.js";
+import xterm from "@xterm/headless";
+import { CommandManager } from "./commandManager.js";
+import log from "../utils/log.js";
+import { gitBashPath } from "../utils/shell.js";
+import ansi from "ansi-escapes";
+import styles from "ansi-styles";
+const ISTermOnDataEvent = "data";
+export class ISTerm {
+    pid;
+    cols;
+    rows;
+    process;
+    handleFlowControl = false;
+    onData;
+    onExit;
+    shellBuffer;
+    cwd = "";
+    #pty;
+    #ptyEmitter;
+    #term;
+    #commandManager;
+    #shell;
+    constructor({ shell, cols, rows, env, shellTarget, shellArgs, underTest }) {
+        this.#pty = pty.spawn(shellTarget, shellArgs ?? [], {
+            name: "xterm-256color",
+            cols,
+            rows,
+            cwd: process.cwd(),
+            env: { ...convertToPtyEnv(shell, underTest), ...env },
+        });
+        this.pid = this.#pty.pid;
+        this.cols = this.#pty.cols;
+        this.rows = this.#pty.rows;
+        this.process = this.#pty.process;
+        this.#term = new xterm.Terminal({ allowProposedApi: true, rows, cols });
+        this.#term.parser.registerOscHandler(IsTermOscPs, (data) => this._handleIsSequence(data));
+        this.#commandManager = new CommandManager(this.#term, shell);
+        this.#shell = shell;
+        this.#ptyEmitter = new EventEmitter();
+        this.#pty.onData((data) => {
+            this.#term.write(data, () => {
+                log.debug({ msg: "parsing data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+                this.#commandManager.termSync();
+                this.#ptyEmitter.emit(ISTermOnDataEvent, data);
+            });
+        });
+        this.onData = (listener) => {
+            this.#ptyEmitter.on(ISTermOnDataEvent, listener);
+            return {
+                dispose: () => this.#ptyEmitter.removeListener(ISTermOnDataEvent, listener),
+            };
+        };
+        this.onExit = this.#pty.onExit;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    on(_event, _listener) {
+        throw new Error("Method not implemented as deprecated in node-pty.");
+    }
+    _deserializeIsMessage(message) {
+        return message.replaceAll(/\\(\\|x([0-9a-f]{2}))/gi, (_match, op, hex) => (hex ? String.fromCharCode(parseInt(hex, 16)) : op));
+    }
+    _sanitizedCwd(cwd) {
+        if (cwd.match(/^['"].*['"]$/)) {
+            cwd = cwd.substring(1, cwd.length - 1);
+        }
+        // Convert a drive prefix to windows style when using Git Bash
+        if (os.platform() === "win32" && this.#shell == Shell.Bash && cwd && cwd.match(/^\/[A-z]{1}\//)) {
+            cwd = `${cwd[1]}:\\` + cwd.substring(3, cwd.length);
+        }
+        // Make the drive letter uppercase on Windows (see vscode #9448)
+        if (os.platform() === "win32" && cwd && cwd[1] === ":") {
+            return cwd[0].toUpperCase() + cwd.substring(1);
+        }
+        return cwd;
+    }
+    _handleIsSequence(data) {
+        const argsIndex = data.indexOf(";");
+        const sequence = argsIndex === -1 ? data : data.substring(0, argsIndex);
+        switch (sequence) {
+            case IstermOscPt.PromptStarted:
+                this.#commandManager.handlePromptStart();
+                break;
+            case IstermOscPt.PromptEnded:
+                this.#commandManager.handlePromptEnd();
+                break;
+            case IstermOscPt.CurrentWorkingDirectory: {
+                const cwd = data.split(";").at(1);
+                if (cwd != null) {
+                    this.cwd = path.resolve(this._sanitizedCwd(this._deserializeIsMessage(cwd)));
+                }
+                break;
+            }
+            default:
+                return false;
+        }
+        return true;
+    }
+    noop() {
+        this.#ptyEmitter.emit(ISTermOnDataEvent, "");
+    }
+    resize(columns, rows) {
+        this.cols = columns;
+        this.rows = rows;
+        this.#pty.resize(columns, rows);
+        this.#term.resize(columns, rows);
+    }
+    clear() {
+        this.#term.reset();
+        this.#pty.clear();
+    }
+    kill(signal) {
+        this.#pty.kill(signal);
+    }
+    pause() {
+        this.#pty.pause();
+    }
+    resume() {
+        this.#pty.resume();
+    }
+    write(data) {
+        log.debug({ msg: "reading data", data, bytes: Uint8Array.from([...data].map((c) => c.charCodeAt(0))) });
+        this.#pty.write(data);
+    }
+    getCommandState() {
+        return this.#commandManager.getState();
+    }
+    getCursorState() {
+        return {
+            onLastLine: this.#term.buffer.active.cursorY >= this.#term.rows - 2,
+            remainingLines: Math.max(this.#term.rows - 2 - this.#term.buffer.active.cursorY, 0),
+            cursorX: this.#term.buffer.active.cursorX,
+            cursorY: this.#term.buffer.active.cursorY,
+        };
+    }
+    _sameColor(baseCell, targetCell) {
+        return (baseCell?.getBgColorMode() == targetCell?.getBgColorMode() &&
+            baseCell?.getBgColor() == targetCell?.getBgColor() &&
+            baseCell?.getFgColorMode() == targetCell?.getFgColorMode() &&
+            baseCell?.getFgColor() == targetCell?.getFgColor());
+    }
+    _getAnsiColors(cell) {
+        if (cell == null)
+            return "";
+        let bgAnsi = "";
+        cell.getBgColor;
+        cell.getFgColor;
+        if (cell.isBgDefault()) {
+            bgAnsi = "\x1b[49m";
+        }
+        else if (cell.isBgPalette()) {
+            bgAnsi = `\x1b[48;5;${cell.getBgColor()}m`;
+        }
+        else {
+            bgAnsi = `\x1b[48;5;${styles.hexToAnsi256(cell.getBgColor().toString(16))}m`;
+        }
+        let fgAnsi = "";
+        if (cell.isFgDefault()) {
+            fgAnsi = "\x1b[39m";
+        }
+        else if (cell.isFgPalette()) {
+            fgAnsi = `\x1b[38;5;${cell.getFgColor()}m`;
+        }
+        else {
+            fgAnsi = `\x1b[38;5;${styles.hexToAnsi256(cell.getFgColor().toString(16))}m`;
+        }
+        return bgAnsi + fgAnsi;
+    }
+    getCells(height, direction) {
+        const currentCursorPosition = this.#term.buffer.active.cursorY + this.#term.buffer.active.baseY;
+        const writeLine = (y) => {
+            const line = this.#term.buffer.active.getLine(y);
+            const ansiLine = ["\x1b[0m"];
+            if (line == null)
+                return "";
+            let prevCell;
+            for (let x = 0; x < line.length; x++) {
+                const cell = line.getCell(x);
+                const chars = cell?.getChars() ?? "";
+                if (!this._sameColor(prevCell, cell)) {
+                    ansiLine.push(this._getAnsiColors(cell));
+                }
+                ansiLine.push(chars == "" ? " " : chars);
+                prevCell = cell;
+            }
+            return ansiLine.join("");
+        };
+        const lines = [];
+        if (direction == "above") {
+            const startCursorPosition = currentCursorPosition - 1;
+            const endCursorPosition = currentCursorPosition - 1 - height;
+            for (let y = startCursorPosition; y > endCursorPosition; y--) {
+                lines.push(writeLine(y));
+            }
+        }
+        else {
+            const startCursorPosition = currentCursorPosition + 1;
+            const endCursorPosition = currentCursorPosition + 1 + height;
+            for (let y = startCursorPosition; y < endCursorPosition; y++) {
+                lines.push(writeLine(y));
+            }
+        }
+        return lines.reverse().join(ansi.cursorNextLine);
+    }
+}
+export const spawn = async (options) => {
+    const { shellTarget, shellArgs } = await convertToPtyTarget(options.shell);
+    return new ISTerm({ ...options, shellTarget, shellArgs });
+};
+const convertToPtyTarget = async (shell) => {
+    const platform = os.platform();
+    let shellTarget = shell == Shell.Bash && platform == "win32" ? await gitBashPath() : platform == "win32" ? `${shell}.exe` : shell;
+    const shellFolderPath = path.join(path.dirname(url.fileURLToPath(import.meta.url)), "..", "..", "shell");
+    let shellArgs = [];
+    switch (shell) {
+        case Shell.Bash:
+            shellArgs = ["--init-file", path.join(shellFolderPath, "shellIntegration.bash")];
+            break;
+        case Shell.Powershell:
+        case Shell.Pwsh:
+            shellArgs = ["-noexit", "-command", `try { . "${path.join(shellFolderPath, "shellIntegration.ps1")}" } catch {}`];
+            break;
+        case Shell.Fish:
+            shellArgs = ["--init-command", `. ${path.join(shellFolderPath, "shellIntegration.fish").replace(/(\s+)/g, "\\$1")}`];
+            break;
+        case Shell.Xonsh: {
+            const sharedConfig = os.platform() == "win32" ? path.join("C:\\ProgramData", "xonsh", "xonshrc") : path.join("etc", "xonsh", "xonshrc");
+            const userConfigs = [
+                path.join(os.homedir(), ".xonshrc"),
+                path.join(os.homedir(), ".config", "xonsh", "rc.xsh"),
+                path.join(os.homedir(), ".config", "xonsh", "rc.d"),
+            ];
+            const configs = [sharedConfig, ...userConfigs].filter((config) => fs.existsSync(config));
+            shellArgs = ["-m", "xonsh", "--rc", ...configs, path.join(shellFolderPath, "shellIntegration.xsh")];
+            shellTarget = await getPythonPath();
+            break;
+        }
+    }
+    return { shellTarget, shellArgs };
+};
+const convertToPtyEnv = (shell, underTest) => {
+    const env = {
+        ...process.env,
+        ISTERM: "1",
+        ISTERM_TESTING: underTest ? "1" : undefined,
+    };
+    switch (shell) {
+        case Shell.Cmd: {
+            if (underTest) {
+                return { ...env, PROMPT: `${IstermPromptStart}$G ${IstermPromptEnd}` };
+            }
+            const prompt = process.env.PROMPT ? process.env.PROMPT : "$P$G";
+            return { ...env, PROMPT: `${IstermPromptStart}${prompt}${IstermPromptEnd}` };
+        }
+        case Shell.Zsh: {
+            return { ...env, ZDOTDIR: zdotdir, USER_ZDOTDIR: userZdotdir };
+        }
+    }
+    return env;
+};

package/build/runtime/generator.js

@@ -1,11 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import log from "../utils/log.js";
 import { runTemplates } from "./template.js";
 import { buildExecuteShellCommand } from "./utils.js";
-const getGeneratorContext = () => {
+const getGeneratorContext = (cwd) => {
     return {
         environmentVariables: Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null)),
-        currentWorkingDirectory: process.cwd(),
+        currentWorkingDirectory: cwd,
         currentProcess: "",
         sshPrefix: "",
         isDangerous: false,
@@ -13,30 +14,42 @@ const getGeneratorContext = () => {
     };
 };
 // TODO: add support for caching, trigger, & getQueryTerm
-export const runGenerator = async (generator, tokens) => {
-    const { script, postProcess, scriptTimeout, splitOn, custom, template } = generator;
+export const runGenerator = async (generator, tokens, cwd) => {
+    // TODO: support trigger
+    const { script, postProcess, scriptTimeout, splitOn, custom, template, filterTemplateSuggestions } = generator;
     const executeShellCommand = buildExecuteShellCommand(scriptTimeout ?? 5000);
     const suggestions = [];
     try {
         if (script) {
-            const scriptOutput = typeof script === "function" ? script(tokens) : script != null ? await executeShellCommand(script) : "";
+            const shellInput = typeof script === "function" ? script(tokens) : script;
+            const scriptOutput = Array.isArray(shellInput)
+                ? await executeShellCommand({ command: shellInput.at(0) ?? "", args: shellInput.slice(1), cwd })
+                : await executeShellCommand({ ...shellInput, cwd });
+            const scriptStdout = scriptOutput.stdout.trim();
             if (postProcess) {
-                suggestions.push(...postProcess(scriptOutput, tokens));
+                suggestions.push(...postProcess(scriptStdout, tokens));
             }
             else if (splitOn) {
-                suggestions.push(...scriptOutput.split(splitOn).map((s) => ({ name: s })));
+                suggestions.push(...scriptStdout.split(splitOn).map((s) => ({ name: s })));
             }
         }
         if (custom) {
-            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext())));
+            suggestions.push(...(await custom(tokens, executeShellCommand, getGeneratorContext(cwd))));
         }
         if (template != null) {
-            suggestions.push(...(await runTemplates(template)));
+            const templateSuggestions = await runTemplates(template, cwd);
+            if (filterTemplateSuggestions) {
+                suggestions.push(...filterTemplateSuggestions(templateSuggestions));
+            }
+            else {
+                suggestions.push(...templateSuggestions);
+            }
         }
         return suggestions;
     }
     catch (e) {
-        /* empty */
+        const err = typeof e === "string" ? e : e instanceof Error ? e.message : e;
+        log.debug({ msg: "generator failed", err, script, splitOn, template });
     }
     return suggestions;
 };

package/build/runtime/parser.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-const cmdDelim = /(\|\|)|(&&)|(;)/;
+const cmdDelim = /(\|\|)|(&&)|(;)|(\|)/;
 const spaceRegex = /\s/;
 export const parseCommand = (command) => {
     const lastCommand = command.split(cmdDelim).at(-1)?.trimStart();
@@ -56,7 +56,7 @@ const lex = (command) => {
         tokens.push({
             token: command.slice(readingIdx),
             complete: false,
-            isOption: false,
+            isOption: readingFlag,
         });
     }
     return tokens;