pi-ui-extend 0.1.1

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

@@ -0,0 +1,37 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { ServerCapabilities } from "vscode-languageserver-protocol";
+import { matchesAnyGlob } from "./_shared/glob";
+import { normalizeRelativePath } from "./_shared/paths";
+import type { LspServerConfig } from "./_shared/types";
+
+export async function readTextFile(file: string): Promise<string> {
+  return fs.readFile(file, "utf8");
+}
+
+export async function fileSizeAllowed(file: string, limit: number): Promise<boolean> {
+  const stat = await fs.stat(file);
+  return stat.size <= limit;
+}
+
+export function languageIdForFile(server: LspServerConfig, file: string): string {
+  const extension = path.extname(file);
+  return server.languageIdByExtension?.[extension] ?? (extension.replace(/^\./, "") || "plaintext");
+}
+
+export function couldMatchBeforeRoot(file: string, cwd: string, include?: string[], exclude?: string[]): boolean {
+  const candidates = [...new Set([normalizeRelativePath(path.relative(cwd, file)), path.basename(file)])];
+  const included = !include || include.length === 0 || candidates.some((candidate) => matchesAnyGlob(include, candidate));
+  if (!included) return false;
+  return !candidates.some((candidate) => matchesAnyGlob(exclude, candidate));
+}
+
+export function supportsSave(capabilities: ServerCapabilities | undefined): boolean {
+  const sync = capabilities?.textDocumentSync;
+  if (!sync || typeof sync === "number") return false;
+  return !!sync.save;
+}
+
+export function clientKey(serverId: string, root: string): string {
+  return `${serverId}\u0000${root}`;
+}

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

