@build-astron-co/nimbus 0.2.0

package/src/commands/version.ts

@@ -0,0 +1,170 @@
+/**
+ * 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 component versions from services (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' },
+  ];
+
+  const fetchWithTimeout = async (url: string, timeout = 2000): Promise<Response> => {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    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 => {
+      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';
+        }
+      } catch {
+        components[service.name] = 'unavailable';
+      }
+    })
+  );
+
+  return components;
+}
+
+/**
+ * Run the version command
+ */
+export async function versionCommand(options: VersionOptions = {}): Promise<void> {
+  logger.debug('Running version command', { options });
+
+  const versionInfo: VersionInfo = {
+    cli: getCliVersion(),
+    node: process.version,
+    bun: getBunVersion(),
+    platform: process.platform,
+    arch: process.arch,
+  };
+
+  // Fetch component versions in verbose mode
+  if (options.verbose) {
+    ui.startSpinner({ message: 'Fetching component versions...' });
+    versionInfo.components = await fetchComponentVersions();
+    ui.stopSpinnerSuccess('');
+  }
+
+  // JSON output
+  if (options.json) {
+    console.log(JSON.stringify(versionInfo, null, 2));
+    return;
+  }
+
+  // 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(`Components:`);
+      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}`);
+      }
+    }
+  }
+}
+
+// Export as default command
+export default versionCommand;

package/src/compat/index.ts

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

package/src/compat/runtime.ts

@@ -0,0 +1,12 @@
+/**
+ * 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/src/compat/sqlite.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 {
+    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

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