@theupsider/lsp-mcp 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-compat.js");
+const zod_json_schema_compat_js_1 = require("@modelcontextprotocol/sdk/server/zod-json-schema-compat.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const lifecycle_manager_1 = require("../lsp/lifecycle-manager");
+const shared_1 = require("./tools/shared");
+const read_tools_1 = require("./tools/read-tools");
+const write_tools_1 = require("./tools/write-tools");
+class McpServer {
+    currentManager = null;
+    currentRoot = null;
+    initialized = false;
+    logLevel;
+    createLifecycleManager;
+    server;
+    tools = new Map();
+    constructor(logLevel = 'info', createLifecycleManager = (root, level) => new lifecycle_manager_1.LifecycleManager(root, level)) {
+        this.logLevel = logLevel;
+        this.createLifecycleManager = createLifecycleManager;
+        this.server = new mcp_js_1.McpServer({ name: '@theupsider/lsp-mcp', version: '0.1.0' });
+    }
+    async start() {
+        const lifecycleProxy = this.createLifecycleProxy();
+        const registrar = {
+            registerTool: (name, config, handler) => {
+                this.tools.set(name, { name, description: config.description, inputSchema: config.inputSchema, handler });
+            },
+            fromJsonSchema: (schema) => schema
+        };
+        (0, read_tools_1.registerReadTools)(registrar, lifecycleProxy, { initializeManager: async (root, languages) => await this.initializeManager(root, languages) });
+        (0, write_tools_1.registerWriteTools)(registrar, lifecycleProxy);
+        this.configureToolHandlers();
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+    }
+    async initializeManager(root, languages) {
+        const nextManager = this.createLifecycleManager(root, this.logLevel);
+        const previousManager = this.currentManager;
+        if (previousManager) {
+            await previousManager.shutdown();
+            this.currentManager = null;
+            this.currentRoot = null;
+        }
+        await nextManager.start(languages);
+        this.setManager(nextManager);
+        this.currentRoot = root;
+        return { root, health: nextManager.getHealth() };
+    }
+    setManager(lifecycleManager) {
+        this.currentManager = lifecycleManager;
+        this.initialized = true;
+    }
+    async shutdown() {
+        const activeManager = this.currentManager;
+        this.currentManager = null;
+        this.currentRoot = null;
+        this.initialized = false;
+        if (activeManager) {
+            await activeManager.shutdown();
+        }
+    }
+    configureToolHandlers() {
+        this.server.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: this.listTools() }));
+        this.server.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const toolName = request.params.name;
+            if (toolName === 'lsp_init' && this.initialized) {
+                return (0, shared_1.failure)(`Already initialized at ${this.currentRoot ?? 'unknown'}. Call lsp_init again with a new root to switch projects.`);
+            }
+            if (toolName !== 'lsp_init' && !this.initialized) {
+                return (0, shared_1.noProjectRootResult)();
+            }
+            const tool = this.tools.get(toolName);
+            if (!tool) {
+                return (0, shared_1.failure)(`Tool not found: ${toolName}`);
+            }
+            return await tool.handler(isRecord(request.params.arguments) ? request.params.arguments : {});
+        });
+    }
+    listTools() {
+        return [...this.tools.values()].map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: this.toInputSchema(tool.inputSchema)
+        }));
+    }
+    toInputSchema(schema) {
+        const normalized = (0, zod_compat_js_1.normalizeObjectSchema)(schema);
+        const result = normalized
+            ? (0, zod_json_schema_compat_js_1.toJsonSchemaCompat)(normalized, { strictUnions: true, pipeStrategy: 'input' })
+            : {};
+        return { type: 'object', ...result };
+    }
+    createLifecycleProxy() {
+        return {
+            getClientForFile: (filePath) => this.requireManager().getClientForFile(filePath),
+            getReadyClients: (language) => this.requireManager().getReadyClients(language),
+            getFileDiagnostics: (filePath) => this.requireManager().getFileDiagnostics(filePath),
+            getWorkspaceDiagnostics: (language) => this.requireManager().getWorkspaceDiagnostics(language),
+            getHealth: () => this.requireManager().getHealth(),
+            ensureLanguageForFile: async (filePath) => await this.requireManager().ensureLanguageForFile(filePath)
+        };
+    }
+    requireManager() {
+        if (this.currentManager === null) {
+            throw new Error("No project root set. Call lsp_init({ root: '/path/to/project' }) first.");
+        }
+        return this.currentManager;
+    }
+}
+exports.McpServer = McpServer;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

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

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerReadTools = registerReadTools;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const formatters_1 = require("../formatters");
+const uri_1 = require("../../utils/uri");
+const shared_1 = require("./shared");
+function registerReadTools(registrar, lifecycleManager, options) {
+    registrar.registerTool('lsp_init', {
+        description: 'Initialize LSP for a project root. Pass languages to pre-warm specific servers; omit to auto-detect from project files (lazy startup per file if none found).',
+        inputSchema: zod_1.z.object({ root: zod_1.z.string(), languages: zod_1.z.array(zod_1.z.string()).optional() })
+    }, async (args) => {
+        return await handleInitTool(args, options);
+    });
+    registrar.registerTool('lsp_hover', { description: 'Show hover information', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({ args, lifecycleManager, method: 'textDocument/hover', timeoutMs: 5000, format: formatters_1.formatHover, raw: (result) => result });
+    });
+    registrar.registerTool('lsp_definition', { description: 'Find definitions', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/definition',
+            timeoutMs: 5000,
+            format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
+            raw: (result) => (0, shared_1.normalizeLocations)(asLocationArray(result))
+        });
+    });
+    registrar.registerTool('lsp_references', { description: 'Find references', inputSchema: positionSchema.extend({ includeDeclaration: zod_1.z.boolean().optional() }) }, async (args) => {
+        const includeDeclaration = args.includeDeclaration === true;
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/references',
+            timeoutMs: 15000,
+            params: (uri, position) => ({ textDocument: { uri }, position, context: { includeDeclaration } }),
+            format: formatters_1.formatReferences,
+            raw: shared_1.normalizeLocations
+        });
+    });
+    registrar.registerTool('lsp_document_symbols', { description: 'List document symbols', inputSchema: zod_1.z.object({ file: zod_1.z.string() }) }, async (args) => {
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/documentSymbol',
+            timeoutMs: 15000,
+            format: formatters_1.formatSymbols,
+            raw: shared_1.normalizeSymbols
+        });
+    });
+    registrar.registerTool('lsp_workspace_symbols', { description: 'Search workspace symbols', inputSchema: zod_1.z.object({ query: zod_1.z.string().default('') }) }, async (args) => {
+        const query = typeof args.query === 'string' ? args.query : '';
+        const results = await Promise.all(lifecycleManager.getReadyClients().map(async (client) => {
+            return await client.request('workspace/symbol', { query }, 30000);
+        }));
+        const merged = results.flat().slice(0, query === '' ? 100 : 500);
+        return (0, shared_1.success)((0, formatters_1.formatSymbols)(merged), (0, shared_1.normalizeSymbols)(merged));
+    });
+    registrar.registerTool('lsp_completion', { description: 'Get completions', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/completion',
+            timeoutMs: 5000,
+            format: (result) => (0, formatters_1.formatCompletion)(asCompletionItems(result)),
+            raw: (result) => asCompletionItems(result)?.slice(0, 50) ?? null
+        });
+    });
+    registrar.registerTool('lsp_diagnostics', { description: 'Show diagnostics', inputSchema: zod_1.z.object({ file: zod_1.z.string().optional(), scope: zod_1.z.enum(['file', 'workspace']).default('file'), language: zod_1.z.string().optional() }) }, async (args) => {
+        const scope = args.scope === 'workspace' ? 'workspace' : 'file';
+        if (scope === 'workspace') {
+            const language = typeof args.language === 'string' ? args.language : undefined;
+            const diagnostics = lifecycleManager.getWorkspaceDiagnostics(language).slice(0, 200);
+            return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, 'workspace'), diagnostics);
+        }
+        const filePath = typeof args.file === 'string' ? args.file : '';
+        const diagnostics = lifecycleManager.getFileDiagnostics(filePath);
+        return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, 'file'), diagnostics);
+    });
+    registrar.registerTool('lsp_signature_help', { description: 'Show signature help', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({ args, lifecycleManager, method: 'textDocument/signatureHelp', timeoutMs: 5000, format: stringifyResult, raw: (result) => result });
+    });
+    registrar.registerTool('lsp_type_definition', { description: 'Find type definitions', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/typeDefinition',
+            timeoutMs: 5000,
+            format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
+            raw: (result) => (0, shared_1.normalizeLocations)(asLocationArray(result))
+        });
+    });
+    registrar.registerTool('lsp_implementation', { description: 'Find implementations', inputSchema: positionSchema }, async (args) => {
+        return await runFileRequest({
+            args,
+            lifecycleManager,
+            method: 'textDocument/implementation',
+            timeoutMs: 5000,
+            format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
+            raw: (result) => (0, shared_1.normalizeLocations)(asLocationArray(result))
+        });
+    });
+    registrar.registerTool('lsp_health', { description: 'Show LSP server health', inputSchema: zod_1.z.object({}) }, async () => {
+        const health = lifecycleManager.getHealth();
+        return (0, shared_1.success)((0, formatters_1.formatHealth)(health), health);
+    });
+}
+async function handleInitTool(args, options) {
+    const root = typeof args.root === 'string' ? args.root : '';
+    if (root.length === 0) {
+        return (0, shared_1.failure)('Project root is required. Provide lsp_init({ root: \'/absolute/path\' }).');
+    }
+    if (!node_path_1.default.isAbsolute(root)) {
+        return (0, shared_1.failure)(`Project root must be an absolute path: ${root}`);
+    }
+    try {
+        const stats = await (0, promises_1.stat)(root);
+        if (!stats.isDirectory()) {
+            return (0, shared_1.failure)(`Project root is not a directory: ${root}`);
+        }
+    }
+    catch {
+        return (0, shared_1.failure)(`Project root does not exist: ${root}`);
+    }
+    const languages = Array.isArray(args.languages)
+        ? args.languages.filter((item) => typeof item === 'string')
+        : undefined;
+    try {
+        const initialized = await options.initializeManager(root, languages);
+        const languageNames = initialized.health.map((entry) => formatLanguageName(entry.language));
+        const started = initialized.health.filter((entry) => entry.status === 'ready').length;
+        const errors = initialized.health.filter((entry) => entry.status === 'error').length;
+        const lazyNote = languageNames.length === 0 ? ' Language servers will start on first file access.' : '';
+        const text = `Initialized LSP for ${initialized.root}. Detected languages: ${formatLanguageList(languageNames)}. LSP servers: ${started} started, ${errors} errors.${lazyNote}`;
+        return {
+            content: [{ type: 'text', text }],
+            text,
+            raw: {
+                root: initialized.root,
+                languages: languageNames,
+                health: initialized.health
+            }
+        };
+    }
+    catch (error) {
+        return (0, shared_1.mapToolError)(error, 30);
+    }
+}
+const positionSchema = zod_1.z.object({
+    file: zod_1.z.string(),
+    line: zod_1.z.number().int(),
+    character: zod_1.z.number().int()
+});
+async function runFileRequest(options) {
+    const filePath = typeof options.args.file === 'string' ? options.args.file : '';
+    await options.lifecycleManager.ensureLanguageForFile(filePath);
+    const client = options.lifecycleManager.getClientForFile(filePath);
+    if (!client) {
+        return (0, shared_1.noServerResult)(filePath);
+    }
+    const position = {
+        line: Number(options.args.line ?? 0),
+        character: Number(options.args.character ?? 0)
+    };
+    const uri = (0, uri_1.pathToUri)(filePath);
+    try {
+        await (0, shared_1.ensureDidOpen)(client, filePath);
+        const result = await client.request(options.method, options.params?.(uri, position) ?? {
+            textDocument: { uri },
+            position
+        }, options.timeoutMs);
+        return (0, shared_1.success)(options.format(result), options.raw(result));
+    }
+    catch (error) {
+        return (0, shared_1.mapToolError)(error, options.timeoutMs / 1000);
+    }
+}
+function asLocationArray(result) {
+    if (!result) {
+        return null;
+    }
+    return Array.isArray(result) ? result : [result];
+}
+function asCompletionItems(result) {
+    if (!result) {
+        return null;
+    }
+    return Array.isArray(result) ? result : result.items;
+}
+function stringifyResult(result) {
+    if (!result) {
+        return 'No result';
+    }
+    return JSON.stringify(result, null, 2);
+}
+function formatLanguageList(languages) {
+    return languages.length === 0 ? 'None' : languages.join(', ');
+}
+function formatLanguageName(language) {
+    if (language.length === 0) {
+        return language;
+    }
+    return `${language[0]?.toUpperCase() ?? ''}${language.slice(1)}`;
+}

