@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/commands/usage/index.ts

@@ -1,134 +0,0 @@
-/**
- * Usage Command
- * Usage dashboard CLI command
- */
-
-import { ui } from '../../wizard/ui';
-import { billingClient } from '../../clients/enterprise-client';
-import type { UsageOptions } from '../../types';
-
-/**
- * Get current team ID from config or environment
- */
-function getCurrentTeamId(): string | null {
-  return process.env.NIMBUS_TEAM_ID || null;
-}
-
-/**
- * Parse usage options
- */
-export function parseUsageOptions(args: string[]): UsageOptions {
-  const options: UsageOptions = {};
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--period' && args[i + 1]) {
-      options.period = args[++i] as 'day' | 'week' | 'month';
-    } else if (arg === '--team' && args[i + 1]) {
-      options.teamId = args[++i];
-    } else if (arg === '--json') {
-      options.json = true;
-    } else if (arg === '--non-interactive') {
-      options.nonInteractive = true;
-    }
-  }
-
-  return options;
-}
-
-/**
- * Format number with commas
- */
-function formatNumber(n: number): string {
-  return n.toLocaleString();
-}
-
-/**
- * Format cost in USD
- */
-function formatCost(n: number): string {
-  return `$${n.toFixed(2)}`;
-}
-
-/**
- * Usage command
- */
-export async function usageCommand(options: UsageOptions): Promise<void> {
-  try {
-    const teamId = options.teamId || getCurrentTeamId();
-    if (!teamId) {
-      ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
-      ui.info('Or use: nimbus usage --team <team-id>');
-      return;
-    }
-
-    const period = options.period || 'month';
-
-    ui.startSpinner({ message: `Fetching ${period} usage...` });
-    const usage = await billingClient.getUsage(teamId, period);
-    ui.stopSpinnerSuccess('Usage retrieved');
-
-    if (options.json) {
-      console.log(JSON.stringify(usage, null, 2));
-      return;
-    }
-
-    ui.newLine();
-    ui.header(
-      'Usage Dashboard',
-      `${new Date(usage.period.start).toLocaleDateString()} - ${new Date(usage.period.end).toLocaleDateString()}`
-    );
-
-    // Summary
-    ui.section('Summary');
-    ui.print(`  Total Operations: ${formatNumber(usage.totals.operations)}`);
-    ui.print(`  Total Tokens:     ${formatNumber(usage.totals.tokensUsed)}`);
-    ui.print(`  Total Cost:       ${formatCost(usage.totals.costUsd)}`);
-
-    // By operation type
-    const operationTypes = Object.entries(usage.byOperationType);
-    if (operationTypes.length > 0) {
-      ui.section('By Operation Type');
-      ui.table({
-        columns: [
-          { key: 'type', header: 'Operation' },
-          { key: 'count', header: 'Count' },
-          { key: 'tokens', header: 'Tokens' },
-          { key: 'cost', header: 'Cost' },
-        ],
-        data: operationTypes.map(([type, data]) => ({
-          type,
-          count: formatNumber(data.count),
-          tokens: formatNumber(data.tokensUsed),
-          cost: formatCost(data.costUsd),
-        })),
-      });
-    }
-
-    // By user (if available)
-    if (usage.byUser && Object.keys(usage.byUser).length > 0) {
-      const userUsage = Object.entries(usage.byUser);
-      ui.section('By User');
-      ui.table({
-        columns: [
-          { key: 'user', header: 'User' },
-          { key: 'count', header: 'Operations' },
-          { key: 'tokens', header: 'Tokens' },
-          { key: 'cost', header: 'Cost' },
-        ],
-        data: userUsage.map(([user, data]) => ({
-          user,
-          count: formatNumber(data.count),
-          tokens: formatNumber(data.tokensUsed),
-          cost: formatCost(data.costUsd),
-        })),
-      });
-    }
-
-    ui.newLine();
-    ui.dim(`Period: ${period} | Use --period day|week|month to change`);
-  } catch (error: any) {
-    ui.stopSpinnerFail('Failed to get usage');
-    ui.error(error.message);
-  }
-}

package/src/commands/version.ts

