@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/llm/types.js

@@ -0,0 +1,69 @@
+/**
+ * Base LLM Provider Interface
+ * Defines the contract that all LLM providers must implement
+ */
+/**
+ * Extract the text content from a message's content field.
+ * Handles both plain strings and content block arrays.
+ */
+export function getTextContent(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    return content
+        .filter((b) => b.type === 'text')
+        .map(b => b.text)
+        .join('');
+}
+/**
+ * Check if a message contains image content blocks.
+ */
+export function hasImageContent(content) {
+    if (typeof content === 'string') {
+        return false;
+    }
+    return content.some(b => b.type === 'image');
+}
+/**
+ * Base provider class with common utilities
+ */
+export class BaseProvider {
+    /**
+     * Extract system prompt from messages
+     */
+    extractSystemPrompt(messages) {
+        const systemMessages = messages.filter(m => m.role === 'system');
+        if (systemMessages.length === 0) {
+            return undefined;
+        }
+        return systemMessages.map(m => getTextContent(m.content)).join('\n\n');
+    }
+    /**
+     * Filter out system messages
+     */
+    filterSystemMessages(messages) {
+        return messages.filter(m => m.role !== 'system');
+    }
+    /**
+     * Map finish reason to standard format
+     */
+    mapFinishReason(reason) {
+        if (!reason) {
+            return 'stop';
+        }
+        const normalized = reason.toLowerCase();
+        if (normalized.includes('stop') || normalized === 'end_turn') {
+            return 'stop';
+        }
+        if (normalized.includes('length') || normalized.includes('max_tokens')) {
+            return 'length';
+        }
+        if (normalized.includes('tool') || normalized.includes('function')) {
+            return 'tool_calls';
+        }
+        if (normalized.includes('content_filter') || normalized.includes('safety')) {
+            return 'content_filter';
+        }
+        return 'stop';
+    }
+}

package/dist/src/lsp/client.js

