openspec-cn 0.23.0

package/dist/core/completions/factory.js

@@ -0,0 +1,75 @@
+import { ZshGenerator } from './generators/zsh-generator.js';
+import { BashGenerator } from './generators/bash-generator.js';
+import { FishGenerator } from './generators/fish-generator.js';
+import { PowerShellGenerator } from './generators/powershell-generator.js';
+import { ZshInstaller } from './installers/zsh-installer.js';
+import { BashInstaller } from './installers/bash-installer.js';
+import { FishInstaller } from './installers/fish-installer.js';
+import { PowerShellInstaller } from './installers/powershell-installer.js';
+/**
+ * Factory for creating completion generators and installers
+ * This design makes it easy to add support for additional shells
+ */
+export class CompletionFactory {
+    static SUPPORTED_SHELLS = ['zsh', 'bash', 'fish', 'powershell'];
+    /**
+     * Create a completion generator for the specified shell
+     *
+     * @param shell - The target shell
+     * @returns CompletionGenerator instance
+     * @throws Error if shell is not supported
+     */
+    static createGenerator(shell) {
+        switch (shell) {
+            case 'zsh':
+                return new ZshGenerator();
+            case 'bash':
+                return new BashGenerator();
+            case 'fish':
+                return new FishGenerator();
+            case 'powershell':
+                return new PowerShellGenerator();
+            default:
+                throw new Error(`Unsupported shell: ${shell}`);
+        }
+    }
+    /**
+     * Create a completion installer for the specified shell
+     *
+     * @param shell - The target shell
+     * @returns CompletionInstaller instance
+     * @throws Error if shell is not supported
+     */
+    static createInstaller(shell) {
+        switch (shell) {
+            case 'zsh':
+                return new ZshInstaller();
+            case 'bash':
+                return new BashInstaller();
+            case 'fish':
+                return new FishInstaller();
+            case 'powershell':
+                return new PowerShellInstaller();
+            default:
+                throw new Error(`Unsupported shell: ${shell}`);
+        }
+    }
+    /**
+     * Check if a shell is supported
+     *
+     * @param shell - The shell to check
+     * @returns true if the shell is supported
+     */
+    static isSupported(shell) {
+        return this.SUPPORTED_SHELLS.includes(shell);
+    }
+    /**
+     * Get list of all supported shells
+     *
+     * @returns Array of supported shell names
+     */
+    static getSupportedShells() {
+        return [...this.SUPPORTED_SHELLS];
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/core/completions/generators/bash-generator.d.ts

@@ -0,0 +1,32 @@
+import { CompletionGenerator, CommandDefinition } from '../types.js';
+/**
+ * Generates Bash completion scripts for the OpenSpec CLI.
+ * Follows Bash completion conventions using complete builtin and COMPREPLY array.
+ */
+export declare class BashGenerator implements CompletionGenerator {
+    readonly shell: "bash";
+    /**
+     * Generate a Bash completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns Bash completion script as a string
+     */
+    generate(commands: CommandDefinition[]): string;
+    /**
+     * Generate completion case logic for a command
+     */
+    private generateCommandCase;
+    /**
+     * Generate argument completion (flags and positional arguments)
+     */
+    private generateArgumentCompletion;
+    /**
+     * Generate positional argument completion based on type
+     */
+    private generatePositionalCompletion;
+    /**
+     * Escape command/subcommand names for safe use in Bash scripts
+     */
+    private escapeCommandName;
+}
+//# sourceMappingURL=bash-generator.d.ts.map

package/dist/core/completions/generators/bash-generator.js

@@ -0,0 +1,174 @@
+import { BASH_DYNAMIC_HELPERS } from '../templates/bash-templates.js';
+/**
+ * Generates Bash completion scripts for the OpenSpec CLI.
+ * Follows Bash completion conventions using complete builtin and COMPREPLY array.
+ */
+export class BashGenerator {
+    shell = 'bash';
+    /**
+     * Generate a Bash completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns Bash completion script as a string
+     */
+    generate(commands) {
+        // Build command list for top-level completions
+        const commandList = commands.map(c => this.escapeCommandName(c.name)).join(' ');
+        // Build command cases using push() for loop clarity
+        const caseLines = [];
+        for (const cmd of commands) {
+            caseLines.push(`    ${cmd.name})`);
+            caseLines.push(...this.generateCommandCase(cmd, '      '));
+            caseLines.push('      ;;');
+        }
+        const commandCases = caseLines.join('\n');
+        // Dynamic completion helpers from template
+        const helpers = BASH_DYNAMIC_HELPERS;
+        // Assemble final script with template literal
+        return `# Bash completion script for OpenSpec CLI
+# Auto-generated - do not edit manually
+
+_openspec_completion() {
+  local cur prev words cword
+
+  # Use _init_completion if available (from bash-completion package)
+  # The -n : option prevents colons from being treated as word separators
+  # (important for spec/change IDs that may contain colons)
+  # Otherwise, fall back to manual initialization
+  if declare -F _init_completion >/dev/null 2>&1; then
+    _init_completion -n : || return
+  else
+    # Manual fallback when bash-completion is not installed
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    words=("\${COMP_WORDS[@]}")
+    cword=$COMP_CWORD
+  fi
+
+  local cmd="\${words[1]}"
+  local subcmd="\${words[2]}"
+
+  # Top-level commands
+  if [[ $cword -eq 1 ]]; then
+    local commands="${commandList}"
+    COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+    return 0
+  fi
+
+  # Command-specific completion
+  case "$cmd" in
+${commandCases}
+  esac
+
+  return 0
+}
+
+${helpers}
+complete -F _openspec_completion openspec
+`;
+    }
+    /**
+     * Generate completion case logic for a command
+     */
+    generateCommandCase(cmd, indent) {
+        const lines = [];
+        // Handle subcommands
+        if (cmd.subcommands && cmd.subcommands.length > 0) {
+            // First, check if user is typing a flag for the parent command
+            if (cmd.flags.length > 0) {
+                lines.push(`${indent}if [[ "$cur" == -* ]]; then`);
+                const flags = cmd.flags.map(f => {
+                    const parts = [];
+                    if (f.short)
+                        parts.push(`-${f.short}`);
+                    parts.push(`--${f.name}`);
+                    return parts.join(' ');
+                }).join(' ');
+                lines.push(`${indent}  local flags="${flags}"`);
+                lines.push(`${indent}  COMPREPLY=($(compgen -W "$flags" -- "$cur"))`);
+                lines.push(`${indent}  return 0`);
+                lines.push(`${indent}fi`);
+                lines.push('');
+            }
+            lines.push(`${indent}if [[ $cword -eq 2 ]]; then`);
+            lines.push(`${indent}  local subcommands="` + cmd.subcommands.map(s => this.escapeCommandName(s.name)).join(' ') + '"');
+            lines.push(`${indent}  COMPREPLY=($(compgen -W "$subcommands" -- "$cur"))`);
+            lines.push(`${indent}  return 0`);
+            lines.push(`${indent}fi`);
+            lines.push('');
+            lines.push(`${indent}case "$subcmd" in`);
+            for (const subcmd of cmd.subcommands) {
+                lines.push(`${indent}  ${subcmd.name})`);
+                lines.push(...this.generateArgumentCompletion(subcmd, indent + '    '));
+                lines.push(`${indent}    ;;`);
+            }
+            lines.push(`${indent}esac`);
+        }
+        else {
+            // No subcommands, just complete arguments
+            lines.push(...this.generateArgumentCompletion(cmd, indent));
+        }
+        return lines;
+    }
+    /**
+     * Generate argument completion (flags and positional arguments)
+     */
+    generateArgumentCompletion(cmd, indent) {
+        const lines = [];
+        // Check for flag completion
+        if (cmd.flags.length > 0) {
+            lines.push(`${indent}if [[ "$cur" == -* ]]; then`);
+            const flags = cmd.flags.map(f => {
+                const parts = [];
+                if (f.short)
+                    parts.push(`-${f.short}`);
+                parts.push(`--${f.name}`);
+                return parts.join(' ');
+            }).join(' ');
+            lines.push(`${indent}  local flags="${flags}"`);
+            lines.push(`${indent}  COMPREPLY=($(compgen -W "$flags" -- "$cur"))`);
+            lines.push(`${indent}  return 0`);
+            lines.push(`${indent}fi`);
+            lines.push('');
+        }
+        // Handle positional completions
+        if (cmd.acceptsPositional) {
+            lines.push(...this.generatePositionalCompletion(cmd.positionalType, indent));
+        }
+        return lines;
+    }
+    /**
+     * Generate positional argument completion based on type
+     */
+    generatePositionalCompletion(positionalType, indent) {
+        const lines = [];
+        switch (positionalType) {
+            case 'change-id':
+                lines.push(`${indent}_openspec_complete_changes`);
+                break;
+            case 'spec-id':
+                lines.push(`${indent}_openspec_complete_specs`);
+                break;
+            case 'change-or-spec-id':
+                lines.push(`${indent}_openspec_complete_items`);
+                break;
+            case 'shell':
+                lines.push(`${indent}local shells="zsh bash fish powershell"`);
+                lines.push(`${indent}COMPREPLY=($(compgen -W "$shells" -- "$cur"))`);
+                break;
+            case 'path':
+                lines.push(`${indent}COMPREPLY=($(compgen -f -- "$cur"))`);
+                break;
+        }
+        return lines;
+    }
+    /**
+     * Escape command/subcommand names for safe use in Bash scripts
+     */
+    escapeCommandName(name) {
+        // Escape shell metacharacters to prevent command injection
+        return name.replace(/["\$`\\]/g, '\\$&');
+    }
+}
+//# sourceMappingURL=bash-generator.js.map

package/dist/core/completions/generators/fish-generator.d.ts

@@ -0,0 +1,32 @@
+import { CompletionGenerator, CommandDefinition } from '../types.js';
+/**
+ * Generates Fish completion scripts for the OpenSpec CLI.
+ * Follows Fish completion conventions using the complete command.
+ */
+export declare class FishGenerator implements CompletionGenerator {
+    readonly shell: "fish";
+    /**
+     * Generate a Fish completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns Fish completion script as a string
+     */
+    generate(commands: CommandDefinition[]): string;
+    /**
+     * Generate completions for a specific command
+     */
+    private generateCommandCompletions;
+    /**
+     * Generate flag completion
+     */
+    private generateFlagCompletion;
+    /**
+     * Generate positional argument completion
+     */
+    private generatePositionalCompletion;
+    /**
+     * Escape description text for Fish
+     */
+    private escapeDescription;
+}
+//# sourceMappingURL=fish-generator.d.ts.map

package/dist/core/completions/generators/fish-generator.js

@@ -0,0 +1,157 @@
+import { FISH_STATIC_HELPERS, FISH_DYNAMIC_HELPERS } from '../templates/fish-templates.js';
+/**
+ * Generates Fish completion scripts for the OpenSpec CLI.
+ * Follows Fish completion conventions using the complete command.
+ */
+export class FishGenerator {
+    shell = 'fish';
+    /**
+     * Generate a Fish completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns Fish completion script as a string
+     */
+    generate(commands) {
+        // Build top-level commands using push() for loop clarity
+        const topLevelLines = [];
+        for (const cmd of commands) {
+            topLevelLines.push(`# ${cmd.name} command`);
+            topLevelLines.push(`complete -c openspec -n '__fish_openspec_no_subcommand' -a '${cmd.name}' -d '${this.escapeDescription(cmd.description)}'`);
+        }
+        const topLevelCommands = topLevelLines.join('\n');
+        // Build command-specific completions using push() for loop clarity
+        const commandCompletionLines = [];
+        for (const cmd of commands) {
+            commandCompletionLines.push(...this.generateCommandCompletions(cmd));
+            commandCompletionLines.push('');
+        }
+        const commandCompletions = commandCompletionLines.join('\n');
+        // Static helper functions from template
+        const helperFunctions = FISH_STATIC_HELPERS;
+        // Dynamic completion helpers from template
+        const dynamicHelpers = FISH_DYNAMIC_HELPERS;
+        // Assemble final script with template literal
+        return `# Fish completion script for OpenSpec CLI
+# Auto-generated - do not edit manually
+
+${helperFunctions}
+${dynamicHelpers}
+${topLevelCommands}
+
+${commandCompletions}`;
+    }
+    /**
+     * Generate completions for a specific command
+     */
+    generateCommandCompletions(cmd) {
+        const lines = [];
+        // If command has subcommands
+        if (cmd.subcommands && cmd.subcommands.length > 0) {
+            // Add subcommand completions
+            for (const subcmd of cmd.subcommands) {
+                lines.push(`complete -c openspec -n '__fish_openspec_using_subcommand ${cmd.name}; and not __fish_openspec_using_subcommand ${subcmd.name}' -a '${subcmd.name}' -d '${this.escapeDescription(subcmd.description)}'`);
+            }
+            lines.push('');
+            // Add flags for parent command
+            for (const flag of cmd.flags) {
+                lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}`));
+            }
+            // Add completions for each subcommand
+            for (const subcmd of cmd.subcommands) {
+                lines.push(`# ${cmd.name} ${subcmd.name} flags`);
+                for (const flag of subcmd.flags) {
+                    lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}; and __fish_openspec_using_subcommand ${subcmd.name}`));
+                }
+                // Add positional completions for subcommand
+                if (subcmd.acceptsPositional) {
+                    lines.push(...this.generatePositionalCompletion(subcmd.positionalType, `__fish_openspec_using_subcommand ${cmd.name}; and __fish_openspec_using_subcommand ${subcmd.name}`));
+                }
+            }
+        }
+        else {
+            // Command without subcommands
+            lines.push(`# ${cmd.name} flags`);
+            for (const flag of cmd.flags) {
+                lines.push(...this.generateFlagCompletion(flag, `__fish_openspec_using_subcommand ${cmd.name}`));
+            }
+            // Add positional completions
+            if (cmd.acceptsPositional) {
+                lines.push(...this.generatePositionalCompletion(cmd.positionalType, `__fish_openspec_using_subcommand ${cmd.name}`));
+            }
+        }
+        return lines;
+    }
+    /**
+     * Generate flag completion
+     */
+    generateFlagCompletion(flag, condition) {
+        const lines = [];
+        const longFlag = `--${flag.name}`;
+        const shortFlag = flag.short ? `-${flag.short}` : undefined;
+        if (flag.takesValue && flag.values) {
+            // Flag with enum values
+            for (const value of flag.values) {
+                if (shortFlag) {
+                    lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -a '${value}' -d '${this.escapeDescription(flag.description)}'`);
+                }
+                else {
+                    lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -a '${value}' -d '${this.escapeDescription(flag.description)}'`);
+                }
+            }
+        }
+        else if (flag.takesValue) {
+            // Flag that takes a value but no specific values defined
+            if (shortFlag) {
+                lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
+            }
+            else {
+                lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
+            }
+        }
+        else {
+            // Boolean flag
+            if (shortFlag) {
+                lines.push(`complete -c openspec -n '${condition}' -s ${flag.short} -l ${flag.name} -d '${this.escapeDescription(flag.description)}'`);
+            }
+            else {
+                lines.push(`complete -c openspec -n '${condition}' -l ${flag.name} -d '${this.escapeDescription(flag.description)}'`);
+            }
+        }
+        return lines;
+    }
+    /**
+     * Generate positional argument completion
+     */
+    generatePositionalCompletion(positionalType, condition) {
+        const lines = [];
+        switch (positionalType) {
+            case 'change-id':
+                lines.push(`complete -c openspec -n '${condition}' -a '(__fish_openspec_changes)' -f`);
+                break;
+            case 'spec-id':
+                lines.push(`complete -c openspec -n '${condition}' -a '(__fish_openspec_specs)' -f`);
+                break;
+            case 'change-or-spec-id':
+                lines.push(`complete -c openspec -n '${condition}' -a '(__fish_openspec_items)' -f`);
+                break;
+            case 'shell':
+                lines.push(`complete -c openspec -n '${condition}' -a 'zsh bash fish powershell' -f`);
+                break;
+            case 'path':
+                // Fish automatically completes files, no need to specify
+                break;
+        }
+        return lines;
+    }
+    /**
+     * Escape description text for Fish
+     */
+    escapeDescription(description) {
+        return description
+            .replace(/\\/g, '\\\\') // Backslashes first
+            .replace(/'/g, "\\'") // Single quotes
+            .replace(/\$/g, '\\$') // Dollar signs (prevents $())
+            .replace(/`/g, '\\`'); // Backticks
+    }
+}
+//# sourceMappingURL=fish-generator.js.map

package/dist/core/completions/generators/powershell-generator.d.ts

@@ -0,0 +1,33 @@
+import { CompletionGenerator, CommandDefinition } from '../types.js';
+/**
+ * Generates PowerShell completion scripts for the OpenSpec CLI.
+ * Uses Register-ArgumentCompleter for command completion.
+ */
+export declare class PowerShellGenerator implements CompletionGenerator {
+    readonly shell: "powershell";
+    private stripTrailingCommaFromLastLine;
+    /**
+     * Generate a PowerShell completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns PowerShell completion script as a string
+     */
+    generate(commands: CommandDefinition[]): string;
+    /**
+     * Generate completion case for a command
+     */
+    private generateCommandCase;
+    /**
+     * Generate argument completion (flags and positional)
+     */
+    private generateArgumentCompletion;
+    /**
+     * Generate positional argument completion
+     */
+    private generatePositionalCompletion;
+    /**
+     * Escape description text for PowerShell
+     */
+    private escapeDescription;
+}
+//# sourceMappingURL=powershell-generator.d.ts.map