@build-astron-co/nimbus 0.4.2 → 0.4.3

package/src/mcp/manager.ts

@@ -1,133 +0,0 @@
-/**
- * MCP Manager
- *
- * Manages multiple MCP server connections and provides a unified
- * interface for tool discovery and registration.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { homedir } from 'node:os';
-import { MCPClient, type MCPServerConfig } from './client';
-import type { ToolDefinition, ToolRegistry } from '../tools/schemas/types';
-
-/** Configuration file format for MCP servers */
-export interface MCPConfig {
-  mcpServers?: Record<string, Omit<MCPServerConfig, 'name'>>;
-}
-
-export class MCPManager {
-  private clients: Map<string, MCPClient> = new Map();
-  private initialized = false;
-
-  /**
-   * Load MCP server configurations from config files.
-   * Searches: .nimbus/mcp.json, nimbus.json, ~/.nimbus/mcp.json
-   */
-  async loadConfig(cwd?: string): Promise<void> {
-    const configPaths = [
-      cwd ? path.join(cwd, '.nimbus', 'mcp.json') : null,
-      cwd ? path.join(cwd, 'nimbus.json') : null,
-      path.join(homedir(), '.nimbus', 'mcp.json'),
-    ].filter((p): p is string => p !== null);
-
-    for (const configPath of configPaths) {
-      if (fs.existsSync(configPath)) {
-        try {
-          const content = fs.readFileSync(configPath, 'utf-8');
-          const config: MCPConfig = JSON.parse(content) as MCPConfig;
-          if (config.mcpServers) {
-            for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-              if (!this.clients.has(name)) {
-                this.clients.set(name, new MCPClient({ ...serverConfig, name }));
-              }
-            }
-          }
-        } catch {
-          // Skip invalid config files
-        }
-      }
-    }
-
-    this.initialized = true;
-  }
-
-  /**
-   * Connect to all configured MCP servers and discover tools.
-   * Lazy servers are skipped until explicitly needed.
-   */
-  async connectAll(): Promise<void> {
-    if (!this.initialized) {
-      await this.loadConfig();
-    }
-
-    const connectPromises: Promise<void>[] = [];
-    for (const [name, client] of this.clients) {
-      if (!client.config.lazy) {
-        connectPromises.push(
-          client
-            .connect()
-            .then(() => client.listTools())
-            .then(() => undefined)
-            .catch((err: unknown) => {
-              const msg = err instanceof Error ? err.message : String(err);
-              console.warn(`MCP server '${name}' failed to connect: ${msg}`);
-            })
-        );
-      }
-    }
-
-    await Promise.all(connectPromises);
-  }
-
-  /**
-   * Get all tool definitions from connected MCP servers.
-   */
-  getAllTools(): ToolDefinition[] {
-    const tools: ToolDefinition[] = [];
-    for (const client of this.clients.values()) {
-      if (client.isConnected) {
-        tools.push(...client.toToolDefinitions());
-      }
-    }
-    return tools;
-  }
-
-  /**
-   * Register all MCP tools into a tool registry.
-   */
-  registerTools(registry: ToolRegistry): void {
-    for (const tool of this.getAllTools()) {
-      try {
-        registry.register(tool);
-      } catch {
-        // Skip duplicate tool names
-      }
-    }
-  }
-
-  /**
-   * Get a specific client by server name.
-   */
-  getClient(name: string): MCPClient | undefined {
-    return this.clients.get(name);
-  }
-
-  /**
-   * Disconnect all MCP servers.
-   */
-  async disconnectAll(): Promise<void> {
-    const disconnectPromises = Array.from(this.clients.values()).map(client => client.disconnect());
-    await Promise.all(disconnectPromises);
-  }
-
-  /** Number of configured servers */
-  get serverCount(): number {
-    return this.clients.size;
-  }
-
-  /** Number of connected servers */
-  get connectedCount(): number {
-    return Array.from(this.clients.values()).filter(c => c.isConnected).length;
-  }
-}

