@mrclrchtr/supi-code-intelligence 1.5.0 → 1.7.0

package/src/types.ts

@@ -17,6 +17,15 @@ export interface BriefDetails {
   prioritySignals?: PrioritySignalsSummary | null;
 }
 
+/** Structured details metadata for factual map results. */
+export interface MapDetails {
+  scope: string | null;
+  totalFiles: number;
+  childDirectoryCount: number;
+  landmarkCount: number;
+  nextQueries: string[];
+}
+
 /** Structured details metadata for relationship and pattern results. */
 export interface SearchDetails {
   confidence: ConfidenceMode;
@@ -56,6 +65,7 @@ export interface CodeIntelResult {
   content: string;
   details?:
     | { type: "brief"; data: BriefDetails }
+    | { type: "map"; data: MapDetails }
     | { type: "search"; data: SearchDetails }
     | { type: "affected"; data: AffectedDetails };
 }

package/src/actions/index-action.ts

@@ -1,187 +0,0 @@
-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");
-}

package/src/tool/action-specs.ts

@@ -1,66 +0,0 @@
-/**
- * Single source of truth for the public `code_intel` action surface.
- *
- * The action list, prompt guidance, and router validation should derive from
- * these specs so the high-level orchestration tool stays internally coherent.
- */
-export const CODE_INTEL_ACTION_SPECS = [
-  {
-    name: "brief",
-    promptGuideline:
-      'Use code_intel with `action: "brief"` for a project, package, directory, file, or anchored-position brief before opening more files.',
-  },
-  {
-    name: "callers",
-    promptGuideline:
-      'Use code_intel with `action: "callers"` to find who invokes a symbol or file-level surface before falling back to text search.',
-  },
-  {
-    name: "callees",
-    promptGuideline:
-      'Use code_intel with `action: "callees"` for outgoing calls from a function or method at a known `file`, `line`, and `character`.',
-  },
-  {
-    name: "implementations",
-    promptGuideline:
-      'Use code_intel with `action: "implementations"` to find which concrete types implement a declaration.',
-  },
-  {
-    name: "affected",
-    promptGuideline:
-      'Use code_intel with `action: "affected"` before edits for blast radius, downstream modules, risk, and likely follow-up checks or tests.',
-  },
-  {
-    name: "pattern",
-    promptGuideline:
-      'Use code_intel with `action: "pattern"` for bounded search within a path; `pattern` is literal by default, set `regex: true` for regex, and use `kind: "definition" | "export" | "import"` for structured search.',
-  },
-  {
-    name: "index",
-    promptGuideline:
-      'Use code_intel with `action: "index"` for a project map, top-level directories, language mix, or landmark files.',
-  },
-] as const;
-
-export type CodeIntelAction = (typeof CODE_INTEL_ACTION_SPECS)[number]["name"];
-export type CodeIntelActionSpec = (typeof CODE_INTEL_ACTION_SPECS)[number];
-
-/** Ordered action names for schemas, validation messages, and docs. */
-export const CODE_INTEL_ACTION_NAMES = CODE_INTEL_ACTION_SPECS.map(
-  (spec) => spec.name,
-) as readonly CodeIntelAction[];
-
-const CODE_INTEL_ACTION_NAME_SET = new Set<string>(CODE_INTEL_ACTION_NAMES);
-
-/** Check whether a runtime string is a supported `code_intel` action. */
-export function isCodeIntelAction(action: string): action is CodeIntelAction {
-  return CODE_INTEL_ACTION_NAME_SET.has(action);
-}
-
-/** Format the public action list for validation messages and docs. */
-export function formatCodeIntelActionList(options?: { fenced?: boolean }): string {
-  if (options?.fenced) {
-    return CODE_INTEL_ACTION_NAMES.map((name) => `\`${name}\``).join(", ");
-  }
-  return CODE_INTEL_ACTION_NAMES.join(", ");
-}

package/src/tool-actions.ts

