@mrclrchtr/supi-code-intelligence 1.16.0 → 2.0.0

package/src/presentation/markdown/relations.ts

@@ -1,121 +0,0 @@
-// Relations markdown renderer — consumes use-case data and produces markdown content.
-
-import { isInProjectPath, uriToFile } from "../../search-helpers.ts";
-import type { ReferenceCollection } from "../../use-case/support/semantic-references.ts";
-import { formatReferenceList } from "../../use-case/support/semantic-references.ts";
-
-// ── Callers ──────────────────────────────────────────────────────────
-
-export function renderCallersResult(
-  symbolName: string,
-  result: ReferenceCollection,
-  cwd: string,
-  maxResults: number,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Callers of \`${symbolName}\``);
-  lines.push("");
-  lines.push(
-    `**${result.refs.length} reference${result.refs.length !== 1 ? "s" : ""}** (${result.confidence})`,
-  );
-  if (result.externalCount > 0) {
-    lines.push(
-      `_+${result.externalCount} external reference${result.externalCount !== 1 ? "s" : ""}_`,
-    );
-  }
-  lines.push("");
-
-  formatReferenceList(lines, result.refs, maxResults, cwd);
-  return lines.join("\n");
-}
-
-// ── Implementations ──────────────────────────────────────────────────
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: implementation rendering with project/external splitting and formatting is clearer as one function
-export function renderImplementationsResult(
-  locations: Array<{
-    uri?: string;
-    targetUri?: string;
-    range?: { start: { line: number } };
-    targetRange?: { start: { line: number } };
-    targetSelectionRange?: { start: { line: number } };
-  }>,
-  cwd: string,
-  maxResults: number,
-): string {
-  const projectLocs = locations.filter((loc) => {
-    const uri = loc.uri ?? loc.targetUri ?? "";
-    const filePath = uriToFile(uri);
-    return filePath && isInProjectPath(filePath, cwd);
-  });
-  const externalLocs = locations.filter((loc) => {
-    const uri = loc.uri ?? loc.targetUri ?? "";
-    const filePath = uriToFile(uri);
-    return !filePath || !isInProjectPath(filePath, cwd);
-  });
-
-  const lines: string[] = [];
-  lines.push("# Implementations (semantic)");
-  lines.push("");
-  if (projectLocs.length > 0) {
-    lines.push(
-      `**${projectLocs.length} implementation${projectLocs.length !== 1 ? "s" : ""}** in the project`,
-    );
-    lines.push("");
-    for (const loc of projectLocs.slice(0, maxResults)) {
-      const uri = loc.uri ?? loc.targetUri ?? "";
-      const filePath = uriToFile(uri);
-      const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
-      if (filePath && range) {
-        lines.push(`- \`${filePath}:${(range as { start: { line: number } }).start.line + 1}\``);
-      } else if (filePath) {
-        lines.push(`- \`${filePath}\``);
-      }
-    }
-    lines.push("");
-  }
-
-  if (externalLocs.length > 0) {
-    lines.push(
-      `_+${externalLocs.length} external location${externalLocs.length !== 1 ? "s" : ""} (outside this project)_`,
-    );
-    lines.push("");
-  }
-
-  lines.push(
-    "_Semantic analysis. Use `code_pattern` only when you explicitly want text-search hints for likely implementations._",
-  );
-  lines.push("");
-
-  return lines.join("\n");
-}
-
-// ── Callees ──────────────────────────────────────────────────────────
-
-export function renderCalleesResult(
-  data: { enclosingScope: { name: string }; callees: Array<{ name: string; startLine: number }> },
-  relPath: string,
-  maxResults: number,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Callees of \`${data.enclosingScope.name}\` (structural)`);
-  lines.push("");
-  lines.push(
-    `**${data.callees.length} outgoing call${data.callees.length > 1 ? "s" : ""}** from \`${data.enclosingScope.name}\` in \`${relPath}\``,
-  );
-  lines.push("");
-
-  const shown = data.callees.slice(0, maxResults);
-  for (const c of shown) {
-    lines.push(`- \`${c.name}\` (L${c.startLine})`);
-  }
-  if (data.callees.length > maxResults) {
-    lines.push(`- _+${data.callees.length - maxResults} more_`);
-  }
-  lines.push("");
-  lines.push(
-    "_Structural analysis — may include unresolved or qualified names. Use `lsp_hover` with `file`, `line`, and `character` for precise type information._",
-  );
-  lines.push("");
-  return lines.join("\n");
-}

