orquesta-cli 0.2.108 → 0.2.111

package/dist/core/lsp/lsp-client.js

@@ -0,0 +1,201 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { encodeMessage, MessageDecoder } from './jsonrpc.js';
+import { logger } from '../../utils/logger.js';
+const INIT_TIMEOUT_MS = Number(process.env['ORQUESTA_LSP_INIT_TIMEOUT_MS']) || 12000;
+const DIAGNOSTICS_WAIT_MS = Number(process.env['ORQUESTA_LSP_DIAG_TIMEOUT_MS']) || 2500;
+class LspClient {
+    def;
+    rootDir;
+    proc = null;
+    decoder = new MessageDecoder();
+    nextId = 1;
+    pendingRequests = new Map();
+    diagnostics = new Map();
+    diagWaiters = new Map();
+    openDocs = new Set();
+    initialized = false;
+    version = new Map();
+    constructor(def, rootDir) {
+        this.def = def;
+        this.rootDir = rootDir;
+    }
+    send(msg) {
+        if (!this.proc)
+            return;
+        this.proc.stdin.write(encodeMessage({ jsonrpc: '2.0', ...msg }));
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve: resolve, reject });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.send({ method, params });
+    }
+    handleMessage(msg) {
+        if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+                this.pendingRequests.delete(msg.id);
+                if (msg.error)
+                    pending.reject(new Error(msg.error.message));
+                else
+                    pending.resolve(msg.result);
+            }
+            return;
+        }
+        if (msg.method === 'textDocument/publishDiagnostics') {
+            const params = msg.params;
+            const diags = (params.diagnostics || []).map((d) => ({
+                severity: d.severity ?? 1,
+                line: d.range?.start?.line ?? 0,
+                character: d.range?.start?.character ?? 0,
+                message: d.message ?? '',
+                source: d.source,
+            }));
+            this.diagnostics.set(params.uri, diags);
+            const waiters = this.diagWaiters.get(params.uri);
+            if (waiters) {
+                this.diagWaiters.delete(params.uri);
+                for (const w of waiters)
+                    w();
+            }
+            return;
+        }
+        if (msg.id !== undefined && msg.method) {
+            this.send({ id: msg.id, result: null });
+        }
+    }
+    async start() {
+        if (this.initialized)
+            return;
+        if (this.proc) {
+            await this.waitFor(() => this.initialized, INIT_TIMEOUT_MS);
+            return;
+        }
+        logger.flow('LSP starting server', { id: this.def.id, root: this.rootDir });
+        const proc = spawn(this.def.command, this.def.args, {
+            cwd: this.rootDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: process.env,
+        });
+        this.proc = proc;
+        proc.stdout.on('data', (chunk) => {
+            for (const msg of this.decoder.push(chunk))
+                this.handleMessage(msg);
+        });
+        proc.stderr.on('data', () => {
+        });
+        proc.on('error', (err) => {
+            logger.warn('LSP server process error', { id: this.def.id, error: err.message });
+            this.teardown();
+        });
+        proc.on('exit', () => this.teardown());
+        await this.request('initialize', {
+            processId: process.pid,
+            rootUri: pathToFileURL(this.rootDir).toString(),
+            rootPath: this.rootDir,
+            capabilities: {
+                textDocument: {
+                    synchronization: { didSave: true, dynamicRegistration: false },
+                    publishDiagnostics: { relatedInformation: false },
+                },
+            },
+            workspaceFolders: [{ uri: pathToFileURL(this.rootDir).toString(), name: path.basename(this.rootDir) }],
+        });
+        this.notify('initialized', {});
+        this.initialized = true;
+        logger.flow('LSP server initialized', { id: this.def.id });
+    }
+    async getDiagnostics(absPath, text) {
+        await this.start();
+        const uri = pathToFileURL(absPath).toString();
+        this.diagnostics.delete(uri);
+        const arrived = this.onceDiagnostics(uri);
+        if (!this.openDocs.has(uri)) {
+            this.openDocs.add(uri);
+            this.version.set(uri, 1);
+            this.notify('textDocument/didOpen', {
+                textDocument: { uri, languageId: this.def.id, version: 1, text },
+            });
+        }
+        else {
+            const v = (this.version.get(uri) ?? 1) + 1;
+            this.version.set(uri, v);
+            this.notify('textDocument/didChange', {
+                textDocument: { uri, version: v },
+                contentChanges: [{ text }],
+            });
+        }
+        this.notify('textDocument/didSave', { textDocument: { uri }, text });
+        await Promise.race([arrived, this.delay(DIAGNOSTICS_WAIT_MS)]);
+        return this.diagnostics.get(uri) ?? [];
+    }
+    onceDiagnostics(uri) {
+        return new Promise((resolve) => {
+            const list = this.diagWaiters.get(uri) ?? [];
+            list.push(resolve);
+            this.diagWaiters.set(uri, list);
+        });
+    }
+    delay(ms) {
+        return new Promise((r) => {
+            const t = setTimeout(r, ms);
+            if (typeof t.unref === 'function')
+                t.unref();
+        });
+    }
+    async waitFor(cond, timeoutMs) {
+        const start = Date.now();
+        while (!cond() && Date.now() - start < timeoutMs) {
+            await this.delay(50);
+        }
+    }
+    teardown() {
+        this.initialized = false;
+        for (const [, p] of this.pendingRequests)
+            p.reject(new Error('LSP server exited'));
+        this.pendingRequests.clear();
+        this.proc = null;
+    }
+    async stop() {
+        if (!this.proc)
+            return;
+        try {
+            await Promise.race([this.request('shutdown', null), this.delay(1000)]);
+            this.notify('exit', null);
+        }
+        catch {
+        }
+        try {
+            this.proc.kill();
+        }
+        catch {
+        }
+        this.teardown();
+    }
+}
+const clients = new Map();
+export function getOrCreateClient(def, rootDir) {
+    const key = `${def.id}::${rootDir}`;
+    let client = clients.get(key);
+    if (!client) {
+        client = new LspClient(def, rootDir);
+        clients.set(key, client);
+    }
+    return client;
+}
+export async function shutdownAllLspClients() {
+    const all = Array.from(clients.values());
+    clients.clear();
+    await Promise.all(all.map((c) => c.stop().catch(() => undefined)));
+}
+export function getActiveLspClientCount() {
+    return clients.size;
+}
+export { fileURLToPath };
+//# sourceMappingURL=lsp-client.js.map

