orquesta-cli 0.2.107 → 0.2.111

package/dist/cli.js

@@ -28,7 +28,7 @@ import { sessionManager } from './core/session/session-manager.js';
 import { connectWithToken, showConnectionStatus, disconnectFromOrquesta, switchProject } from './setup/first-run-setup.js';
 import { syncOrquestaConfigs } from './orquesta/config-sync.js';
 import { scanProviders, scanProvider, toEndpointConfig } from './core/config/auto-detect.js';
-import { PROVIDERS } from './core/config/providers.js';
+import { getProviders, refreshCatalogFromServer } from './core/config/providers.js';
 import { shouldShowOnboarding, runOnboarding } from './core/onboarding.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -224,7 +224,7 @@ program
                 console.log(chalk.yellow('\nNo LLM providers detected.'));
                 console.log(chalk.dim('Set environment variables (e.g., OPENAI_API_KEY) or start a local provider (Ollama, LM Studio).'));
                 console.log(chalk.dim('\nSupported providers:'));
-                for (const p of PROVIDERS) {
+                for (const p of getProviders()) {
                     const envHint = p.envVars.length > 0 ? chalk.dim(` (${p.envVars[0]})`) : p.isLocal ? chalk.dim(` (port ${p.localPort})`) : '';
                     console.log(chalk.white(`  ${p.name}${envHint}`));
                 }
@@ -265,7 +265,7 @@ program
             const detected = await scanProvider(options.addProvider);
             if (!detected) {
                 spinner.fail(chalk.red(`Provider '${options.addProvider}' not found or not available`));
-                const provider = PROVIDERS.find(p => p.id === options.addProvider);
+                const provider = getProviders().find(p => p.id === options.addProvider);
                 if (provider && provider.envVars.length > 0) {
                     console.log(chalk.dim(`Set ${provider.envVars[0]} environment variable and try again.`));
                 }
@@ -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();
         }
@@ -495,5 +517,6 @@ program.on('command:*', () => {
     console.log(chalk.white('\nUse /help in interactive mode for more help.\n'));
     process.exit(1);
 });
+void refreshCatalogFromServer();
 program.parse(process.argv);
 //# sourceMappingURL=cli.js.map

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)

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/auto-detect.js

@@ -1,9 +1,9 @@
 import axios from 'axios';
