decorated-pi 0.1.0

package/extensions/lsp/format.ts

@@ -0,0 +1,349 @@
+import { fileURLToPath } from "node:url";
+import type { LspDiagnostic, LspHover, LspLocation, LspDocumentSymbol } from "./client.js";
+import { LspClientStartError } from "./client.js";
+import { get_server_config, list_supported_languages } from "./servers.js";
+
+export interface LspToolErrorDetail {
+  kind: string;
+  file?: string;
+  language?: string;
+  workspace_root?: string;
+  command?: string;
+  install_hint?: string;
+  message: string;
+  code?: string;
+}
+
+export class LspToolError extends Error {
+  details: LspToolErrorDetail;
+  constructor(details: LspToolErrorDetail) {
+    super(details.message);
+    this.name = "LspToolError";
+    this.details = details;
+  }
+}
+
+const SYMBOL_KIND_LABELS: Record<number, string> = {
+  2: "module",
+  3: "namespace",
+  5: "class",
+  6: "method",
+  7: "property",
+  8: "field",
+  9: "constructor",
+  11: "interface",
+  12: "function",
+  13: "variable",
+  14: "constant",
+  23: "struct",
+  24: "event",
+};
+
+export const SYMBOL_KIND_NAMES = Object.values(SYMBOL_KIND_LABELS);
+
+export function format_status_lines(
+  cwd: string,
+  clients_by_server: Map<string, any>,
+  failed_servers: Map<string, any>
+): string[] {
+  const lines: string[] = [];
+  const active_languages = new Set<string>();
+
+  const running_states = Array.from(clients_by_server.values()).sort(
+    (a: any, b: any) =>
+      a.language.localeCompare(b.language) ||
+      a.workspace_root.localeCompare(b.workspace_root)
+  );
+  for (const running of running_states) {
+    active_languages.add(running.language);
+    lines.push(
+      `${running.language}: running (ready=${running.client.is_ready()}) — ${running.command} [workspace ${running.workspace_root}]`
+    );
+  }
+
+  const failures = Array.from(failed_servers.values()).sort(
+    (a: any, b: any) =>
+      (a.language ?? "").localeCompare(b.language ?? "") ||
+      (a.workspace_root ?? "").localeCompare(b.workspace_root ?? "")
+  );
+  for (const failure of failures) {
+    if (failure.language) active_languages.add(failure.language);
+    const workspace = failure.workspace_root
+      ? ` [workspace ${failure.workspace_root}]`
+      : "";
+    const language = failure.language ?? "unknown";
+    lines.push(`${language}: failed — ${failure.message}${workspace}`);
+  }
+
+  for (const language of list_supported_languages()) {
+    if (active_languages.has(language)) continue;
+    const config = get_server_config(language, cwd);
+    if (config) {
+      lines.push(`${language}: idle — ${config.command}`);
+    }
+  }
+
+  return lines.length > 0 ? lines : ["No language servers configured for this project."];
+}
+
+export function to_lsp_tool_error(
+  file: string,
+  language: string,
+  workspace_root: string | undefined,
+  command: string,
+  install_hint: string | undefined,
+  error: unknown
+): LspToolErrorDetail {
+  if (error instanceof LspToolError) {
+    return error.details;
+  }
+  if (error instanceof LspClientStartError) {
+    const missing_binary = error.code === "ENOENT";
+    return {
+      kind: "server_start_failed",
+      file,
+      language,
+      workspace_root,
+      command,
+      install_hint,
+      code: error.code,
+      message: missing_binary
+        ? `command "${command}" not found`
+        : error.message,
+    };
+  }
+  const err = error as Record<string, unknown> | undefined;
+  return {
+    kind: "tool_execution_failed",
+    file,
+    language,
+    workspace_root,
+    command,
+    install_hint,
+    message: error instanceof Error ? error.message : String(error),
+    code:
+      err && typeof err.code === "string" ? err.code : undefined,
+  };
+}
+
+export function format_tool_error(details: LspToolErrorDetail): string {
+  if (details.kind === "unsupported_language") {
+    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");
+}
+
+function severity_label(severity: number): string {
+  switch (severity) {
+    case 1: return "error";
+    case 2: return "warning";
+    case 3: return "info";
+    case 4: return "hint";
+    default: return "info";
+  }
+}
+
+export type SeverityFilter = "error" | "warning" | "info" | "hint";
+
+const SEVERITY_MAP: Record<SeverityFilter, number> = {
+  error: 1,
+  warning: 2,
+  info: 3,
+  hint: 4,
+};
+
+export function filter_diagnostics(
+  diagnostics: LspDiagnostic[],
+  severities?: SeverityFilter[]
+): LspDiagnostic[] {
+  if (!severities || severities.length === 0) return diagnostics;
+  // 取最小的 severity 值（error=1 < warning=2 < info=3 < hint=4）
+  const minSeverity = Math.min(...severities.map((s) => SEVERITY_MAP[s]));
+  // 显示 severity <= minSeverity（更严重 + 自身）
+  return diagnostics.filter((d) => (d.severity ?? 1) <= minSeverity);
+}
+
+export function format_diagnostics(
+  file: string,
+  diagnostics: LspDiagnostic[],
+  severities?: SeverityFilter[]
+): string {
+  const filtered = filter_diagnostics(diagnostics, severities);
+  if (filtered.length === 0) return `${file}: no diagnostics`;
+  const lines = [`${file}: ${filtered.length} diagnostic(s)`];
+  for (const d of filtered) {
+    const position = `${d.range.start.line + 1}:${d.range.start.character + 1}`;
+    const source = d.source ? ` [${d.source}]` : "";
+    const code = d.code != null ? ` (${d.code})` : "";
+    lines.push(
+      `  ${position} ${severity_label(d.severity ?? 1)}${source}${code}: ${d.message}`
+    );
+  }
+  return lines.join("\n");
+}
+
+export function format_hover(hover: LspHover | null): string {
+  if (!hover) return "No hover info.";
+  const contents = hover.contents;
+  const extract = (item: unknown): string =>
+    typeof item === "string" ? item : ((item as { value?: string })?.value ?? "");
+  if (Array.isArray(contents)) {
+    return contents.map(extract).join("\n\n").trim() || "No hover info.";
+  }
+  return extract(contents).trim() || "No hover info.";
+}
+
+export function format_locations(
+  locations: LspLocation[],
+  empty_message: string
+): string {
+  if (locations.length === 0) return empty_message;
+  return locations
+    .map((loc) => {
+      const path = file_url_to_path_or_value(loc.uri);
+      return `${path}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+    })
+    .join("\n");
+}
+
+export function format_document_symbols(
+  file: string,
+  symbols: LspDocumentSymbol[]
+): string {
+  if (symbols.length === 0) return `${file}: no symbols`;
+  const lines = [`${file}: ${symbols.length} top-level symbol(s)`];
+  append_symbol_lines(lines, symbols, 1);
+  return lines.join("\n");
+}
+
+export interface SymbolMatchOptions {
+  max_results: number;
+  top_level_only: boolean;
+  exact_match: boolean;
+  kinds: Set<string>;
+  language: string;
+}
+
+export interface SymbolMatch {
+  symbol: LspDocumentSymbol;
+  depth: number;
+}
+
+export function find_symbol_matches(
+  symbols: LspDocumentSymbol[],
+  query: string,
+  options: SymbolMatchOptions
+): SymbolMatch[] {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) return [];
+
+  const matches: SymbolMatch[] = [];
+
+  const expand_exact_name_values = (name: string): string[] => {
+    const trimmed = name.trim().toLowerCase();
+    if (!trimmed) return [];
+    const expanded = new Set([trimmed]);
+    if (options.language === "cpp" && trimmed.includes("::")) {
+      const parts = trimmed
+        .split("::")
+        .map((part) => part.trim())
+        .filter(Boolean);
+      if (parts.length > 0) expanded.add(parts[parts.length - 1]!);
+    }
+    return Array.from(expanded);
+  };
+
+  const matches_query = (symbol: LspDocumentSymbol): boolean => {
+    const raw_name = symbol.name.trim().toLowerCase();
+    const raw_detail = (symbol.detail ?? "").trim().toLowerCase();
+    if (options.exact_match) {
+      const exact_values = [
+        ...expand_exact_name_values(symbol.name),
+        ...(raw_detail ? [raw_detail] : []),
+      ];
+      return exact_values.some((value) => value === normalized);
+    }
+    const fuzzy_values = [raw_name, raw_detail].filter(Boolean);
+    return fuzzy_values.some((value) => value.includes(normalized));
+  };
+
+  const matches_kind = (symbol: LspDocumentSymbol): boolean => {
+    if (options.kinds.size === 0) return true;
+    return options.kinds.has(symbol_kind_label(symbol.kind));
+  };
+
+  const visit = (entries: LspDocumentSymbol[], depth: number): void => {
+    for (const symbol of entries) {
+      if (matches_kind(symbol) && matches_query(symbol)) {
+        matches.push({ symbol, depth });
+        if (matches.length >= options.max_results) return;
+      }
+      if (!options.top_level_only && symbol.children?.length) {
+        visit(symbol.children, depth + 1);
+        if (matches.length >= options.max_results) return;
+      }
+    }
+  };
+
+  visit(symbols, 1);
+  return matches;
+}
+
+export function format_symbol_matches(
+  file: string,
+  query: string,
+  matches: SymbolMatch[]
+): string {
+  if (matches.length === 0) {
+    return `${file}: no symbols matching "${query}"`;
+  }
+  const lines = [`${file}: ${matches.length} symbol match(es) for "${query}"`];
+  for (const { symbol, depth } of matches) {
+    const indent = "  ".repeat(depth);
+    const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+    const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+    lines.push(
+      `${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`
+    );
+  }
+  return lines.join("\n");
+}
+
+function append_symbol_lines(
+  lines: string[],
+  symbols: LspDocumentSymbol[],
+  depth: number
+): void {
+  for (const symbol of symbols) {
+    const indent = "  ".repeat(depth);
+    const detail = symbol.detail ? ` — ${symbol.detail}` : "";
+    const range = `${symbol.range.start.line + 1}:${symbol.range.start.character + 1}`;
+    lines.push(
+      `${indent}${symbol_kind_label(symbol.kind)} ${symbol.name}${detail} @ ${range}`
+    );
+    if (symbol.children?.length) {
+      append_symbol_lines(lines, symbol.children, depth + 1);
+    }
+  }
+}
+
+export function symbol_kind_label(kind: number): string {
+  return SYMBOL_KIND_LABELS[kind] ?? "symbol";
+}
+
+function file_url_to_path_or_value(uri: string): string {
+  try {
+    return uri.startsWith("file:") ? fileURLToPath(uri) : uri;
+  } catch {
+    return uri;
+  }
+}

package/extensions/lsp/index.ts

@@ -0,0 +1,14 @@
+import { LspServerManager } from "./server-manager.js";
+import { register_lsp_tools } from "./tools.js";
+import { setup_lsp_prompt } from "./prompt.js";
+
+export function setupLsp(pi: any) {
+  const manager = new LspServerManager();
+
+  setup_lsp_prompt(pi);
+  register_lsp_tools(pi, manager);
+
+  pi.on("session_shutdown", async () => {
+    await manager.clear_language_state();
+  });
+}

package/extensions/lsp/prompt.ts

@@ -0,0 +1,39 @@
+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/server-manager.ts

@@ -0,0 +1,303 @@
+import { resolve_project_trust } from "@spences10/pi-project-trust";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import {
+  file_path_to_uri,
+  LspClient,
+  type LspClientOptions,
+} from "./client.js";
+import {
+  LspToolError,
+  to_lsp_tool_error,
+} from "./format.js";
+import {
+  detect_language,
+  find_workspace_root,
+  get_server_config,
+  language_id_for_file,
+  type LanguageConfig,
+} from "./servers.js";
+import {
+  create_lsp_binary_trust_subject,
+  default_lsp_trust_store_path,
+  is_lsp_binary_trusted,
+} from "./trust.js";
+
+const LSP_PROJECT_BINARY_ENV = "MY_PI_LSP_PROJECT_BINARY";
+
+class LspStartupCancelledError extends Error {
+  constructor(language: string, workspace_root: string) {
+    super(`Startup cancelled for ${language} LSP in ${workspace_root}`);
+    this.name = "LspStartupCancelledError";
+  }
+}
+
+export interface FileState {
+  client: LspClient;
+  language: string;
+  workspace_root: string;
+  root_uri: string;
+  command: string;
+  install_hint: string;
+}
+
+export interface ResolvedFileState {
+  abs: string;
+  uri: string;
+  state: FileState;
+}
+
+interface Startup {
+  cancelled: boolean;
+  promise: Promise<FileState | undefined>;
+}
+
+export interface LspServerManagerOptions {
+  cwd?: () => string;
+  create_client?: (options: LspClientOptions) => LspClient;
+  read_file?: (path: string) => Promise<string>;
+}
+
+export class LspServerManager {
+  cwd: string;
+  clients_by_server = new Map<string, FileState>();
+  failed_servers = new Map<string, any>();
+  #create_client: (options: LspClientOptions) => LspClient;
+  #read_file: (path: string) => Promise<string>;
+  #starting_servers = new Map<string, Startup>();
+
+  constructor(options: LspServerManagerOptions = {}) {
+    this.cwd = options.cwd?.() ?? process.cwd();
+    this.#create_client =
+      options.create_client ??
+      ((client_options) => new LspClient(client_options));
+    this.#read_file =
+      options.read_file ?? ((path) => readFile(path, "utf-8"));
+  }
+
+  resolve_abs(file: string): string {
+    return isAbsolute(file) ? file : resolve(this.cwd, file);
+  }
+
+  async clear_language_state(language?: string): Promise<void> {
+    const states = language
+      ? Array.from(this.clients_by_server.entries()).filter(
+          ([, state]) => state.language === language
+        )
+      : Array.from(this.clients_by_server.entries());
+
+    const starting = language
+      ? Array.from(this.#starting_servers.entries()).filter(([key]) =>
+          key.startsWith(`${language}\u0000`)
+        )
+      : Array.from(this.#starting_servers.entries());
+
+    for (const [key, startup] of starting) {
+      startup.cancelled = true;
+      this.#starting_servers.delete(key);
+    }
+
+    await Promise.allSettled(states.map(([, state]) => state.client.stop()));
+
+    for (const [key] of states) {
+      this.clients_by_server.delete(key);
+    }
+
+    if (!language) {
+      this.failed_servers.clear();
+      return;
+    }
+
+    for (const [key, failure] of this.failed_servers.entries()) {
+      if (failure.language === language) {
+        this.failed_servers.delete(key);
+      }
+    }
+  }
+
+  async resolve_file_state(
+    file: string,
+    ctx?: any
+  ): Promise<
+    | { ok: true; result: ResolvedFileState }
+    | { ok: false; error: any }
+  > {
+    const abs = this.resolve_abs(file);
+    try {
+      const result = await this.#get_file_state(abs, ctx);
+      if (!result) {
+        return {
+          ok: false,
+          error: {
+            kind: "unsupported_language",
+            file: abs,
+            message: `No language server configured for ${abs}`,
+          },
+        };
+      }
+      return { ok: true, result };
+    } 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 #get_file_state(
+    file: string,
+    ctx?: any
+  ): Promise<ResolvedFileState | undefined> {
+    const abs = this.resolve_abs(file);
+    const state = await this.#get_or_start_client(abs, ctx);
+    if (!state) return undefined;
+    const uri = await this.#open_file(state, abs);
+    return { abs, uri, state };
+  }
+
+  async #get_or_start_client(
+    file_path: string,
+    ctx?: any
+  ): Promise<FileState | undefined> {
+    const language = detect_language(file_path);
+    if (!language) return undefined;
+
+    const workspace_root = find_workspace_root(file_path, this.cwd);
+    const key = `${language}\u0000${workspace_root}`;
+
+    const existing = this.clients_by_server.get(key);
+    if (existing) return existing;
+
+    const failed = this.failed_servers.get(key);
+    if (failed) {
+      throw new LspToolError(failed);
+    }
+
+    const in_flight = this.#starting_servers.get(key);
+    if (in_flight) return in_flight.promise;
+
+    let server_config = get_server_config(language, workspace_root);
+    if (!server_config) return undefined;
+
+    if (
+      server_config.is_project_local &&
+      !(await should_use_project_lsp_binary(server_config, ctx))
+    ) {
+      server_config = get_server_config(language, "/");
+      if (!server_config) return undefined;
+    }
+
+    const root_uri = file_path_to_uri(workspace_root);
+
+    const startup: Startup = {
+      cancelled: false,
+      promise: Promise.resolve(undefined),
+    };
+
+    const start_promise = (async () => {
+      const client = this.#create_client({
+        command: server_config!.command,
+        args: server_config!.args,
+        root_uri,
+        language_id_for_uri: (uri) => language_id_for_file(uri),
+      });
+
+      try {
+        await client.start();
+      } catch (error) {
+        if (startup.cancelled) {
+          throw new LspStartupCancelledError(language, workspace_root);
+        }
+        const failure = to_lsp_tool_error(
+          file_path,
+          language,
+          workspace_root,
+          server_config!.command,
+          server_config!.install_hint,
+          error
+        );
+        this.failed_servers.set(key, failure);
+        throw new LspToolError(failure);
+      }
+
+      if (startup.cancelled) {
+        await Promise.allSettled([client.stop()]);
+        throw new LspStartupCancelledError(language, workspace_root);
+      }
+
+      const state: FileState = {
+        client,
+        language,
+        workspace_root,
+        root_uri,
+        command: server_config!.command,
+        install_hint: server_config!.install_hint,
+      };
+
+      this.clients_by_server.set(key, state);
+      this.failed_servers.delete(key);
+      return state;
+    })();
+
+    startup.promise = start_promise;
+    this.#starting_servers.set(key, startup);
+
+    try {
+      return await start_promise;
+    } finally {
+      if (this.#starting_servers.get(key) === startup) {
+        this.#starting_servers.delete(key);
+      }
+    }
+  }
+
+  async #open_file(state: FileState, abs_path: string): Promise<string> {
+    const text = await this.#read_file(abs_path);
+    const uri = file_path_to_uri(abs_path);
+    await state.client.ensure_document_open(uri, text);
+    return uri;
+  }
+}
+
+async function should_use_project_lsp_binary(
+  server_config: LanguageConfig,
+  ctx?: any
+): Promise<boolean> {
+  if (!server_config.is_project_local) return true;
+
+  if (is_lsp_binary_trusted(server_config.command)) return true;
+
+  const subject = {
+    ...create_lsp_binary_trust_subject(server_config.command),
+    prompt_title:
+      "Project-local language server binaries can execute code.\nTrust this LSP binary?",
+    summary_lines: [
+      `Language: ${server_config.language}`,
+      `Binary: ${server_config.command}`,
+    ],
+    headless_warning: `Skipping untrusted project-local LSP binary: ${server_config.command}. Set ${LSP_PROJECT_BINARY_ENV}=allow to enable it for this run.`,
+  };
+
+  const decision = await resolve_project_trust(subject, {
+    env: process.env,
+    has_ui: ctx?.hasUI,
+    select: ctx?.hasUI
+      ? async (message: string, choices: any) =>
+          (await ctx.ui.select(message, choices)) ?? ""
+      : undefined,
+    warn: console.warn,
+    trust_store_path: default_lsp_trust_store_path(),
+  });
+
+  return (
+    decision.action === "allow-once" ||
+    decision.action === "trust-persisted"
+  );
+}