lightspec 0.1.1

package/dist/commands/completion.d.ts

@@ -0,0 +1,72 @@
+interface GenerateOptions {
+    shell?: string;
+}
+interface InstallOptions {
+    shell?: string;
+    verbose?: boolean;
+}
+interface UninstallOptions {
+    shell?: string;
+    yes?: boolean;
+}
+interface CompleteOptions {
+    type: string;
+}
+/**
+ * Command for managing shell completions for LightSpec CLI
+ */
+export declare class CompletionCommand {
+    private completionProvider;
+    constructor();
+    /**
+     * Resolve shell parameter or exit with error
+     *
+     * @param shell - The shell parameter (may be undefined)
+     * @param operationName - Name of the operation (for error messages)
+     * @returns Resolved shell or null if should exit
+     */
+    private resolveShellOrExit;
+    /**
+     * Generate completion script and output to stdout
+     *
+     * @param options - Options for generation (shell type)
+     */
+    generate(options?: GenerateOptions): Promise<void>;
+    /**
+     * Install completion script to the appropriate location
+     *
+     * @param options - Options for installation (shell type, verbose output)
+     */
+    install(options?: InstallOptions): Promise<void>;
+    /**
+     * Uninstall completion script from the installation location
+     *
+     * @param options - Options for uninstallation (shell type, yes flag)
+     */
+    uninstall(options?: UninstallOptions): Promise<void>;
+    /**
+     * Generate completion script for a specific shell
+     */
+    private generateForShell;
+    /**
+     * Install completion script for a specific shell
+     */
+    private installForShell;
+    /**
+     * Uninstall completion script for a specific shell
+     */
+    private uninstallForShell;
+    /**
+     * Output machine-readable completion data for shell consumption
+     * Format: tab-separated "id\tdescription" per line
+     *
+     * @param options - Options specifying completion type
+     */
+    complete(options: CompleteOptions): Promise<void>;
+    /**
+     * Normalize shell parameter to lowercase
+     */
+    private normalizeShell;
+}
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/commands/completion.js