package/dist/mcp/tools/shared.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.failure = failure;
+exports.ensureDidOpen = ensureDidOpen;
+exports.clearOpenedFiles = clearOpenedFiles;
+exports.noServerResult = noServerResult;
+exports.noProjectRootResult = noProjectRootResult;
+exports.mapToolError = mapToolError;
+exports.normalizeLocations = normalizeLocations;
+exports.normalizeSymbols = normalizeSymbols;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const uri_1 = require("../../utils/uri");
+const openedFiles = new Set();
+function success(text, raw) {
+    return { content: [{ type: 'text', text }], raw };
+}
+function failure(text, raw = null) {
+    return { content: [{ type: 'text', text }], error: true, raw };
+}
+async function ensureDidOpen(client, filePath) {
+    if (openedFiles.has(filePath)) {
+        return;
+    }
+    const text = await (0, promises_1.readFile)(filePath, 'utf8');
+    client.notify('textDocument/didOpen', {
+        textDocument: {
+            uri: (0, uri_1.pathToUri)(filePath),
+            languageId: languageIdForFile(filePath),
+            version: 1,
+            text
+        }
+    });
+    openedFiles.add(filePath);
+}
+function clearOpenedFiles() {
+    openedFiles.clear();
+}
+function noServerResult(filePath) {
+    return failure(`No language server available for ${node_path_1.default.extname(filePath) || 'unknown'} files. Run lsp_health for details.`);
+}
+function noProjectRootResult() {
+    const text = "No project root set. Call lsp_init({ root: '/path/to/project' }) first.";
+    return { content: [{ type: 'text', text }], text, error: true, raw: null };
+}
+function mapToolError(error, timeoutSeconds) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('timed out')) {
+        return failure(`Operation timed out after ${timeoutSeconds}s — try a more specific query or check the LSP server health`);
+    }
+    if (message.includes('LSP server exited')) {
+        return failure('Der Language Server ist neu gestartet, bitte versuche es erneut.');
+    }
+    return failure(message, error);
+}
+function normalizeLocations(locations) {
+    if (!locations || locations.length === 0) {
+        return null;
+    }
+    return locations.map((location) => ({ path: (0, uri_1.uriToPath)(location.uri), range: location.range }));
+}
+function normalizeSymbols(symbols) {
+    if (!symbols || symbols.length === 0) {
+        return null;
+    }
+    const normalized = [];
+    for (const symbol of symbols) {
+        if ('location' in symbol) {
+            normalized.push({
+                name: symbol.name,
+                kind: symbol.kind,
+                path: (0, uri_1.uriToPath)(symbol.location.uri),
+                range: symbol.location.range
+            });
+            continue;
+        }
+        normalized.push({ name: symbol.name, kind: symbol.kind, range: symbol.range, selectionRange: symbol.selectionRange });
+    }
+    return normalized;
+}
+function languageIdForFile(filePath) {
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    const languageMap = {
+        '.ts': 'typescript',
+        '.tsx': 'typescriptreact',
+        '.js': 'javascript',
+        '.jsx': 'javascriptreact',
+        '.py': 'python',
+        '.go': 'go',
+        '.rs': 'rust',
+        '.java': 'java',
+        '.cs': 'csharp',
+        '.php': 'php',
+        '.rb': 'ruby',
+        '.kt': 'kotlin',
+        '.swift': 'swift',
+        '.c': 'c',
+        '.cpp': 'cpp',
+        '.h': 'c'
+    };
+    return languageMap[ext] ?? 'plaintext';
+}