@theupsider/lsp-mcp 1.0.0 → 1.0.7

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

@@ -11,119 +11,163 @@ 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() })
+    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_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) => {
+    registrar.registerTool("lsp_definition", { description: "Find definitions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
             lifecycleManager,
-            method: 'textDocument/definition',
+            method: "textDocument/definition",
             timeoutMs: 5000,
             format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
-            raw: (result) => (0, shared_1.normalizeLocations)(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) => {
+    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',
+            method: "textDocument/references",
             timeoutMs: 15000,
-            params: (uri, position) => ({ textDocument: { uri }, position, context: { includeDeclaration } }),
+            params: (uri, position) => ({
+                textDocument: { uri },
+                position,
+                context: { includeDeclaration },
+            }),
             format: formatters_1.formatReferences,
-            raw: shared_1.normalizeLocations
+            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) => {
+    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',
+            method: "textDocument/documentSymbol",
             timeoutMs: 15000,
             format: formatters_1.formatSymbols,
-            raw: shared_1.normalizeSymbols
+            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 : '';
+    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 : "";
         await lifecycleManager.ensureSeedFilesOpen();
         const results = await Promise.all(lifecycleManager.getReadyClients().map(async (client) => {
-            return await client.request('workspace/symbol', { query }, 30000);
+            return (await client.request("workspace/symbol", { query }, 30000));
         }));
-        const merged = results.flat().slice(0, query === '' ? 100 : 500);
+        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) => {
+    registrar.registerTool("lsp_completion", { description: "Get completions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
             lifecycleManager,
-            method: 'textDocument/completion',
+            method: "textDocument/completion",
             timeoutMs: 5000,
             format: (result) => (0, formatters_1.formatCompletion)(asCompletionItems(result)),
-            raw: (result) => asCompletionItems(result)?.slice(0, 50) ?? null
+            raw: (result) => asCompletionItems(result)?.slice(0, 50) ?? null,
         });
     });
-    registrar.registerTool('lsp_diagnostics', { description: 'Get errors and warnings. Pass a file path to trigger analysis of that file and its language server, then return diagnostics for that file (scope: file) or all files seen so far (scope: workspace). Omit file for workspace scope to query whatever has been opened previously.', 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 filePath = typeof args.file === 'string' ? args.file : '';
-        const scope = args.scope === 'workspace' ? 'workspace' : 'file';
+    registrar.registerTool("lsp_diagnostics", {
+        description: "Get errors and warnings. Pass a file path to trigger analysis of that file and its language server, then return diagnostics for that file (scope: file) or all files seen so far (scope: workspace). Omit file for workspace scope to query whatever has been opened previously.",
+        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 filePath = typeof args.file === "string" ? args.file : "";
+        const scope = args.scope === "workspace" ? "workspace" : "file";
         if (filePath) {
             await lifecycleManager.ensureLanguageForFile(filePath);
             const client = lifecycleManager.getClientForFile(filePath);
             if (client) {
                 const waitPromise = client.waitForDiagnosticsPublish(filePath, 10000);
                 await client.ensureDidOpen(filePath);
-                client.notify('textDocument/didSave', { textDocument: { uri: (0, uri_1.pathToUri)(filePath) } });
+                client.notify("textDocument/didSave", {
+                    textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
+                });
                 await waitPromise;
             }
         }
-        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);
+        if (scope === "workspace") {
+            const language = typeof args.language === "string" ? args.language : undefined;
+            await lifecycleManager.analyzeWorkspace(language);
+            const diagnostics = lifecycleManager
+                .getWorkspaceDiagnostics(language)
+                .slice(0, 200);
+            return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, "workspace"), diagnostics);
         }
         const diagnostics = lifecycleManager.getFileDiagnostics(filePath);
-        return (0, shared_1.success)((0, formatters_1.formatDiagnostics)(diagnostics, 'file'), diagnostics);
+        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_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) => {
+    registrar.registerTool("lsp_type_definition", { description: "Find type definitions", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
             lifecycleManager,
-            method: 'textDocument/typeDefinition',
+            method: "textDocument/typeDefinition",
             timeoutMs: 5000,
             format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
-            raw: (result) => (0, shared_1.normalizeLocations)(asLocationArray(result))
+            raw: (result) => (0, shared_1.normalizeLocations)(asLocationArray(result)),
         });
     });
-    registrar.registerTool('lsp_implementation', { description: 'Find implementations', inputSchema: positionSchema }, async (args) => {
+    registrar.registerTool("lsp_implementation", { description: "Find implementations", inputSchema: positionSchema }, async (args) => {
         return await runFileRequest({
             args,
             lifecycleManager,
-            method: 'textDocument/implementation',
+            method: "textDocument/implementation",
             timeoutMs: 5000,
             format: (result) => (0, formatters_1.formatDefinition)(asLocationArray(result)),
-            raw: (result) => (0, shared_1.normalizeLocations)(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 () => {
+    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 : '';
+    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\' }).');
+        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}`);
@@ -138,23 +182,25 @@ async function handleInitTool(args, options) {
         return (0, shared_1.failure)(`Project root does not exist: ${root}`);
     }
     const languages = Array.isArray(args.languages)
-        ? args.languages.filter((item) => typeof item === 'string')
+        ? 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 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 }],
+            content: [{ type: "text", text }],
             text,
             raw: {
                 root: initialized.root,
                 languages: languageNames,
-                health: initialized.health
-            }
+                health: initialized.health,
+            },
         };
     }
     catch (error) {
@@ -164,10 +210,10 @@ async function handleInitTool(args, options) {
 const positionSchema = zod_1.z.object({
     file: zod_1.z.string(),
     line: zod_1.z.number().int(),
-    character: 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 : '';
+    const filePath = typeof options.args.file === "string" ? options.args.file : "";
     await options.lifecycleManager.ensureLanguageForFile(filePath);
     const client = options.lifecycleManager.getClientForFile(filePath);
     if (!client) {
@@ -175,15 +221,15 @@ async function runFileRequest(options) {
     }
     const position = {
         line: Number(options.args.line ?? 0),
-        character: Number(options.args.character ?? 0)
+        character: Number(options.args.character ?? 0),
     };
     const uri = (0, uri_1.pathToUri)(filePath);
     try {
         await client.ensureDidOpen(filePath);
-        const result = await client.request(options.method, options.params?.(uri, position) ?? {
+        const result = (await client.request(options.method, options.params?.(uri, position) ?? {
             textDocument: { uri },
-            position
-        }, options.timeoutMs);
+            position,
+        }, options.timeoutMs));
         return (0, shared_1.success)(options.format(result), options.raw(result));
     }
     catch (error) {
@@ -204,16 +250,16 @@ function asCompletionItems(result) {
 }
 function stringifyResult(result) {
     if (!result) {
-        return 'No result';
+        return "No result";
     }
     return JSON.stringify(result, null, 2);
 }
 function formatLanguageList(languages) {
-    return languages.length === 0 ? 'None' : languages.join(', ');
+    return languages.length === 0 ? "None" : languages.join(", ");
 }
 function formatLanguageName(language) {
     if (language.length === 0) {
         return language;
     }
-    return `${language[0]?.toUpperCase() ?? ''}${language.slice(1)}`;
+    return `${language[0]?.toUpperCase() ?? ""}${language.slice(1)}`;
 }

package/dist/mcp/tools/shared.js

@@ -13,25 +13,25 @@ exports.normalizeSymbols = normalizeSymbols;
 const node_path_1 = __importDefault(require("node:path"));
 const uri_1 = require("../../utils/uri");
 function success(text, raw) {
-    return { content: [{ type: 'text', text }], raw };
+    return { content: [{ type: "text", text }], raw };
 }
 function failure(text, raw = null) {
-    return { content: [{ type: 'text', text }], error: true, raw };
+    return { content: [{ type: "text", text }], error: true, raw };
 }
 function noServerResult(filePath) {
-    return failure(`No language server available for ${node_path_1.default.extname(filePath) || 'unknown'} files. Run lsp_health for details.`);
+    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 };
+    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')) {
+    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.');
+    if (message.includes("LSP server exited")) {
+        return failure("Der Language Server ist neu gestartet, bitte versuche es erneut.");
     }
     return failure(message, error);
 }
@@ -39,7 +39,10 @@ function normalizeLocations(locations) {
     if (!locations || locations.length === 0) {
         return null;
     }
-    return locations.map((location) => ({ path: (0, uri_1.uriToPath)(location.uri), range: location.range }));
+    return locations.map((location) => ({
+        path: (0, uri_1.uriToPath)(location.uri),
+        range: location.range,
+    }));
 }
 function normalizeSymbols(symbols) {
     if (!symbols || symbols.length === 0) {
@@ -47,16 +50,21 @@ function normalizeSymbols(symbols) {
     }
     const normalized = [];
     for (const symbol of symbols) {
-        if ('location' in symbol) {
+        if ("location" in symbol) {
             normalized.push({
                 name: symbol.name,
                 kind: symbol.kind,
                 path: (0, uri_1.uriToPath)(symbol.location.uri),
-                range: symbol.location.range
+                range: symbol.location.range,
             });
             continue;
         }
-        normalized.push({ name: symbol.name, kind: symbol.kind, range: symbol.range, selectionRange: symbol.selectionRange });
+        normalized.push({
+            name: symbol.name,
+            kind: symbol.kind,
+            range: symbol.range,
+            selectionRange: symbol.selectionRange,
+        });
     }
     return normalized;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theupsider/lsp-mcp",
-  "version": "1.0.0",
+  "version": "1.0.7",
   "description": "Universal LSP MCP server",
   "license": "Apache-2.0",
   "type": "commonjs",