package/dist/core/lsp/server-registry.d.ts

@@ -0,0 +1,14 @@
+export interface LspServerDef {
+    id: string;
+    extensions: string[];
+    command: string;
+    args: string[];
+}
+export declare function resolveServerBinary(command: string): string | null;
+export declare function getServerDefs(): LspServerDef[];
+export declare function findServerForFile(absPath: string): {
+    def: LspServerDef;
+    binary: string;
+} | null;
+export declare function clearResolveCache(): void;
+//# sourceMappingURL=server-registry.d.ts.map

package/dist/core/lsp/server-registry.js

@@ -0,0 +1,85 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { configManager } from '../config/config-manager.js';
+const DEFAULT_SERVERS = [
+    {
+        id: 'typescript',
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'],
+        command: 'typescript-language-server',
+        args: ['--stdio'],
+    },
+    { id: 'python', extensions: ['.py', '.pyi'], command: 'pyright-langserver', args: ['--stdio'] },
+    { id: 'rust', extensions: ['.rs'], command: 'rust-analyzer', args: [] },
+    { id: 'go', extensions: ['.go'], command: 'gopls', args: [] },
+    { id: 'ruby', extensions: ['.rb'], command: 'solargraph', args: ['stdio'] },
+];
+function execCandidates(command) {
+    if (path.isAbsolute(command))
+        return [command];
+    if (process.platform === 'win32') {
+        const exts = (process.env['PATHEXT'] || '.COM;.EXE;.BAT;.CMD').split(';');
+        return [command, ...exts.map((e) => command + e.toLowerCase()), ...exts.map((e) => command + e)];
+    }
+    return [command];
+}
+const resolveCache = new Map();
+export function resolveServerBinary(command) {
+    if (resolveCache.has(command))
+        return resolveCache.get(command);
+    const tryFile = (p) => {
+        try {
+            const st = fs.statSync(p);
+            if (st.isFile())
+                return p;
+        }
+        catch {
+        }
+        return null;
+    };
+    let found = null;
+    if (path.isAbsolute(command) || command.includes('/') || command.includes('\\')) {
+        for (const cand of execCandidates(command)) {
+            found = tryFile(path.resolve(cand));
+            if (found)
+                break;
+        }
+    }
+    else {
+        const pathDirs = (process.env['PATH'] || '').split(path.delimiter).filter(Boolean);
+        outer: for (const dir of pathDirs) {
+            for (const cand of execCandidates(command)) {
+                found = tryFile(path.join(dir, cand));
+                if (found)
+                    break outer;
+            }
+        }
+    }
+    resolveCache.set(command, found);
+    return found;
+}
+export function getServerDefs() {
+    let custom = [];
+    try {
+        custom = configManager.getLspServers();
+    }
+    catch {
+    }
+    return [...custom, ...DEFAULT_SERVERS];
+}
+export function findServerForFile(absPath) {
+    const ext = path.extname(absPath).toLowerCase();
+    if (!ext)
+        return null;
+    for (const def of getServerDefs()) {
+        if (!def.extensions.includes(ext))
+            continue;
+        const binary = resolveServerBinary(def.command);
+        if (binary)
+            return { def: { ...def, command: binary }, binary };
+    }
+    return null;
+}
+export function clearResolveCache() {
+    resolveCache.clear();
+}
+//# sourceMappingURL=server-registry.js.map

