@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/aws-terraform.ts

@@ -7,7 +7,6 @@
  */
 
 import { logger } from '../utils';
-import { RestClient } from '../clients';
 import {
   createWizard,
   ui,
@@ -18,14 +17,11 @@ import {
   type StepResult,
 } from '../wizard';
 import { awsDiscoverCommand, type AwsDiscoverOptions } from './aws-discover';
+import { generateTerraformProject } from '../generator/terraform';
 import { readFile, writeFile } from 'node:fs/promises';
 import * as path from 'path';
 import * as fs from 'fs';
 
-// AWS Tools Service client
-const awsToolsUrl = process.env.AWS_TOOLS_SERVICE_URL || 'http://localhost:3009';
-const awsClient = new RestClient(awsToolsUrl);
-
 /**
  * Terraform generation context
  */
@@ -364,85 +360,54 @@ async function outputLocationStep(ctx: AwsTerraformContext): Promise<StepResult>
 }
 
 /**
- * Step 3: Generate Terraform
+ * Step 3: Generate Terraform using local generator
  */
 async function generateStep(ctx: AwsTerraformContext): Promise<StepResult> {
   ui.startSpinner({ message: 'Generating Terraform configurations...' });
 
   try {
-    let response: any;
-
-    // Generate from discovery session or direct resources
-    if (ctx.discoverySessionId) {
-      response = await awsClient.post<{
-        terraformSessionId: string;
-        files: Record<string, string>;
-        summary: GenerationSummary;
-        imports: any[];
-        importScript: string;
-      }>('/api/aws/terraform/generate', {
-        sessionId: ctx.discoverySessionId,
-        options: {
-          organizeByService: ctx.organizeByService,
-          generateImportBlocks: ctx.generateImportBlocks,
-          terraformVersion: ctx.terraformVersion,
-          awsProviderVersion: ctx.awsProviderVersion,
-        },
-      });
-    } else if (ctx.resources && ctx.resources.length > 0) {
-      response = await awsClient.post<{
-        terraformSessionId: string;
-        files: Record<string, string>;
-        summary: GenerationSummary;
-        imports: any[];
-        importScript: string;
-      }>('/api/aws/terraform/generate-direct', {
-        resources: ctx.resources,
-        options: {
-          organizeByService: ctx.organizeByService,
-          generateImportBlocks: ctx.generateImportBlocks,
-          terraformVersion: ctx.terraformVersion,
-          awsProviderVersion: ctx.awsProviderVersion,
-        },
-      });
-    } else {
-      ui.stopSpinnerFail('No resources to generate from');
-      return { success: false, error: 'No resources available' };
+    // Derive components from discovered resources
+    const resourceTypes = (ctx.resources ?? []).map(r => r.type);
+    const components: string[] = [];
+    if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet'))) components.push('vpc');
+    if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance'))) components.push('ec2');
+    if (resourceTypes.some(t => t.includes('S3'))) components.push('s3');
+    if (resourceTypes.some(t => t.includes('RDS'))) components.push('rds');
+    if (resourceTypes.some(t => t.includes('EKS'))) components.push('eks');
+    if (components.length === 0) components.push('vpc', 's3');
+
+    const generatedProject = await generateTerraformProject({
+      projectName: 'infrastructure',
+      provider: 'aws',
+      region: ctx.resources?.[0]?.region || 'us-east-1',
+      components,
+    });
+
+    const fileMap: Record<string, string> = {};
+    for (const file of generatedProject.files) {
+      fileMap[file.path] = file.content;
     }
 
-    if (!response.success || !response.data) {
-      ui.stopSpinnerFail(`Generation failed: ${response.error || 'Unknown error'}`);
-      return { success: false, error: response.error || 'Generation failed' };
-    }
-
-    const { terraformSessionId, files, summary, importScript } = response.data;
+    const summary: GenerationSummary = {
+      totalResources: ctx.resources?.length ?? 0,
+      mappedResources: ctx.resources?.length ?? 0,
+      unmappedResources: 0,
+      filesGenerated: generatedProject.files.length,
+      servicesIncluded: components,
+      regionsIncluded: [...new Set((ctx.resources ?? []).map(r => r.region).filter(Boolean))],
+    };
 
-    ui.stopSpinnerSuccess(`Generated ${Object.keys(files).length} files`);
+    ui.stopSpinnerSuccess(`Generated ${Object.keys(fileMap).length} file(s)`);
 
     // Add starter kit files if requested
-    const allFiles = { ...files };
-
-    if (ctx.includeReadme) {
-      allFiles['README.md'] = generateReadme(summary);
-    }
-
-    if (ctx.includeGitignore) {
-      allFiles['.gitignore'] = generateGitignore();
-    }
-
-    if (ctx.includeMakefile) {
-      allFiles['Makefile'] = generateMakefile();
-    }
-
-    if (ctx.generateImportScript && importScript) {
-      allFiles['import.sh'] = importScript;
-    }
+    if (ctx.includeReadme) fileMap['README.md'] = generateReadme(summary);
+    if (ctx.includeGitignore) fileMap['.gitignore'] = generateGitignore();
+    if (ctx.includeMakefile) fileMap['Makefile'] = generateMakefile();
 
     return {
       success: true,
       data: {
-        terraformSessionId,
-        generatedFiles: allFiles,
+        generatedFiles: fileMap,
         summary,
       },
     };
@@ -722,39 +687,41 @@ async function runNonInteractive(options: AwsTerraformOptions): Promise<void> {
     resources = inventory.resources;
   }
 
-  // Generate Terraform
+  // Generate Terraform using local generator
   ui.startSpinner({ message: 'Generating Terraform configurations...' });
 
   try {
-    let response: any;
-
-    if (options.sessionId) {
-      response = await awsClient.post('/api/aws/terraform/generate', {
-        sessionId: options.sessionId,
-        options: {
-          organizeByService: options.organizeByService ?? true,
-          generateImportBlocks: options.importBlocks ?? true,
-          terraformVersion: options.terraformVersion || '1.5.0',
-        },
-      });
-    } else if (resources) {
-      response = await awsClient.post('/api/aws/terraform/generate-direct', {
-        resources,
-        options: {
-          organizeByService: options.organizeByService ?? true,
-          generateImportBlocks: options.importBlocks ?? true,
-          terraformVersion: options.terraformVersion || '1.5.0',
-        },
-      });
+    const resourceTypes = (resources ?? []).map(r => r.type);
+    const components: string[] = [];
+    if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet'))) components.push('vpc');
+    if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance'))) components.push('ec2');
+    if (resourceTypes.some(t => t.includes('S3'))) components.push('s3');
+    if (resourceTypes.some(t => t.includes('RDS'))) components.push('rds');
+    if (resourceTypes.some(t => t.includes('EKS'))) components.push('eks');
+    if (components.length === 0) components.push('vpc', 's3');
+
+    const generatedProject = await generateTerraformProject({
+      projectName: 'infrastructure',
+      provider: 'aws',
+      region: resources?.[0]?.region || 'us-east-1',
+      components,
+    });
+
+    const files: Record<string, string> = {};
+    for (const file of generatedProject.files) {
+      files[file.path] = file.content;
     }
 
-    if (!response.success || !response.data) {
-      ui.stopSpinnerFail('Generation failed');
-      process.exit(1);
-    }
+    const summary: GenerationSummary = {
+      totalResources: resources?.length ?? 0,
+      mappedResources: resources?.length ?? 0,
+      unmappedResources: 0,
+      filesGenerated: generatedProject.files.length,
+      servicesIncluded: components,
+      regionsIncluded: [...new Set((resources ?? []).map(r => r.region).filter(Boolean))],
+    };
 
-    const { files, summary, importScript } = response.data;
-    ui.stopSpinnerSuccess(`Generated ${Object.keys(files).length} files`);
+    ui.stopSpinnerSuccess(`Generated ${Object.keys(files).length} file(s)`);
 
     // Write files
     const outputPath = options.output || './terraform-aws';
@@ -764,38 +731,21 @@ async function runNonInteractive(options: AwsTerraformOptions): Promise<void> {
       fs.mkdirSync(outputPath, { recursive: true });
     }
 
-    // Add starter kit if requested
-    if (options.includeStarterKit || options.includeReadme) {
-      files['README.md'] = generateReadme(summary);
-    }
-    if (options.includeStarterKit || options.includeGitignore) {
-      files['.gitignore'] = generateGitignore();
-    }
-    if (options.includeStarterKit || options.includeMakefile) {
-      files['Makefile'] = generateMakefile();
-    }
-    if (importScript && (options.importScript ?? true)) {
-      files['import.sh'] = importScript;
-    }
+    if (options.includeStarterKit || options.includeReadme) files['README.md'] = generateReadme(summary);
+    if (options.includeStarterKit || options.includeGitignore) files['.gitignore'] = generateGitignore();
+    if (options.includeStarterKit || options.includeMakefile) files['Makefile'] = generateMakefile();
 
     for (const [fileName, content] of Object.entries(files)) {
       const filePath = path.join(outputPath, fileName);
       await writeFile(filePath, content as string, 'utf-8');
     }
 
-    if (files['import.sh']) {
-      fs.chmodSync(path.join(outputPath, 'import.sh'), '755');
-    }
-
     ui.stopSpinnerSuccess(`Wrote ${Object.keys(files).length} files to ${outputPath}`);
 
-    // Show summary
     ui.newLine();
     ui.success('Generation complete!');
     ui.print(`  Output: ${outputPath}`);
-    ui.print(
-      `  Resources: ${summary.mappedResources} mapped, ${summary.unmappedResources} unmapped`
-    );
+    ui.print(`  Resources: ${summary.mappedResources} mapped`);
   } catch (error: any) {
     ui.stopSpinnerFail(`Generation failed: ${error.message}`);
     process.exit(1);

package/src/commands/chat.ts

@@ -30,6 +30,10 @@ export interface ChatOptions {
   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';
 }
 
 /**
@@ -108,6 +112,8 @@ export async function chatCommand(options: ChatOptions = {}): Promise<void> {
         systemPrompt: options.systemPrompt,
         showTokenCount: options.showTokenCount,
         resumeSessionId,
+        initialPrompt: options.initialPrompt,
+        mode: options.mode as any,
       });
       return;
     } catch {
@@ -282,11 +288,11 @@ function getPersonaSystemPrompt(
   verbosity: 'minimal' | 'normal' | 'detailed'
 ): string {
   // Base identity shared across all personas
-  const baseIdentity = `You are Nimbus, an AI-powered cloud engineering assistant. You help users with:
+  const baseIdentity = `You are Nimbus, an AI-powered DevOps engineering agent. You help users with:
 
-- Infrastructure as Code (Terraform, CloudFormation, Pulumi)
-- Kubernetes operations and configurations
+- 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`;
 

package/src/commands/completions.ts

@@ -0,0 +1,268 @@
+/**
+ * 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>');
+  }
+}

package/src/commands/config.ts

@@ -115,6 +115,32 @@ export async function configSetCommand(options: ConfigSetOptions): Promise<void>
     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);