synarcx 0.1.0

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

@@ -0,0 +1,160 @@
+import { FISH_STATIC_HELPERS, FISH_DYNAMIC_HELPERS } from '../templates/fish-templates.js';
+/**
+ * Generates Fish completion scripts for the synarcx 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 synarcx -n '__fish_synarcx_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 synarcx 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 synarcx -n '__fish_synarcx_using_subcommand ${cmd.name}; and not __fish_synarcx_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_synarcx_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_synarcx_using_subcommand ${cmd.name}; and __fish_synarcx_using_subcommand ${subcmd.name}`));
+                }
+                // Add positional completions for subcommand
+                if (subcmd.acceptsPositional) {
+                    lines.push(...this.generatePositionalCompletion(subcmd.positionalType, `__fish_synarcx_using_subcommand ${cmd.name}; and __fish_synarcx_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_synarcx_using_subcommand ${cmd.name}`));
+            }
+            // Add positional completions
+            if (cmd.acceptsPositional) {
+                lines.push(...this.generatePositionalCompletion(cmd.positionalType, `__fish_synarcx_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 synarcx -n '${condition}' -s ${flag.short} -l ${flag.name} -a '${value}' -d '${this.escapeDescription(flag.description)}'`);
+                }
+                else {
+                    lines.push(`complete -c synarcx -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 synarcx -n '${condition}' -s ${flag.short} -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
+            }
+            else {
+                lines.push(`complete -c synarcx -n '${condition}' -l ${flag.name} -r -d '${this.escapeDescription(flag.description)}'`);
+            }
+        }
+        else {
+            // Boolean flag
+            if (shortFlag) {
+                lines.push(`complete -c synarcx -n '${condition}' -s ${flag.short} -l ${flag.name} -d '${this.escapeDescription(flag.description)}'`);
+            }
+            else {
+                lines.push(`complete -c synarcx -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 synarcx -n '${condition}' -a '(__fish_synarcx_changes)' -f`);
+                break;
+            case 'spec-id':
+                lines.push(`complete -c synarcx -n '${condition}' -a '(__fish_synarcx_specs)' -f`);
+                break;
+            case 'change-or-spec-id':
+                lines.push(`complete -c synarcx -n '${condition}' -a '(__fish_synarcx_items)' -f`);
+                break;
+            case 'schema-name':
+                lines.push(`complete -c synarcx -n '${condition}' -a '(__fish_synarcx_schemas)' -f`);
+                break;
+            case 'shell':
+                lines.push(`complete -c synarcx -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,36 @@
+import { CompletionGenerator, CommandDefinition } from '../types.js';
+/**
+ * Generates PowerShell completion scripts for the synarcx 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;
+    private generateIndexedPositionalCompletion;
+    private generateValueFlags;
+    private escapeRegex;
+    /**
+     * 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,266 @@
+import { POWERSHELL_DYNAMIC_HELPERS } from '../templates/powershell-templates.js';
+/**
+ * Generates PowerShell completion scripts for the synarcx CLI.
+ * Uses Register-ArgumentCompleter for command completion.
+ */
+export class PowerShellGenerator {
+    shell = 'powershell';
+    stripTrailingCommaFromLastLine(lines) {
+        if (lines.length === 0)
+            return;
+        lines[lines.length - 1] = lines[lines.length - 1].replace(/,\s*$/, '');
+    }
+    /**
+     * 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)}"},`);
+        }
+        this.stripTrailingCommaFromLastLine(commandLines);
+        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 synarcx CLI
+# Auto-generated - do not edit manually
+
+${helpers}
+$synarcxCompleter = {
+    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 synarcx -ScriptBlock $synarcxCompleter
+`;
+    }
+    /**
+     * 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)}"},`);
+                    }
+                }
+                this.stripTrailingCommaFromLastLine(lines);
+                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)}"},`);
+            }
+            this.stripTrailingCommaFromLastLine(lines);
+            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 + '        ', 3));
+                lines.push(`${indent}    }`);
+            }
+            lines.push(`${indent}}`);
+        }
+        else {
+            // No subcommands
+            lines.push(...this.generateArgumentCompletion(cmd, indent, 2));
+        }
+        return lines;
+    }
+    /**
+     * Generate argument completion (flags and positional)
+     */
+    generateArgumentCompletion(cmd, indent, firstPositionalTokenIndex) {
+        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)}"},`);
+                }
+            }
+            this.stripTrailingCommaFromLastLine(lines);
+            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.positionals && cmd.positionals.length > 0) {
+            lines.push(...this.generateIndexedPositionalCompletion(cmd.positionals, cmd.flags, firstPositionalTokenIndex, indent));
+        }
+        else if (cmd.acceptsPositional) {
+            lines.push(...this.generatePositionalCompletion(cmd.positionalType, indent));
+        }
+        return lines;
+    }
+    generateIndexedPositionalCompletion(positionals, flags, firstPositionalTokenIndex, indent) {
+        const lines = [];
+        const valueFlags = this.generateValueFlags(flags);
+        if (valueFlags.length > 0) {
+            const flagList = valueFlags.map((flag) => `"${flag}"`).join(', ');
+            lines.push(`${indent}if (@(${flagList}) -contains $tokens[$commandCount - 2]) { return }`);
+            lines.push('');
+        }
+        lines.push(`${indent}$positionalIndex = 0`);
+        lines.push(`${indent}$skipNext = $false`);
+        lines.push(`${indent}for ($i = ${firstPositionalTokenIndex}; $i -lt ($commandCount - 1); $i++) {`);
+        lines.push(`${indent}    if ($skipNext) {`);
+        lines.push(`${indent}        $skipNext = $false`);
+        lines.push(`${indent}        continue`);
+        lines.push(`${indent}    }`);
+        lines.push(`${indent}    $token = $tokens[$i]`);
+        if (valueFlags.length > 0) {
+            const flagList = valueFlags.map((flag) => `"${flag}"`).join(', ');
+            lines.push(`${indent}    if (@(${flagList}) -contains $token) {`);
+            lines.push(`${indent}        $skipNext = $true`);
+            lines.push(`${indent}        continue`);
+            lines.push(`${indent}    }`);
+            lines.push(`${indent}    if ($token -match "^(${valueFlags.map((flag) => this.escapeRegex(flag)).join('|')})=.*") { continue }`);
+        }
+        lines.push(`${indent}    if ($token -like "-*") { continue }`);
+        lines.push(`${indent}    $positionalIndex++`);
+        lines.push(`${indent}}`);
+        lines.push('');
+        lines.push(`${indent}switch ($positionalIndex) {`);
+        for (const [index, positional] of positionals.entries()) {
+            const completion = this.generatePositionalCompletion(positional.type, indent + '    ');
+            if (completion.length === 0)
+                continue;
+            lines.push(`${indent}    ${index} {`);
+            lines.push(...completion);
+            lines.push(`${indent}    }`);
+        }
+        lines.push(`${indent}}`);
+        return lines;
+    }
+    generateValueFlags(flags) {
+        return flags
+            .filter((flag) => flag.takesValue)
+            .flatMap((flag) => [
+            `--${flag.name}`,
+            ...(flag.short ? [`-${flag.short}`] : []),
+        ]);
+    }
+    escapeRegex(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Generate positional argument completion
+     */
+    generatePositionalCompletion(positionalType, indent) {
+        const lines = [];
+        switch (positionalType) {
+            case 'change-id':
+                lines.push(`${indent}Get-SynarcxChanges | 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-SynarcxSpecs | 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-SynarcxChanges) + @(Get-SynarcxSpecs)`);
+                lines.push(`${indent}$items | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_)`);
+                lines.push(`${indent}}`);
+                break;
+            case 'schema-name':
+                lines.push(`${indent}Get-SynarcxSchemas | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {`);
+                lines.push(`${indent}    [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", "Schema: $_")`);
+                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

@@ -0,0 +1,47 @@
+import { CompletionGenerator, CommandDefinition } from '../types.js';
+/**
+ * Generates Zsh completion scripts for the synarcx CLI.
+ * Follows Zsh completion system conventions using the _synarcx function.
+ */
+export declare class ZshGenerator implements CompletionGenerator {
+    readonly shell: "zsh";
+    /**
+     * Generate a Zsh completion script
+     *
+     * @param commands - Command definitions to generate completions for
+     * @returns Zsh completion script as a string
+     */
+    generate(commands: CommandDefinition[]): string;
+    /**
+     * Generate completion function for a specific command
+     */
+    private generateCommandFunction;
+    /**
+     * Generate completion function for a subcommand
+     */
+    private generateSubcommandFunction;
+    /**
+     * Generate flag specification for _arguments
+     */
+    private generateFlagSpec;
+    /**
+     * Generate positional argument specification
+     */
+    private generatePositionalSpec;
+    private appendPositionalSpecs;
+    private generatePositionalSpecs;
+    private generateIndexedPositionalSpec;
+    /**
+     * Escape special characters in descriptions
+     */
+    private escapeDescription;
+    /**
+     * Escape special characters in values
+     */
+    private escapeValue;
+    /**
+     * Sanitize command names for use in function names
+     */
+    private sanitizeFunctionName;
+}
+//# sourceMappingURL=zsh-generator.d.ts.map