@@ -1,100 +0,0 @@
-// Tool action router — dispatches code_intel actions to specific implementations.
-
-import * as fs from "node:fs";
-import { executeAffectedAction } from "./actions/affected-action.ts";
-import { executeBriefAction } from "./actions/brief-action.ts";
-import { executeCalleesAction } from "./actions/callees-action.ts";
-import { executeCallersAction } from "./actions/callers-action.ts";
-import { executeImplementationsAction } from "./actions/implementations-action.ts";
-import { executeIndexAction } from "./actions/index-action.ts";
-import { executePatternAction } from "./actions/pattern-action.ts";
-import { normalizePath } from "./search-helpers.ts";
-import {
-  type CodeIntelAction,
-  formatCodeIntelActionList,
-  isCodeIntelAction,
-} from "./tool/action-specs.ts";
-import type { CodeIntelResult } from "./types.ts";
-
-export type { CodeIntelAction } from "./tool/action-specs.ts";
-
-/** Flat parameter bag shared by `code_intel` action handlers. */
-export interface ActionParams {
-  action: CodeIntelAction;
-  path?: string;
-  file?: string;
-  line?: number;
-  character?: number;
-  symbol?: string;
-  /** Text search input for `action: "pattern"`; treated as literal unless `regex` is true. */
-  pattern?: string;
-  /** Opt into raw ripgrep regex semantics for `action: "pattern"`. */
-  regex?: boolean;
-  kind?: string;
-  exportedOnly?: boolean;
-  maxResults?: number;
-  contextLines?: number;
-  /** Aggregate counts by directory instead of line-level matches (pattern action only). */
-  summary?: boolean;
-}
-
-type ActionHandler = (
-  params: ActionParams,
-  cwd: string,
-) => CodeIntelResult | Promise<CodeIntelResult>;
-
-const ACTION_HANDLERS: Record<CodeIntelAction, ActionHandler> = {
-  brief: executeBriefAction,
-  callers: executeCallersAction,
-  callees: executeCalleesAction,
-  implementations: executeImplementationsAction,
-  affected: executeAffectedAction,
-  pattern: executePatternAction,
-  index: (_params, cwd) => executeIndexAction(cwd),
-};
-
-/**
- * Main action dispatcher — validates params and routes to specific action handlers.
- * Returns structured content with optional metadata details per action type.
- */
-export async function executeAction(
-  params: ActionParams,
-  ctx: { cwd: string },
-): Promise<CodeIntelResult> {
-  const cwd = ctx.cwd;
-  const error = validateParams(params, cwd);
-  if (error) return { content: error, details: undefined };
-
-  return ACTION_HANDLERS[params.action](params, cwd);
-}
-
-function validateParams(params: ActionParams, cwd: string): string | null {
-  if (!params.action || !isCodeIntelAction(params.action)) {
-    return `**Error:** Unknown action \`${params.action ?? "(none)"}\`. Supported: ${formatCodeIntelActionList({ fenced: true })}.`;
-  }
-
-  if (params.path && (params.line != null || params.character != null)) {
-    return "**Error:** `line` and `character` require `file`, not `path`. Use `path` to scope/focus; use `file` to anchor a position.";
-  }
-
-  if (params.file) {
-    const resolvedFile = normalizePath(params.file, cwd);
-    if (fs.existsSync(resolvedFile) && fs.statSync(resolvedFile).isDirectory()) {
-      return "**Error:** `file` points to a directory. Use `path` to scope a directory; use `file` to anchor a position in a file.";
-    }
-  }
-
-  if ((params.line != null || params.character != null) && !params.file) {
-    return "**Error:** `line` and `character` require `file`.";
-  }
-
-  if (
-    params.action === "pattern" &&
-    params.kind &&
-    !new Set(["definition", "export", "import"]).has(params.kind)
-  ) {
-    return "**Error:** `pattern` action `kind` must be one of `definition`, `export`, or `import`.";
-  }
-
-  return null;
-}