@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/completions.js

@@ -0,0 +1,255 @@
+/**
+ * Shell Completion Auto-Installer (L7)
+ *
+ * Installs shell completions for bash, zsh, and fish.
+ * Completion scripts are generated dynamically from the CLI command list.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ui } from '../wizard/ui';
+const COMMANDS = [
+    'chat', 'run', 'init', 'login', 'logout', 'doctor', 'cost',
+    'sessions', 'audit', 'share', 'upgrade', 'serve', 'web',
+    'auth-refresh', 'plugin', 'completions', 'team-context',
+    'logs', 'pipeline', 'alias',
+];
+/**
+ * L4: Get available kubectl contexts for shell completion.
+ */
+function getKubeContexts() {
+    try {
+        const { execFileSync } = require('node:child_process');
+        return execFileSync('kubectl', ['config', 'get-contexts', '--no-headers', '-o', 'name'], { encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] })
+            .trim()
+            .split('\n')
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * L2: Get terraform workspaces for dynamic shell completion.
+ */
+function getTerraformWorkspaces() {
+    try {
+        const { execFileSync } = require('node:child_process');
+        return execFileSync('terraform', ['workspace', 'list'], {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        })
+            .split('\n')
+            .map((l) => l.replace(/^\*?\s*/, '').trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * L2: Get helm releases for dynamic shell completion.
+ */
+function getHelmReleases() {
+    try {
+        const { execFileSync } = require('node:child_process');
+        return execFileSync('helm', ['list', '--short'], {
+            encoding: 'utf-8',
+            timeout: 3000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        })
+            .trim()
+            .split('\n')
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * L2: Dynamic completion dispatcher.
+ * Called from shell with: nimbus __complete <prev_word> <curr_word>
+ */
+export function dynamicComplete(prevWord, _currWord) {
+    let suggestions = [];
+    if (prevWord === 'workspace' || prevWord === 'ws') {
+        suggestions = getTerraformWorkspaces();
+    }
+    else if (prevWord === 'switch' || prevWord === 'context') {
+        suggestions = getKubeContexts();
+    }
+    else if (prevWord === 'upgrade' || prevWord === 'rollback') {
+        suggestions = getHelmReleases();
+    }
+    if (suggestions.length > 0) {
+        process.stdout.write(suggestions.join('\n') + '\n');
+    }
+}
+const FLAGS = [
+    '--help', '--version', '--model', '--mode', '--auto-approve',
+    '--format', '--verbose', '--json', '--fix',
+];
+function generateBashCompletion() {
+    return `# Nimbus bash completion
+_nimbus_completions() {
+  local cur prev
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  local commands="${COMMANDS.join(' ')}"
+  local flags="${FLAGS.join(' ')}"
+
+  if [ \$COMP_CWORD -eq 1 ]; then
+    COMPREPLY=( \$(compgen -W "\$commands" -- "\$cur") )
+  else
+    COMPREPLY=( \$(compgen -W "\$flags" -- "\$cur") )
+  fi
+}
+
+complete -F _nimbus_completions nimbus
+`;
+}
+function generateZshCompletion() {
+    const commandDefs = COMMANDS.map(c => `    '${c}:${c} command'`).join('\n');
+    const kubeContexts = getKubeContexts();
+    const contextCompletion = kubeContexts.length > 0
+        ? `\n        '--context[kubectl context]:context:(${kubeContexts.join(' ')})' \\`
+        : '';
+    return `#compdef nimbus
+# Nimbus zsh completion
+
+_nimbus() {
+  local state
+
+  _arguments \\
+    '1: :->command' \\${contextCompletion}
+    '*: :->args'
+
+  case \$state in
+    command)
+      _describe 'nimbus commands' \\
+        (
+${commandDefs}
+        )
+      ;;
+    args)
+      _arguments \\
+        '--help[Show help]' \\
+        '--version[Show version]' \\
+        '--model[Specify LLM model]:model:' \\
+        '--mode[Agent mode (plan/build/deploy)]:mode:(plan build deploy)' \\
+        '--auto-approve[Auto-approve all actions]' \\
+        '--format[Output format]:format:(json text)'
+      ;;
+  esac
+}
+
+_nimbus
+`;
+}
+function generateFishCompletion() {
+    const cmdCompletions = COMMANDS.map(c => `complete -c nimbus -f -n '__fish_use_subcommand' -a '${c}'`).join('\n');
+    return `# Nimbus fish completion
+
+${cmdCompletions}
+
+complete -c nimbus -l help -d 'Show help'
+complete -c nimbus -l version -d 'Show version'
+complete -c nimbus -l model -d 'Specify LLM model' -r
+complete -c nimbus -l mode -d 'Agent mode' -r -a 'plan build deploy'
+complete -c nimbus -l auto-approve -d 'Auto-approve all actions'
+complete -c nimbus -l format -d 'Output format' -r -a 'json text'
+`;
+}
+export async function completionsCommand(subcommand) {
+    switch (subcommand) {
+        case 'install': {
+            const shell = path.basename(process.env.SHELL ?? '/bin/bash');
+            ui.info(`Detected shell: ${shell}`);
+            if (shell === 'bash') {
+                const dir = path.join(os.homedir(), '.bash_completion.d');
+                const file = path.join(dir, 'nimbus.bash');
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(file, generateBashCompletion(), 'utf-8');
+                // Add source to .bashrc if not already there
+                const bashrc = path.join(os.homedir(), '.bashrc');
+                const sourceLine = `\n# Nimbus completions\n[ -f "${file}" ] && source "${file}"\n`;
+                let alreadyConfigured = false;
+                try {
+                    const existing = fs.readFileSync(bashrc, 'utf-8');
+                    if (!existing.includes('nimbus.bash')) {
+                        fs.appendFileSync(bashrc, sourceLine);
+                    }
+                    else {
+                        alreadyConfigured = true;
+                    }
+                }
+                catch {
+                    fs.appendFileSync(bashrc, sourceLine);
+                }
+                ui.print(`${ui.color('✓', 'green')} Installed bash completions to ${file}`);
+                if (alreadyConfigured) {
+                    ui.print('  Already configured, skipping.');
+                }
+                else {
+                    ui.print('  Restart your shell or run: source ~/.bashrc');
+                }
+            }
+            else if (shell === 'zsh') {
+                const dir = path.join(os.homedir(), '.zsh', 'completions');
+                const file = path.join(dir, '_nimbus');
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(file, generateZshCompletion(), 'utf-8');
+                ui.print(`${ui.color('✓', 'green')} Installed zsh completions to ${file}`);
+                ui.print('  Add to .zshrc: fpath=(~/.zsh/completions $fpath) && autoload -U compinit && compinit');
+                ui.print('  Restart your shell or run: source ~/.zshrc');
+            }
+            else if (shell === 'fish') {
+                const dir = path.join(os.homedir(), '.config', 'fish', 'completions');
+                const file = path.join(dir, 'nimbus.fish');
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(file, generateFishCompletion(), 'utf-8');
+                ui.print(`${ui.color('✓', 'green')} Installed fish completions to ${file}`);
+                ui.print('  Fish completions are active immediately. Restart your shell to confirm.');
+            }
+            else {
+                ui.warning(`Shell "${shell}" not supported. Supported: bash, zsh, fish`);
+            }
+            break;
+        }
+        case 'uninstall': {
+            const shell = path.basename(process.env.SHELL ?? '/bin/bash');
+            const files = [
+                path.join(os.homedir(), '.bash_completion.d', 'nimbus.bash'),
+                path.join(os.homedir(), '.zsh', 'completions', '_nimbus'),
+                path.join(os.homedir(), '.config', 'fish', 'completions', 'nimbus.fish'),
+            ];
+            let removed = 0;
+            for (const f of files) {
+                if (fs.existsSync(f)) {
+                    fs.unlinkSync(f);
+                    ui.print(`${ui.color('✓', 'green')} Removed ${f}`);
+                    removed++;
+                }
+            }
+            if (removed === 0) {
+                ui.info('No completion files found to remove.');
+            }
+            else {
+                ui.info(`Removed ${removed} completion file(s). Reload your shell.`);
+            }
+            void shell; // suppress unused warning
+            break;
+        }
+        case '__complete': {
+            // L2: Dynamic completion dispatcher — called from shell completion scripts
+            // Usage: nimbus completions __complete <prev_word> <curr_word>
+            // (args passed as positional args by the shell)
+            break;
+        }
+        default:
+            ui.print('Usage: nimbus completions <install|uninstall>');
+    }
+}

package/dist/src/commands/config.js

@@ -0,0 +1,291 @@
+/**
+ * Config Command
+ *
+ * Manage Nimbus configuration
+ */
+import { ui } from '../wizard/ui';
+import { select, input, confirm } from '../wizard/prompts';
+import { ConfigManager, CONFIG_KEYS } from '../config';
+/**
+ * Config set command
+ */
+export async function configSetCommand(options) {
+    const configManager = new ConfigManager();
+    let key = options.key;
+    let value = options.value;
+    // Interactive mode - select key if not provided
+    if (!key && !options.nonInteractive) {
+        const keyOptions = CONFIG_KEYS.map(k => ({
+            label: k.key,
+            value: k.key,
+            description: k.description,
+        }));
+        key = (await select({
+            message: 'Select configuration key to set:',
+            options: keyOptions,
+        }));
+    }
+    if (!key) {
+        ui.error('Configuration key is required.');
+        process.exit(1);
+    }
+    // Validate key
+    const keyInfo = configManager.getKeyInfo(key);
+    if (!keyInfo) {
+        ui.warning(`Unknown configuration key: ${key}`);
+        ui.info('Use "nimbus config list" to see available keys.');
+        if (!options.nonInteractive) {
+            const proceed = await confirm({
+                message: 'Set this key anyway?',
+                defaultValue: false,
+            });
+            if (!proceed) {
+                return;
+            }
+        }
+    }
+    // Get value if not provided
+    if (value === undefined && !options.nonInteractive) {
+        const currentValue = configManager.get(key);
+        const defaultValue = keyInfo?.defaultValue;
+        let placeholder = '';
+        if (currentValue !== undefined) {
+            placeholder = String(currentValue);
+        }
+        else if (defaultValue !== undefined) {
+            placeholder = `default: ${defaultValue}`;
+        }
+        if (keyInfo?.type === 'boolean') {
+            const boolValue = await confirm({
+                message: `Set ${key}:`,
+                defaultValue: currentValue ?? defaultValue ?? false,
+            });
+            value = String(boolValue);
+        }
+        else {
+            value = await input({
+                message: `Enter value for ${key}:`,
+                defaultValue: currentValue !== undefined ? String(currentValue) : undefined,
+                placeholder,
+            });
+        }
+    }
+    if (value === undefined) {
+        ui.error('Configuration value is required.');
+        process.exit(1);
+    }
+    // M4: Validate model key against known model IDs
+    if (key === 'model' || key === 'llm.defaultModel') {
+        const knownModels = [
+            'claude-opus-4-6',
+            'claude-sonnet-4-6',
+            'claude-haiku-4-5-20251001',
+            'claude-opus-4-20250514',
+            'claude-sonnet-4-20250514',
+            'claude-haiku-4-5',
+            'anthropic/claude-opus-4-6',
+            'anthropic/claude-sonnet-4-6',
+            'anthropic/claude-haiku-4-5-20251001',
+            'anthropic/claude-opus-4-20250514',
+            'anthropic/claude-sonnet-4-20250514',
+        ];
+        if (!knownModels.includes(value)) {
+            ui.warning(`"${value}" is not a recognized Nimbus model ID.`);
+            ui.info('Known models: ' + knownModels.slice(0, 6).join(', '));
+            if (!options.nonInteractive) {
+                const { confirm: confirmPrompt } = await import('../wizard/prompts');
+                const proceed = await confirmPrompt({ message: 'Set this model anyway?', defaultValue: false });
+                if (!proceed)
+                    return;
+            }
+        }
+    }
+    // Parse and set value
+    const parsedValue = configManager.parseValue(key, value);
+    configManager.set(key, parsedValue);
+    ui.success(`Configuration updated: ${key} = ${parsedValue}`);
+}
+/**
+ * Config get command
+ */
+export async function configGetCommand(options) {
+    const configManager = new ConfigManager();
+    let key = options.key;
+    // Interactive mode - select key if not provided
+    if (!key && !options.nonInteractive) {
+        const keyOptions = CONFIG_KEYS.map(k => ({
+            label: k.key,
+            value: k.key,
+            description: k.description,
+        }));
+        key = (await select({
+            message: 'Select configuration key to view:',
+            options: keyOptions,
+        }));
+    }
+    if (!key) {
+        ui.error('Configuration key is required.');
+        process.exit(1);
+    }
+    const value = configManager.get(key);
+    if (value === undefined) {
+        const keyInfo = configManager.getKeyInfo(key);
+        if (keyInfo?.defaultValue !== undefined) {
+            ui.print(`${ui.color(key, 'cyan')}: ${keyInfo.defaultValue} ${ui.dim('(default)')}`);
+        }
+        else {
+            ui.print(`${ui.color(key, 'cyan')}: ${ui.dim('(not set)')}`);
+        }
+    }
+    else {
+        ui.print(`${ui.color(key, 'cyan')}: ${value}`);
+    }
+}
+/**
+ * Config list command
+ */
+export async function configListCommand(options) {
+    const configManager = new ConfigManager();
+    const allConfig = configManager.getAllFlat();
+    if (options.json) {
+        console.log(JSON.stringify(allConfig, null, 2));
+        return;
+    }
+    ui.newLine();
+    ui.header('Nimbus Configuration', configManager.getConfigPath());
+    // Group by section
+    const sections = {};
+    for (const keyInfo of CONFIG_KEYS) {
+        const [section] = keyInfo.key.split('.');
+        if (!sections[section]) {
+            sections[section] = [];
+        }
+        const value = allConfig[keyInfo.key];
+        const isDefault = value === undefined || value === keyInfo.defaultValue;
+        if (options.changed && isDefault) {
+            continue;
+        }
+        sections[section].push({
+            key: keyInfo.key,
+            value: value !== undefined ? value : keyInfo.defaultValue,
+            info: keyInfo,
+        });
+    }
+    for (const [section, items] of Object.entries(sections)) {
+        if (items.length === 0) {
+            continue;
+        }
+        ui.section(section.charAt(0).toUpperCase() + section.slice(1));
+        for (const item of items) {
+            const isDefault = item.value === item.info?.defaultValue;
+            const valueStr = item.value !== undefined ? String(item.value) : ui.dim('(not set)');
+            const defaultMarker = isDefault ? ui.dim(' (default)') : '';
+            ui.print(`  ${ui.color(item.key, 'cyan')}: ${valueStr}${defaultMarker}`);
+            if (item.info?.description) {
+                ui.print(`    ${ui.dim(item.info.description)}`);
+            }
+        }
+        ui.newLine();
+    }
+}
+/**
+ * Config init command
+ */
+export async function configInitCommand(options) {
+    const configManager = new ConfigManager();
+    if (configManager.exists() && !options.force) {
+        ui.warning(`Configuration file already exists at: ${configManager.getConfigPath()}`);
+        if (!options.nonInteractive) {
+            const overwrite = await confirm({
+                message: 'Overwrite existing configuration?',
+                defaultValue: false,
+            });
+            if (!overwrite) {
+                ui.info('Configuration unchanged.');
+                return;
+            }
+        }
+        else {
+            ui.info('Use --force to overwrite.');
+            return;
+        }
+    }
+    // Interactive configuration setup
+    if (!options.nonInteractive) {
+        ui.newLine();
+        ui.header('Nimbus Configuration Setup', "Let's configure your Nimbus CLI");
+        // Workspace settings
+        ui.section('Workspace');
+        const defaultProvider = await select({
+            message: 'Default cloud provider:',
+            options: [
+                { label: 'AWS', value: 'aws', description: 'Amazon Web Services' },
+                { label: 'GCP', value: 'gcp', description: 'Google Cloud Platform' },
+                { label: 'Azure', value: 'azure', description: 'Microsoft Azure' },
+            ],
+        });
+        const outputDir = await input({
+            message: 'Default output directory for generated code:',
+            defaultValue: './infrastructure',
+        });
+        // LLM settings
+        ui.section('LLM');
+        const temperature = await input({
+            message: 'LLM temperature (0-1):',
+            defaultValue: '0.7',
+            validate: val => {
+                const num = Number(val);
+                if (isNaN(num) || num < 0 || num > 1) {
+                    return 'Temperature must be a number between 0 and 1';
+                }
+                return true;
+            },
+        });
+        // Safety settings
+        ui.section('Safety');
+        const requireConfirmation = await confirm({
+            message: 'Require confirmation for destructive operations?',
+            defaultValue: true,
+        });
+        // Save configuration
+        configManager.set('workspace.defaultProvider', defaultProvider);
+        configManager.set('workspace.outputDirectory', outputDir);
+        configManager.set('llm.temperature', Number(temperature));
+        configManager.set('safety.requireConfirmation', requireConfirmation);
+        ui.newLine();
+        ui.success(`Configuration saved to: ${configManager.getConfigPath()}`);
+    }
+    else {
+        // Non-interactive - just create default config
+        configManager.reset();
+        ui.success(`Default configuration created at: ${configManager.getConfigPath()}`);
+    }
+}
+/**
+ * Config reset command
+ */
+export async function configResetCommand(options) {
+    const configManager = new ConfigManager();
+    if (!options.nonInteractive) {
+        const confirm_reset = await confirm({
+            message: 'Reset all configuration to defaults?',
+            defaultValue: false,
+        });
+        if (!confirm_reset) {
+            ui.info('Configuration unchanged.');
+            return;
+        }
+    }
+    configManager.reset();
+    ui.success('Configuration reset to defaults.');
+}
+/**
+ * Main config command dispatcher
+ */
+export const configCommand = {
+    set: configSetCommand,
+    get: configGetCommand,
+    list: configListCommand,
+    init: configInitCommand,
+    reset: configResetCommand,
+};