pi-ui-extend 0.1.1

package/external/pi-tools-suite/src/lsp/_shared/types.ts

@@ -0,0 +1,98 @@
+import type { Diagnostic } from "vscode-languageserver-protocol";
+
+export type ConfigKind = "lsp";
+
+export interface CommandConfig {
+  bin: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  config?: string;
+  timeoutMs?: number;
+  diagnosticExitCodes?: number[];
+}
+
+export interface MatchableConfig {
+  id: string;
+  enabled?: boolean;
+  include?: string[];
+  exclude?: string[];
+  rootMarkers?: string[];
+  maxFileSizeBytes?: number;
+}
+
+export interface LspServerConfig extends MatchableConfig {
+  bin: string;
+  args?: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  config?: string;
+  languageIdByExtension?: Record<string, string>;
+  startupTimeoutMs?: number;
+  diagnosticsWaitMs?: number;
+  initializationOptions?: unknown;
+  settings?: unknown;
+}
+
+export interface LspConfigFile {
+  version?: number;
+  servers?: LspServerConfig[];
+}
+
+export interface ConfigLayer<TItem extends MatchableConfig> {
+  scope: "global" | "project";
+  path: string;
+  dir: string;
+  raw: string;
+  hash: string;
+  items: TItem[];
+}
+
+export interface LoadedConfig<TItem extends MatchableConfig> {
+  items: TItem[];
+  layers: ConfigLayer<TItem>[];
+  warnings: string[];
+}
+
+export interface PathPlaceholders {
+  workspace: string;
+  root: string;
+  file: string;
+  relFile: string;
+  dir: string;
+  relDir: string;
+  config: string;
+  configDir: string;
+}
+
+export interface ResolvedCommand {
+  id: string;
+  bin: string;
+  args: string[];
+  cwd: string;
+  env?: Record<string, string>;
+  timeoutMs?: number;
+  configPath?: string;
+  placeholders: PathPlaceholders;
+}
+
+export interface CommandRunResult {
+  id: string;
+  bin: string;
+  args: string[];
+  cwd: string;
+  stdout: string;
+  stderr: string;
+  code: number;
+  killed: boolean;
+  durationMs: number;
+}
+
+export interface StoredDiagnostics {
+  serverId: string;
+  root: string;
+  file: string;
+  version?: number;
+  diagnostics: Diagnostic[];
+  updatedAt: number;
+}

package/external/pi-tools-suite/src/lsp/async.ts

@@ -0,0 +1,29 @@
+export function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(new Error("aborted"));
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    };
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const abort = () => {
+      cleanup();
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+  let timeout: NodeJS.Timeout | undefined;
+  const timeoutPromise = new Promise<never>((_resolve, reject) => {
+    timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    if (timeout) clearTimeout(timeout);
+  });
+}

package/external/pi-tools-suite/src/lsp/child-process.ts

@@ -0,0 +1,81 @@
+import { spawnSync, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { SHUTDOWN_KILL_TIMEOUT_MS, SHUTDOWN_TERM_TIMEOUT_MS, SHUTDOWN_WRITE_TIMEOUT_MS } from "./constants";
+
+export function isChildRunning(child: ChildProcessWithoutNullStreams): boolean {
+  return child.exitCode === null && child.signalCode === null;
+}
+
+function canWriteToChild(child: ChildProcessWithoutNullStreams): boolean {
+  return isChildRunning(child) && child.stdin.writable && !child.stdin.destroyed && !child.stdin.writableEnded;
+}
+
+export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): boolean {
+  try {
+    if (process.platform === "win32" && child.pid) {
+      const result = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore",
+        timeout: 1_000,
+        windowsHide: true,
+      });
+      if (!result.error && result.status === 0) return true;
+    }
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+
+function waitForChildExit(child: ChildProcessWithoutNullStreams, timeoutMs: number): Promise<boolean> {
+  if (!isChildRunning(child)) return Promise.resolve(true);
+
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (exited: boolean) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      child.off("exit", onExit);
+      resolve(exited);
+    };
+    const onExit = () => finish(true);
+    const timeout = setTimeout(() => finish(false), timeoutMs);
+    timeout.unref();
+    child.once("exit", onExit);
+    if (!isChildRunning(child)) finish(true);
+  });
+}
+
+export async function terminateChild(child: ChildProcessWithoutNullStreams): Promise<void> {
+  if (!isChildRunning(child)) return;
+
+  if (!killChild(child, "SIGTERM")) return;
+  const exited = await waitForChildExit(child, SHUTDOWN_TERM_TIMEOUT_MS);
+  if (exited || !isChildRunning(child)) return;
+
+  killChild(child, "SIGKILL");
+  await waitForChildExit(child, SHUTDOWN_KILL_TIMEOUT_MS);
+}
+
+export async function bestEffortWriteJsonRpc(child: ChildProcessWithoutNullStreams, message: Record<string, unknown>): Promise<void> {
+  if (!canWriteToChild(child)) return;
+
+  const json = JSON.stringify(message);
+  const payload = `Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n${json}`;
+  await new Promise<void>((resolve) => {
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      resolve();
+    };
+    const timeout = setTimeout(finish, SHUTDOWN_WRITE_TIMEOUT_MS);
+    timeout.unref();
+
+    try {
+      child.stdin.write(payload, "utf8", finish);
+    } catch {
+      finish();
+    }
+  });
+}

