@theupsider/lsp-mcp 0.1.0

package/dist/detection/language-detector.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLanguages = detectLanguages;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const MARKER_DEFINITIONS = [
+    { language: 'javascript', markers: ['package.json'] },
+    { language: 'typescript', markers: ['tsconfig.json'] },
+    { language: 'python', markers: ['pyproject.toml', 'setup.py'] },
+    { language: 'csharp', markers: ['.csproj', '.sln'] },
+    { language: 'rust', markers: ['Cargo.toml'] },
+    { language: 'go', markers: ['go.mod'] },
+    { language: 'java', markers: ['pom.xml', 'build.gradle'] },
+    { language: 'ruby', markers: ['Gemfile'] },
+    { language: 'php', markers: ['composer.json'] },
+    { language: 'kotlin', markers: ['build.gradle.kts'] },
+    { language: 'swift', markers: ['Package.swift'] }
+];
+const EXTENSION_DEFINITIONS = [
+    { language: 'c', extensions: ['.c', '.h'] },
+    { language: 'cpp', extensions: ['.cpp', '.hpp', '.cc'] }
+];
+async function detectLanguages(projectRoot) {
+    const entries = await collectEntries(projectRoot, projectRoot);
+    const markerMatches = new Map();
+    for (const definition of MARKER_DEFINITIONS) {
+        const matches = entries
+            .filter((entry) => definition.markers.some((marker) => matchesMarker(entry.relativePath, marker)))
+            .map((entry) => entry.relativePath);
+        if (matches.length > 0) {
+            markerMatches.set(definition.language, matches.sort());
+        }
+    }
+    const detected = [];
+    if (markerMatches.has('javascript')) {
+        detected.push({
+            language: 'javascript',
+            confidence: 'marker',
+            markers: markerMatches.get('javascript') ?? []
+        });
+    }
+    if (markerMatches.has('typescript')) {
+        detected.push({
+            language: 'typescript',
+            confidence: 'marker',
+            markers: markerMatches.has('javascript')
+                ? ['package.json', ...(markerMatches.get('typescript') ?? [])]
+                : (markerMatches.get('typescript') ?? [])
+        });
+    }
+    for (const definition of MARKER_DEFINITIONS) {
+        if (definition.language === 'javascript' || definition.language === 'typescript') {
+            continue;
+        }
+        const matches = markerMatches.get(definition.language);
+        if (matches && matches.length > 0) {
+            detected.push({
+                language: definition.language,
+                confidence: 'marker',
+                markers: matches
+            });
+        }
+    }
+    for (const definition of EXTENSION_DEFINITIONS) {
+        const matches = entries
+            .filter((entry) => definition.extensions.some((extension) => entry.relativePath.endsWith(extension)))
+            .map((entry) => entry.relativePath)
+            .sort((left, right) => compareByExtensionPriority(left, right, definition.extensions));
+        if (matches.length > 0) {
+            detected.push({
+                language: definition.language,
+                confidence: 'extension',
+                markers: matches
+            });
+        }
+    }
+    return detected;
+}
+function compareByExtensionPriority(left, right, extensions) {
+    const leftIndex = extensions.findIndex((extension) => left.endsWith(extension));
+    const rightIndex = extensions.findIndex((extension) => right.endsWith(extension));
+    if (leftIndex !== rightIndex) {
+        return leftIndex - rightIndex;
+    }
+    return left.localeCompare(right);
+}
+async function collectEntries(root, currentDir) {
+    const dirents = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+    const entries = [];
+    for (const dirent of dirents) {
+        const absolutePath = node_path_1.default.join(currentDir, dirent.name);
+        if (dirent.isDirectory()) {
+            entries.push(...await collectEntries(root, absolutePath));
+            continue;
+        }
+        entries.push({
+            relativePath: node_path_1.default.relative(root, absolutePath).split(node_path_1.default.sep).join('/')
+        });
+    }
+    return entries;
+}
+function matchesMarker(relativePath, marker) {
+    return marker.startsWith('.') ? relativePath.endsWith(marker) : relativePath === marker;
+}

