orquesta-cli 0.2.108 → 0.2.112

package/dist/cli.js

@@ -349,6 +349,16 @@ program
         const toolsPromise = initializeOptionalTools().then(() => {
             logger.flow('Optional tools initialized');
         });
+        const mcpPromise = import('./tools/mcp/index.js')
+            .then(({ initializeMcpServers }) => initializeMcpServers())
+            .then((r) => {
+            if (r.servers > 0 || r.errors.length > 0) {
+                logger.flow('MCP initialized', { servers: r.servers, tools: r.tools, errors: r.errors.length });
+            }
+        })
+            .catch((error) => {
+            logger.warn('MCP init failed', { error: error instanceof Error ? error.message : String(error) });
+        });
         const syncPromise = (configManager.hasOrquestaConnection() && configManager.shouldAutoSync())
             ? syncOrquestaConfigs().then(syncResult => {
                 if (syncResult.success && (syncResult.added > 0 || syncResult.updated > 0)) {
@@ -375,7 +385,7 @@ program
             logger.flow('No LLM endpoints configured');
         }
         await Promise.race([
-            Promise.all([toolsPromise, syncPromise]),
+            Promise.all([toolsPromise, syncPromise, mcpPromise]),
             new Promise(resolve => setTimeout(resolve, Number(process.env['ORQUESTA_INIT_TIMEOUT_MS']) || 12000).unref?.()),
         ]);
         spinner.stop();
@@ -414,6 +424,18 @@ program
             sessionId: sessionManager.getCurrentSessionId(),
             exitReason: 'normal',
         });
+        try {
+            const { disconnectMcpServers } = await import('./tools/mcp/index.js');
+            await disconnectMcpServers();
+        }
+        catch {
+        }
+        try {
+            const { shutdownAllLspClients } = await import('./core/lsp/index.js');
+            await shutdownAllLspClients();
+        }
+        catch {
+        }
         if (cleanup) {
             await cleanup();
         }

package/dist/core/commands/help.js

