@mrclrchtr/supi-code-intelligence 0.1.0

package/node_modules/@mrclrchtr/supi-lsp/src/search-fallback.ts

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface GrepMatch {
+  file: string;
+  line: number;
+  text: string;
+}
+
+const IGNORE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "tmp",
+  ".pnpm",
+]);
+
+const SOURCE_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".java",
+  ".kt",
+  ".swift",
+  ".rb",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+]);
+
+/** Simple recursive text search in project source files. */
+export function fallbackGrep(projectRoot: string, query: string): GrepMatch[] {
+  const results: GrepMatch[] = [];
+  walk(projectRoot, projectRoot, query, results);
+  return results;
+}
+
+function walk(dir: string, projectRoot: string, query: string, results: GrepMatch[]): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!IGNORE_DIRS.has(entry.name)) {
+        walk(path.join(dir, entry.name), projectRoot, query, results);
+      }
+      continue;
+    }
+
+    if (!entry.isFile() || !SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+      continue;
+    }
+
+    const filePath = path.join(dir, entry.name);
+    searchFile(filePath, projectRoot, query, results);
+    if (results.length >= 20) return;
+  }
+}
+
+function searchFile(
+  filePath: string,
+  projectRoot: string,
+  query: string,
+  results: GrepMatch[],
+): void {
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(query)) {
+      results.push({
+        file: path.relative(projectRoot, filePath),
+        line: i + 1,
+        text: lines[i].trim(),
+      });
+      if (results.length >= 20) return;
+    }
+  }
+}

package/node_modules/@mrclrchtr/supi-lsp/src/service-registry.ts

