march-cli 0.1.0

package/src/lsp/client.mjs

@@ -0,0 +1,204 @@
+import { spawn } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { extname } from "node:path";
+import { readFileSync } from "node:fs";
+
+const INITIALIZE_TIMEOUT_MS = 15000;
+const TEXT_DOCUMENT_SYNC_INCREMENTAL = 2;
+
+const LANGUAGE_IDS = {
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".vue": "vue",
+};
+
+export class LspClient {
+  constructor({ serverId, command, args = [], cwd, initialization = {}, store }) {
+    this.serverId = serverId;
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.initialization = initialization;
+    this.store = store;
+    this.status = "starting";
+    this.process = null;
+    this.buffer = Buffer.alloc(0);
+    this.nextId = 1;
+    this.pending = new Map();
+    this.documents = new Map();
+    this.syncKind = null;
+  }
+
+  async start() {
+    this.process = spawn(this.command, this.args, {
+      cwd: this.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    this.process.stdout.on("data", (chunk) => this.#onData(chunk));
+    this.process.on("exit", () => {
+      this.status = "failed";
+      for (const pending of this.pending.values()) pending.reject(new Error("LSP exited"));
+      this.pending.clear();
+    });
+
+    const initialized = await withTimeout(this.#request("initialize", {
+      processId: process.pid,
+      rootUri: pathToFileURL(this.cwd).href,
+      workspaceFolders: [{ name: "workspace", uri: pathToFileURL(this.cwd).href }],
+      initializationOptions: this.initialization,
+      capabilities: {
+        workspace: {
+          configuration: true,
+          workspaceFolders: true,
+        },
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+          },
+          publishDiagnostics: {},
+        },
+      },
+    }), INITIALIZE_TIMEOUT_MS);
+    this.syncKind = getSyncKind(initialized?.capabilities);
+    this.#notify("initialized", {});
+    this.status = "ready";
+  }
+
+  touchFile(path) {
+    if (this.status === "failed") return;
+    const text = readFileSync(path, "utf8");
+    const uri = pathToFileURL(path).href;
+    const existing = this.documents.get(path);
+    this.status = "busy";
+    if (existing) {
+      const version = existing.version + 1;
+      this.documents.set(path, { version, text });
+      this.#notify("textDocument/didChange", {
+        textDocument: { uri, version },
+        contentChanges: this.syncKind === TEXT_DOCUMENT_SYNC_INCREMENTAL
+          ? [{ range: { start: { line: 0, character: 0 }, end: endPosition(existing.text) }, text }]
+          : [{ text }],
+      });
+      return;
+    }
+    this.documents.set(path, { version: 0, text });
+    this.#notify("textDocument/didOpen", {
+      textDocument: {
+        uri,
+        languageId: LANGUAGE_IDS[extname(path).toLowerCase()] ?? "plaintext",
+        version: 0,
+        text,
+      },
+    });
+  }
+
+  async shutdown() {
+    if (!this.process) return;
+    try { this.#notify("shutdown", null); } catch {}
+    this.process.kill();
+  }
+
+  #onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    for (;;) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+      const header = this.buffer.slice(0, headerEnd).toString("utf8");
+      const match = header.match(/Content-Length: (\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.slice(headerEnd + 4);
+        continue;
+      }
+      const length = Number(match[1]);
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + length;
+      if (this.buffer.length < messageEnd) return;
+      const raw = this.buffer.slice(messageStart, messageEnd).toString("utf8");
+      this.buffer = this.buffer.slice(messageEnd);
+      try {
+        this.#handleMessage(JSON.parse(raw));
+      } catch {}
+    }
+  }
+
+  #handleMessage(message) {
+    if (message.id !== undefined && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      if (message.error) pending.reject(new Error(message.error.message ?? "LSP request failed"));
+      else pending.resolve(message.result);
+      return;
+    }
+
+    if (message.method === "textDocument/publishDiagnostics") {
+      this.store.replaceFile({
+        serverId: this.serverId,
+        uri: message.params?.uri,
+        diagnostics: message.params?.diagnostics ?? [],
+      });
+      this.status = "idle";
+      return;
+    }
+
+    if (message.id !== undefined && message.method) {
+      this.#send({ jsonrpc: "2.0", id: message.id, result: this.#requestResult(message.method) });
+    }
+  }
+
+  #requestResult(method) {
+    if (method === "workspace/configuration") return [];
+    if (method === "workspace/workspaceFolders") return [{ name: "workspace", uri: pathToFileURL(this.cwd).href }];
+    if (method === "window/workDoneProgress/create") return null;
+    if (method === "client/registerCapability") return null;
+    if (method === "client/unregisterCapability") return null;
+    return null;
+  }
+
+  #request(method, params) {
+    const id = this.nextId++;
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+    this.#send({ jsonrpc: "2.0", id, method, params });
+    return promise;
+  }
+
+  #notify(method, params) {
+    this.#send({ jsonrpc: "2.0", method, params });
+  }
+
+  #send(message) {
+    const body = JSON.stringify(message);
+    this.process.stdin.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+  }
+}
+
+function withTimeout(promise, ms) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error("LSP initialize timed out")), ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+function getSyncKind(capabilities) {
+  const sync = capabilities?.textDocumentSync;
+  if (typeof sync === "number") return sync;
+  return sync?.change ?? null;
+}
+
+function endPosition(text) {
+  const lines = text.split(/\r\n|\r|\n/);
+  return { line: lines.length - 1, character: lines.at(-1)?.length ?? 0 };
+}

