@flowscripter/dynamic-cli-framework 1.7.3 → 1.7.4

package/dist/src/service/completion/CompletionServiceProvider.js

@@ -0,0 +1,160 @@
+import process from "node:process";
+import { COMPLETION_SERVICE_ID } from "../../api/service/core/CompletionService.js";
+import { ShellType } from "../../api/service/core/CompletionService.js";
+import { PROMPTER_SERVICE_ID } from "../../api/service/core/PrompterService.js";
+import { PromptType } from "../../api/service/core/PrompterService.js";
+import { KEY_VALUE_SERVICE_ID } from "../../api/service/core/KeyValueService.js";
+import { Icon, PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.js";
+import getLogger from "../../util/logger.js";
+import { CompletionIntegrationSubCommand } from "./command/CompletionIntegrationSubCommand.js";
+import { CompletionCompleteSubCommand } from "./command/CompletionCompleteSubCommand.js";
+import { CompletionGroupCommand } from "./command/CompletionGroupCommand.js";
+const logger = getLogger("CompletionServiceProvider");
+export default class CompletionServiceProvider {
+    serviceId = COMPLETION_SERVICE_ID;
+    servicePriority;
+    #completionService;
+    #cliName = "";
+    constructor(servicePriority, completionService, commandRegistry) {
+        this.servicePriority = servicePriority;
+        this.#completionService = completionService;
+        this.#completionService.setCommandRegistry(commandRegistry);
+    }
+    getServiceInfo(cliConfig) {
+        this.#cliName = cliConfig.name;
+        return Promise.resolve({
+            service: this.#completionService,
+            commands: [
+                new CompletionGroupCommand(new CompletionIntegrationSubCommand(), new CompletionCompleteSubCommand()),
+            ],
+        });
+    }
+    async initService(context) {
+        if (!context.doesServiceExist(PROMPTER_SERVICE_ID)) {
+            logger.debug(() => "PrompterService not available, skipping auto-prompt");
+            return;
+        }
+        if (!context.doesServiceExist(KEY_VALUE_SERVICE_ID)) {
+            logger.debug(() => "KeyValueService not available, skipping auto-prompt");
+            return;
+        }
+        const keyValueService = context.getServiceById(KEY_VALUE_SERVICE_ID);
+        if (await keyValueService.hasKey("completion-status")) {
+            const status = await keyValueService.getKey("completion-status");
+            if (status === "installed" || status === "declined") {
+                logger.debug(() => `Completion status is '${status}', skipping auto-prompt`);
+                return;
+            }
+        }
+        const prompterService = context.getServiceById(PROMPTER_SERVICE_ID);
+        if (!prompterService.promptEnabled) {
+            logger.debug(() => "Prompting is disabled, skipping auto-prompt");
+            return;
+        }
+        const detectedShells = await this.#detectAvailableShells();
+        if (detectedShells.length === 0) {
+            logger.debug(() => "No supported shells detected, skipping auto-prompt");
+            return;
+        }
+        let enableResult;
+        try {
+            enableResult = await prompterService.prompt({
+                name: "enable-completion",
+                promptText: "Would you like to enable autocompletion?",
+                description: "This will set up your terminal so that pressing TAB while typing commands will show possible options and autocomplete arguments.\n(Enabling autocompletion will modify configuration files in your home directory.)",
+                type: PromptType.TOGGLE,
+                options: [
+                    { displayValue: "Yes", returnedValue: true },
+                    { displayValue: "No", returnedValue: false },
+                ],
+            });
+        }
+        catch {
+            return;
+        }
+        if (enableResult.value !== true) {
+            await keyValueService.setKey("completion-status", "declined");
+            return;
+        }
+        let shellType;
+        if (detectedShells.length === 1) {
+            shellType = detectedShells[0];
+        }
+        else {
+            const shellOptions = detectedShells.map((shell) => ({
+                displayValue: shell,
+                returnedValue: shell,
+            }));
+            let shellResult;
+            try {
+                shellResult = await prompterService.prompt({
+                    name: "shell-type",
+                    promptText: "Which shell would you like to configure?",
+                    type: PromptType.SINGLE_SELECT,
+                    defaultOption: shellOptions[0],
+                    options: shellOptions,
+                });
+            }
+            catch {
+                return;
+            }
+            shellType = shellResult.value;
+        }
+        try {
+            await this.#installCompletion(context, shellType);
+            await keyValueService.setKey("completion-status", "installed");
+        }
+        catch (error) {
+            logger.error("Failed to install completion: %s", error.message);
+            if (context.doesServiceExist(PRINTER_SERVICE_ID)) {
+                const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+                await printerService.error(`Failed to install completion: ${error.message}`, Icon.FAILURE);
+            }
+        }
+    }
+    async #detectAvailableShells() {
+        const available = [];
+        for (const shell of Object.values(ShellType)) {
+            if (await this.#completionService.validateShellEnvironment(shell)) {
+                available.push(shell);
+            }
+        }
+        return available;
+    }
+    async #installCompletion(context, shellType) {
+        const configPath = this.#completionService.getDefaultConfigPath(shellType);
+        const bootstrapScript = this.#completionService.getBootstrapScript(shellType, this.#cliName, process.execPath);
+        const beginMarker = `# BEGIN ${this.#cliName} completion`;
+        const endMarker = `# END ${this.#cliName} completion`;
+        const block = `${beginMarker}\n${bootstrapScript}\n${endMarker}`;
+        let existingContent = "";
+        try {
+            existingContent = await Bun.file(configPath).text();
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        let newContent;
+        const beginIdx = existingContent.indexOf(beginMarker);
+        const endIdx = existingContent.indexOf(endMarker);
+        if (beginIdx !== -1 && endIdx !== -1) {
+            newContent =
+                existingContent.substring(0, beginIdx) +
+                    block +
+                    existingContent.substring(endIdx + endMarker.length);
+        }
+        else {
+            const separator = existingContent.length > 0 && !existingContent.endsWith("\n")
+                ? "\n\n"
+                : existingContent.length > 0
+                    ? "\n"
+                    : "";
+            newContent = existingContent + separator + block + "\n";
+        }
+        await Bun.write(configPath, newContent);
+        if (context.doesServiceExist(PRINTER_SERVICE_ID)) {
+            const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+            await printerService.info(`Shell completion installed for ${shellType}. Restart your shell or run 'source ${configPath}' to activate.`, Icon.SUCCESS);
+        }
+    }
+}

