march-cli 0.1.14 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",

package/src/agent/command-exec-tool.mjs

@@ -6,6 +6,8 @@ import { toolText } from "./tool-result.mjs";
 import { stripAnsi } from "../text/ansi.mjs";
 
 const OUTPUT_LIMIT = 64 * 1024;
+const DEFAULT_COMMAND_TIMEOUT_SECONDS = 60;
+const COMMAND_KILL_GRACE_MS = 1000;
 
 export function createCommandExecTool({ cwd }) {
   return defineTool({
@@ -15,13 +17,13 @@ export function createCommandExecTool({ cwd }) {
     parameters: Type.Object({
       command: Type.String({ description: "Command to execute" }),
       shell: Type.Optional(Type.String({ description: "auto (default), bash, or powershell" })),
-      timeout: Type.Optional(Type.Number({ description: "Timeout in seconds; default 60" })),
+      timeout: Type.Optional(Type.Number({ description: "Timeout in seconds; default 60", default: DEFAULT_COMMAND_TIMEOUT_SECONDS })),
     }),
-    execute: async (_toolCallId, params) => executeCommand({ cwd, ...params }),
+    execute: async (_toolCallId, params, signal) => executeCommand({ cwd, signal, ...params }),
   });
 }
 
-export async function executeCommand({ cwd, command, shell = "auto", timeout = 60, spawnImpl = spawn }) {
+export async function executeCommand({ cwd, command, shell = "auto", timeout = DEFAULT_COMMAND_TIMEOUT_SECONDS, signal, spawnImpl = spawn, killProcessTreeImpl = killProcessTree, forceSettleMs = COMMAND_KILL_GRACE_MS }) {
   let resolved;
   try {
     resolved = resolveCommandShell(shell);
@@ -29,14 +31,18 @@ export async function executeCommand({ cwd, command, shell = "auto", timeout = 6
     return toolText(`Error: ${err.message}`, { error: true });
   }
 
-  const timeoutMs = Math.max(1, Number(timeout) || 60) * 1000;
+  const timeoutSeconds = Math.max(0.001, Number(timeout) || DEFAULT_COMMAND_TIMEOUT_SECONDS);
+  const timeoutMs = timeoutSeconds * 1000;
   const result = await spawnCommand(spawnImpl, resolved.bin, [...resolved.args, String(command ?? "")], {
     cwd,
     timeoutMs,
+    signal,
     windowsHide: true,
+    killProcessTreeImpl,
+    forceSettleMs,
   });
   if (result.error) {
-    const detail = result.timedOut ? ` (timed out after ${timeout}s)` : "";
+    const detail = result.timedOut ? ` (timed out after ${timeoutSeconds}s)` : "";
     return toolText(`Error: ${result.error.message}${detail}`, { error: true });
   }
   const stdout = stripAnsi(result.stdout ?? "");
@@ -57,12 +63,23 @@ function spawnCommand(spawnImpl, bin, args, options) {
     let stderr = "";
     let settled = false;
     let timedOut = false;
-    const child = spawnImpl(bin, args, { cwd: options.cwd, windowsHide: options.windowsHide });
+    let aborted = false;
+    let forceTimer = null;
+    const child = spawnImpl(bin, args, {
+      cwd: options.cwd,
+      windowsHide: options.windowsHide,
+      detached: process.platform !== "win32",
+    });
     const timer = setTimeout(() => {
       timedOut = true;
-      child.kill?.("SIGTERM");
+      terminateChild(new Error("Command timed out"));
     }, options.timeoutMs);
-    timer.unref?.();
+    const onAbort = () => {
+      aborted = true;
+      terminateChild(new Error("Command aborted"));
+    };
+    if (options.signal?.aborted) queueMicrotask(onAbort);
+    else options.signal?.addEventListener?.("abort", onAbort, { once: true });
 
     child.stdout?.setEncoding?.("utf8");
     child.stderr?.setEncoding?.("utf8");
@@ -71,16 +88,42 @@ function spawnCommand(spawnImpl, bin, args, options) {
     child.once?.("error", (error) => finish({ error }));
     child.once?.("close", (status, signal) => finish({ status, signal }));
 
+    function terminateChild(error) {
+      if (settled) return;
+      options.killProcessTreeImpl?.(child);
+      forceTimer ??= setTimeout(() => finish({ error }), options.forceSettleMs);
+    }
+
     function finish(result) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      const error = result.error ?? (timedOut ? Object.assign(new Error("Command timed out"), { code: "ETIMEDOUT" }) : null);
-      resolve({ ...result, error, stdout, stderr, timedOut });
+      clearTimeout(forceTimer);
+      options.signal?.removeEventListener?.("abort", onAbort);
+      const error = result.error ?? (timedOut ? Object.assign(new Error("Command timed out"), { code: "ETIMEDOUT" }) : null) ?? (aborted ? Object.assign(new Error("Command aborted"), { code: "ABORT_ERR" }) : null);
+      resolve({ ...result, error, stdout, stderr, timedOut, aborted });
     }
   });
 }
 
+function killProcessTree(child, platform = process.platform) {
+  if (!child?.pid) {
+    child?.kill?.("SIGTERM");
+    return;
+  }
+  if (platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 5000 });
+      return;
+    } catch {}
+  }
+  try {
+    process.kill(-child.pid, "SIGTERM");
+    return;
+  } catch {}
+  child.kill?.("SIGTERM");
+}
+
 function appendLimited(current, chunk) {
   const next = current + String(chunk ?? "");
   return next.length <= OUTPUT_LIMIT ? next : next.slice(-OUTPUT_LIMIT);

package/src/agent/runner.mjs

@@ -52,14 +52,11 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, profilePaths, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
-  let currentModelCallKind = "model", currentTurnId = null;
-  let currentPromptForContext = "";
+  let currentModelCallKind = "model", currentTurnId = null, currentPromptForContext = "";
   let currentTurnContextMode = "rebuild";
   let nextTurnContextMode = "rebuild";
   let pendingMidTurnRecallHints = [];
-  let lastNotificationResult = null;
-  let runtimeHost = null;
-  let lifecycleAdapter = null;
+  let lastNotificationResult = null, runtimeHost = null, lifecycleAdapter = null;
   let _currentFastEntry = null;
   if (useRuntimeHost) {
     runtimeHost = await createRunnerRuntimeHost({
@@ -227,10 +224,12 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     getExtensionDiagnostics() { return runtimeHost?.getDiagnostics?.() ?? []; },
     getExtensionLifecycleState() { return lifecycleAdapter.getState(); },
     getLspStatus() { return lspService.snapshot(); },
-    async switchPiSession(sessionPath) {
+    async switchPiSession(sessionPath, restoreState = null) {
       if (!runtimeHost) throw new Error("pi runtime host is not enabled");
       nextTurnContextMode = "rebuild";
-      return runtimeHost.switchSession(sessionPath);
+      const result = await runtimeHost.switchSession(sessionPath);
+      if (!result?.cancelled && restoreState) engine.restoreSession(restoreState, null, { replace: true });
+      return result;
     },
     cycleThinkingLevel() {
       const level = sessionBinding.get().cycleThinkingLevel();

package/src/agent/runtime/remote-runner-client.mjs

@@ -30,7 +30,7 @@ export function createRemoteRunnerClient(peer, { initialState = null } = {}) {
     getExtensionDiagnostics: () => state?.extensionDiagnostics ?? [],
     getExtensionLifecycleState: () => state?.extensionLifecycleState ?? null,
     getLspStatus: () => state?.lspStatus ?? null,
-    async switchPiSession(sessionPath) { return applyResultWithState(await peer.call("switchPiSession", sessionPath)); },
+    async switchPiSession(sessionPath, restoreState = null) { return applyResultWithState(await peer.call("switchPiSession", sessionPath, restoreState)); },
     async cycleThinkingLevel() { return applyResultWithState(await peer.call("cycleThinkingLevel")); },
     getThinkingLevel: () => state?.engine?.thinkingLevel ?? null,
     async setThinkingLevel(level) { return applyResultWithState(await peer.call("setThinkingLevel", level)); },

package/src/agent/runtime/runner-ipc-target.mjs

@@ -67,8 +67,8 @@ export function createRunnerIpcTarget({ createRunnerImpl, runnerOptions = {} } =
     getLspStatus() {
       return getRunner().getLspStatus();
     },
-    async switchPiSession(sessionPath) {
-      const result = await getRunner().switchPiSession(sessionPath);
+    async switchPiSession(sessionPath, restoreState = null) {
+      const result = await getRunner().switchPiSession(sessionPath, restoreState);
       return { result, state: getRunnerState(runner) };
     },
     cycleThinkingLevel() {
@@ -123,4 +123,3 @@ export function getRunnerState(runner) {
     extensionLifecycleState: runner.getExtensionLifecycleState?.() ?? null,
   };
 }
-

package/src/agent/tools.mjs

@@ -40,7 +40,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
   return tools.map((tool) => {
     const execute = tool.execute;
     if (!execute) return tool;
-    const wrapped = async (toolCallId, params) => {
+    const wrapped = async (toolCallId, params, signal, onUpdate) => {
       const decision = await permissionController.requestApproval(
         tool.name,
         params,
@@ -51,7 +51,7 @@ export function createMarchCustomTools({ cwd, engine, ui, memoryTools = [], shel
       if (decision.behavior === "deny") {
         return toolText(`Permission denied: ${decision.message}`, { error: true, permissionDenied: true });
       }
-      return execute(toolCallId, params);
+      return execute(toolCallId, params, signal, onUpdate);
     };
     return { ...tool, execute: wrapped };
   });

package/src/cli/session/pi-session-switch-command.mjs

@@ -26,13 +26,13 @@ export async function resumePiSessionById(id, { runner, sessions, projectMarchDi
   }
 
   let result;
+  const restoreState = toContextSessionState(sidecar.state);
   try {
-    result = await runner.switchPiSession(session.path);
+    result = await runner.switchPiSession(session.path, restoreState);
   } catch (err) {
     return [`Error: failed to switch pi session ${session.id}: ${err.message}`];
   }
   if (result?.cancelled) return [`Resume pi session cancelled: ${session.id}`];
-  runner.engine.restoreSession(toContextSessionState(sidecar.state), null, { replace: true });
   return [`Resumed pi session: ${session.id}`];
 }
 

package/src/lsp/client.mjs

@@ -1,23 +1,76 @@
 import { pathToFileURL } from "node:url";
 import { spawnCommand } from "../platform/spawn-command.mjs";
-import { extname } from "node:path";
+import { basename, extname } from "node:path";
 import { readFileSync } from "node:fs";
 
 const INITIALIZE_TIMEOUT_MS = 15000;
 const TEXT_DOCUMENT_SYNC_INCREMENTAL = 2;
 
 const LANGUAGE_IDS = {
+  ".astro": "astro",
+  ".bash": "shellscript",
+  ".c": "c",
+  ".c++": "cpp",
+  ".cc": "cpp",
+  ".cjs": "javascript",
+  ".cpp": "cpp",
+  ".css": "css",
+  ".cts": "typescript",
+  ".cxx": "cpp",
+  ".dart": "dart",
+  ".dockerfile": "dockerfile",
+  ".go": "go",
+  ".h": "c",
+  ".h++": "cpp",
+  ".hh": "cpp",
+  ".hpp": "cpp",
+  ".htm": "html",
+  ".html": "html",
+  ".hxx": "cpp",
   ".js": "javascript",
+  ".json": "json",
+  ".jsonc": "jsonc",
   ".jsx": "javascriptreact",
-  ".ts": "typescript",
-  ".tsx": "typescriptreact",
+  ".ksh": "shellscript",
+  ".less": "less",
+  ".lua": "lua",
+  ".markdown": "markdown",
+  ".md": "markdown",
+  ".mdx": "mdx",
   ".mjs": "javascript",
-  ".cjs": "javascript",
   ".mts": "typescript",
-  ".cts": "typescript",
+  ".php": "php",
+  ".prisma": "prisma",
+  ".py": "python",
+  ".pyi": "python",
+  ".rs": "rust",
+  ".sass": "sass",
+  ".scss": "scss",
+  ".sh": "shellscript",
+  ".svelte": "svelte",
+  ".tf": "terraform",
+  ".tfvars": "terraform-vars",
+  ".toml": "toml",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
   ".vue": "vue",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".zig": "zig",
+  ".zon": "zig",
+  ".zsh": "shellscript",
+};
+
+const FILENAME_LANGUAGE_IDS = {
+  containerfile: "dockerfile",
+  dockerfile: "dockerfile",
 };
 
+export function languageIdForPath(path) {
+  const name = basename(path).toLowerCase();
+  return FILENAME_LANGUAGE_IDS[name] ?? LANGUAGE_IDS[extname(path).toLowerCase()] ?? "plaintext";
+}
+
 export class LspClient {
   constructor({ serverId, command, args = [], cwd, initialization = {}, store }) {
     this.serverId = serverId;
@@ -94,7 +147,7 @@ export class LspClient {
     this.#notify("textDocument/didOpen", {
       textDocument: {
         uri,
-        languageId: LANGUAGE_IDS[extname(path).toLowerCase()] ?? "plaintext",
+        languageId: languageIdForPath(path),
         version: 0,
         text,
       },

package/src/lsp/managed-node-server.mjs

@@ -8,6 +8,11 @@ const DEFAULT_CACHE_ROOT = join(homedir(), ".march", "lsp", "node");
 const MANAGED_PACKAGES = {
   "typescript-language-server": ["typescript-language-server", "typescript"],
   "vue-language-server": ["@vue/language-server", "typescript"],
+  "pyright-langserver": ["pyright"],
+  "vscode-json-language-server": ["vscode-langservers-extracted"],
+  "vscode-html-language-server": ["vscode-langservers-extracted"],
+  "vscode-css-language-server": ["vscode-langservers-extracted"],
+  "docker-langserver": ["dockerfile-language-server-nodejs"],
 };
 
 const installs = new Map();

package/src/lsp/server-definitions.mjs

@@ -0,0 +1,188 @@
+const NODE_ROOT_MARKERS = ["package-lock.json", "bun.lockb", "bun.lock", "pnpm-lock.yaml", "yarn.lock", "package.json"];
+
+export function createLspServerDefinitions({ resolveTypeScriptProjectRoot, resolveTypeScriptSdk, resolveTypeScriptServer }) {
+  return [
+    {
+      id: "vue",
+      extensions: [".vue"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      command: ["vue-language-server"],
+      managedCommand: "vue-language-server",
+      args: ["--stdio"],
+      initialization: ({ root, workspaceRoot }) => {
+        const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+        return tsdk ? { typescript: { tsdk } } : null;
+      },
+      managedTypeScript: true,
+      missingInitialization: "missing project typescript SDK",
+    },
+    {
+      id: "typescript",
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      projectRoot: resolveTypeScriptProjectRoot,
+      command: ["typescript-language-server"],
+      managedCommand: "typescript-language-server",
+      args: ["--stdio"],
+      initialization: ({ root, workspaceRoot }) => {
+        const tsserver = resolveTypeScriptServer({ root, workspaceRoot });
+        return tsserver ? { tsserver: { path: tsserver } } : null;
+      },
+      managedTypeScript: true,
+      missingInitialization: "missing project typescript/tsserver.js",
+    },
+    {
+      id: "python",
+      extensions: [".py", ".pyi"],
+      rootMarkers: ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"],
+      command: ["pyright-langserver"],
+      managedCommand: "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 tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+        return tsdk ? { typescript: { tsdk } } : null;
+      },
+      missingInitialization: "missing project typescript SDK",
+    },
+    {
+      id: "json",
+      extensions: [".json", ".jsonc"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      command: ["vscode-json-language-server"],
+      managedCommand: "vscode-json-language-server",
+      args: ["--stdio"],
+    },
+    {
+      id: "html",
+      extensions: [".html", ".htm"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      command: ["vscode-html-language-server"],
+      managedCommand: "vscode-html-language-server",
+      args: ["--stdio"],
+    },
+    {
+      id: "css",
+      extensions: [".css", ".scss", ".sass", ".less"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      command: ["vscode-css-language-server"],
+      managedCommand: "vscode-css-language-server",
+      args: ["--stdio"],
+    },
+    {
+      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: "dockerfile",
+      extensions: [".dockerfile"],
+      filenames: ["dockerfile", "containerfile"],
+      rootMarkers: ["Dockerfile", "docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"],
+      command: ["docker-langserver"],
+      managedCommand: "docker-langserver",
+      args: ["--stdio"],
+    },
+    {
+      id: "markdown",
+      extensions: [".md", ".mdx", ".markdown"],
+      rootMarkers: NODE_ROOT_MARKERS,
+      command: ["marksman"],
+      args: ["server"],
+    },
+    {
+      id: "toml",
+      extensions: [".toml"],
+      rootMarkers: ["Cargo.toml", "pyproject.toml", "taplo.toml", ".taplo.toml"],
+      command: ["taplo"],
+      args: ["lsp", "stdio"],
+    },
+    {
+      id: "terraform",
+      extensions: [".tf", ".tfvars"],
+      rootMarkers: [".terraform", ".terraform.lock.hcl", "terraform.tfstate"],
+      command: ["terraform-ls"],
+      args: ["serve"],
+    },
+    {
+      id: "prisma",
+      extensions: [".prisma"],
+      rootMarkers: ["schema.prisma", "prisma/schema.prisma", "prisma"],
+      command: ["prisma"],
+      args: ["language-server"],
+    },
+  ];
+}

package/src/lsp/servers.mjs

@@ -1,140 +1,11 @@
 import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { createRequire } from "node:module";
 import { ensureManagedNodeCommand, ensureManagedTypeScript, findManagedTypeScriptSdk, findManagedTypeScriptServer } from "./managed-node-server.mjs";
+import { createLspServerDefinitions } from "./server-definitions.mjs";
 import { resolveTypeScriptProjectRoot } from "./typescript-project-resolver.mjs";
 
-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"],
-    managedCommand: "vue-language-server",
-    args: ["--stdio"],
-    initialization: ({ root, workspaceRoot }) => {
-      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
-      return tsdk ? { typescript: { tsdk } } : null;
-    },
-    managedTypeScript: true,
-    missingInitialization: "missing project typescript SDK",
-  },
-  {
-    id: "typescript",
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
-    rootMarkers: NODE_ROOT_MARKERS,
-    projectRoot: resolveTypeScriptProjectRoot,
-    command: ["typescript-language-server"],
-    managedCommand: "typescript-language-server",
-    args: ["--stdio"],
-    initialization: ({ root, workspaceRoot }) => {
-      const tsserver = resolveTypeScriptServer({ root, workspaceRoot });
-      return tsserver ? { tsserver: { path: tsserver } } : null;
-    },
-    managedTypeScript: true,
-    missingInitialization: "missing project typescript/tsserver.js",
-  },
-  {
-    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 tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
-      return tsdk ? { typescript: { tsdk } } : null;
-    },
-    missingInitialization: "missing project typescript SDK",
-  },
-  {
-    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"],
-  },
-];
+const LSP_SERVERS = createLspServerDefinitions({ resolveTypeScriptProjectRoot, resolveTypeScriptSdk, resolveTypeScriptServer });
 
 export async function resolveLspServer({ filePath, workspaceRoot, onEvent = null } = {}) {
   const result = await resolveLspServerStatus({ filePath, workspaceRoot, onEvent });
@@ -143,7 +14,7 @@ export async function resolveLspServer({ filePath, workspaceRoot, onEvent = null
 
 export async function resolveLspServerStatus({ filePath, workspaceRoot, onEvent = null } = {}) {
   const ext = extensionOf(filePath);
-  const def = LSP_SERVERS.find((server) => server.extensions.includes(ext));
+  const def = LSP_SERVERS.find((server) => matchesServer(server, filePath, ext));
   if (!def) return { status: "unsupported", extension: ext };
 
   const root = resolveServerRoot(def, { filePath, workspaceRoot });
@@ -165,7 +36,13 @@ export async function resolveLspServerStatus({ filePath, workspaceRoot, onEvent
 }
 
 export function listLspServerDefinitions() {
-  return LSP_SERVERS.map(({ id, extensions, rootMarkers, command, args }) => ({ id, extensions, rootMarkers, command, args }));
+  return LSP_SERVERS.map(({ id, extensions, filenames, rootMarkers, command, args }) => ({ id, extensions, filenames, rootMarkers, command, args }));
+}
+
+function matchesServer(server, filePath, ext) {
+  if (server.extensions.includes(ext)) return true;
+  const name = basename(filePath).toLowerCase();
+  return server.filenames?.includes(name) ?? false;
 }
 
 async function resolveCommand(def, { root, workspaceRoot, onEvent }) {