@mrclrchtr/supi-code-intelligence 1.6.0 → 1.8.0

package/src/actions/brief-action.ts

@@ -1,241 +0,0 @@
-// Brief action — architecture overviews and focused briefs.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { TreeSitterService } from "@mrclrchtr/supi-tree-sitter/api";
-import { buildArchitectureModel, findModuleForPath } from "../architecture.ts";
-import { generateFocusedBrief, generateProjectBrief } from "../brief.ts";
-import { withStructuralSession } from "../providers/structural-provider.ts";
-import { normalizePath } from "../search-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
-import type { CodeIntelResult } from "../types.ts";
-
-export async function executeBriefAction(
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const model = await buildArchitectureModel(cwd);
-  if (!model) {
-    return {
-      content:
-        "No project structure detected. This directory has no recognizable project metadata or source files.",
-      details: {
-        type: "brief" as const,
-        data: {
-          confidence: "unavailable",
-          focusTarget: null,
-          startHere: [],
-          publicSurfaces: [],
-          dependencySummary: null,
-          omittedCount: 0,
-          nextQueries: [
-            "Add a package.json or pnpm-workspace.yaml to enable architecture analysis",
-          ],
-        },
-      },
-    };
-  }
-
-  if (params.file && params.line != null && params.character != null) {
-    const content = await executeAnchoredBrief(params, cwd, model);
-    const relPath = path.relative(cwd, normalizePath(params.file ?? "", cwd));
-    const mod = findModuleForPath(model, path.resolve(cwd, relPath));
-    return {
-      content,
-      details: {
-        type: "brief" as const,
-        data: {
-          confidence: "structural",
-          focusTarget: `${relPath}:${params.line}:${params.character}`,
-          startHere: [],
-          publicSurfaces: [],
-          dependencySummary: mod && model ? { moduleCount: 1, edgeCount: 0 } : null,
-          omittedCount: 0,
-          nextQueries: [
-            `\`code_intel callers\` with \`file: "${relPath}", line: ${params.line}, character: ${params.character}\` for call sites`,
-            `\`code_intel affected\` with \`file: "${relPath}", line: ${params.line}, character: ${params.character}\` for impact analysis`,
-          ],
-        },
-      },
-    };
-  }
-
-  if (params.path) {
-    const result = generateFocusedBrief(model, normalizePath(params.path, cwd));
-    return { content: result.content, details: { type: "brief" as const, data: result.details } };
-  }
-
-  if (params.file) {
-    const result = generateFocusedBrief(model, normalizePath(params.file, cwd));
-    return { content: result.content, details: { type: "brief" as const, data: result.details } };
-  }
-
-  const result = generateProjectBrief(model);
-  return { content: result.content, details: { type: "brief" as const, data: result.details } };
-}
-
-async function executeAnchoredBrief(
-  params: ActionParams,
-  cwd: string,
-  model: NonNullable<Awaited<ReturnType<typeof buildArchitectureModel>>>,
-): Promise<string> {
-  const file = normalizePath(params.file ?? "", cwd);
-  const line1 = params.line ?? 1;
-  const char1 = params.character ?? 1;
-  const relPath = path.relative(cwd, file);
-
-  if (!fs.existsSync(file)) {
-    return `**Error:** File not found: \`${params.file}\``;
-  }
-
-  const lines: string[] = [];
-  lines.push(`# Anchored Brief: ${relPath}:${line1}:${char1}`);
-  lines.push("");
-
-  await addTreeSitterContext({ lines, relPath, line1, char1, cwd });
-  addModuleContext(lines, model, file);
-  addNextQueries(lines, relPath, line1, char1);
-
-  return lines.join("\n");
-}
-
-interface TreeSitterContextInput {
-  lines: string[];
-  relPath: string;
-  line1: number;
-  char1: number;
-  cwd: string;
-}
-
-async function addTreeSitterContext(input: TreeSitterContextInput): Promise<void> {
-  const { lines, relPath, line1, char1, cwd } = input;
-  try {
-    await withStructuralSession(cwd, async (tsSession) => {
-      await addNodeContext(lines, tsSession, relPath, { line: line1, char: char1 });
-      await addOutlineContext(lines, tsSession, relPath, line1);
-      await addImportsContext(lines, tsSession, relPath);
-      await addExportsContext(lines, tsSession, relPath);
-    });
-  } catch {
-    // Tree-sitter not available
-  }
-}
-
-async function addNodeContext(
-  lines: string[],
-  ts: TreeSitterService,
-  relPath: string,
-  pos: { line: number; char: number },
-): Promise<void> {
-  const result = await ts.nodeAt(relPath, pos.line, pos.char);
-  if (result.kind !== "success") return;
-  const node = result.data;
-  lines.push(
-    `**Node:** \`${node.type}\` at ${relPath}:${node.range.startLine}:${node.range.startCharacter}`,
-  );
-  if (node.text && node.text.length <= 200) {
-    lines.push("```");
-    lines.push(node.text);
-    lines.push("```");
-  }
-  lines.push("");
-}
-
-async function addOutlineContext(
-  lines: string[],
-  ts: TreeSitterService,
-  relPath: string,
-  line1: number,
-): Promise<void> {
-  const result = await ts.outline(relPath);
-  if (result.kind !== "success") return;
-  const outline = result.data;
-
-  const enclosing = outline.find(
-    (item) => item.range.startLine <= line1 && item.range.endLine >= line1,
-  );
-  if (enclosing) {
-    lines.push(`**Enclosing symbol:** \`${enclosing.name}\` (${enclosing.kind})`);
-    lines.push(`- Range: ${relPath}:${enclosing.range.startLine}–${enclosing.range.endLine}`);
-    lines.push("");
-  }
-
-  if (outline.length > 0) {
-    lines.push("## File Outline");
-    const shown = outline.slice(0, 15);
-    for (const item of shown) {
-      const prefix = getOutlinePrefix(item.kind);
-      lines.push(`- ${prefix} \`${item.name}\` (${item.kind}) L${item.range.startLine}`);
-    }
-    if (outline.length > 15) {
-      lines.push(`- _+${outline.length - 15} more declarations_`);
-    }
-    lines.push("");
-  }
-}
-
-function getOutlinePrefix(kind: string): string {
-  if (kind === "function" || kind === "method") return "ƒ";
-  if (kind === "class") return "◆";
-  return "·";
-}
-
-async function addImportsContext(
-  lines: string[],
-  ts: TreeSitterService,
-  relPath: string,
-): Promise<void> {
-  const result = await ts.imports(relPath);
-  if (result.kind !== "success" || result.data.length === 0) return;
-  lines.push("## Imports");
-  const shown = result.data.slice(0, 10);
-  for (const imp of shown) {
-    lines.push(`- \`${imp.moduleSpecifier}\``);
-  }
-  if (result.data.length > 10) {
-    lines.push(`- _+${result.data.length - 10} more_`);
-  }
-  lines.push("");
-}
-
-async function addExportsContext(
-  lines: string[],
-  ts: TreeSitterService,
-  relPath: string,
-): Promise<void> {
-  const result = await ts.exports(relPath);
-  if (result.kind !== "success" || result.data.length === 0) return;
-  lines.push("## Exports");
-  const shown = result.data.slice(0, 10);
-  for (const exp of shown) {
-    lines.push(`- \`${exp.name}\` (${exp.kind})`);
-  }
-  if (result.data.length > 10) {
-    lines.push(`- _+${result.data.length - 10} more_`);
-  }
-  lines.push("");
-}
-
-function addModuleContext(
-  lines: string[],
-  model: NonNullable<Awaited<ReturnType<typeof buildArchitectureModel>>>,
-  file: string,
-): void {
-  const mod = findModuleForPath(model, file);
-  if (mod) {
-    const shortName = mod.name.replace(/^@[^/]+\//, "");
-    lines.push(`_Module: ${shortName} (\`${mod.relativePath}\`)_`);
-    lines.push("");
-  }
-}
-
-function addNextQueries(lines: string[], relPath: string, line1: number, char1: number): void {
-  lines.push("## Next");
-  lines.push(
-    `- \`code_intel callers\` with \`file: "${relPath}", line: ${line1}, character: ${char1}\` for call sites`,
-  );
-  lines.push(
-    `- \`code_intel affected\` with \`file: "${relPath}", line: ${line1}, character: ${char1}\` for impact analysis`,
-  );
-  lines.push("");
-}

package/src/actions/callees-action.ts

@@ -1,155 +0,0 @@
-// Callees action — structural outgoing call map via Tree-sitter.
-// Orchestrates target resolution and formatting; delegates grammar-aware
-// extraction to @mrclrchtr/supi-tree-sitter/api.
-
-import * as path from "node:path";
-import { withStructuralSession } from "../providers/structural-provider.ts";
-import { resolveTarget } from "../resolve-target.ts";
-import { isResolvedTargetGroup } from "../semantic-action-helpers.ts";
-import type { ActionParams } from "../tool-actions.ts";
-import type { CodeIntelResult, SearchDetails } from "../types.ts";
-
-export async function executeCalleesAction(
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const target = await resolveTarget(params, cwd);
-  if (typeof target === "string") {
-    return {
-      content: target,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable",
-          scope: null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
-        },
-      },
-    };
-  }
-
-  if (isResolvedTargetGroup(target)) {
-    return {
-      content: `**Error:** File-level callee discovery is not available for \`${path.relative(cwd, target.file)}\`.\n\nProvide \`line\` and \`character\`, or a \`symbol\` for discovery.`,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable",
-          scope: params.path ?? null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Use `file` + coordinates or `symbol` for callee lookup"],
-        },
-      },
-    };
-  }
-
-  const relPath = path.relative(cwd, target.file);
-
-  try {
-    const result = await withStructuralSession(cwd, (tsSession) =>
-      tsSession.calleesAt(relPath, target.displayLine, target.displayCharacter),
-    );
-
-    if (result.kind !== "success") {
-      return {
-        content: noCalleesMessage(relPath, target.displayLine, target.displayCharacter),
-        details: {
-          type: "search" as const,
-          data: {
-            confidence: "unavailable",
-            scope: null,
-            candidateCount: 0,
-            omittedCount: 0,
-            nextQueries: [
-              'Use `lsp_lookup` with `kind: "hover"` for type-aware analysis on this file',
-            ],
-          },
-        },
-      };
-    }
-
-    const { enclosingScope, callees } = result.data;
-
-    if (callees.length === 0) {
-      return {
-        content: noCalleesMessage(relPath, target.displayLine, target.displayCharacter),
-        details: {
-          type: "search" as const,
-          data: {
-            confidence: "structural",
-            scope: null,
-            candidateCount: 0,
-            omittedCount: 0,
-            nextQueries: [
-              'Use `tree_sitter` with `action: "outline"` to explore the enclosing function',
-            ],
-          },
-        },
-      };
-    }
-
-    const content = formatCallees(callees, enclosingScope.name, relPath, params.maxResults ?? 8);
-    const details: SearchDetails = {
-      confidence: "structural",
-      scope: null,
-      candidateCount: callees.length,
-      omittedCount: Math.max(0, callees.length - (params.maxResults ?? 8)),
-      nextQueries: [
-        'Use `lsp_lookup` with `kind: "hover"` for precise type information on callees',
-      ],
-    };
-    return { content, details: { type: "search" as const, data: details } };
-  } catch {
-    return {
-      content: noCalleesMessage(relPath, target.displayLine, target.displayCharacter),
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable",
-          scope: null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: [
-            'Use `lsp_lookup` with `kind: "hover"` for type-aware analysis on this file',
-          ],
-        },
-      },
-    };
-  }
-}
-
-function formatCallees(
-  callees: Array<{ name: string; range: { startLine: number } }>,
-  enclosingName: string,
-  relPath: string,
-  maxResults: number,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Callees of \`${enclosingName}\` (structural)`);
-  lines.push("");
-  lines.push(
-    `**${callees.length} outgoing call${callees.length > 1 ? "s" : ""}** from \`${enclosingName}\` in \`${relPath}\``,
-  );
-  lines.push("");
-
-  const shown = callees.slice(0, maxResults);
-  for (const c of shown) {
-    lines.push(`- \`${c.name}\` (L${c.range.startLine})`);
-  }
-  if (callees.length > maxResults) {
-    lines.push(`- _+${callees.length - maxResults} more_`);
-  }
-  lines.push("");
-  lines.push(
-    '_Structural analysis — may include unresolved or qualified names. Use `lsp_lookup` with `kind: "hover"` for precise type information._',
-  );
-  lines.push("");
-  return lines.join("\n");
-}
-
-function noCalleesMessage(relPath: string, line: number, char: number): string {
-  return `No callee data available for ${relPath}:${line}:${char}.\n\nUse \`tree_sitter\` with \`action: "callees"\` for structural drill-down.`;
-}