package/dist/eval/eval-runner.js

@@ -40,6 +40,12 @@ export class EvalRunner {
             if (input.working_dir) {
                 process.chdir(input.working_dir);
             }
+            try {
+                const { initializeMcpServers } = await import('../tools/mcp/index.js');
+                await initializeMcpServers(process.cwd());
+            }
+            catch {
+            }
             const startEvent = {
                 event: 'start',
                 timestamp: now(),
@@ -58,6 +64,14 @@ export class EvalRunner {
             this.emitError(error instanceof Error ? error.message : String(error));
             this.emitEnd(false);
         }
+        finally {
+            try {
+                const { shutdownAllLspClients } = await import('../core/lsp/index.js');
+                await shutdownAllLspClients();
+            }
+            catch {
+            }
+        }
     }
     async execute(prompt) {
         if (!this.llmClient) {

package/dist/orchestration/plan-executor.js

@@ -2,6 +2,7 @@ import { PlanningLLM } from '../agents/planner/index.js';
 import { sessionManager } from '../core/session/session-manager.js';
 import { CompactManager, contextTracker, buildCompactedMessages, } from '../core/compact/index.js';
 import { configManager } from '../core/config/config-manager.js';
+import { fileSnapshotStore } from '../core/file-snapshot-store.js';
 import { setTodoWriteCallback, clearTodoCallbacks, } from '../tools/llm/simple/todo-tools.js';
 import { setGetTodosCallback, setFinalResponseCallback, setMarkTodosCompletedCallback, clearFinalResponseCallbacks, } from '../tools/llm/simple/final-response-tool.js';
 import { eventBus, Events } from '../core/event-bus.js';
@@ -54,6 +55,7 @@ export class PlanExecutor {
         });
         this.currentLLMClient = llmClient;
         setDocsSearchLLMClientGetter(() => this.currentLLMClient);
+        fileSnapshotStore.beginTurn(userMessage);
         isInterruptedRef.current = false;
         callbacks.setIsInterrupted(false);
         callbacks.setTodos([]);

package/dist/tools/llm/simple/file-tools.js

@@ -3,6 +3,8 @@ import * as path from 'path';
 import { logger } from '../../../utils/logger.js';
 import { shouldIgnore } from '../../../core/ignore-filter.js';
 import { getCachedFile, setCachedFile, invalidateCache } from '../../../core/file-cache.js';
+import { fileSnapshotStore } from '../../../core/file-snapshot-store.js';
+import { getDiagnosticsForFile } from '../../../core/lsp/index.js';
 const EXCLUDED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -193,10 +195,12 @@ async function _executeCreateFile(args) {
         }
         const dir = path.dirname(resolvedPath);
         await fs.mkdir(dir, { recursive: true });
+        fileSnapshotStore.record(resolvedPath, null);
         await fs.writeFile(resolvedPath, content, 'utf-8');
         invalidateCache(resolvedPath);
         const lines = content.split('\n').length;
         logger.toolSuccess('create_file', args, { file: displayPath, lines }, 0);
+        const diagnostics = await getDiagnosticsForFile(resolvedPath);
         return {
             success: true,
             result: JSON.stringify({
@@ -204,7 +208,7 @@ async function _executeCreateFile(args) {
                 file: displayPath,
                 lines: lines,
                 message: `Created ${displayPath} (${lines} lines)`,
-            }),
+            }) + diagnostics,
         };
     }
     catch (error) {
@@ -356,6 +360,7 @@ async function _executeEditFile(args) {
                 error: `Modified content too large (${(newContentSize / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_WRITE_SIZE / 1024 / 1024}MB`,
             };
         }