@@ -0,0 +1,190 @@
+import path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_DIAGNOSTICS_WAIT_MS, DEFAULT_MAX_FILE_SIZE_BYTES, LSP_MANAGER_GLOBAL_KEY } from "./constants";
+import { DiagnosticsStore } from "./diagnostics-store";
+import { LspClient } from "./client";
+import { loadLspConfig } from "./_shared/config";
+import { isPathIncluded } from "./_shared/glob";
+import { filePathToUri, findProjectRoot, normalizeRelativePath, resolveCommand, toAbsolutePath } from "./_shared/paths";
+import { formatLspDiagnostics, formatWarnings, joinSections } from "./_shared/output";
+import type { LspServerConfig, StoredDiagnostics } from "./_shared/types";
+import { clientKey, couldMatchBeforeRoot, fileSizeAllowed, languageIdForFile, readTextFile } from "./lsp-utils";
+import type { MatchedServer } from "./types";
+
+function isFreshDiagnosticsEntry(entry: StoredDiagnostics | undefined, since: number, version: number | undefined): entry is StoredDiagnostics {
+  return !!entry
+    && entry.updatedAt >= since
+    && (entry.version === undefined || version === undefined || entry.version >= version);
+}
+
+export class LspManager {
+  private readonly diagnostics = new DiagnosticsStore();
+  private readonly clients = new Map<string, LspClient>();
+  private readonly backoff = new Map<string, { retryAt: number; attempts: number; reason: string }>();
+  private readonly handleProcessExit = () => {
+    this.shutdownAllSync();
+  };
+
+  constructor() {
+    process.once("exit", this.handleProcessExit);
+  }
+
+  async matchingServers(ctx: ExtensionContext, file: string): Promise<{ matches: MatchedServer[]; warnings: string[]; workspace: string }> {
+    const loaded = await loadLspConfig(ctx);
+    const warnings = [...loaded.warnings];
+    const projectLayer = loaded.layers.find((layer) => layer.scope === "project");
+    const workspace = projectLayer ? path.dirname(projectLayer.dir) : ctx.cwd;
+    const matches: MatchedServer[] = [];
+
+    for (const server of loaded.items) {
+      if (server.enabled === false) continue;
+      if (!couldMatchBeforeRoot(file, ctx.cwd, server.include, server.exclude)) continue;
+
+      const root = findProjectRoot(file, server.rootMarkers, ctx.cwd);
+      if (!root) {
+        warnings.push(`${server.id}: root markers not found (${(server.rootMarkers ?? []).join(", ") || "none"})`);
+        continue;
+      }
+      const relFile = normalizeRelativePath(path.relative(root, file));
+      if (relFile.startsWith("..") || path.isAbsolute(relFile)) continue;
+      if (!isPathIncluded(relFile, server.include, server.exclude)) continue;
+      matches.push({ server, root, relFile });
+    }
+
+    return { matches, warnings, workspace };
+  }
+
+  private async getClient(server: LspServerConfig, root: string, file: string, workspace: string, signal?: AbortSignal): Promise<LspClient> {
+    const key = clientKey(server.id, root);
+    const backoff = this.backoff.get(key);
+    if (backoff && Date.now() < backoff.retryAt) {
+      throw new Error(`${server.id}: unavailable (${backoff.reason}); retry after ${new Date(backoff.retryAt).toISOString()}`);
+    }
+
+    let client = this.clients.get(key);
+    if (!client || client.isUnavailable) {
+      const command = resolveCommand(server.id, server, { workspace, root, file });
+      client = new LspClient(server, root, command, this.diagnostics);
+      this.clients.set(key, client);
+    }
+
+    try {
+      await client.ensureStarted(signal);
+      this.backoff.delete(key);
+      return client;
+    } catch (error) {
+      const previous = this.backoff.get(key);
+      const attempts = (previous?.attempts ?? 0) + 1;
+      const delayMs = Math.min(60_000, 1_000 * 2 ** Math.min(attempts, 6));
+      this.backoff.set(key, { attempts, retryAt: Date.now() + delayMs, reason: (error as Error).message });
+      throw error;
+    }
+  }
+
+  async updateDiagnosticsForFile(ctx: ExtensionContext, file: string): Promise<string> {
+    const { matches, warnings, workspace } = await this.matchingServers(ctx, file);
+    if (matches.length === 0) return formatWarnings("LSP diagnostics", warnings);
+
+    const lines: string[] = [];
+    for (const match of matches) {
+      try {
+        const maxFileSizeBytes = match.server.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+        if (!(await fileSizeAllowed(file, maxFileSizeBytes))) {
+          lines.push(`⚠️ ${match.server.id}: skipped ${match.relFile}; file exceeds maxFileSizeBytes (${maxFileSizeBytes})`);
+          continue;
+        }
+
+        // Clear stale diagnostics before refreshing this file. The synchronous
+        // wait below must observe a fresh publishDiagnostics notification, not an
+        // old error from a previous document version. Empty diagnostics published
+        // by the server are stored, but this local clear is not.
+        this.diagnostics.clear(match.server.id, match.root, filePathToUri(file));
+
+        const text = await readTextFile(file);
+        const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
+        const languageId = languageIdForFile(match.server, file);
+        const startedAt = Date.now();
+        const doc = await client.openOrChange(file, languageId, text, ctx.signal);
+        await client.didSave(file);
+        const diagnosticsWaitMs = match.server.diagnosticsWaitMs ?? DEFAULT_DIAGNOSTICS_WAIT_MS;
+
+        // typescript-language-server sometimes does not emit a fresh
+        // textDocument/publishDiagnostics notification after didChange/didSave,
+        // even though tsserver can answer diagnostics synchronously. Prefer the
+        // explicit tsserver request when the server exposes it, so post-edit
+        // diagnostics don't degrade into a misleading publishDiagnostics timeout.
+        let tsserverFallbackError: string | undefined;
+        try {
+          const tsserverDiagnostics = await client.tsserverDiagnostics(file, text, diagnosticsWaitMs);
+          if (tsserverDiagnostics !== undefined) {
+            this.diagnostics.set(match.server.id, match.root, filePathToUri(file), tsserverDiagnostics, doc.version);
+            lines.push(formatLspDiagnostics(match.server.id, file, tsserverDiagnostics, match.root));
+            continue;
+          }
+        } catch (error) {
+          tsserverFallbackError = (error as Error).message;
+        }
+
+        const entry = await this.diagnostics.waitForFile(
+          match.server.id,
+          match.root,
+          file,
+          startedAt,
+          doc.version,
+          diagnosticsWaitMs,
+          ctx.signal,
+        );
+        if (!isFreshDiagnosticsEntry(entry, startedAt, doc.version)) {
+          const fallbackSuffix = tsserverFallbackError ? `; tsserver fallback failed: ${tsserverFallbackError}` : "";
+          lines.push(`⚠️ ${match.server.id}: timed out after ${diagnosticsWaitMs}ms waiting for fresh diagnostics for ${match.relFile}${fallbackSuffix}`);
+          continue;
+        }
+        lines.push(formatLspDiagnostics(match.server.id, file, entry.diagnostics, match.root));
+      } catch (error) {
+        lines.push(`⚠️ ${match.server.id}: ${(error as Error).message}`);
+      }
+    }
+
+    return [formatWarnings("LSP diagnostics", warnings), joinSections("LSP diagnostics", lines)].filter(Boolean).join("\n\n");
+  }
+
+  async ensureDocumentForTool(ctx: ExtensionContext, inputPath: string): Promise<{ file: string; match: MatchedServer; client: LspClient; workspace: string } | undefined> {
+    const file = toAbsolutePath(inputPath, ctx.cwd);
+    const { matches, workspace } = await this.matchingServers(ctx, file);
+    const match = matches[0];
+    if (!match) return undefined;
+    const text = await readTextFile(file);
+    const client = await this.getClient(match.server, match.root, file, workspace, ctx.signal);
+    await client.openOrChange(file, languageIdForFile(match.server, file), text, ctx.signal);
+    return { file, match, client, workspace };
+  }
+
+  diagnosticsForPath(ctx: ExtensionContext, inputPath: string): string {
+    const file = toAbsolutePath(inputPath, ctx.cwd);
+    const entries = this.diagnostics.getAllForFile(file);
+    if (entries.length === 0) return `LSP diagnostics:\n\n✅ no diagnostics recorded for ${file}`;
+    return joinSections(
+      "LSP diagnostics",
+      entries.map((entry) => formatLspDiagnostics(entry.serverId, entry.file, entry.diagnostics, entry.root)),
+    );
+  }
+
+  async shutdownAll(): Promise<void> {
+    const clients = [...this.clients.values()];
+    this.clients.clear();
+    await Promise.allSettled(clients.map((client) => client.shutdown()));
+  }
+
+  shutdownAllSync(): void {
+    const clients = [...this.clients.values()];
+    this.clients.clear();
+    process.off("exit", this.handleProcessExit);
+    for (const client of clients) client.shutdownSync();
+  }
+}
+
+export function getGlobalLspManager(): LspManager {
+  const globalState = globalThis as typeof globalThis & { [LSP_MANAGER_GLOBAL_KEY]?: LspManager };
+  globalState[LSP_MANAGER_GLOBAL_KEY] ??= new LspManager();
+  return globalState[LSP_MANAGER_GLOBAL_KEY];
+}