package/src/actions/callers-action.ts

@@ -1,282 +0,0 @@
-// Callers action — find call sites for a symbol.
-
-import * as path from "node:path";
-import { getSemanticService } from "../providers/semantic-provider.ts";
-import { resolveTarget } from "../resolve-target.ts";
-import {
-  escapeRegex,
-  filterOutDeclaration,
-  isInProjectPath,
-  normalizePath,
-  runRipgrep,
-  uriToFile,
-} from "../search-helpers.ts";
-import {
-  dedupeFileLineRefs,
-  highestConfidence,
-  isResolvedTargetGroup,
-} from "../semantic-action-helpers.ts";
-import type { ResolvedTarget, ResolvedTargetGroup } from "../target-resolution.ts";
-import type { ActionParams } from "../tool-actions.ts";
-import type { CodeIntelResult, ConfidenceMode, SearchDetails } from "../types.ts";
-
-export async function executeCallersAction(
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const target = await resolveTarget(params, cwd);
-  if (typeof target === "string") {
-    return {
-      content: target,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: "unavailable",
-          scope: null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Provide `file`, `line`, `character` or a `symbol` to resolve the target"],
-        },
-      },
-    };
-  }
-
-  if (isResolvedTargetGroup(target)) {
-    return executeFileLevelCallers(target, params, cwd);
-  }
-
-  const result = await collectCallerRefs(target, params, cwd);
-  if (result.refs.length > 0) {
-    const content = formatTargetCallers(
-      `Callers of \`${target.name ?? "symbol"}\``,
-      result,
-      cwd,
-      params,
-    );
-    const details: SearchDetails = {
-      confidence: result.confidence,
-      scope: params.path ?? null,
-      candidateCount: result.candidateCount,
-      omittedCount: result.externalCount,
-      nextQueries: [
-        "`code_intel affected` for impact analysis",
-        "`code_intel pattern` with broader scope for additional matches",
-      ],
-    };
-    return { content, details: { type: "search" as const, data: details } };
-  }
-
-  if (target.name) {
-    return {
-      content: `No references found for \`${target.name}\` (${result.confidence}).`,
-      details: {
-        type: "search" as const,
-        data: {
-          confidence: result.confidence,
-          scope: params.path ?? null,
-          candidateCount: 0,
-          omittedCount: 0,
-          nextQueries: ["Enable LSP for `semantic` caller accuracy"],
-        },
-      },
-    };
-  }
-
-  const relPath = path.relative(cwd, target.file);
-  return {
-    content: `No caller data available for ${relPath}:${target.displayLine}:${target.displayCharacter}. LSP may not be active.\n\nTry \`code_intel pattern\` with the symbol name for text-search matches.`,
-    details: {
-      type: "search" as const,
-      data: {
-        confidence: "unavailable",
-        scope: params.path ?? null,
-        candidateCount: 0,
-        omittedCount: 0,
-        nextQueries: ["Enable LSP for semantic caller resolution, or try `code_intel pattern`"],
-      },
-    },
-  };
-}
-
-interface CallerRef {
-  file: string;
-  line: number;
-}
-
-interface CallerCollection {
-  refs: CallerRef[];
-  confidence: ConfidenceMode;
-  externalCount: number;
-  candidateCount: number;
-}
-
-async function executeFileLevelCallers(
-  targetGroup: ResolvedTargetGroup,
-  params: ActionParams,
-  cwd: string,
-): Promise<CodeIntelResult> {
-  const perTarget = await Promise.all(
-    targetGroup.targets.map(async (target) => ({
-      target,
-      result: await collectCallerRefs(target, params, cwd),
-    })),
-  );
-
-  const withRefs = perTarget.filter((entry) => entry.result.refs.length > 0);
-  const uniqueRefs = dedupeFileLineRefs(withRefs.flatMap((entry) => entry.result.refs));
-  const confidence = highestConfidence(withRefs.map((entry) => entry.result.confidence));
-  const externalCount = withRefs.reduce((sum, entry) => sum + entry.result.externalCount, 0);
-
-  const lines: string[] = [];
-  lines.push(`# Callers in \`${targetGroup.displayName}\``);
-  lines.push("");
-  lines.push(
-    `**${targetGroup.targets.length} exported target${targetGroup.targets.length !== 1 ? "s" : ""}** | **${uniqueRefs.length} reference${uniqueRefs.length !== 1 ? "s" : ""}** (${confidence})`,
-  );
-  if (externalCount > 0) {
-    lines.push(`_+${externalCount} external reference${externalCount !== 1 ? "s" : ""}_`);
-  }
-  lines.push("");
-
-  for (const entry of withRefs) {
-    lines.push(`## \`${entry.target.name ?? "symbol"}\``);
-    addRefList(lines, entry.result.refs, cwd, params.maxResults ?? 5);
-    lines.push("");
-  }
-
-  if (withRefs.length === 0) {
-    lines.push("No caller references found for the discovered file-level targets.");
-    lines.push("");
-  }
-
-  const details: SearchDetails = {
-    confidence,
-    scope: params.path ?? null,
-    candidateCount: uniqueRefs.length,
-    omittedCount: externalCount,
-    nextQueries: [
-      "`code_intel affected` for impact analysis",
-      "Use `file` + coordinates to drill into one symbol precisely",
-    ],
-  };
-
-  return { content: lines.join("\n"), details: { type: "search" as const, data: details } };
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: LSP-first caller collection with fallback and declaration filtering is clearest in one helper
-async function collectCallerRefs(
-  target: ResolvedTarget,
-  params: ActionParams,
-  cwd: string,
-): Promise<CallerCollection> {
-  const lsp = await getSemanticService(cwd, { waitForReady: true });
-
-  if (lsp) {
-    const refs = await lsp.references(target.file, target.position);
-    if (refs && refs.length > 0) {
-      const filtered = filterOutDeclaration(refs, target.file, target.position);
-      const projectRefs: CallerRef[] = [];
-      let externalCount = 0;
-      for (const ref of refs) {
-        const filePath = uriToFile(ref.uri);
-        if (!isInProjectPath(filePath, cwd)) {
-          externalCount++;
-        }
-      }
-      for (const ref of filtered) {
-        const filePath = uriToFile(ref.uri);
-        if (isInProjectPath(filePath, cwd)) {
-          projectRefs.push({ file: path.relative(cwd, filePath), line: ref.range.start.line + 1 });
-        }
-      }
-      if (projectRefs.length > 0) {
-        return {
-          refs: projectRefs,
-          confidence: "semantic",
-          externalCount,
-          candidateCount: projectRefs.length,
-        };
-      }
-    }
-  }
-
-  if (!target.name) {
-    return { refs: [], confidence: "unavailable", externalCount: 0, candidateCount: 0 };
-  }
-
-  const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
-  const pattern = `\\b${escapeRegex(target.name)}\\b`;
-  const matches = runRipgrep(pattern, scopePath, cwd, { maxMatches: (params.maxResults ?? 8) * 3 });
-  const refs = matches
-    .filter((match) => !isDeclarationMatch(match.file, match.line, target, cwd))
-    .map((match) => ({
-      file: path.relative(cwd, path.resolve(cwd, match.file)),
-      line: match.line,
-    }));
-
-  return { refs, confidence: "heuristic", externalCount: 0, candidateCount: refs.length };
-}
-
-function formatTargetCallers(
-  title: string,
-  result: CallerCollection,
-  cwd: string,
-  params: ActionParams,
-): string {
-  const lines: string[] = [];
-  lines.push(`# ${title}`);
-  lines.push("");
-  lines.push(
-    `**${result.candidateCount} reference${result.candidateCount !== 1 ? "s" : ""}** (${result.confidence})`,
-  );
-  if (result.externalCount > 0) {
-    lines.push(
-      `_+${result.externalCount} external reference${result.externalCount !== 1 ? "s" : ""}_`,
-    );
-  }
-  lines.push("");
-  addRefList(lines, result.refs, cwd, params.maxResults ?? 5);
-  return lines.join("\n");
-}
-
-function addRefList(lines: string[], refs: CallerRef[], cwd: string, maxResults: number): void {
-  const byFile = groupRefsByFile(refs, cwd);
-  let shown = 0;
-  for (const [file, locations] of byFile) {
-    if (shown >= maxResults) break;
-    lines.push(`### ${file}`);
-    for (const loc of locations.slice(0, 5)) {
-      lines.push(`- L${loc}`);
-    }
-    if (locations.length > 5) {
-      lines.push(`- _+${locations.length - 5} more in this file_`);
-    }
-    lines.push("");
-    shown++;
-  }
-
-  if (byFile.size > maxResults) {
-    lines.push(
-      `_+${byFile.size - maxResults} more files omitted. Narrow with \`path\` or increase \`maxResults\`._`,
-    );
-  }
-}
-
-function groupRefsByFile(refs: CallerRef[], _cwd: string): Map<string, number[]> {
-  const byFile = new Map<string, number[]>();
-  for (const ref of refs) {
-    const group = byFile.get(ref.file) ?? [];
-    group.push(ref.line);
-    byFile.set(ref.file, group);
-  }
-  return byFile;
-}
-
-function isDeclarationMatch(
-  file: string,
-  line: number,
-  target: ResolvedTarget,
-  cwd: string,
-): boolean {
-  return path.resolve(cwd, file) === target.file && line === target.displayLine;
-}