@mrclrchtr/supi-code-intelligence 1.16.1 → 2.0.1

package/src/{presentation/markdown/pattern.ts → tool/find/markdown.ts}

@@ -1,61 +1,126 @@
 // Pattern search markdown renderer — all formatting for literal, regex, and structured search results.
 
-import type { StructuredMatch, StructuredPatternResult } from "../../pattern-structured.ts";
-import type { RgMatch } from "../../search-helpers.ts";
-import { groupByFile } from "../../search-helpers.ts";
-import type { StructuralSubstrate } from "../../substrates/types.ts";
+import type { StructuralProvider as StructuralSubstrate } from "@mrclrchtr/supi-code-runtime/api";
+import {
+  createEvidenceList,
+  type EvidenceListMetadata,
+  renderEvidenceListDisclosure,
+} from "../../analysis/evidence.ts";
+import type {
+  StructuredMatch,
+  StructuredPatternKind,
+  StructuredPatternResult,
+} from "../../analysis/search/pattern.ts";
+import type { RgMatch } from "../../analysis/search/ripgrep.ts";
+import { groupByFile } from "../../analysis/search/ripgrep.ts";
 
 // ── Structured search formatting ─────────────────────────────────────
 
 // biome-ignore lint/complexity/useMaxParams: structured empty-state with optional result parameter keeps partial-warning logic together
 export function renderStructuredEmptyState(
   pattern: string,
-  kind: "definition" | "export" | "import",
+  kind: StructuredPatternKind,
   relScope: string,
   _structural?: StructuralSubstrate,
   result?: StructuredPatternResult,
 ): string {
   const lines = [`No ${kind} matches found for \`${pattern}\` in \`${relScope}\`.`];
-  if (result && result.omittedCount > 0 && result.partialReason) {
+  const partial = renderPartialWarning(result);
+  if (partial) {
     lines.push("");
-    if (result.partialReason === "timeout") {
-      lines.push(
-        `_Partial structured results — scan timed out with +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted. Narrow \`path\` or \`pattern\` for complete coverage._`,
-      );
-    } else {
-      lines.push(
-        `_Partial structured results — +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted after reaching the structured scan cap. Narrow \`path\` or \`pattern\` for complete coverage._`,
-      );
-    }
+    lines.push(partial);
+  }
+  const failureLines = renderFailureSummary(result?.failures);
+  if (failureLines.length > 0) {
+    lines.push("");
+    lines.push(...failureLines);
   }
   return lines.join("\n");
 }
 
+function renderFailureSummary(failures?: Array<{ file: string; reason: string }>): string[] {
+  if (!failures || failures.length === 0) return [];
+  const lines: string[] = [
+    `**${failures.length} file${failures.length !== 1 ? "s" : ""} could not be analyzed:**`,
+  ];
+  for (const f of failures.slice(0, 5)) {
+    lines.push(`- \`${f.file}\` — ${f.reason}`);
+  }
+  if (failures.length > 5) {
+    lines.push(`- _+${failures.length - 5} more_`);
+  }
+  return lines;
+}
+
+function renderPartialWarning(result?: StructuredPatternResult): string | null {
+  if (!result || result.omittedCount <= 0 || !result.partialReason) return null;
+  if (result.partialReason === "timeout") {
+    return `_Partial structured results — scan timed out with +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted. Narrow \`path\` or \`pattern\` for complete coverage._`;
+  }
+  return `_Partial structured results — +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted after reaching the structured scan cap. Narrow \`path\` or \`pattern\` for complete coverage._`;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: pattern search rendering groups matches by file and adds summaries — each branch stays linear
+// biome-ignore lint/complexity/useMaxParams: structured renderer mirrors the existing public helper shape plus display cap
 export function renderStructuredMatches(
   pattern: string,
-  kind: "definition" | "export" | "import",
+  kind: StructuredPatternKind,
   relScope: string,
   result: StructuredPatternResult,
-): string {
+  maxResults: number,
+): { content: string; evidenceList: EvidenceListMetadata } {
+  const evidence = createEvidenceList({
+    key: "find.astMatches",
+    items: result.matches,
+    maxResults,
+  });
   const grouped = new Map<string, StructuredMatch[]>();
-  for (const match of result.matches) {
+  for (const match of evidence.items) {
     const group = grouped.get(match.file) ?? [];
     group.push(match);
     grouped.set(match.file, group);
   }
 
   const kindLabel =
-    kind === "definition" ? "Definitions" : kind === "export" ? "Exports" : "Imports";
+    kind === "definition"
+      ? "Definitions"
+      : kind === "export"
+        ? "Exports"
+        : kind === "import"
+          ? "Imports"
+          : kind === "call"
+            ? "Calls"
+            : kind === "type"
+              ? "Types"
+              : kind === "interface"
+                ? "Interfaces"
+                : kind === "class"
+                  ? "Classes"
+                  : kind === "method"
+                    ? "Methods"
+                    : kind === "enum"
+                      ? "Enums"
+                      : "Tests";
   const lines: string[] = [];
   lines.push(`# Pattern ${kindLabel}: \`${pattern}\``);
   lines.push("");
   lines.push(
     `**${result.matches.length} match${result.matches.length !== 1 ? "es" : ""}** across **${grouped.size} file${grouped.size !== 1 ? "s" : ""}** in \`${relScope}\``,
   );
-  const partialWarning = formatPartialStructuredWarning(result);
+  if (kind === "call") {
+    lines.push("");
+    lines.push(
+      '_Note: AST call results are name-based, not symbol-identity-aware. Use `code_graph` with `relations: ["references"]` on a resolved target for identity-aware callers._',
+    );
+  }
+  const partialWarning = renderPartialWarning(result);
   if (partialWarning) {
     lines.push(partialWarning);
   }
+  if (result.failures.length > 0) {
+    lines.push("");
+    lines.push(...renderFailureSummary(result.failures));
+  }
   lines.push("");
 
   if (kind === "definition" || kind === "export") {
@@ -64,26 +129,18 @@ export function renderStructuredMatches(
 
   for (const [file, fileMatches] of grouped) {
     lines.push(`### ${file}`);
-    for (const match of fileMatches.slice(0, 8)) {
+    for (const match of fileMatches) {
       lines.push(`- \`${match.name}\` (${match.kind}) L${match.line}`);
     }
-    if (fileMatches.length > 8) {
-      lines.push(`- _+${fileMatches.length - 8} more in this file_`);
-    }
     lines.push("");
   }
 
-  return lines.join("\n");
-}
-
-function formatPartialStructuredWarning(result: StructuredPatternResult): string | null {
-  if (!result.partialReason || result.omittedCount <= 0) return null;
-
-  if (result.partialReason === "timeout") {
-    return `_Partial structured results — scan timed out with +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted. Narrow \`path\` or \`pattern\` for complete coverage._`;
+  const disclosure = renderEvidenceListDisclosure(evidence);
+  if (disclosure) {
+    lines.push(disclosure);
   }
 
-  return `_Partial structured results — +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted after reaching the structured scan cap. Narrow \`path\` or \`pattern\` for complete coverage._`;
+  return { content: lines.join("\n"), evidenceList: evidence.metadata };
 }
 
 function addDuplicateSummary(lines: string[], matches: StructuredMatch[]): void {
@@ -137,40 +194,35 @@ export function renderPatternResults(
   relScope: string,
   matches: RgMatch[],
   maxResults: number,
-): string {
+): { content: string; evidenceList: EvidenceListMetadata } {
   const lines: string[] = [];
   lines.push(`# Pattern: \`${pattern}\``);
   lines.push("");
   lines.push(`**${matches.length} match${matches.length > 1 ? "es" : ""}** in \`${relScope}\``);
   lines.push("");
 
-  const byFile = groupByFile(matches);
-  let shown = 0;
+  const evidence = createEvidenceList({
+    key: "find.textMatches",
+    items: matches,
+    maxResults,
+  });
+  const byFile = groupByFile(evidence.items);
   for (const [file, fileMatches] of byFile) {
-    if (shown >= maxResults) break;
     lines.push(`### ${file}`);
     const renderedLines = new Set<number>();
     const matchLines = new Set(fileMatches.map((match) => match.line));
-    for (const m of fileMatches.slice(0, 5)) {
+    for (const m of fileMatches) {
       renderMatchWithContext(lines, m, renderedLines, matchLines, pattern);
     }
-    if (fileMatches.length > 5) {
-      lines.push(`- _+${fileMatches.length - 5} more in this file_`);
-    }
     lines.push("");
-    shown++;
   }
 
-  if (byFile.size > maxResults) {
-    lines.push(
-      `_+${byFile.size - maxResults} more files omitted. Narrow \`path\` or increase \`maxResults\`._`,
-    );
+  const disclosure = renderEvidenceListDisclosure(evidence);
+  if (disclosure) {
+    lines.push(disclosure);
   }
   lines.push("");
-  lines.push("_Text search — results may include comments, strings, or unrelated matches._");
-  lines.push("");
-
-  return lines.join("\n");
+  return { content: lines.join("\n"), evidenceList: evidence.metadata };
 }
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: context-line rendering with before/after/skip logic is clearer as one function
@@ -232,8 +284,5 @@ export function renderPatternSummary(
     lines.push(`- _+${sorted.length - maxResults} more files omitted_`);
   }
   lines.push("");
-  lines.push("_Text search — results may include comments, strings, or unrelated matches._");
-  lines.push("");
-
   return lines.join("\n");
 }

package/src/{use-case/generate-pattern.ts → tool/find/orchestrate.ts}

@@ -2,25 +2,36 @@
 // Coordinates ripgrep literal/regex search and structured tree-sitter search,
 // returning fully rendered content + details metadata.
 
-import { getStructuredPatternMatches, isStructuredPatternKind } from "../pattern-structured.ts";
+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 {
+  normalizePath,
+  runRipgrep,
+  runRipgrepDetailed,
+  toDisplayPath,
+} from "../../analysis/search/ripgrep.ts";
+import type { CodeIntelResult, SearchDetails } from "../../types/index.ts";
+import type { CodeQueryParams } from "../params.ts";
 import {
   renderPatternResults,
   renderPatternSummary,
   renderRegexError,
   renderStructuredEmptyState,
   renderStructuredMatches,
-} from "../presentation/markdown/pattern.ts";
-import type { CodeQueryParams } from "../query-params.ts";
-import type { RgMatch } from "../search-helpers.ts";
-import { normalizePath, runRipgrep, runRipgrepDetailed } from "../search-helpers.ts";
-import type { CodeIntelResult, SearchDetails } from "../types.ts";
-import type { CodeProvider } from "../workspace/request-context.ts";
+} from "./markdown.ts";
+import { executeSemanticSearch } from "./semantic-search.ts";
 
 export interface PatternInput {
   pattern: string;
   path?: string;
   regex?: boolean;
   kind?: string;
+  mode?: "text" | "regex" | "ast" | "semantic";
   maxResults?: number;
   contextLines?: number;
   summary?: boolean;
@@ -29,9 +40,12 @@ export interface PatternInput {
 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. */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: mode dispatch branches are linear, not nested
 export async function executePattern(
   input: PatternInput,
   deps: PatternDeps,
@@ -43,6 +57,11 @@ export async function executePattern(
     };
   }
 
+  // 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 scopePath = input.path ? normalizePath(input.path, deps.cwd) : deps.cwd;
@@ -61,19 +80,20 @@ export async function executePattern(
   }
 
   const matches = input.regex
-    ? getRegexMatches({
+    ? await getRegexMatches({
         pattern: input.pattern,
         scopePath,
         cwd: deps.cwd,
         maxResults,
         contextLines,
         summary: input.summary,
+        signal: deps.signal,
       })
-    : runRipgrep(input.pattern, scopePath, deps.cwd, {
-        maxMatches: input.summary ? undefined : maxResults * 3,
+    : await runRipgrep(input.pattern, scopePath, deps.cwd, {
         contextLines,
         literal: true,
         filterLowSignal: true,
+        signal: deps.signal,
       });
 
   if (typeof matches === "string") {
@@ -91,20 +111,29 @@ export async function executePattern(
     return formatEmptyResult(input, relScope);
   }
 
-  const content = input.summary
-    ? renderPatternSummary(input.pattern, relScope, matches, maxResults)
-    : renderPatternResults(input.pattern, relScope, matches, maxResults);
+  const displayMatches = matches.map((m) => ({
+    ...m,
+    file: toDisplayPath(deps.cwd, m.file),
+  }));
+
+  const rendered = input.summary
+    ? {
+        content: renderPatternSummary(input.pattern, relScope, displayMatches, maxResults),
+        evidenceList: undefined,
+      }
+    : renderPatternResults(input.pattern, relScope, displayMatches, maxResults);
 
   const details: SearchDetails = {
     confidence: "heuristic",
     scope: input.path ?? null,
     candidateCount: matches.length,
-    omittedCount: 0,
+    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, details: { type: "search" as const, data: details } };
+  return { content: rendered.content, details: { type: "search" as const, data: details } };
 }
 
 // ── Structured search ────────────────────────────────────────────────
@@ -112,11 +141,11 @@ export async function executePattern(
 // biome-ignore lint/complexity/useMaxParams: structured-search parameters are clearer as positional when linking input, scope, and substrate
 async function executeStructuredSearch(
   input: PatternInput,
-  kind: "definition" | "export" | "import",
+  kind: StructuredPatternKind,
   scopePath: string,
   cwd: string,
   relScope: string,
-  _maxResults: number,
+  maxResults: number,
   provider: CodeProvider | null,
 ): Promise<CodeIntelResult> {
   if (!provider) {
@@ -148,7 +177,7 @@ async function executeStructuredSearch(
   if (!structured || structured.matches.length === 0) {
     const content = renderStructuredEmptyState(
       input.pattern,
-      kind as "definition" | "export" | "import",
+      kind,
       relScope,
       provider,
       structured ?? undefined,
@@ -171,24 +200,28 @@ async function executeStructuredSearch(
     };
   }
 
+  const rendered = renderStructuredMatches(input.pattern, kind, relScope, structured, maxResults);
+
   return {
-    content: renderStructuredMatches(
-      input.pattern,
-      kind as "definition" | "export" | "import",
-      relScope,
-      structured,
-    ),
+    content: rendered.content,
     details: {
       type: "search",
       data: {
         confidence: "structural",
         scope: input.path ?? null,
         candidateCount: structured.matches.length,
-        omittedCount: structured.omittedCount,
-        nextQueries: [
-          "Omit `kind` for plain text matches",
-          "Use `summary: true` for broader textual distribution",
-        ],
+        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",
+              ],
       },
     },
   };
@@ -223,18 +256,19 @@ function formatEmptyResult(input: PatternInput, relScope: string): CodeIntelResu
   };
 }
 
-function getRegexMatches(options: {
+async function getRegexMatches(options: {
   pattern: string;
   scopePath: string;
   cwd: string;
   maxResults: number;
   contextLines: number;
   summary?: boolean;
-}): RgMatch[] | string {
-  const result = runRipgrepDetailed(options.pattern, options.scopePath, options.cwd, {
-    maxMatches: options.summary ? undefined : options.maxResults * 3,
+  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) {

package/src/tool/find/semantic-search.ts

@@ -0,0 +1,114 @@
+/**
+ * Semantic search support for the pattern/find use-case.
+ *
+ * LSP workspace-symbol search with scope filtering and markdown rendering.
+ * Extracted from orchestrate.ts to keep the main use-case under the
+ * file-line limit.
+ */
+
+import type { CodeSymbol } from "@mrclrchtr/supi-code-runtime/api";
+import { isWithinOrEqual } from "@mrclrchtr/supi-core/project";
+import { createEvidenceList, renderEvidenceListDisclosure } from "../../analysis/evidence.ts";
+import type { CodeProvider } from "../../analysis/provider.ts";
+import { normalizePath } from "../../analysis/search/ripgrep.ts";
+import type { CodeIntelResult, SearchDetails } from "../../types/index.ts";
+import type { PatternInput } from "./orchestrate.ts";
+
+export async function executeSemanticSearch(
+  input: PatternInput,
+  provider: CodeProvider | null,
+  cwd: string,
+): Promise<CodeIntelResult> {
+  if (!provider?.workspaceSymbols) {
+    throw new Error(
+      "code_find semantic search is unavailable because no semantic/LSP provider is active for this workspace.",
+    );
+  }
+
+  const symbols = await provider.workspaceSymbols(input.pattern);
+  if (symbols === null) {
+    throw new Error(
+      "code_find semantic search is unavailable because the active semantic provider cannot serve workspace symbol queries.",
+    );
+  }
+
+  const scopePath = input.path ? normalizePath(input.path, cwd) : cwd;
+  const scopedSymbols = filterSymbolsByScope(symbols, scopePath);
+  if (scopedSymbols.length === 0) {
+    return renderSemanticEmptyResult(input);
+  }
+
+  return renderSemanticResults(input, scopedSymbols, cwd);
+}
+
+function filterSymbolsByScope<T extends { file: string }>(symbols: T[], scopePath: string): T[] {
+  return symbols.filter((symbol) => isWithinOrEqual(scopePath, symbol.file));
+}
+
+function renderSemanticEmptyResult(input: PatternInput): CodeIntelResult {
+  const relPath = input.path ?? ".";
+  return {
+    content: `**Semantic search** — \`${input.pattern}\`\n\nNo semantic results found in \`${relPath}\`.`,
+    details: {
+      type: "search",
+      data: {
+        confidence: "semantic",
+        scope: input.path ?? null,
+        candidateCount: 0,
+        omittedCount: 0,
+        nextQueries: [
+          'Use `mode: "text"` for literal text search',
+          'Use `mode: "ast"` with `kind` for structural filtering',
+        ],
+      } satisfies SearchDetails,
+    },
+  };
+}
+
+function renderSemanticResults(
+  input: PatternInput,
+  symbols: CodeSymbol[],
+  cwd: string,
+): CodeIntelResult {
+  const max = input.maxResults ?? 8;
+  const evidence = createEvidenceList({
+    key: "find.semanticSymbols",
+    items: symbols,
+    maxResults: max,
+  });
+
+  const lines = [
+    `**Semantic search** — \`${input.pattern}\` (${symbols.length} symbol${symbols.length !== 1 ? "s" : ""} found)`,
+  ];
+
+  for (const sym of evidence.items) {
+    const kindLabel = sym.kind ? ` [${sym.kind}]` : "";
+    const container = sym.container ? ` (in ${sym.container})` : "";
+    const fileRel = sym.file.startsWith(cwd) ? sym.file.slice(cwd.length + 1) : sym.file;
+    const anchor = sym.nameAnchor ?? sym.declarationAnchor;
+    lines.push(`- \`${sym.name}\`${kindLabel}${container} — \`${fileRel}:${anchor.line}\``);
+  }
+
+  const disclosure = renderEvidenceListDisclosure(evidence);
+  if (disclosure) {
+    lines.push(disclosure);
+  }
+
+  return {
+    content: lines.join("\n"),
+    details: {
+      type: "search",
+      data: {
+        confidence: "semantic",
+        scope: input.path ?? null,
+        candidateCount: symbols.length,
+        omittedCount: evidence.metadata.omittedCount ?? 0,
+        evidenceLists: [evidence.metadata],
+        nextQueries: [
+          'Use `mode: "text"` for literal text search',
+          'Use `mode: "ast"` with `kind` for structural filtering',
+        ],
+      } satisfies SearchDetails,
+    },
+  };
+}

package/src/tool/find/tui.ts

@@ -0,0 +1,39 @@
+/**
+ * TUI renderer for code_find — renderCall + renderResult.
+ */
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { type ResultOptios, renderSimpleResult, type ToolResult } from "../../ui/tui/common.ts";
+import type { CodeFindToolParams } from "./execute.ts";
+
+/** ── renderCall ────────────────────────────────────────────────── */
+
+export function renderFindCall(args: unknown, theme: Theme, _context: unknown): Text {
+  const params = (args ?? {}) as CodeFindToolParams;
+  const mode = params.mode ?? "text";
+
+  let content = theme.fg("toolTitle", "code_find");
+
+  if (params.query) {
+    content += ` ${theme.fg("accent", JSON.stringify(params.query))}`;
+  }
+
+  content += ` ${theme.fg("muted", mode)}`;
+
+  if (params.kind) {
+    content += theme.fg("dim", ` [${params.kind}]`);
+  }
+
+  return new Text(content, 0, 0);
+}
+
+/** ── renderResult ──────────────────────────────────────────────── */
+
+export function renderFindResult(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  _context: unknown,
+): ReturnType<typeof renderSimpleResult> {
+  return renderSimpleResult(result, options, theme, "Searching…");
+}