@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/substrate/lsp/diagnostic-injection.ts

@@ -1,203 +0,0 @@
-// Diagnostic injection handlers — before_agent_start and context for lsp-context messages.
-//
-// Ported from supi-lsp's diagnostic-injection.ts.
-
-import * as nodePath from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  clearTsconfigCache,
-  isLikelyStaleDiagnostic,
-  syncWorkspaceSentinelSnapshot,
-} from "@mrclrchtr/supi-lsp/api";
-import type { LspAdapterState } from "./state.ts";
-import { diagnosticMessageString } from "./utils.ts";
-
-export function registerDiagnosticInjectionHandlers(
-  pi: ExtensionAPI,
-  state: LspAdapterState,
-): void {
-  pi.on("before_agent_start", async (_event, _ctx: ExtensionContext) => {
-    const manager = state.controller?.manager;
-    if (!manager || !state.lspActive) {
-      return;
-    }
-
-    // Sentinel refresh: detect lockfile/tsconfig/d.ts changes from outside write/edit
-    applySentinelChanges(state, manager);
-
-    // Stale-module resync: force-reopen files with "Cannot find module" errors
-    await resyncStaleModuleFiles(state);
-
-    // Two-pass prune/refresh for diagnostics
-    manager.pruneMissingFiles();
-    try {
-      await manager.refreshOpenDiagnostics();
-    } catch {
-      /* best-effort */
-    }
-    manager.pruneMissingFiles();
-
-    const diagnostics = manager.getOutstandingDiagnosticSummary(state.inlineSeverity);
-    if (!diagnostics || diagnostics.length === 0) {
-      state.lastDiagnosticsFingerprint = null;
-      state.currentContextToken = null;
-      return;
-    }
-
-    state.currentContextToken = `lsp-context-${++state.contextCounter}`;
-
-    const detailedDiagnostics = manager
-      .getOutstandingDiagnostics(state.inlineSeverity)
-      .map((entry) => ({
-        file: entry.file,
-        diagnostics: entry.diagnostics.map((d) => ({
-          range: d.range,
-          message: diagnosticMessageString(d),
-        })),
-      }));
-
-    return {
-      message: {
-        customType: "lsp-context",
-        content: buildInjectionContent(diagnostics, detailedDiagnostics),
-        display: true,
-        details: {
-          contextToken: state.currentContextToken,
-          promptContent: buildInjectionContent(diagnostics),
-          inlineSeverity: state.inlineSeverity,
-          diagnostics: diagnostics.map(
-            (d: {
-              file: string;
-              errors: number;
-              warnings: number;
-              information: number;
-              hints: number;
-            }) => ({
-              file: d.file,
-              errors: d.errors,
-              warnings: d.warnings,
-              information: d.information,
-              hints: d.hints,
-            }),
-          ),
-        },
-      },
-    };
-  });
-
-  pi.on("context", (event, _ctx) => {
-    const messages = event.messages as unknown as Array<Record<string, unknown>>;
-    const token = state.currentContextToken;
-
-    const pruned = messages.filter((m) => {
-      if (m.customType !== "lsp-context") return true;
-      if (!token) return false;
-      const details = m.details as { contextToken?: string } | undefined;
-      return details?.contextToken === token;
-    });
-
-    if (pruned.length === event.messages.length) return;
-    return { messages: pruned as unknown as typeof event.messages };
-  });
-}
-
-/** Diff sentinel snapshot and notify manager of changes. */
-// biome-ignore lint/suspicious/noExplicitAny: callback accepts FileEvent[] which satisfies the structural type
-function applySentinelChanges(state: LspAdapterState, manager: any): void {
-  const controller = state.controller;
-  if (!controller) return;
-
-  const { snapshot, changes } = syncWorkspaceSentinelSnapshot(
-    controller.cwd,
-    state.sentinelSnapshot,
-  );
-  state.sentinelSnapshot = snapshot;
-
-  if (changes.length === 0) return;
-
-  clearTsconfigCache();
-  manager.clearAllPullResultIds();
-  manager.notifyWorkspaceFileChanges(changes);
-
-  state.staleSuspected = true;
-  state.lastDiagnosticsFingerprint = null;
-  state.currentContextToken = null;
-  state.lastWorkspaceChangeAt = Date.now();
-}
-
-/** Re-open files with stale module-resolution errors. */
-async function resyncStaleModuleFiles(state: LspAdapterState): Promise<void> {
-  const manager = state.controller?.manager;
-  if (!manager) return;
-
-  const outstanding = manager.getOutstandingDiagnostics(1);
-  const staleFiles: string[] = [];
-
-  for (const entry of outstanding) {
-    // biome-ignore lint/suspicious/noExplicitAny: isLikelyStaleDiagnostic accepts Diagnostic, which the manager provides
-    if (entry.diagnostics.some((d) => isLikelyStaleDiagnostic(d as any))) {
-      staleFiles.push(entry.file);
-    }
-  }
-
-  if (staleFiles.length === 0) return;
-
-  const cwd = state.controller?.cwd ?? "";
-  for (const file of staleFiles) {
-    const filePath = nodePath.resolve(cwd, file);
-    manager.closeFile(filePath);
-    await manager.ensureFileOpen(filePath);
-  }
-
-  try {
-    await manager.refreshOpenDiagnostics({ quietMs: 300, maxWaitMs: 2000 });
-  } catch {
-    /* best-effort */
-  }
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: diagnostic formatting logic
-function buildInjectionContent(
-  diagnostics: Array<{ file: string; errors: number; warnings: number }>,
-  detailed?: Array<{
-    file: string;
-    diagnostics: Array<{ message: string; range: { start: { line: number } } }>;
-  }>,
-): string {
-  if (!diagnostics || diagnostics.length === 0) return "";
-
-  const parts: string[] = [
-    '<extension-context source="supi-code-intelligence">',
-    "Outstanding LSP diagnostics:",
-  ];
-
-  for (const diag of diagnostics.slice(0, 15)) {
-    const pieces: string[] = [];
-    if (diag.errors > 0) pieces.push(`${diag.errors} error${diag.errors > 1 ? "s" : ""}`);
-    if (diag.warnings > 0) pieces.push(`${diag.warnings} warning${diag.warnings > 1 ? "s" : ""}`);
-    parts.push(`- ${diag.file}: ${pieces.join(", ")}`);
-  }
-
-  if (diagnostics.length > 15) {
-    parts.push(`... and ${diagnostics.length - 15} more files`);
-  }
-
-  if (detailed) {
-    for (const entry of detailed.slice(0, 5)) {
-      for (const d of entry.diagnostics.slice(0, 5)) {
-        parts.push(`  ${d.range.start.line + 1}: ${d.message}`);
-      }
-    }
-  }
-
-  parts.push("</extension-context>");
-
-  const totalErrors = diagnostics.reduce((s: number, d: { errors: number }) => s + d.errors, 0);
-  if (totalErrors > 0) {
-    parts.push("");
-    parts.push(`Found ${totalErrors} errors across the workspace.`);
-    parts.push("Use code_health to inspect issues.");
-  }
-
-  return parts.join("\n");
-}

package/src/substrate/lsp/overrides.ts

@@ -1,132 +0,0 @@
-// LSP-aware tool overrides — ports read/write/edit overrides from supi-lsp.
-//
-// Opens files on read, appends inline diagnostics after write/edit.
-// biome-ignore-all lint/complexity/useMaxParams: pi ToolDefinition.execute signature requires 5 params.
-
-import * as nodePath from "node:path";
-import type {
-  AgentToolUpdateCallback,
-  EditToolInput,
-  ExtensionAPI,
-  ExtensionContext,
-  ReadToolInput,
-  WriteToolInput,
-} from "@earendil-works/pi-coding-agent";
-import { createEditTool, createReadTool, createWriteTool } from "@earendil-works/pi-coding-agent";
-import type { LspAdapterState } from "./state.ts";
-import { diagnosticMessageString } from "./utils.ts";
-
-export function registerLspAwareToolOverrides(pi: ExtensionAPI, state: LspAdapterState): void {
-  const readMeta = createReadTool(process.cwd());
-  const writeMeta = createWriteTool(process.cwd());
-  const editMeta = createEditTool(process.cwd());
-
-  pi.registerTool({
-    ...readMeta,
-    execute: makeReadExecutor(state),
-  });
-
-  pi.registerTool({
-    ...writeMeta,
-    execute: makeWriteExecutor(state),
-  });
-
-  pi.registerTool({
-    ...editMeta,
-    execute: makeEditExecutor(state),
-  });
-}
-
-function makeReadExecutor(state: LspAdapterState) {
-  return async (
-    toolCallId: string,
-    params: ReadToolInput,
-    signal: AbortSignal | undefined,
-    onUpdate: AgentToolUpdateCallback | undefined,
-    ctx: ExtensionContext,
-  ) => {
-    const originalRead = createReadTool(ctx.cwd);
-    const result = await originalRead.execute(toolCallId, params, signal, onUpdate);
-    if (!state.lspActive || !state.controller?.manager) return result;
-    try {
-      await state.controller.manager.ensureFileOpen(resolveSessionPath(ctx.cwd, params.path));
-    } catch {
-      /* never block the agent */
-    }
-    return result;
-  };
-}
-
-function makeWriteExecutor(state: LspAdapterState) {
-  return async (
-    toolCallId: string,
-    params: WriteToolInput,
-    signal: AbortSignal | undefined,
-    onUpdate: AgentToolUpdateCallback | undefined,
-    ctx: ExtensionContext,
-  ) => {
-    const originalWrite = createWriteTool(ctx.cwd);
-    const result = await originalWrite.execute(toolCallId, params, signal, onUpdate);
-    if (!state.lspActive) return result;
-    return appendInlineDiagnostics(state, ctx.cwd, params.path, result);
-  };
-}
-
-function makeEditExecutor(state: LspAdapterState) {
-  return async (
-    toolCallId: string,
-    params: EditToolInput,
-    signal: AbortSignal | undefined,
-    onUpdate: AgentToolUpdateCallback | undefined,
-    ctx: ExtensionContext,
-  ) => {
-    const originalEdit = createEditTool(ctx.cwd);
-    const result = await originalEdit.execute(toolCallId, params, signal, onUpdate);
-    if (!state.lspActive) return result;
-    return appendInlineDiagnostics(state, ctx.cwd, params.path, result);
-  };
-}
-
-async function appendInlineDiagnostics<T extends { content: unknown[]; details: unknown }>(
-  state: LspAdapterState,
-  cwd: string,
-  filePath: string,
-  result: T,
-): Promise<T> {
-  const manager = state.controller?.manager;
-  if (!manager) return result;
-
-  try {
-    const resolved = resolveSessionPath(cwd, filePath);
-    const effectiveSeverity = Math.max(state.inlineSeverity, 2);
-    const entries = await manager.syncFileAndGetCascadingDiagnostics(resolved, effectiveSeverity);
-    if (entries.length === 0) return result;
-
-    // biome-ignore format: manual formatting for readability
-    const lines = [
-      "\n\n⚠️ LSP Diagnostics — review before continuing:",
-      ...entries.flatMap((entry) =>
-        entry.diagnostics.map(
-          (d) =>
-            `  ${entry.file}:${d.range.start.line + 1}: ${diagnosticMessageString(d)}`,
-        ),
-      ),
-      "If these errors are unexpected or appear across multiple files, fix the root cause before editing more.",
-    ];
-
-    const diagnosticContent = {
-      type: "text" as const,
-      text: lines.join("\n"),
-    } as T["content"][number];
-
-    return { ...result, content: [...result.content, diagnosticContent] } as T;
-  } catch {
-    return result;
-  }
-}
-
-function resolveSessionPath(cwd: string, filePath: string): string {
-  if (nodePath.isAbsolute(filePath)) return filePath;
-  if (filePath.startsWith("@")) return nodePath.resolve(cwd, filePath.slice(1));
-  return nodePath.resolve(cwd, filePath);
-}

package/src/substrate/tree-sitter/lifecycle.ts

@@ -1,52 +0,0 @@
-// Tree-sitter session lifecycle — uses TreeSitterRuntimeController from @mrclrchtr/supi-tree-sitter/api.
-
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { getDefaultWorkspaceRuntime } from "@mrclrchtr/supi-code-runtime/api";
-import { TreeSitterRuntimeController } from "@mrclrchtr/supi-tree-sitter/api";
-
-/**
- * Tree-sitter adapter state for the umbrella extension.
- */
-export interface TsAdapterState {
-  controller: TreeSitterRuntimeController | null;
-}
-
-export function createTsAdapterState(): TsAdapterState {
-  return { controller: null };
-}
-
-/**
- * Register Tree-sitter session lifecycle handlers.
- *
- * - session_start: creates TreeSitterRuntimeController, starts it, registers tools
- * - session_shutdown: shuts down the controller
- */
-export function registerTsSessionLifecycle(pi: ExtensionAPI, state: TsAdapterState): void {
-  pi.on("session_start", async (_event, ctx: ExtensionContext) => {
-    const cwd = ctx.cwd;
-    const runtime = getDefaultWorkspaceRuntime();
-
-    // Shut down any existing controller
-    if (state.controller) {
-      await state.controller.shutdown();
-      state.controller = null;
-    }
-
-    const controller = new TreeSitterRuntimeController(cwd, runtime);
-    const result = await controller.start();
-
-    if (result.kind === "ready") {
-      state.controller = controller;
-    } else {
-      await controller.shutdown();
-      state.controller = null;
-    }
-  });
-
-  pi.on("session_shutdown", async () => {
-    if (state.controller) {
-      await state.controller.shutdown();
-      state.controller = null;
-    }
-  });
-}

package/src/tool/find/orchestrate.ts

@@ -1,317 +0,0 @@
-// Pattern orchestration use-case — bounded, scope-aware text search.
-// Coordinates ripgrep literal/regex search and structured tree-sitter search,
-// returning fully rendered content + details metadata.
-
-import type { CodeProvider } from "../../analysis/provider.ts";
-import {
-  getStructuredPatternMatches,
-  isStructuredPatternKind,
-  type StructuredPatternKind,
-} from "../../analysis/search/pattern.ts";
-import type { RgMatch } from "../../analysis/search/ripgrep.ts";
-import { runRipgrep, runRipgrepDetailed, toDisplayPath } from "../../analysis/search/ripgrep.ts";
-import type { CodeIntelResult } from "../../types/index.ts";
-import type { CodeQueryParams } from "../params.ts";
-import { assembleFindResult } from "../result/find.ts";
-import {
-  renderPatternResults,
-  renderPatternSummary,
-  renderRegexError,
-  renderStructuredEmptyState,
-  renderStructuredMatches,
-} from "./markdown.ts";
-import { executeSemanticSearch } from "./semantic-search.ts";
-
-export interface PatternInput {
-  pattern: string;
-  /** One or more resolved search roots. */
-  paths?: string[];
-  /** Human-readable requested scope label for markdown/details. */
-  scopeLabel?: string | null;
-  regex?: boolean;
-  kind?: string;
-  mode?: "text" | "regex" | "ast" | "semantic";
-  maxResults?: number;
-  contextLines?: number;
-  summary?: boolean;
-}
-
-export interface PatternDeps {
-  cwd: string;
-  provider: CodeProvider | null;
-  /** Abort signal forwarded to ripgrep for text/regex modes. */
-  signal?: AbortSignal;
-}
-
-/** Execute the pattern search use-case. */
-export async function executePattern(
-  input: PatternInput,
-  deps: PatternDeps,
-): Promise<CodeIntelResult> {
-  if (!input.pattern) {
-    return {
-      content: "**Error:** `pattern` action requires a `pattern` parameter.",
-      details: undefined,
-    };
-  }
-
-  // Semantic mode — LSP workspace symbol search
-  if (input.mode === "semantic") {
-    return executeSemanticSearch(input, deps.provider, deps.cwd);
-  }
-
-  const maxResults = input.maxResults ?? 8;
-  const contextLines = input.contextLines ?? 1;
-  const scope = getPatternScope(input, deps.cwd);
-
-  if (isStructuredPatternKind(input.kind)) {
-    return executeStructuredSearch(
-      input,
-      input.kind,
-      scope.paths,
-      deps.cwd,
-      scope.label,
-      maxResults,
-      deps.provider,
-    );
-  }
-
-  const matches = input.regex
-    ? await getRegexMatches({
-        pattern: input.pattern,
-        scopePath: scope.paths,
-        cwd: deps.cwd,
-        maxResults,
-        contextLines,
-        summary: input.summary,
-        signal: deps.signal,
-      })
-    : await runRipgrep(input.pattern, scope.paths, deps.cwd, {
-        contextLines,
-        literal: true,
-        filterLowSignal: true,
-        signal: deps.signal,
-      });
-
-  if (typeof matches === "string") {
-    return {
-      content: matches,
-      details: {
-        type: "search",
-        data: assembleFindResult({
-          confidence: "unavailable",
-          scope: getDetailScope(input),
-          candidateCount: 0,
-          nextQueries: ["Fix the regex pattern and retry"],
-        }),
-      },
-    };
-  }
-
-  if (matches.length === 0) {
-    return formatEmptyResult(input, scope.label);
-  }
-
-  const displayMatches = matches.map((m) => ({
-    ...m,
-    file: toDisplayPath(deps.cwd, m.file),
-  }));
-
-  const rendered = input.summary
-    ? {
-        content: renderPatternSummary(input.pattern, scope.label, displayMatches, maxResults),
-        evidenceList: undefined,
-      }
-    : renderPatternResults(input.pattern, scope.label, displayMatches, maxResults);
-
-  const details = assembleFindResult({
-    confidence: "heuristic",
-    scope: getDetailScope(input),
-    candidateCount: matches.length,
-    omittedCount: rendered.evidenceList?.omittedCount ?? 0,
-    evidenceLists: rendered.evidenceList ? [rendered.evidenceList] : [],
-    nextQueries: input.regex
-      ? ["Set `regex: false` for literal matching"]
-      : ["Set `regex: true` for regex matching"],
-  });
-  return { content: rendered.content, details: { type: "search" as const, data: details } };
-}
-
-// ── Structured search ────────────────────────────────────────────────
-
-// biome-ignore lint/complexity/useMaxParams: structured-search parameters are clearer as positional when linking input, scope, and substrate
-async function executeStructuredSearch(
-  input: PatternInput,
-  kind: StructuredPatternKind,
-  scopePaths: readonly string[],
-  cwd: string,
-  relScope: string,
-  maxResults: number,
-  provider: CodeProvider | null,
-): Promise<CodeIntelResult> {
-  if (!provider) {
-    return {
-      content: `**Error:** Structured ${kind} search requires tree-sitter, which is not available.`,
-      details: undefined,
-    };
-  }
-
-  const structured = await getStructuredPatternMatches(
-    { ...input, pattern: input.pattern, kind },
-    scopePaths,
-    cwd,
-    relScope,
-    provider,
-  );
-
-  if (typeof structured === "string") {
-    return {
-      content: structured,
-      details: {
-        type: "search",
-        data: assembleFindResult({
-          confidence: "unavailable",
-          scope: getDetailScope(input),
-          candidateCount: 0,
-          nextQueries: ["Fix the regex pattern and retry"],
-        }),
-      },
-    };
-  }
-
-  if (!structured || structured.matches.length === 0) {
-    const content = renderStructuredEmptyState(
-      input.pattern,
-      kind,
-      relScope,
-      provider,
-      structured ?? undefined,
-    );
-    return {
-      content,
-      details: {
-        type: "search",
-        data: assembleFindResult({
-          confidence: "structural",
-          scope: getDetailScope(input),
-          candidateCount: 0,
-          omittedCount: structured?.omittedCount ?? 0,
-          nextQueries: [
-            "Try a broader `pattern`, or omit `kind` for plain text search",
-            "Narrow `path` if the structured scan was partial",
-          ],
-        }),
-      },
-    };
-  }
-
-  const rendered = renderStructuredMatches(input.pattern, kind, relScope, structured, maxResults);
-
-  return {
-    content: rendered.content,
-    details: {
-      type: "search",
-      data: assembleFindResult({
-        confidence: "structural",
-        scope: getDetailScope(input),
-        candidateCount: structured.matches.length,
-        omittedCount: structured.omittedCount + (rendered.evidenceList.omittedCount ?? 0),
-        evidenceLists: [rendered.evidenceList],
-        nextQueries:
-          kind === "call"
-            ? [
-                "Omit `kind` for plain text matches",
-                'Use `code_graph` with `relations: ["references"]` on a resolved target for identity-aware callers',
-              ]
-            : [
-                "Omit `kind` for plain text matches",
-                "Widen `scope` or raise `maxResults` for broader coverage",
-              ],
-      }),
-    },
-  };
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-function getPatternScope(input: PatternInput, cwd: string): { paths: string[]; label: string } {
-  if (input.paths && input.paths.length > 0) {
-    return { paths: input.paths, label: input.scopeLabel ?? input.paths.join(", ") };
-  }
-  return { paths: [cwd], label: "." };
-}
-
-function getDetailScope(input: PatternInput): string | null {
-  return input.scopeLabel ?? null;
-}
-
-const REGEX_HINT_CHARS = /[|.*+?^${}()[\]\\]/;
-
-function hasRegexChars(pattern: string): boolean {
-  return REGEX_HINT_CHARS.test(pattern);
-}
-
-function formatEmptyResult(input: PatternInput, relScope: string): CodeIntelResult {
-  const emptyDetails = assembleFindResult({
-    confidence: "heuristic",
-    scope: getDetailScope(input),
-    candidateCount: 0,
-    nextQueries: input.regex
-      ? ["Set `regex: false` for literal matching"]
-      : ["Set `regex: true` for regex matching"],
-  });
-  const hint = input.regex
-    ? ""
-    : hasRegexChars(input.pattern)
-      ? " — pattern contains regex-like characters; set `regex: true` for regex matching"
-      : " — set `regex: true` for regex matching";
-  return {
-    content: `No matches found for \`${input.pattern}\` in \`${relScope}\`${hint}.`,
-    details: { type: "search", data: emptyDetails },
-  };
-}
-
-async function getRegexMatches(options: {
-  pattern: string;
-  scopePath: string | readonly string[];
-  cwd: string;
-  maxResults: number;
-  contextLines: number;
-  summary?: boolean;
-  signal?: AbortSignal;
-}): Promise<RgMatch[] | string> {
-  const result = await runRipgrepDetailed(options.pattern, options.scopePath, options.cwd, {
-    contextLines: options.contextLines,
-    filterLowSignal: true,
-    signal: options.signal,
-  });
-
-  if (result.error) {
-    return renderRegexError(options.pattern, result.error);
-  }
-
-  return result.matches;
-}
-
-// ── Test helper wrapper ─────────────────────────────────────────────
-
-/** Prefer {@link executePattern} with the typed PatternInput/PatternDeps interface. */
-export async function executePatternAction(
-  params: CodeQueryParams,
-  cwd: string,
-  provider?: CodeProvider | null,
-): Promise<CodeIntelResult> {
-  return executePattern(
-    {
-      pattern: params.pattern ?? "",
-      paths: params.path ? [params.path] : undefined,
-      scopeLabel: params.path ?? null,
-      regex: params.regex,
-      kind: params.kind,
-      maxResults: params.maxResults,
-      contextLines: params.contextLines,
-      summary: params.summary,
-    },
-    { cwd, provider: provider ?? null },
-  );
-}