@build-astron-co/nimbus 0.2.0 → 0.4.0

package/src/commands/tf/index.ts

@@ -22,6 +22,7 @@ export interface TfCommandOptions {
   recursive?: boolean;
   diff?: boolean;
   type?: 'plan' | 'apply';
+  workspace?: string;
 }
 
 /**
@@ -114,28 +115,88 @@ export async function tfPlanCommand(options: TfCommandOptions = {}): Promise<voi
 }
 
 /**
- * Apply Terraform changes
+ * Apply Terraform changes — shows plan first and prompts for confirmation
+ * unless --auto-approve or a planFile is provided.
  */
 export async function tfApplyCommand(options: TfCommandOptions = {}): Promise<void> {
   const directory = options.directory || process.cwd();
+  const { confirm } = await import('../../wizard/prompts');
+  const os = await import('os');
+  const path = await import('path');
 
   ui.header('Terraform Apply');
   ui.info(`Directory: ${directory}`);
 
-  if (!options.autoApprove && !options.planFile) {
-    ui.warning('Running with -auto-approve flag or specify a plan file for non-interactive mode');
-  }
-
-  ui.startSpinner({ message: 'Applying Terraform changes...' });
-
   try {
     const available = await terraformClient.isAvailable();
     if (!available) {
-      ui.stopSpinnerFail('Terraform Tools Service not available');
+      ui.error('Terraform Tools Service not available');
       ui.error('Please ensure the Terraform Tools Service is running.');
       return;
     }
 
+    // Select workspace if specified
+    if (options.workspace) {
+      ui.startSpinner({ message: `Selecting workspace "${options.workspace}"...` });
+      await terraformClient.workspace.select(options.workspace, directory);
+      ui.stopSpinnerSuccess(`Workspace: ${options.workspace}`);
+    }
+
+    // If no planFile and not auto-approving, run plan first and prompt
+    if (!options.planFile && !options.autoApprove) {
+      const tmpPlanPath = path.join(os.tmpdir(), `nimbus-tfplan-${Date.now()}.bin`);
+
+      ui.startSpinner({ message: 'Running terraform plan...' });
+      const planResult = await terraformClient.plan(directory, {
+        varFile: options.varFile,
+        vars: options.vars,
+        out: tmpPlanPath,
+      });
+
+      if (!planResult.success) {
+        ui.stopSpinnerFail('Terraform plan failed');
+        if (planResult.error) ui.error(planResult.error);
+        return;
+      }
+
+      if (!planResult.hasChanges) {
+        ui.stopSpinnerSuccess('No changes — infrastructure is up-to-date');
+        return;
+      }
+
+      ui.stopSpinnerSuccess('Plan complete');
+      if (planResult.output) {
+        ui.box({ title: 'Terraform Plan', content: planResult.output });
+      }
+
+      const proceed = await confirm({ message: 'Apply these changes?', defaultValue: false });
+      if (!proceed) {
+        ui.info('Apply cancelled.');
+        return;
+      }
+
+      // Apply using the saved plan file
+      ui.startSpinner({ message: 'Applying Terraform changes...' });
+      const applyResult = await terraformClient.apply(directory, {
+        planFile: tmpPlanPath,
+        varFile: options.varFile,
+        vars: options.vars,
+      });
+
+      if (applyResult.success) {
+        ui.stopSpinnerSuccess('Terraform apply completed successfully');
+        if (applyResult.output) {
+          ui.box({ title: 'Apply Output', content: applyResult.output });
+        }
+      } else {
+        ui.stopSpinnerFail('Terraform apply failed');
+        if (applyResult.error) ui.error(applyResult.error);
+      }
+      return;
+    }
+
+    // auto-approve or explicit planFile path: apply directly
+    ui.startSpinner({ message: 'Applying Terraform changes...' });
     const result = await terraformClient.apply(directory, {
       planFile: options.planFile,
       autoApprove: options.autoApprove,
@@ -150,9 +211,7 @@ export async function tfApplyCommand(options: TfCommandOptions = {}): Promise<vo
       }
     } else {
       ui.stopSpinnerFail('Terraform apply failed');
-      if (result.error) {
-        ui.error(result.error);
-      }
+      if (result.error) ui.error(result.error);
     }
   } catch (error: any) {
     ui.stopSpinnerFail('Error applying Terraform changes');

package/src/commands/upgrade.ts

@@ -24,6 +24,10 @@ export interface UpgradeOptions {
   force?: boolean;
   /** Check only, don't actually upgrade */
   check?: boolean;
+  /** Show what would be upgraded without actually upgrading */
+  dryRun?: boolean;
+  /** Show the changelog for the latest version */
+  changelog?: boolean;
 }
 
 /** Detected installation method for nimbus. */
@@ -179,6 +183,35 @@ async function fetchGitHubReleaseVersion(): Promise<string | null> {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Changelog fetching
+// ---------------------------------------------------------------------------
+
+/**
+ * Fetch the raw CHANGELOG.md from GitHub. Returns the last ~20 lines on success,
+ * or null if unavailable.
+ */
+async function fetchChangelog(): Promise<string | null> {
+  try {
+    const urls = [
+      `https://raw.githubusercontent.com/${GITHUB_REPO}/main/CHANGELOG.md`,
+      `https://raw.githubusercontent.com/${GITHUB_REPO}/main/CHANGELOG`,
+    ];
+    for (const url of urls) {
+      const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+      if (response.ok) {
+        const text = await response.text();
+        const lines = text.split('\n');
+        // Return last 20 lines or the full content if shorter
+        return lines.slice(-20).join('\n');
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Installation method detection
 // ---------------------------------------------------------------------------
@@ -412,6 +445,30 @@ export async function upgradeCommand(options: UpgradeOptions = {}): Promise<void
   }
   console.log('');
 
+  // --dry-run: show what would be upgraded without upgrading
+  if (options.dryRun) {
+    console.log(
+      `${yellow('Dry run:')} Current: ${bold(VERSION)} → Latest: ${bold(green(latestVersion))}`
+    );
+    console.log(dim(`  Source: ${source === 'github' ? 'GitHub Releases' : 'npm registry'}`));
+    console.log('');
+    console.log(dim('No changes were made. Remove --dry-run to perform the upgrade.'));
+    return;
+  }
+
+  // --changelog: fetch and display the changelog
+  if (options.changelog) {
+    console.log(bold(`Changelog for nimbus ${latestVersion}:`));
+    console.log('');
+    const cl = await fetchChangelog();
+    if (cl) {
+      console.log(cl);
+    } else {
+      console.log(dim(`Changelog not available. View releases at: https://github.com/${GITHUB_REPO}/releases`));
+    }
+    return;
+  }
+
   if (options.check) {
     return;
   }

package/src/commands/version.ts

@@ -66,52 +66,45 @@ function getBunVersion(): string | undefined {
 }
 
 /**
- * Fetch component versions from services (for verbose mode)
+ * Fetch DevOps CLI tool versions (for verbose mode)
  */
-async function fetchComponentVersions(): Promise<Record<string, string>> {
-  const components: Record<string, string> = {};
-  const services = [
-    { name: 'core-engine', url: process.env.CORE_ENGINE_URL || 'http://localhost:3001' },
-    { name: 'llm-service', url: process.env.LLM_SERVICE_URL || 'http://localhost:3002' },
-    {
-      name: 'generator-service',
-      url: process.env.GENERATOR_SERVICE_URL || 'http://localhost:3003',
-    },
-    { name: 'terraform-tools', url: process.env.TERRAFORM_TOOLS_URL || 'http://localhost:3006' },
-    { name: 'k8s-tools', url: process.env.K8S_TOOLS_URL || 'http://localhost:3007' },
-    { name: 'helm-tools', url: process.env.HELM_TOOLS_URL || 'http://localhost:3008' },
+async function fetchDevOpsVersions(): Promise<Record<string, string>> {
+  const { execFileSync } = await import('child_process');
+  const tools = [
+    { name: 'terraform', args: ['version', '-json'] },
+    { name: 'kubectl', args: ['version', '--client', '--output=json'] },
+    { name: 'helm', args: ['version', '--short'] },
+    { name: 'aws', args: ['--version'] },
+    { name: 'gcloud', args: ['version'] },
+    { name: 'az', args: ['version'] },
   ];
 
-  const fetchWithTimeout = async (url: string, timeout = 2000): Promise<Response> => {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const versions: Record<string, string> = {};
+  for (const tool of tools) {
     try {
-      const response = await fetch(url, { signal: controller.signal });
-      clearTimeout(timeoutId);
-      return response;
-    } catch {
-      clearTimeout(timeoutId);
-      throw new Error('Timeout');
-    }
-  };
-
-  await Promise.all(
-    services.map(async service => {
+      const output = execFileSync(tool.name, tool.args, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      // Try to parse version string from JSON output
+      let version = 'installed';
       try {
-        const response = await fetchWithTimeout(`${service.url}/health`);
-        if (response.ok) {
-          const data = (await response.json()) as { version?: string; status?: string };
-          components[service.name] = data.version || 'running';
-        } else {
-          components[service.name] = 'unavailable';
-        }
+        const parsed = JSON.parse(output);
+        version =
+          parsed.terraform_version ||
+          parsed.clientVersion?.gitVersion ||
+          'installed';
       } catch {
-        components[service.name] = 'unavailable';
+        const match = output.match(/[\d]+\.[\d]+\.[\d]+/);
+        if (match) version = `v${match[0]}`;
       }
-    })
-  );
-
-  return components;
+      versions[tool.name] = version;
+    } catch {
+      versions[tool.name] = 'not installed';
+    }
+  }
+  return versions;
 }
 
 /**
@@ -120,25 +113,35 @@ async function fetchComponentVersions(): Promise<Record<string, string>> {
 export async function versionCommand(options: VersionOptions = {}): Promise<void> {
   logger.debug('Running version command', { options });
 
+  const cliVersion = getCliVersion();
   const versionInfo: VersionInfo = {
-    cli: getCliVersion(),
+    cli: cliVersion,
     node: process.version,
     bun: getBunVersion(),
     platform: process.platform,
     arch: process.arch,
   };
 
-  // Fetch component versions in verbose mode
+  // Fetch DevOps tool versions in verbose mode
   if (options.verbose) {
-    ui.startSpinner({ message: 'Fetching component versions...' });
-    versionInfo.components = await fetchComponentVersions();
+    ui.startSpinner({ message: 'Checking DevOps tool versions...' });
+    versionInfo.components = await fetchDevOpsVersions();
     ui.stopSpinnerSuccess('');
   }
 
-  // JSON output
+  // JSON output — expose `version` field (alias for `cli`) for L3 compatibility
   if (options.json) {
-    console.log(JSON.stringify(versionInfo, null, 2));
-    return;
+    const jsonOutput: Record<string, unknown> = {
+      version: cliVersion,
+      node: versionInfo.node,
+      platform: versionInfo.platform,
+      arch: versionInfo.arch,
+      cli: versionInfo.cli,
+    };
+    if (versionInfo.bun) jsonOutput.bun = versionInfo.bun;
+    if (versionInfo.components) jsonOutput.components = versionInfo.components;
+    console.log(JSON.stringify(jsonOutput, null, 2));
+    process.exit(0);
   }
 
   // Human-readable output
@@ -156,11 +159,12 @@ export async function versionCommand(options: VersionOptions = {}): Promise<void
 
     if (versionInfo.components) {
       ui.newLine();
-      ui.print(`Components:`);
+      ui.print(`DevOps Tools:`);
       for (const [name, version] of Object.entries(versionInfo.components)) {
-        const status =
-          version === 'unavailable' ? ui.color(version, 'red') : ui.color(version, 'green');
-        ui.print(`  ${name.padEnd(18)} ${status}`);
+        const isInstalled = version !== 'not installed';
+        const icon = isInstalled ? '[+]' : '[-]';
+        const color = isInstalled ? 'green' : 'red';
+        ui.print(`  ${ui.color(icon, color)} ${name.padEnd(12)} ${version}`);
       }
     }
   }

package/src/commands/watch.ts

@@ -0,0 +1,153 @@
+/**
+ * nimbus watch — Watch files and trigger agent runs on change (M3)
+ *
+ * Usage:
+ *   nimbus watch "*.tf" --run "validate the terraform changes"
+ *   nimbus watch "src/**" --run "run tests" --debounce 2000
+ */
+
+import { basename } from 'node:path';
+import { FSWatcher, watch as fsWatch } from 'node:fs';
+
+export interface WatchOptions {
+  /** Glob pattern to watch (e.g. "*.tf") */
+  glob: string;
+  /** Agent prompt to run on change */
+  run?: string;
+  /** Debounce delay in ms (default 500) */
+  debounce?: number;
+  /** Auto-approve agent runs */
+  autoApprove?: boolean;
+  /** Maximum number of runs before stopping (0 = unlimited) */
+  maxRuns?: number;
+}
+
+/**
+ * Simple glob pattern matching without external dependencies.
+ * Supports: *.ext, *.*, prefix/**, prefix/name.ext
+ */
+function matchGlob(filename: string, pattern: string): boolean {
+  // Normalize separators
+  const f = filename.replace(/\\/g, '/');
+  const p = pattern.replace(/\\/g, '/');
+
+  // Convert glob pattern to regex
+  const regexStr = p
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape regex special chars (but not * and ?)
+    .replace(/\*\*/g, '__GLOBSTAR__')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]')
+    .replace(/__GLOBSTAR__/g, '.*');
+
+  const re = new RegExp(`^${regexStr}$`);
+  // Also match against basename for simple patterns like "*.tf"
+  const base = basename(f);
+  return re.test(f) || (!/\//.test(p) && re.test(base));
+}
+
+/**
+ * Start watching files matching the glob pattern.
+ * On change, triggers an agent run with the configured prompt.
+ */
+export async function watchCommand(options: WatchOptions): Promise<void> {
+  const { glob, run, debounce = 500, autoApprove = false, maxRuns = 0 } = options;
+
+  if (!glob) {
+    console.error('Usage: nimbus watch <glob> --run "prompt"');
+    process.exit(1);
+  }
+
+  if (!run) {
+    console.error('Error: --run "prompt" is required for watch command');
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  console.log(`Watching ${glob} in ${cwd}...`);
+  console.log(`On change, will run: "${run}"`);
+  console.log('Press Ctrl+C to stop.\n');
+
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  let runCount = 0;
+  let isRunning = false;
+
+  async function triggerRun(changedFile: string): Promise<void> {
+    if (isRunning) {
+      return; // Skip concurrent runs
+    }
+    if (maxRuns > 0 && runCount >= maxRuns) {
+      console.log(`\nMaximum runs (${maxRuns}) reached. Stopping watcher.`);
+      process.exit(0);
+    }
+
+    runCount++;
+    isRunning = true;
+    const prompt = `${run}\n\nChanged file: ${changedFile}`;
+
+    try {
+      console.log(`\n[${new Date().toLocaleTimeString()}] Change detected: ${changedFile}`);
+      console.log(`Running: nimbus run "${run}"\n`);
+
+      const { initApp } = await import('../app');
+      const { executeRun } = await import('../cli/run');
+      const { router } = await initApp();
+      await executeRun(router, {
+        prompt,
+        format: 'text',
+        autoApprove,
+        stdin: false,
+        stdinJson: false,
+        mode: 'build',
+        maxTurns: 10,
+        rawToolOutput: false,
+        schema: false,
+        dryRun: false,
+        exitOnError: false,
+      });
+    } catch (error) {
+      console.error(`Run failed: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      isRunning = false;
+    }
+  }
+
+  function onChange(filename: string | null): void {
+    if (!filename) return;
+
+    // Check if the file matches the glob pattern
+    if (!matchGlob(filename, glob)) return;
+
+    // Debounce rapid successive changes
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      triggerRun(filename).catch(err => {
+        console.error('Watch trigger error:', err);
+      });
+    }, debounce);
+  }
+
+  let watcher: FSWatcher;
+  try {
+    watcher = fsWatch(cwd, { recursive: true }, (_eventType, filename) => {
+      onChange(filename);
+    });
+  } catch (error) {
+    console.error(`Failed to start watcher: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+
+  // Handle shutdown gracefully
+  process.on('SIGINT', () => {
+    console.log('\nWatcher stopped.');
+    watcher.close();
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    watcher.close();
+    process.exit(0);
+  });
+
+  // Keep process alive
+  await new Promise<void>(() => { /* intentionally never resolves */ });
+}

package/src/compat/runtime.ts

@@ -6,7 +6,7 @@
  */
 
 /** Whether the current runtime is Bun. */
-export const isBun = typeof globalThis.Bun !== 'undefined';
+export const isBun = typeof (globalThis as any).Bun !== 'undefined';
 
 /** Whether the current runtime is Node.js (without Bun). */
 export const isNode = !isBun && typeof process !== 'undefined' && !!process.versions?.node;

package/src/compat/sqlite.ts

@@ -79,11 +79,81 @@ if (isBun) {
     }
     _Impl = BetterSqlite3;
   } catch {
-    throw new Error(
-      'Nimbus requires either the Bun runtime (bun:sqlite) or the better-sqlite3 package.\n' +
-        'Install better-sqlite3: npm install better-sqlite3\n' +
-        'Or install Bun: curl -fsSL https://bun.sh/install | bash'
-    );
+    // G1: Path 3 — sql.js fallback (pure WASM, no native build required)
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const initSqlJs = require('sql.js');
+      process.stderr.write(
+        '[nimbus] WARNING: Running in in-memory SQLite mode (no persistence).\n' +
+        '[nimbus] Install better-sqlite3 for full functionality: npm install better-sqlite3\n'
+      );
+
+      let sqlJsDb: { run(sql: string, params?: unknown[]): void; prepare(sql: string): unknown; close(): void } | null = null;
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const getSqlJsDb = (): any => {
+        if (!sqlJsDb) throw new Error('sql.js database not yet initialised — call new Database() first');
+        return sqlJsDb;
+      };
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      class SqlJsDatabase {
+        constructor(_path: string) {
+          // Synchronously initialise — sql.js init is async but we use a trick:
+          // initSqlJs() returns a promise; we store a sentinel and resolve lazily.
+          // For simplicity, initialise synchronously with the default WASM bundle.
+          try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const SQL = (initSqlJs as any)({ locateFile: () => '' });
+            if (SQL && SQL.then) {
+              // async — best-effort; DB will be ready after first await
+              SQL.then((s: { Database: new () => typeof sqlJsDb }) => { sqlJsDb = new s.Database(); });
+            } else {
+              sqlJsDb = new (SQL as { Database: new () => typeof sqlJsDb }).Database();
+            }
+          } catch {
+            // fallback: leave sqlJsDb null, operations will throw with clear message
+          }
+        }
+        exec(sql: string): void { getSqlJsDb().run(sql); }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        prepare(sql: string): any {
+          const db = getSqlJsDb();
+          const stmt = db.prepare(sql);
+          return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            run: (...params: unknown[]) => { stmt.run(params as any[]); return {}; },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            get: (...params: unknown[]) => { stmt.bind(params as any[]); return stmt.step() ? stmt.getAsObject() : undefined; },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            all: (...params: unknown[]) => { const rows: unknown[] = []; stmt.bind(params as any[]); while (stmt.step()) rows.push(stmt.getAsObject()); return rows; },
+            finalize: () => stmt.free(),
+          };
+        }
+        close(): void { getSqlJsDb().close(); sqlJsDb = null; }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        transaction<T>(fn: (...args: any[]) => T): (...args: any[]) => T {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return (...args: any[]) => {
+            getSqlJsDb().run('BEGIN');
+            try { const r = fn(...args); getSqlJsDb().run('COMMIT'); return r; }
+            catch (e) { try { getSqlJsDb().run('ROLLBACK'); } catch { /* ignore */ } throw e; }
+          };
+        }
+        run(sql: string, params?: unknown[]): unknown {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return params ? getSqlJsDb().run(sql, params as any[]) : getSqlJsDb().run(sql);
+        }
+        query(sql: string) { return this.prepare(sql); }
+      }
+      _Impl = SqlJsDatabase;
+    } catch {
+      throw new Error(
+        'Nimbus requires either the Bun runtime (bun:sqlite) or the better-sqlite3 package.\n' +
+          'Install better-sqlite3: npm install better-sqlite3\n' +
+          'Or install Bun: curl -fsSL https://bun.sh/install | bash'
+      );
+    }
   }
 }
 

package/src/config/mode-store.ts

@@ -0,0 +1,62 @@
+/**
+ * Mode persistence per working directory.
+ *
+ * Saves and loads the agent mode (plan/build/deploy) for each project directory
+ * using a JSON file at ~/.nimbus/mode-config.json.
+ */
+
+import type { AgentMode } from '../agent/system-prompt';
+
+const MODE_CACHE = new Map<string, AgentMode>();
+
+function getConfigPath(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? '/tmp';
+  return `${home}/.nimbus/mode-config.json`;
+}
+
+function loadConfig(): Record<string, AgentMode> {
+  try {
+    const { readFileSync } = require('node:fs') as typeof import('node:fs');
+    const raw = readFileSync(getConfigPath(), 'utf-8');
+    return JSON.parse(raw) as Record<string, AgentMode>;
+  } catch {
+    return {};
+  }
+}
+
+function saveConfig(data: Record<string, AgentMode>): void {
+  try {
+    const { writeFileSync, mkdirSync } = require('node:fs') as typeof import('node:fs');
+    const { dirname } = require('node:path') as typeof import('node:path');
+    const configPath = getConfigPath();
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(data, null, 2), 'utf-8');
+  } catch {
+    // Non-critical — silently ignore
+  }
+}
+
+/**
+ * Load the saved agent mode for the given working directory.
+ * Returns null if no mode has been saved for this directory.
+ */
+export function loadModeForCwd(cwd: string): AgentMode | null {
+  if (MODE_CACHE.has(cwd)) return MODE_CACHE.get(cwd) ?? null;
+  const config = loadConfig();
+  const mode = config[cwd] as AgentMode | undefined;
+  if (mode && ['plan', 'build', 'deploy'].includes(mode)) {
+    MODE_CACHE.set(cwd, mode);
+    return mode;
+  }
+  return null;
+}
+
+/**
+ * Save the agent mode for the given working directory.
+ */
+export function saveModeForCwd(cwd: string, mode: AgentMode): void {
+  MODE_CACHE.set(cwd, mode);
+  const config = loadConfig();
+  config[cwd] = mode;
+  saveConfig(config);
+}