@mrclrchtr/supi-lsp 0.1.0 → 1.1.2

package/src/overrides.ts

@@ -0,0 +1,173 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createEditTool, createReadTool, createWriteTool } from "@earendil-works/pi-coding-agent";
+import { augmentDiagnostics } from "./diagnostics/diagnostic-augmentation.ts";
+import { formatGroupedDiagnostics } from "./diagnostics/diagnostics.ts";
+import { splitSuppressionDiagnostics } from "./diagnostics/suppression-diagnostics.ts";
+import type { LspManager } from "./manager/manager.ts";
+import type { Diagnostic } from "./types.ts";
+
+interface LspOverrideState {
+  getInlineSeverity(): number;
+  getManager(): LspManager | null;
+  getCwd(): string;
+}
+
+export function registerLspAwareToolOverrides(pi: ExtensionAPI, state: LspOverrideState): void {
+  const readMeta = createReadTool(process.cwd());
+  const writeMeta = createWriteTool(process.cwd());
+  const editMeta = createEditTool(process.cwd());
+
+  pi.registerTool({
+    ...readMeta,
+    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+    async execute(toolCallId, params, signal, onUpdate, _ctx) {
+      const cwd = state.getCwd();
+      const originalRead = createReadTool(cwd);
+      const result = await originalRead.execute(toolCallId, params, signal, onUpdate);
+      await ensureFileOpen(state.getManager(), params.path);
+      return result;
+    },
+  });
+
+  pi.registerTool({
+    ...writeMeta,
+    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+    async execute(toolCallId, params, signal, onUpdate, _ctx) {
+      const cwd = state.getCwd();
+      const originalWrite = createWriteTool(cwd);
+      const result = await originalWrite.execute(toolCallId, params, signal, onUpdate);
+      return appendInlineDiagnostics({
+        manager: state.getManager(),
+        filePath: params.path,
+        inlineSeverity: state.getInlineSeverity(),
+        cwd,
+        result,
+      });
+    },
+  });
+
+  pi.registerTool({
+    ...editMeta,
+    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
+    async execute(toolCallId, params, signal, onUpdate, _ctx) {
+      const cwd = state.getCwd();
+      const originalEdit = createEditTool(cwd);
+      const result = await originalEdit.execute(toolCallId, params, signal, onUpdate);
+      return appendInlineDiagnostics({
+        manager: state.getManager(),
+        filePath: params.path,
+        inlineSeverity: state.getInlineSeverity(),
+        cwd,
+        result,
+      });
+    },
+  });
+}
+
+interface AppendInlineDiagnosticsOptions<T extends { content: unknown[]; details: unknown }> {
+  manager: LspManager | null;
+  filePath: string;
+  inlineSeverity: number;
+  cwd: string;
+  result: T;
+}
+
+async function appendInlineDiagnostics<T extends { content: unknown[]; details: unknown }>(
+  options: AppendInlineDiagnosticsOptions<T>,
+): Promise<T> {
+  if (!options.manager) return options.result;
+
+  try {
+    const effectiveSeverity = Math.max(options.inlineSeverity, 2);
+    const entries = await options.manager.syncFileAndGetCascadingDiagnostics(
+      options.filePath,
+      effectiveSeverity,
+    );
+    if (entries.length === 0) return options.result;
+
+    const primaryDiagnostics =
+      entries.find((entry) => entry.file === options.filePath)?.diagnostics ?? [];
+    const augmentation = await augmentDiagnostics(
+      options.filePath,
+      splitSuppressionDiagnostics(primaryDiagnostics, options.inlineSeverity).regular,
+      options.manager,
+      options.cwd,
+    );
+    const diagText = buildInlineDiagnosticsMessage(
+      entries,
+      options.cwd,
+      options.inlineSeverity,
+      augmentation ?? undefined,
+    );
+    if (!diagText) return options.result;
+
+    const diagnosticContent = {
+      type: "text" as const,
+      text: `\n\n${diagText}`,
+    } as T["content"][number];
+
+    return {
+      ...options.result,
+      content: [...options.result.content, diagnosticContent],
+    } as T;
+  } catch {
+    return options.result;
+  }
+}
+
+export function buildInlineDiagnosticsMessage(
+  entries: Array<{ file: string; diagnostics: Diagnostic[] }>,
+  cwd: string,
+  inlineSeverity: number = 1,
+  augmentation?: string,
+): string | null {
+  const regularEntries: Array<{ file: string; diagnostics: Diagnostic[] }> = [];
+  const suppressionEntries: Array<{ file: string; diagnostics: Diagnostic[] }> = [];
+
+  for (const entry of entries) {
+    const { regular, suppressions } = splitSuppressionDiagnostics(
+      entry.diagnostics,
+      inlineSeverity,
+    );
+    if (regular.length > 0) {
+      regularEntries.push({ file: entry.file, diagnostics: regular });
+    }
+    if (suppressions.length > 0) {
+      suppressionEntries.push({ file: entry.file, diagnostics: suppressions });
+    }
+  }
+
+  if (regularEntries.length === 0 && suppressionEntries.length === 0) {
+    return null;
+  }
+
+  const sections = ["⚠️ LSP Diagnostics — review before continuing:"];
+
+  if (regularEntries.length > 0) {
+    sections.push(formatGroupedDiagnostics(regularEntries, cwd));
+    if (augmentation) {
+      sections.push(augmentation);
+    }
+  }
+
+  if (suppressionEntries.length > 0) {
+    sections.push(
+      `🗑️ Stale suppressions — cleanup available:\n${formatGroupedDiagnostics(suppressionEntries, cwd)}`,
+    );
+  }
+
+  sections.push(
+    "If these errors are unexpected or appear across multiple files, fix the root cause before editing more files.",
+  );
+  return sections.join("\n\n");
+}
+
+async function ensureFileOpen(manager: LspManager | null, filePath: string): Promise<void> {
+  if (!manager) return;
+
+  try {
+    await manager.ensureFileOpen(filePath);
+  } catch {
+    // Never block the agent on LSP errors
+  }
+}

