@theupsider/lsp-mcp 0.1.0

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

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWriteTools = registerWriteTools;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const uri_1 = require("../../utils/uri");
+const shared_1 = require("./shared");
+function registerWriteTools(registrar, lifecycleManager) {
+    registrar.registerTool('lsp_rename', { description: 'Rename symbol', inputSchema: zod_1.z.object({ file: zod_1.z.string(), line: zod_1.z.number().int(), character: zod_1.z.number().int(), newName: zod_1.z.string() }) }, async (args) => {
+        const filePath = getFilePath(args);
+        await lifecycleManager.ensureLanguageForFile(filePath);
+        const client = lifecycleManager.getClientForFile(filePath);
+        if (!client) {
+            return (0, shared_1.noServerResult)(filePath);
+        }
+        if (hasRenameProviderDisabled(client.getCapabilities())) {
+            return (0, shared_1.failure)('Rename is not supported by the active language server.');
+        }
+        try {
+            await (0, shared_1.ensureDidOpen)(client, filePath);
+            const edit = await client.request('textDocument/rename', {
+                textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
+                position: getPosition(args),
+                newName: String(args.newName ?? '')
+            }, 15000);
+            return await applyWorkspaceEdit(edit, lifecycleManager, client, 'Applied workspace edit to');
+        }
+        catch (error) {
+            return (0, shared_1.mapToolError)(error, 15);
+        }
+    });
+    registrar.registerTool('lsp_code_action', { description: 'List or apply code actions', inputSchema: zod_1.z.object({ file: zod_1.z.string(), line: zod_1.z.number().int(), character: zod_1.z.number().int(), apply: zod_1.z.union([zod_1.z.boolean(), zod_1.z.object({ index: zod_1.z.number().int() })]).optional(), range: rangeSchema.optional() }) }, async (args) => {
+        const filePath = getFilePath(args);
+        await lifecycleManager.ensureLanguageForFile(filePath);
+        const client = lifecycleManager.getClientForFile(filePath);
+        if (!client) {
+            return (0, shared_1.noServerResult)(filePath);
+        }
+        try {
+            await (0, shared_1.ensureDidOpen)(client, filePath);
+            const range = isRange(args.range)
+                ? args.range
+                : { start: getPosition(args), end: getPosition(args) };
+            const actions = await client.request('textDocument/codeAction', {
+                textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
+                range,
+                context: { diagnostics: [] }
+            }, 15000);
+            const selected = selectCodeAction(actions, args.apply);
+            if (!selected) {
+                return (0, shared_1.success)(formatCodeActions(actions ?? []), actions ?? []);
+            }
+            const applied = selected.edit
+                ? await applyWorkspaceEdit(selected.edit, lifecycleManager, client, 'Applied workspace edit to')
+                : (0, shared_1.success)('Applied workspace edit to 0 file(s)', { changedFiles: [] });
+            if (selected.command) {
+                await client.request('workspace/executeCommand', selected.command, 15000);
+            }
+            return (0, shared_1.success)(`Applied code action: ${selected.title}`, {
+                title: selected.title,
+                changedFiles: extractChangedFiles(applied.raw)
+            });
+        }
+        catch (error) {
+            return (0, shared_1.mapToolError)(error, 15);
+        }
+    });
+    registrar.registerTool('lsp_formatting', { description: 'Format document', inputSchema: zod_1.z.object({ file: zod_1.z.string(), options: formattingOptionsSchema.optional() }) }, async (args) => {
+        return await runFormattingRequest('textDocument/formatting', args, lifecycleManager, async (client, filePath, options) => {
+            return await client.request('textDocument/formatting', { textDocument: { uri: (0, uri_1.pathToUri)(filePath) }, options }, 15000);
+        });
+    });
+    registrar.registerTool('lsp_range_formatting', { description: 'Format selected range', inputSchema: zod_1.z.object({ file: zod_1.z.string(), range: rangeSchema, options: formattingOptionsSchema.optional() }) }, async (args) => {
+        return await runFormattingRequest('textDocument/rangeFormatting', args, lifecycleManager, async (client, filePath, options) => {
+            return await client.request('textDocument/rangeFormatting', {
+                textDocument: { uri: (0, uri_1.pathToUri)(filePath) },
+                range: args.range,
+                options
+            }, 15000);
+        });
+    });
+    registrar.registerTool('lsp_apply_workspace_edit', { description: 'Apply raw workspace edit', inputSchema: zod_1.z.object({ edit: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()) }) }, async (args) => {
+        const clients = lifecycleManager.getReadyClients();
+        const client = clients[0] ?? null;
+        if (!client) {
+            return (0, shared_1.failure)('No language servers are ready. Run lsp_health for details.');
+        }
+        try {
+            return await applyWorkspaceEdit((args.edit ?? null), lifecycleManager, client, 'Applied workspace edit to');
+        }
+        catch (error) {
+            return (0, shared_1.mapToolError)(error, 15);
+        }
+    });
+}
+const positionSchema = zod_1.z.object({ line: zod_1.z.number().int(), character: zod_1.z.number().int() });
+const rangeSchema = zod_1.z.object({ start: positionSchema, end: positionSchema });
+const formattingOptionsSchema = zod_1.z.object({ tabSize: zod_1.z.number().int(), insertSpaces: zod_1.z.boolean() });
+async function runFormattingRequest(_method, args, lifecycleManager, requestEdits) {
+    const filePath = getFilePath(args);
+    await lifecycleManager.ensureLanguageForFile(filePath);
+    const client = lifecycleManager.getClientForFile(filePath);
+    if (!client) {
+        return (0, shared_1.noServerResult)(filePath);
+    }
+    try {
+        await (0, shared_1.ensureDidOpen)(client, filePath);
+        const options = await resolveFormattingOptions(filePath, args.options);
+        const edits = await requestEdits(client, filePath, options);
+        return await applyTextEdits(edits, [filePath], lifecycleManager, client);
+    }
+    catch (error) {
+        return (0, shared_1.mapToolError)(error, 15);
+    }
+}
+async function applyWorkspaceEdit(edit, lifecycleManager, fallbackClient, verb) {
+    if (!edit) {
+        return (0, shared_1.success)('No result', null);
+    }
+    const changeEntries = Object.entries(edit.changes ?? {});
+    const changedFiles = [];
+    for (const [uri, edits] of changeEntries) {
+        const filePath = (0, uri_1.uriToPath)(uri);
+        const client = lifecycleManager.getClientForFile(filePath) ?? fallbackClient;
+        await (0, shared_1.ensureDidOpen)(client, filePath);
+        await applyEditsToFile(filePath, edits ?? []);
+        client.notify('textDocument/didSave', { textDocument: { uri } });
+        changedFiles.push(filePath);
+    }
+    for (const change of edit.documentChanges ?? []) {
+        if ('textDocument' in change && 'edits' in change) {
+            const filePath = (0, uri_1.uriToPath)(change.textDocument.uri);
+            const client = lifecycleManager.getClientForFile(filePath) ?? fallbackClient;
+            await (0, shared_1.ensureDidOpen)(client, filePath);
+            await applyEditsToFile(filePath, change.edits);
+            client.notify('textDocument/didSave', { textDocument: { uri: change.textDocument.uri } });
+            changedFiles.push(filePath);
+        }
+    }
+    return (0, shared_1.success)(`${verb} ${changedFiles.length} file(s)`, { changedFiles: [...new Set(changedFiles)] });
+}
+async function applyTextEdits(edits, files, lifecycleManager, fallbackClient) {
+    const changedFiles = [];
+    for (const filePath of files) {
+        if (!edits || edits.length === 0) {
+            continue;
+        }
+        const client = lifecycleManager.getClientForFile(filePath) ?? fallbackClient;
+        await applyEditsToFile(filePath, edits);
+        client.notify('textDocument/didSave', { textDocument: { uri: (0, uri_1.pathToUri)(filePath) } });
+        changedFiles.push(filePath);
+    }
+    return (0, shared_1.success)(`Applied workspace edit to ${changedFiles.length} file(s)`, { changedFiles });
+}
+async function applyEditsToFile(filePath, edits) {
+    const original = await (0, promises_1.readFile)(filePath, 'utf8');
+    const updated = applyEdits(original, edits);
+    await (0, promises_1.writeFile)(filePath, updated, 'utf8');
+}
+function applyEdits(text, edits) {
+    const ordered = [...edits].sort((left, right) => comparePosition(right.range.start, left.range.start));
+    let current = text;
+    for (const edit of ordered) {
+        const start = positionToOffset(current, edit.range.start);
+        const end = positionToOffset(current, edit.range.end);
+        current = `${current.slice(0, start)}${edit.newText}${current.slice(end)}`;
+    }
+    return current;
+}
+async function resolveFormattingOptions(filePath, provided) {
+    if (isFormattingOptions(provided)) {
+        return provided;
+    }
+    const editorConfig = await readNearestConfig(filePath, '.editorconfig');
+    if (editorConfig) {
+        const tabSizeMatch = editorConfig.match(/indent_size\s*=\s*(\d+)/);
+        const indentStyleMatch = editorConfig.match(/indent_style\s*=\s*(space|tab)/);
+        return {
+            tabSize: Number(tabSizeMatch?.[1] ?? 2),
+            insertSpaces: indentStyleMatch?.[1] !== 'tab'
+        };
+    }
+    return { tabSize: 2, insertSpaces: true };
+}
+async function readNearestConfig(filePath, fileName) {
+    let currentDir = node_path_1.default.dirname(filePath);
+    while (true) {
+        const candidate = node_path_1.default.join(currentDir, fileName);
+        try {
+            await (0, promises_1.access)(candidate);
+            return await (0, promises_1.readFile)(candidate, 'utf8');
+        }
+        catch {
+            if (currentDir === node_path_1.default.dirname(currentDir)) {
+                return null;
+            }
+            currentDir = node_path_1.default.dirname(currentDir);
+        }
+    }
+}
+function selectCodeAction(actions, apply) {
+    if (apply === true) {
+        return actions?.[0] ?? null;
+    }
+    if (typeof apply === 'object' && apply && 'index' in apply && typeof apply.index === 'number') {
+        return actions?.[apply.index] ?? null;
+    }
+    return null;
+}
+function formatCodeActions(actions) {
+    if (actions.length === 0) {
+        return 'No result';
+    }
+    return ['Available code actions:', ...actions.map((action, index) => `- [${index}] ${action.title}`)].join('\n');
+}
+function extractChangedFiles(raw) {
+    if (typeof raw === 'object' && raw && 'changedFiles' in raw && Array.isArray(raw.changedFiles)) {
+        return raw.changedFiles.filter((value) => typeof value === 'string');
+    }
+    return [];
+}
+function getFilePath(args) {
+    return typeof args.file === 'string' ? args.file : '';
+}
+function getPosition(args) {
+    return { line: Number(args.line ?? 0), character: Number(args.character ?? 0) };
+}
+function comparePosition(left, right) {
+    return left.line === right.line ? left.character - right.character : left.line - right.line;
+}
+function positionToOffset(text, position) {
+    const lines = text.split('\n');
+    let offset = 0;
+    for (let index = 0; index < position.line; index += 1) {
+        offset += (lines[index]?.length ?? 0) + 1;
+    }
+    return offset + position.character;
+}
+function isRange(value) {
+    return typeof value === 'object' && value !== null && 'start' in value && 'end' in value;
+}
+function isFormattingOptions(value) {
+    return typeof value === 'object' && value !== null && 'tabSize' in value && 'insertSpaces' in value
+        && typeof value.tabSize === 'number' && typeof value.insertSpaces === 'boolean';
+}
+function hasRenameProviderDisabled(value) {
+    return typeof value === 'object' && value !== null && 'renameProvider' in value && value.renameProvider === false;
+}