package/src/lsp/diagnostic-store.mjs

@@ -0,0 +1,39 @@
+import { fileURLToPath } from "node:url";
+
+export class LspDiagnosticStore {
+  constructor() {
+    this.byPath = new Map();
+  }
+
+  replaceFile({ serverId, uri, diagnostics = [] }) {
+    const path = uriToPath(uri);
+    if (!path) return;
+    const normalized = diagnostics.map((diagnostic) => ({
+      ...diagnostic,
+      serverId,
+      path,
+    }));
+    this.byPath.set(path, {
+      path,
+      updatedAt: Date.now(),
+      diagnostics: normalized,
+    });
+  }
+
+  snapshot() {
+    const diagnostics = [];
+    for (const entry of this.byPath.values()) {
+      diagnostics.push(...entry.diagnostics);
+    }
+    return diagnostics;
+  }
+}
+
+function uriToPath(uri) {
+  if (typeof uri !== "string" || !uri.startsWith("file://")) return null;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}

package/src/lsp/servers.mjs

@@ -0,0 +1,212 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+
+const NODE_ROOT_MARKERS = ["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock", "package.json"];
+
+const LSP_SERVERS = [
+  {
+    id: "vue",
+    extensions: [".vue"],
+    rootMarkers: NODE_ROOT_MARKERS,
+    command: ["vue-language-server"],
+    args: ["--stdio"],
+    initialization: () => ({}),
+  },
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    rootMarkers: NODE_ROOT_MARKERS,
+    command: ["typescript-language-server"],
+    args: ["--stdio"],
+    initialization: ({ root, workspaceRoot }) => {
+      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
+      if (!tsserver) return null;
+      return { tsserver: { path: tsserver } };
+    },
+  },
+  {
+    id: "python",
+    extensions: [".py", ".pyi"],
+    rootMarkers: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"],
+    command: ["pyright-langserver"],
+    args: ["--stdio"],
+  },
+  {
+    id: "go",
+    extensions: [".go"],
+    rootMarkers: ["go.work", "go.mod", "go.sum"],
+    command: ["gopls"],
+    args: [],
+  },
+  {
+    id: "rust",
+    extensions: [".rs"],
+    rootMarkers: ["Cargo.toml", "Cargo.lock"],
+    command: ["rust-analyzer"],
+    args: [],
+  },
+  {
+    id: "clangd",
+    extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"],
+    rootMarkers: ["compile_commands.json", "compile_flags.txt", ".clangd"],
+    command: ["clangd"],
+    args: ["--background-index", "--clang-tidy"],
+  },
+  {
+    id: "svelte",
+    extensions: [".svelte"],
+    rootMarkers: NODE_ROOT_MARKERS,
+    command: ["svelteserver", "svelte-language-server"],
+    args: ["--stdio"],
+    initialization: () => ({}),
+  },
+  {
+    id: "astro",
+    extensions: [".astro"],
+    rootMarkers: NODE_ROOT_MARKERS,
+    command: ["astro-ls", "@astrojs/language-server"],
+    args: ["--stdio"],
+    initialization: ({ root, workspaceRoot }) => {
+      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
+      if (!tsserver) return null;
+      return { typescript: { tsdk: dirname(tsserver) } };
+    },
+  },
+  {
+    id: "yaml",
+    extensions: [".yaml", ".yml"],
+    rootMarkers: NODE_ROOT_MARKERS,
+    command: ["yaml-language-server"],
+    args: ["--stdio"],
+  },
+  {
+    id: "bash",
+    extensions: [".sh", ".bash", ".zsh", ".ksh"],
+    rootMarkers: [],
+    command: ["bash-language-server"],
+    args: ["start"],
+  },
+  {
+    id: "lua",
+    extensions: [".lua"],
+    rootMarkers: [".luarc.json", ".luarc.jsonc", ".luacheckrc", ".stylua.toml", "stylua.toml", "selene.toml", "selene.yml"],
+    command: ["lua-language-server"],
+    args: [],
+  },
+  {
+    id: "zig",
+    extensions: [".zig", ".zon"],
+    rootMarkers: ["build.zig"],
+    command: ["zls"],
+    args: [],
+  },
+  {
+    id: "dart",
+    extensions: [".dart"],
+    rootMarkers: ["pubspec.yaml", "analysis_options.yaml"],
+    command: ["dart"],
+    args: ["language-server", "--lsp"],
+  },
+  {
+    id: "php",
+    extensions: [".php"],
+    rootMarkers: ["composer.json", "composer.lock", ".php-version"],
+    command: ["intelephense"],
+    args: ["--stdio"],
+    initialization: () => ({ telemetry: { enabled: false } }),
+  },
+  {
+    id: "prisma",
+    extensions: [".prisma"],
+    rootMarkers: ["schema.prisma", "prisma/schema.prisma", "prisma"],
+    command: ["prisma"],
+    args: ["language-server"],
+  },
+];
+
+export function resolveLspServer({ filePath, workspaceRoot }) {
+  const ext = extensionOf(filePath);
+  const def = LSP_SERVERS.find((server) => server.extensions.includes(ext));
+  if (!def) return null;
+
+  const root = def.rootMarkers.length > 0
+    ? findNearestRoot(dirname(filePath), workspaceRoot, def.rootMarkers) ?? workspaceRoot
+    : workspaceRoot;
+  const command = findCommand(def.command, { root, workspaceRoot });
+  if (!command) return null;
+  const initialization = def.initialization?.({ root, workspaceRoot }) ?? {};
+  if (initialization === null) return null;
+  return {
+    id: def.id,
+    command,
+    args: def.args,
+    root,
+    initialization,
+  };
+}
+
+export function listLspServerDefinitions() {
+  return LSP_SERVERS.map(({ id, extensions, rootMarkers, command, args }) => ({ id, extensions, rootMarkers, command, args }));
+}
+
+function findCommand(names, { root, workspaceRoot }) {
+  for (const name of names) {
+    const hit = findBin(name, { root, workspaceRoot });
+    if (hit) return hit;
+  }
+  return null;
+}
+
+function findBin(name, { root, workspaceRoot }) {
+  const names = platformCommandNames(name);
+  for (const base of [root, workspaceRoot]) {
+    for (const bin of names) {
+      const candidate = join(base, "node_modules", ".bin", bin);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return findOnPath(names);
+}
+
+function platformCommandNames(name) {
+  if (process.platform !== "win32") return [name];
+  return name.includes("/") ? [name] : [`${name}.cmd`, `${name}.exe`, name];
+}
+
+function findOnPath(names) {
+  const dirs = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":").filter(Boolean);
+  for (const dir of dirs) {
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function resolveModule(id, base) {
+  try {
+    return createRequire(join(base, "package.json")).resolve(id);
+  } catch {
+    return null;
+  }
+}
+
+function findNearestRoot(start, stop, markers) {
+  let dir = resolve(start);
+  const boundary = resolve(stop);
+  for (;;) {
+    for (const marker of markers) {
+      if (existsSync(join(dir, marker))) return dir;
+    }
+    if (dir === boundary || dirname(dir) === dir) return null;
+    dir = dirname(dir);
+  }
+}
+
+function extensionOf(path) {
+  const lower = path.toLowerCase();
+  const dot = lower.lastIndexOf(".");
+  return dot === -1 ? "" : lower.slice(dot);
+}

package/src/lsp/service.mjs

@@ -0,0 +1,65 @@
+import { LspClient } from "./client.mjs";
+import { LspDiagnosticStore } from "./diagnostic-store.mjs";
+import { resolveLspServer } from "./servers.mjs";
+
+export class LspService {
+  constructor({ cwd }) {
+    this.cwd = cwd;
+    this.store = new LspDiagnosticStore();
+    this.clients = new Map();
+    this.spawning = new Map();
+  }
+
+  touchFile(path) {
+    const server = resolveLspServer({ filePath: path, workspaceRoot: this.cwd });
+    if (!server) return;
+    const key = `${server.id}:${server.root}`;
+    const existing = this.clients.get(key);
+    if (existing) {
+      existing.touchFile(path);
+      return;
+    }
+    if (this.spawning.has(key)) {
+      this.spawning.get(key).then((client) => client?.touchFile(path)).catch(() => {});
+      return;
+    }
+    const task = this.#startClient(server, key).then((client) => {
+      client?.touchFile(path);
+      return client;
+    });
+    this.spawning.set(key, task);
+    task.finally(() => {
+      if (this.spawning.get(key) === task) this.spawning.delete(key);
+    }).catch(() => {});
+  }
+
+  snapshot() {
+    const diagnostics = this.store.snapshot();
+    const statuses = [...this.clients.values()].map((client) => client.status);
+    const status = statuses.includes("busy") ? "busy" : statuses.includes("starting") ? "starting" : statuses.includes("failed") ? "failed" : statuses.length > 0 ? "idle" : "";
+    return { status, diagnostics };
+  }
+
+  async dispose() {
+    await Promise.all([...this.clients.values()].map((client) => client.shutdown().catch(() => {})));
+  }
+
+  async #startClient(server, key) {
+    const client = new LspClient({
+      serverId: server.id,
+      command: server.command,
+      args: server.args,
+      cwd: server.root,
+      initialization: server.initialization,
+      store: this.store,
+    });
+    try {
+      await client.start();
+      this.clients.set(key, client);
+      return client;
+    } catch {
+      client.status = "failed";
+      return null;
+    }
+  }
+}