package/src/resolve-target.ts

@@ -1,130 +0,0 @@
-/**
- * Action-facing target resolution — routes normalized queries and
- * maps typed resolver outcomes to user-facing strings and legacy types.
- *
- * This is the thin orchestration layer between tool/action params and
- * the typed targeting pipeline. Formatting of disambiguation/error
- * outcomes happens here, at the action boundary.
- */
-
-import type { CodeQueryParams as ActionParams } from "./query-params.ts";
-import {
-  type ResolvedTarget,
-  type ResolvedTargetGroup,
-  resolveAnchoredTarget,
-  resolveFileTargetGroup,
-  resolveSymbolTarget,
-} from "./target-resolution.ts";
-import { normalizeQuery } from "./targeting/query.ts";
-import type { ResolverDeps, TargetOutcome } from "./targeting/types.ts";
-
-/**
- * Resolve a target from action params.
- *
- * Returns either a {@link ResolvedTarget}, a {@link ResolvedTargetGroup},
- * or a user-facing error/disambiguation string.
- */
-export async function resolveTarget(
-  params: ActionParams,
-  cwd: string,
-  semantic?: import("./substrates/types.ts").SemanticSubstrate,
-): Promise<ResolvedTarget | ResolvedTargetGroup | string> {
-  const query = normalizeQuery(params);
-
-  switch (query.kind) {
-    case "anchored":
-      return resolveAnchored(query.file, query.line, query.character, cwd);
-
-    case "file":
-      return resolveByFile(query.file, cwd);
-
-    case "symbol": {
-      if (!semantic) {
-        return "**Error:** Symbol discovery requires active LSP. Use `file` + coordinates, or enable LSP and retry.";
-      }
-      const deps: ResolverDeps = { cwd, semantic };
-      return resolveBySymbol(query.symbol, deps, {
-        path: query.path,
-        kind: query.symbolKind,
-        exportedOnly: query.exportedOnly,
-      });
-    }
-
-    case "invalid":
-      return `**Error:** ${query.reason}`;
-  }
-}
-
-function resolveAnchored(
-  file: string,
-  line: number,
-  character: number,
-  cwd: string,
-): ResolvedTarget | string {
-  const result = resolveAnchoredTarget(file, line, character, cwd);
-  if (result.kind === "error") return result.message;
-  if (result.kind === "resolved") return result.target;
-  return "**Error:** Unexpected resolution outcome.";
-}
-
-async function resolveByFile(file: string, cwd: string): Promise<ResolvedTargetGroup | string> {
-  const result = await resolveFileTargetGroup(file, cwd);
-  if (result.kind === "error") return result.message;
-  return result.group;
-}
-
-async function resolveBySymbol(
-  symbol: string,
-  deps: ResolverDeps,
-  options?: { path?: string; kind?: string; exportedOnly?: boolean },
-): Promise<ResolvedTarget | string> {
-  const outcome: TargetOutcome = await resolveSymbolTarget(
-    symbol,
-    deps.cwd,
-    // biome-ignore lint/style/noNonNullAssertion: semantic is always set for symbol queries
-    deps.semantic!,
-    options,
-  );
-
-  if (outcome.kind === "resolved") {
-    return outcome.target as ResolvedTarget;
-  }
-
-  if (outcome.kind === "error") {
-    return outcome.message;
-  }
-
-  return formatDisambiguation(symbol, outcome);
-}
-
-function formatDisambiguation(
-  symbol: string,
-  result: Extract<TargetOutcome, { kind: "disambiguation" }>,
-): string {
-  const lines: string[] = [];
-  lines.push(`# Disambiguation needed for \`${symbol}\``);
-  lines.push("");
-  const omitNote = result.omittedCount > 0 ? ` (+${result.omittedCount} more)` : "";
-  lines.push(
-    `Found ${result.candidates.length} candidates${omitNote}. Rerun with anchored coordinates:`,
-  );
-  lines.push("");
-
-  for (const c of result.candidates) {
-    const kind = c.kind ? ` (${c.kind})` : "";
-    const container = c.container ? ` in ${c.container}` : "";
-    lines.push(
-      `${c.rank}. **${c.name}**${kind}${container} — \`${c.file}\`:${c.line}:${c.character}`,
-    );
-  }
-
-  lines.push("");
-  if (result.candidates.length > 0) {
-    const first = result.candidates[0];
-    lines.push(
-      `Example: rerun with \`file: "${first.file}"\`, \`line: ${first.line}\`, and \`character: ${first.character}\`.`,
-    );
-  }
-
-  return lines.join("\n");
-}