@@ -1,174 +0,0 @@
-/**
- * Version Command
- *
- * Display CLI and component version information
- *
- * Usage: nimbus version [options]
- */
-
-import { logger } from '../utils';
-import { ui } from '../wizard';
-
-/**
- * Command options
- */
-export interface VersionOptions {
-  verbose?: boolean;
-  json?: boolean;
-}
-
-/**
- * Version information structure
- */
-interface VersionInfo {
-  cli: string;
-  node: string;
-  bun?: string;
-  platform: string;
-  arch: string;
-  components?: Record<string, string>;
-}
-
-/**
- * Get the CLI version from package.json or environment
- */
-function getCliVersion(): string {
-  // Try environment variable first (set during build)
-  if (process.env.NIMBUS_VERSION) {
-    return process.env.NIMBUS_VERSION;
-  }
-
-  // Try npm_package_version (available when run via npm/bun)
-  if (process.env.npm_package_version) {
-    return process.env.npm_package_version;
-  }
-
-  // Fallback to reading package.json
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const pkg = require('../../package.json');
-    return pkg.version || '0.1.0';
-  } catch {
-    return '0.1.0';
-  }
-}
-
-/**
- * Get Bun version if running under Bun
- */
-function getBunVersion(): string | undefined {
-  // Check for Bun global
-  const globalAny = globalThis as any;
-  if (typeof globalAny.Bun !== 'undefined') {
-    return globalAny.Bun.version;
-  }
-  return undefined;
-}
-
-/**
- * Fetch DevOps CLI tool versions (for verbose mode)
- */
-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 versions: Record<string, string> = {};
-  for (const tool of tools) {
-    try {
-      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 parsed = JSON.parse(output);
-        version =
-          parsed.terraform_version ||
-          parsed.clientVersion?.gitVersion ||
-          'installed';
-      } catch {
-        const match = output.match(/[\d]+\.[\d]+\.[\d]+/);
-        if (match) version = `v${match[0]}`;
-      }
-      versions[tool.name] = version;
-    } catch {
-      versions[tool.name] = 'not installed';
-    }
-  }
-  return versions;
-}
-
-/**
- * Run the version command
- */
-export async function versionCommand(options: VersionOptions = {}): Promise<void> {
-  logger.debug('Running version command', { options });
-
-  const cliVersion = getCliVersion();
-  const versionInfo: VersionInfo = {
-    cli: cliVersion,
-    node: process.version,
-    bun: getBunVersion(),
-    platform: process.platform,
-    arch: process.arch,
-  };
-
-  // Fetch DevOps tool versions in verbose mode
-  if (options.verbose) {
-    ui.startSpinner({ message: 'Checking DevOps tool versions...' });
-    versionInfo.components = await fetchDevOpsVersions();
-    ui.stopSpinnerSuccess('');
-  }
-
-  // JSON output — expose `version` field (alias for `cli`) for L3 compatibility
-  if (options.json) {
-    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
-  ui.print(`nimbus version ${versionInfo.cli}`);
-
-  if (options.verbose) {
-    ui.newLine();
-    ui.print(`Runtime:`);
-    if (versionInfo.bun) {
-      ui.print(`  Bun:      ${versionInfo.bun}`);
-    }
-    ui.print(`  Node:     ${versionInfo.node}`);
-    ui.print(`  Platform: ${versionInfo.platform}`);
-    ui.print(`  Arch:     ${versionInfo.arch}`);
-
-    if (versionInfo.components) {
-      ui.newLine();
-      ui.print(`DevOps Tools:`);
-      for (const [name, version] of Object.entries(versionInfo.components)) {
-        const isInstalled = version !== 'not installed';
-        const icon = isInstalled ? '[+]' : '[-]';
-        const color = isInstalled ? 'green' : 'red';
-        ui.print(`  ${ui.color(icon, color)} ${name.padEnd(12)} ${version}`);
-      }
-    }
-  }
-}
-
-// Export as default command
-export default versionCommand;

package/src/commands/watch.ts

@@ -1,153 +0,0 @@
-/**
- * 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/index.ts

@@ -1,2 +0,0 @@
-export { isBun, isNode } from './runtime';
-export { Database } from './sqlite';

package/src/compat/runtime.ts

@@ -1,12 +0,0 @@
-/**
- * Runtime Compatibility Layer
- *
- * Detects whether we're running under Bun or Node.js and provides
- * compatibility shims for Bun-specific APIs when running under Node.
- */
-
-/** Whether the current runtime is Bun. */
-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

@@ -1,177 +0,0 @@
-/**
- * SQLite Compatibility Layer
- *
- * Uses bun:sqlite when running under Bun, falls back to better-sqlite3
- * under Node.js. Both libraries have nearly identical APIs.
- *
- * Exports:
- *   - `Database` (value) -- the constructor, usable as `new Database(path)`
- *   - `Database` (type)  -- the instance interface, usable as `db: Database`
- *
- * This dual export mirrors how a native `class` declaration works in
- * TypeScript: the same identifier serves as both a value and a type.
- */
-
-import { isBun } from './runtime';
-
-// ---------------------------------------------------------------------------
-// Type definitions
-// ---------------------------------------------------------------------------
-
-/** Prepared statement returned by Database.prepare(). */
-export interface Statement {
-  run(...params: unknown[]): unknown;
-  get(...params: unknown[]): unknown;
-  all(...params: unknown[]): unknown[];
-  finalize?(): void;
-}
-
-/**
- * Minimal Database instance interface shared by bun:sqlite and better-sqlite3.
- *
- * When consumer code writes `db: Database`, TypeScript resolves
- * the *type* side of the `Database` export -- which is this interface.
- */
-interface DatabaseI {
-  exec(sql: string): void;
-  prepare(sql: string): Statement;
-  close(): void;
-  transaction<T>(fn: (...args: any[]) => T): (...args: any[]) => T;
-
-  // bun:sqlite specific methods used throughout the codebase
-  run(sql: string, params?: unknown[]): unknown;
-  query(sql: string): Statement;
-
-  // Allow accessing additional runtime-specific properties
-  [key: string]: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Runtime selection
-// ---------------------------------------------------------------------------
-
-// Re-export the Database class from the appropriate backend.
-// Both bun:sqlite and better-sqlite3 expose a compatible API:
-//   new Database(path), db.exec(sql), db.prepare(sql).run/get/all, db.close()
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _Impl: any;
-
-if (isBun) {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  _Impl = require('bun:sqlite').Database;
-} else {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const BetterSqlite3 = require('better-sqlite3');
-    // Polyfill bun:sqlite-compatible methods on better-sqlite3 instances
-    const OrigProto = BetterSqlite3.prototype;
-    if (!OrigProto.run) {
-      OrigProto.run = function (sql: string, params?: unknown[]) {
-        const stmt = this.prepare(sql);
-        return params ? stmt.run(...params) : stmt.run();
-      };
-    }
-    if (!OrigProto.query) {
-      OrigProto.query = function (sql: string) {
-        return this.prepare(sql);
-      };
-    }
-    _Impl = BetterSqlite3;
-  } catch {
-    // 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'
-      );
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Dual export: value + type under the same name
-// ---------------------------------------------------------------------------
-
-/**
- * The Database constructor at runtime.
- *
- * TypeScript resolves `Database` to either the *value* (constructor) or
- * the *type* (instance interface) depending on context:
- *   - `new Database(path)` -- uses the value
- *   - `db: Database`       -- uses the type (the interface below)
- */
-const Database = _Impl as { new (path: string): DatabaseI };
-
-/** The instance type, exported under the same name for type-position use. */
-type Database = DatabaseI;
-
-export { Database };

package/src/config/index.ts

@@ -1,17 +0,0 @@
-/**
- * Configuration Module
- *
- * Exports configuration management utilities
- */
-
-export { ConfigManager, configManager, CONFIG_KEYS } from './manager';
-export type {
-  NimbusConfig,
-  WorkspaceConfig,
-  LLMConfig,
-  HistoryConfig,
-  SafetyConfig,
-  UIConfig,
-  ConfigKey,
-  ConfigKeyInfo,
-} from './types';