package/external/pi-tools-suite/src/lsp/mutation-events.ts

@@ -0,0 +1,78 @@
+function patchTextFromInput(input: unknown): string | undefined {
+  if (typeof input === "string") return input;
+  if (typeof input !== "object" || input === null) return undefined;
+
+  const record = input as Record<string, unknown>;
+  for (const key of ["input", "patch", "text", "content"]) {
+    if (typeof record[key] === "string") return record[key];
+  }
+  return undefined;
+}
+
+function changedFilesFromDetails(details: unknown): string[] {
+  if (typeof details !== "object" || details === null) return [];
+  const changedFiles = (details as Record<string, unknown>).changedFiles;
+  if (!Array.isArray(changedFiles)) return [];
+  return changedFiles.filter((file): file is string => typeof file === "string" && file.trim().length > 0);
+}
+
+function addPaths(paths: Set<string>, inputPaths: string[]): void {
+  for (const inputPath of inputPaths) {
+    addPath(paths, inputPath);
+  }
+}
+
+function addPath(paths: Set<string>, inputPath: string): void {
+  const trimmed = inputPath.trim();
+  if (trimmed) paths.add(trimmed);
+}
+
+function uniqueNonEmptyPaths(inputPaths: string[]): string[] {
+  const paths = new Set<string>();
+  addPaths(paths, inputPaths);
+  return [...paths];
+}
+
+export function getEventPaths(input: unknown, details?: unknown): string[] {
+  const record = typeof input === "object" && input !== null ? input as Record<string, unknown> : undefined;
+  const exactChangedFiles = changedFilesFromDetails(details);
+  if (exactChangedFiles.length > 0) return uniqueNonEmptyPaths(exactChangedFiles);
+
+  const paths = new Set<string>();
+
+  if (typeof record?.path === "string") addPath(paths, record.path);
+  if (typeof record?.file_path === "string") addPath(paths, record.file_path);
+  if (Array.isArray(record?.paths)) addPaths(paths, record.paths.filter((file): file is string => typeof file === "string"));
+
+  // apply_patch receives the whole patch in a tool-specific field rather than
+  // a top-level path. Extract every affected file so multi-file patches refresh
+  // diagnostics for all changed files.
+  const patchText = patchTextFromInput(input);
+  if (patchText) {
+    const headerPattern = /^\*\*\* (?:Add|Update|Delete) File: (.+)$/gm;
+    for (const match of patchText.matchAll(headerPattern)) {
+      const patchPath = match[1]?.trim();
+      if (patchPath) addPath(paths, patchPath);
+    }
+
+    const movePattern = /^\*\*\* Move to: (.+)$/gm;
+    for (const match of patchText.matchAll(movePattern)) {
+      const patchPath = match[1]?.trim();
+      if (patchPath) addPath(paths, patchPath);
+    }
+  }
+
+  return [...paths];
+}
+
+export function isMutationToolResult(event: { toolName?: string; input: unknown; details?: unknown }): boolean {
+  const toolName = typeof event.toolName === "string" ? event.toolName : "";
+  const baseName = (toolName.split(".").pop() ?? toolName).toLowerCase();
+  if (["write", "edit", "apply_patch"].includes(baseName)) return true;
+  if (baseName === "ast_apply") return changedFilesFromDetails(event.details).length > 0;
+
+  // Some tool providers may wrap/rename apply_patch but still expose the patch
+  // body in the input. Treat patch-shaped input as a file mutation.
+  const patchText = patchTextFromInput(event.input);
+  return typeof patchText === "string" && /^\*\*\* Begin Patch\b/m.test(patchText);
+}

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