@@ -6,12 +6,16 @@ export const helpCommand = {
 Available commands:
   /exit, /quit    - Exit the application
   /clear          - Clear conversation and TODOs
+  /undo           - Revert the file changes from the last turn
+  /redo           - Re-apply the changes undone by /undo
   /compact        - Compact conversation to free up context
   /memory         - Persistent memory: /memory add <note> | list | remove <n> | clear
   /settings       - Open settings menu
   /model          - Switch between LLM models
   /project        - Switch between Orquesta projects
   /tool           - Enable/disable optional tools (Browser, Background)
+  /mcp            - List connected MCP servers and their tools
+  /lsp            - LSP diagnostics after edits: status | on | off
   /load           - Load a saved session
   /usage          - Show token usage statistics
   /cost           - Estimated USD spend this process (by model)
@@ -26,6 +30,7 @@ Available commands:
 
 Keyboard shortcuts:
   Ctrl+C          - Exit
+  Ctrl+S          - Send now / steer the running task (no wait for next turn)
   Ctrl+T          - Toggle TODO details
   ESC             - Interrupt current execution
   @               - File browser

package/dist/core/commands/index.js

@@ -4,10 +4,17 @@ import { compactCommand } from './compact.js';
 import { memoryCommand } from './memory.js';
 import { recallCommand } from './recall.js';
 import { helpCommand } from './help.js';
+import { mcpCommand } from './mcp.js';
+import { undoCommand, redoCommand } from './undo.js';
+import { lspCommand } from './lsp.js';
 commandRegistry.register(clearCommand);
 commandRegistry.register(compactCommand);
 commandRegistry.register(memoryCommand);
 commandRegistry.register(recallCommand);
 commandRegistry.register(helpCommand);
+commandRegistry.register(mcpCommand);
+commandRegistry.register(undoCommand);
+commandRegistry.register(redoCommand);
+commandRegistry.register(lspCommand);
 export { commandRegistry } from './registry.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const lspCommand: SlashCommand;
+//# sourceMappingURL=lsp.d.ts.map

package/dist/core/commands/lsp.js

@@ -0,0 +1,37 @@
+import { configManager } from '../config/config-manager.js';
+import { getServerDefs, resolveServerBinary, getActiveLspClientCount } from '../lsp/index.js';
+export const lspCommand = {
+    name: '/lsp',
+    description: 'LSP diagnostics: /lsp | on | off',
+    async execute(context, rawInput) {
+        const reply = (content) => {
+            const updatedMessages = [...context.messages, { role: 'assistant', content }];
+            context.setMessages(updatedMessages);
+            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+        };
+        const arg = rawInput.slice('/lsp'.length).trim().toLowerCase();
+        if (arg === 'on' || arg === 'enable') {
+            await configManager.setLspEnabled(true);
+            return reply('✓ LSP diagnostics enabled.');
+        }
+        if (arg === 'off' || arg === 'disable') {
+            await configManager.setLspEnabled(false);
+            return reply('✓ LSP diagnostics disabled.');
+        }
+        const enabled = configManager.isLspEnabled();
+        const lines = [
+            `🩺 LSP diagnostics: ${enabled ? 'ON' : 'OFF'}  (${getActiveLspClientCount()} server(s) running)`,
+            '',
+            'Language servers (✓ = found on PATH):',
+        ];
+        for (const def of getServerDefs()) {
+            const bin = resolveServerBinary(def.command);
+            const mark = bin ? '✓' : '·';
+            const where = bin ? `→ ${bin}` : 'not installed';
+            lines.push(`  ${mark} ${def.id} (${def.extensions.join(', ')})  ${def.command} ${where}`);
+        }
+        lines.push('', 'Toggle with /lsp on | /lsp off');
+        return reply(lines.join('\n'));
+    },
+};
+//# sourceMappingURL=lsp.js.map

package/dist/core/commands/mcp.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const mcpCommand: SlashCommand;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/core/commands/mcp.js

@@ -0,0 +1,46 @@
+import { getConnectedMcpServers } from '../../tools/mcp/index.js';
+import { loadMcpServerConfigs } from '../../tools/mcp/mcp-config.js';
+export const mcpCommand = {
+    name: '/mcp',
+    description: 'List connected MCP servers and their tools',
+    async execute(context) {
+        const reply = (content) => {
+            const updatedMessages = [...context.messages, { role: 'assistant', content }];
+            context.setMessages(updatedMessages);
+            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+        };
+        const live = getConnectedMcpServers();
+        const configured = loadMcpServerConfigs();
+        if (configured.length === 0 && live.length === 0) {
+            return reply('No MCP servers configured.\n\n' +
+                'Add one to ~/.orquesta-cli/config.json:\n' +
+                '  "mcpServers": [\n' +
+                '    { "name": "filesystem", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "."] }\n' +
+                '  ]\n\n' +
+                'Or drop a Claude-compatible .mcp.json in the project root.');
+        }
+        const liveByName = new Map(live.map((s) => [s.name, s]));
+        const lines = [`🔌 MCP servers (${live.length} connected / ${configured.length} configured):`];
+        for (const cfg of configured) {
+            const conn = liveByName.get(cfg.name);
+            const transport = cfg.url ? `http ${cfg.url}` : `stdio ${cfg.command ?? ''}`.trim();
+            if (conn) {
+                lines.push(`\n  ✓ ${cfg.name}  (${transport}) — ${conn.tools.length} tool(s)`);
+                for (const t of conn.tools)
+                    lines.push(`      • ${t}`);
+            }
+            else {
+                lines.push(`\n  ✗ ${cfg.name}  (${transport}) — not connected`);
+            }
+        }
+        for (const s of live) {
+            if (!configured.some((c) => c.name === s.name)) {
+                lines.push(`\n  ✓ ${s.name}  (runtime) — ${s.tools.length} tool(s)`);
+                for (const t of s.tools)
+                    lines.push(`      • ${t}`);
+            }
+        }
+        return reply(lines.join('\n'));
+    },
+};
+//# sourceMappingURL=mcp.js.map

package/dist/core/commands/undo.d.ts

@@ -0,0 +1,4 @@
+import { SlashCommand } from './types.js';
+export declare const undoCommand: SlashCommand;
+export declare const redoCommand: SlashCommand;
+//# sourceMappingURL=undo.d.ts.map

package/dist/core/commands/undo.js

@@ -0,0 +1,45 @@
+import { fileSnapshotStore } from '../file-snapshot-store.js';
+import * as path from 'path';
+function rel(p) {
+    const r = path.relative(process.cwd(), p);
+    return r && !r.startsWith('..') ? r : p;
+}
+function formatResult(verb, result) {
+    const lines = [`↩️  ${verb} "${result.label}" — ${result.restored.length} file(s):`];
+    for (const p of result.restored)
+        lines.push(`   • ${rel(p)}`);
+    if (result.failed.length > 0) {
+        lines.push(`   ⚠️  ${result.failed.length} could not be restored:`);
+        for (const p of result.failed)
+            lines.push(`   ✗ ${rel(p)}`);
+    }
+    return lines.join('\n');
+}
+function reply(context, content) {
+    const updatedMessages = [...context.messages, { role: 'assistant', content }];
+    context.setMessages(updatedMessages);
+    return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+}
+export const undoCommand = {
+    name: '/undo',
+    description: 'Revert the file changes from the last turn',
+    async execute(context) {
+        const result = await fileSnapshotStore.undo();
+        if (!result) {
+            return reply(context, 'Nothing to undo. (Only agent create_file/edit_file changes are tracked — not bash edits.)');
+        }
+        return reply(context, formatResult('Reverted', result));
+    },
+};
+export const redoCommand = {
+    name: '/redo',
+    description: 'Re-apply the changes undone by /undo',
+    async execute(context) {
+        const result = await fileSnapshotStore.redo();
+        if (!result) {
+            return reply(context, 'Nothing to redo.');
+        }
+        return reply(context, formatResult('Re-applied', result));
+    },
+};
+//# sourceMappingURL=undo.js.map

package/dist/core/config/config-manager.d.ts

@@ -1,4 +1,4 @@
-import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig, OrchestrationConfig, OrchestrationRole } from '../../types/index.js';
+import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig, OrchestrationConfig, OrchestrationRole, McpServerConfig, LspServerConfig } from '../../types/index.js';
 export declare class ConfigManager {
     private config;
     private initialized;
@@ -62,6 +62,12 @@ export declare class ConfigManager {
     setRefinerEnabled(enabled: boolean): Promise<void>;
     isSingleAgentMode(): boolean;
     setSingleAgentMode(enabled: boolean): Promise<void>;
+    getMcpServers(): McpServerConfig[];
+    addMcpServer(server: McpServerConfig): Promise<void>;
+    removeMcpServer(name: string): Promise<boolean>;
+    getLspServers(): LspServerConfig[];
+    isLspEnabled(): boolean;
+    setLspEnabled(enabled: boolean): Promise<void>;
     isWorktreeIsolationEnabled(): boolean;
     setWorktreeIsolationEnabled(enabled: boolean): Promise<void>;
 }

package/dist/core/config/config-manager.js

@@ -425,6 +425,42 @@ export class ConfigManager {
         config.orchestration.singleAgentMode = enabled;
         await this.saveConfig();
     }
+    getMcpServers() {
+        return this.config?.mcpServers ?? [];
+    }
+    async addMcpServer(server) {
+        const config = this.getConfig();
+        const list = config.mcpServers ?? [];
+        const idx = list.findIndex((s) => s.name === server.name);
+        if (idx >= 0)
+            list[idx] = server;
+        else
+            list.push(server);
+        config.mcpServers = list;
+        await this.saveConfig();
+    }
+    async removeMcpServer(name) {
+        const config = this.getConfig();
+        const list = config.mcpServers ?? [];
+        const next = list.filter((s) => s.name !== name);
+        const removed = next.length !== list.length;
+        if (removed) {
+            config.mcpServers = next;
+            await this.saveConfig();
+        }
+        return removed;
+    }
+    getLspServers() {
+        return this.config?.lspServers ?? [];
+    }
+    isLspEnabled() {
+        return this.config?.lsp?.enabled ?? true;
+    }
+    async setLspEnabled(enabled) {
+        const config = this.getConfig();
+        config.lsp = { ...config.lsp, enabled };
+        await this.saveConfig();
+    }
     isWorktreeIsolationEnabled() {
         return this.config?.orchestration?.worktreeIsolation ?? false;
     }

package/dist/core/file-snapshot-store.d.ts

@@ -0,0 +1,25 @@
+export interface UndoRedoResult {
+    label: string;
+    restored: string[];
+    failed: string[];
+}
+declare class FileSnapshotStore {
+    private current;
+    private undoStack;
+    private redoStack;
+    beginTurn(label: string): void;
+    seal(): void;
+    record(absPath: string, priorContent: string | null): void;
+    private apply;
+    undo(): Promise<UndoRedoResult | null>;
+    redo(): Promise<UndoRedoResult | null>;
+    getStatus(): {
+        undo: number;
+        redo: number;
+        pendingEdits: number;
+    };
+    reset(): void;
+}
+export declare const fileSnapshotStore: FileSnapshotStore;
+export {};
+//# sourceMappingURL=file-snapshot-store.d.ts.map

package/dist/core/file-snapshot-store.js

@@ -0,0 +1,104 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { invalidateCache } from './file-cache.js';
+import { logger } from '../utils/logger.js';
+const MAX_SNAPSHOT_BYTES = 5 * 1024 * 1024;
+const MAX_STACK = 50;
+class FileSnapshotStore {
+    current = null;
+    undoStack = [];
+    redoStack = [];
+    beginTurn(label) {
+        this.seal();
+        this.redoStack = [];
+        this.current = { label: label.slice(0, 120), ts: Date.now(), entries: [] };
+    }
+    seal() {
+        if (this.current && this.current.entries.length > 0) {
+            this.undoStack.push(this.current);
+            if (this.undoStack.length > MAX_STACK)
+                this.undoStack.shift();
+        }
+        this.current = null;
+    }
+    record(absPath, priorContent) {
+        if (!this.current) {
+            this.current = { label: '(edits)', ts: Date.now(), entries: [] };
+        }
+        if (this.current.entries.some((e) => e.path === absPath))
+            return;
+        if (priorContent !== null && Buffer.byteLength(priorContent, 'utf-8') > MAX_SNAPSHOT_BYTES) {
+            logger.warn('Skipping snapshot: file too large for undo', { path: absPath });
+            return;
+        }
+        this.current.entries.push({ path: absPath, content: priorContent });
+    }
+    async apply(cp) {
+        const restored = [];
+        const failed = [];
+        for (const entry of cp.entries) {
+            let captured;
+            try {
+                captured = await fs.readFile(entry.path, 'utf-8');
+            }
+            catch {
+                captured = null;
+            }
+            try {
+                if (entry.content === null) {
+                    await fs.rm(entry.path, { force: true });
+                }
+                else {
+                    await fs.mkdir(path.dirname(entry.path), { recursive: true });
+                    await fs.writeFile(entry.path, entry.content, 'utf-8');
+                }
+                invalidateCache(entry.path);
+                entry.content = captured;
+                restored.push(entry.path);
+            }
+            catch (err) {
+                logger.warn('Undo/redo failed for path', {
+                    path: entry.path,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                failed.push(entry.path);
+            }
+        }
+        return { label: cp.label, restored, failed };
+    }
+    async undo() {
+        this.seal();
+        const cp = this.undoStack.pop();
+        if (!cp)
+            return null;
+        const result = await this.apply(cp);
+        this.redoStack.push(cp);
+        if (this.redoStack.length > MAX_STACK)
+            this.redoStack.shift();
+        return result;
+    }
+    async redo() {
+        const cp = this.redoStack.pop();
+        if (!cp)
+            return null;
+        const result = await this.apply(cp);
+        this.undoStack.push(cp);
+        if (this.undoStack.length > MAX_STACK)
+            this.undoStack.shift();
+        return result;
+    }
+    getStatus() {
+        return {
+            undo: this.undoStack.length + (this.current && this.current.entries.length > 0 ? 1 : 0),
+            redo: this.redoStack.length,
+            pendingEdits: this.current?.entries.length ?? 0,
+        };
+    }
+    reset() {
+        this.current = null;
+        this.undoStack = [];
+        this.redoStack = [];
+    }
+}
+export const fileSnapshotStore = new FileSnapshotStore();
+//# sourceMappingURL=file-snapshot-store.js.map

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

@@ -0,0 +1,6 @@
+import { shutdownAllLspClients, getActiveLspClientCount, Diagnostic } from './lsp-client.js';
+export declare function formatDiagnostics(relPath: string, diags: Diagnostic[]): string;
+export declare function getDiagnosticsForFile(absPath: string): Promise<string>;
+export { shutdownAllLspClients, getActiveLspClientCount };
+export { findServerForFile, getServerDefs, resolveServerBinary } from './server-registry.js';
+//# sourceMappingURL=index.d.ts.map

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