package/dist/src/service/completion/DefaultCompletionService.js

@@ -0,0 +1,279 @@
+import { ShellType } from "../../api/service/core/CompletionService.js";
+import BashShellHandler from "./shell/bash.js";
+import ZshShellHandler from "./shell/zsh.js";
+import FishShellHandler from "./shell/fish.js";
+import PowerShellShellHandler from "./shell/powershell.js";
+export default class DefaultCompletionService {
+    #commandRegistry;
+    #shellHandlers = new Map([
+        [ShellType.BASH, new BashShellHandler()],
+        [ShellType.ZSH, new ZshShellHandler()],
+        [ShellType.FISH, new FishShellHandler()],
+        [ShellType.POWERSHELL, new PowerShellShellHandler()],
+    ]);
+    setCommandRegistry(registry) {
+        this.#commandRegistry = registry;
+    }
+    getBootstrapScript(shellType, cliName, executablePath) {
+        return this.#getHandler(shellType).getBootstrapScript(cliName, executablePath);
+    }
+    getDefaultConfigPath(shellType) {
+        return this.#getHandler(shellType).getDefaultConfigPath();
+    }
+    validateShellEnvironment(shellType) {
+        return this.#getHandler(shellType).validateEnvironment();
+    }
+    formatCompletions(shellType, completions) {
+        return this.#getHandler(shellType).formatCompletions(completions);
+    }
+    parseCompletionContext(shell, args) {
+        return this.#getHandler(shell).parseCompletionContext(args);
+    }
+    generateCompletions(_shellType, line, cursorPosition) {
+        if (!this.#commandRegistry) {
+            return Promise.resolve([]);
+        }
+        const beforeCursor = line.substring(0, cursorPosition);
+        const words = this.#tokenize(beforeCursor);
+        // Remove CLI name (first word)
+        const relevantWords = words.slice(1);
+        const currentWord = relevantWords[relevantWords.length - 1] ?? "";
+        const previousWords = relevantWords.slice(0, -1);
+        const endsWithSpace = beforeCursor.endsWith(" ");
+        if (relevantWords.length === 0 || (relevantWords.length === 1 && !endsWithSpace)) {
+            return Promise.resolve(this.#completeCommandName(currentWord));
+        }
+        if (endsWithSpace) {
+            const commandWord = relevantWords[0];
+            return Promise.resolve(this.#completeAfterCommand(commandWord, relevantWords.slice(1), ""));
+        }
+        const commandWord = previousWords[0];
+        if (commandWord) {
+            return Promise.resolve(this.#completeAfterCommand(commandWord, previousWords.slice(1), currentWord));
+        }
+        return Promise.resolve(this.#completeCommandName(currentWord));
+    }
+    #completeAfterCommand(commandWord, intermediateWords, currentWord) {
+        // Check for group:member pattern
+        if (commandWord.includes(":")) {
+            const result = this.#commandRegistry.getGroupCommandAndMemberSubCommandByJoinedName(commandWord);
+            if (result) {
+                return this.#completeSubCommandArgs(result.command, intermediateWords, currentWord);
+            }
+        }
+        // Check if partial group:member (e.g. "completions:" completing member)
+        if (currentWord.includes(":")) {
+            const colonIdx = currentWord.indexOf(":");
+            const groupPart = currentWord.substring(0, colonIdx);
+            const groupCommand = this.#commandRegistry.getGroupCommandByName(groupPart);
+            if (groupCommand) {
+                return groupCommand.memberSubCommands
+                    .filter((sc) => `${groupPart}:${sc.name}`.startsWith(currentWord))
+                    .map((sc) => ({
+                    value: `${groupPart}:${sc.name}`,
+                    description: sc.description,
+                }));
+            }
+        }
+        // Check global command (--name pattern)
+        if (commandWord.startsWith("--")) {
+            const globalCommandName = commandWord.substring(2);
+            const globalCommand = this.#commandRegistry.getGlobalCommandByName(globalCommandName);
+            if (globalCommand) {
+                if (globalCommand.argument?.allowableValues) {
+                    return globalCommand.argument.allowableValues
+                        .filter((v) => String(v).startsWith(currentWord))
+                        .map((v) => ({ value: String(v) }));
+                }
+                return [];
+            }
+        }
+        // Check sub-command
+        const subCommand = this.#commandRegistry.getSubCommandByName(commandWord);
+        if (subCommand) {
+            return this.#completeSubCommandArgs(subCommand, intermediateWords, currentWord);
+        }
+        // Check group command (suggest members)
+        const groupCommand = this.#commandRegistry.getGroupCommandByName(commandWord);
+        if (groupCommand) {
+            return groupCommand.memberSubCommands
+                .filter((sc) => sc.name.startsWith(currentWord))
+                .map((sc) => ({
+                value: `${commandWord}:${sc.name}`,
+                description: sc.description,
+            }));
+        }
+        return this.#completeCommandName(currentWord);
+    }
+    #completeCommandName(prefix) {
+        const completions = [];
+        // Sub-commands
+        const subCommands = this.#commandRegistry.getSubCommands();
+        for (const cmd of subCommands) {
+            if (cmd.name.startsWith(prefix)) {
+                completions.push({ value: cmd.name, description: cmd.description });
+            }
+        }
+        // Group:member joined names
+        const groupAndMembers = this.#commandRegistry.getGroupAndMemberCommandsByJoinedName();
+        for (const [joinedName, entry] of groupAndMembers) {
+            if (joinedName.startsWith(prefix)) {
+                completions.push({
+                    value: joinedName,
+                    description: entry.command.description,
+                });
+            }
+        }
+        // Group command names (to suggest further typing "group:")
+        const groupCommands = this.#commandRegistry.getGroupCommands();
+        for (const cmd of groupCommands) {
+            if (cmd.name.startsWith(prefix) && !prefix.includes(":")) {
+                completions.push({
+                    value: cmd.name,
+                    description: cmd.description,
+                });
+            }
+        }
+        // Global commands (with -- prefix)
+        const globalCommands = this.#commandRegistry.getGlobalCommands();
+        for (const cmd of globalCommands) {
+            const prefixed = `--${cmd.name}`;
+            if (prefixed.startsWith(prefix)) {
+                completions.push({ value: prefixed, description: cmd.description });
+            }
+        }
+        // Global modifier commands (with -- prefix)
+        const modifierCommands = this.#commandRegistry.getGlobalModifierCommands();
+        for (const cmd of modifierCommands) {
+            const prefixed = `--${cmd.name}`;
+            if (prefixed.startsWith(prefix)) {
+                completions.push({ value: prefixed, description: cmd.description });
+            }
+        }
+        return completions;
+    }
+    #completeSubCommandArgs(subCommand, previousArgs, currentWord) {
+        const completions = [];
+        // If current word starts with --, complete option names
+        if (currentWord.startsWith("--")) {
+            const prefix = currentWord.substring(2);
+            for (const opt of subCommand.options) {
+                if ("name" in opt && opt.name.startsWith(prefix)) {
+                    completions.push({
+                        value: `--${opt.name}`,
+                        description: opt.description,
+                    });
+                }
+            }
+            return completions;
+        }
+        // If current word starts with -, complete short aliases
+        if (currentWord.startsWith("-") && currentWord.length <= 2) {
+            for (const opt of subCommand.options) {
+                if ("shortAlias" in opt && opt.shortAlias) {
+                    const alias = `-${opt.shortAlias}`;
+                    if (alias.startsWith(currentWord)) {
+                        completions.push({
+                            value: alias,
+                            description: opt.description,
+                        });
+                    }
+                }
+            }
+            return completions;
+        }
+        // Check if previous word was an option expecting a value
+        const lastPrevWord = previousArgs[previousArgs.length - 1];
+        if (lastPrevWord && lastPrevWord.startsWith("--")) {
+            const optName = lastPrevWord.substring(2);
+            const option = subCommand.options.find((o) => "name" in o && o.name === optName);
+            if (option && option.allowableValues) {
+                return option.allowableValues
+                    .filter((v) => String(v).startsWith(currentWord))
+                    .map((v) => ({ value: String(v) }));
+            }
+        }
+        // Suggest options that haven't been used
+        for (const opt of subCommand.options) {
+            if ("name" in opt) {
+                const optName = `--${opt.name}`;
+                if (!previousArgs.includes(optName) && optName.startsWith(currentWord)) {
+                    completions.push({
+                        value: optName,
+                        description: opt.description,
+                    });
+                }
+            }
+        }
+        // Suggest positional allowable values
+        const positionalIndex = this.#countPositionalArgs(previousArgs, subCommand);
+        if (positionalIndex < subCommand.positionals.length) {
+            const positional = subCommand.positionals[positionalIndex];
+            if (positional.allowableValues) {
+                for (const v of positional.allowableValues) {
+                    if (String(v).startsWith(currentWord)) {
+                        completions.push({ value: String(v) });
+                    }
+                }
+            }
+        }
+        return completions;
+    }
+    #countPositionalArgs(args, subCommand) {
+        let count = 0;
+        let i = 0;
+        while (i < args.length) {
+            const arg = args[i];
+            if (arg.startsWith("-")) {
+                // Skip option and its value
+                const optName = arg.startsWith("--") ? arg.substring(2) : undefined;
+                const option = optName
+                    ? subCommand.options.find((o) => "name" in o && o.name === optName)
+                    : undefined;
+                if (option && option.type !== undefined) {
+                    i++; // skip the option value
+                }
+            }
+            else {
+                count++;
+            }
+            i++;
+        }
+        return count;
+    }
+    #tokenize(input) {
+        const words = [];
+        let current = "";
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            }
+            else if (ch === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            else if (ch === " " && !inSingleQuote && !inDoubleQuote) {
+                if (current.length > 0) {
+                    words.push(current);
+                    current = "";
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        if (current.length > 0) {
+            words.push(current);
+        }
+        return words;
+    }
+    #getHandler(shellType) {
+        const handler = this.#shellHandlers.get(shellType);
+        if (!handler) {
+            throw new Error(`Unsupported shell type: ${shellType}`);
+        }
+        return handler;
+    }
+}

