@fission-ai/openspec 0.17.2 → 0.19.0

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'";
         }

package/dist/core/completions/installers/bash-installer.d.ts

@@ -0,0 +1,87 @@
+import { InstallationResult } from '../factory.js';
+/**
+ * Installer for Bash completion scripts.
+ * Supports bash-completion package and standalone installations.
+ */
+export declare class BashInstaller {
+    private readonly homeDir;
+    /**
+     * Markers for .bashrc configuration management
+     */
+    private readonly BASHRC_MARKERS;
+    constructor(homeDir?: string);
+    /**
+     * Check if bash-completion is installed
+     *
+     * @returns true if bash-completion directories exist
+     */
+    isBashCompletionInstalled(): Promise<boolean>;
+    /**
+     * Get the appropriate installation path for the completion script
+     *
+     * @returns Installation path
+     */
+    getInstallationPath(): Promise<string>;
+    /**
+     * Backup an existing completion file if it exists
+     *
+     * @param targetPath - Path to the file to backup
+     * @returns Path to the backup file, or undefined if no backup was needed
+     */
+    backupExistingFile(targetPath: string): Promise<string | undefined>;
+    /**
+     * Get the path to .bashrc file
+     *
+     * @returns Path to .bashrc
+     */
+    private getBashrcPath;
+    /**
+     * Generate .bashrc configuration content
+     *
+     * @param completionsDir - Directory containing completion scripts
+     * @returns Configuration content
+     */
+    private generateBashrcConfig;
+    /**
+     * Configure .bashrc to enable completions
+     *
+     * @param completionsDir - Directory containing completion scripts
+     * @returns true if configured successfully, false otherwise
+     */
+    configureBashrc(completionsDir: string): Promise<boolean>;
+    /**
+     * Remove .bashrc configuration
+     * Used during uninstallation
+     *
+     * @returns true if removed successfully, false otherwise
+     */
+    removeBashrcConfig(): Promise<boolean>;
+    /**
+     * Install the completion script
+     *
+     * @param completionScript - The completion script content to install
+     * @returns Installation result with status and instructions
+     */
+    install(completionScript: string): Promise<InstallationResult>;
+    /**
+     * Generate user instructions for enabling completions
+     *
+     * @param installedPath - Path where the script was installed
+     * @returns Array of instruction strings
+     */
+    private generateInstructions;
+    /**
+     * Uninstall the completion script
+     *
+     * @param options - Optional uninstall options
+     * @param options.yes - Skip confirmation prompt (handled by command layer)
+     * @returns Uninstallation result
+     */
+    uninstall(options?: {
+        yes?: boolean;
+    }): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=bash-installer.d.ts.map