march-cli 0.1.8 → 0.1.9

package/package.json

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

package/src/agent/file-edit-tool.mjs

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 import { toolText } from "./tool-result.mjs";
 import { applyReplaceTextPatch, applyReplaceRangePatch } from "./editing/diff-apply.mjs";
 import { formatAppliedDiff, formatDiff } from "./editing/diff-format.mjs";
-import { buildDiagnosticsForPath } from "../context/diagnostics.mjs";
+import { formatLspDiagnosticsForPath } from "../lsp/diagnostics-format.mjs";
 
 export { formatDiff } from "./editing/diff-format.mjs";
 
@@ -117,7 +117,7 @@ async function waitForDiagnosticsForPath({ lspService, path, timeoutMs, interval
   if (!lspService?.snapshot || !path) return "";
   const deadline = Date.now() + timeoutMs;
   for (;;) {
-    const diagnostics = buildDiagnosticsForPath({ snapshot: lspService.snapshot(), path });
+    const diagnostics = formatLspDiagnosticsForPath({ snapshot: lspService.snapshot(), path });
     if (diagnostics) return diagnostics;
     const remaining = deadline - Date.now();
     if (remaining <= 0) return "";

package/src/agent/runner.mjs

@@ -8,6 +8,7 @@ import { ContextEngine } from "../context/engine.mjs";
 import { createMarchLifecycleAdapter } from "../extensions/lifecycle-adapter.mjs";
 import { syncPiSessionSidecar } from "../session/sidecar-sync.mjs";
 import { LspService } from "../lsp/service.mjs";
+import { formatLspServiceEvent } from "../lsp/status-message.mjs";
 import { formatRecallHints } from "../memory/markdown-store.mjs";
 import { appendProviderUserMessage, estimateProviderPayloadTokens, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
 import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
@@ -48,7 +49,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     compaction: { enabled: false },
     retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
   });
-  const lspService = new LspService({ cwd });
+  const lspService = new LspService({ cwd, onEvent: (event) => ui.status?.(formatLspServiceEvent(event)) });
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, centerMemoryPath, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
@@ -218,6 +219,7 @@ 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) {
       if (!runtimeHost) throw new Error("pi runtime host is not enabled");
       nextTurnContextMode = "rebuild";

package/src/cli/commands/status-command.mjs

@@ -31,6 +31,7 @@ export function statusBarLine({
   mode = MODES.DO,
   contextTokens = null,
   activity = null,
+  lspStatus = null,
 }) {
   return formatStatusBarLine({
     engine: runner.engine,
@@ -43,6 +44,7 @@ export function statusBarLine({
     mode,
     contextTokens,
     activity,
+    lspStatus,
   });
 }
 
@@ -80,6 +82,7 @@ export function formatStatusBarLine({
   mode = MODES.DO,
   contextTokens = null,
   activity = null,
+  lspStatus = null,
 }) {
   const model = engine.modelId || "model?";
   const thinking = engine.thinkingLevel || "thinking?";
@@ -91,6 +94,8 @@ export function formatStatusBarLine({
   const modeSegment = `${mode === MODES.DISCUSS ? WARN : OK}${formatModeLabel(mode)}`;
   const runtime = `${C.cyan}${model}${DIM}·${thinking}`;
   const segments = [modeSegment, runtime];
+  const lspText = formatLspSegment(lspStatus);
+  if (lspText) segments.push(`${C.fg250}${lspText}`);
   const activityText = formatActivitySegment(activity);
   if (activityText) segments.push(`${C.fg250}${activityText}`);
   const compactTokens = formatCompactTokenCount(contextTokens);
@@ -100,6 +105,42 @@ export function formatStatusBarLine({
   return `${inner}${R}`;
 }
 
+export function formatLspSegment(lspStatus) {
+  if (!lspStatus) return "";
+  const servers = lspStatus.servers ?? [];
+  const visible = servers.filter((server) => server.id);
+  if (visible.length === 0) return "lsp:off";
+  const parts = buildLspStatusParts(visible);
+  if (parts.length === 0) return "lsp:off";
+  return `lsp:${parts.join(",")}`;
+}
+
+function buildLspStatusParts(servers) {
+  const byId = new Map();
+  for (const server of servers) {
+    const id = shortLspId(server.id);
+    byId.set(id, mergeLspStatus(byId.get(id), server.status));
+  }
+  return [...byId.entries()]
+    .filter(([, status]) => status !== "unavailable")
+    .map(([id, status]) => `${id}${formatLspStatusMark(status)}`);
+}
+
+function mergeLspStatus(current, next) {
+  const rank = { failed: 4, starting: 3, busy: 2, ready: 1, idle: 1, unavailable: 0 };
+  if (!current) return next ?? "unavailable";
+  const currentRank = rank[current] ?? 0;
+  const nextRank = rank[next] ?? 0;
+  return nextRank > currentRank ? next : current;
+}
+
+function formatLspStatusMark(status) {
+  if (status === "failed") return "!";
+  if (status === "starting") return "…";
+  if (status === "unavailable") return "";
+  return "✓";
+}
+
 function formatActivitySegment(activity) {
   if (!activity) return "";
   const label = String(activity.label ?? "").trim();
@@ -107,6 +148,11 @@ function formatActivitySegment(activity) {
   return [frame, label].filter(Boolean).join(" ");
 }
 
+function shortLspId(id) {
+  if (id === "typescript") return "ts";
+  return String(id ?? "?");
+}
+
 export function formatCompactTokenCount(tokens) {
   const value = Number(tokens);
   if (!Number.isFinite(value) || value <= 0) return "";

package/src/cli/status-line-updater.mjs

@@ -27,6 +27,7 @@ export function createStatusLineUpdater({
       mode: getMode(),
       contextTokens,
       activity: formatActivity(activity, frameIndex),
+      lspStatus: runner.getLspStatus?.() ?? null,
     });
     ui.setStatusBar(line);
     return line;

package/src/{context/diagnostics.mjs → lsp/diagnostics-format.mjs}

@@ -1,6 +1,6 @@
 const MAX_DIAGNOSTICS = 20;
 
-export function buildDiagnosticsLayer({ snapshot } = {}) {
+export function formatLspDiagnostics({ snapshot } = {}) {
   const diagnostics = snapshot?.diagnostics ?? [];
   if (diagnostics.length === 0) return "[diagnostics]";
 
@@ -17,12 +17,12 @@ export function buildDiagnosticsLayer({ snapshot } = {}) {
   return lines.join("\n");
 }
 
-export function buildDiagnosticsForPath({ snapshot, path } = {}) {
+export function formatLspDiagnosticsForPath({ snapshot, path } = {}) {
   const targetPath = String(path ?? "");
   if (!targetPath) return "";
   const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => diagnostic.path === targetPath);
   if (diagnostics.length === 0) return "";
-  return buildDiagnosticsLayer({
+  return formatLspDiagnostics({
     snapshot: {
       ...snapshot,
       diagnostics,

package/src/lsp/servers.mjs

@@ -11,7 +11,11 @@ const LSP_SERVERS = [
     rootMarkers: NODE_ROOT_MARKERS,
     command: ["vue-language-server"],
     args: ["--stdio"],
-    initialization: () => ({}),
+    initialization: ({ root, workspaceRoot }) => {
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
+    },
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "typescript",
@@ -20,10 +24,10 @@ const LSP_SERVERS = [
     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 } };
+      const tsserver = resolveTypeScriptServer({ root, workspaceRoot });
+      return tsserver ? { tsserver: { path: tsserver } } : null;
     },
+    missingInitialization: "missing project typescript/tsserver.js",
   },
   {
     id: "python",
@@ -68,10 +72,10 @@ const LSP_SERVERS = [
     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) } };
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
     },
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "yaml",
@@ -126,23 +130,30 @@ const LSP_SERVERS = [
 ];
 
 export function resolveLspServer({ filePath, workspaceRoot }) {
+  const result = resolveLspServerStatus({ filePath, workspaceRoot });
+  return result.status === "available" ? result.server : null;
+}
+
+export function resolveLspServerStatus({ filePath, workspaceRoot }) {
   const ext = extensionOf(filePath);
   const def = LSP_SERVERS.find((server) => server.extensions.includes(ext));
-  if (!def) return null;
+  if (!def) return { status: "unsupported", extension: ext };
 
   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;
+  if (!command) {
+    return { status: "unavailable", id: def.id, root, reason: `missing ${def.command[0]}` };
+  }
+
   const initialization = def.initialization?.({ root, workspaceRoot }) ?? {};
-  if (initialization === null) return null;
+  if (initialization === null) {
+    return { status: "unavailable", id: def.id, root, reason: def.missingInitialization ?? "missing SDK" };
+  }
   return {
-    id: def.id,
-    command,
-    args: def.args,
-    root,
-    initialization,
+    status: "available",
+    server: { id: def.id, command, args: def.args, root, initialization },
   };
 }
 
@@ -160,7 +171,7 @@ function findCommand(names, { root, workspaceRoot }) {
 
 function findBin(name, { root, workspaceRoot }) {
   const names = platformCommandNames(name);
-  for (const base of [root, workspaceRoot]) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
     for (const bin of names) {
       const candidate = join(base, "node_modules", ".bin", bin);
       if (existsSync(candidate)) return candidate;
@@ -185,6 +196,24 @@ function findOnPath(names) {
   return null;
 }
 
+function resolveTypeScriptServer({ root, workspaceRoot }) {
+  return resolveModuleFromRoots("typescript/lib/tsserver.js", { root, workspaceRoot });
+}
+
+function resolveTypeScriptSdk({ root, workspaceRoot }) {
+  const serverLibrary = resolveModuleFromRoots("typescript/lib/tsserverlibrary.js", { root, workspaceRoot });
+  const tsserver = serverLibrary ?? resolveTypeScriptServer({ root, workspaceRoot });
+  return tsserver ? dirname(tsserver) : null;
+}
+
+function resolveModuleFromRoots(id, { root, workspaceRoot }) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
+    const hit = resolveModule(id, base);
+    if (hit) return hit;
+  }
+  return null;
+}
+
 function resolveModule(id, base) {
   try {
     return createRequire(join(base, "package.json")).resolve(id);
@@ -193,6 +222,10 @@ function resolveModule(id, base) {
   }
 }
 
+function uniquePaths(paths) {
+  return [...new Set(paths.map((path) => resolve(path)))];
+}
+
 function findNearestRoot(start, stop, markers) {
   let dir = resolve(start);
   const boundary = resolve(stop);

package/src/lsp/service.mjs

@@ -1,28 +1,40 @@
 import { LspClient } from "./client.mjs";
 import { LspDiagnosticStore } from "./diagnostic-store.mjs";
-import { resolveLspServer } from "./servers.mjs";
+import { resolveLspServerStatus } from "./servers.mjs";
 
 export class LspService {
-  constructor({ cwd }) {
+  constructor({ cwd, onEvent = null }) {
     this.cwd = cwd;
+    this.onEvent = onEvent;
     this.store = new LspDiagnosticStore();
     this.clients = new Map();
     this.spawning = new Map();
+    this.unavailable = new Map();
+    this.announced = new Set();
   }
 
   touchFile(path) {
-    const server = resolveLspServer({ filePath: path, workspaceRoot: this.cwd });
-    if (!server) return;
+    const result = resolveLspServerStatus({ filePath: path, workspaceRoot: this.cwd });
+    if (result.status === "unsupported") return result;
+    if (result.status === "unavailable") {
+      this.unavailable.set(result.id, result);
+      this.#emitOnce(`unavailable:${result.id}:${result.reason}`, result);
+      return result;
+    }
+
+    const server = result.server;
     const key = `${server.id}:${server.root}`;
     const existing = this.clients.get(key);
     if (existing) {
       existing.touchFile(path);
-      return;
+      return { status: "already_attached", id: server.id, root: server.root };
     }
     if (this.spawning.has(key)) {
       this.spawning.get(key).then((client) => client?.touchFile(path)).catch(() => {});
-      return;
+      return { status: "starting", id: server.id, root: server.root };
     }
+
+    this.#emitOnce(`starting:${key}`, { status: "starting", id: server.id, root: server.root });
     const task = this.#startClient(server, key).then((client) => {
       client?.touchFile(path);
       return client;
@@ -31,13 +43,25 @@ export class LspService {
     task.finally(() => {
       if (this.spawning.get(key) === task) this.spawning.delete(key);
     }).catch(() => {});
+    return { status: "starting", id: server.id, root: server.root };
   }
 
   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 };
+    const servers = [
+      ...[...this.clients.values()].map((client) => ({
+        id: client.serverId,
+        root: client.cwd,
+        status: client.status,
+      })),
+      ...[...this.spawning.keys()].map((key) => ({
+        id: key.slice(0, key.indexOf(":")),
+        root: key.slice(key.indexOf(":") + 1),
+        status: "starting",
+      })),
+      ...this.unavailable.values(),
+    ];
+    return { status: summarizeStatus(servers), diagnostics, servers };
   }
 
   async dispose() {
@@ -56,10 +80,31 @@ export class LspService {
     try {
       await client.start();
       this.clients.set(key, client);
+      this.unavailable.delete(server.id);
+      this.#emitOnce(`attached:${key}`, { status: "attached", id: server.id, root: server.root });
       return client;
-    } catch {
+    } catch (err) {
       client.status = "failed";
+      const event = { status: "failed", id: server.id, root: server.root, reason: err.message };
+      this.unavailable.set(server.id, event);
+      this.#emitOnce(`failed:${key}:${err.message}`, event);
       return null;
     }
   }
+
+  #emitOnce(key, event) {
+    if (this.announced.has(key)) return;
+    this.announced.add(key);
+    this.onEvent?.(event);
+  }
+}
+
+function summarizeStatus(servers) {
+  const statuses = servers.map((server) => server.status);
+  if (statuses.includes("busy")) return "busy";
+  if (statuses.includes("starting")) return "starting";
+  if (statuses.includes("failed")) return "failed";
+  if (statuses.includes("ready") || statuses.includes("idle")) return "idle";
+  if (statuses.includes("unavailable")) return "unavailable";
+  return "";
 }

package/src/lsp/status-message.mjs

@@ -0,0 +1,8 @@
+export function formatLspServiceEvent(event) {
+  const id = event?.id ? String(event.id) : "server";
+  if (event?.status === "attached") return `LSP attached: ${id}`;
+  if (event?.status === "starting") return `LSP starting: ${id}`;
+  if (event?.status === "failed") return `LSP failed: ${id} - ${event.reason}`;
+  if (event?.status === "unavailable") return `LSP unavailable: ${id} - ${event.reason}`;
+  return `LSP ${event?.status ?? "status"}: ${id}`;
+}