package/external/pi-tools-suite/src/lsp/client.ts

@@ -0,0 +1,340 @@
+import path from "node:path";
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { MessageConnection } from "vscode-jsonrpc";
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node";
+import {
+  DefinitionRequest,
+  DidChangeConfigurationNotification,
+  DidChangeTextDocumentNotification,
+  DidOpenTextDocumentNotification,
+  DidSaveTextDocumentNotification,
+  DocumentSymbolRequest,
+  ExecuteCommandRequest,
+  HoverRequest,
+  InitializeRequest,
+  InitializedNotification,
+  PublishDiagnosticsNotification,
+  ReferencesRequest,
+  type Diagnostic,
+  type InitializeResult,
+  type ServerCapabilities,
+} from "vscode-languageserver-protocol";
+import { withTimeout } from "./async";
+import { bestEffortWriteJsonRpc, isChildRunning, killChild, terminateChild } from "./child-process";
+import { DEFAULT_STARTUP_TIMEOUT_MS, REQUEST_TIMEOUT_MS } from "./constants";
+import { DocumentStore } from "./documents";
+import type { DiagnosticsStore } from "./diagnostics-store";
+import { filePathToUri } from "./_shared/paths";
+import { isExecutableAvailable } from "./_shared/runner";
+import type { LspServerConfig, ResolvedCommand } from "./_shared/types";
+import { supportsSave } from "./lsp-utils";
+import type { OpenDocument } from "./types";
+import { tsserverDiagnosticToLsp, tsserverDiagnosticsFromResponse } from "./tsserver";
+
+export class LspClient {
+  private process: ChildProcessWithoutNullStreams | undefined;
+  private connection: MessageConnection | undefined;
+  private capabilities: ServerCapabilities | undefined;
+  private readonly documents = new DocumentStore();
+  private startPromise: Promise<void> | undefined;
+  private initialized = false;
+  private unavailableReason: string | undefined;
+  private stderrTail = "";
+
+  constructor(
+    private readonly server: LspServerConfig,
+    private readonly root: string,
+    private readonly command: ResolvedCommand,
+    private readonly diagnostics: DiagnosticsStore,
+  ) {}
+
+  get isUnavailable(): boolean {
+    return !!this.unavailableReason;
+  }
+
+  get reason(): string | undefined {
+    return this.unavailableReason;
+  }
+
+  async ensureStarted(signal?: AbortSignal): Promise<void> {
+    if (this.initialized && this.connection && !this.unavailableReason) return;
+    if (this.unavailableReason) throw new Error(this.unavailableReason);
+    this.startPromise ??= this.start(signal).catch(async (error) => {
+      this.startPromise = undefined;
+      await this.shutdown();
+      throw error;
+    });
+    await this.startPromise;
+  }
+
+  private async start(signal?: AbortSignal): Promise<void> {
+    if (!isExecutableAvailable(this.command.bin)) {
+      this.unavailableReason = `${this.server.id}: LSP binary not found: ${this.command.bin}`;
+      throw new Error(this.unavailableReason);
+    }
+
+    const child = spawn(this.command.bin, this.command.args, {
+      cwd: this.command.cwd,
+      env: this.command.env ? { ...process.env, ...this.command.env } : process.env,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process = child;
+    let failStartup: ((error: Error) => void) | undefined;
+    const startupFailure = new Promise<never>((_resolve, reject) => {
+      failStartup = reject;
+    });
+    const markUnavailable = (reason: string) => {
+      this.unavailableReason = reason;
+      this.initialized = false;
+      this.startPromise = undefined;
+      this.connection?.dispose();
+      this.connection = undefined;
+      failStartup?.(new Error(reason));
+    };
+
+    child.stderr.on("data", (chunk: Buffer) => {
+      this.stderrTail = `${this.stderrTail}${chunk.toString()}`.slice(-4000);
+    });
+    child.on("error", (error) => {
+      markUnavailable(`${this.server.id}: LSP failed to start: ${error.message}`);
+    });
+    child.on("exit", (code, sig) => {
+      markUnavailable(`${this.server.id}: LSP exited (${code ?? sig ?? "unknown"})${this.stderrTail ? `: ${this.stderrTail.trim()}` : ""}`);
+    });
+
+    const connection = createMessageConnection(new StreamMessageReader(child.stdout), new StreamMessageWriter(child.stdin));
+    this.connection = connection;
+    this.registerHandlers(connection);
+    connection.listen();
+
+    const initializeResult = (await withTimeout(
+      Promise.race([connection.sendRequest(InitializeRequest.method, this.initializeParams()), startupFailure]),
+      this.server.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
+      `${this.server.id} initialize`,
+    )) as InitializeResult;
+    this.capabilities = initializeResult.capabilities;
+    failStartup = undefined;
+
+    await connection.sendNotification(InitializedNotification.method, {});
+    if (this.server.settings !== undefined) {
+      await connection.sendNotification(DidChangeConfigurationNotification.method, { settings: this.server.settings });
+    }
+
+    if (signal?.aborted) throw new Error("aborted");
+    this.initialized = true;
+  }
+
+  private initializeParams() {
+    const rootUri = filePathToUri(this.root);
+    return {
+      processId: process.pid,
+      rootUri,
+      workspaceFolders: [{ name: path.basename(this.root), uri: rootUri }],
+      capabilities: {
+        window: { workDoneProgress: true },
+        workspace: {
+          configuration: true,
+          workspaceFolders: true,
+          didChangeWatchedFiles: { dynamicRegistration: true },
+        },
+        textDocument: {
+          synchronization: {
+            didOpen: true,
+            didChange: true,
+            didSave: true,
+          },
+          publishDiagnostics: {
+            relatedInformation: true,
+            versionSupport: true,
+          },
+          hover: {},
+          definition: {},
+          references: {},
+          documentSymbol: {},
+        },
+      },
+      initializationOptions: this.server.initializationOptions ?? {},
+    };
+  }
+
+  private registerHandlers(connection: MessageConnection): void {
+    connection.onNotification(
+      PublishDiagnosticsNotification.method,
+      (params: { uri: string; diagnostics: Diagnostic[]; version?: number }) => {
+        this.diagnostics.set(this.server.id, this.root, params.uri, params.diagnostics, params.version);
+      },
+    );
+
+    const anyConnection = connection as unknown as {
+      onRequest(method: string, handler: (params: unknown) => unknown): void;
+      onNotification(method: string, handler: (params: unknown) => void): void;
+    };
+
+    anyConnection.onRequest("workspace/configuration", (params: unknown) => {
+      const items = (params as { items?: unknown[] } | undefined)?.items;
+      if (!Array.isArray(items)) return [this.server.settings ?? {}];
+      return items.map(() => this.server.settings ?? {});
+    });
+    anyConnection.onRequest("workspace/workspaceFolders", () => [{ name: path.basename(this.root), uri: filePathToUri(this.root) }]);
+    anyConnection.onRequest("client/registerCapability", () => null);
+    anyConnection.onRequest("client/unregisterCapability", () => null);
+    anyConnection.onRequest("window/workDoneProgress/create", () => null);
+    anyConnection.onNotification("window/logMessage", () => undefined);
+    anyConnection.onNotification("telemetry/event", () => undefined);
+  }
+
+  async openOrChange(file: string, languageId: string, text: string, signal?: AbortSignal): Promise<OpenDocument> {
+    await this.ensureStarted(signal);
+    if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
+
+    const existing = this.documents.get(file);
+    if (!existing) {
+      const doc = this.documents.open(file, languageId, text);
+      await this.connection.sendNotification(DidOpenTextDocumentNotification.method, {
+        textDocument: {
+          uri: doc.uri,
+          languageId: doc.languageId,
+          version: doc.version,
+          text: doc.text,
+        },
+      });
+      return doc;
+    }
+
+    const doc = this.documents.change(file, text);
+    await this.connection.sendNotification(DidChangeTextDocumentNotification.method, {
+      textDocument: { uri: doc.uri, version: doc.version },
+      contentChanges: [{ text: doc.text }],
+    });
+    return doc;
+  }
+
+  async didSave(file: string): Promise<void> {
+    if (!this.connection || !supportsSave(this.capabilities)) return;
+    const doc = this.documents.get(file);
+    if (!doc) return;
+    await this.connection.sendNotification(DidSaveTextDocumentNotification.method, {
+      textDocument: { uri: doc.uri },
+      text: doc.text,
+    });
+  }
+
+  private supportsTsserverDiagnostics(): boolean {
+    const commands = this.capabilities?.executeCommandProvider?.commands;
+    return Array.isArray(commands) && commands.includes("typescript.tsserverRequest");
+  }
+
+  async tsserverDiagnostics(file: string, text: string, timeoutMs: number): Promise<Diagnostic[] | undefined> {
+    const connection = this.connection;
+    if (!connection || !this.supportsTsserverDiagnostics()) return undefined;
+
+    const requests = [
+      { command: "syntacticDiagnosticsSync", executionTarget: 1 },
+      { command: "semanticDiagnosticsSync", executionTarget: 0 },
+      { command: "suggestionDiagnosticsSync", executionTarget: 0 },
+    ];
+
+    const responses = await Promise.all(requests.map((request) => withTimeout(
+      connection.sendRequest(ExecuteCommandRequest.method, {
+        command: "typescript.tsserverRequest",
+        arguments: [
+          request.command,
+          { file, includeLinePosition: true },
+          {
+            executionTarget: request.executionTarget,
+            expectsResult: true,
+            isAsync: false,
+            lowPriority: false,
+          },
+        ],
+      }),
+      timeoutMs,
+      `${this.server.id} ${request.command}`,
+    )));
+
+    return responses.flatMap((response) => tsserverDiagnosticsFromResponse(response).map((diagnostic) => tsserverDiagnosticToLsp(diagnostic, text)));
+  }
+
+  async hover(file: string, line: number, character: number): Promise<unknown> {
+    if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
+    return withTimeout(
+      this.connection.sendRequest(HoverRequest.method, {
+        textDocument: { uri: filePathToUri(file) },
+        position: { line, character },
+      }),
+      REQUEST_TIMEOUT_MS,
+      `${this.server.id} hover`,
+    );
+  }
+
+  async definition(file: string, line: number, character: number): Promise<unknown> {
+    if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
+    return withTimeout(
+      this.connection.sendRequest(DefinitionRequest.method, {
+        textDocument: { uri: filePathToUri(file) },
+        position: { line, character },
+      }),
+      REQUEST_TIMEOUT_MS,
+      `${this.server.id} definition`,
+    );
+  }
+
+  async references(file: string, line: number, character: number, includeDeclaration: boolean): Promise<unknown> {
+    if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
+    return withTimeout(
+      this.connection.sendRequest(ReferencesRequest.method, {
+        textDocument: { uri: filePathToUri(file) },
+        position: { line, character },
+        context: { includeDeclaration },
+      }),
+      REQUEST_TIMEOUT_MS,
+      `${this.server.id} references`,
+    );
+  }
+
+  async symbols(file: string): Promise<unknown> {
+    if (!this.connection) throw new Error(`${this.server.id}: LSP connection unavailable`);
+    return withTimeout(
+      this.connection.sendRequest(DocumentSymbolRequest.method, {
+        textDocument: { uri: filePathToUri(file) },
+      }),
+      REQUEST_TIMEOUT_MS,
+      `${this.server.id} document symbols`,
+    );
+  }
+
+  async shutdown(): Promise<void> {
+    const connection = this.connection;
+    const child = this.process;
+    this.connection = undefined;
+    this.process = undefined;
+    this.initialized = false;
+    this.startPromise = undefined;
+
+    if (child) {
+      await bestEffortWriteJsonRpc(child, { jsonrpc: "2.0", id: "pi-lsp-shutdown", method: "shutdown" });
+      await bestEffortWriteJsonRpc(child, { jsonrpc: "2.0", method: "exit" });
+    }
+
+    connection?.dispose();
+
+    if (child) {
+      await terminateChild(child);
+    }
+  }
+
+  shutdownSync(): void {
+    const connection = this.connection;
+    const child = this.process;
+    this.connection = undefined;
+    this.process = undefined;
+    this.initialized = false;
+    this.startPromise = undefined;
+
+    connection?.dispose();
+
+    if (child && isChildRunning(child)) killChild(child, "SIGKILL");
+  }
+}

package/external/pi-tools-suite/src/lsp/constants.ts

@@ -0,0 +1,9 @@
+export const DEFAULT_STARTUP_TIMEOUT_MS = 45_000;
+export const DEFAULT_DIAGNOSTICS_WAIT_MS = 10_000;
+export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+export const REQUEST_TIMEOUT_MS = 30_000;
+export const SHUTDOWN_WRITE_TIMEOUT_MS = 100;
+export const SHUTDOWN_TERM_TIMEOUT_MS = 2_000;
+export const SHUTDOWN_KILL_TIMEOUT_MS = 500;
+
+export const LSP_MANAGER_GLOBAL_KEY = "__piToolsSuiteLspManager";

package/external/pi-tools-suite/src/lsp/diagnostics-store.ts

@@ -0,0 +1,64 @@
+import type { Diagnostic } from "vscode-languageserver-protocol";
+import { delay } from "./async";
+import { uriToFilePath } from "./_shared/paths";
+import type { StoredDiagnostics } from "./_shared/types";
+
+export class DiagnosticsStore {
+  private readonly diagnostics = new Map<string, StoredDiagnostics>();
+
+  private key(serverId: string, root: string, file: string): string {
+    return `${serverId}\u0000${root}\u0000${file}`;
+  }
+
+  set(serverId: string, root: string, uri: string, diagnostics: Diagnostic[], version?: number): void {
+    const file = uriToFilePath(uri);
+    const key = this.key(serverId, root, file);
+    this.diagnostics.set(key, {
+      serverId,
+      root,
+      file,
+      version,
+      diagnostics,
+      updatedAt: Date.now(),
+    });
+  }
+
+  clear(serverId: string, root: string, uri: string): void {
+    this.diagnostics.delete(this.key(serverId, root, uriToFilePath(uri)));
+  }
+
+  get(serverId: string, root: string, file: string): StoredDiagnostics | undefined {
+    return this.diagnostics.get(this.key(serverId, root, file));
+  }
+
+  async waitForFile(
+    serverId: string,
+    root: string,
+    file: string,
+    since: number,
+    version: number | undefined,
+    timeoutMs: number,
+    signal?: AbortSignal,
+  ): Promise<StoredDiagnostics | undefined> {
+    const deadline = Date.now() + Math.max(0, timeoutMs);
+
+    while (true) {
+      const entry = this.get(serverId, root, file);
+      if (entry && entry.updatedAt >= since) {
+        // Some language servers omit diagnostic versions. If present, require
+        // diagnostics for the document version we just sent or newer.
+        if (entry.version === undefined || version === undefined || entry.version >= version) {
+          return entry;
+        }
+      }
+
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return this.get(serverId, root, file);
+      await delay(Math.min(50, remaining), signal);
+    }
+  }
+
+  getAllForFile(file: string): StoredDiagnostics[] {
+    return [...this.diagnostics.values()].filter((entry) => entry.file === file);
+  }
+}

package/external/pi-tools-suite/src/lsp/documents.ts

@@ -0,0 +1,24 @@
+import { filePathToUri } from "./_shared/paths";
+import type { OpenDocument } from "./types";
+
+export class DocumentStore {
+  private readonly documents = new Map<string, OpenDocument>();
+
+  get(file: string): OpenDocument | undefined {
+    return this.documents.get(file);
+  }
+
+  open(file: string, languageId: string, text: string): OpenDocument {
+    const doc: OpenDocument = { file, uri: filePathToUri(file), languageId, version: 1, text };
+    this.documents.set(file, doc);
+    return doc;
+  }
+
+  change(file: string, text: string): OpenDocument {
+    const existing = this.documents.get(file);
+    if (!existing) throw new Error(`document not opened: ${file}`);
+    const updated: OpenDocument = { ...existing, version: existing.version + 1, text };
+    this.documents.set(file, updated);
+    return updated;
+  }
+}

package/external/pi-tools-suite/src/lsp/index.ts

@@ -0,0 +1,31 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { appendLspDiagnosticsToMutationResult, shutdownGlobalLspManager } from "./tool-result.js";
+
+// renderer.ts is intentionally empty — TUI rendering removed.
+export { LspManager, getGlobalLspManager } from "./manager";
+export { getEventPaths, isMutationToolResult } from "./mutation-events";
+export {
+  appendLspDiagnosticsToMutationResult,
+  shutdownGlobalLspManager,
+  type LspEnrichableToolResult,
+  type LspMutationToolResultInput,
+} from "./tool-result";
+
+export default function piLspExtension(pi: ExtensionAPI) {
+  pi.on("tool_result", async (event, ctx) => {
+    const result = await appendLspDiagnosticsToMutationResult({
+      toolName: event.toolName,
+      input: event.input,
+      result: { content: event.content, details: event.details },
+      ctx,
+      isError: event.isError,
+    });
+
+    if (result.content === event.content && result.details === event.details) return undefined;
+    return { content: result.content, details: result.details };
+  });
+
+  pi.on("session_shutdown", async () => {
+    await shutdownGlobalLspManager();
+  });
+}