package/dist/src/service/completion/command/CompletionCompleteSubCommand.d.ts

@@ -0,0 +1,15 @@
+import type SubCommand from "../../../api/command/SubCommand.ts";
+import type Option from "../../../api/argument/Option.ts";
+import type Positional from "../../../api/argument/Positional.ts";
+import type Context from "../../../api/Context.ts";
+import { type ArgumentValues } from "../../../api/argument/ArgumentValueTypes.ts";
+export declare class CompletionCompleteSubCommand implements SubCommand {
+    readonly name = "complete";
+    readonly description = "Generate completions for shell integration";
+    readonly enableConfiguration = false;
+    readonly disableGenericHelpDisplay = true;
+    readonly options: ReadonlyArray<Option>;
+    readonly positionals: ReadonlyArray<Positional>;
+    execute(context: Context, argumentValues: ArgumentValues): Promise<void>;
+}
+//# sourceMappingURL=CompletionCompleteSubCommand.d.ts.map

package/dist/src/service/completion/command/CompletionCompleteSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionCompleteSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/completion/command/CompletionCompleteSubCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,oCAAoC,CAAC;AACjE,OAAO,KAAK,MAAM,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,UAAU,MAAM,qCAAqC,CAAC;AAClE,OAAO,KAAK,OAAO,MAAM,yBAAyB,CAAC;AACnD,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,6CAA6C,CAAC;AAMrD,qBAAa,4BAA6B,YAAW,UAAU;IAC7D,QAAQ,CAAC,IAAI,cAAc;IAC3B,QAAQ,CAAC,WAAW,gDAAgD;IACpE,QAAQ,CAAC,mBAAmB,SAAS;IACrC,QAAQ,CAAC,yBAAyB,QAAQ;IAE1C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAM;IAE7C,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAc7C;IAEI,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAqB/E"}

