decorated-pi 0.3.0 → 0.4.0

package/extensions/lsp/manager.ts

@@ -0,0 +1,249 @@
+/**
+ * LSP Server Manager — lifecycle, per-language instances, project-local binaries.
+ */
+import { readFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
+import { LspClient, LspClientStartError, filePathToUri } from "./client.js";
+import { createChildProcessEnv } from "./env.js";
+import {
+  detectLanguage,
+  findWorkspaceRoot,
+  getServerConfig,
+  languageIdForFile,
+} from "./servers.js";
+
+interface FileState {
+  client: LspClient;
+  language: string;
+  workspaceRoot: string;
+  rootUri: string;
+  command: string;
+  installHint: string;
+}
+
+interface ResolvedState {
+  abs: string;
+  uri: string;
+  state: FileState;
+}
+
+interface Startup {
+  cancelled: boolean;
+  promise: Promise<FileState | undefined>;
+}
+
+async function raceWithTimeout<T>(promise: Promise<T>, timeoutMs: number, file: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => setTimeout(() => reject(new LspToolError({ kind: "tool_timeout", file, message: `LSP request timed out after ${timeoutMs}ms` })), timeoutMs)),
+  ]);
+}
+
+export interface LspManagerOptions {
+  cwd?: () => string;
+}
+
+export interface ResolveFileStateOptions {
+  timeoutMs?: number;
+}
+
+/**
+ * Manages LSP server instances per (language, workspace_root).
+ *
+ * - Deduplicates: one client per language+workspace
+ * - Deduplicates startup: concurrent requests share the same startup promise
+ * - Caches failures to avoid repeated start attempts
+ */
+export class LspServerManager {
+  cwd: string;
+  #clients = new Map<string, FileState>();
+  #failures = new Map<string, any>();
+  #starting = new Map<string, Startup>();
+
+  constructor(options: LspManagerOptions = {}) {
+    this.cwd = options.cwd?.() ?? process.cwd();
+  }
+
+  resolveAbs(file: string): string {
+    return file.startsWith("/") ? file : resolvePath(this.cwd, file);
+  }
+
+  async clearLanguageState(language?: string): Promise<void> {
+    const toStop = language
+      ? [...this.#clients.values()].filter((s) => s.language === language)
+      : [...this.#clients.values()];
+
+    for (const [, startup] of this.#starting) {
+      startup.cancelled = true;
+    }
+    this.#starting.clear();
+
+    await Promise.allSettled(toStop.map((s) => s.client.stop()));
+    for (const [key, state] of this.#clients) {
+      if (!language || state.language === language) this.#clients.delete(key);
+    }
+    if (!language) {
+      this.#failures.clear();
+    } else {
+      for (const [key, f] of this.#failures) {
+        if (f.language === language) this.#failures.delete(key);
+      }
+    }
+  }
+
+  async resolveFileState(
+    file: string,
+    options: ResolveFileStateOptions = {},
+  ): Promise<{ ok: true; result: ResolvedState } | { ok: false; error: any }> {
+    const abs = this.resolveAbs(file);
+    try {
+      const work = async () => {
+        const state = await this.#getFileState(abs, options);
+        if (!state) {
+          return { ok: false, error: { kind: "unsupported_language", file: abs, message: `No language server configured for ${abs}` } } as const;
+        }
+        const uri = await this.#openFile(state, abs);
+        return { ok: true, result: { abs, uri, state } } as const;
+      };
+      return options.timeoutMs != null
+        ? await raceWithTimeout(work(), options.timeoutMs, abs)
+        : await work();
+    } catch (error) {
+      if (error instanceof LspToolError) return { ok: false, error: error.details };
+      return {
+        ok: false,
+        error: { kind: "tool_execution_failed", file: abs, message: error instanceof Error ? error.message : String(error) },
+      };
+    }
+  }
+
+  async #getFileState(file: string, options: ResolveFileStateOptions = {}): Promise<FileState | undefined> {
+    const language = detectLanguage(file);
+    if (!language) return undefined;
+
+    const workspaceRoot = findWorkspaceRoot(file, this.cwd);
+    const key = `${language}\0${workspaceRoot}`;
+
+    const existing = this.#clients.get(key);
+    if (existing) return existing;
+
+    if (this.#failures.has(key)) throw new LspToolError(this.#failures.get(key));
+
+    const inFlight = this.#starting.get(key);
+    if (inFlight) return inFlight.promise;
+
+    const config = getServerConfig(language, workspaceRoot);
+    if (!config) return undefined;
+
+    const rootUri = filePathToUri(workspaceRoot);
+    const startup: Startup = { cancelled: false, promise: Promise.resolve(undefined) };
+
+    const startPromise = (async (): Promise<FileState | undefined> => {
+      const client = new LspClient({
+        command: config.command,
+        args: config.args,
+        root_uri: rootUri,
+        language_id_for_uri: languageIdForFile,
+        env: createChildProcessEnv(),
+      });
+
+      try {
+        await client.start(options.timeoutMs);
+      } catch (error) {
+        if (startup.cancelled) throw new LspStartupCancelledError(language, workspaceRoot);
+        const failure = toLspToolError(file, language, workspaceRoot, config.command, config.install_hint, error);
+        this.#failures.set(key, failure);
+        throw new LspToolError(failure);
+      }
+
+      if (startup.cancelled) {
+        await client.stop();
+        throw new LspStartupCancelledError(language, workspaceRoot);
+      }
+
+      const state: FileState = {
+        client, language, workspaceRoot, rootUri,
+        command: config.command, installHint: config.install_hint,
+      };
+      this.#clients.set(key, state);
+      this.#failures.delete(key);
+      return state;
+    })();
+
+    startup.promise = startPromise;
+    this.#starting.set(key, startup);
+
+    try {
+      return await startPromise;
+    } finally {
+      if (this.#starting.get(key) === startup) this.#starting.delete(key);
+    }
+  }
+
+  async #openFile(state: FileState, absPath: string): Promise<string> {
+    const text = await readFile(absPath, "utf-8");
+    const uri = filePathToUri(absPath);
+    await state.client.ensureDocumentOpen(uri, text);
+    return uri;
+  }
+}
+
+// ─── Error types ──────────────────────────────────────────────────────────
+
+class LspStartupCancelledError extends Error {
+  constructor(language: string, workspaceRoot: string) {
+    super(`Startup cancelled for ${language} LSP in ${workspaceRoot}`);
+    this.name = "LspStartupCancelledError";
+  }
+}
+
+export class LspToolError extends Error {
+  constructor(public readonly details: LspToolErrorDetail) {
+    super(details.message);
+    this.name = "LspToolError";
+  }
+}
+
+export interface LspToolErrorDetail {
+  kind: string;
+  file?: string;
+  language?: string;
+  workspace_root?: string;
+  command?: string;
+  install_hint?: string;
+  message: string;
+  code?: string;
+}
+
+export function toLspToolError(
+  file: string, language: string, workspaceRoot: string | undefined,
+  command: string, installHint: string | undefined, error: unknown,
+): LspToolErrorDetail {
+  if (error instanceof LspToolError) return error.details;
+  if (error instanceof LspClientStartError) {
+    return {
+      kind: "server_start_failed", file, language, workspace_root: workspaceRoot,
+      command, install_hint: installHint, code: error.code,
+      message: error.code === "ENOENT" ? `command "${command}" not found` : error.message,
+    };
+  }
+  const err = error as Record<string, unknown> | undefined;
+  return {
+    kind: "tool_execution_failed", file, language, workspace_root: workspaceRoot,
+    command, install_hint: installHint,
+    message: error instanceof Error ? error.message : String(error),
+    code: err?.code as string | undefined,
+  };
+}
+
+export function formatToolError(details: LspToolErrorDetail): string {
+  if (details.kind === "unsupported_language" || details.kind === "tool_timeout") return details.message;
+  const lines = [
+    details.language ? `${details.language} LSP unavailable for ${details.file}` : `LSP request failed for ${details.file}`,
+    `Reason: ${details.message}`,
+  ];
+  if (details.command) lines.push(`Command: ${details.command}`);
+  if (details.workspace_root) lines.push(`Workspace: ${details.workspace_root}`);
+  if (details.install_hint) lines.push(`Hint: ${details.install_hint}`);
+  return lines.join("\n");
+}

package/extensions/lsp/prompt.ts

@@ -1,45 +1,6 @@
 /**
- * LSP System Prompt — injects LSP guidance into agent system prompt
+ * LSP System Prompt — LSP guidance via promptGuidelines (no injection).
  *
- * Based on @spences10/pi-lsp by Scott Spence
- * https://github.com/spences10/my-pi/tree/main/packages/pi-lsp (MIT License)
+ * System-level guidance is unnecessary; promptSnippet + promptGuidelines
+ * on each tool are sufficient for model tool selection and usage.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { list_supported_languages } from "./servers.js";
-
-export const LSP_TOOL_NAMES = new Set([
-  "lsp_diagnostics",
-  "lsp_find_symbol",
-  "lsp_hover",
-  "lsp_definition",
-  "lsp_references",
-  "lsp_document_symbols",
-  "lsp_rename",
-]);
-
-const LSP_GUIDANCE_MARKER = "### LSP Guidance";
-
-export function setup_lsp_prompt(pi: ExtensionAPI) {
-  pi.on("before_agent_start", async (event) => {
-    if (!should_inject_lsp_prompt(event.systemPromptOptions)) return;
-    if (event.systemPrompt.includes(LSP_GUIDANCE_MARKER)) return;
-
-    const languages = list_supported_languages().join(", ");
-    const guidance = [
-      LSP_GUIDANCE_MARKER,
-      "",
-      `Consider using LSP tools when reading or editing source files. Supported languages: ${languages}. Use them when debugging language-server-supported errors, checking types, symbol definitions or API documentation from code, finding references more precisely than text search, and renaming symbols across a project.`,
-    ].join("\n");
-
-    return {
-      systemPrompt: `${event.systemPrompt}\n\n${guidance}`,
-    };
-  });
-}
-
-export function should_inject_lsp_prompt(options?: {
-  selectedTools?: string[];
-}): boolean {
-  const tools = options?.selectedTools;
-  return !tools || tools.some((tool) => LSP_TOOL_NAMES.has(tool));
-}

package/extensions/lsp/protocol.ts

@@ -0,0 +1,219 @@
+/**
+ * JSON-RPC over stdio — minimal LSP transport layer.
+ *
+ * Handles message framing (Content-Length headers), request/response
+ * correlation with timeouts, and server-to-client notifications.
+ */
+import { spawn, ChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+export interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number | string;
+  method: string;
+  params?: unknown;
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number | string;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+export interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: unknown;
+}
+
+export class LspProtocolError extends Error {
+  constructor(public readonly code: number, message: string) {
+    super(`LSP error ${code}: ${message}`);
+    this.name = "LspProtocolError";
+  }
+}
+
+interface PendingRequest {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timer: NodeJS.Timeout;
+}
+
+export class LspProtocol extends EventEmitter {
+  #proc: ChildProcess | null = null;
+  #buffer = Buffer.alloc(0);
+  #nextId = 1;
+  #pending = new Map<number, PendingRequest>();
+  #stopped = false;
+
+  get process(): ChildProcess | null {
+    return this.#proc;
+  }
+
+  /** Spawn the LSP server process. */
+  spawn(command: string, args: string[], env: NodeJS.ProcessEnv): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.#stopped = false;
+      this.#proc = spawn(command, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env,
+      });
+      const proc = this.#proc;
+      let settled = false;
+
+      proc.once("spawn", () => {
+        if (settled) return;
+        settled = true;
+        resolve();
+      });
+
+      proc.once("error", (err) => {
+        if (!settled) {
+          settled = true;
+          reject(Object.assign(new Error(`Failed to spawn ${command}: ${err.message}`), { code: (err as NodeJS.ErrnoException).code }));
+        }
+      });
+
+      proc.on("close", (code) => {
+        if (!this.#stopped) {
+          for (const p of this.#pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(new Error(`LSP server exited (code ${code})`));
+          }
+          this.#pending.clear();
+        }
+      });
+
+      proc.stderr?.on("data", () => {}); // discard
+
+      proc.stdout?.on("data", (chunk: Buffer) => {
+        this.#buffer = Buffer.concat([this.#buffer, chunk]);
+        this.#drain();
+      });
+    });
+  }
+
+  /** Send a request and wait for response. */
+  request(method: string, params: unknown, timeoutMs = 30_000): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const id = this.#nextId++;
+      const timer = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`LSP request "${method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.#pending.set(id, { resolve, reject, timer });
+      try {
+        this.#send({ jsonrpc: "2.0", id, method, params });
+      } catch (err) {
+        clearTimeout(timer);
+        this.#pending.delete(id);
+        reject(err);
+      }
+    });
+  }
+
+  /** Send a fire-and-forget notification. */
+  notify(method: string, params: unknown): void {
+    this.#send({ jsonrpc: "2.0", method, params });
+  }
+
+  /** Gracefully shut down the server. */
+  async shutdown(timeoutMs = 1000): Promise<void> {
+    this.#stopped = true;
+    try {
+      await this.request("shutdown", null, timeoutMs);
+    } catch {
+      // server already dead
+    }
+    this.notify("exit", null);
+    this.#proc?.kill();
+    this.#proc = null;
+  }
+
+  /** Force kill. */
+  kill(): void {
+    this.#stopped = true;
+    this.#proc?.kill();
+    this.#proc = null;
+    for (const p of this.#pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(new Error("LSP protocol stopped"));
+    }
+    this.#pending.clear();
+  }
+
+  #send(message: JsonRpcRequest | JsonRpcNotification | JsonRpcResponse): void {
+    if (!this.#proc?.stdin?.writable) {
+      throw new Error("LSP server not connected");
+    }
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii");
+    this.#proc.stdin.write(Buffer.concat([header, body]));
+  }
+
+  #drain(): void {
+    while (true) {
+      const headerEnd = this.#buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+
+      const header = this.#buffer.subarray(0, headerEnd).toString("ascii");
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.#buffer = this.#buffer.subarray(headerEnd + 4);
+        continue;
+      }
+
+      const length = Number(match[1]);
+      const bodyStart = headerEnd + 4;
+      if (this.#buffer.length < bodyStart + length) return;
+
+      const body = this.#buffer.subarray(bodyStart, bodyStart + length);
+      this.#buffer = this.#buffer.subarray(bodyStart + length);
+
+      try {
+        this.#handle(JSON.parse(body.toString("utf8")));
+      } catch (err) {
+        // ignore malformed messages
+      }
+    }
+  }
+
+  #handle(msg: Record<string, unknown>): void {
+    // Response to our request
+    if (msg.id != null) {
+      const numId = typeof msg.id === "number"
+        ? msg.id
+        : typeof msg.id === "string" && /^-?\d+$/.test(msg.id)
+          ? Number(msg.id)
+          : null;
+
+      if (numId != null && this.#pending.has(numId)) {
+        const p = this.#pending.get(numId)!;
+        this.#pending.delete(numId);
+        clearTimeout(p.timer);
+
+        if (msg.error) {
+          const e = msg.error as { code: number; message: string };
+          p.reject(new LspProtocolError(e.code, e.message));
+        } else {
+          p.resolve(msg.result);
+        }
+        return;
+      }
+
+      // Server-to-client request — respond with null
+      if (msg.method != null && msg.id != null) {
+        const resp: JsonRpcResponse = { jsonrpc: "2.0", id: msg.id as number | string, result: null };
+        this.#send(resp);
+      }
+      return;
+    }
+
+    // Notification from server
+    if (msg.method === "textDocument/publishDiagnostics" && msg.params) {
+      this.emit("diagnostics", msg.params);
+    }
+  }
+}