package/src/nimbus.ts

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-/**
- * Nimbus CLI — Main Entry Point
- *
- * Single-process embedded architecture. All modules (LLM, tools, state,
- * enterprise, engine, generator) run in-process — no HTTP services needed.
- *
- * Usage:
- *   bun src/nimbus.ts --version
- *   bun src/nimbus.ts --help
- *   bun src/nimbus.ts chat
- *   bun src/nimbus.ts ask "what is terraform"
- *   bun src/nimbus.ts generate terraform --provider aws
- *   bun src/nimbus.ts tf plan
- */
-
-import { VERSION } from './version';
-
-/**
- * Non-blocking update check. Fires a single HTTPS HEAD request to npm
- * and prints a one-liner to stderr if a newer version exists. The check
- * uses a 3-second timeout so it never slows startup.
- */
-function checkForUpdates(): void {
-  // Only check for interactive TTY sessions, not in CI
-  if (!process.stderr.isTTY || process.env.CI || process.env.NIMBUS_NO_UPDATE_CHECK) {
-    return;
-  }
-
-  // Fire-and-forget — deferred to let the TUI render first
-  (async () => {
-    try {
-      // Small delay so the check doesn't compete with startup I/O
-      await new Promise(r => setTimeout(r, 500));
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 1500);
-
-      const res = await fetch('https://registry.npmjs.org/@build-astron-co/nimbus/latest', {
-        signal: controller.signal,
-        headers: { Accept: 'application/json' },
-      });
-      clearTimeout(timeout);
-
-      if (!res.ok) {
-        return;
-      }
-
-      const data = (await res.json()) as { version?: string };
-      const latest = data.version;
-      if (!latest || latest === VERSION) {
-        return;
-      }
-
-      // Simple semver comparison: split on dots, compare numerically
-      const current = VERSION.split('.').map(Number);
-      const remote = latest.split('.').map(Number);
-      let isNewer = false;
-      for (let i = 0; i < 3; i++) {
-        if ((remote[i] ?? 0) > (current[i] ?? 0)) {
-          isNewer = true;
-          break;
-        }
-        if ((remote[i] ?? 0) < (current[i] ?? 0)) {
-          break;
-        }
-      }
-
-      if (isNewer) {
-        process.stderr.write(
-          `\x1b[33m  Update available: ${VERSION} → ${latest}. Run: nimbus upgrade\x1b[0m\n`
-        );
-      }
-    } catch {
-      // Network errors are silently ignored
-    }
-  })();
-}
-
-// ---------------------------------------------------------------------------
-// Global error handlers (Gap 6: prevent silent crashes from unhandled promises)
-// ---------------------------------------------------------------------------
-
-process.on('unhandledRejection', reason => {
-  const msg = reason instanceof Error ? reason.message : String(reason);
-  process.stderr.write(`\x1b[31mUnhandled promise rejection: ${msg}\x1b[0m\n`);
-  // Don't exit — let the TUI continue running. The user can see the error
-  // and decide whether to continue or quit.
-});
-
-process.on('uncaughtException', error => {
-  process.stderr.write(`\x1b[31mUncaught exception: ${error.message}\x1b[0m\n`);
-  if (error.stack) {
-    process.stderr.write(`\x1b[2m${error.stack}\x1b[0m\n`);
-  }
-  // For uncaught exceptions, set exit code but let cleanup run
-  process.exitCode = 1;
-});
-
-async function main() {
-  let args = process.argv.slice(2);
-
-  // G11: Global --project / --cwd flag: change working directory before command dispatch
-  const cwdFlagIdx = args.findIndex(a => a === '--project' || a === '--cwd');
-  if (cwdFlagIdx !== -1 && args[cwdFlagIdx + 1]) {
-    const { resolve } = await import('node:path');
-    const targetDir = resolve(args[cwdFlagIdx + 1]);
-    process.chdir(targetDir);
-    args.splice(cwdFlagIdx, 2);
-  }
-
-  // Handle --version and -v before anything else (no init needed)
-  if (args[0] === '--version' || args[0] === '-v') {
-    console.log(`nimbus ${VERSION}`);
-    process.exit(0);
-  }
-
-  // Handle --completion-install / completion <shell> — print shell completion script
-  if (args[0] === '--completion-install' || args[0] === 'completion') {
-    const shell = args[1] ?? 'bash';
-    const { join } = await import('node:path');
-    const { readFileSync } = await import('node:fs');
-    const { fileURLToPath } = await import('node:url');
-    const dir = join(fileURLToPath(import.meta.url), '../../completions');
-    try {
-      process.stdout.write(readFileSync(join(dir, `nimbus.${shell}`), 'utf-8'));
-    } catch {
-      console.error(`No completion script for shell: ${shell}. Available: bash, zsh, fish`);
-      process.exit(1);
-    }
-    process.exit(0);
-  }
-
-  // Show help when explicitly requested — handles both `nimbus --help`
-  // and subcommand-level help like `nimbus chat --help` or `nimbus tf -h`.
-  if (args.includes('--help') || args.includes('-h')) {
-    const otherArgs = args.filter(a => a !== '--help' && a !== '-h');
-    args.length = 0;
-    args.push('help', ...otherArgs);
-  }
-
-  // Kick off a non-blocking update check (fire-and-forget)
-  checkForUpdates();
-
-  // Default no-args: launch chat (or onboarding if first run)
-  if (args.length === 0) {
-    const { needsOnboarding } = await import('./commands/onboarding');
-    if (needsOnboarding()) {
-      args[0] = 'onboarding';
-    } else {
-      args[0] = 'chat';
-    }
-  }
-
-  // Initialize the application (SQLite, LLM router, etc.)
-  const { initApp, shutdownApp } = await import('./app');
-
-  // Register shutdown hooks for clean exit.
-  // Use process.exitCode instead of process.exit() to avoid racing
-  // with finally blocks and async cleanup in the TUI.
-  let cleaningUp = false;
-  const cleanup = async () => {
-    if (cleaningUp) {
-      return;
-    } // Prevent double-cleanup on rapid Ctrl+C
-    cleaningUp = true;
-    await shutdownApp();
-    process.exitCode = 0;
-  };
-
-  process.on('SIGINT', cleanup);
-  process.on('SIGTERM', cleanup);
-
-  try {
-    // Commands that don't need full initialization
-    const noInitCommands = new Set([
-      'help',
-      'version',
-      'doctor',
-      'onboarding',
-      'login',
-      'upgrade',
-      'update',
-    ]);
-
-    if (!noInitCommands.has(args[0])) {
-      // Show brief startup indicator for interactive commands
-      if (args[0] === 'chat' && process.stderr.isTTY) {
-        process.stderr.write('\x1b[2mStarting Nimbus...\x1b[0m');
-      }
-      await initApp();
-      if (args[0] === 'chat' && process.stderr.isTTY) {
-        process.stderr.write('\r\x1b[K');
-      }
-    }
-
-    // Resolve aliases before dispatching (L2)
-    try {
-      const { resolveAlias } = await import('./commands/alias');
-      args = resolveAlias(args);
-    } catch {
-      /* alias file not found — ignore */
-    }
-
-    // Import and run CLI command router
-    const { runCommand } = await import('./cli');
-    await runCommand(args);
-
-    // After onboarding, clear auth cache, initialize app, and launch chat
-    if (args[0] === 'onboarding') {
-      // Clear the auth-bridge cache so the router picks up freshly-saved credentials
-      try {
-        const { clearAuthCache } = await import('./llm/auth-bridge');
-        clearAuthCache();
-      } catch {
-        /* non-critical */
-      }
-      await initApp();
-      await runCommand(['chat']);
-    }
-  } catch (error: any) {
-    const msg = error.message || String(error);
-    if (error.code === 'MODULE_NOT_FOUND') {
-      console.error(`Error: Missing module — ${msg}`);
-      console.error('Run "npm install" to install dependencies.');
-    } else {
-      console.error(`Error: ${msg}`);
-    }
-    process.exit(1);
-  } finally {
-    await shutdownApp();
-  }
-}
-
-main();

package/src/plugins/index.ts

@@ -1,27 +0,0 @@
-/**
- * Nimbus Plugin System — Public API
- *
- * Re-exports the primary class and types needed by the rest of the
- * application and by external consumers that want to integrate with the
- * plugin system without importing internal submodules directly.
- *
- * @module plugins
- */
-
-// Manager (class + singleton)
-export { PluginManager, pluginManager } from './manager';
-export type { PluginInfo, PluginInitResult } from './manager';
-
-// Loader (class — exposed for testing and advanced use)
-export { PluginLoader } from './loader';
-
-// Public types
-export type {
-  NimbusPlugin,
-  PluginToolDefinition,
-  PluginProviderDefinition,
-  PluginManifest,
-  PluginPermissionTier,
-  LoadedPlugin,
-  PluginLoadError,
-} from './types';