@fission-ai/openspec 0.18.0 → 0.19.0

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,32 @@
+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";
+    /**
+     * 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

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

@@ -0,0 +1,198 @@
+import { POWERSHELL_DYNAMIC_HELPERS } from '../templates/powershell-templates.js';
+/**
+ * Generates PowerShell completion scripts for the OpenSpec CLI.
+ * Uses Register-ArgumentCompleter for command completion.
+ */
+export class PowerShellGenerator {
+    shell = 'powershell';
+    /**
+     * Generate a PowerShell completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns PowerShell completion script as a string
+     */
+    generate(commands) {
+        // Build top-level commands using push() for loop clarity
+        const commandLines = [];
+        for (const cmd of commands) {
+            commandLines.push(`            @{Name="${cmd.name}"; Description="${this.escapeDescription(cmd.description)}"},`);
+        }
+        const topLevelCommands = commandLines.join('\n');
+        // Build command cases using push() for loop clarity
+        const commandCaseLines = [];
+        for (const cmd of commands) {
+            commandCaseLines.push(`        "${cmd.name}" {`);
+            commandCaseLines.push(...this.generateCommandCase(cmd, '            '));
+            commandCaseLines.push('        }');
+        }
+        const commandCases = commandCaseLines.join('\n');
+        // Dynamic completion helpers from template
+        const helpers = POWERSHELL_DYNAMIC_HELPERS;
+        // Assemble final script with template literal
+        return `# PowerShell completion script for OpenSpec CLI
+# Auto-generated - do not edit manually
+
+${helpers}
+$openspecCompleter = {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $tokens = $commandAst.ToString() -split "\\s+"
+    $commandCount = ($tokens | Measure-Object).Count
+
+    # Top-level commands
+    if ($commandCount -eq 1 -or ($commandCount -eq 2 -and $wordToComplete)) {
+        $commands = @(
+${topLevelCommands}
+        )
+        $commands | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {
+            [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, "ParameterValue", $_.Description)
+        }
+        return
+    }
+
+    $command = $tokens[1]
+
+    switch ($command) {
+${commandCases}
+    }
+}
+
+Register-ArgumentCompleter -CommandName openspec -ScriptBlock $openspecCompleter
+`;
+    }
+    /**
+     * Generate completion case for a command
+     */
+    generateCommandCase(cmd, indent) {
+        const lines = [];
+        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 ($wordToComplete -like "-*") {`);
+                lines.push(`${indent}    $flags = @(`);
+                for (const flag of cmd.flags) {
+                    const longFlag = `--${flag.name}`;
+                    const shortFlag = flag.short ? `-${flag.short}` : undefined;
+                    if (shortFlag) {
+                        lines.push(`${indent}        @{Name="${longFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                        lines.push(`${indent}        @{Name="${shortFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                    }
+                    else {
+                        lines.push(`${indent}        @{Name="${longFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                    }
+                }
+                lines.push(`${indent}    )`);
+                lines.push(`${indent}    $flags | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, "ParameterName", $_.Description)`);
+                lines.push(`${indent}    }`);
+                lines.push(`${indent}    return`);
+                lines.push(`${indent}}`);
+                lines.push('');
+            }
+            // Handle subcommands
+            lines.push(`${indent}if ($commandCount -eq 2 -or ($commandCount -eq 3 -and $wordToComplete)) {`);
+            lines.push(`${indent}    $subcommands = @(`);
+            for (const subcmd of cmd.subcommands) {
+                lines.push(`${indent}        @{Name="${subcmd.name}"; Description="${this.escapeDescription(subcmd.description)}"},`);
+            }
+            lines.push(`${indent}    )`);
+            lines.push(`${indent}    $subcommands | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {`);
+            lines.push(`${indent}        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, "ParameterValue", $_.Description)`);
+            lines.push(`${indent}    }`);
+            lines.push(`${indent}    return`);
+            lines.push(`${indent}}`);
+            lines.push('');
+            lines.push(`${indent}$subcommand = if ($commandCount -gt 2) { $tokens[2] } else { "" }`);
+            lines.push(`${indent}switch ($subcommand) {`);
+            for (const subcmd of cmd.subcommands) {
+                lines.push(`${indent}    "${subcmd.name}" {`);
+                lines.push(...this.generateArgumentCompletion(subcmd, indent + '        '));
+                lines.push(`${indent}    }`);
+            }
+            lines.push(`${indent}}`);
+        }
+        else {
+            // No subcommands
+            lines.push(...this.generateArgumentCompletion(cmd, indent));
+        }
+        return lines;
+    }
+    /**
+     * Generate argument completion (flags and positional)
+     */
+    generateArgumentCompletion(cmd, indent) {
+        const lines = [];
+        // Flag completion
+        if (cmd.flags.length > 0) {
+            lines.push(`${indent}if ($wordToComplete -like "-*") {`);
+            lines.push(`${indent}    $flags = @(`);
+            for (const flag of cmd.flags) {
+                const longFlag = `--${flag.name}`;
+                const shortFlag = flag.short ? `-${flag.short}` : undefined;
+                if (shortFlag) {
+                    lines.push(`${indent}        @{Name="${longFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                    lines.push(`${indent}        @{Name="${shortFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                }
+                else {
+                    lines.push(`${indent}        @{Name="${longFlag}"; Description="${this.escapeDescription(flag.description)}"},`);
+                }
+            }
+            lines.push(`${indent}    )`);
+            lines.push(`${indent}    $flags | Where-Object { $_.Name -like "$wordToComplete*" } | ForEach-Object {`);
+            lines.push(`${indent}        [System.Management.Automation.CompletionResult]::new($_.Name, $_.Name, "ParameterName", $_.Description)`);
+            lines.push(`${indent}    }`);
+            lines.push(`${indent}    return`);
+            lines.push(`${indent}}`);
+            lines.push('');
+        }
+        // Positional completion
+        if (cmd.acceptsPositional) {
+            lines.push(...this.generatePositionalCompletion(cmd.positionalType, indent));
+        }
+        return lines;
+    }
+    /**
+     * Generate positional argument completion
+     */
+    generatePositionalCompletion(positionalType, indent) {
+        const lines = [];
+        switch (positionalType) {
+            case 'change-id':
+                lines.push(`${indent}Get-OpenSpecChanges | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", "Change: $_")`);
+                lines.push(`${indent}}`);
+                break;
+            case 'spec-id':
+                lines.push(`${indent}Get-OpenSpecSpecs | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", "Spec: $_")`);
+                lines.push(`${indent}}`);
+                break;
+            case 'change-or-spec-id':
+                lines.push(`${indent}$items = @(Get-OpenSpecChanges) + @(Get-OpenSpecSpecs)`);
+                lines.push(`${indent}$items | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_)`);
+                lines.push(`${indent}}`);
+                break;
+            case 'shell':
+                lines.push(`${indent}$shells = @("zsh", "bash", "fish", "powershell")`);
+                lines.push(`${indent}$shells | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", "Shell: $_")`);
+                lines.push(`${indent}}`);
+                break;
+            case 'path':
+                // PowerShell handles file path completion automatically
+                break;
+        }
+        return lines;
+    }
+    /**
+     * Escape description text for PowerShell
+     */
+    escapeDescription(description) {
+        return description
+            .replace(/`/g, '``') // Backticks (escape sequences)
+            .replace(/\$/g, '`$') // Dollar signs (prevents $())
+            .replace(/"/g, '""'); // Double quotes
+    }
+}
+//# sourceMappingURL=powershell-generator.js.map

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

@@ -12,20 +12,6 @@ export declare class ZshGenerator implements CompletionGenerator {
      * @returns Zsh completion script as a string
      */
     generate(commands: CommandDefinition[]): string;
-    /**
-     * Generate a single completion function
-     *
-     * @param functionName - Name of the completion function
-     * @param varName - Name of the local array variable
-     * @param varLabel - Label for the completion items
-     * @param commandLines - Command line(s) to populate the array
-     * @param comment - Optional comment describing the function
-     */
-    private generateCompletionFunction;
-    /**
-     * Generate dynamic completion helper functions for change and spec IDs
-     */
-    private generateDynamicCompletionHelpers;
     /**
      * Generate completion function for a specific command
      */

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

@@ -1,3 +1,4 @@
+import { ZSH_DYNAMIC_HELPERS } from '../templates/zsh-templates.js';
 /**
  * Generates Zsh completion scripts for the OpenSpec CLI.
  * Follows Zsh completion system conventions using the _openspec function.
@@ -11,135 +12,65 @@ export class ZshGenerator {
      * @returns Zsh completion script as a string
      */
     generate(commands) {
-        const script = [];
-        // Header comment
-        script.push('#compdef openspec');
-        script.push('');
-        script.push('# Zsh completion script for OpenSpec CLI');
-        script.push('# Auto-generated - do not edit manually');
-        script.push('');
-        // Main completion function
-        script.push('_openspec() {');
-        script.push('  local context state line');
-        script.push('  typeset -A opt_args');
-        script.push('');
-        // Generate main command argument specification
-        script.push('  local -a commands');
-        script.push('  commands=(');
+        // Build command list using push() for loop clarity
+        const commandLines = [];
         for (const cmd of commands) {
             const escapedDesc = this.escapeDescription(cmd.description);
-            script.push(`    '${cmd.name}:${escapedDesc}'`);
+            commandLines.push(`    '${cmd.name}:${escapedDesc}'`);
         }
-        script.push('  )');
-        script.push('');
-        // Main _arguments call
-        script.push('  _arguments -C \\');
-        script.push('    "1: :->command" \\');
-        script.push('    "*::arg:->args"');
-        script.push('');
-        // Command dispatch logic
-        script.push('  case $state in');
-        script.push('    command)');
-        script.push('      _describe "openspec command" commands');
-        script.push('      ;;');
-        script.push('    args)');
-        script.push('      case $words[1] in');
-        // Generate completion for each command
+        const commandList = commandLines.join('\n');
+        // Build command cases using push() for loop clarity
+        const commandCaseLines = [];
         for (const cmd of commands) {
-            script.push(`        ${cmd.name})`);
-            script.push(`          _openspec_${this.sanitizeFunctionName(cmd.name)}`);
-            script.push('          ;;');
+            commandCaseLines.push(`        ${cmd.name})`);
+            commandCaseLines.push(`          _openspec_${this.sanitizeFunctionName(cmd.name)}`);
+            commandCaseLines.push('          ;;');
         }
-        script.push('      esac');
-        script.push('      ;;');
-        script.push('  esac');
-        script.push('}');
-        script.push('');
-        // Generate individual command completion functions
+        const commandCases = commandCaseLines.join('\n');
+        // Build command functions using push() for loop clarity
+        const commandFunctionLines = [];
         for (const cmd of commands) {
-            script.push(...this.generateCommandFunction(cmd));
-            script.push('');
-        }
-        // Add dynamic completion helper functions
-        script.push(...this.generateDynamicCompletionHelpers());
-        // Register the completion function
-        script.push('compdef _openspec openspec');
-        script.push('');
-        return script.join('\n');
-    }
-    /**
-     * Generate a single completion function
-     *
-     * @param functionName - Name of the completion function
-     * @param varName - Name of the local array variable
-     * @param varLabel - Label for the completion items
-     * @param commandLines - Command line(s) to populate the array
-     * @param comment - Optional comment describing the function
-     */
-    generateCompletionFunction(functionName, varName, varLabel, commandLines, comment) {
-        const lines = [];
-        if (comment) {
-            lines.push(comment);
-        }
-        lines.push(`${functionName}() {`);
-        lines.push(`  local -a ${varName}`);
-        if (commandLines.length === 1) {
-            lines.push(`  ${commandLines[0]}`);
-        }
-        else {
-            lines.push(`  ${varName}=(`);
-            for (let i = 0; i < commandLines.length; i++) {
-                const suffix = i < commandLines.length - 1 ? ' \\' : '';
-                lines.push(`    ${commandLines[i]}${suffix}`);
-            }
-            lines.push('  )');
-        }
-        lines.push(`  _describe "${varLabel}" ${varName}`);
-        lines.push('}');
-        lines.push('');
-        return lines;
-    }
-    /**
-     * Generate dynamic completion helper functions for change and spec IDs
-     */
-    generateDynamicCompletionHelpers() {
-        const lines = [];
-        lines.push('# Dynamic completion helpers');
-        lines.push('');
-        // Helper function for completing change IDs
-        lines.push('# Use openspec __complete to get available changes');
-        lines.push('_openspec_complete_changes() {');
-        lines.push('  local -a changes');
-        lines.push('  while IFS=$\'\\t\' read -r id desc; do');
-        lines.push('    changes+=("$id:$desc")');
-        lines.push('  done < <(openspec __complete changes 2>/dev/null)');
-        lines.push('  _describe "change" changes');
-        lines.push('}');
-        lines.push('');
-        // Helper function for completing spec IDs
-        lines.push('# Use openspec __complete to get available specs');
-        lines.push('_openspec_complete_specs() {');
-        lines.push('  local -a specs');
-        lines.push('  while IFS=$\'\\t\' read -r id desc; do');
-        lines.push('    specs+=("$id:$desc")');
-        lines.push('  done < <(openspec __complete specs 2>/dev/null)');
-        lines.push('  _describe "spec" specs');
-        lines.push('}');
-        lines.push('');
-        // Helper function for completing both changes and specs
-        lines.push('# Get both changes and specs');
-        lines.push('_openspec_complete_items() {');
-        lines.push('  local -a items');
-        lines.push('  while IFS=$\'\\t\' read -r id desc; do');
-        lines.push('    items+=("$id:$desc")');
-        lines.push('  done < <(openspec __complete changes 2>/dev/null)');
-        lines.push('  while IFS=$\'\\t\' read -r id desc; do');
-        lines.push('    items+=("$id:$desc")');
-        lines.push('  done < <(openspec __complete specs 2>/dev/null)');
-        lines.push('  _describe "item" items');
-        lines.push('}');
-        lines.push('');
-        return lines;
+            commandFunctionLines.push(...this.generateCommandFunction(cmd));
+            commandFunctionLines.push('');
+        }
+        const commandFunctions = commandFunctionLines.join('\n');
+        // Dynamic completion helpers from template
+        const helpers = ZSH_DYNAMIC_HELPERS;
+        // Assemble final script with template literal
+        return `#compdef openspec
+
+# Zsh completion script for OpenSpec CLI
+# Auto-generated - do not edit manually
+
+_openspec() {
+  local context state line
+  typeset -A opt_args
+
+  local -a commands
+  commands=(
+${commandList}
+  )
+
+  _arguments -C \\
+    "1: :->command" \\
+    "*::arg:->args"
+
+  case $state in
+    command)
+      _describe "openspec command" commands
+      ;;
+    args)
+      case $words[1] in
+${commandCases}
+      esac
+      ;;
+  esac
+}
+
+${commandFunctions}
+${helpers}
+compdef _openspec openspec
+`;
     }
     /**
      * Generate completion function for a specific command
@@ -284,7 +215,7 @@ export class ZshGenerator {
             case 'path':
                 return "'*:path:_files'";
             case 'shell':
-                return "'*:shell:(zsh)'";
+                return "'*:shell:(zsh bash fish powershell)'";
             default:
                 return "'*: :_default'";
         }