orquesta-cli 0.2.107 → 0.2.111

package/dist/core/lsp/index.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { findServerForFile } from './server-registry.js';
+import { getOrCreateClient, shutdownAllLspClients, getActiveLspClientCount } from './lsp-client.js';
+import { configManager } from '../config/config-manager.js';
+import { logger } from '../../utils/logger.js';
+const ROOT_MARKERS = ['tsconfig.json', 'package.json', 'pyproject.toml', 'go.mod', 'Cargo.toml', '.git'];
+function findProjectRoot(absPath) {
+    let dir = path.dirname(absPath);
+    for (;;) {
+        for (const marker of ROOT_MARKERS) {
+            if (fs.existsSync(path.join(dir, marker)))
+                return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return path.dirname(absPath);
+        dir = parent;
+    }
+}
+function isEnabled() {
+    try {
+        return configManager.isLspEnabled();
+    }
+    catch {
+        return true;
+    }
+}
+const SEVERITY_LABEL = { 1: 'error', 2: 'warning', 3: 'info', 4: 'hint' };
+export function formatDiagnostics(relPath, diags) {
+    const relevant = diags.filter((d) => d.severity <= 2);
+    if (relevant.length === 0)
+        return '';
+    relevant.sort((a, b) => a.severity - b.severity || a.line - b.line);
+    const MAX = 20;
+    const shown = relevant.slice(0, MAX);
+    const lines = shown.map((d) => {
+        const label = SEVERITY_LABEL[d.severity] ?? 'error';
+        const src = d.source ? ` (${d.source})` : '';
+        return `  ${label} [${d.line + 1}:${d.character + 1}]${src}: ${d.message.replace(/\s+/g, ' ').trim()}`;
+    });
+    const errorCount = relevant.filter((d) => d.severity === 1).length;
+    const warnCount = relevant.length - errorCount;
+    const header = `Diagnostics for ${relPath} — ${errorCount} error(s), ${warnCount} warning(s):`;
+    const more = relevant.length > MAX ? `\n  …and ${relevant.length - MAX} more` : '';
+    return `\n\n${header}\n${lines.join('\n')}${more}`;
+}
+export async function getDiagnosticsForFile(absPath) {
+    if (!isEnabled())
+        return '';
+    try {
+        const server = findServerForFile(absPath);
+        if (!server)
+            return '';
+        let text;
+        try {
+            text = fs.readFileSync(absPath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+        const root = findProjectRoot(absPath);
+        const client = getOrCreateClient(server.def, root);
+        const diags = await client.getDiagnostics(absPath, text);
+        const rel = path.relative(process.cwd(), absPath) || path.basename(absPath);
+        return formatDiagnostics(rel, diags);
+    }
+    catch (err) {
+        logger.warn('LSP diagnostics failed', { path: absPath, error: err instanceof Error ? err.message : String(err) });
+        return '';
+    }
+}
+export { shutdownAllLspClients, getActiveLspClientCount };
+export { findServerForFile, getServerDefs, resolveServerBinary } from './server-registry.js';
+//# sourceMappingURL=index.js.map

package/dist/core/lsp/jsonrpc.d.ts

@@ -0,0 +1,18 @@
+export interface JsonRpcMessage {
+    jsonrpc: '2.0';
+    id?: number | string;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export declare function encodeMessage(msg: JsonRpcMessage): Buffer;
+export declare class MessageDecoder {
+    private buffer;
+    push(chunk: Buffer): JsonRpcMessage[];
+}
+//# sourceMappingURL=jsonrpc.d.ts.map

package/dist/core/lsp/jsonrpc.js

@@ -0,0 +1,38 @@
+export function encodeMessage(msg) {
+    const json = JSON.stringify(msg);
+    const body = Buffer.from(json, 'utf-8');
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii');
+    return Buffer.concat([header, body]);
+}
+export class MessageDecoder {
+    buffer = Buffer.alloc(0);
+    push(chunk) {
+        this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+        const out = [];
+        for (;;) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.subarray(0, headerEnd).toString('ascii');
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(match[1], 10);
+            const bodyStart = headerEnd + 4;
+            const bodyEnd = bodyStart + contentLength;
+            if (this.buffer.length < bodyEnd)
+                break;
+            const body = this.buffer.subarray(bodyStart, bodyEnd).toString('utf-8');
+            this.buffer = this.buffer.subarray(bodyEnd);
+            try {
+                out.push(JSON.parse(body));
+            }
+            catch {
+            }
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=jsonrpc.js.map

package/dist/core/lsp/lsp-client.d.ts

@@ -0,0 +1,40 @@
+import { fileURLToPath } from 'url';
+import { LspServerDef } from './server-registry.js';
+export interface Diagnostic {
+    severity: number;
+    line: number;
+    character: number;
+    message: string;
+    source?: string;
+}
+declare class LspClient {
+    private def;
+    private rootDir;
+    private proc;
+    private decoder;
+    private nextId;
+    private pendingRequests;
+    private diagnostics;
+    private diagWaiters;
+    private openDocs;
+    private initialized;
+    private version;
+    constructor(def: LspServerDef, rootDir: string);
+    private send;
+    private request;
+    private notify;
+    private handleMessage;
+    start(): Promise<void>;
+    getDiagnostics(absPath: string, text: string): Promise<Diagnostic[]>;
+    private onceDiagnostics;
+    private delay;
+    private waitFor;
+    private teardown;
+    stop(): Promise<void>;
+}
+export declare function getOrCreateClient(def: LspServerDef, rootDir: string): LspClient;
+export declare function shutdownAllLspClients(): Promise<void>;
+export declare function getActiveLspClientCount(): number;
+export { fileURLToPath };
+export type { LspClient };
+//# sourceMappingURL=lsp-client.d.ts.map

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