package/dist/src/service/completion/command/CompletionCompleteSubCommand.js

@@ -0,0 +1,37 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+import { COMPLETION_SERVICE_ID, ShellType } from "../../../api/service/core/CompletionService.js";
+import { PRINTER_SERVICE_ID } from "../../../api/service/core/PrinterService.js";
+export class CompletionCompleteSubCommand {
+    name = "complete";
+    description = "Generate completions for shell integration";
+    enableConfiguration = false;
+    disableGenericHelpDisplay = true;
+    options = [];
+    positionals = [
+        {
+            name: "shell",
+            type: ArgumentValueTypeName.STRING,
+            allowableValues: Object.values(ShellType),
+            description: "Shell type",
+        },
+        {
+            name: "args",
+            type: ArgumentValueTypeName.STRING,
+            isVarargMultiple: true,
+            isVarargOptional: true,
+            description: "Shell-specific completion context arguments",
+        },
+    ];
+    async execute(context, argumentValues) {
+        const completionService = context.getServiceById(COMPLETION_SERVICE_ID);
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        const shellType = argumentValues.shell;
+        const args = (argumentValues.args || []);
+        const completionContext = completionService.parseCompletionContext(shellType, args);
+        const completions = await completionService.generateCompletions(shellType, completionContext.line, completionContext.cursorPosition);
+        const output = completionService.formatCompletions(shellType, completions);
+        if (output.length > 0) {
+            await printerService.print(output + "\n");
+        }
+    }
+}

