@acmecloud/core 1.0.2

package/dist/tools/lsp-client.d.ts

@@ -0,0 +1,11 @@
+import { type ChildProcessWithoutNullStreams } from "child_process";
+import { MessageConnection } from "vscode-jsonrpc/lib/node/main.js";
+import type { Diagnostic } from "vscode-languageserver-types";
+export interface LspClient {
+    connection: MessageConnection;
+    process: ChildProcessWithoutNullStreams;
+    diagnostics: Map<string, Diagnostic[]>;
+    openFile: (filePath: string, timeoutMs?: number) => Promise<void>;
+    shutdown: () => Promise<void>;
+}
+export declare function getLspClientForFile(workspaceRoot: string, filePath: string): Promise<LspClient>;

package/dist/tools/lsp-client.js

@@ -0,0 +1,224 @@
+import { spawn } from "child_process";
+import path from "path";
+import { pathToFileURL } from "url";
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter, } from "vscode-jsonrpc/lib/node/main.js";
+import * as fs from "fs/promises";
+const SERVER_CONFIGS = {
+    typescript: {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args: ["--no-install", "typescript-language-server", "--stdio"],
+        languageIdResolver: (filePath) => filePath.endsWith(".tsx")
+            ? "typescriptreact"
+            : filePath.endsWith(".jsx")
+                ? "javascriptreact"
+                : filePath.endsWith(".js")
+                    ? "javascript"
+                    : "typescript",
+    },
+    python: {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        // npx pyright-langserver will use standard pyright if available
+        args: ["--no-install", "pyright-langserver", "--stdio"],
+        languageIdResolver: () => "python",
+    },
+    go: {
+        command: "gopls",
+        args: [], // gopls runs in stdio mode by default
+        languageIdResolver: () => "go",
+    },
+    rust: {
+        command: "rust-analyzer",
+        args: [],
+        languageIdResolver: () => "rust",
+    },
+};
+const clients = new Map();
+const clientInitializationPromises = new Map();
+// Track file versions globally across all servers
+const fileVersions = new Map();
+function getLanguageIdForExtension(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if ([".ts", ".tsx", ".js", ".jsx", ".cjs", ".mjs"].includes(ext))
+        return "typescript";
+    if ([".py", ".pyi"].includes(ext))
+        return "python";
+    if ([".go"].includes(ext))
+        return "go";
+    if ([".rs"].includes(ext))
+        return "rust";
+    return null;
+}
+async function getTsServerPath(workspaceRoot) {
+    const localTsServer = path.join(workspaceRoot, "node_modules", "typescript", "lib", "tsserver.js");
+    try {
+        await fs.stat(localTsServer);
+        return localTsServer;
+    }
+    catch { }
+    return null;
+}
+async function resolveTsLsCommand(workspaceRoot) {
+    // Walk up from workspaceRoot looking for node_modules/.bin/typescript-language-server
+    const bin = process.platform === "win32"
+        ? "typescript-language-server.cmd"
+        : "typescript-language-server";
+    let dir = workspaceRoot;
+    for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, "node_modules", ".bin", bin);
+        try {
+            await fs.access(candidate);
+            return { command: candidate, args: ["--stdio"] };
+        }
+        catch { }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: try global install via npx (with --no-install to avoid slow download)
+    return {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args: ["--no-install", "typescript-language-server", "--stdio"],
+    };
+}
+export async function getLspClientForFile(workspaceRoot, filePath) {
+    const langId = getLanguageIdForExtension(filePath);
+    if (!langId) {
+        throw new Error(`Unsupported file extension for LSP: ${filePath}`);
+    }
+    if (clients.has(langId)) {
+        return clients.get(langId);
+    }
+    if (!clientInitializationPromises.has(langId)) {
+        const promise = initializeLspClient(workspaceRoot, langId).catch((err) => {
+            clientInitializationPromises.delete(langId);
+            throw err;
+        });
+        clientInitializationPromises.set(langId, promise);
+    }
+    return clientInitializationPromises.get(langId);
+}
+async function initializeLspClient(workspaceRoot, langId) {
+    let config = SERVER_CONFIGS[langId];
+    // For TypeScript, prefer the local node_modules binary over npx
+    if (langId === "typescript") {
+        const resolved = await resolveTsLsCommand(workspaceRoot);
+        config = { ...config, ...resolved };
+    }
+    console.log(`[LSP] Starting ${langId} language server (${config.command} ${config.args.join(" ")})...`);
+    const proc = spawn(config.command, config.args, {
+        cwd: workspaceRoot,
+        env: { ...process.env },
+        shell: false, // direct binary, no shell needed
+    });
+    // Fast-fail: if the process exits immediately, it's not installed
+    await new Promise((resolve, reject) => {
+        const onExit = (code) => {
+            reject(new Error(`[LSP] ${langId} server exited immediately (code ${code}). Is it installed?`));
+        };
+        proc.once("exit", onExit);
+        // Give it 500ms to either crash or start successfully
+        setTimeout(() => {
+            proc.removeListener("exit", onExit);
+            resolve();
+        }, 500);
+    });
+    // Capture stderr for debug logging
+    proc.stderr.on("data", (data) => {
+        // console.error(`[LSP ${langId}] ${data.toString()}`);
+    });
+    const connection = createMessageConnection(new StreamMessageReader(proc.stdout), new StreamMessageWriter(proc.stdin));
+    const diagnosticsMap = new Map();
+    // Listeners waiting for diagnostics on a specific URI
+    const diagnosticsListeners = new Map();
+    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+        diagnosticsMap.set(params.uri, params.diagnostics);
+        // Notify any waiters for this URI
+        const listeners = diagnosticsListeners.get(params.uri);
+        if (listeners) {
+            diagnosticsListeners.delete(params.uri);
+            for (const cb of listeners)
+                cb();
+        }
+    });
+    connection.onRequest("window/workDoneProgress/create", () => null);
+    connection.onRequest("workspace/configuration", () => [{}]);
+    connection.listen();
+    let initializationOptions = {};
+    if (langId === "typescript") {
+        const tsserverPath = await getTsServerPath(workspaceRoot);
+        if (tsserverPath) {
+            initializationOptions = { tsserver: { path: tsserverPath } };
+        }
+    }
+    // 1. Initialize (with timeout to avoid hanging on slow server startup)
+    const INIT_TIMEOUT_MS = 15000;
+    await Promise.race([
+        connection.sendRequest("initialize", {
+            processId: process.pid,
+            rootUri: pathToFileURL(workspaceRoot).href,
+            capabilities: {
+                textDocument: {
+                    synchronization: { didOpen: true, didChange: true },
+                    publishDiagnostics: { relatedInformation: true },
+                },
+            },
+            initializationOptions,
+        }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`[LSP] initialize timed out after ${INIT_TIMEOUT_MS}ms`)), INIT_TIMEOUT_MS)),
+    ]);
+    // 2. Initialized
+    await connection.sendNotification("initialized", {});
+    const client = {
+        connection,
+        process: proc,
+        diagnostics: diagnosticsMap,
+        openFile: async (filePath, timeoutMs = 3000) => {
+            const uri = pathToFileURL(filePath).href;
+            const content = await fs.readFile(filePath, "utf8");
+            const version = fileVersions.get(uri);
+            const resolvedLangId = config.languageIdResolver(filePath);
+            // Set up a promise that resolves when publishDiagnostics fires for this URI
+            const diagReady = new Promise((resolve) => {
+                const existing = diagnosticsListeners.get(uri) ?? [];
+                existing.push(resolve);
+                diagnosticsListeners.set(uri, existing);
+            });
+            if (version !== undefined) {
+                const nextVersion = version + 1;
+                fileVersions.set(uri, nextVersion);
+                await connection.sendNotification("textDocument/didChange", {
+                    textDocument: { uri, version: nextVersion },
+                    contentChanges: [{ text: content }],
+                });
+            }
+            else {
+                fileVersions.set(uri, 0);
+                await connection.sendNotification("textDocument/didOpen", {
+                    textDocument: {
+                        uri,
+                        languageId: resolvedLangId,
+                        version: 0,
+                        text: content,
+                    },
+                });
+            }
+            // Wait for diagnostics or timeout — whichever comes first
+            await Promise.race([
+                diagReady,
+                new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+            ]);
+        },
+        shutdown: async () => {
+            await connection.sendRequest("shutdown");
+            await connection.sendNotification("exit");
+            connection.dispose();
+            proc.kill();
+            clients.delete(langId);
+            clientInitializationPromises.delete(langId);
+            // Note: fileVersions is global, we don't clear it here so documents stay "open" if another server needs them
+        },
+    };
+    clients.set(langId, client);
+    return client;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@acmecloud/core",
+  "version": "1.0.2",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    "./*": "./dist/*"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "postinstall": "npx playwright install chromium"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.46",
+    "@ai-sdk/deepinfra": "^2.0.34",
+    "@ai-sdk/google": "^3.0.30",
+    "@ai-sdk/groq": "^3.0.24",
+    "@ai-sdk/mistral": "^3.0.20",
+    "@ai-sdk/openai": "^3.0.30",
+    "@ai-sdk/xai": "^3.0.57",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@openrouter/ai-sdk-provider": "^2.2.3",
+    "@playwright/test": "^1.58.2",
+    "ai": "^6.0.97",
+    "better-sqlite3": "^12.6.2",
+    "diff": "^7.0.0",
+    "dotenv": "^17.3.1",
+    "iconv-lite": "^0.7.2",
+    "playwright": "^1.58.2",
+    "turndown": "^7.2.0",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-types": "^3.17.5",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/turndown": "^5.0.6"
+  }
+}