@@ -0,0 +1 @@
+// TUI rendering removed — extensions should not render custom TUI components.

package/external/pi-tools-suite/src/lsp/tool-result.ts

@@ -0,0 +1,6 @@
+export {
+  appendLspDiagnosticsToMutationResult,
+  shutdownGlobalLspManager,
+  type LspEnrichableToolResult,
+  type LspMutationToolResultInput,
+} from "../lib/lsp.js";

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

@@ -0,0 +1,107 @@
+import type { Diagnostic } from "vscode-languageserver-protocol";
+
+interface TsserverLocation {
+  line?: number;
+  offset?: number;
+}
+
+interface TsserverDiagnostic {
+  start?: number | TsserverLocation;
+  end?: TsserverLocation;
+  length?: number;
+  text?: unknown;
+  message?: unknown;
+  code?: string | number;
+  category?: string | number;
+  source?: string;
+}
+
+interface TsserverResponse {
+  success?: boolean;
+  message?: string;
+  body?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function tsserverMessageText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return value === undefined ? "TypeScript diagnostic" : String(value);
+
+  const messageText = tsserverMessageText(value.messageText);
+  const next = Array.isArray(value.next) ? value.next.map(tsserverMessageText).filter((item) => item.trim().length > 0) : [];
+  return [messageText, ...next.map((item) => `  ${item}`)].filter((item) => item.trim().length > 0).join("\n");
+}
+
+function isTsserverDiagnostic(value: unknown): value is TsserverDiagnostic {
+  return isRecord(value) && ("text" in value || "message" in value || "code" in value);
+}
+
+export function tsserverDiagnosticsFromResponse(value: unknown): TsserverDiagnostic[] {
+  const response = isRecord(value) ? value as TsserverResponse : undefined;
+  if (response?.success === false) throw new Error(response.message ?? "tsserver request failed");
+
+  const body = response && "body" in response ? response.body : value;
+  if (!Array.isArray(body)) return [];
+  return body.filter(isTsserverDiagnostic);
+}
+
+function tsserverCategoryToSeverity(category: string | number | undefined): NonNullable<Diagnostic["severity"]> {
+  if (category === "error" || category === 1) return 1;
+  if (category === "warning" || category === 0) return 2;
+  if (category === "message" || category === 3) return 3;
+  if (category === "suggestion" || category === 2) return 4;
+  return 1;
+}
+
+function positionAtOffset(text: string, offset: number): { line: number; character: number } {
+  const safeOffset = Math.max(0, Math.min(text.length, offset));
+  let line = 0;
+  let lineStart = 0;
+  for (let i = 0; i < safeOffset; i += 1) {
+    if (text.charCodeAt(i) === 10) {
+      line += 1;
+      lineStart = i + 1;
+    }
+  }
+  return { line, character: safeOffset - lineStart };
+}
+
+function tsserverLocationToPosition(location: TsserverLocation | undefined): { line: number; character: number } | undefined {
+  if (typeof location?.line !== "number" || typeof location.offset !== "number") return undefined;
+  return {
+    line: Math.max(0, location.line - 1),
+    character: Math.max(0, location.offset - 1),
+  };
+}
+
+function tsserverDiagnosticRange(diagnostic: TsserverDiagnostic, text: string): Diagnostic["range"] {
+  if (isRecord(diagnostic.start)) {
+    const start = tsserverLocationToPosition(diagnostic.start);
+    if (start) return { start, end: tsserverLocationToPosition(diagnostic.end) ?? start };
+  }
+
+  if (typeof diagnostic.start === "number") {
+    const startOffset = Math.max(0, diagnostic.start - 1);
+    const length = typeof diagnostic.length === "number" ? Math.max(0, diagnostic.length) : 0;
+    return {
+      start: positionAtOffset(text, startOffset),
+      end: positionAtOffset(text, startOffset + length),
+    };
+  }
+
+  const start = { line: 0, character: 0 };
+  return { start, end: start };
+}
+
+export function tsserverDiagnosticToLsp(diagnostic: TsserverDiagnostic, text: string): Diagnostic {
+  return {
+    range: tsserverDiagnosticRange(diagnostic, text),
+    severity: tsserverCategoryToSeverity(diagnostic.category),
+    source: diagnostic.source ?? "typescript",
+    message: tsserverMessageText(diagnostic.text ?? diagnostic.message),
+    code: diagnostic.code,
+  };
+}

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

@@ -0,0 +1,15 @@
+import type { LspServerConfig } from "./_shared/types";
+
+export interface MatchedServer {
+  server: LspServerConfig;
+  root: string;
+  relFile: string;
+}
+
+export interface OpenDocument {
+  file: string;
+  uri: string;
+  languageId: string;
+  version: number;
+  text: string;
+}