package/src/pattern-matcher.ts

@@ -0,0 +1,197 @@
+/** Gitignore-style glob pattern matching for path exclusion.
+ *
+ * Supports:
+ *  - Literal names at any depth: __tests__, build
+ *  - Trailing slash directory-only: __tests__ + "/"
+ *  - Leading slash root-anchored: "/" + build
+ *  - Stars-star-slash recursive: e.g. `**` + "/" + fixtures
+ *  - Asterisk single-segment wildcard: *.generated.ts
+ *  - Literal paths: packages + "/" + legacy
+ */
+
+/**
+ * Normalize path separators to forward slashes and trim.
+ */
+function normalize(p: string): string {
+  return p.replaceAll("\\", "/").trim();
+}
+
+/**
+ * Check whether a project-relative file path matches a gitignore-style glob pattern.
+ *
+ * @param filePath - Relative file path with forward slashes (e.g. `"src/__tests__/bar.test.ts"`)
+ * @param pattern - Gitignore-style glob pattern (e.g. `"__tests__/"`, `"*.test.ts"`, `"/build"`)
+ * @returns `true` if the file path matches the pattern
+ */
+export function isGlobMatch(filePath: string, pattern: string): boolean {
+  const fp = normalize(filePath);
+  const pat = normalize(pattern);
+  if (!fp || !pat) return false;
+
+  // Leading / → anchored to root
+  const anchored = pat.startsWith("/");
+  const noLeadingSlash = anchored ? pat.slice(1) : pat;
+
+  // Trailing / → directory-only
+  const dirOnly = noLeadingSlash.endsWith("/");
+  const cleanPat = dirOnly ? noLeadingSlash.slice(0, -1) : noLeadingSlash;
+
+  if (!cleanPat) return false;
+
+  return matchGlob(fp, cleanPat, { anchored, dirOnly });
+}
+
+interface MatchOptions {
+  anchored: boolean;
+  dirOnly: boolean;
+}
+
+/**
+ * Core recursive pattern matching against a multi-segment path.
+ */
+function matchGlob(filePath: string, pattern: string, opts: MatchOptions): boolean {
+  // Direct match
+  if (!opts.anchored && !opts.dirOnly && filePath === pattern) return true;
+
+  // Split into segments
+  const pathSegments = filePath.split("/");
+  const patternSegments = pattern.split("/");
+
+  // ** recursive glob
+  if (pattern.startsWith("**/")) {
+    const suffix = pattern.slice(3);
+    return (
+      matchGlob(filePath, suffix, { ...opts, anchored: false }) ||
+      starStarMatch(pathSegments, suffix)
+    );
+  }
+
+  // prefix/**/suffix bounded recursive glob
+  const dstarIdx = pattern.indexOf("/**/");
+  if (dstarIdx !== -1) {
+    const prefix = pattern.slice(0, dstarIdx);
+    const suffix = pattern.slice(dstarIdx + 4);
+    return matchBoundedStar(pathSegments, prefix, suffix);
+  }
+
+  // Single-segment patterns
+  if (patternSegments.length === 1 && !opts.anchored) {
+    return matchSingleSegment(pathSegments, patternSegments[0], opts.dirOnly);
+  }
+
+  // Multi-segment: anchored or unanchored
+  if (opts.anchored) {
+    return matchSegments(pathSegments, patternSegments, opts.dirOnly);
+  }
+
+  // Unanchored multi-segment: try at each starting position
+  return matchUnanchoredSegments(pathSegments, patternSegments, opts.dirOnly);
+}
+
+/**
+ * Match a ** recursive suffix across directory levels.
+ */
+function starStarMatch(segments: string[], suffix: string): boolean {
+  for (let i = 0; i < segments.length; i++) {
+    const remaining = segments.slice(i).join("/");
+    if (matchGlob(remaining, suffix, { anchored: false, dirOnly: false })) return true;
+  }
+  return false;
+}
+
+/** Match prefix plus star-star-slash plus suffix bounded recursive pattern. */
+function matchBoundedStar(segments: string[], prefix: string, suffix: string): boolean {
+  // Try to find a split point where left matches prefix and right matches suffix
+  for (let i = 1; i < segments.length; i++) {
+    const left = segments.slice(0, i).join("/");
+    const right = segments.slice(i).join("/");
+    if (
+      matchGlob(left, prefix, { anchored: false, dirOnly: false }) &&
+      matchGlob(right, suffix, { anchored: false, dirOnly: false })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Match a single-segment pattern against path segments.
+ */
+function matchSingleSegment(segments: string[], patternSeg: string, dirOnly: boolean): boolean {
+  const hasGlob = patternSeg.includes("*") || patternSeg.includes("?");
+
+  if (hasGlob) {
+    // Glob pattern matches any segment
+    return segments.some((seg) => simpleMatch(seg, patternSeg));
+  }
+
+  // Literal segment name
+  if (dirOnly) {
+    // Match as directory: any segment except the last (file) one
+    return segments.slice(0, -1).some((seg) => seg === patternSeg);
+  }
+
+  // Match any segment (file or directory)
+  return segments.some((seg) => seg === patternSeg);
+}
+
+/**
+ * Try to match multi-segment pattern at each start position.
+ */
+function matchUnanchoredSegments(segments: string[], pattern: string[], dirOnly: boolean): boolean {
+  for (let i = 0; i < segments.length; i++) {
+    if (matchSegments(segments.slice(i), pattern, dirOnly)) return true;
+  }
+  return false;
+}
+
+/** Match segments from start. Returns true if all pattern segments match contiguously. */
+function matchSegments(segments: string[], pattern: string[], dirOnly: boolean): boolean {
+  if (pattern.length > segments.length) return false;
+
+  for (let i = 0; i < pattern.length; i++) {
+    if (!matchSegmentAtIndex(segments, pattern, i)) return false;
+  }
+
+  // dirOnly: last matched segment must not be the last path segment
+  if (dirOnly && pattern.length === segments.length) return false;
+
+  return true;
+}
+
+/** Match a single pattern segment against the corresponding path segment. */
+function matchSegmentAtIndex(segments: string[], pattern: string[], index: number): boolean {
+  const patSeg = pattern[index];
+  const pathSeg = segments[index];
+
+  if (patSeg === "**") {
+    // ** at end matches all remaining segments
+    if (index === pattern.length - 1) return true;
+    // Try rest of pattern from various positions
+    for (let j = index; j < segments.length; j++) {
+      if (matchSegments(segments.slice(j), pattern.slice(index + 1), false)) return true;
+    }
+    return false;
+  }
+
+  return simpleMatch(pathSeg, patSeg);
+}
+
+/**
+ * Match a single path segment against a single pattern segment.
+ * Supports `*` (any chars except `/`) and `?` (single char).
+ */
+function simpleMatch(segment: string, pattern: string): boolean {
+  if (pattern === "*") return true;
+  if (pattern === segment) return true;
+  if (!pattern.includes("*") && !pattern.includes("?")) return false;
+
+  // Convert pattern to simple regex
+  const regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, "[^/]*")
+    .replace(/\?/g, "[^/]");
+
+  return new RegExp(`^${regexStr}$`).test(segment);
+}

package/src/renderer.ts

@@ -0,0 +1,120 @@
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+
+interface LspContextDetails {
+  contextToken?: string;
+  inlineSeverity?: number;
+  staleWarning?: string | null;
+  diagnostics?: Array<{
+    file: string;
+    errors: number;
+    warnings: number;
+    information: number;
+    hints: number;
+  }>;
+}
+
+type DiagnosticEntry = NonNullable<LspContextDetails["diagnostics"]>[number];
+type DiagnosticCounts = Pick<DiagnosticEntry, "errors" | "warnings" | "information" | "hints">;
+
+function formatDiagnosticCounts(
+  totals: DiagnosticCounts,
+  theme: { fg: (color: ThemeColor, text: string) => string },
+): string {
+  const parts: string[] = [];
+  if (totals.errors > 0)
+    parts.push(theme.fg("error", `${totals.errors} error${totals.errors === 1 ? "" : "s"}`));
+  if (totals.warnings > 0)
+    parts.push(
+      theme.fg("warning", `${totals.warnings} warning${totals.warnings === 1 ? "" : "s"}`),
+    );
+  if (totals.information > 0)
+    parts.push(
+      theme.fg("accent", `${totals.information} info${totals.information === 1 ? "" : "s"}`),
+    );
+  if (totals.hints > 0)
+    parts.push(theme.fg("dim", `${totals.hints} hint${totals.hints === 1 ? "" : "s"}`));
+  return parts.join(", ");
+}
+
+function hasDiagnosticCounts(totals: DiagnosticCounts): boolean {
+  return totals.errors > 0 || totals.warnings > 0 || totals.information > 0 || totals.hints > 0;
+}
+
+function buildLspContextCollapsed(
+  diagnostics: LspContextDetails["diagnostics"],
+  totals: DiagnosticCounts | undefined,
+  staleWarning: string | null | undefined,
+  theme: { fg: (color: ThemeColor, text: string) => string },
+): string {
+  const icon = theme.fg("accent", "\u{1F527}");
+  let summary: string;
+  if (!diagnostics || !totals) {
+    summary = `${icon} LSP diagnostics injected`;
+  } else if (!hasDiagnosticCounts(totals)) {
+    summary = `${icon} LSP diagnostics injected ${theme.fg("success", "\u2713")}`;
+  } else {
+    summary = `${icon} LSP diagnostics injected (${formatDiagnosticCounts(totals, theme)})`;
+  }
+
+  if (!staleWarning) return summary;
+  return `${summary}\n${theme.fg("warning", staleWarning)}`;
+}
+
+function formatFileDiagnosticEntry(d: DiagnosticCounts): string {
+  return formatDiagnosticCounts(d, { fg: (_color, text) => text });
+}
+
+function formatExpandedDetails(
+  diagnostics: LspContextDetails["diagnostics"],
+  token: string | undefined,
+  staleWarning: string | null | undefined,
+  theme: { fg: (color: ThemeColor, text: string) => string },
+): string {
+  const lines: string[] = [];
+  if (staleWarning) {
+    lines.push(theme.fg("warning", `  ${staleWarning}`));
+  }
+  if (diagnostics && diagnostics.length > 0) {
+    for (const d of diagnostics) {
+      lines.push(theme.fg("dim", `  ${d.file}: ${formatFileDiagnosticEntry(d)}`));
+    }
+  }
+  if (token) {
+    lines.push(theme.fg("dim", `  token: ${token}`));
+  }
+  return lines.join("\n");
+}
+
+export type { LspContextDetails };
+
+export function registerLspMessageRenderer(
+  pi: import("@earendil-works/pi-coding-agent").ExtensionAPI,
+): void {
+  pi.registerMessageRenderer("lsp-context", (message, { expanded }, theme) => {
+    const details = message.details as LspContextDetails | undefined;
+    const diagnostics = details?.diagnostics;
+    const token = details?.contextToken;
+
+    const totals = diagnostics?.reduce(
+      (acc, d) => ({
+        errors: acc.errors + d.errors,
+        warnings: acc.warnings + d.warnings,
+        information: acc.information + d.information,
+        hints: acc.hints + d.hints,
+      }),
+      { errors: 0, warnings: 0, information: 0, hints: 0 },
+    );
+
+    const staleWarning = details?.staleWarning;
+    const collapsed = buildLspContextCollapsed(diagnostics, totals, staleWarning, theme);
+    const expandedDetails = expanded
+      ? formatExpandedDetails(diagnostics, token, staleWarning, theme)
+      : "";
+    const fullText = expandedDetails ? `${collapsed}\n${expandedDetails}` : collapsed;
+
+    const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
+    box.addChild(new Text(fullText, 0, 0));
+    return box;
+  });
+}

package/src/scanner.ts

@@ -0,0 +1,153 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { dedupeTopmostRoots, walkProject } from "@mrclrchtr/supi-core";
+import type { LspManager } from "./manager/manager.ts";
+import type {
+  DetectedProjectServer,
+  LspConfig,
+  MissingServer,
+  ProjectServerInfo,
+  ServerConfig,
+} from "./types.ts";
+import { commandExists } from "./utils.ts";
+
+const DEFAULT_MAX_DEPTH = 3;
+
+export function scanProjectCapabilities(
+  config: LspConfig,
+  cwd: string,
+  maxDepth: number = DEFAULT_MAX_DEPTH,
+): DetectedProjectServer[] {
+  const { markerMatches, extensionBasedServers } = collectServerHints(config, cwd, maxDepth);
+
+  return Object.entries(config.servers)
+    .flatMap(([serverName, server]) => {
+      if (!commandExists(server.command)) return [];
+      const allRoots = new Set(markerMatches.get(serverName) ?? []);
+      if (extensionBasedServers.has(serverName)) {
+        allRoots.add(cwd);
+      }
+      const roots = dedupeTopmostRoots(Array.from(allRoots));
+      return roots.map(
+        (root) =>
+          ({
+            name: serverName,
+            root,
+            fileTypes: [...server.fileTypes],
+          }) satisfies DetectedProjectServer,
+      );
+    })
+    .sort((a, b) => a.root.localeCompare(b.root) || a.name.localeCompare(b.name));
+}
+
+/** Walk the project collecting marker matches and extension-based server hints. */
+function collectServerHints(
+  config: LspConfig,
+  cwd: string,
+  maxDepth: number,
+): { markerMatches: Map<string, Set<string>>; extensionBasedServers: Set<string> } {
+  const ctx: HintContext = { markerMatches: new Map(), extensionBasedServers: new Set() };
+
+  walkProject(cwd, maxDepth, (directory, entryNames) => {
+    inspectDirectory(directory, entryNames, config.servers, ctx);
+  });
+
+  return { markerMatches: ctx.markerMatches, extensionBasedServers: ctx.extensionBasedServers };
+}
+
+interface HintContext {
+  markerMatches: Map<string, Set<string>>;
+  extensionBasedServers: Set<string>;
+}
+
+/** Check one directory for server markers or matching file extensions. */
+function inspectDirectory(
+  directory: string,
+  entryNames: Set<string>,
+  servers: Record<string, ServerConfig>,
+  ctx: HintContext,
+): void {
+  for (const [serverName, server] of Object.entries(servers)) {
+    if (!commandExists(server.command)) continue;
+
+    if (server.rootMarkers.length === 0) {
+      if (hasMatchingFile(directory, entryNames, server.fileTypes)) {
+        ctx.extensionBasedServers.add(serverName);
+      }
+      continue;
+    }
+
+    if (!server.rootMarkers.some((marker) => entryNames.has(marker))) continue;
+
+    const matches = ctx.markerMatches.get(serverName) ?? new Set<string>();
+    matches.add(directory);
+    ctx.markerMatches.set(serverName, matches);
+  }
+}
+
+/** Check whether a directory contains a file with one of the target extensions. */
+function hasMatchingFile(directory: string, entryNames: Set<string>, fileTypes: string[]): boolean {
+  for (const name of entryNames) {
+    const ext = path.extname(name).slice(1).toLowerCase();
+    if (!fileTypes.includes(ext)) continue;
+    try {
+      if (!fs.statSync(path.join(directory, name)).isFile()) continue;
+    } catch {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+export async function startDetectedServers(
+  manager: LspManager,
+  detected: DetectedProjectServer[],
+): Promise<void> {
+  await Promise.all(detected.map((entry) => manager.startServerForRoot(entry.name, entry.root)));
+}
+
+export function introspectCapabilities(
+  manager: LspManager,
+  detected: DetectedProjectServer[],
+): ProjectServerInfo[] {
+  return manager.getKnownProjectServers(detected);
+}
+
+/**
+ * Scan the project for languages whose source files exist but whose LSP server
+ * binary is not installed on PATH. Walks the project directory tree collecting
+ * file extensions, then checks each configured server.
+ */
+export function scanMissingServers(
+  config: LspConfig,
+  cwd: string,
+  maxDepth: number = DEFAULT_MAX_DEPTH,
+): MissingServer[] {
+  const foundExtensions = new Set<string>();
+
+  walkProject(cwd, maxDepth, (directory, entryNames) => {
+    for (const name of entryNames) {
+      try {
+        if (!fs.statSync(path.join(directory, name)).isFile()) continue;
+      } catch {
+        continue;
+      }
+      const ext = path.extname(name).slice(1).toLowerCase();
+      if (ext) foundExtensions.add(ext);
+    }
+  });
+
+  const missing: MissingServer[] = [];
+
+  for (const [name, server] of Object.entries(config.servers)) {
+    if (commandExists(server.command)) continue;
+
+    const matching = server.fileTypes.filter((ft) => foundExtensions.has(ft));
+    if (matching.length === 0) continue;
+
+    missing.push({ name, command: server.command, foundExtensions: matching });
+  }
+
+  return missing;
+}