-import { PROVIDERS, buildAuthHeaders } from './providers.js';
+import { getProviders, buildAuthHeaders } from './providers.js';
 export async function scanProviders() {
     const detected = [];
     const notFound = [];
-    for (const provider of PROVIDERS.filter((p) => !p.isLocal)) {
+    for (const provider of getProviders().filter((p) => !p.isLocal)) {
         const apiKey = findEnvVar(provider.envVars);
         if (apiKey) {
             const models = await fetchModels(provider, apiKey).catch(() => []);
@@ -18,7 +18,7 @@ export async function scanProviders() {
             notFound.push(provider.id);
         }
     }
-    const localProbes = PROVIDERS.filter((p) => p.isLocal).map(async (provider) => {
+    const localProbes = getProviders().filter((p) => p.isLocal).map(async (provider) => {
         const running = await probeLocal(provider);
         if (running) {
             const models = await fetchModels(provider, '').catch(() => []);
@@ -36,7 +36,7 @@ export async function scanProviders() {
     return { detected, notFound };
 }
 export async function scanProvider(providerId, apiKey) {
-    const provider = PROVIDERS.find((p) => p.id === providerId);
+    const provider = getProviders().find((p) => p.id === providerId);
     if (!provider)
         return null;
     const key = apiKey || findEnvVar(provider.envVars) || '';

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/config/providers.d.ts

@@ -22,6 +22,9 @@ export interface ProviderDefinition {
     healthCheckPath?: string;
 }
 export declare const PROVIDERS: ProviderDefinition[];
+export declare function refreshCatalogFromServer(timeoutMs?: number): Promise<boolean>;
+export declare function getCatalogVersion(): number;
+export declare function getProviders(): ProviderDefinition[];
 export declare function getProvider(id: string): ProviderDefinition | undefined;
 export declare function detectProviderFromUrl(baseUrl: string): ProviderDefinition | undefined;
 export declare function modelHasCapability(providerId: string, modelId: string, capability: ModelCapability): boolean;

package/dist/core/config/providers.js

@@ -1,3 +1,6 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 export const PROVIDERS = [
     {
         id: 'openai',
@@ -302,17 +305,98 @@ export const PROVIDERS = [
         knownModels: [],
     },
 ];
+const CATALOG_CACHE_DIR = path.join(os.homedir(), '.orquesta-cli');
+const CATALOG_CACHE_FILE = path.join(CATALOG_CACHE_DIR, 'catalog.json');
+const CATALOG_ENDPOINT_PATH = '/api/orquesta-cli/catalog';
+let effectiveProviders = PROVIDERS;
+let effectiveVersion = 0;
+function overlayProviders(incoming) {
+    const byId = new Map();
+    for (const p of PROVIDERS)
+        byId.set(p.id, p);
+    for (const p of incoming) {
+        if (p && typeof p.id === 'string' && Array.isArray(p.knownModels)) {
+            byId.set(p.id, p);
+        }
+    }
+    return Array.from(byId.values());
+}
+function isValidCatalogProviders(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((p) => p &&
+            typeof p.id === 'string' &&
+            typeof p.baseUrl === 'string' &&
+            Array.isArray(p.knownModels)));
+}
+function seedCatalogFromDisk() {
+    try {
+        const raw = fs.readFileSync(CATALOG_CACHE_FILE, 'utf-8');
+        const cache = JSON.parse(raw);
+        if (isValidCatalogProviders(cache.providers)) {
+            effectiveProviders = overlayProviders(cache.providers);
+            effectiveVersion = typeof cache.version === 'number' ? cache.version : 0;
+        }
+    }
+    catch {
+    }
+}
+seedCatalogFromDisk();
+function catalogUrl() {
+    const base = process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com';
+    return base.replace(/\/$/, '') + CATALOG_ENDPOINT_PATH;
+}
+export async function refreshCatalogFromServer(timeoutMs = 4000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        const res = await fetch(catalogUrl(), {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return false;
+        const json = (await res.json());
+        if (!isValidCatalogProviders(json.providers))
+            return false;
+        effectiveProviders = overlayProviders(json.providers);
+        effectiveVersion = typeof json.version === 'number' ? json.version : effectiveVersion;
+        try {
+            if (!fs.existsSync(CATALOG_CACHE_DIR))
+                fs.mkdirSync(CATALOG_CACHE_DIR, { recursive: true });
+            const cache = {
+                version: effectiveVersion,
+                providers: json.providers,
+                fetchedAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(CATALOG_CACHE_FILE, JSON.stringify(cache, null, 2));
+        }
+        catch {
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getCatalogVersion() {
+    return effectiveVersion;
+}
+export function getProviders() {
+    return effectiveProviders;
+}
 export function getProvider(id) {
-    return PROVIDERS.find((p) => p.id === id);
+    return effectiveProviders.find((p) => p.id === id);
 }
 export function detectProviderFromUrl(baseUrl) {
     const url = baseUrl.toLowerCase();
-    for (const provider of PROVIDERS) {
+    for (const provider of effectiveProviders) {
         const providerHost = new URL(provider.baseUrl).hostname;
         if (url.includes(providerHost))
             return provider;
     }
-    for (const provider of PROVIDERS.filter((p) => p.isLocal && p.localPort)) {
+    for (const provider of effectiveProviders.filter((p) => p.isLocal && p.localPort)) {
         if (url.includes(`:${provider.localPort}`))
             return provider;
     }

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