package/src/search-helpers.ts

@@ -1,303 +0,0 @@
-// Shared search helpers for code-intelligence search and routing helpers.
-
-import { execFileSync } from "node:child_process";
-import * as path from "node:path";
-import { resolveToolPath, uriToFile as uriToFileShared } from "@mrclrchtr/supi-core/path";
-
-const LOW_SIGNAL_DIRS = new Set([
-  "node_modules",
-  ".git",
-  ".pnpm",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  ".nuxt",
-  "coverage",
-  ".turbo",
-  ".cache",
-  "__pycache__",
-  ".tsbuildinfo",
-]);
-
-/** Check if a file path contains an obviously low-signal directory segment. */
-export function isLowSignalPath(filePath: string): boolean {
-  const segments = filePath.split(path.sep);
-  return segments.some((s) => LOW_SIGNAL_DIRS.has(s));
-}
-
-/** Convert a file:// URI to a file path, matching the shared SuPi normalization. */
-export const uriToFile = uriToFileShared;
-
-/** Check whether a resolved file path is inside the current project (within cwd, not under node_modules or .pnpm). */
-export function isInProjectPath(filePath: string, cwd: string): boolean {
-  const relativePath = path.relative(cwd, path.resolve(cwd, filePath));
-  if (relativePath.startsWith(`..${path.sep}`) || relativePath === "..") return false;
-  const normalized = relativePath.replaceAll("\\", "/");
-  return !(
-    normalized.includes("/node_modules/") ||
-    normalized.startsWith("node_modules/") ||
-    normalized.includes("/.pnpm/") ||
-    normalized.startsWith(".pnpm/")
-  );
-}
-
-/** Escape regex special characters. */
-export function escapeRegex(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-/** Normalize a file/path value: strip leading @, resolve relative to cwd. */
-export function normalizePath(input: string, cwd: string): string {
-  return resolveToolPath(cwd, input);
-}
-
-export interface RgMatch {
-  file: string;
-  line: number;
-  text: string;
-  /** Context lines surrounding this match (from -C flag). */
-  context?: Array<{ line: number; text: string }>;
-}
-
-/** Result of a ripgrep invocation for callers that need both matches and execution errors. */
-export interface RipgrepRunResult {
-  /** Parsed ripgrep matches, if any. */
-  matches: RgMatch[];
-  /** Non-no-match ripgrep execution error text, such as invalid regex syntax. */
-  error?: string;
-}
-
-/**
- * Run ripgrep with JSON output and parse matches, filtering low-signal paths.
- *
- * 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.
- */
-export function runRipgrep(
-  pattern: string,
-  scopePath: string,
-  cwd: string,
-  opts?: {
-    maxMatches?: number;
-    contextLines?: number;
-    literal?: boolean;
-    filterLowSignal?: boolean;
-  },
-): RgMatch[] {
-  return runRipgrepDetailed(pattern, scopePath, cwd, opts).matches;
-}
-
-/**
- * Run ripgrep and preserve non-no-match execution errors for callers that need
- * to distinguish invalid regex syntax from a genuine empty search result.
- */
-export function runRipgrepDetailed(
-  pattern: string,
-  scopePath: string,
-  cwd: string,
-  opts?: {
-    maxMatches?: number;
-    contextLines?: number;
-    literal?: boolean;
-    filterLowSignal?: boolean;
-  },
-): RipgrepRunResult {
-  const filter = opts?.filterLowSignal ?? true;
-
-  try {
-    const result = execFileSync("rg", buildRipgrepArgs(pattern, scopePath, opts), {
-      encoding: "utf-8",
-      cwd,
-      timeout: 10000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    return { matches: parseRgJson(result, filter) };
-  } catch (err: unknown) {
-    return handleRipgrepError(err, filter);
-  }
-}
-
-function buildRipgrepArgs(
-  pattern: string,
-  scopePath: string,
-  opts?: { maxMatches?: number; contextLines?: number; literal?: boolean },
-): string[] {
-  const args = ["--json", "-m", String(opts?.maxMatches ?? 30)];
-  if ((opts?.contextLines ?? 0) > 0) {
-    args.push("-C", String(opts?.contextLines ?? 0));
-  }
-  if (opts?.literal) {
-    args.push("-F");
-  }
-  args.push("-e", pattern, scopePath);
-  return args;
-}
-
-function handleRipgrepError(err: unknown, filterLowSignal: boolean): RipgrepRunResult {
-  // ENOENT means rg is not installed — surface a clear error instead of silent empty results
-  if (isCodeError(err, "ENOENT")) {
-    return {
-      matches: [],
-      error:
-        "ripgrep (rg) is not available. Install it (e.g., `apt install ripgrep` or `brew install ripgrep`).",
-    };
-  }
-
-  if (!isExecError(err)) {
-    return { matches: [] };
-  }
-
-  const stdout = typeof err.stdout === "string" ? err.stdout : "";
-  const stderr = typeof err.stderr === "string" ? err.stderr.trim() : "";
-  const matches = stdout ? parseRgJson(stdout, filterLowSignal) : [];
-
-  if (err.status === 1) {
-    return { matches };
-  }
-
-  return {
-    matches,
-    ...(stderr ? { error: stderr } : {}),
-  };
-}
-
-function isExecError(err: unknown): err is { status: number; stdout?: unknown; stderr?: unknown } {
-  return typeof err === "object" && err !== null && "status" in err;
-}
-
-function isCodeError(err: unknown, code: string): boolean {
-  return (
-    typeof err === "object" &&
-    err !== null &&
-    "code" in err &&
-    (err as { code: unknown }).code === code
-  );
-}
-
-interface RawRgEvent {
-  type: string;
-  data?: {
-    path?: { text: string };
-    line_number?: number;
-    lines?: { text: string };
-  };
-}
-
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: JSON ripgrep output parsing with context line collection
-function parseRgJson(output: string, filterLowSignal: boolean): RgMatch[] {
-  const matches: RgMatch[] = [];
-  // Pending context lines that precede the next match
-  let pendingContext: Array<{ line: number; text: string }> = [];
-
-  for (const line of output.split("\n")) {
-    if (!line.trim()) continue;
-    let parsed: RawRgEvent;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (parsed.type === "context" && parsed.data) {
-      const lineNum = parsed.data.line_number;
-      const text = (parsed.data.lines?.text ?? "").trim();
-      if (lineNum) pendingContext.push({ line: lineNum, text });
-      continue;
-    }
-
-    if (parsed.type === "match" && parsed.data) {
-      const filePath = parsed.data.path?.text;
-      const lineNum = parsed.data.line_number;
-      const text = (parsed.data.lines?.text ?? "").trim();
-      if (filePath && lineNum) {
-        // Split pendingContext: lines before this match are "before" context,
-        // lines from before this match line that trail the previous match stay with it.
-        const beforeCtx = pendingContext.filter((c) => c.line < lineNum);
-        const trailingCtx = pendingContext.filter((c) => c.line >= lineNum);
-
-        // Attach trailing context from previous match to the last accepted match
-        if (beforeCtx.length > 0 && matches.length > 0) {
-          const prev = matches[matches.length - 1];
-          const prevTrailing = beforeCtx.filter((c) => c.line > prev.line);
-          if (prevTrailing.length > 0) {
-            prev.context = [...(prev.context ?? []), ...prevTrailing];
-          }
-        }
-
-        if (filterLowSignal && isLowSignalPath(filePath)) {
-          pendingContext = [];
-          continue;
-        }
-
-        const match: RgMatch = { file: filePath, line: lineNum, text };
-        // Leading context: lines just before this match
-        const leadingCtx =
-          matches.length > 0
-            ? beforeCtx.filter(
-                (c) => c.line <= lineNum && c.line > (matches[matches.length - 1]?.line ?? 0),
-              )
-            : beforeCtx;
-        if (leadingCtx.length > 0) {
-          match.context = leadingCtx;
-        }
-        // Also include any pending context at/after this match's line (trailing from rg ordering)
-        pendingContext = trailingCtx;
-        matches.push(match);
-      } else {
-        pendingContext = [];
-      }
-    }
-  }
-
-  // Attach any trailing context lines to the last match
-  if (pendingContext.length > 0 && matches.length > 0) {
-    const last = matches[matches.length - 1];
-    last.context = [...(last.context ?? []), ...pendingContext];
-  }
-
-  return matches;
-}
-
-/**
- * Minimal interface for a reference-like object with a URI and range start.
- * Used by {@link filterOutDeclaration} to avoid coupling to a specific LspRef type.
- */
-export interface HasLspPosition {
-  uri: string;
-  range: { start: { line: number; character: number } };
-}
-
-/**
- * Filter out the declaration/definition location from LSP references.
- * LSP's `textDocument/references` includes the declaration by default;
- * for callers/affected analysis, the declaration is not a call site or affected reference.
- *
- * Uses {@link uriToFile} for robust URI-to-path conversion.
- */
-export function filterOutDeclaration<T extends HasLspPosition>(
-  refs: T[],
-  targetFile: string,
-  targetPos: { line: number; character: number },
-): T[] {
-  return refs.filter((ref) => {
-    const filePath = uriToFile(ref.uri);
-    if (filePath !== targetFile) return true;
-    const start = ref.range.start;
-    return start.line !== targetPos.line || start.character !== targetPos.character;
-  });
-}
-
-/** Group matches by file. */
-export function groupByFile(matches: RgMatch[]): Map<string, RgMatch[]> {
-  const byFile = new Map<string, RgMatch[]>();
-  for (const m of matches) {
-    const group = byFile.get(m.file) ?? [];
-    group.push(m);
-    byFile.set(m.file, group);
-  }
-  return byFile;
-}

package/src/substrates/types.ts

@@ -1,30 +0,0 @@
-// Substrate interfaces for code-intelligence's semantic (LSP) and
-// structural (tree-sitter) adapters.
-//
-// These are type aliases for the canonical provider contracts
-// now hosted in @mrclrchtr/supi-code-runtime.
-
-import type { SemanticProvider, StructuralProvider } from "@mrclrchtr/supi-code-runtime/api";
-
-export type { CodeLocation, CodePosition } from "../types.ts";
-
-// ── Provider contracts (aliases for shared provider types) ───────────
-
-/** Canonical provider alias — same as SemanticProvider. */
-export type SemanticSubstrate = SemanticProvider;
-
-/** Canonical provider alias — same as StructuralProvider. */
-export type StructuralSubstrate = StructuralProvider;
-
-// ── Value types (re-exported from shared types) ───────────────────────
-
-export type { StructuralResult } from "@mrclrchtr/supi-code-runtime/api";
-export type {
-  CalleesData,
-  CodeResult,
-  CodeSymbol,
-  ExportData,
-  ImportData,
-  NodeAtData,
-  OutlineData,
-} from "../types.ts";