package/dist/detection/lsp-mapping.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_LANGUAGES = void 0;
+exports.getLspCandidates = getLspCandidates;
+exports.findAvailableLsp = findAvailableLsp;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const TYPESCRIPT_CANDIDATES = [
+    { cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' }
+];
+const CLANGD_CANDIDATES = [
+    { cmd: 'clangd', args: [], pkg: 'clangd', mgr: 'apt' }
+];
+const LANGUAGE_TO_CANDIDATES = {
+    python: [
+        { cmd: 'pyright-langserver', args: ['--stdio'], pkg: 'pyright', mgr: 'npm' },
+        { cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' }
+    ],
+    typescript: TYPESCRIPT_CANDIDATES,
+    javascript: TYPESCRIPT_CANDIDATES,
+    csharp: [
+        { cmd: 'omnisharp', args: ['-lsp'], pkg: 'omnisharp-roslyn', mgr: 'dotnet' }
+    ],
+    java: [
+        { cmd: 'java-language-server', args: [], pkg: 'vscode-java', mgr: 'npm' },
+        { cmd: 'jdtls', args: [], pkg: 'eclipse.jdt.ls', mgr: 'apt' }
+    ],
+    go: [
+        { cmd: 'gopls', args: ['serve'], pkg: 'golang.org/x/tools/gopls', mgr: 'go' }
+    ],
+    rust: [
+        { cmd: 'rust-analyzer', args: [], pkg: 'rust-analyzer', mgr: 'cargo' }
+    ],
+    c: CLANGD_CANDIDATES,
+    cpp: CLANGD_CANDIDATES,
+    ruby: [
+        { cmd: 'solargraph', args: ['stdio'], pkg: 'solargraph', mgr: 'gem' }
+    ],
+    php: [
+        { cmd: 'intelephense', args: ['--stdio'], pkg: 'intelephense', mgr: 'npm' }
+    ],
+    kotlin: [
+        { cmd: 'kotlin-language-server', args: ['--stdio'], pkg: 'kotlin-language-server', mgr: 'npm' }
+    ],
+    swift: [
+        { cmd: 'sourcekit-lsp', args: [], pkg: 'sourcekit-lsp', mgr: 'brew' }
+    ]
+};
+exports.SUPPORTED_LANGUAGES = Object.freeze([
+    'python',
+    'typescript',
+    'javascript',
+    'csharp',
+    'java',
+    'go',
+    'rust',
+    'c',
+    'cpp',
+    'ruby',
+    'php',
+    'kotlin',
+    'swift'
+]);
+function getLspCandidates(language) {
+    return LANGUAGE_TO_CANDIDATES[language]?.map((candidate) => ({ ...candidate, args: [...candidate.args] })) ?? [];
+}
+async function findAvailableLsp(language) {
+    const candidates = getLspCandidates(language);
+    for (const candidate of candidates) {
+        if (await commandExists(candidate.cmd)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+async function commandExists(command) {
+    const lookupCommand = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        await execFileAsync(lookupCommand, [command], { env: { ...process.env } });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const server_1 = require("./mcp/server");
+async function main(argv = process.argv.slice(2), env = process.env, overrides = {}) {
+    const stdout = overrides.stdout ?? ((text) => process.stdout.write(text));
+    const stderr = overrides.stderr ?? ((text) => process.stderr.write(text));
+    const exit = overrides.exit ?? ((code) => process.exit(code));
+    const onSignal = overrides.onSignal ?? ((signal, handler) => {
+        process.on(signal, () => {
+            void handler();
+        });
+    });
+    if (argv.includes('--version')) {
+        stdout(`${readVersion()}\n`);
+        exit(0);
+        return;
+    }
+    const projectRoot = env.LSP_MCP_ROOT;
+    const logLevel = env.LSP_MCP_LOG_LEVEL ?? 'info';
+    const mcpServer = new server_1.McpServer(logLevel);
+    if (projectRoot) {
+        const initialized = await mcpServer.initializeManager(projectRoot);
+        const startupReport = summarizeHealth(initialized.health);
+        stderr(`${JSON.stringify(startupReport)}\n`);
+    }
+    else {
+        stderr(`${JSON.stringify({ event: 'startup', status: 'waiting-for-init' })}\n`);
+    }
+    await mcpServer.start();
+    const shutdown = async () => {
+        await mcpServer.shutdown();
+        exit(0);
+    };
+    onSignal('SIGINT', shutdown);
+    onSignal('SIGTERM', shutdown);
+}
+function summarizeHealth(health) {
+    return {
+        languages: health.map((entry) => entry.language),
+        started: health.filter((entry) => entry.status === 'ready').map((entry) => entry.language),
+        errors: health.filter((entry) => entry.status === 'error' && entry.error).map((entry) => entry.error)
+    };
+}
+function readVersion() {
+    const packageJsonPath = node_path_1.default.resolve(__dirname, '..', 'package.json');
+    return JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8')).version;
+}
+if (require.main === module) {
+    void main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}

package/dist/lsp/__tests__/installer.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const installer_1 = require("../installer");
+jest.mock('node:child_process', () => ({
+    exec: jest.fn()
+}));
+describe('installLsp', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('installs npm packages into the user local prefix', async () => {
+        const exec = jest.requireMock('node:child_process').exec;
+        exec.mockImplementation((...args) => {
+            const callback = args[args.length - 1];
+            if (typeof callback === 'function') {
+                callback(null, '', '');
+            }
+            return { on: jest.fn() };
+        });
+        const result = await (0, installer_1.installLsp)({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        expect(result).toEqual({ success: true });
+        expect(exec).toHaveBeenCalledWith('npm install --global --prefix "$HOME/.local" typescript-language-server', expect.objectContaining({ env: process.env }), expect.any(Function));
+    });
+    it('installs pip packages into the user site directory', async () => {
+        const exec = jest.requireMock('node:child_process').exec;
+        exec.mockImplementation((...args) => {
+            const callback = args[args.length - 1];
+            if (typeof callback === 'function') {
+                callback(null, '', '');
+            }
+            return { on: jest.fn() };
+        });
+        const result = await (0, installer_1.installLsp)({ cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' });
+        expect(result).toEqual({ success: true });
+        expect(exec).toHaveBeenCalledWith('pip install --user python-lsp-server', expect.objectContaining({ env: process.env }), expect.any(Function));
+    });
+    it.each([
+        [{ cmd: 'gopls', args: ['serve'], pkg: 'golang.org/x/tools/gopls', mgr: 'go' }, 'go install golang.org/x/tools/gopls@latest'],
+        [{ cmd: 'solargraph', args: ['stdio'], pkg: 'solargraph', mgr: 'gem' }, 'gem install --user-install solargraph'],
+        [{ cmd: 'rust-analyzer', args: [], pkg: 'rust-analyzer', mgr: 'cargo' }, 'cargo install rust-analyzer']
+    ])('uses a user-local install command for %s', async (candidate, expectedCommand) => {
+        const exec = jest.requireMock('node:child_process').exec;
+        exec.mockImplementation((...args) => {
+            const callback = args[args.length - 1];
+            if (typeof callback === 'function') {
+                callback(null, '', '');
+            }
+            return { on: jest.fn() };
+        });
+        const result = await (0, installer_1.installLsp)(candidate);
+        expect(result).toEqual({ success: true });
+        expect(exec).toHaveBeenCalledWith(expectedCommand, expect.objectContaining({ env: process.env }), expect.any(Function));
+    });
+    it('returns a structured failure with manual instructions when install command fails', async () => {
+        const exec = jest.requireMock('node:child_process').exec;
+        exec.mockImplementation((...args) => {
+            const callback = args[args.length - 1];
+            if (typeof callback === 'function') {
+                callback(new Error('permission denied'), '', '');
+            }
+            return { on: jest.fn() };
+        });
+        const result = await (0, installer_1.installLsp)({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        expect(result).toEqual({
+            success: false,
+            error: 'permission denied',
+            instructions: 'npm install -g typescript-language-server'
+        });
+    });
+    it('returns manual instructions for package managers without a user-local path', async () => {
+        const exec = jest.requireMock('node:child_process').exec;
+        const result = await (0, installer_1.installLsp)({ cmd: 'omnisharp', args: ['-lsp'], pkg: 'omnisharp-roslyn', mgr: 'dotnet' });
+        expect(result).toEqual({
+            success: false,
+            error: 'Automatic user-local install is not supported for dotnet',
+            instructions: 'dotnet tool install -g omnisharp-roslyn'
+        });
+        expect(exec).not.toHaveBeenCalled();
+    });
+    it.each([
+        [{ cmd: 'clangd', args: [], pkg: 'clangd', mgr: 'apt' }, 'sudo apt install clangd'],
+        [{ cmd: 'sourcekit-lsp', args: [], pkg: 'sourcekit-lsp', mgr: 'brew' }, 'brew install sourcekit-lsp'],
+        [{ cmd: 'mystery-lsp', args: [], pkg: 'mystery-lsp', mgr: 'custom' }, 'custom install mystery-lsp']
+    ])('returns manual instructions for unsupported %s installs', async (candidate, instructions) => {
+        const result = await (0, installer_1.installLsp)({ ...candidate, args: [...candidate.args] });
+        expect(result).toEqual({
+            success: false,
+            error: `Automatic user-local install is not supported for ${candidate.mgr}`,
+            instructions
+        });
+    });
+    it.each([
+        [{ cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' }, 'pip install python-lsp-server'],
+        [{ cmd: 'gopls', args: ['serve'], pkg: 'golang.org/x/tools/gopls', mgr: 'go' }, 'go install golang.org/x/tools/gopls@latest'],
+        [{ cmd: 'solargraph', args: ['stdio'], pkg: 'solargraph', mgr: 'gem' }, 'gem install solargraph'],
+        [{ cmd: 'rust-analyzer', args: [], pkg: 'rust-analyzer', mgr: 'cargo' }, 'cargo install rust-analyzer']
+    ])('returns manager-specific manual instructions when %s install fails', async (candidate, instructions) => {
+        const exec = jest.requireMock('node:child_process').exec;
+        exec.mockImplementation((...args) => {
+            const callback = args[args.length - 1];
+            if (typeof callback === 'function') {
+                callback(new Error('network down'), '', '');
+            }
+            return { on: jest.fn() };
+        });
+        const result = await (0, installer_1.installLsp)({ ...candidate, args: [...candidate.args] });
+        expect(result).toEqual({
+            success: false,
+            error: 'network down',
+            instructions
+        });
+    });
+});

package/dist/lsp/__tests__/lifecycle-manager.test.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const lifecycle_manager_1 = require("../lifecycle-manager");
+jest.mock('../../detection/language-detector', () => ({
+    detectLanguages: jest.fn()
+}));
+jest.mock('../../detection/lsp-mapping', () => ({
+    findAvailableLsp: jest.fn(),
+    getLspCandidates: jest.fn()
+}));
+jest.mock('../installer', () => ({
+    installLsp: jest.fn()
+}));
+jest.mock('../lsp-client', () => ({
+    LspClient: jest.fn()
+}));
+class MockLspClient extends node_events_1.EventEmitter {
+    start = jest.fn().mockResolvedValue(undefined);
+    shutdown = jest.fn().mockResolvedValue(undefined);
+    request = jest.fn().mockResolvedValue({ items: [] });
+    isReady = jest.fn().mockReturnValue(true);
+    getCapabilities = jest.fn().mockReturnValue({ hoverProvider: true });
+}
+describe('LifecycleManager', () => {
+    beforeEach(() => {
+        jest.useRealTimers();
+        jest.clearAllMocks();
+    });
+    it('starts detected language servers and reports their health', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => new MockLspClient());
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(detectLanguages).toHaveBeenCalledWith('/workspace/project');
+        expect(findAvailableLsp).toHaveBeenCalledWith('typescript');
+        expect(manager.getClient('typescript')).not.toBeNull();
+        expect(manager.getHealth()).toEqual([
+            {
+                language: 'typescript',
+                status: 'ready',
+                capabilities: { hoverProvider: true }
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('records per-language startup errors without failing the whole boot', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const installLsp = jest.requireMock('../installer').installLsp;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        detectLanguages.mockResolvedValue([
+            { language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] },
+            { language: 'python', confidence: 'marker', markers: ['pyproject.toml'] }
+        ]);
+        findAvailableLsp.mockImplementation(async (language) => language === 'typescript'
+            ? { cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' }
+            : null);
+        getLspCandidates.mockImplementation((language) => language === 'python'
+            ? [{ cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' }]
+            : []);
+        installLsp.mockResolvedValue({ success: false, error: 'install failed', instructions: 'pip install python-lsp-server' });
+        LspClient.mockImplementation(() => new MockLspClient());
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(manager.getHealth()).toEqual([
+            {
+                language: 'typescript',
+                status: 'ready',
+                capabilities: { hoverProvider: true }
+            },
+            {
+                language: 'python',
+                status: 'error',
+                error: 'No LSP server available for python',
+                capabilities: undefined
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('routes files to clients by file extension', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        detectLanguages.mockResolvedValue([
+            { language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] },
+            { language: 'python', confidence: 'marker', markers: ['pyproject.toml'] }
+        ]);
+        findAvailableLsp.mockImplementation(async (language) => ({
+            cmd: language === 'typescript' ? 'typescript-language-server' : 'pylsp',
+            args: language === 'typescript' ? ['--stdio'] : [],
+            pkg: language === 'typescript' ? 'typescript-language-server' : 'python-lsp-server',
+            mgr: language === 'typescript' ? 'npm' : 'pip'
+        }));
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => new MockLspClient());
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(manager.getClientForFile('/workspace/project/src/index.ts')).toBe(manager.getClient('typescript'));
+        expect(manager.getClientForFile('/workspace/project/app/main.py')).toBe(manager.getClient('python'));
+        expect(manager.getClientForFile('/workspace/project/README.md')).toBeNull();
+        await manager.shutdown();
+    });
+    it('restarts a client after a failed health ping', async () => {
+        jest.useFakeTimers();
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const firstClient = new MockLspClient();
+        firstClient.request.mockRejectedValueOnce(new Error('ping timeout'));
+        const secondClient = new MockLspClient();
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementationOnce(() => firstClient);
+        LspClient.mockImplementationOnce(() => secondClient);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        await jest.advanceTimersByTimeAsync(30000);
+        expect(firstClient.request).toHaveBeenCalledWith('workspace/symbol', { query: '__lsp_mcp_healthcheck__' }, 5000);
+        expect(secondClient.start).toHaveBeenCalled();
+        expect(manager.getClient('typescript')).toBe(secondClient);
+        await manager.shutdown();
+    });
+    it('attempts installation when no server is available and starts the installed candidate', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const installLsp = jest.requireMock('../installer').installLsp;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const candidate = { cmd: 'pylsp', args: [], pkg: 'python-lsp-server', mgr: 'pip' };
+        detectLanguages.mockResolvedValue([{ language: 'python', confidence: 'marker', markers: ['pyproject.toml'] }]);
+        findAvailableLsp.mockResolvedValue(null);
+        getLspCandidates.mockReturnValue([candidate]);
+        installLsp.mockResolvedValue({ success: true });
+        LspClient.mockImplementation(() => new MockLspClient());
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'verbose');
+        await manager.start();
+        expect(installLsp).toHaveBeenCalledWith(candidate);
+        expect(LspClient).toHaveBeenCalledWith(candidate, '/workspace/project', 'info');
+        await manager.shutdown();
+    });
+    it('surfaces client start failures in health status', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const failingClient = new MockLspClient();
+        failingClient.start.mockRejectedValue(new Error('startup failed'));
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => failingClient);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(manager.getHealth()).toEqual([
+            {
+                language: 'typescript',
+                status: 'error',
+                error: 'startup failed',
+                capabilities: undefined
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('reports shutdown failures in the log', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const failingShutdownClient = new MockLspClient();
+        failingShutdownClient.shutdown.mockRejectedValue(new Error('shutdown failed'));
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => failingShutdownClient);
+        const stderrWrite = jest.spyOn(process.stderr, 'write').mockReturnValue(true);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        await manager.shutdown();
+        expect(stderrWrite).toHaveBeenLastCalledWith(expect.stringContaining('Shutdown: 0 LSP-Server beendet, 1 Fehler'));
+        stderrWrite.mockRestore();
+    });
+    it('marks a language as error when no candidate exists to install', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        detectLanguages.mockResolvedValue([{ language: 'unknown-language', confidence: 'extension', markers: ['main.unknown'] }]);
+        findAvailableLsp.mockResolvedValue(null);
+        getLspCandidates.mockReturnValue([]);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(manager.getHealth()).toEqual([
+            {
+                language: 'unknown-language',
+                status: 'error',
+                error: 'No LSP server available for unknown-language',
+                capabilities: undefined
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('stops restarting once the max restart count is reached', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const client = new MockLspClient();
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => client);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        const managerAccess = manager;
+        const state = managerAccess.states.get('typescript');
+        expect(state).toBeDefined();
+        if (!state) {
+            throw new Error('Expected typescript state');
+        }
+        state.restartCount = 3;
+        await managerAccess.restartLanguage(state, 'too many restarts');
+        expect(manager.getClient('typescript')).toBeNull();
+        expect(manager.getHealth()).toEqual([
+            {
+                language: 'typescript',
+                status: 'error',
+                error: 'too many restarts',
+                capabilities: { hoverProvider: true }
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('stores published diagnostics and exposes ready clients', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        const findAvailableLsp = jest.requireMock('../../detection/lsp-mapping').findAvailableLsp;
+        const getLspCandidates = jest.requireMock('../../detection/lsp-mapping').getLspCandidates;
+        const LspClient = jest.requireMock('../lsp-client').LspClient;
+        const client = new MockLspClient();
+        detectLanguages.mockResolvedValue([{ language: 'typescript', confidence: 'marker', markers: ['tsconfig.json'] }]);
+        findAvailableLsp.mockResolvedValue({ cmd: 'typescript-language-server', args: ['--stdio'], pkg: 'typescript-language-server', mgr: 'npm' });
+        getLspCandidates.mockReturnValue([]);
+        LspClient.mockImplementation(() => client);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        client.emit('notification', 'textDocument/publishDiagnostics', {
+            uri: 'file:///workspace/project/src/index.ts',
+            diagnostics: [{ message: 'Boom', severity: 1, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } } }]
+        });
+        expect(manager.getReadyClients()).toEqual([client]);
+        expect(manager.getFileDiagnostics('/workspace/project/src/index.ts')).toEqual([
+            {
+                uri: 'file:///workspace/project/src/index.ts',
+                message: 'Boom',
+                severity: 1,
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }
+            }
+        ]);
+        expect(manager.getWorkspaceDiagnostics('typescript')).toEqual([
+            {
+                uri: 'file:///workspace/project/src/index.ts',
+                message: 'Boom',
+                severity: 1,
+                range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } }
+            }
+        ]);
+        await manager.shutdown();
+    });
+    it('handles empty detections and aggregates workspace diagnostics without filters', async () => {
+        const detectLanguages = jest.requireMock('../../detection/language-detector').detectLanguages;
+        detectLanguages.mockResolvedValue([]);
+        const manager = new lifecycle_manager_1.LifecycleManager('/workspace/project', 'debug');
+        await manager.start();
+        expect(manager.getHealth()).toEqual([]);
+        expect(manager.getReadyClients()).toEqual([]);
+        expect(manager.getWorkspaceDiagnostics()).toEqual([]);
+        await manager.shutdown();
+    });
+});