@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/app.js

@@ -0,0 +1,152 @@
+/**
+ * App Lifecycle
+ *
+ * Handles initialization and shutdown of the embedded Nimbus application.
+ * Lazily initializes the SQLite database and the LLM router.
+ */
+import { mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+/** The resolved path to ~/.nimbus */
+const NIMBUS_DIR = join(homedir(), '.nimbus');
+/** Holds the initialized app context, or null if not yet initialized. */
+let appContext = null;
+/**
+ * Startup warnings collected during initApp() — surfaced as first system
+ * message when the TUI starts (Gap 19).
+ */
+export let startupWarnings = [];
+/**
+ * Initialize the Nimbus application.
+ *
+ * - Ensures the ~/.nimbus directory exists.
+ * - Opens (or creates) the local SQLite database via the state module.
+ * - Loads config and creates the LLM router instance.
+ * - Runs pre-flight health checks and exits on critical failures (Gap 19).
+ *
+ * This function is lazy: calling it multiple times returns the same context.
+ */
+export async function initApp() {
+    if (appContext) {
+        return appContext;
+    }
+    // Gap 19: Pre-flight startup checks (fast, no network calls)
+    try {
+        const { runStartupChecks } = await import('./commands/doctor');
+        const issues = await runStartupChecks();
+        if (issues.critical.length > 0) {
+            const lines = [
+                '\x1b[31m\x1b[1mNimbus cannot start:\x1b[0m',
+                ...issues.critical.map(i => `  \x1b[31m✗ ${i}\x1b[0m`),
+                '',
+                '\x1b[2mRun `nimbus doctor` for detailed diagnosis.\x1b[0m',
+            ];
+            process.stderr.write(lines.join('\n') + '\n');
+            process.exit(1);
+        }
+        startupWarnings = issues.warnings;
+    }
+    catch {
+        // Startup checks are non-critical — never let them block startup
+    }
+    // H2: Warn if no NIMBUS.md found in the current project directory
+    try {
+        const cwd = process.cwd();
+        const nimbusMdPaths = [join(cwd, 'NIMBUS.md'), join(cwd, '.nimbus', 'NIMBUS.md')];
+        if (!nimbusMdPaths.some(p => existsSync(p))) {
+            startupWarnings.push('No NIMBUS.md found — run /init to set up project context for better results.');
+        }
+    }
+    catch {
+        // Non-critical
+    }
+    // M3: Load per-project config and surface protected environments as warnings
+    try {
+        const { loadProjectConfig } = await import('./config/types');
+        const projectConfig = loadProjectConfig(process.cwd());
+        if (projectConfig?.protectedEnvironments && projectConfig.protectedEnvironments.length > 0) {
+            startupWarnings.push(`Protected environments: ${projectConfig.protectedEnvironments.join(', ')} — destructive operations require confirmation.`);
+        }
+    }
+    catch {
+        // Non-critical
+    }
+    // Ensure ~/.nimbus directory exists
+    if (!existsSync(NIMBUS_DIR)) {
+        mkdirSync(NIMBUS_DIR, { recursive: true });
+    }
+    // Initialize the SQLite database
+    const { getDb } = await import('./state/db');
+    const db = getDb();
+    // Load LLM config and create router
+    const { loadLLMConfig } = await import('./llm/config-loader');
+    const { LLMRouter: LLMRouterClass } = await import('./llm/router');
+    const llmConfig = loadLLMConfig();
+    const router = new LLMRouterClass(llmConfig);
+    // Register all built-in tools into the global registry
+    const { defaultToolRegistry } = await import('./tools/schemas/types');
+    if (defaultToolRegistry.size === 0) {
+        const { standardTools } = await import('./tools/schemas/standard');
+        const { devopsTools } = await import('./tools/schemas/devops');
+        for (const tool of [...standardTools, ...devopsTools]) {
+            try {
+                defaultToolRegistry.register(tool);
+            }
+            catch {
+                /* skip duplicates */
+            }
+        }
+    }
+    // Connect MCP servers and register their tools (non-critical)
+    try {
+        const { MCPManager } = await import('./mcp/manager');
+        const mcpManager = new MCPManager();
+        await mcpManager.loadConfig(process.cwd());
+        if (mcpManager.serverCount > 0) {
+            await mcpManager.connectAll();
+            mcpManager.registerTools(defaultToolRegistry);
+        }
+    }
+    catch (mcpErr) {
+        // MCP is non-critical — tools work fine without it, but warn the user
+        const msg = mcpErr instanceof Error ? mcpErr.message : String(mcpErr);
+        if (process.stderr.isTTY) {
+            process.stderr.write(`\x1b[33m  Warning: MCP server loading failed: ${msg}. External tools from .mcp.json will not be available.\x1b[0m\n`);
+        }
+    }
+    appContext = { db, router, nimbusDir: NIMBUS_DIR };
+    return appContext;
+}
+/**
+ * Get the current app context without initializing.
+ * Returns null if initApp() has not been called yet.
+ */
+export function getAppContext() {
+    return appContext;
+}
+/**
+ * Gracefully shut down the Nimbus application.
+ *
+ * Closes the database connection and clears the cached context so that
+ * a subsequent call to initApp() will re-initialize from scratch.
+ */
+export async function shutdownApp() {
+    if (!appContext) {
+        return;
+    }
+    // Flush any pending debounced SQLite writes before closing the DB
+    try {
+        const { SessionManager } = await import('./sessions/manager');
+        SessionManager.getInstance().flushAll();
+    }
+    catch {
+        // SessionManager may not have been used — ignore
+    }
+    try {
+        appContext.db.close();
+    }
+    catch {
+        // Database may already be closed; ignore.
+    }
+    appContext = null;
+}

package/dist/src/audit/activity-log.js

@@ -0,0 +1,209 @@
+/**
+ * Activity Log - Record and query every tool call executed by the Nimbus agent.
+ *
+ * Each entry captures the tool name, input parameters, output, duration,
+ * session context, and operating mode (plan/build/deploy). The log supports
+ * flexible filtering, summary statistics with tool-level breakdowns, and
+ * both concise and verbose text formatting.
+ */
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Format a duration in milliseconds as a human-friendly string.
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    if (ms < 60_000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = ((ms % 60_000) / 1000).toFixed(0);
+    return `${minutes}m ${seconds}s`;
+}
+/**
+ * Format a Date as a compact ISO-like timestamp (YYYY-MM-DD HH:MM:SS).
+ */
+function formatTimestamp(date) {
+    const y = date.getFullYear();
+    const mo = String(date.getMonth() + 1).padStart(2, '0');
+    const d = String(date.getDate()).padStart(2, '0');
+    const h = String(date.getHours()).padStart(2, '0');
+    const mi = String(date.getMinutes()).padStart(2, '0');
+    const s = String(date.getSeconds()).padStart(2, '0');
+    return `${y}-${mo}-${d} ${h}:${mi}:${s}`;
+}
+/**
+ * Truncate a string to maxLen characters, appending an ellipsis if needed.
+ */
+function truncate(str, maxLen) {
+    if (str.length <= maxLen) {
+        return str;
+    }
+    return `${str.slice(0, maxLen - 3)}...`;
+}
+// ---------------------------------------------------------------------------
+// ActivityLog
+// ---------------------------------------------------------------------------
+/**
+ * In-memory log of all tool calls made during Nimbus sessions.
+ *
+ * Supports recording entries, querying with filters, computing summary
+ * statistics, and formatting output for display in the CLI.
+ *
+ * @example
+ * ```typescript
+ * const log = new ActivityLog();
+ *
+ * log.log({
+ *   timestamp: new Date(),
+ *   sessionId: 'session-1',
+ *   toolName: 'terraform_plan',
+ *   toolInput: { dir: '/infra' },
+ *   result: { output: 'Plan: 3 to add', isError: false },
+ *   duration: 4200,
+ *   mode: 'plan',
+ * });
+ *
+ * const entries = log.query({ toolName: 'terraform_plan' });
+ * console.log(log.formatLog(entries));
+ * ```
+ */
+export class ActivityLog {
+    entries = [];
+    /**
+     * Record a tool call in the activity log.
+     *
+     * A unique ID is generated automatically. The entry is appended to the
+     * internal ledger and returned.
+     *
+     * @param entry - All fields except `id` (which is auto-generated)
+     * @returns The created activity entry with its assigned ID
+     */
+    log(entry) {
+        const full = {
+            id: crypto.randomUUID(),
+            ...entry,
+        };
+        this.entries.push(full);
+        return full;
+    }
+    /**
+     * Query the activity log with optional filters.
+     *
+     * Filters are combined with AND logic. Results are returned in reverse
+     * chronological order (newest first). Use `limit` to cap the result count.
+     *
+     * @param filter - Optional filter criteria
+     * @returns Matching activity entries
+     */
+    query(filter) {
+        let results = [...this.entries];
+        if (filter?.toolName) {
+            results = results.filter(e => e.toolName === filter.toolName);
+        }
+        if (filter?.sessionId) {
+            results = results.filter(e => e.sessionId === filter.sessionId);
+        }
+        if (filter?.since) {
+            const since = filter.since.getTime();
+            results = results.filter(e => e.timestamp.getTime() >= since);
+        }
+        if (filter?.until) {
+            const until = filter.until.getTime();
+            results = results.filter(e => e.timestamp.getTime() <= until);
+        }
+        if (filter?.isError !== undefined) {
+            results = results.filter(e => e.result.isError === filter.isError);
+        }
+        // Sort newest first
+        results.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        if (filter?.limit !== undefined && filter.limit > 0) {
+            results = results.slice(0, filter.limit);
+        }
+        return results;
+    }
+    /**
+     * Compute summary statistics for the activity log.
+     *
+     * Returns total call count, error count, average duration, and a breakdown
+     * of call counts per tool name.
+     *
+     * @param sessionId - If provided, restrict statistics to this session
+     * @returns Summary statistics object
+     */
+    getStats(sessionId) {
+        let entries = this.entries;
+        if (sessionId) {
+            entries = entries.filter(e => e.sessionId === sessionId);
+        }
+        const totalCalls = entries.length;
+        const errorCount = entries.filter(e => e.result.isError).length;
+        const totalDuration = entries.reduce((sum, e) => sum + e.duration, 0);
+        const avgDuration = totalCalls > 0 ? Math.round(totalDuration / totalCalls) : 0;
+        const toolBreakdown = {};
+        for (const entry of entries) {
+            toolBreakdown[entry.toolName] = (toolBreakdown[entry.toolName] ?? 0) + 1;
+        }
+        return {
+            totalCalls,
+            errorCount,
+            avgDuration,
+            toolBreakdown,
+        };
+    }
+    /**
+     * Format activity entries as a human-readable text report.
+     *
+     * In concise mode (default), each entry is a single line with timestamp,
+     * tool name, duration, and status. In verbose mode, input parameters and
+     * output are also shown.
+     *
+     * @param entries - Entries to format
+     * @param options - Formatting options
+     * @returns Multi-line formatted log
+     */
+    formatLog(entries, options) {
+        if (entries.length === 0) {
+            return 'No activity entries to display.';
+        }
+        const verbose = options?.verbose ?? false;
+        const lines = [`Activity Log (${entries.length} entries)`, '='.repeat(60), ''];
+        for (const entry of entries) {
+            const status = entry.result.isError ? '[ERROR]' : '[OK]   ';
+            const ts = formatTimestamp(entry.timestamp);
+            const dur = formatDuration(entry.duration);
+            lines.push(`${ts}  ${status}  ${entry.toolName}  (${dur})  [${entry.mode}]`);
+            if (verbose) {
+                // Show input
+                const inputStr = JSON.stringify(entry.toolInput);
+                lines.push(`  Input:  ${truncate(inputStr, 120)}`);
+                // Show output
+                const outputStr = entry.result.output;
+                lines.push(`  Output: ${truncate(outputStr, 120)}`);
+                if (entry.result.isError) {
+                    lines.push(`  ** Error occurred during execution **`);
+                }
+                lines.push('');
+            }
+        }
+        if (!verbose) {
+            lines.push('');
+        }
+        // Append quick stats
+        const errorCount = entries.filter(e => e.result.isError).length;
+        const totalDuration = entries.reduce((s, e) => s + e.duration, 0);
+        const avgDuration = entries.length > 0 ? Math.round(totalDuration / entries.length) : 0;
+        lines.push('-'.repeat(60));
+        lines.push(`${entries.length} calls, ${errorCount} errors, avg ${formatDuration(avgDuration)}`);
+        return lines.join('\n');
+    }
+    /**
+     * Remove all entries from the activity log.
+     */
+    clear() {
+        this.entries = [];
+    }
+}