@mrclrchtr/supi-code-intelligence 1.5.0 → 1.7.0

package/src/actions/implementations-action.ts

@@ -1,20 +1,14 @@
-// Implementations action — find concrete implementations via LSP or heuristic.
+// Implementations action — find concrete implementations via LSP.
 
 import * as path from "node:path";
 import { getSemanticService } from "../providers/semantic-provider.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import { resolveTarget } from "../resolve-target.ts";
-import {
-  escapeRegex,
-  isInProjectPath,
-  normalizePath,
-  runRipgrep,
-  uriToFile,
-} from "../search-helpers.ts";
+import { isInProjectPath, uriToFile } from "../search-helpers.ts";
 import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
 import type { CodeIntelResult, SearchDetails } from "../types.ts";
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: implementation lookup has distinct semantic, unsupported-file, and heuristic branches
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: implementation lookup keeps semantic and unsupported-file paths explicit for maintainability
 export async function executeImplementationsAction(
   params: ActionParams,
   cwd: string,
@@ -57,7 +51,7 @@ export async function executeImplementationsAction(
 
   if (lsp) {
     const impls = await lsp.implementation(target.file, target.position);
-    if (impls) {
+    if (impls !== null) {
       const locations = Array.isArray(impls) ? impls : [impls];
       if (locations.length > 0) {
         const content = formatSemanticImpls(locations, cwd, params.maxResults ?? 8);
@@ -68,29 +62,35 @@ export async function executeImplementationsAction(
           candidateCount: projectLocs.length,
           omittedCount: externalLocs.length,
           nextQueries: [
-            "`code_intel affected` before changing implementations",
-            "`code_intel brief` on containing modules for deeper context",
+            "`code_affected` before changing implementations",
+            "`code_brief` on containing modules for deeper context",
           ],
         };
         return { content, details: { type: "search" as const, data: searchDetails } };
       }
-    }
-  }
 
-  if (target.name) {
-    const result = formatHeuristicImpls(target.name, params, cwd);
-    const details: SearchDetails = {
-      confidence: "heuristic",
-      scope: params.path ?? null,
-      candidateCount: result.matchCount,
-      omittedCount: 0,
-      nextQueries: ["Enable LSP for semantic implementation resolution"],
-    };
-    return { content: result.content, details: { type: "search" as const, data: details } };
+      const semanticEmptyDetails: SearchDetails = {
+        confidence: "semantic",
+        scope: params.path ?? null,
+        candidateCount: 0,
+        omittedCount: 0,
+        nextQueries: [
+          "`code_pattern` only if you explicitly want text-search hints for likely implementations",
+        ],
+      };
+      return {
+        content: target.name
+          ? `No implementations found for \`${target.name}\`.`
+          : `No implementations found for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
+        details: { type: "search" as const, data: semanticEmptyDetails },
+      };
+    }
   }
 
   return {
-    content: `No implementations found for ${relPath}:${target.displayLine}:${target.displayCharacter}.\n\nLSP implementation lookup may not be available. Try \`code_intel pattern\` with the type name.`,
+    content: target.name
+      ? `No implementations found for \`${target.name}\`.`
+      : `No implementations found for ${relPath}:${target.displayLine}:${target.displayCharacter}.`,
     details: {
       type: "search" as const,
       data: {
@@ -98,9 +98,7 @@ export async function executeImplementationsAction(
         scope: params.path ?? null,
         candidateCount: 0,
         omittedCount: 0,
-        nextQueries: [
-          "Enable LSP for semantic implementation resolution, or try `code_intel pattern`",
-        ],
+        nextQueries: ["Enable LSP for semantic implementation resolution."],
       },
     },
   };
@@ -172,37 +170,3 @@ function formatSemanticImpls(
   lines.push("");
   return lines.join("\n");
 }
-
-function formatHeuristicImpls(
-  symbol: string,
-  params: ActionParams,
-  cwd: string,
-): { content: string; matchCount: number } {
-  const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
-  const pattern = `(implements|extends)\\s+.*\\b${escapeRegex(symbol)}\\b`;
-  const matches = runRipgrep(pattern, scopePath, cwd, { maxMatches: 10 });
-
-  if (matches.length === 0) {
-    return {
-      content: `No implementations found for \`${symbol}\`.\n\nTry \`code_intel pattern\` with the type name.`,
-      matchCount: 0,
-    };
-  }
-
-  const lines: string[] = [];
-  lines.push(`# Implementations of \`${symbol}\` (heuristic)`);
-  lines.push("");
-  lines.push(
-    `**${matches.length} candidate${matches.length > 1 ? "s" : ""}** — text-search hints, not semantic implementations`,
-  );
-  lines.push("");
-
-  for (const m of matches.slice(0, 8)) {
-    lines.push(`- \`${m.file}\`:${m.line} — \`${m.text.slice(0, 80)}\``);
-  }
-  if (matches.length > 8) {
-    lines.push(`- _+${matches.length - 8} more omitted_`);
-  }
-  lines.push("");
-  return { content: lines.join("\n"), matchCount: matches.length };
-}

package/src/actions/map-action.ts

@@ -0,0 +1,206 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { CodeIntelResult, MapDetails } from "../types.ts";
+
+const SOURCE_EXTENSIONS = new Map([
+  [".ts", "TypeScript"],
+  [".tsx", "TSX"],
+  [".js", "JavaScript"],
+  [".jsx", "JSX"],
+  [".mts", "TypeScript"],
+  [".cts", "TypeScript"],
+  [".mjs", "JavaScript"],
+  [".cjs", "JavaScript"],
+  [".py", "Python"],
+  [".pyi", "Python"],
+  [".rs", "Rust"],
+  [".go", "Go"],
+  [".mod", "Go"],
+  [".java", "Java"],
+  [".kt", "Kotlin"],
+  [".kts", "Kotlin"],
+  [".rb", "Ruby"],
+  [".php", "PHP"],
+  [".swift", "Swift"],
+  [".cpp", "C++"],
+  [".hpp", "C++"],
+  [".cc", "C++"],
+  [".cxx", "C++"],
+  [".hxx", "C++ Header"],
+  [".c++", "C++"],
+  [".h++", "C++ Header"],
+  [".c", "C"],
+  [".h", "C Header"],
+  [".css", "CSS"],
+  [".scss", "SCSS"],
+  [".less", "Less"],
+  [".html", "HTML"],
+  [".htm", "HTML"],
+  [".xhtml", "HTML"],
+  [".json", "JSON"],
+  [".yaml", "YAML"],
+  [".yml", "YAML"],
+  [".toml", "TOML"],
+  [".md", "Markdown"],
+  [".sh", "Shell"],
+  [".bash", "Shell"],
+  [".zsh", "Shell"],
+  [".r", "R"],
+  [".sql", "SQL"],
+  [".cs", "C#"],
+]);
+
+const LANDMARK_FILES = new Set([
+  "package.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "vite.config.ts",
+  "vitest.config.ts",
+  "jest.config.ts",
+  "playwright.config.ts",
+  "biome.json",
+  "eslint.config.js",
+  ".eslintrc.js",
+  "deno.json",
+  "deno.jsonc",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "setup.py",
+  "requirements.txt",
+  "Makefile",
+  "justfile",
+  "Taskfile.yml",
+  "Dockerfile",
+  "docker-compose.yml",
+  ".env.example",
+  ".env.local.example",
+]);
+
+const SKIP_DIRS = new Set(["node_modules", "dist", "build", ".git"]);
+
+interface FileStats {
+  byExtension: Map<string, number>;
+  byChildDir: Map<string, number>;
+  landmarkFiles: string[];
+  total: number;
+}
+
+export function executeMapAction(scopePath: string, cwd: string): CodeIntelResult {
+  const stats = gatherStats(scopePath);
+  const scope = formatScope(scopePath, cwd);
+  const content = formatMap(scope, stats);
+  const details: MapDetails = {
+    scope,
+    totalFiles: stats.total,
+    childDirectoryCount: stats.byChildDir.size,
+    landmarkCount: stats.landmarkFiles.length,
+    nextQueries: ["`code_brief` for prioritized context on this scope"],
+  };
+
+  return { content, details: { type: "map", data: details } };
+}
+
+function gatherStats(scopePath: string): FileStats {
+  const stats: FileStats = {
+    byExtension: new Map<string, number>(),
+    byChildDir: new Map<string, number>(),
+    landmarkFiles: [],
+    total: 0,
+  };
+
+  walkDirectory(scopePath, "", stats);
+  return stats;
+}
+
+function walkDirectory(dir: string, rel: string, stats: FileStats): void {
+  const entries = readEntries(dir);
+  if (!entries) return;
+
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry)) continue;
+    visitEntry(dir, rel, entry, stats);
+  }
+}
+
+function readEntries(dir: string): fs.Dirent[] | null {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+
+function shouldSkipEntry(entry: fs.Dirent): boolean {
+  return entry.name.startsWith(".") || SKIP_DIRS.has(entry.name);
+}
+
+function visitEntry(dir: string, rel: string, entry: fs.Dirent, stats: FileStats): void {
+  const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+  const fullPath = path.join(dir, entry.name);
+
+  if (entry.isDirectory()) {
+    walkDirectory(fullPath, entryRel, stats);
+    return;
+  }
+
+  recordFileStats(entry.name, entryRel, stats);
+}
+
+function recordFileStats(entryName: string, entryRel: string, stats: FileStats): void {
+  stats.total++;
+  const ext = path.extname(entryName).toLowerCase();
+  stats.byExtension.set(ext, (stats.byExtension.get(ext) ?? 0) + 1);
+
+  const firstSegment = entryRel.split("/")[0];
+  if (firstSegment && entryRel.includes("/")) {
+    stats.byChildDir.set(firstSegment, (stats.byChildDir.get(firstSegment) ?? 0) + 1);
+  }
+
+  if (LANDMARK_FILES.has(entryName)) {
+    stats.landmarkFiles.push(entryRel);
+  }
+}
+
+function formatMap(scope: string, stats: FileStats): string {
+  const lines: string[] = [];
+
+  lines.push(`# Code Map: ${scope}`);
+  lines.push("");
+  lines.push(`**Files:** ${stats.total} total`);
+  for (const [ext, count] of [...stats.byExtension.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)) {
+    const label = SOURCE_EXTENSIONS.get(ext) ?? (ext || "(no extension)");
+    lines.push(`- ${label}: ${count}`);
+  }
+  if (stats.byExtension.size > 10) {
+    lines.push(`- _+${stats.byExtension.size - 10} more extensions_`);
+  }
+  lines.push("");
+
+  if (stats.byChildDir.size > 0) {
+    lines.push("**Child directories:**");
+    for (const [dir, count] of [...stats.byChildDir.entries()].sort((a, b) => b[1] - a[1])) {
+      lines.push(`- ${dir}/ (${count} file${count !== 1 ? "s" : ""})`);
+    }
+    lines.push("");
+  }
+
+  if (stats.landmarkFiles.length > 0) {
+    lines.push("**Landmark files:**");
+    for (const file of stats.landmarkFiles) {
+      lines.push(`- \`${file}\``);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function formatScope(scopePath: string, cwd: string): string {
+  const relative = path.relative(cwd, scopePath);
+  if (relative === "") return ".";
+  if (relative.startsWith(`..${path.sep}`) || relative === "..") return scopePath;
+  return relative.replaceAll(path.sep, "/");
+}

package/src/actions/pattern-action.ts

@@ -7,6 +7,7 @@ import {
   type StructuredMatch,
   type StructuredPatternResult,
 } from "../pattern-structured.ts";
+import type { CodeQueryParams as ActionParams } from "../query-params.ts";
 import type { RgMatch } from "../search-helpers.ts";
 import {
   escapeRegex,
@@ -15,7 +16,6 @@ import {
   runRipgrep,
   runRipgrepDetailed,
 } from "../search-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
 import type { CodeIntelResult, SearchDetails } from "../types.ts";
 
 /**

package/src/api.ts

@@ -23,5 +23,6 @@ export type {
   CodeIntelResult,
   ConfidenceMode,
   DisambiguationCandidate,
+  MapDetails,
   SearchDetails,
 } from "./types.ts";

package/src/brief-focused.ts

@@ -183,13 +183,13 @@ function addDependentsSection(
       const depShort = dep.name.replace(/^@[^/]+\//, "");
       lines.push(`- ${depShort} (\`${dep.relativePath}\`)`);
     }
-    nextQueries.push("`code_intel affected` before modifying exports from this module");
+    nextQueries.push("`code_affected` before modifying exports from this module");
   }
 
   if (mod.entrypoints.length > 0) {
     const ep = mod.entrypoints[0];
     nextQueries.push(
-      `\`code_intel brief\` with \`file: "${mod.relativePath}/${ep.replace(/^\.\//, "")}"\` for entrypoint details`,
+      `\`code_brief\` with \`file: "${mod.relativePath}/${ep.replace(/^\.\//, "")}"\` for entrypoint details`,
     );
   }
 }
@@ -276,7 +276,7 @@ function formatNonModuleDir(ctx: NonModuleDirContext): void {
     lines.push(`- Exports: ${summary.exportCount}`);
     lines.push("");
     nextQueries.push(
-      `\`code_intel pattern\` with \`path: "${relPath || originalPath}"\` to inspect a specific nested symbol`,
+      `\`code_pattern\` with \`path: "${relPath || originalPath}"\` to inspect a specific nested symbol`,
     );
   }
 
@@ -334,11 +334,11 @@ function generateFileBrief(
   }
 
   nextQueries.push(
-    `\`code_intel callers\` with \`file: "${relPath}"\` and a line/character for call-site analysis`,
+    `\`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, and a line/character for call-site analysis`,
   );
   if (mod) {
     nextQueries.push(
-      `\`code_intel brief\` with \`path: "${mod.relativePath}"\` for the containing module overview`,
+      `\`code_brief\` with \`path: "${mod.relativePath}"\` for the containing module overview`,
     );
   }
 

package/src/brief.ts

@@ -64,7 +64,7 @@ export function generateOverview(model: ArchitectureModel): string | null {
     lines.push(formatGitContext(gitCtx));
   }
 
-  lines.push("_Use `code_intel brief` for deeper context on any module or file._");
+  lines.push("_Use `code_brief` for deeper context on any module or file._");
 
   return lines.join("\n");
 }
@@ -208,11 +208,11 @@ function buildNextQueries(model: ArchitectureModel, publicSurfaces: string[]): s
   if (model.modules.length > 0) {
     const firstMod = model.modules[0];
     nextQueries.push(
-      `\`code_intel brief\` with \`path: "${firstMod.relativePath}"\` for a focused module brief`,
+      `\`code_brief\` with \`path: "${firstMod.relativePath}"\` for a focused module brief`,
     );
   }
   if (publicSurfaces.length > 0) {
-    nextQueries.push("`code_intel affected` before modifying shared exports");
+    nextQueries.push("`code_affected` before modifying shared exports");
   }
   return nextQueries;
 }

package/src/code-intelligence.ts

@@ -1,22 +1,16 @@
-// Code Intelligence extension entry point — registers the `code_intel` tool with pi.
-// Provides architecture briefs, caller/callee analysis, impact assessment, and pattern search.
+// Code Intelligence extension entry point — registers the focused code-intelligence tools.
+// Provides architecture briefs, project maps, relationship tracing, impact assessment, and pattern search.
 
-import { StringEnum } from "@earendil-works/pi-ai";
 import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 import { buildArchitectureModel } from "./architecture.ts";
 import { generateOverview } from "./brief.ts";
-import { CODE_INTEL_ACTION_NAMES, type CodeIntelAction } from "./tool/action-specs.ts";
-import { promptGuidelines, promptSnippet, toolDescription } from "./tool/guidance.ts";
-import { executeAction } from "./tool-actions.ts";
+import { registerCodeIntelligenceTools } from "./tool/register-tools.ts";
 
 const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
 
-const CodeIntelActionEnum = StringEnum(CODE_INTEL_ACTION_NAMES);
-
 /**
- * Register the `code_intel` tool and inject a lightweight architecture overview
- * once per session.
+ * Register the focused code-intelligence tools and inject a lightweight
+ * architecture overview once per session.
  */
 export default function codeIntelligenceExtension(pi: ExtensionAPI) {
   let hasInjectedOverview = false;
@@ -56,68 +50,5 @@ export default function codeIntelligenceExtension(pi: ExtensionAPI) {
     },
   );
 
-  pi.registerTool({
-    name: "code_intel",
-    label: "Code Intelligence",
-    description: toolDescription,
-    parameters: Type.Object({
-      action: CodeIntelActionEnum,
-      path: Type.Optional(
-        Type.String({ description: "Scope or focus path (package, directory, or file)" }),
-      ),
-      file: Type.Optional(
-        Type.String({
-          description:
-            "Anchored target file (use with line/character) or a file-level semantic target for brief/callers/affected",
-        }),
-      ),
-      line: Type.Optional(Type.Number({ description: "1-based line number for anchored target" })),
-      character: Type.Optional(
-        Type.Number({ description: "1-based character column (UTF-16) for anchored target" }),
-      ),
-      symbol: Type.Optional(
-        Type.String({ description: "Symbol name for discovery-based resolution" }),
-      ),
-      pattern: Type.Optional(
-        Type.String({
-          description: "Text search pattern (pattern action only; literal by default)",
-        }),
-      ),
-      regex: Type.Optional(
-        Type.Boolean({
-          description: "Use regex semantics for pattern action (default: false, literal search)",
-        }),
-      ),
-      kind: Type.Optional(
-        Type.String({
-          description:
-            "Symbol kind filter for discovery, or pattern kind (`definition` | `export` | `import`) for structured searches",
-        }),
-      ),
-      exportedOnly: Type.Optional(
-        Type.Boolean({ description: "Limit discovery to exported symbols" }),
-      ),
-      maxResults: Type.Optional(Type.Number({ description: "Maximum results to return" })),
-      contextLines: Type.Optional(Type.Number({ description: "Context lines around matches" })),
-      summary: Type.Optional(
-        Type.Boolean({
-          description:
-            "Aggregate counts by directory instead of line-level matches (pattern action only)",
-        }),
-      ),
-    }),
-    promptSnippet,
-    promptGuidelines,
-    // biome-ignore lint/complexity/useMaxParams: pi ToolDefinition.execute signature
-    execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => {
-      const { content, details } = await executeAction(
-        params as unknown as { action: CodeIntelAction } & Record<string, unknown>,
-        { cwd: ctx.cwd },
-      );
-      return {
-        content: [{ type: "text", text: content }],
-        details,
-      };
-    },
-  });
+  registerCodeIntelligenceTools(pi);
 }

package/src/index.ts

@@ -24,5 +24,6 @@ export type {
   CodeIntelResult,
   ConfidenceMode,
   DisambiguationCandidate,
+  MapDetails,
   SearchDetails,
 } from "./types.ts";

package/src/pattern-structured.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { withStructuralSession } from "./providers/structural-provider.ts";
-import type { ActionParams } from "./tool-actions.ts";
+import type { CodeQueryParams as ActionParams } from "./query-params.ts";
 
 export const STRUCTURED_PATTERN_FILE_CAP = 200;
 const STRUCTURED_PATTERN_TIMEOUT_MS = 10_000;

package/src/prioritization-signals.ts

@@ -1,5 +1,5 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
+import { readJsonFile } from "@mrclrchtr/supi-core/api";
 import { getSessionLspService } from "@mrclrchtr/supi-lsp/api";
 
 export interface PrioritySignalsSummary {
@@ -106,22 +106,18 @@ function loadDiagnostics(
 
 function loadCoverageSummary(cwd: string): Map<string, number> {
   const coveragePath = path.join(cwd, "coverage", "coverage-summary.json");
-  if (!fs.existsSync(coveragePath)) return new Map();
-
-  try {
-    const parsed = JSON.parse(fs.readFileSync(coveragePath, "utf-8")) as Record<string, unknown>;
-    const map = new Map<string, number>();
-    for (const [file, value] of Object.entries(parsed)) {
-      if (file === "total" || typeof value !== "object" || value === null) continue;
-      const linesPct = getPct(value, "lines");
-      const statementsPct = getPct(value, "statements");
-      const pct = Math.min(linesPct ?? 100, statementsPct ?? 100);
-      map.set(path.resolve(cwd, file), pct);
-    }
-    return map;
-  } catch {
-    return new Map();
+  const parsed = readJsonFile(coveragePath);
+  if (!parsed) return new Map();
+
+  const map = new Map<string, number>();
+  for (const [file, value] of Object.entries(parsed)) {
+    if (file === "total" || typeof value !== "object" || value === null) continue;
+    const linesPct = getPct(value, "lines");
+    const statementsPct = getPct(value, "statements");
+    const pct = Math.min(linesPct ?? 100, statementsPct ?? 100);
+    map.set(path.resolve(cwd, file), pct);
   }
+  return map;
 }
 
 function loadUnusedFiles(cwd: string): Set<string> {
@@ -157,16 +153,7 @@ function loadUnusedExports(cwd: string): Array<{ file: string; name: string }> {
 }
 
 function loadKnipJson(cwd: string): Record<string, unknown> | null {
-  const knipPath = path.join(cwd, "knip.json");
-  if (!fs.existsSync(knipPath)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(knipPath, "utf-8"));
-    return typeof parsed === "object" && parsed !== null
-      ? (parsed as Record<string, unknown>)
-      : null;
-  } catch {
-    return null;
-  }
+  return readJsonFile(path.join(cwd, "knip.json"));
 }
 
 function getPct(value: object, key: string): number | null {

package/src/query-params.ts

@@ -0,0 +1,15 @@
+/** Shared parameter bag for internal code-intelligence actions. */
+export interface CodeQueryParams {
+  path?: string;
+  file?: string;
+  line?: number;
+  character?: number;
+  symbol?: string;
+  pattern?: string;
+  regex?: boolean;
+  kind?: string;
+  exportedOnly?: boolean;
+  maxResults?: number;
+  contextLines?: number;
+  summary?: boolean;
+}

package/src/resolve-target.ts

@@ -1,3 +1,4 @@
+import type { CodeQueryParams as ActionParams } from "./query-params.ts";
 import {
   type ResolvedTarget,
   type ResolvedTargetGroup,
@@ -5,7 +6,6 @@ import {
   resolveFileTargetGroup,
   resolveSymbolTarget,
 } from "./target-resolution.ts";
-import type { ActionParams } from "./tool-actions.ts";
 
 /**
  * Resolve a target from action params. Returns either a target, a file-level target group,
@@ -104,7 +104,7 @@ function formatDisambiguation(
   if (result.candidates.length > 0) {
     const first = result.candidates[0];
     lines.push(
-      `Example: \`{ "action": "${params.action}", "file": "${first.file}", "line": ${first.line}, "character": ${first.character} }\``,
+      `Example: rerun with \`file: "${first.file}"\`, \`line: ${first.line}\`, and \`character: ${first.character}\`.`,
     );
   }
 

package/src/search-helpers.ts

@@ -1,4 +1,4 @@
-// Shared search helpers for code_intel actions.
+// Shared search helpers for code-intelligence search and routing helpers.
 
 import { execFileSync } from "node:child_process";
 import * as path from "node:path";
@@ -71,7 +71,7 @@ export interface RipgrepRunResult {
 /**
  * Run ripgrep with JSON output and parse matches, filtering low-signal paths.
  *
- * This helper preserves the historical behavior used by most `code_intel`
+ * This helper preserves the historical behavior used by internal
  * actions: any ripgrep execution failure is treated like an empty match set.
  * Call `runRipgrepDetailed()` when a caller needs to surface regex parse errors
  * or other non-no-match failures to the agent.