@@ -0,0 +1,153 @@
+// Shared session-scoped LSP service registry.
+// Peer extensions can import `getSessionLspService` from the package root
+// to reuse the active LSP runtime without starting duplicate servers.
+
+import * as path from "node:path";
+import type { LspManager } from "./manager/manager.ts";
+import type {
+  Diagnostic,
+  DocumentSymbol,
+  Hover,
+  Location,
+  LocationLink,
+  Position,
+  ProjectServerInfo,
+  SymbolInformation,
+  WorkspaceSymbol,
+} from "./types.ts";
+
+export type SessionLspServiceState =
+  | { kind: "ready"; service: SessionLspService }
+  | { kind: "pending" }
+  | { kind: "disabled" }
+  | { kind: "unavailable"; reason: string };
+
+/**
+ * Public wrapper around {@link LspManager} that exposes stable semantic operations.
+ * File path inputs may be absolute or session-cwd-relative; a leading `@` is stripped
+ * to match pi's built-in path-tool convention.
+ */
+export class SessionLspService {
+  constructor(private readonly manager: LspManager) {}
+
+  // ── Semantic lookups ────────────────────────────────────────────────
+
+  async hover(filePath: string, position: Position): Promise<Hover | null> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    const client = await this.manager.ensureFileOpen(resolvedPath);
+    if (!client) return null;
+    return client.hover(resolvedPath, position);
+  }
+
+  async definition(
+    filePath: string,
+    position: Position,
+  ): Promise<Location | Location[] | LocationLink[] | null> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    const client = await this.manager.ensureFileOpen(resolvedPath);
+    if (!client) return null;
+    return client.definition(resolvedPath, position);
+  }
+
+  async references(filePath: string, position: Position): Promise<Location[] | null> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    const client = await this.manager.ensureFileOpen(resolvedPath);
+    if (!client) return null;
+    return client.references(resolvedPath, position);
+  }
+
+  async implementation(
+    filePath: string,
+    position: Position,
+  ): Promise<Location | Location[] | LocationLink[] | null> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    const client = await this.manager.ensureFileOpen(resolvedPath);
+    if (!client) return null;
+    return client.implementation(resolvedPath, position);
+  }
+
+  async documentSymbols(filePath: string): Promise<DocumentSymbol[] | SymbolInformation[] | null> {
+    const resolvedPath = this.resolveFilePath(filePath);
+    const client = await this.manager.ensureFileOpen(resolvedPath);
+    if (!client) return null;
+    return client.documentSymbols(resolvedPath);
+  }
+
+  async workspaceSymbol(query: string): Promise<SymbolInformation[] | WorkspaceSymbol[] | null> {
+    return this.manager.workspaceSymbol(query);
+  }
+
+  // ── Project / runtime awareness ─────────────────────────────────────
+
+  getProjectServers(): ProjectServerInfo[] {
+    return this.manager.getKnownProjectServers([]);
+  }
+
+  isSupportedSourceFile(filePath: string): boolean {
+    return this.manager.isSupportedSourceFile(this.resolveFilePath(filePath));
+  }
+
+  // ── Diagnostics ─────────────────────────────────────────────────────
+
+  getOutstandingDiagnostics(
+    maxSeverity: number = 1,
+  ): Array<{ file: string; diagnostics: Diagnostic[] }> {
+    return this.manager.getOutstandingDiagnostics(maxSeverity);
+  }
+
+  getOutstandingDiagnosticSummary(
+    maxSeverity: number = 1,
+  ): import("./manager/manager-types.ts").OutstandingDiagnosticSummaryEntry[] {
+    return this.manager.getOutstandingDiagnosticSummary(maxSeverity);
+  }
+
+  /** Access the underlying manager for advanced use cases (discouraged). */
+  getManager(): LspManager {
+    return this.manager;
+  }
+
+  private resolveFilePath(filePath: string): string {
+    const normalizedPath = filePath.startsWith("@") ? filePath.slice(1) : filePath;
+    return path.resolve(this.manager.getCwd(), normalizedPath);
+  }
+}
+
+// ── Registry ──────────────────────────────────────────────────────────
+
+const REGISTRY_KEY = Symbol.for("@mrclrchtr/supi-lsp/session-registry");
+
+function getRegistry(): Map<string, SessionLspServiceState> {
+  const globalScope = globalThis as typeof globalThis & Record<symbol, unknown>;
+  const existing = globalScope[REGISTRY_KEY];
+  if (existing instanceof Map) return existing as Map<string, SessionLspServiceState>;
+
+  const registry = new Map<string, SessionLspServiceState>();
+  globalScope[REGISTRY_KEY] = registry;
+  return registry;
+}
+
+function normalizeCwd(cwd: string): string {
+  return path.resolve(cwd);
+}
+
+const registry = getRegistry();
+
+/** Publish the LSP service state for a session cwd. */
+export function setSessionLspServiceState(cwd: string, state: SessionLspServiceState): void {
+  registry.set(normalizeCwd(cwd), state);
+}
+
+/** Acquire the LSP service state for a session cwd. */
+export function getSessionLspService(cwd: string): SessionLspServiceState {
+  return (
+    registry.get(normalizeCwd(cwd)) ?? {
+      kind: "unavailable",
+      reason: "No LSP session initialized for this workspace",
+    }
+  );
+}
+
+/** Remove the LSP service state for a session cwd. */
+export function clearSessionLspService(cwd: string): void {
+  registry.delete(normalizeCwd(cwd));
+}

package/node_modules/@mrclrchtr/supi-lsp/src/settings-registration.ts