@@ -0,0 +1,239 @@
+/**
+ * LSP Client -- JSON-RPC over stdio
+ *
+ * Implements the Language Server Protocol client that communicates
+ * with language servers via stdin/stdout using JSON-RPC 2.0.
+ */
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+/** Severity labels for display. */
+const SEVERITY_LABELS = {
+    1: 'Error',
+    2: 'Warning',
+    3: 'Info',
+    4: 'Hint',
+};
+export function severityLabel(severity) {
+    return SEVERITY_LABELS[severity] ?? 'Unknown';
+}
+/**
+ * LSP Client that communicates with a single language server.
+ */
+export class LSPClient extends EventEmitter {
+    process = null;
+    config;
+    requestId = 0;
+    pending = new Map();
+    buffer = '';
+    initialized = false;
+    rootUri;
+    diagnostics = new Map();
+    constructor(config, rootUri) {
+        super();
+        this.config = config;
+        this.rootUri = rootUri;
+    }
+    /** Whether the client is connected and initialized. */
+    get isInitialized() {
+        return this.initialized;
+    }
+    /** Get the language ID. */
+    get languageId() {
+        return this.config.id;
+    }
+    /** Start the language server process. */
+    async start() {
+        try {
+            this.process = spawn(this.config.command, this.config.args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env },
+            });
+            if (!this.process.stdout || !this.process.stdin) {
+                this.process.kill();
+                this.process = null;
+                return false;
+            }
+            this.process.stdout.on('data', (data) => {
+                this.handleData(data.toString());
+            });
+            this.process.stderr?.on('data', () => {
+                // Silently ignore stderr from language servers
+            });
+            this.process.on('exit', () => {
+                this.initialized = false;
+                this.process = null;
+                this.emit('exit');
+            });
+            // Send initialize request
+            const _initResult = await this.sendRequest('initialize', {
+                processId: process.pid,
+                rootUri: `file://${this.rootUri}`,
+                capabilities: {
+                    textDocument: {
+                        synchronization: { didOpen: true, didChange: true, didClose: true },
+                        publishDiagnostics: { relatedInformation: true },
+                    },
+                },
+                initializationOptions: this.config.initializationOptions ?? {},
+            });
+            // Send initialized notification
+            this.sendNotification('initialized', {});
+            this.initialized = true;
+            return true;
+        }
+        catch {
+            this.process = null;
+            return false;
+        }
+    }
+    /** Stop the language server. */
+    async stop() {
+        if (!this.process) {
+            return;
+        }
+        try {
+            await this.sendRequest('shutdown', null);
+            this.sendNotification('exit', null);
+        }
+        catch {
+            // Server may already be dead
+        }
+        // Force kill after 2 seconds
+        const proc = this.process;
+        setTimeout(() => {
+            if (proc && !proc.killed) {
+                proc.kill('SIGKILL');
+            }
+        }, 2000);
+        this.process = null;
+        this.initialized = false;
+    }
+    /** Notify the server that a file was opened or changed. */
+    async touchFile(filePath, content, version = 1) {
+        if (!this.initialized) {
+            return;
+        }
+        const uri = `file://${filePath}`;
+        const languageId = this.config.id;
+        // Send didOpen (simplified -- in a full implementation we'd track open state)
+        this.sendNotification('textDocument/didOpen', {
+            textDocument: { uri, languageId, version, text: content },
+        });
+    }
+    /** Request diagnostics for a file by waiting for publishDiagnostics. */
+    async getDiagnostics(filePath, timeoutMs = 2000) {
+        const uri = `file://${filePath}`;
+        // Return cached diagnostics if available
+        const cached = this.diagnostics.get(uri);
+        // Wait for new diagnostics up to timeout
+        return new Promise(resolve => {
+            const timer = setTimeout(() => {
+                resolve(cached ?? []);
+            }, timeoutMs);
+            const handler = (params) => {
+                if (params.uri === uri) {
+                    clearTimeout(timer);
+                    this.removeListener('diagnostics', handler);
+                    resolve(this.diagnostics.get(uri) ?? []);
+                }
+            };
+            this.on('diagnostics', handler);
+        });
+    }
+    /** Get all cached diagnostics for a file. */
+    getCachedDiagnostics(filePath) {
+        return this.diagnostics.get(`file://${filePath}`) ?? [];
+    }
+    /** Send a JSON-RPC request and wait for response. */
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.process?.stdin) {
+                reject(new Error('LSP process not running'));
+                return;
+            }
+            const id = ++this.requestId;
+            this.pending.set(id, { resolve, reject });
+            const message = JSON.stringify({ jsonrpc: '2.0', id, method, params });
+            const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+            this.process.stdin.write(header + message);
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new Error(`LSP request timeout: ${method}`));
+                }
+            }, 10000);
+        });
+    }
+    /** Send a JSON-RPC notification (no response expected). */
+    sendNotification(method, params) {
+        if (!this.process?.stdin) {
+            return;
+        }
+        const message = JSON.stringify({ jsonrpc: '2.0', method, params });
+        const header = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n`;
+        this.process.stdin.write(header + message);
+    }
+    /** Handle incoming data from the language server. */
+    handleData(data) {
+        this.buffer += data;
+        for (;;) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1) {
+                break;
+            }
+            const header = this.buffer.slice(0, headerEnd);
+            const contentLengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+            if (!contentLengthMatch) {
+                this.buffer = this.buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(contentLengthMatch[1], 10);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + contentLength) {
+                break;
+            }
+            const body = this.buffer.slice(bodyStart, bodyStart + contentLength);
+            this.buffer = this.buffer.slice(bodyStart + contentLength);
+            try {
+                const message = JSON.parse(body);
+                this.handleMessage(message);
+            }
+            catch {
+                // Ignore malformed messages
+            }
+        }
+    }
+    /** Handle a parsed JSON-RPC message. */
+    handleMessage(message) {
+        // Response to a request
+        if (message.id !== undefined && this.pending.has(message.id)) {
+            const handler = this.pending.get(message.id);
+            this.pending.delete(message.id);
+            if (message.error) {
+                handler.reject(new Error(message.error.message));
+            }
+            else {
+                handler.resolve(message.result);
+            }
+            return;
+        }
+        // Notification from server
+        if (message.method === 'textDocument/publishDiagnostics') {
+            const { uri, diagnostics: rawDiags } = message.params;
+            const parsed = rawDiags.map((d) => ({
+                file: uri.replace('file://', ''),
+                line: (d.range?.start?.line ?? 0) + 1,
+                column: (d.range?.start?.character ?? 0) + 1,
+                endLine: d.range?.end ? d.range.end.line + 1 : undefined,
+                endColumn: d.range?.end ? d.range.end.character + 1 : undefined,
+                severity: d.severity ?? 1,
+                message: d.message,
+                source: d.source,
+                code: d.code,
+            }));
+            this.diagnostics.set(uri, parsed);
+            this.emit('diagnostics', message.params);
+        }
+    }
+}

package/dist/src/lsp/languages.js

@@ -0,0 +1,95 @@
+/**
+ * Language Server Configurations
+ *
+ * Defines the LSP binary names, install commands, and file associations
+ * for each supported language.
+ */
+/** Supported language server configurations. */
+export const LANGUAGE_CONFIGS = [
+    {
+        id: 'typescript',
+        name: 'TypeScript',
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+        command: 'typescript-language-server',
+        args: ['--stdio'],
+        installHint: 'npm install -g typescript-language-server typescript',
+        initializationOptions: {
+            preferences: {
+                includeInlayParameterNameHints: 'none',
+            },
+        },
+    },
+    {
+        id: 'go',
+        name: 'Go',
+        extensions: ['.go'],
+        command: 'gopls',
+        args: ['serve'],
+        installHint: 'go install golang.org/x/tools/gopls@latest',
+    },
+    {
+        id: 'python',
+        name: 'Python',
+        extensions: ['.py', '.pyi'],
+        command: 'pylsp',
+        args: [],
+        installHint: 'pip install python-lsp-server',
+    },
+    {
+        id: 'terraform',
+        name: 'Terraform/HCL',
+        extensions: ['.tf', '.tfvars', '.hcl'],
+        command: 'terraform-ls',
+        args: ['serve'],
+        installHint: 'brew install hashicorp/tap/terraform-ls',
+    },
+    {
+        id: 'yaml',
+        name: 'YAML',
+        extensions: ['.yaml', '.yml'],
+        command: 'yaml-language-server',
+        args: ['--stdio'],
+        installHint: 'npm install -g yaml-language-server',
+    },
+    {
+        id: 'docker',
+        name: 'Docker',
+        extensions: ['Dockerfile', '.dockerfile'],
+        command: 'docker-langserver',
+        args: ['--stdio'],
+        installHint: 'npm install -g dockerfile-language-server-nodejs',
+    },
+];
+/**
+ * Find the language config for a given file path.
+ * Returns undefined if no matching language server is configured.
+ */
+export function getLanguageForFile(filePath) {
+    const lowerPath = filePath.toLowerCase();
+    const baseName = filePath.split('/').pop() ?? '';
+    for (const config of LANGUAGE_CONFIGS) {
+        for (const ext of config.extensions) {
+            if (ext.startsWith('.')) {
+                if (lowerPath.endsWith(ext)) {
+                    return config;
+                }
+            }
+            else {
+                // Match exact filename (e.g., Dockerfile)
+                if (baseName === ext || baseName.toLowerCase() === ext.toLowerCase()) {
+                    return config;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Get the priority order of language configs.
+ * TypeScript > Go > Python > HCL > YAML > Docker
+ */
+export function getLanguagePriority() {
+    return [...LANGUAGE_CONFIGS];
+}
+/** Language IDs relevant for DevOps workflows. */
+export const DEVOPS_LANGUAGE_IDS = ['terraform', 'yaml', 'docker'];

package/dist/src/lsp/manager.js

@@ -0,0 +1,243 @@
+/**
+ * LSP Manager -- Language Server Lifecycle
+ *
+ * Manages starting, stopping, and querying multiple language servers.
+ * Lazy loading: servers only start when a file of that type is first edited.
+ * Auto-stop: servers shut down after 5 minutes of inactivity.
+ */
+import { readFile } from 'node:fs/promises';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { EventEmitter } from 'node:events';
+import { LSPClient } from './client';
+import { getLanguageForFile, LANGUAGE_CONFIGS } from './languages';
+const execAsync = promisify(exec);
+/** Default idle timeout: 5 minutes. */
+const DEFAULT_IDLE_TIMEOUT = 5 * 60 * 1000;
+/** Delay after file change before requesting diagnostics. */
+const DIAGNOSTIC_DELAY = 500;
+export class LSPManager extends EventEmitter {
+    clients = new Map();
+    idleTimers = new Map();
+    rootUri;
+    availabilityCache = new Map();
+    fileVersions = new Map();
+    enabled = true;
+    enabledLanguages;
+    /** C4: Track languages already reported as unavailable to avoid duplicate events. */
+    failedLSPs = new Set();
+    constructor(rootUri, options) {
+        super();
+        this.rootUri = rootUri ?? process.cwd();
+        this.enabledLanguages = options?.enabledLanguages;
+    }
+    /** Enable or disable LSP integration. */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+        if (!enabled) {
+            this.stopAll();
+        }
+    }
+    /**
+     * Notify the LSP manager that a file was modified.
+     * This lazily starts the appropriate language server and sends the update.
+     */
+    async touchFile(filePath) {
+        if (!this.enabled) {
+            return;
+        }
+        const config = getLanguageForFile(filePath);
+        if (!config) {
+            return;
+        }
+        // Skip non-enabled language servers if a filter is set
+        if (this.enabledLanguages && !this.enabledLanguages.includes(config.id)) {
+            return;
+        }
+        // Ensure the client is running
+        const client = await this.ensureClient(config);
+        if (!client) {
+            return;
+        }
+        // Read file content and bump version
+        let content;
+        try {
+            content = await readFile(filePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const version = (this.fileVersions.get(filePath) ?? 0) + 1;
+        this.fileVersions.set(filePath, version);
+        await client.touchFile(filePath, content, version);
+        this.resetIdleTimer(config.id);
+    }
+    /**
+     * Get diagnostics for a file.
+     * Waits up to `delayMs` for the LSP to process and return results.
+     */
+    async getDiagnostics(filePath, delayMs = DIAGNOSTIC_DELAY) {
+        if (!this.enabled) {
+            return [];
+        }
+        const config = getLanguageForFile(filePath);
+        if (!config) {
+            return [];
+        }
+        const client = this.clients.get(config.id);
+        if (!client?.isInitialized) {
+            return [];
+        }
+        // Wait a brief moment for the LSP to process
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+        return client.getDiagnostics(filePath);
+    }
+    /**
+     * Get errors only (severity 1 = Error).
+     */
+    async getErrors(filePath) {
+        const diagnostics = await this.getDiagnostics(filePath);
+        return diagnostics.filter(d => d.severity === 1);
+    }
+    /**
+     * Format diagnostics as messages suitable for injection into the agent conversation.
+     */
+    formatDiagnosticsForAgent(diagnostics) {
+        if (diagnostics.length === 0) {
+            return null;
+        }
+        const errors = diagnostics.filter(d => d.severity === 1);
+        const warnings = diagnostics.filter(d => d.severity === 2);
+        if (errors.length === 0 && warnings.length === 0) {
+            return null;
+        }
+        const lines = ['[LSP Diagnostics]'];
+        for (const d of errors) {
+            const loc = `${d.file}:${d.line}:${d.column}`;
+            lines.push(`  Error: ${loc} — ${d.message}${d.source ? ` (${d.source})` : ''}`);
+        }
+        for (const d of warnings.slice(0, 5)) {
+            const loc = `${d.file}:${d.line}:${d.column}`;
+            lines.push(`  Warning: ${loc} — ${d.message}${d.source ? ` (${d.source})` : ''}`);
+        }
+        if (warnings.length > 5) {
+            lines.push(`  ... and ${warnings.length - 5} more warnings`);
+        }
+        return lines.join('\n');
+    }
+    /** Get status of all known language servers. */
+    async getStatus() {
+        const statuses = [];
+        for (const config of LANGUAGE_CONFIGS) {
+            const client = this.clients.get(config.id);
+            const available = await this.isAvailable(config);
+            statuses.push({
+                language: config.name,
+                active: client?.isInitialized ?? false,
+                available,
+            });
+        }
+        return statuses;
+    }
+    /** Stop all running language servers. */
+    async stopAll() {
+        for (const [id, client] of this.clients) {
+            await client.stop();
+            const timer = this.idleTimers.get(id);
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+        this.clients.clear();
+        this.idleTimers.clear();
+    }
+    /** Stop a specific language server. */
+    async stop(languageId) {
+        const client = this.clients.get(languageId);
+        if (client) {
+            await client.stop();
+            this.clients.delete(languageId);
+        }
+        const timer = this.idleTimers.get(languageId);
+        if (timer) {
+            clearTimeout(timer);
+            this.idleTimers.delete(languageId);
+        }
+    }
+    /** Ensure a client exists and is initialized for the given language. */
+    async ensureClient(config) {
+        const existing = this.clients.get(config.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        // Check if the binary is available
+        const available = await this.isAvailable(config);
+        if (!available) {
+            // C4: Emit once per language so the TUI can surface a diagnostic message
+            if (!this.failedLSPs.has(config.id)) {
+                this.failedLSPs.add(config.id);
+                this.emit('lsp-unavailable', config.name ?? config.id, config.command);
+            }
+            return null;
+        }
+        const client = new LSPClient(config, this.rootUri);
+        const started = await client.start();
+        if (!started) {
+            return null;
+        }
+        this.clients.set(config.id, client);
+        this.resetIdleTimer(config.id);
+        client.on('exit', () => {
+            this.clients.delete(config.id);
+            const timer = this.idleTimers.get(config.id);
+            if (timer) {
+                clearTimeout(timer);
+                this.idleTimers.delete(config.id);
+            }
+        });
+        return client;
+    }
+    /** Check if a language server binary is available in PATH. */
+    async isAvailable(config) {
+        const cached = this.availabilityCache.get(config.id);
+        if (cached !== undefined) {
+            return cached;
+        }
+        try {
+            await execAsync(`which ${config.command}`);
+            this.availabilityCache.set(config.id, true);
+            return true;
+        }
+        catch {
+            this.availabilityCache.set(config.id, false);
+            return false;
+        }
+    }
+    /** Reset the idle timer for a language server. */
+    resetIdleTimer(languageId) {
+        const existing = this.idleTimers.get(languageId);
+        if (existing) {
+            clearTimeout(existing);
+        }
+        const config = LANGUAGE_CONFIGS.find(c => c.id === languageId);
+        const timeout = config?.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+        const timer = setTimeout(() => {
+            this.stop(languageId);
+        }, timeout);
+        this.idleTimers.set(languageId, timer);
+    }
+}
+/** Singleton LSP manager instance. */
+let lspManagerInstance = null;
+/** Get or create the singleton LSP manager. */
+export function getLSPManager(rootUri, options) {
+    if (!lspManagerInstance) {
+        lspManagerInstance = new LSPManager(rootUri, options);
+    }
+    return lspManagerInstance;
+}
+/** Reset the singleton (for testing). */
+export function resetLSPManager() {
+    lspManagerInstance?.stopAll();
+    lspManagerInstance = null;
+}