+        fileSnapshotStore.record(resolvedPath, originalContent);
         await fs.writeFile(resolvedPath, newContent, 'utf-8');
         invalidateCache(resolvedPath);
         const oldLinesArr = oldString.split('\n');
@@ -371,6 +376,7 @@ async function _executeEditFile(args) {
         if (newLinesArr.length > 5)
             diffPreview.push('+ ...');
         logger.toolSuccess('edit_file', args, { file: displayPath, replacements, oldLines: oldLinesArr.length, newLines: newLinesArr.length }, 0);
+        const diagnostics = await getDiagnosticsForFile(resolvedPath);
         return {
             success: true,
             result: JSON.stringify({
@@ -383,7 +389,7 @@ async function _executeEditFile(args) {
                     ? `Replaced ${replacements} occurrence(s) in ${displayPath}`
                     : `Updated ${displayPath}`,
                 diff: diffPreview,
-            }),
+            }) + diagnostics,
         };
     }
     catch (error) {

package/dist/tools/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { initializeMcpServers, disconnectMcpServers, getConnectedMcpServers, namespacedToolName, type McpInitResult, } from './mcp-client.js';
+export { loadMcpServerConfigs, normalizeSource } from './mcp-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/mcp/index.js

@@ -0,0 +1,3 @@
+export { initializeMcpServers, disconnectMcpServers, getConnectedMcpServers, namespacedToolName, } from './mcp-client.js';
+export { loadMcpServerConfigs, normalizeSource } from './mcp-config.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/mcp/mcp-client.d.ts

@@ -0,0 +1,16 @@
+export declare function namespacedToolName(server: string, tool: string): string;
+export interface McpInitResult {
+    servers: number;
+    tools: number;
+    errors: Array<{
+        server: string;
+        error: string;
+    }>;
+}
+export declare function initializeMcpServers(cwd?: string): Promise<McpInitResult>;
+export declare function getConnectedMcpServers(): Array<{
+    name: string;
+    tools: string[];
+}>;
+export declare function disconnectMcpServers(): Promise<void>;
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/tools/mcp/mcp-client.js

@@ -0,0 +1,180 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { createRequire } from 'module';
+import { toolRegistry } from '../registry.js';
+import { loadMcpServerConfigs } from './mcp-config.js';
+import { logger } from '../../utils/logger.js';
+const pkg = createRequire(import.meta.url)('../../../package.json');
+const CONNECT_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_TIMEOUT_MS']) || 15000;
+const CALL_TIMEOUT_MS = Number(process.env['ORQUESTA_MCP_CALL_TIMEOUT_MS']) || 120000;
+const connected = [];
+export function namespacedToolName(server, tool) {
+    const clean = (s) => s.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return `mcp__${clean(server)}__${clean(tool)}`;
+}
+function flattenToolContent(content) {
+    if (!Array.isArray(content)) {
+        return typeof content === 'string' ? content : JSON.stringify(content ?? '');
+    }
+    const parts = [];
+    for (const item of content) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const block = item;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            parts.push(block.text);
+        }
+        else if (block.type === 'image') {
+            parts.push(`[image${block.mimeType ? ` ${block.mimeType}` : ''} — ${block.data ? `${block.data.length} b64 bytes` : 'no data'}]`);
+        }
+        else if (block.type === 'resource' && block.resource) {
+            const r = block.resource;
+            parts.push(r.text ?? `[resource ${r.uri ?? ''}]`);
+        }
+        else {
+            parts.push(JSON.stringify(block));
+        }
+    }
+    return parts.join('\n').trim();
+}
+function toToolParameters(inputSchema) {
+    const schema = (inputSchema && typeof inputSchema === 'object' ? inputSchema : {});
+    return {
+        type: 'object',
+        properties: schema.properties && typeof schema.properties === 'object' ? schema.properties : {},
+        ...(Array.isArray(schema.required) ? { required: schema.required } : {}),
+    };
+}
+function wrapMcpTool(client, serverName, tool) {
+    const fqName = namespacedToolName(serverName, tool.name);
+    const description = `[MCP:${serverName}] ${tool.description || tool.name}`.slice(0, 1024);
+    const definition = {
+        type: 'function',
+        function: {
+            name: fqName,
+            description,
+            parameters: toToolParameters(tool.inputSchema),
+        },
+    };
+    return {
+        definition,
+        categories: ['llm-simple', 'mcp'],
+        async execute(args) {
+            try {
+                const res = await client.callTool({ name: tool.name, arguments: args ?? {} }, undefined, { timeout: CALL_TIMEOUT_MS });
+                const text = flattenToolContent(res.content);
+                if (res.isError) {
+                    return { success: false, error: text || `MCP tool ${fqName} reported an error` };
+                }
+                return { success: true, result: text || '(no output)' };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `MCP tool ${fqName} failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        },
+    };
+}
+function buildTransport(cfg) {
+    if (cfg.url) {
+        const options = cfg.headers
+            ? { requestInit: { headers: cfg.headers } }
+            : undefined;
+        return new StreamableHTTPClientTransport(new URL(cfg.url), options);
+    }
+    if (cfg.command) {
+        return new StdioClientTransport({
+            command: cfg.command,
+            args: cfg.args ?? [],
+            env: { ...getInheritedEnv(), ...(cfg.env ?? {}) },
+            ...(cfg.cwd ? { cwd: cfg.cwd } : {}),
+            stderr: 'ignore',
+        });
+    }
+    throw new Error(`MCP server "${cfg.name}" has no command or url`);
+}
+function getInheritedEnv() {
+    const out = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+}
+function withTimeout(promise, ms, label) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+        if (typeof t.unref === 'function')
+            t.unref();
+        promise.then((v) => {
+            clearTimeout(t);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(t);
+            reject(e);
+        });
+    });
+}
+async function connectOne(cfg) {
+    const client = new Client({ name: 'orquesta-cli', version: pkg.version || '0.0.0' }, { capabilities: {} });
+    let transport;
+    try {
+        transport = buildTransport(cfg);
+    }
+    catch (err) {
+        logger.warn('MCP transport build failed', { server: cfg.name, error: err instanceof Error ? err.message : String(err) });
+        return 0;
+    }
+    await withTimeout(client.connect(transport), CONNECT_TIMEOUT_MS, `MCP connect (${cfg.name})`);
+    const listed = await withTimeout(client.listTools(), CONNECT_TIMEOUT_MS, `MCP listTools (${cfg.name})`);
+    const tools = Array.isArray(listed.tools) ? listed.tools : [];
+    const toolNames = [];
+    for (const t of tools) {
+        if (!t?.name)
+            continue;
+        const wrapped = wrapMcpTool(client, cfg.name, t);
+        toolRegistry.register(wrapped);
+        toolNames.push(wrapped.definition.function.name);
+    }
+    connected.push({ name: cfg.name, client, toolNames });
+    logger.info('MCP server connected', { server: cfg.name, tools: toolNames.length });
+    return toolNames.length;
+}
+export async function initializeMcpServers(cwd = process.cwd()) {
+    const configs = loadMcpServerConfigs(cwd);
+    const result = { servers: 0, tools: 0, errors: [] };
+    if (configs.length === 0)
+        return result;
+    logger.enter('initializeMcpServers', { count: configs.length });
+    await Promise.all(configs.map(async (cfg) => {
+        try {
+            const n = await connectOne(cfg);
+            result.servers += 1;
+            result.tools += n;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            logger.warn('MCP server failed to connect', { server: cfg.name, error });
+            result.errors.push({ server: cfg.name, error });
+        }
+    }));
+    logger.exit('initializeMcpServers', result);
+    return result;
+}
+export function getConnectedMcpServers() {
+    return connected.map((c) => ({ name: c.name, tools: [...c.toolNames] }));
+}
+export async function disconnectMcpServers() {
+    await Promise.all(connected.map(async (c) => {
+        try {
+            await c.client.close();
+        }
+        catch {
+        }
+    }));
+    connected.length = 0;
+}
+//# sourceMappingURL=mcp-client.js.map

package/dist/tools/mcp/mcp-config.d.ts

@@ -0,0 +1,4 @@
+import { McpServerConfig } from '../../types/index.js';
+export declare function normalizeSource(parsed: unknown): McpServerConfig[];
+export declare function loadMcpServerConfigs(cwd?: string): McpServerConfig[];
+//# sourceMappingURL=mcp-config.d.ts.map