@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/version.js

@@ -0,0 +1,145 @@
+/**
+ * Version Command
+ *
+ * Display CLI and component version information
+ *
+ * Usage: nimbus version [options]
+ */
+import { logger } from '../utils';
+import { ui } from '../wizard';
+/**
+ * Get the CLI version from package.json or environment
+ */
+function getCliVersion() {
+    // 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() {
+    // Check for Bun global
+    const globalAny = globalThis;
+    if (typeof globalAny.Bun !== 'undefined') {
+        return globalAny.Bun.version;
+    }
+    return undefined;
+}
+/**
+ * Fetch DevOps CLI tool versions (for verbose mode)
+ */
+async function fetchDevOpsVersions() {
+    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 = {};
+    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 = {}) {
+    logger.debug('Running version command', { options });
+    const cliVersion = getCliVersion();
+    const 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 = {
+            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/dist/src/commands/watch.js

@@ -0,0 +1,127 @@
+/**
+ * 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 { watch as fsWatch } from 'node:fs';
+/**
+ * Simple glob pattern matching without external dependencies.
+ * Supports: *.ext, *.*, prefix/**, prefix/name.ext
+ */
+function matchGlob(filename, pattern) {
+    // 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) {
+    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 = null;
+    let runCount = 0;
+    let isRunning = false;
+    async function triggerRun(changedFile) {
+        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) {
+        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;
+    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(() => { });
+}

package/dist/src/compat/index.js

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

package/dist/src/compat/runtime.js

@@ -0,0 +1,10 @@
+/**
+ * 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.Bun !== 'undefined';
+/** Whether the current runtime is Node.js (without Bun). */
+export const isNode = !isBun && typeof process !== 'undefined' && !!process.versions?.node;

package/dist/src/compat/sqlite.js

@@ -0,0 +1,144 @@
+/**
+ * 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';
+// ---------------------------------------------------------------------------
+// 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;
+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, params) {
+                const stmt = this.prepare(sql);
+                return params ? stmt.run(...params) : stmt.run();
+            };
+        }
+        if (!OrigProto.query) {
+            OrigProto.query = function (sql) {
+                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 = null;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const getSqlJsDb = () => {
+                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) {
+                    // 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({ locateFile: () => '' });
+                        if (SQL && SQL.then) {
+                            // async — best-effort; DB will be ready after first await
+                            SQL.then((s) => { sqlJsDb = new s.Database(); });
+                        }
+                        else {
+                            sqlJsDb = new SQL.Database();
+                        }
+                    }
+                    catch {
+                        // fallback: leave sqlJsDb null, operations will throw with clear message
+                    }
+                }
+                exec(sql) { getSqlJsDb().run(sql); }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                prepare(sql) {
+                    const db = getSqlJsDb();
+                    const stmt = db.prepare(sql);
+                    return {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        run: (...params) => { stmt.run(params); return {}; },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        get: (...params) => { stmt.bind(params); return stmt.step() ? stmt.getAsObject() : undefined; },
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        all: (...params) => { const rows = []; stmt.bind(params); while (stmt.step())
+                            rows.push(stmt.getAsObject()); return rows; },
+                        finalize: () => stmt.free(),
+                    };
+                }
+                close() { getSqlJsDb().close(); sqlJsDb = null; }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                transaction(fn) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return (...args) => {
+                        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, params) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return params ? getSqlJsDb().run(sql, params) : getSqlJsDb().run(sql);
+                }
+                query(sql) { 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;
+export { Database };

package/dist/src/config/index.js

@@ -0,0 +1,6 @@
+/**
+ * Configuration Module
+ *
+ * Exports configuration management utilities
+ */
+export { ConfigManager, configManager, CONFIG_KEYS } from './manager';