@fission-ai/openspec 0.17.2 → 0.19.0

package/dist/core/artifact-graph/state.js

@@ -0,0 +1,54 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import fg from 'fast-glob';
+import { FileSystemUtils } from '../../utils/file-system.js';
+/**
+ * Detects which artifacts are completed by checking file existence in the change directory.
+ * Returns a Set of completed artifact IDs.
+ *
+ * @param graph - The artifact graph to check
+ * @param changeDir - The change directory to scan for files
+ * @returns Set of artifact IDs whose generated files exist
+ */
+export function detectCompleted(graph, changeDir) {
+    const completed = new Set();
+    // Handle missing change directory gracefully
+    if (!fs.existsSync(changeDir)) {
+        return completed;
+    }
+    for (const artifact of graph.getAllArtifacts()) {
+        if (isArtifactComplete(artifact.generates, changeDir)) {
+            completed.add(artifact.id);
+        }
+    }
+    return completed;
+}
+/**
+ * Checks if an artifact is complete by checking if its generated file(s) exist.
+ * Supports both simple paths and glob patterns.
+ */
+function isArtifactComplete(generates, changeDir) {
+    const fullPattern = path.join(changeDir, generates);
+    // Check if it's a glob pattern
+    if (isGlobPattern(generates)) {
+        return hasGlobMatches(fullPattern);
+    }
+    // Simple file path - check if file exists
+    return fs.existsSync(fullPattern);
+}
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+function isGlobPattern(pattern) {
+    return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
+}
+/**
+ * Checks if a glob pattern has any matches.
+ * Normalizes Windows backslashes to forward slashes for cross-platform glob compatibility.
+ */
+function hasGlobMatches(pattern) {
+    const normalizedPattern = FileSystemUtils.toPosixPath(pattern);
+    const matches = fg.sync(normalizedPattern, { onlyFiles: true });
+    return matches.length > 0;
+}
+//# sourceMappingURL=state.js.map

package/dist/core/artifact-graph/types.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const ArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    generates: z.ZodString;
+    description: z.ZodString;
+    template: z.ZodString;
+    instruction: z.ZodOptional<z.ZodString>;
+    requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ApplyPhaseSchema: z.ZodObject<{
+    requires: z.ZodArray<z.ZodString>;
+    tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instruction: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SchemaYamlSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        generates: z.ZodString;
+        description: z.ZodString;
+        template: z.ZodString;
+        instruction: z.ZodOptional<z.ZodString>;
+        requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    apply: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        instruction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Artifact = z.infer<typeof ArtifactSchema>;
+export type ApplyPhase = z.infer<typeof ApplyPhaseSchema>;
+export type SchemaYaml = z.infer<typeof SchemaYamlSchema>;
+export declare const ChangeMetadataSchema: z.ZodObject<{
+    schema: z.ZodString;
+    created: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChangeMetadata = z.infer<typeof ChangeMetadataSchema>;
+export type CompletedSet = Set<string>;
+export interface BlockedArtifacts {
+    [artifactId: string]: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/artifact-graph/types.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+// Artifact definition schema
+export const ArtifactSchema = z.object({
+    id: z.string().min(1, { error: 'Artifact ID is required' }),
+    generates: z.string().min(1, { error: 'generates field is required' }),
+    description: z.string(),
+    template: z.string().min(1, { error: 'template field is required' }),
+    instruction: z.string().optional(),
+    requires: z.array(z.string()).default([]),
+});
+// Apply phase configuration for schema-aware apply instructions
+export const ApplyPhaseSchema = z.object({
+    // Artifact IDs that must exist before apply is available
+    requires: z.array(z.string()).min(1, { error: 'At least one required artifact' }),
+    // Path to file with checkboxes for progress (relative to change dir), or null if no tracking
+    tracks: z.string().nullable().optional(),
+    // Custom guidance for the apply phase
+    instruction: z.string().optional(),
+});
+// Full schema YAML structure
+export const SchemaYamlSchema = z.object({
+    name: z.string().min(1, { error: 'Schema name is required' }),
+    version: z.number().int().positive({ error: 'Version must be a positive integer' }),
+    description: z.string().optional(),
+    artifacts: z.array(ArtifactSchema).min(1, { error: 'At least one artifact required' }),
+    // Optional apply phase configuration (for schema-aware apply instructions)
+    apply: ApplyPhaseSchema.optional(),
+});
+// Per-change metadata schema
+// Note: schema field is validated at parse time against available schemas
+// using a lazy import to avoid circular dependencies
+export const ChangeMetadataSchema = z.object({
+    // Required: which workflow schema this change uses
+    schema: z.string().min(1, { message: 'schema is required' }),
+    // Optional: creation timestamp (ISO date string)
+    created: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, {
+        message: 'created must be YYYY-MM-DD format',
+    })
+        .optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/core/completions/command-registry.js

@@ -281,7 +281,13 @@ export const COMMAND_REGISTRY = [
                 description: 'Uninstall completion script for a shell',
                 acceptsPositional: true,
                 positionalType: 'shell',
-                flags: [],
+                flags: [
+                    {
+                        name: 'yes',
+                        short: 'y',
+                        description: 'Skip confirmation prompts',
+                    },
+                ],
             },
         ],
     },

package/dist/core/completions/factory.d.ts

@@ -1,6 +1,20 @@
 import { CompletionGenerator } from './types.js';
-import { InstallationResult } from './installers/zsh-installer.js';
 import { SupportedShell } from '../../utils/shell-detection.js';
+/**
+ * Common installation result interface
+ */
+export interface InstallationResult {
+    success: boolean;
+    installedPath?: string;
+    backupPath?: string;
+    message: string;
+    instructions?: string[];
+    warnings?: string[];
+    isOhMyZsh?: boolean;
+    zshrcConfigured?: boolean;
+    bashrcConfigured?: boolean;
+    profileConfigured?: boolean;
+}
 /**
  * Interface for completion installers
  */
@@ -11,7 +25,6 @@ export interface CompletionInstaller {
         message: string;
     }>;
 }
-export type { InstallationResult };
 /**
  * Factory for creating completion generators and installers
  * This design makes it easy to add support for additional shells

package/dist/core/completions/factory.js

@@ -1,11 +1,17 @@
 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'];
+    static SUPPORTED_SHELLS = ['zsh', 'bash', 'fish', 'powershell'];
     /**
      * Create a completion generator for the specified shell
      *
@@ -17,6 +23,12 @@ export class CompletionFactory {
         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}`);
         }
@@ -32,6 +44,12 @@ export class CompletionFactory {
         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}`);
         }

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,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