@@ -0,0 +1,257 @@
+import ora from 'ora';
+import { CompletionFactory } from '../core/completions/factory.js';
+import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
+import { detectShell } from '../utils/shell-detection.js';
+import { CompletionProvider } from '../core/completions/completion-provider.js';
+import { getArchivedChangeIds } from '../utils/item-discovery.js';
+/**
+ * Command for managing shell completions for LightSpec CLI
+ */
+export class CompletionCommand {
+    completionProvider;
+    constructor() {
+        this.completionProvider = new CompletionProvider();
+    }
+    /**
+     * Resolve shell parameter or exit with error
+     *
+     * @param shell - The shell parameter (may be undefined)
+     * @param operationName - Name of the operation (for error messages)
+     * @returns Resolved shell or null if should exit
+     */
+    resolveShellOrExit(shell, operationName) {
+        const normalizedShell = this.normalizeShell(shell);
+        if (!normalizedShell) {
+            const detectionResult = detectShell();
+            if (detectionResult.shell && CompletionFactory.isSupported(detectionResult.shell)) {
+                return detectionResult.shell;
+            }
+            // Shell was detected but not supported
+            if (detectionResult.detected && !detectionResult.shell) {
+                console.error(`Error: Shell '${detectionResult.detected}' is not supported yet. Currently supported: ${CompletionFactory.getSupportedShells().join(', ')}`);
+                process.exitCode = 1;
+                return null;
+            }
+            // No shell specified and cannot auto-detect
+            console.error('Error: Could not auto-detect shell. Please specify shell explicitly.');
+            console.error(`Usage: lightspec completion ${operationName} [shell]`);
+            console.error(`Currently supported: ${CompletionFactory.getSupportedShells().join(', ')}`);
+            process.exitCode = 1;
+            return null;
+        }
+        if (!CompletionFactory.isSupported(normalizedShell)) {
+            console.error(`Error: Shell '${normalizedShell}' is not supported yet. Currently supported: ${CompletionFactory.getSupportedShells().join(', ')}`);
+            process.exitCode = 1;
+            return null;
+        }
+        return normalizedShell;
+    }
+    /**
+     * Generate completion script and output to stdout
+     *
+     * @param options - Options for generation (shell type)
+     */
+    async generate(options = {}) {
+        const shell = this.resolveShellOrExit(options.shell, 'generate');
+        if (!shell)
+            return;
+        await this.generateForShell(shell);
+    }
+    /**
+     * Install completion script to the appropriate location
+     *
+     * @param options - Options for installation (shell type, verbose output)
+     */
+    async install(options = {}) {
+        const shell = this.resolveShellOrExit(options.shell, 'install');
+        if (!shell)
+            return;
+        await this.installForShell(shell, options.verbose || false);
+    }
+    /**
+     * Uninstall completion script from the installation location
+     *
+     * @param options - Options for uninstallation (shell type, yes flag)
+     */
+    async uninstall(options = {}) {
+        const shell = this.resolveShellOrExit(options.shell, 'uninstall');
+        if (!shell)
+            return;
+        await this.uninstallForShell(shell, options.yes || false);
+    }
+    /**
+     * Generate completion script for a specific shell
+     */
+    async generateForShell(shell) {
+        const generator = CompletionFactory.createGenerator(shell);
+        const script = generator.generate(COMMAND_REGISTRY);
+        console.log(script);
+    }
+    /**
+     * Install completion script for a specific shell
+     */
+    async installForShell(shell, verbose) {
+        const generator = CompletionFactory.createGenerator(shell);
+        const installer = CompletionFactory.createInstaller(shell);
+        const spinner = ora(`Installing ${shell} completion script...`).start();
+        try {
+            // Generate the completion script
+            const script = generator.generate(COMMAND_REGISTRY);
+            // Install it
+            const result = await installer.install(script);
+            spinner.stop();
+            if (result.success) {
+                console.log(`✓ ${result.message}`);
+                if (verbose && result.installedPath) {
+                    console.log(`  Installed to: ${result.installedPath}`);
+                    if (result.backupPath) {
+                        console.log(`  Backup created: ${result.backupPath}`);
+                    }
+                    // Check if any shell config was updated
+                    const configWasUpdated = result.zshrcConfigured || result.bashrcConfigured || result.profileConfigured;
+                    if (configWasUpdated) {
+                        const configPaths = {
+                            zsh: '~/.zshrc',
+                            bash: '~/.bashrc',
+                            fish: '~/.config/fish/config.fish',
+                            powershell: '$PROFILE',
+                        };
+                        const configPath = configPaths[shell] || 'config file';
+                        console.log(`  ${configPath} configured automatically`);
+                    }
+                }
+                // Display warnings if present
+                if (result.warnings && result.warnings.length > 0) {
+                    console.log('');
+                    for (const warning of result.warnings) {
+                        console.log(warning);
+                    }
+                }
+                // Print instructions (only shown if .zshrc wasn't auto-configured)
+                if (result.instructions && result.instructions.length > 0) {
+                    console.log('');
+                    for (const instruction of result.instructions) {
+                        console.log(instruction);
+                    }
+                }
+                else {
+                    // Check if any shell config was updated (InstallationResult has: zshrcConfigured, bashrcConfigured, profileConfigured)
+                    const configWasUpdated = result.zshrcConfigured || result.bashrcConfigured || result.profileConfigured;
+                    if (configWasUpdated) {
+                        console.log('');
+                        // Shell-specific reload instructions
+                        const reloadCommands = {
+                            zsh: 'exec zsh',
+                            bash: 'exec bash',
+                            fish: 'exec fish',
+                            powershell: '. $PROFILE',
+                        };
+                        const reloadCmd = reloadCommands[shell] || `restart your ${shell} shell`;
+                        console.log(`Restart your shell or run: ${reloadCmd}`);
+                    }
+                }
+            }
+            else {
+                console.error(`✗ ${result.message}`);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            console.error(`✗ Failed to install completion script: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    }
+    /**
+     * Uninstall completion script for a specific shell
+     */
+    async uninstallForShell(shell, skipConfirmation) {
+        const installer = CompletionFactory.createInstaller(shell);
+        // Prompt for confirmation unless --yes flag is provided
+        if (!skipConfirmation) {
+            const { confirm } = await import('@inquirer/prompts');
+            // Get shell-specific config file path
+            const configPaths = {
+                zsh: '~/.zshrc',
+                bash: '~/.bashrc',
+                fish: 'Fish configuration', // Fish doesn't modify profile, just removes script file
+                powershell: '$PROFILE',
+            };
+            const configPath = configPaths[shell] || `${shell} configuration`;
+            const confirmed = await confirm({
+                message: `Remove LightSpec configuration from ${configPath}?`,
+                default: false,
+            });
+            if (!confirmed) {
+                console.log('Uninstall cancelled.');
+                return;
+            }
+        }
+        const spinner = ora(`Uninstalling ${shell} completion script...`).start();
+        try {
+            const result = await installer.uninstall();
+            spinner.stop();
+            if (result.success) {
+                console.log(`✓ ${result.message}`);
+            }
+            else {
+                console.error(`✗ ${result.message}`);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            spinner.stop();
+            console.error(`✗ Failed to uninstall completion script: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    }
+    /**
+     * Output machine-readable completion data for shell consumption
+     * Format: tab-separated "id\tdescription" per line
+     *
+     * @param options - Options specifying completion type
+     */
+    async complete(options) {
+        const type = options.type.toLowerCase();
+        try {
+            switch (type) {
+                case 'changes': {
+                    const changeIds = await this.completionProvider.getChangeIds();
+                    for (const id of changeIds) {
+                        console.log(`${id}\tactive change`);
+                    }
+                    break;
+                }
+                case 'specs': {
+                    const specIds = await this.completionProvider.getSpecIds();
+                    for (const id of specIds) {
+                        console.log(`${id}\tspecification`);
+                    }
+                    break;
+                }
+                case 'archived-changes': {
+                    const archivedIds = await getArchivedChangeIds();
+                    for (const id of archivedIds) {
+                        console.log(`${id}\tarchived change`);
+                    }
+                    break;
+                }
+                default:
+                    // Invalid type - silently exit with no output for graceful shell completion failure
+                    process.exitCode = 1;
+                    break;
+            }
+        }
+        catch {
+            // Silently fail for graceful shell completion experience
+            process.exitCode = 1;
+        }
+    }
+    /**
+     * Normalize shell parameter to lowercase
+     */
+    normalizeShell(shell) {
+        return shell?.toLowerCase();
+    }
+}
+//# sourceMappingURL=completion.js.map

package/dist/commands/config.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+/**
+ * Register the config command and all its subcommands.
+ *
+ * @param program - The Commander program instance
+ */
+export declare function registerConfigCommand(program: Command): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.js

@@ -0,0 +1,198 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import { getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, } from '../core/global-config.js';
+import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatValueYaml, validateConfigKeyPath, validateConfig, DEFAULT_CONFIG, } from '../core/config-schema.js';
+/**
+ * Register the config command and all its subcommands.
+ *
+ * @param program - The Commander program instance
+ */
+export function registerConfigCommand(program) {
+    const configCmd = program
+        .command('config')
+        .description('View and modify global LightSpec configuration')
+        .option('--scope <scope>', 'Config scope (only "global" supported currently)')
+        .hook('preAction', (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.scope && opts.scope !== 'global') {
+            console.error('Error: Project-local config is not yet implemented');
+            process.exit(1);
+        }
+    });
+    // config path
+    configCmd
+        .command('path')
+        .description('Show config file location')
+        .action(() => {
+        console.log(getGlobalConfigPath());
+    });
+    // config list
+    configCmd
+        .command('list')
+        .description('Show all current settings')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        const config = getGlobalConfig();
+        if (options.json) {
+            console.log(JSON.stringify(config, null, 2));
+        }
+        else {
+            console.log(formatValueYaml(config));
+        }
+    });
+    // config get
+    configCmd
+        .command('get <key>')
+        .description('Get a specific value (raw, scriptable)')
+        .action((key) => {
+        const config = getGlobalConfig();
+        const value = getNestedValue(config, key);
+        if (value === undefined) {
+            process.exitCode = 1;
+            return;
+        }
+        if (typeof value === 'object' && value !== null) {
+            console.log(JSON.stringify(value));
+        }
+        else {
+            console.log(String(value));
+        }
+    });
+    // config set
+    configCmd
+        .command('set <key> <value>')
+        .description('Set a value (auto-coerce types)')
+        .option('--string', 'Force value to be stored as string')
+        .option('--allow-unknown', 'Allow setting unknown keys')
+        .action((key, value, options) => {
+        const allowUnknown = Boolean(options.allowUnknown);
+        const keyValidation = validateConfigKeyPath(key);
+        if (!keyValidation.valid && !allowUnknown) {
+            const reason = keyValidation.reason ? ` ${keyValidation.reason}.` : '';
+            console.error(`Error: Invalid configuration key "${key}".${reason}`);
+            console.error('Use "lightspec config list" to see available keys.');
+            console.error('Pass --allow-unknown to bypass this check.');
+            process.exitCode = 1;
+            return;
+        }
+        const config = getGlobalConfig();
+        const coercedValue = coerceValue(value, options.string || false);
+        // Create a copy to validate before saving
+        const newConfig = JSON.parse(JSON.stringify(config));
+        setNestedValue(newConfig, key, coercedValue);
+        // Validate the new config
+        const validation = validateConfig(newConfig);
+        if (!validation.success) {
+            console.error(`Error: Invalid configuration - ${validation.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        // Apply changes and save
+        setNestedValue(config, key, coercedValue);
+        saveGlobalConfig(config);
+        const displayValue = typeof coercedValue === 'string' ? `"${coercedValue}"` : String(coercedValue);
+        console.log(`Set ${key} = ${displayValue}`);
+    });
+    // config unset
+    configCmd
+        .command('unset <key>')
+        .description('Remove a key (revert to default)')
+        .action((key) => {
+        const config = getGlobalConfig();
+        const existed = deleteNestedValue(config, key);
+        if (existed) {
+            saveGlobalConfig(config);
+            console.log(`Unset ${key} (reverted to default)`);
+        }
+        else {
+            console.log(`Key "${key}" was not set`);
+        }
+    });
+    // config reset
+    configCmd
+        .command('reset')
+        .description('Reset configuration to defaults')
+        .option('--all', 'Reset all configuration (required)')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (options) => {
+        if (!options.all) {
+            console.error('Error: --all flag is required for reset');
+            console.error('Usage: lightspec config reset --all [-y]');
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.yes) {
+            const { confirm } = await import('@inquirer/prompts');
+            const confirmed = await confirm({
+                message: 'Reset all configuration to defaults?',
+                default: false,
+            });
+            if (!confirmed) {
+                console.log('Reset cancelled.');
+                return;
+            }
+        }
+        saveGlobalConfig({ ...DEFAULT_CONFIG });
+        console.log('Configuration reset to defaults');
+    });
+    // config edit
+    configCmd
+        .command('edit')
+        .description('Open config in $EDITOR')
+        .action(async () => {
+        const editor = process.env.EDITOR || process.env.VISUAL;
+        if (!editor) {
+            console.error('Error: No editor configured');
+            console.error('Set the EDITOR or VISUAL environment variable to your preferred editor');
+            console.error('Example: export EDITOR=vim');
+            process.exitCode = 1;
+            return;
+        }
+        const configPath = getGlobalConfigPath();
+        // Ensure config file exists with defaults
+        if (!fs.existsSync(configPath)) {
+            saveGlobalConfig({ ...DEFAULT_CONFIG });
+        }
+        // Spawn editor and wait for it to close
+        // Avoid shell parsing to correctly handle paths with spaces in both
+        // the editor path and config path
+        const child = spawn(editor, [configPath], {
+            stdio: 'inherit',
+            shell: false,
+        });
+        await new Promise((resolve, reject) => {
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Editor exited with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+        try {
+            const rawConfig = fs.readFileSync(configPath, 'utf-8');
+            const parsedConfig = JSON.parse(rawConfig);
+            const validation = validateConfig(parsedConfig);
+            if (!validation.success) {
+                console.error(`Error: Invalid configuration - ${validation.error}`);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.error(`Error: Config file not found at ${configPath}`);
+            }
+            else if (error instanceof SyntaxError) {
+                console.error(`Error: Invalid JSON in ${configPath}`);
+                console.error(error.message);
+            }
+            else {
+                console.error(`Error: Unable to validate configuration - ${error instanceof Error ? error.message : String(error)}`);
+            }
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/feedback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feedback command implementation
+ */
+export declare class FeedbackCommand {
+    execute(message: string, options?: {
+        body?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=feedback.d.ts.map