package/dist/utils/__tests__/uri.test.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uri_1 = require("../uri");
+describe('uri utilities', () => {
+    it('converts an absolute posix path to a file URI', () => {
+        expect((0, uri_1.pathToUri)('/home/user/foo.ts')).toBe('file:///home/user/foo.ts');
+    });
+    it('round-trips posix paths with spaces', () => {
+        const uri = (0, uri_1.pathToUri)('/home/user/My Project/foo bar.ts');
+        expect(uri).toBe('file:///home/user/My%20Project/foo%20bar.ts');
+        expect((0, uri_1.uriToPath)(uri)).toBe('/home/user/My Project/foo bar.ts');
+    });
+    it('returns file URIs unchanged and rejects relative paths', () => {
+        expect((0, uri_1.pathToUri)('file:///home/user/foo.ts')).toBe('file:///home/user/foo.ts');
+        expect(() => (0, uri_1.pathToUri)('src/foo.ts')).toThrow('Expected an absolute file path');
+    });
+    it('handles windows drive paths in both directions', () => {
+        expect((0, uri_1.pathToUri)('C:\\work\\foo bar.ts')).toBe('file:///C:/work/foo%20bar.ts');
+        expect((0, uri_1.uriToPath)('file:///C:/work/foo%20bar.ts')).toBe('C:\\work\\foo bar.ts');
+    });
+});