@@ -0,0 +1,292 @@
+// LSP settings registration for the supi settings registry.
+
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
+import { Container, Key, matchesKey, SettingsList, Text } from "@earendil-works/pi-tui";
+import {
+  loadSupiConfig,
+  loadSupiConfigForScope,
+  registerConfigSettings,
+} from "@mrclrchtr/supi-core";
+import { loadConfig } from "./config.ts";
+
+// ── Types ────────────────────────────────────────────────────
+
+export interface LspSettings {
+  enabled: boolean;
+  severity: number;
+  active: string[];
+  exclude: string[];
+}
+
+const LSP_DEFAULTS: LspSettings = {
+  enabled: true,
+  severity: 1,
+  active: [],
+  exclude: [],
+};
+
+// ── Config helpers ───────────────────────────────────────────
+
+export function loadLspSettings(cwd: string, homeDir?: string): LspSettings {
+  return loadSupiConfig("lsp", cwd, LSP_DEFAULTS, { homeDir });
+}
+
+/**
+ * Return a user-facing message that indicates which config scope disabled LSP.
+ */
+export function getLspDisabledMessage(cwd: string, homeDir?: string): string {
+  const global = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "global", homeDir });
+  const project = loadSupiConfigForScope("lsp", cwd, LSP_DEFAULTS, { scope: "project", homeDir });
+
+  if (project.enabled === false) {
+    return "LSP is disabled in project settings (.pi/supi/config.json)";
+  }
+  if (global.enabled === false) {
+    return "LSP is disabled in global settings (~/.pi/agent/supi/config.json)";
+  }
+  return "LSP is disabled in settings";
+}
+
+function severityLabel(severity: number): string {
+  switch (severity) {
+    case 1:
+      return "errors";
+    case 2:
+      return "warnings";
+    case 3:
+      return "info";
+    case 4:
+      return "hints";
+    default:
+      return "errors";
+  }
+}
+
+// ── Settings registration ────────────────────────────────────
+
+export function registerLspSettings(): void {
+  registerConfigSettings({
+    id: "lsp",
+    label: "LSP",
+    section: "lsp",
+    defaults: LSP_DEFAULTS,
+    buildItems: (settings, scope, cwd) => buildLspSettingItems(settings, scope, cwd),
+    // biome-ignore lint/complexity/useMaxParams: ConfigSettingsOptions interface callback
+    persistChange: (_scope, _cwd, settingId, value, helpers) => {
+      handlePersistChange(settingId, value, helpers);
+    },
+  });
+}
+
+function handlePersistChange(
+  settingId: string,
+  value: string,
+  helpers: { set: (key: string, value: unknown) => void; unset: (key: string) => void },
+): void {
+  switch (settingId) {
+    case "enabled":
+      helpers.set("enabled", value === "on");
+      break;
+    case "severity": {
+      const num = Number.parseInt(value.split(" ")[0] ?? "1", 10);
+      helpers.set("severity", Number.isNaN(num) ? 1 : num);
+      break;
+    }
+    case "active": {
+      const active = value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+      if (active.length > 0) {
+        helpers.set("active", active);
+      } else {
+        helpers.unset("active");
+      }
+      break;
+    }
+    case "exclude": {
+      const patterns = value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+      if (patterns.length > 0) {
+        helpers.set("exclude", patterns);
+      } else {
+        helpers.unset("exclude");
+      }
+      break;
+    }
+  }
+}
+
+function buildLspSettingItems(
+  settings: LspSettings,
+  scope: "project" | "global",
+  cwd: string,
+): SettingItem[] {
+  return [
+    {
+      id: "enabled",
+      label: "Enable LSP",
+      description: "Enable or disable all LSP functionality",
+      currentValue: settings.enabled ? "on" : "off",
+      values: ["on", "off"],
+    },
+    {
+      id: "severity",
+      label: "Inline Severity",
+      description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
+      currentValue: `${settings.severity} (${severityLabel(settings.severity)})`,
+      values: ["1 (errors)", "2 (warnings)", "3 (info)", "4 (hints)"],
+    },
+    {
+      id: "active",
+      label: "Active Servers",
+      description: "Press Enter to configure which language servers are active",
+      currentValue: settings.active.length > 0 ? settings.active.join(", ") : "all",
+      submenu: (_currentValue, done) => createServerSubmenu(scope, cwd, settings, done),
+    },
+    {
+      id: "exclude",
+      label: "Exclude Patterns",
+      description:
+        "Gitignore patterns to suppress LSP diagnostics (e.g. __tests__/, *.generated.ts)",
+      currentValue: settings.exclude.length > 0 ? settings.exclude.join(", ") : "none",
+      submenu: (_currentValue, done) => createExcludeSubmenu(scope, cwd, settings, done),
+    },
+  ];
+}
+
+// ── Server submenu ───────────────────────────────────────────
+
+function createServerSubmenu(
+  _scope: "project" | "global",
+  cwd: string,
+  settings: LspSettings,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const config = loadConfig(cwd);
+  const allServers = Object.keys(config.servers);
+  const allEnabled = settings.active.length === 0;
+  const enabledServers = new Set(settings.active);
+
+  const items: SettingItem[] = allServers.map((name) => ({
+    id: name,
+    label: name,
+    currentValue: allEnabled || enabledServers.has(name) ? "enabled" : "disabled",
+    values: ["enabled", "disabled"],
+  }));
+
+  let dirty = false;
+
+  const container = new Container();
+  const header = new Text("Active Servers — all enabled by default", 0, 0);
+  container.addChild(header);
+
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 2, 15),
+    getSettingsListTheme(),
+    (id, newValue) => {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx >= 0 && items[idx].currentValue !== newValue) {
+        dirty = true;
+        items[idx].currentValue = newValue;
+      }
+    },
+    () => {
+      // Escape on inner SettingsList — no-op, handled by submenu wrapper
+    },
+    { enableSearch: true },
+  );
+
+  container.addChild(settingsList);
+
+  return {
+    render: (width: number) => container.render(width),
+    invalidate: () => container.invalidate(),
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        if (!dirty) {
+          done();
+          return true;
+        }
+        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
+        done(enabled.join(", ") || undefined);
+        return true;
+      }
+      settingsList.handleInput?.(data);
+      return true;
+    },
+  };
+}
+
+// ── Exclude patterns submenu ─────────────────────────────────
+
+function createExcludeSubmenu(
+  _scope: "project" | "global",
+  _cwd: string,
+  settings: LspSettings,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const items: SettingItem[] = settings.exclude.map((pattern) => ({
+    id: pattern,
+    label: pattern,
+    currentValue: "enabled",
+    values: ["enabled", "disabled"],
+  }));
+
+  let dirty = false;
+
+  const container = new Container();
+  const header = new Text("Exclude Patterns — toggle off to remove", 0, 0);
+  container.addChild(header);
+
+  const footer = new Text("Add new patterns in .pi/supi/config.json under lsp.exclude", 0, 0);
+  container.addChild(footer);
+
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 3, 15),
+    getSettingsListTheme(),
+    (id, newValue) => {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx >= 0 && items[idx].currentValue !== newValue) {
+        dirty = true;
+        items[idx].currentValue = newValue;
+      }
+    },
+    () => {
+      // Escape on inner SettingsList — no-op, handled by submenu wrapper
+    },
+  );
+
+  container.addChild(settingsList);
+
+  return {
+    render: (width: number) => container.render(width),
+    invalidate: () => container.invalidate(),
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        if (!dirty) {
+          done();
+          return true;
+        }
+        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
+        done(enabled.join(", ") || undefined);
+        return true;
+      }
+      settingsList.handleInput?.(data);
+      return true;
+    },
+  };
+}

