@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/commands/chat.ts

@@ -1,320 +0,0 @@
-/**
- * Chat Command
- *
- * Interactive chat mode with LLM streaming and infrastructure generation
- */
-
-import { startChat, type ChatUIOptions } from '../ui';
-import { AuthStore } from '../auth/store';
-import { ui } from '../wizard/ui';
-import { historyManager } from '../history';
-
-export interface ChatOptions {
-  /** LLM model to use */
-  model?: string;
-  /** Initial system prompt */
-  systemPrompt?: string;
-  /** Show token count after responses */
-  showTokenCount?: boolean;
-  /** Non-interactive mode (for API usage) */
-  nonInteractive?: boolean;
-  /** Single message to send (non-interactive) */
-  message?: string;
-  /** Enable infrastructure generation mode */
-  generateMode?: boolean;
-  /** Persona mode */
-  persona?: 'professional' | 'assistant' | 'expert';
-  /** Verbosity level */
-  verbosity?: 'minimal' | 'normal' | 'detailed';
-  /** UI mode (defaults to 'ink' for rich TUI, 'readline' for simple) */
-  ui?: 'ink' | 'readline';
-  /** Resume the most recent chat session */
-  continue?: boolean;
-  /** Pre-loaded initial prompt sent as the first user message automatically */
-  initialPrompt?: string;
-  /** Initial agent mode */
-  mode?: 'plan' | 'build' | 'deploy';
-}
-
-/**
- * Chat command handler
- *
- * Usage:
- *   nimbus chat                    - Start interactive chat (Ink TUI)
- *   nimbus chat --model gpt-4o     - Use specific model
- *   nimbus chat -m "Hello"         - Send single message (non-interactive)
- *   nimbus chat --ui=readline      - Use simple readline interface (no React/Ink)
- */
-export async function chatCommand(options: ChatOptions = {}): Promise<void> {
-  // Check for NIMBUS.md and suggest init if missing (non-blocking)
-  if (!options.nonInteractive && !options.message) {
-    try {
-      const fs = await import('node:fs');
-      const path = await import('node:path');
-      const nimbusPath = path.default.join(process.cwd(), 'NIMBUS.md');
-      if (!fs.default.existsSync(nimbusPath)) {
-        ui.print(
-          ui.dim(
-            'Tip: No NIMBUS.md found. Run `nimbus init` to set up project context for better results.'
-          )
-        );
-        ui.newLine();
-      }
-    } catch {
-      // Non-critical, ignore
-    }
-  }
-
-  // Pre-flight: verify at least one LLM provider is available
-  try {
-    const { getAppContext } = await import('../app');
-    const ctx = getAppContext();
-    if (ctx?.router && ctx.router.getAvailableProviders().length === 0) {
-      ui.newLine();
-      ui.error('No LLM provider configured.');
-      ui.newLine();
-      ui.print('Set up a provider using one of these methods:');
-      ui.print(`  ${ui.bold('nimbus login')}           — interactive setup wizard`);
-      ui.print(`  ${ui.bold('export ANTHROPIC_API_KEY=sk-ant-...')}  — environment variable`);
-      ui.print(`  ${ui.bold('export OPENAI_API_KEY=sk-...')}         — environment variable`);
-      ui.newLine();
-      return;
-    }
-  } catch {
-    // Pre-flight is non-critical — let it fail later with a real error
-  }
-
-  // Resolve --continue: look up the most recent session ID
-  let resumeSessionId: string | undefined;
-  if (options.continue) {
-    try {
-      const { SessionManager } = await import('../sessions/manager');
-      const sessionManager = SessionManager.getInstance();
-      const recent = sessionManager.list();
-      if (recent.length > 0) {
-        resumeSessionId = recent[0].id;
-      } else {
-        ui.print(ui.dim('No previous session found. Starting a new session.'));
-        ui.newLine();
-      }
-    } catch {
-      // Session lookup is non-critical — fall through to a fresh session
-    }
-  }
-
-  // Default to Ink TUI, fall back to readline if unavailable or explicitly requested.
-  // If stdin is not a TTY (piped input), skip Ink and use readline mode.
-  if (options.ui !== 'readline' && process.stdin.isTTY) {
-    try {
-      const { startInkChat } = await import('../ui/ink/index');
-      await startInkChat({
-        model: options.model,
-        systemPrompt: options.systemPrompt,
-        showTokenCount: options.showTokenCount,
-        resumeSessionId,
-        initialPrompt: options.initialPrompt,
-        mode: options.mode as any,
-      });
-      return;
-    } catch {
-      // Ink TUI unavailable (compiled binary without React/Ink) — fall back to readline
-      ui.print(
-        ui.dim(
-          'Using readline mode (same features, simpler UI). For the rich TUI, run: bun src/nimbus.ts'
-        )
-      );
-      ui.newLine();
-    }
-  } else if (!process.stdin.isTTY && options.ui !== 'readline') {
-    // Piped stdin detected — inform user
-    ui.print(ui.dim('Non-interactive terminal detected, using readline mode.'));
-    ui.newLine();
-  }
-
-  const startTime = Date.now();
-  const entry = historyManager.addEntry('chat', [], {
-    model: options.model,
-    persona: options.persona,
-  });
-
-  try {
-    // Get default model from auth store if not specified
-    if (!options.model) {
-      const authStore = new AuthStore();
-      const status = authStore.getStatus();
-      // Find the default provider's model
-      const defaultProviderInfo = status.providers.find(p => p.name === status.defaultProvider);
-      options.model = defaultProviderInfo?.model;
-    }
-
-    // Read persona from config if not specified
-    if (!options.persona || !options.verbosity) {
-      try {
-        const { configManager } = await import('../config/manager');
-        if (!options.persona) {
-          const mode = configManager.get('persona.mode');
-          if (mode) {
-            options.persona = mode;
-          }
-        }
-        if (!options.verbosity) {
-          const verbosity = configManager.get('persona.verbosity');
-          if (verbosity) {
-            options.verbosity = verbosity;
-          }
-        }
-      } catch {
-        // Config read failure is non-critical
-      }
-    }
-    const persona = options.persona || 'assistant';
-    const verbosity = options.verbosity || 'normal';
-
-    // Non-interactive mode: send single message
-    if (options.nonInteractive || options.message) {
-      if (!options.message) {
-        ui.error('Message is required in non-interactive mode. Use --message or -m.');
-        process.exit(1);
-      }
-
-      await sendSingleMessage(options.message, options, persona, verbosity);
-      historyManager.completeEntry(entry.id, 'success', Date.now() - startTime);
-      return;
-    }
-
-    // Interactive mode: start chat UI
-    const chatOptions: ChatUIOptions = {
-      model: options.model,
-      systemPrompt: options.systemPrompt || getPersonaSystemPrompt(persona, verbosity),
-      showTokenCount: options.showTokenCount ?? false,
-      resumeSessionId,
-    };
-
-    await startChat(chatOptions);
-    historyManager.completeEntry(entry.id, 'success', Date.now() - startTime);
-  } catch (error: any) {
-    historyManager.completeEntry(entry.id, 'failure', Date.now() - startTime, {
-      error: error.message,
-    });
-
-    // Detect auth/API key errors and suggest re-onboarding
-    const errMsg = error.message || String(error);
-    if (/auth|api.?key|unauthorized|forbidden|401|403|invalid.*key/i.test(errMsg)) {
-      ui.newLine();
-      ui.error('LLM authentication failed. Your API key may be invalid or expired.');
-      ui.newLine();
-      ui.print('To reconfigure:');
-      ui.print(`  ${ui.bold('nimbus login')}  — re-run the setup wizard`);
-      ui.print(`  ${ui.bold('export ANTHROPIC_API_KEY=sk-ant-...')}  — set a new key`);
-      ui.newLine();
-      return;
-    }
-
-    throw error;
-  }
-}
-
-/**
- * Send a single message and display the response (non-interactive mode)
- *
- * Uses the full agent loop so that tool-calling is available even in
- * non-interactive / single-message mode (`nimbus chat -m "..."`).
- */
-async function sendSingleMessage(
-  message: string,
-  options: ChatOptions,
-  _persona: 'professional' | 'assistant' | 'expert',
-  _verbosity: 'minimal' | 'normal' | 'detailed'
-): Promise<void> {
-  const { getAppContext } = await import('../app');
-  const { runAgentLoop } = await import('../agent/loop');
-  const { defaultToolRegistry } = await import('../tools/schemas/types');
-
-  const ctx = getAppContext();
-  if (!ctx) {
-    ui.error('App not initialised. Cannot send message.');
-    process.exit(1);
-  }
-
-  const outputParts: string[] = [];
-
-  try {
-    const result = await runAgentLoop(message, [], {
-      router: ctx.router,
-      toolRegistry: defaultToolRegistry,
-      mode: 'build',
-      model: options.model,
-      cwd: process.cwd(),
-
-      onText: text => {
-        process.stdout.write(text);
-        outputParts.push(text);
-      },
-
-      onToolCallStart: toolCall => {
-        process.stderr.write(`\n[Tool: ${toolCall.name}]\n`);
-      },
-
-      onToolCallEnd: (_toolCall, toolResult) => {
-        if (toolResult.isError) {
-          process.stderr.write(`[Error: ${toolResult.error}]\n`);
-        }
-      },
-    });
-
-    // Final newline
-    if (outputParts.length > 0) {
-      console.log('');
-    }
-
-    if (result.interrupted) {
-      ui.info('Operation interrupted.');
-    }
-  } catch (error: any) {
-    ui.error(error.message || 'Failed to get response');
-    process.exit(1);
-  }
-}
-
-/**
- * Build a persona-aware system prompt for Nimbus chat.
- *
- * @param persona - The persona mode that controls tone and style
- * @param verbosity - The verbosity level that controls response length
- * @returns A complete system prompt string
- */
-function getPersonaSystemPrompt(
-  persona: 'professional' | 'assistant' | 'expert',
-  verbosity: 'minimal' | 'normal' | 'detailed'
-): string {
-  // Base identity shared across all personas
-  const baseIdentity = `You are Nimbus, an AI-powered DevOps engineering agent. You help users with:
-
-- Infrastructure as Code (Terraform, Kubernetes, Helm)
-- Cloud provider operations (AWS, GCP, Azure)
-- Kubernetes operations and configurations
-- DevOps best practices and CI/CD pipelines
-- Troubleshooting infrastructure issues`;
-
-  // Persona-specific instructions
-  const personaInstructions: Record<typeof persona, string> = {
-    professional: `Maintain a formal, structured, and enterprise-focused tone at all times. Use bullet points and numbered lists to organize information clearly. Prefer formal language and avoid colloquialisms. Frame recommendations in terms of business impact, compliance, and operational excellence. When proposing changes, present them as structured plans with clear rationale, risk assessment, and rollback considerations.`,
-    assistant: `Be friendly and conversational while remaining helpful and accurate. Explain concepts in an approachable way, breaking down complex topics so they are easy to understand. When suggesting infrastructure code, walk through the reasoning behind each decision. If you need more information to provide accurate help, ask clarifying questions. Offer encouragement and context to help users learn as they go.`,
-    expert: `Be technical and concise. Assume the user has deep knowledge of cloud infrastructure, networking, and DevOps practices. Skip introductory explanations and get straight to the solution. Include advanced patterns, edge cases, and performance considerations where relevant. Reference specific API versions, provider documentation, and known gotchas. Prefer code-first responses with terse inline comments over lengthy prose.`,
-  };
-
-  // Verbosity-level instructions
-  const verbosityInstructions: Record<typeof verbosity, string> = {
-    minimal: `Keep responses brief and to the point. Omit preamble and unnecessary context. Provide the shortest correct answer, using code blocks or bullet points when possible. Avoid repeating the question or restating what the user already knows.`,
-    normal: `Provide balanced responses that include enough context to be useful without being verbose. Include a brief explanation alongside code or commands. Mention important caveats or prerequisites when relevant, but do not over-explain.`,
-    detailed: `Provide comprehensive responses with thorough explanations. Include code examples, usage patterns, and alternative approaches. Explain trade-offs, link to relevant best practices, and suggest next steps. Where applicable, show before-and-after comparisons and provide context on why a particular approach is preferred.`,
-  };
-
-  return [
-    baseIdentity,
-    '',
-    personaInstructions[persona],
-    '',
-    verbosityInstructions[verbosity],
-  ].join('\n');
-}

package/src/commands/completions.ts

@@ -1,268 +0,0 @@
-/**
- * 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(): string[] {
-  try {
-    const { execFileSync } = require('node:child_process') as typeof import('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(): string[] {
-  try {
-    const { execFileSync } = require('node:child_process') as typeof import('node:child_process');
-    return execFileSync('terraform', ['workspace', 'list'], {
-      encoding: 'utf-8',
-      timeout: 3000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    })
-      .split('\n')
-      .map((l: string) => l.replace(/^\*?\s*/, '').trim())
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * L2: Get helm releases for dynamic shell completion.
- */
-function getHelmReleases(): string[] {
-  try {
-    const { execFileSync } = require('node:child_process') as typeof import('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: string, _currWord: string): void {
-  let suggestions: string[] = [];
-
-  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(): string {
-  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(): string {
-  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(): string {
-  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: string): Promise<void> {
-  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: string[] = [
-        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>');
-  }
-}