acmecode 1.0.0

package/packages/core/src/tools/lsp-client.ts

@@ -0,0 +1,303 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "child_process";
+import path from "path";
+import { pathToFileURL } from "url";
+import {
+  createMessageConnection,
+  StreamMessageReader,
+  StreamMessageWriter,
+  MessageConnection,
+} from "vscode-jsonrpc/lib/node/main.js";
+import type { Diagnostic } from "vscode-languageserver-types";
+import * as fs from "fs/promises";
+
+export interface LspClient {
+  connection: MessageConnection;
+  process: ChildProcessWithoutNullStreams;
+  diagnostics: Map<string, Diagnostic[]>;
+  openFile: (filePath: string, timeoutMs?: number) => Promise<void>;
+  shutdown: () => Promise<void>;
+}
+
+type LanguageId = "typescript" | "python" | "go" | "rust";
+
+interface ServerConfig {
+  command: string;
+  args: string[];
+  languageIdResolver: (filePath: string) => string;
+}
+
+const SERVER_CONFIGS: Record<LanguageId, ServerConfig> = {
+  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<LanguageId, LspClient>();
+const clientInitializationPromises = new Map<LanguageId, Promise<LspClient>>();
+
+// Track file versions globally across all servers
+const fileVersions = new Map<string, number>();
+
+function getLanguageIdForExtension(filePath: string): LanguageId | null {
+  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: string): Promise<string | null> {
+  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: string,
+): Promise<{ command: string; args: string[] }> {
+  // 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: string,
+  filePath: string,
+): Promise<LspClient> {
+  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: string,
+  langId: LanguageId,
+): Promise<LspClient> {
+  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<void>((resolve, reject) => {
+    const onExit = (code: number | null) => {
+      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<string, Diagnostic[]>();
+  // Listeners waiting for diagnostics on a specific URI
+  const diagnosticsListeners = new Map<string, Array<() => void>>();
+
+  connection.onNotification(
+    "textDocument/publishDiagnostics",
+    (params: any) => {
+      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: any = {};
+  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<never>((_, 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: LspClient = {
+    connection,
+    process: proc,
+    diagnostics: diagnosticsMap,
+    openFile: async (filePath: string, 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<void>((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<void>((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/packages/core/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "outDir": "dist",
+        "rootDir": "src",
+        "declaration": true,
+        "composite": true,
+        "jsx": "react"
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/packages/tui/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@acmecode/tui",
+    "version": "1.0.0",
+    "type": "module",
+    "main": "dist/index.js",
+    "exports": {
+        "./*": "./dist/*"
+    },
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@acmecode/core": "^1.0.0",
+        "ink": "^6.8.0",
+        "ink-text-input": "^6.0.0",
+        "marked": "^17.0.3",
+        "picocolors": "^1.1.1",
+        "react": "^19.2.4"
+    },
+    "devDependencies": {
+        "@types/node": "^25.3.0",
+        "@types/react": "^19.2.14"
+    }
+}