package/dist/src/service/completion/command/CompletionGroupCommand.d.ts

@@ -0,0 +1,14 @@
+import type GroupCommand from "../../../api/command/GroupCommand.ts";
+import type SubCommand from "../../../api/command/SubCommand.ts";
+import type Context from "../../../api/Context.ts";
+import type { CompletionIntegrationSubCommand } from "./CompletionIntegrationSubCommand.ts";
+import type { CompletionCompleteSubCommand } from "./CompletionCompleteSubCommand.ts";
+export declare class CompletionGroupCommand implements GroupCommand {
+    readonly name = "completion";
+    readonly description = "Manage shell auto-completion";
+    readonly enableConfiguration = false;
+    readonly memberSubCommands: ReadonlyArray<SubCommand>;
+    constructor(integrationCommand: CompletionIntegrationSubCommand, completeCommand: CompletionCompleteSubCommand);
+    execute(_context: Context): Promise<void>;
+}
+//# sourceMappingURL=CompletionGroupCommand.d.ts.map

package/dist/src/service/completion/command/CompletionGroupCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionGroupCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/completion/command/CompletionGroupCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,sCAAsC,CAAC;AACrE,OAAO,KAAK,UAAU,MAAM,oCAAoC,CAAC;AACjE,OAAO,KAAK,OAAO,MAAM,yBAAyB,CAAC;AACnD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AAC5F,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAEtF,qBAAa,sBAAuB,YAAW,YAAY;IACzD,QAAQ,CAAC,IAAI,gBAAgB;IAC7B,QAAQ,CAAC,WAAW,kCAAkC;IACtD,QAAQ,CAAC,mBAAmB,SAAS;IACrC,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;gBAGpD,kBAAkB,EAAE,+BAA+B,EACnD,eAAe,EAAE,4BAA4B;IAKzC,OAAO,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAChD"}

