@mrclrchtr/supi-code-intelligence 0.1.0

package/src/actions/callers-action.ts

@@ -0,0 +1,215 @@
+// Callers action — find call sites for a symbol.
+
+import * as path from "node:path";
+import { getSessionLspService } from "@mrclrchtr/supi-lsp";
+import { resolveTarget } from "../resolve-target.ts";
+import {
+  escapeRegex,
+  filterOutDeclaration,
+  groupByFile,
+  isInProjectPath,
+  normalizePath,
+  runRipgrep,
+  uriToFile,
+} from "../search-helpers.ts";
+import type { ActionParams } from "../tool-actions.ts";
+import type { CodeIntelResult, 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"],
+        },
+      },
+    };
+  }
+
+  const maxResults = params.maxResults ?? 5;
+  const lspState = getSessionLspService(cwd);
+
+  if (lspState.kind === "ready") {
+    const refs = await lspState.service.references(target.file, target.position);
+    if (refs && refs.length > 0) {
+      // Filter out the declaration itself — LSP includes it with includeDeclaration
+      const callerRefs = filterOutDeclaration(refs, target.file, target.position);
+      if (callerRefs.length > 0) {
+        const content = formatSemanticCallers(callerRefs, target.name, cwd, maxResults);
+        const { project: projectRefs, external: externalRefs } = partitionRefs(refs, cwd);
+        const details: SearchDetails = {
+          confidence: "semantic",
+          scope: params.path ?? null,
+          candidateCount: projectRefs.length,
+          omittedCount: externalRefs.length,
+          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) {
+    const result = formatHeuristicCallers(target.name, params, cwd);
+    const details: SearchDetails = {
+      confidence: "heuristic",
+      scope: params.path ?? null,
+      candidateCount: result.matchCount,
+      omittedCount: 0,
+      nextQueries: ["Enable LSP for `semantic` caller accuracy"],
+    };
+    return { content: result.content, details: { type: "search" as const, data: details } };
+  }
+
+  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`"],
+      },
+    },
+  };
+}
+
+function partitionRefs(
+  refs: Array<{ uri: string; range: { start: { line: number; character: number } } }>,
+  cwd: string,
+): { project: typeof refs; external: typeof refs } {
+  const project: typeof refs = [];
+  const external: typeof refs = [];
+  for (const ref of refs) {
+    if (isInProjectPath(uriToFile(ref.uri), cwd)) {
+      project.push(ref);
+    } else {
+      external.push(ref);
+    }
+  }
+  return { project, external };
+}
+
+function groupRefsByFile(
+  refs: Array<{ uri: string; range: { start: { line: number; character: number } } }>,
+  cwd: string,
+): Map<string, number[]> {
+  const byFile = new Map<string, number[]>();
+  for (const ref of refs) {
+    const filePath = uriToFile(ref.uri);
+    const relPath = path.relative(cwd, filePath);
+    const group = byFile.get(relPath) ?? [];
+    group.push(ref.range.start.line + 1);
+    byFile.set(relPath, group);
+  }
+  return byFile;
+}
+
+function formatSemanticCallers(
+  refs: Array<{ uri: string; range: { start: { line: number; character: number } } }>,
+  name: string | null,
+  cwd: string,
+  maxResults: number,
+): string {
+  const { project: projectRefs, external: externalRefs } = partitionRefs(refs, cwd);
+
+  const lines: string[] = [];
+  lines.push(`# Callers of \`${name ?? "symbol"}\``);
+  lines.push("");
+  lines.push(
+    `**${projectRefs.length} reference${projectRefs.length !== 1 ? "s" : ""}** (semantic)`,
+  );
+  if (externalRefs.length > 0) {
+    const suffix =
+      externalRefs.length === 1
+        ? "+1 external reference"
+        : `+${externalRefs.length} external references`;
+    lines.push(`_${suffix} (node_modules, .pnpm, or out-of-tree)_`);
+  }
+  lines.push("");
+
+  const byFile = groupRefsByFile(projectRefs, 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\`._`,
+    );
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function formatHeuristicCallers(
+  symbol: string,
+  params: ActionParams,
+  cwd: string,
+): { content: string; matchCount: number } {
+  const maxResults = params.maxResults ?? 8;
+  const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
+  const pattern = `\\b${escapeRegex(symbol)}\\b`;
+  const matches = runRipgrep(pattern, scopePath, cwd, { maxMatches: maxResults * 3 });
+
+  if (matches.length === 0) {
+    return { content: `No references found for \`${symbol}\` (heuristic).`, matchCount: 0 };
+  }
+
+  const lines: string[] = [];
+  lines.push(`# Callers of \`${symbol}\` (heuristic)`);
+  lines.push("");
+  lines.push(
+    `**${matches.length} match${matches.length > 1 ? "es" : ""}** — text-search hints, not semantic references`,
+  );
+  lines.push("");
+
+  const byFile = groupByFile(matches);
+  let shown = 0;
+  for (const [file, fileMatches] of byFile) {
+    if (shown >= maxResults) break;
+    lines.push(`### ${file}`);
+    for (const m of fileMatches.slice(0, 3)) {
+      lines.push(`- L${m.line}: \`${m.text.slice(0, 100)}\``);
+    }
+    if (fileMatches.length > 3) {
+      lines.push(`- _+${fileMatches.length - 3} more_`);
+    }
+    lines.push("");
+    shown++;
+  }
+
+  if (byFile.size > maxResults) {
+    lines.push(`_+${byFile.size - maxResults} more files omitted._`);
+  }
+
+  return { content: lines.join("\n"), matchCount: matches.length };
+}

package/src/actions/implementations-action.ts

@@ -0,0 +1,190 @@
+// Implementations action — find concrete implementations via LSP or heuristic.
+
+import * as path from "node:path";
+import { getSessionLspService } from "@mrclrchtr/supi-lsp";
+import { resolveTarget } from "../resolve-target.ts";
+import {
+  escapeRegex,
+  isInProjectPath,
+  normalizePath,
+  runRipgrep,
+  uriToFile,
+} from "../search-helpers.ts";
+import type { ActionParams } from "../tool-actions.ts";
+import type { CodeIntelResult, SearchDetails } from "../types.ts";
+
+export async function executeImplementationsAction(
+  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"],
+        },
+      },
+    };
+  }
+
+  const lspState = getSessionLspService(cwd);
+  const relPath = path.relative(cwd, target.file);
+
+  if (lspState.kind === "ready") {
+    const impls = await lspState.service.implementation(target.file, target.position);
+    if (impls) {
+      const locations = Array.isArray(impls) ? impls : [impls];
+      if (locations.length > 0) {
+        const content = formatSemanticImpls(locations, cwd, params.maxResults ?? 8);
+        const { project: projectLocs, external: externalLocs } = partitionImpls(locations, cwd);
+        const searchDetails: SearchDetails = {
+          confidence: "semantic",
+          scope: params.path ?? null,
+          candidateCount: projectLocs.length,
+          omittedCount: externalLocs.length,
+          nextQueries: [
+            "`code_intel affected` before changing implementations",
+            "`code_intel 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 } };
+  }
+
+  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.`,
+    details: {
+      type: "search" as const,
+      data: {
+        confidence: "unavailable",
+        scope: params.path ?? null,
+        candidateCount: 0,
+        omittedCount: 0,
+        nextQueries: [
+          "Enable LSP for semantic implementation resolution, or try `code_intel pattern`",
+        ],
+      },
+    },
+  };
+}
+
+function partitionImpls(
+  locations: Array<{
+    uri?: string;
+    targetUri?: string;
+    range?: { start: { line: number } };
+    targetRange?: { start: { line: number } };
+  }>,
+  cwd: string,
+): { project: typeof locations; external: typeof locations } {
+  const project: typeof locations = [];
+  const external: typeof locations = [];
+  for (const loc of locations) {
+    const uri = loc.uri ?? loc.targetUri ?? "";
+    const filePath = uriToFile(uri);
+    if (filePath && isInProjectPath(filePath, cwd)) {
+      project.push(loc);
+    } else {
+      external.push(loc);
+    }
+  }
+  return { project, external };
+}
+
+function formatSemanticImpls(
+  locations: Array<{
+    uri?: string;
+    targetUri?: string;
+    range?: { start: { line: number } };
+    targetRange?: { start: { line: number } };
+  }>,
+  cwd: string,
+  maxResults: number,
+): string {
+  const { project: projectLocs, external: externalLocs } = partitionImpls(locations, cwd);
+
+  const lines: string[] = [];
+  lines.push("# Implementations (semantic)");
+  lines.push("");
+  lines.push(`**${projectLocs.length} implementation${projectLocs.length !== 1 ? "s" : ""}**`);
+  if (externalLocs.length > 0) {
+    const suffix =
+      externalLocs.length === 1
+        ? "+1 external implementation"
+        : `+${externalLocs.length} external implementations`;
+    lines.push(`_${suffix} (node_modules, .pnpm, or out-of-tree)_`);
+  }
+  lines.push("");
+
+  let shown = 0;
+  for (const loc of projectLocs) {
+    if (shown >= maxResults) break;
+    const uri = loc.uri ?? loc.targetUri ?? "";
+    const range = loc.range ?? loc.targetRange ?? null;
+    const filePath = uriToFile(uri);
+    const implRelPath = path.relative(cwd, filePath);
+    const line = range ? range.start.line + 1 : 0;
+    lines.push(`- \`${implRelPath}\`:${line}`);
+    shown++;
+  }
+
+  if (projectLocs.length > maxResults) {
+    lines.push(`- _+${projectLocs.length - maxResults} more omitted_`);
+  }
+  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/index-action.ts

@@ -0,0 +1,187 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { CodeIntelResult, SearchDetails } 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",
+]);
+
+export function executeIndexAction(cwd: string): CodeIntelResult {
+  const stats = gatherStats(cwd);
+  const content = formatIndex(stats, cwd);
+  const details: SearchDetails = {
+    confidence: "structural",
+    scope: null,
+    candidateCount: stats.total,
+    omittedCount: 0,
+    nextQueries: ["`code_intel brief` for deeper context on a module"],
+  };
+  return { content, details: { type: "search" as const, data: details } };
+}
+
+interface FileStats {
+  byExtension: Map<string, number>;
+  byTopDir: Map<string, number>;
+  landmarkFiles: string[];
+  total: number;
+}
+
+const SKIP_DIRS = new Set(["node_modules", "dist", "build", ".git"]);
+
+function shouldSkipEntry(entry: fs.Dirent): boolean {
+  return entry.name.startsWith(".") || SKIP_DIRS.has(entry.name);
+}
+
+function gatherStats(cwd: string): FileStats {
+  const byExtension = new Map<string, number>();
+  const byTopDir = new Map<string, number>();
+  const landmarkFiles: string[] = [];
+  let total = 0;
+
+  function processFile(entryRel: string, entryName: string) {
+    total++;
+    const ext = path.extname(entryName).toLowerCase();
+    byExtension.set(ext, (byExtension.get(ext) ?? 0) + 1);
+
+    const topDir = entryRel.split("/")[0] ?? ".";
+    byTopDir.set(topDir, (byTopDir.get(topDir) ?? 0) + 1);
+
+    if (LANDMARK_FILES.has(entryName)) {
+      landmarkFiles.push(entryRel);
+    }
+  }
+
+  function walk(dir: string, rel: string) {
+    let entries: fs.Dirent[];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (shouldSkipEntry(entry)) continue;
+
+      const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        walk(fullPath, entryRel);
+      } else {
+        processFile(entryRel, entry.name);
+      }
+    }
+  }
+
+  walk(cwd, "");
+  return { byExtension, byTopDir, landmarkFiles, total };
+}
+
+function formatIndex(stats: FileStats, cwd: string): string {
+  const lines: string[] = [];
+  const name = path.basename(cwd);
+
+  lines.push(`# Project Map: ${name}`);
+  lines.push("");
+
+  lines.push(`**Source 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.byTopDir.size > 0) {
+    lines.push("**Top-level directories:**");
+    for (const [dir, count] of [...stats.byTopDir.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 f of stats.landmarkFiles) {
+      lines.push(`- \`${f}\``);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}