package/dist/utils/uri.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToUri = pathToUri;
+exports.uriToPath = uriToPath;
+const FILE_URI_PREFIX = 'file://';
+function pathToUri(filePath) {
+    if (isFileUri(filePath)) {
+        return filePath;
+    }
+    if (isWindowsPath(filePath)) {
+        const normalized = filePath.replace(/\\/g, '/');
+        return `${FILE_URI_PREFIX}/${encodePath(normalized)}`;
+    }
+    if (!filePath.startsWith('/')) {
+        throw new Error('Expected an absolute file path');
+    }
+    return `${FILE_URI_PREFIX}${encodePath(filePath)}`;
+}
+function uriToPath(uri) {
+    if (!isFileUri(uri)) {
+        throw new Error('Expected a file URI');
+    }
+    const decoded = decodeURIComponent(uri.slice(FILE_URI_PREFIX.length));
+    if (/^\/[A-Za-z]:\//.test(decoded)) {
+        return decoded.slice(1).replace(/\//g, '\\');
+    }
+    return decoded;
+}
+function isFileUri(value) {
+    return value.startsWith(`${FILE_URI_PREFIX}/`);
+}
+function isWindowsPath(value) {
+    return /^[A-Za-z]:[\\/]/.test(value);
+}
+function encodePath(value) {
+    return value
+        .split('/')
+        .map((segment, index) => {
+        const encoded = encodeURIComponent(segment);
+        return index === 0 && /^[A-Za-z]:$/.test(segment) ? encoded.replace('%3A', ':') : encoded;
+    })
+        .join('/');
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@theupsider/lsp-mcp",
+  "version": "0.1.0",
+  "description": "Universal LSP MCP server",
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "lsp-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --config jest.config.js --coverage",
+    "test:integration": "jest --config jest.config.integration.js --forceExit --runInBand",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "vscode-languageserver-protocol": "latest",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/jest": "latest",
+    "@types/node": "latest",
+    "jest": "latest",
+    "ts-jest": "latest",
+    "typescript": "latest"
+  }
+}