package/node_modules/@mrclrchtr/supi-lsp/src/summary.ts

@@ -0,0 +1,153 @@
+import * as path from "node:path";
+import type {
+  ActiveCoverageSummaryEntry,
+  OutstandingDiagnosticSummaryEntry,
+} from "./manager/manager-types.ts";
+
+/**
+ * Display form for a file path used both for human-readable LSP output and as
+ * the diagnostic key. In-tree paths return the project-relative form; out-of-
+ * tree paths preserve the absolute path so files in sibling worktrees or
+ * monorepo packages don't collapse to a basename — that collapse used to make
+ * unrelated files with the same name appear interchangeable in relevance
+ * matching, and it broke diagnostic correlation for tracked external paths.
+ */
+export function displayRelativeFilePath(filePath: string, cwd: string): string {
+  const absolutePath = path.resolve(cwd, filePath);
+  const relativePath = path.relative(cwd, absolutePath);
+  if (relativePath === "") return path.basename(absolutePath);
+  if (relativePath.startsWith(`..${path.sep}`) || relativePath === "..") {
+    return absolutePath;
+  }
+  return relativePath;
+}
+
+export function formatCoverageSummaryText(
+  entries: ActiveCoverageSummaryEntry[],
+  maxServers: number,
+  maxFiles: number,
+): string | null {
+  if (entries.length === 0) return null;
+
+  const visible = entries.slice(0, maxServers);
+  const parts = visible.map(
+    (entry) => `${entry.name} (${formatOpenFiles(entry.openFiles, maxFiles)})`,
+  );
+  const remaining = entries.length - visible.length;
+  const suffix =
+    remaining > 0 ? `; +${remaining} more ${remaining === 1 ? "server" : "servers"}` : "";
+
+  return `Active LSP coverage: ${parts.join("; ")}${suffix}.`;
+}
+
+export function formatOutstandingDiagnosticsSummaryText(
+  entries: OutstandingDiagnosticSummaryEntry[],
+  maxFiles: number,
+): string | null {
+  if (entries.length === 0) return null;
+
+  const visible = entries.slice(0, maxFiles);
+  const parts = visible.map((entry) => `${entry.file} (${formatDiagnosticCounts(entry)})`);
+  const remaining = entries.length - visible.length;
+  const suffix = remaining > 0 ? `; +${remaining} more ${remaining === 1 ? "file" : "files"}` : "";
+
+  return `Outstanding LSP diagnostics: ${parts.join("; ")}${suffix}.`;
+}
+
+export function normalizeRelevantPaths(relevantPaths: string[]): string[] {
+  return Array.from(new Set(relevantPaths.map(normalizeRelevantPath).filter(Boolean)));
+}
+
+/**
+ * Match a file against caller-supplied relevance hints. Hints come from prompt
+ * tokens and recent tool paths, so they're heterogeneous: full relative paths,
+ * directory names, or bare filenames. Matching modes:
+ *  - exact path match
+ *  - candidate contains "/": treat as a directory prefix (`lsp/foo` ⊂ `lsp/foo/...`)
+ *  - candidate has no "/" and no ".": treat as a directory name anywhere in the path
+ *  - otherwise: treat as a filename and match the basename
+ */
+export function isPathRelevant(filePath: string, relevantPaths: string[], cwd: string): boolean {
+  const normalizedFilePath = normalizeRelevantPath(filePath);
+  if (shouldIgnoreLspPath(normalizedFilePath, cwd)) return false;
+
+  return relevantPaths.some((candidate) => {
+    if (normalizedFilePath === candidate) return true;
+    if (candidate.includes("/")) return normalizedFilePath.startsWith(`${candidate}/`);
+    if (!candidate.includes(".")) {
+      return (
+        normalizedFilePath.startsWith(`${candidate}/`) ||
+        normalizedFilePath.includes(`/${candidate}/`)
+      );
+    }
+    return path.basename(normalizedFilePath) === candidate;
+  });
+}
+
+import { isFileExcludedByTsconfig } from "./tsconfig-scope.ts";
+
+/** Check whether a file path is inside the project tree (within cwd, not node_modules/.pnpm/out-of-tree).
+ *  Does NOT check tsconfig exclusion — use `shouldIgnoreLspPath` for diagnostics/guidance filtering. */
+export function isInProjectTree(filePath: string, cwd: string): boolean {
+  const normalized = normalizeRelevantPath(filePath);
+  if (
+    normalized === "node_modules" ||
+    normalized.startsWith("node_modules/") ||
+    normalized.includes("/node_modules/") ||
+    normalized === ".pnpm" ||
+    normalized.startsWith(".pnpm/") ||
+    normalized.includes("/.pnpm/")
+  ) {
+    return false;
+  }
+
+  const absolutePath = path.resolve(cwd, filePath);
+  const relativePath = path.relative(cwd, absolutePath);
+  return !(relativePath.startsWith(`..${path.sep}`) || relativePath === "..");
+}
+
+/** Check whether a file path is inside the current project (not ignored and within cwd). */
+export function isProjectSource(filePath: string, cwd: string): boolean {
+  return isInProjectTree(filePath, cwd);
+}
+
+export function shouldIgnoreLspPath(filePath: string, cwd: string): boolean {
+  const normalized = normalizeRelevantPath(filePath);
+  if (
+    normalized === "node_modules" ||
+    normalized.startsWith("node_modules/") ||
+    normalized.includes("/node_modules/") ||
+    normalized === ".pnpm" ||
+    normalized.startsWith(".pnpm/") ||
+    normalized.includes("/.pnpm/") ||
+    isFileExcludedByTsconfig(normalized, cwd)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function normalizeRelevantPath(filePath: string): string {
+  return filePath.replaceAll("\\", "/").replace(/\/$/, "").trim();
+}
+
+function formatOpenFiles(openFiles: string[], maxFiles: number): string {
+  const visible = openFiles.slice(0, maxFiles);
+  const remaining = openFiles.length - visible.length;
+  const suffix = remaining > 0 ? `, +${remaining} more` : "";
+  return `${pluralize(openFiles.length, "open file")}: ${visible.join(", ")}${suffix}`;
+}
+
+function formatDiagnosticCounts(entry: OutstandingDiagnosticSummaryEntry): string {
+  const counts: string[] = [];
+  if (entry.errors > 0) counts.push(pluralize(entry.errors, "error"));
+  if (entry.warnings > 0) counts.push(pluralize(entry.warnings, "warning"));
+  if (entry.information > 0) counts.push(pluralize(entry.information, "info"));
+  if (entry.hints > 0) counts.push(pluralize(entry.hints, "hint"));
+  return counts.join(", ");
+}
+
+function pluralize(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}