pi-lens 3.6.2 → 3.6.4

package/clients/lsp/index.js

@@ -1,318 +0,0 @@
-/**
- * LSP Service Layer for pi-lens
- *
- * Manages multiple LSP clients per workspace with:
- * - Auto-spawning based on file type
- * - Effect-TS service composition
- * - Bus event integration
- * - Resource cleanup
- */
-import { Effect } from "effect";
-import { createLSPClient } from "./client.js";
-import { getServersForFileWithConfig } from "./config.js";
-import { getLanguageId } from "./language.js";
-// --- Service ---
-export class LSPService {
-    constructor() {
-        this.state = {
-            clients: new Map(),
-            servers: new Map(),
-            broken: new Set(),
-            inFlight: new Map(),
-        };
-    }
-    /**
-     * Get or create LSP client for a file
-     * Prevents duplicate client creation via in-flight promise tracking
-     */
-    async getClientForFile(filePath) {
-        const servers = getServersForFileWithConfig(filePath);
-        if (servers.length === 0)
-            return undefined;
-        // Try each matching server
-        for (const server of servers) {
-            const root = await server.root(filePath);
-            if (!root)
-                continue;
-            // Normalize root path for consistent cache key on Windows
-            const normalizedRoot = process.platform === "win32" ? root.toLowerCase() : root;
-            const key = `${server.id}:${normalizedRoot}`;
-            // Check cache first (fast path)
-            const existing = this.state.clients.get(key);
-            if (existing) {
-                return { client: existing, info: server };
-            }
-            // Check if broken
-            if (this.state.broken.has(key)) {
-                continue;
-            }
-            // Check if there's already an in-flight spawn for this key
-            const inFlight = this.state.inFlight.get(key);
-            if (inFlight) {
-                // Wait for the existing spawn to complete
-                const result = await inFlight;
-                if (result)
-                    return result;
-                continue; // This server failed, try next
-            }
-            // Create the spawn promise and store it
-            const spawnPromise = this.spawnClient(server, root, key);
-            this.state.inFlight.set(key, spawnPromise);
-            try {
-                const result = await spawnPromise;
-                if (result)
-                    return result;
-            }
-            finally {
-                // Clean up in-flight tracking
-                this.state.inFlight.delete(key);
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Internal: spawn a client for a server/root combination
-     */
-    async spawnClient(server, root, key) {
-        try {
-            const spawned = await server.spawn(root);
-            if (!spawned) {
-                this.state.broken.add(key);
-                return undefined;
-            }
-            const client = await createLSPClient({
-                serverId: server.id,
-                process: spawned.process,
-                root,
-                initialization: spawned.initialization,
-            });
-            this.state.clients.set(key, client);
-            return { client, info: server };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            if (errorMsg.includes("Timeout")) {
-                console.error(`[lsp] ${server.id} timed out during initialization (${errorMsg}). The server may be downloading or the project is large. Skipping.`);
-            }
-            else if (errorMsg.includes("stream was destroyed")) {
-                console.error(`[lsp] ${server.id} stream was destroyed. The server binary may be missing or crashed immediately. Try reinstalling: npm install -g ${server.id}-language-server`);
-            }
-            else if (errorMsg.includes("exited immediately")) {
-                console.error(`[lsp] ${server.id} ${errorMsg}. Try reinstalling: npm install -g ${server.id}-language-server`);
-            }
-            else {
-                console.error(`[lsp] Failed to spawn ${server.id}:`, err);
-            }
-            this.state.broken.add(key);
-            return undefined;
-        }
-    }
-    /**
-     * Open a file in LSP (sends textDocument/didOpen)
-     */
-    async openFile(filePath, content) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return;
-        const languageId = getLanguageId(filePath) ?? "plaintext";
-        await spawned.client.notify.open(filePath, content, languageId);
-    }
-    /**
-     * Update file content (sends textDocument/didChange)
-     */
-    async updateFile(filePath, content) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return;
-        await spawned.client.notify.change(filePath, content);
-    }
-    /**
-     * Get diagnostics for a file
-     */
-    async getDiagnostics(filePath) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        await spawned.client.waitForDiagnostics(filePath, 3000);
-        return spawned.client.getDiagnostics(filePath);
-    }
-    /**
-     * Navigation: go to definition
-     */
-    async definition(filePath, line, character) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        return spawned.client.definition(filePath, line, character);
-    }
-    /**
-     * Navigation: find all references
-     */
-    async references(filePath, line, character, includeDeclaration = true) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        return spawned.client.references(filePath, line, character, includeDeclaration);
-    }
-    /**
-     * Navigation: hover info
-     */
-    async hover(filePath, line, character) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return null;
-        return spawned.client.hover(filePath, line, character);
-    }
-    /**
-     * Navigation: symbols in document
-     */
-    async documentSymbol(filePath) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        return spawned.client.documentSymbol(filePath);
-    }
-    /**
-     * Navigation: workspace-wide symbol search
-     */
-    async workspaceSymbol(query) {
-        // Use the first active client for workspace-level queries
-        const clients = Array.from(this.state.clients.values());
-        if (clients.length === 0)
-            return [];
-        return clients[0].workspaceSymbol(query);
-    }
-    /**
-     * Navigation: go to implementation
-     */
-    async implementation(filePath, line, character) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        return spawned.client.implementation(filePath, line, character);
-    }
-    /**
-     * Navigation: prepare call hierarchy at position
-     */
-    async prepareCallHierarchy(filePath, line, character) {
-        const spawned = await this.getClientForFile(filePath);
-        if (!spawned)
-            return [];
-        return spawned.client.prepareCallHierarchy(filePath, line, character);
-    }
-    /**
-     * Navigation: find incoming calls (callers)
-     */
-    async incomingCalls(item) {
-        const spawned = await this.getClientForFile(item.uri.replace("file://", ""));
-        if (!spawned)
-            return [];
-        return spawned.client.incomingCalls(item);
-    }
-    /**
-     * Navigation: find outgoing calls (callees)
-     */
-    async outgoingCalls(item) {
-        const spawned = await this.getClientForFile(item.uri.replace("file://", ""));
-        if (!spawned)
-            return [];
-        return spawned.client.outgoingCalls(item);
-    }
-    /**
-     * Get all diagnostics across all tracked files (for cascade checking)
-     */
-    async getAllDiagnostics() {
-        const all = new Map();
-        for (const [_key, client] of this.state.clients) {
-            const clientDiags = client.getAllDiagnostics();
-            for (const [filePath, diags] of clientDiags) {
-                const existing = all.get(filePath) ?? [];
-                all.set(filePath, [...existing, ...diags]);
-            }
-        }
-        return all;
-    }
-    /**
-     * Check if LSP is available for a file
-     */
-    async hasLSP(filePath) {
-        const servers = getServersForFileWithConfig(filePath);
-        if (servers.length === 0)
-            return false;
-        // Check if any server can provide a root
-        for (const server of servers) {
-            const root = await server.root(filePath);
-            if (root)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Shutdown all LSP clients
-     */
-    async shutdown() {
-        // Cancel any in-flight spawns
-        this.state.inFlight.clear();
-        for (const [key, client] of this.state.clients) {
-            try {
-                await client.shutdown();
-            }
-            catch (err) {
-                console.error(`[lsp] Error shutting down ${key}:`, err);
-            }
-        }
-        this.state.clients.clear();
-        this.state.broken.clear();
-    }
-    /**
-     * Get status of all active clients
-     */
-    getStatus() {
-        return Array.from(this.state.clients.entries()).map(([key, _client]) => {
-            const [serverId, root] = key.split(":");
-            return { serverId, root, connected: true };
-        });
-    }
-}
-// --- Effect Integration ---
-/**
- * Effect wrapper for LSP operations
- */
-export function lspEffect(service) {
-    return {
-        openFile: (filePath, content) => Effect.tryPromise({
-            try: () => service.openFile(filePath, content),
-            catch: (err) => err,
-        }),
-        updateFile: (filePath, content) => Effect.tryPromise({
-            try: () => service.updateFile(filePath, content),
-            catch: (err) => err,
-        }),
-        getDiagnostics: (filePath) => Effect.tryPromise({
-            try: () => service.getDiagnostics(filePath),
-            catch: (err) => err,
-        }),
-        hasLSP: (filePath) => Effect.tryPromise({
-            try: () => service.hasLSP(filePath),
-            catch: (err) => err,
-        }),
-        shutdown: () => Effect.tryPromise({
-            try: () => service.shutdown(),
-            catch: (err) => err,
-        }),
-    };
-}
-// --- Singleton Instance ---
-let globalLSPService = null;
-export function getLSPService() {
-    if (!globalLSPService) {
-        globalLSPService = new LSPService();
-    }
-    return globalLSPService;
-}
-export function resetLSPService() {
-    if (globalLSPService) {
-        globalLSPService.shutdown().catch(() => { });
-    }
-    globalLSPService = null;
-}

package/clients/lsp/installer/index.js

@@ -1,391 +0,0 @@
-/**
- * Auto-Installation System for pi-lens
- *
- * Automatically installs required tools when they're not found.
- * Covers 14/31 LSP servers (npm/pip installable) plus linting tools.
- *
- * Core LSP (5):
- * - typescript-language-server (TypeScript)
- * - pyright (Python)
- * - yaml-language-server (YAML)
- * - vscode-json-languageserver (JSON)
- * - bash-language-server (Bash)
- *
- * Web Framework LSP (4):
- * - @vue/language-server (Vue)
- * - svelte-language-server (Svelte)
- * - vscode-eslint-language-server (ESLint)
- * - vscode-css-languageserver (CSS/SCSS/Sass/Less)
- *
- * DevOps/Config LSP (2):
- * - dockerfile-language-server-nodejs (Dockerfile)
- * - @prisma/language-server (Prisma)
- *
- * Linting/Structural (3):
- * - ruff (Python linting)
- * - @biomejs/biome (JS/TS/JSON linting)
- * - @ast-grep/cli (structural search)
- *
- * Strategies:
- * - npm packages via npx/bun
- * - pip packages
- * - GitHub releases (for platform-specific binaries - not yet implemented)
- */
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import path from "path";
-// Global installation directory for pi-lens tools
-const TOOLS_DIR = path.join(process.cwd(), ".pi-lens", "tools");
-const TOOLS = [
-    // Core LSP servers
-    {
-        id: "typescript-language-server",
-        name: "TypeScript Language Server",
-        checkCommand: "typescript-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "typescript-language-server",
-        binaryName: "typescript-language-server",
-    },
-    {
-        id: "pyright",
-        name: "Pyright",
-        checkCommand: "pyright",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "pyright",
-        binaryName: "pyright",
-    },
-    // Linting/formatting tools
-    {
-        id: "ruff",
-        name: "Ruff",
-        checkCommand: "ruff",
-        checkArgs: ["--version"],
-        installStrategy: "pip",
-        packageName: "ruff",
-        binaryName: "ruff",
-    },
-    {
-        id: "biome",
-        name: "Biome",
-        checkCommand: "biome",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "@biomejs/biome",
-        binaryName: "biome",
-    },
-    {
-        id: "ast-grep",
-        name: "ast-grep",
-        checkCommand: "ast-grep",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "@ast-grep/cli",
-        binaryName: "sg",
-    },
-    // Config/Data LSP servers
-    {
-        id: "yaml-language-server",
-        name: "YAML Language Server",
-        checkCommand: "yaml-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "yaml-language-server",
-        binaryName: "yaml-language-server",
-    },
-    {
-        id: "vscode-json-languageserver",
-        name: "JSON Language Server",
-        checkCommand: "vscode-json-languageserver",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "vscode-langservers-extracted",
-        binaryName: "vscode-json-languageserver",
-    },
-    // Shell/DevOps LSP servers
-    {
-        id: "bash-language-server",
-        name: "Bash Language Server",
-        checkCommand: "bash-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "bash-language-server",
-        binaryName: "bash-language-server",
-    },
-    {
-        id: "dockerfile-language-server",
-        name: "Dockerfile Language Server",
-        checkCommand: "dockerfile-language-server-nodejs",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "dockerfile-language-server-nodejs",
-        binaryName: "dockerfile-language-server-nodejs",
-    },
-    // Web framework LSP servers
-    {
-        id: "vue-language-server",
-        name: "Vue Language Server",
-        checkCommand: "vue-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "@vue/language-server",
-        binaryName: "vue-language-server",
-    },
-    {
-        id: "svelte-language-server",
-        name: "Svelte Language Server",
-        checkCommand: "svelteserver",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "svelte-language-server",
-        binaryName: "svelteserver",
-    },
-    {
-        id: "eslint-server",
-        name: "ESLint Language Server",
-        checkCommand: "vscode-eslint-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "vscode-langservers-extracted",
-        binaryName: "vscode-eslint-language-server",
-    },
-    {
-        id: "css-language-server",
-        name: "CSS Language Server",
-        checkCommand: "vscode-css-languageserver",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "vscode-langservers-extracted",
-        binaryName: "vscode-css-languageserver",
-    },
-    // Database/ORM LSP servers
-    {
-        id: "prisma-language-server",
-        name: "Prisma Language Server",
-        checkCommand: "prisma-language-server",
-        checkArgs: ["--version"],
-        installStrategy: "npm",
-        packageName: "@prisma/language-server",
-        binaryName: "prisma-language-server",
-    },
-];
-// --- Check Functions ---
-/**
- * Check if a command is available in PATH
- */
-async function isCommandAvailable(command, args = ["--version"]) {
-    return new Promise((resolve) => {
-        // On Windows, use shell: true to handle .cmd files
-        const isWindows = process.platform === "win32";
-        const proc = isWindows
-            ? spawn(`${command} ${args.join(" ")}`, [], { stdio: "ignore", shell: true })
-            : spawn(command, args, { stdio: "ignore" });
-        proc.on("exit", (code) => resolve(code === 0));
-        proc.on("error", () => resolve(false));
-    });
-}
-/**
- * Check if a tool is installed (globally or locally)
- */
-export async function isToolInstalled(toolId) {
-    const tool = TOOLS.find((t) => t.id === toolId);
-    if (!tool)
-        return false;
-    // Check global PATH
-    if (await isCommandAvailable(tool.checkCommand, tool.checkArgs)) {
-        return true;
-    }
-    // Check local tools directory
-    const localPath = path.join(TOOLS_DIR, "node_modules", ".bin", tool.binaryName || tool.id);
-    try {
-        await fs.access(localPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the path to a tool (global or local)
- */
-export async function getToolPath(toolId) {
-    const tool = TOOLS.find((t) => t.id === toolId);
-    if (!tool)
-        return undefined;
-    // Check if global
-    if (await isCommandAvailable(tool.checkCommand, tool.checkArgs)) {
-        return tool.checkCommand;
-    }
-    // Check local
-    const localPath = path.join(TOOLS_DIR, "node_modules", ".bin", tool.binaryName || tool.id);
-    try {
-        await fs.access(localPath);
-        return localPath;
-    }
-    catch {
-        return undefined;
-    }
-}
-// --- Installation Functions ---
-/**
- * Install an npm package tool
- */
-async function installNpmTool(packageName, binaryName) {
-    try {
-        // Ensure tools directory exists
-        await fs.mkdir(TOOLS_DIR, { recursive: true });
-        // Create a minimal package.json if it doesn't exist
-        const packageJsonPath = path.join(TOOLS_DIR, "package.json");
-        try {
-            await fs.access(packageJsonPath);
-        }
-        catch {
-            await fs.writeFile(packageJsonPath, JSON.stringify({ name: "pi-lens-tools", version: "1.0.0" }, null, 2));
-        }
-        // Install via npm or bun (use .cmd on Windows)
-        const isWindows = process.platform === "win32";
-        const pm = process.env.BUN_INSTALL
-            ? isWindows ? "bun.exe" : "bun"
-            : isWindows ? "npm.cmd" : "npm";
-        const proc = spawn(pm, ["install", packageName], {
-            cwd: TOOLS_DIR,
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: isWindows, // Required for .cmd files on Windows
-        });
-        return new Promise((resolve, reject) => {
-            let stderr = "";
-            proc.stderr?.on("data", (data) => (stderr += data));
-            proc.on("exit", async (code) => {
-                if (code === 0) {
-                    const binPath = path.join(TOOLS_DIR, "node_modules", ".bin", binaryName);
-                    // Make executable on Unix
-                    if (process.platform !== "win32") {
-                        try {
-                            await fs.chmod(binPath, 0o755);
-                        }
-                        catch { /* ignore */ }
-                    }
-                    resolve(binPath);
-                }
-                else {
-                    reject(new Error(`Failed to install ${packageName}: ${stderr}`));
-                }
-            });
-            proc.on("error", (err) => reject(err));
-        });
-    }
-    catch (err) {
-        console.error(`[auto-install] Failed to install npm tool ${packageName}:`, err);
-        return undefined;
-    }
-}
-/**
- * Install a pip package tool
- */
-async function installPipTool(packageName) {
-    try {
-        const pipCmd = process.platform === "win32" ? "pip" : "pip3";
-        const isWindows = process.platform === "win32";
-        const proc = spawn(pipCmd, ["install", "--user", packageName], {
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: isWindows, // Required for .cmd files on Windows
-        });
-        return new Promise((resolve, reject) => {
-            let stderr = "";
-            proc.stderr?.on("data", (data) => (stderr += data));
-            proc.on("exit", (code) => {
-                if (code === 0) {
-                    resolve(packageName); // pip installs to PATH
-                }
-                else {
-                    reject(new Error(`Failed to install ${packageName}: ${stderr}`));
-                }
-            });
-            proc.on("error", (err) => reject(err));
-        });
-    }
-    catch (err) {
-        console.error(`[auto-install] Failed to install pip tool ${packageName}:`, err);
-        return undefined;
-    }
-}
-/**
- * Install a tool by ID
- */
-export async function installTool(toolId) {
-    const tool = TOOLS.find((t) => t.id === toolId);
-    if (!tool) {
-        console.error(`[auto-install] Unknown tool: ${toolId}`);
-        return false;
-    }
-    console.error(`[auto-install] Installing ${tool.name}...`);
-    try {
-        switch (tool.installStrategy) {
-            case "npm":
-                if (!tool.packageName || !tool.binaryName)
-                    return false;
-                const npmPath = await installNpmTool(tool.packageName, tool.binaryName);
-                return npmPath !== undefined;
-            case "pip":
-                if (!tool.packageName)
-                    return false;
-                const pipPath = await installPipTool(tool.packageName);
-                return pipPath !== undefined;
-            default:
-                console.error(`[auto-install] Unsupported strategy: ${tool.installStrategy}`);
-                return false;
-        }
-    }
-    catch (err) {
-        console.error(`[auto-install] Failed to install ${tool.name}:`, err);
-        return false;
-    }
-}
-/**
- * Ensure a tool is installed (check first, install if missing)
- */
-export async function ensureTool(toolId) {
-    // Check if already installed
-    const existingPath = await getToolPath(toolId);
-    if (existingPath) {
-        return existingPath;
-    }
-    // Try to install
-    const installed = await installTool(toolId);
-    if (!installed) {
-        return undefined;
-    }
-    // Return the path after installation
-    return getToolPath(toolId);
-}
-// --- Integration Helpers ---
-/**
- * Get environment with tool paths added
- */
-export async function getToolEnvironment() {
-    const localBin = path.join(TOOLS_DIR, "node_modules", ".bin");
-    const currentPath = process.env.PATH || "";
-    const separator = process.platform === "win32" ? ";" : ":";
-    return {
-        ...process.env,
-        PATH: `${localBin}${separator}${currentPath}`,
-    };
-}
-// --- Status Check ---
-/**
- * Check status of all managed tools
- */
-export async function checkAllTools() {
-    const results = [];
-    for (const tool of TOOLS) {
-        const path = await getToolPath(tool.id);
-        results.push({
-            id: tool.id,
-            name: tool.name,
-            installed: path !== undefined,
-            path,
-        });
-    }
-    return results;
-}