package/dist/src/service/completion/command/CompletionGroupCommand.js

@@ -0,0 +1,10 @@
+export class CompletionGroupCommand {
+    name = "completion";
+    description = "Manage shell auto-completion";
+    enableConfiguration = false;
+    memberSubCommands;
+    constructor(integrationCommand, completeCommand) {
+        this.memberSubCommands = [integrationCommand, completeCommand];
+    }
+    async execute(_context) { }
+}

package/dist/src/service/completion/command/CompletionIntegrationSubCommand.d.ts

@@ -0,0 +1,14 @@
+import type SubCommand from "../../../api/command/SubCommand.ts";
+import type Option from "../../../api/argument/Option.ts";
+import type Positional from "../../../api/argument/Positional.ts";
+import type Context from "../../../api/Context.ts";
+import { type ArgumentValues } from "../../../api/argument/ArgumentValueTypes.ts";
+export declare class CompletionIntegrationSubCommand implements SubCommand {
+    readonly name = "integration";
+    readonly description = "Install shell completion integration";
+    readonly enableConfiguration = false;
+    readonly options: ReadonlyArray<Option>;
+    readonly positionals: ReadonlyArray<Positional>;
+    execute(context: Context, argumentValues: ArgumentValues): Promise<void>;
+}
+//# sourceMappingURL=CompletionIntegrationSubCommand.d.ts.map

package/dist/src/service/completion/command/CompletionIntegrationSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompletionIntegrationSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/completion/command/CompletionIntegrationSubCommand.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,UAAU,MAAM,oCAAoC,CAAC;AACjE,OAAO,KAAK,MAAM,MAAM,iCAAiC,CAAC;AAC1D,OAAO,KAAK,UAAU,MAAM,qCAAqC,CAAC;AAClE,OAAO,KAAK,OAAO,MAAM,yBAAyB,CAAC;AACnD,OAAO,EACL,KAAK,cAAc,EAEpB,MAAM,6CAA6C,CAAC;AAMrD,qBAAa,+BAAgC,YAAW,UAAU;IAChE,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,QAAQ,CAAC,WAAW,0CAA0C;IAC9D,QAAQ,CAAC,mBAAmB,SAAS;IAErC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAOrC;IAEF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAO7C;IAEI,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CA4D/E"}

package/dist/src/service/completion/command/CompletionIntegrationSubCommand.js

@@ -0,0 +1,67 @@
+import process from "node:process";
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+import { COMPLETION_SERVICE_ID, ShellType } from "../../../api/service/core/CompletionService.js";
+import { Icon, PRINTER_SERVICE_ID } from "../../../api/service/core/PrinterService.js";
+export class CompletionIntegrationSubCommand {
+    name = "integration";
+    description = "Install shell completion integration";
+    enableConfiguration = false;
+    options = [
+        {
+            name: "config-path",
+            type: ArgumentValueTypeName.STRING,
+            isOptional: true,
+            description: "Path to shell configuration file",
+        },
+    ];
+    positionals = [
+        {
+            name: "shell",
+            type: ArgumentValueTypeName.STRING,
+            allowableValues: Object.values(ShellType),
+            description: "Shell type to configure",
+        },
+    ];
+    async execute(context, argumentValues) {
+        const completionService = context.getServiceById(COMPLETION_SERVICE_ID);
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        const shellType = argumentValues.shell;
+        const configPathArg = argumentValues["config-path"];
+        const isValid = await completionService.validateShellEnvironment(shellType);
+        if (!isValid) {
+            await printerService.warn(`Shell '${shellType}' was not detected in the current environment. Proceeding anyway.\n`, Icon.ALERT);
+        }
+        const configPath = configPathArg || completionService.getDefaultConfigPath(shellType);
+        const cliName = context.cliConfig.name;
+        const bootstrapScript = completionService.getBootstrapScript(shellType, cliName, process.execPath);
+        const beginMarker = `# BEGIN ${cliName} completion`;
+        const endMarker = `# END ${cliName} completion`;
+        const block = `${beginMarker}\n${bootstrapScript}\n${endMarker}`;
+        let existingContent = "";
+        try {
+            existingContent = await Bun.file(configPath).text();
+        }
+        catch {
+            // File doesn't exist yet
+        }
+        let newContent;
+        const beginIdx = existingContent.indexOf(beginMarker);
+        const endIdx = existingContent.indexOf(endMarker);
+        if (beginIdx !== -1 && endIdx !== -1) {
+            newContent =
+                existingContent.substring(0, beginIdx) +
+                    block +
+                    existingContent.substring(endIdx + endMarker.length);
+        }
+        else {
+            const separator = existingContent.length > 0 && !existingContent.endsWith("\n")
+                ? "\n\n"
+                : existingContent.length > 0
+                    ? "\n"
+                    : "";
+            newContent = existingContent + separator + block + "\n";
+        }
+        await Bun.write(configPath, newContent);
+        await printerService.info(`Shell completion installed for ${shellType}. Restart your shell or run 'source ${configPath}' to activate.\n`);
+    }
+}

package/dist/src/service/completion/shell/bash.js

@@ -0,0 +1,39 @@
+import process from "node:process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Reference: https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion.html
+export default class BashShellHandler {
+    getDefaultConfigPath() {
+        return join(homedir(), ".bashrc");
+    }
+    getBootstrapScript(cliName, executablePath) {
+        return [
+            `_${cliName}_completions() {`,
+            `  local IFS=$'\\n'`,
+            `  COMPREPLY=( $("${executablePath}" completion:complete bash "\${COMP_LINE}" "\${COMP_POINT}" 2>/dev/null) )`,
+            `}`,
+            `complete -F _${cliName}_completions ${cliName}`,
+        ].join("\n");
+    }
+    validateEnvironment() {
+        const shell = process.env.SHELL || "";
+        if (shell.endsWith("/bash")) {
+            return Promise.resolve(true);
+        }
+        try {
+            const result = Bun.spawnSync(["bash", "--version"]);
+            return Promise.resolve(result.exitCode === 0);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    formatCompletions(completions) {
+        return completions.map((c) => c.value).join("\n");
+    }
+    parseCompletionContext(args) {
+        const line = args[0] || "";
+        const cursorPosition = parseInt(args[1] || "0", 10) || line.length;
+        return { line, cursorPosition };
+    }
+}