@mrclrchtr/supi-code-intelligence 0.1.0

package/src/actions/pattern-action.ts

@@ -0,0 +1,232 @@
+// Pattern action — bounded, scope-aware text search.
+
+import type { RgMatch } from "../search-helpers.ts";
+import {
+  escapeRegex,
+  groupByFile,
+  normalizePath,
+  runRipgrep,
+  runRipgrepDetailed,
+} from "../search-helpers.ts";
+import type { ActionParams } from "../tool-actions.ts";
+import type { CodeIntelResult, SearchDetails } from "../types.ts";
+
+/**
+ * Execute the bounded text-search action.
+ *
+ * Public `pattern` input is treated as a literal string by default. Callers can
+ * opt into raw ripgrep regex semantics with `regex: true`; malformed regex
+ * patterns are surfaced as explicit user-facing errors instead of being
+ * collapsed into a misleading no-match response.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: function has multiple distinct paths (validation, regex vs literal, summary vs detailed, zero vs results) that are clearer when explicit than when split; 18 is acceptable for the use case
+export async function executePatternAction(
+  params: ActionParams,
+  cwd: string,
+): Promise<CodeIntelResult> {
+  if (!params.pattern) {
+    return {
+      content: "**Error:** `pattern` action requires a `pattern` parameter.",
+      details: undefined,
+    };
+  }
+
+  const maxResults = params.maxResults ?? 8;
+  const contextLines = params.contextLines ?? 1;
+  const scopePath = params.path ? normalizePath(params.path, cwd) : cwd;
+  const relScope = params.path ?? ".";
+
+  const matches = params.regex
+    ? getRegexMatches({
+        pattern: params.pattern,
+        scopePath,
+        cwd,
+        maxResults,
+        contextLines,
+        summary: params.summary,
+      })
+    : runRipgrep(escapeRegex(params.pattern), scopePath, cwd, {
+        maxMatches: params.summary ? undefined : maxResults * 3,
+        contextLines,
+        filterLowSignal: true,
+      });
+
+  if (typeof matches === "string") {
+    const errorDetails: SearchDetails = {
+      confidence: "unavailable",
+      scope: params.path ?? null,
+      candidateCount: 0,
+      omittedCount: 0,
+      nextQueries: ["Fix the regex pattern and retry"],
+    };
+    return { content: matches, details: { type: "search", data: errorDetails } };
+  }
+
+  if (matches.length === 0) {
+    const emptyDetails: SearchDetails = {
+      confidence: "heuristic",
+      scope: params.path ?? null,
+      candidateCount: 0,
+      omittedCount: 0,
+      nextQueries: params.regex
+        ? ["Set `regex: false` for literal matching"]
+        : ["Set `regex: true` for regex matching"],
+    };
+    return {
+      content: `No matches found for \`${params.pattern}\` in \`${relScope}\`.`,
+      details: { type: "search", data: emptyDetails },
+    };
+  }
+
+  let content: string;
+  if (params.summary) {
+    content = formatPatternSummary(params.pattern, relScope, matches, maxResults);
+  } else {
+    content = formatPatternResults(params.pattern, relScope, matches, maxResults);
+  }
+
+  const details: SearchDetails = {
+    confidence: "heuristic",
+    scope: params.path ?? null,
+    candidateCount: matches.length,
+    omittedCount: 0,
+    nextQueries: params.regex
+      ? ["Set `regex: false` for literal matching"]
+      : ["Set `regex: true` for regex matching"],
+  };
+  return { content, details: { type: "search" as const, data: details } };
+}
+
+function getRegexMatches(options: {
+  pattern: string;
+  scopePath: string;
+  cwd: string;
+  maxResults: number;
+  contextLines: number;
+  summary?: boolean;
+}): RgMatch[] | string {
+  const result = runRipgrepDetailed(options.pattern, options.scopePath, options.cwd, {
+    maxMatches: options.summary ? undefined : options.maxResults * 3,
+    contextLines: options.contextLines,
+    filterLowSignal: true,
+  });
+
+  if (result.error) {
+    return formatRegexError(options.pattern, result.error);
+  }
+
+  return result.matches;
+}
+
+function formatRegexError(pattern: string, error: string): string {
+  const lines = error
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const detail =
+    [...lines]
+      .reverse()
+      .find((line) => line.startsWith("error:"))
+      ?.replace(/^error:\s*/, "") ??
+    lines.at(-1) ??
+    "ripgrep rejected the regex.";
+  return `**Error:** Invalid regex pattern \`${pattern}\`: ${detail}`;
+}
+
+function formatPatternResults(
+  pattern: string,
+  relScope: string,
+  matches: RgMatch[],
+  maxResults: number,
+): string {
+  const lines: string[] = [];
+  lines.push(`# Pattern: \`${pattern}\``);
+  lines.push("");
+  lines.push(`**${matches.length} match${matches.length > 1 ? "es" : ""}** in \`${relScope}\``);
+  lines.push("");
+
+  const byFile = groupByFile(matches);
+  let shown = 0;
+  for (const [file, fileMatches] of byFile) {
+    if (shown >= maxResults) break;
+    lines.push(`### ${file}`);
+    const renderedLines = new Set<number>();
+    const matchLines = new Set(fileMatches.map((match) => match.line));
+    for (const m of fileMatches.slice(0, 5)) {
+      renderMatchWithContext(lines, m, renderedLines, matchLines);
+    }
+    if (fileMatches.length > 5) {
+      lines.push(`- _+${fileMatches.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\`._`,
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function formatPatternSummary(
+  pattern: string,
+  relScope: string,
+  matches: RgMatch[],
+  maxResults: number,
+): string {
+  const byFile = groupByFile(matches);
+  const byDir = new Map<string, number>();
+  for (const [file] of byFile) {
+    const dir = file.includes("/") ? file.split("/").slice(0, -1).join("/") : ".";
+    byDir.set(dir, (byDir.get(dir) ?? 0) + 1);
+  }
+
+  const lines: string[] = [];
+  lines.push(`# Pattern Summary: \`${pattern}\``);
+  lines.push("");
+  lines.push(
+    `**${matches.length} match${matches.length > 1 ? "es" : ""}** across **${byFile.size} file${byFile.size !== 1 ? "s" : ""}** in \`${relScope}\``,
+  );
+  lines.push("");
+
+  const sortedDirs = [...byDir.entries()].sort((a, b) => b[1] - a[1]).slice(0, maxResults);
+  for (const [dir, count] of sortedDirs) {
+    lines.push(`- \`${dir}/\` — ${count} file${count !== 1 ? "s" : ""}`);
+  }
+
+  if (byDir.size > maxResults) {
+    lines.push(`- _+${byDir.size - maxResults} more directories_`);
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+function renderMatchWithContext(
+  lines: string[],
+  m: RgMatch,
+  renderedLines: Set<number>,
+  matchLines: Set<number>,
+): void {
+  if (m.context) {
+    for (const c of m.context.filter((cx) => cx.line < m.line)) {
+      if (renderedLines.has(c.line) || matchLines.has(c.line)) continue;
+      lines.push(`  L${c.line}: ${c.text.slice(0, 120)}`);
+      renderedLines.add(c.line);
+    }
+  }
+  if (!renderedLines.has(m.line)) {
+    lines.push(`- L${m.line}: \`${m.text.slice(0, 120)}\``);
+    renderedLines.add(m.line);
+  }
+  if (m.context) {
+    for (const c of m.context.filter((cx) => cx.line > m.line)) {
+      if (renderedLines.has(c.line) || matchLines.has(c.line)) continue;
+      lines.push(`  L${c.line}: ${c.text.slice(0, 120)}`);
+      renderedLines.add(c.line);
+    }
+  }
+}

package/src/architecture.ts

@@ -0,0 +1,367 @@
+// Shared architecture model — scans project metadata to build a structural model
+// that powers both auto-injected overviews and on-demand briefs.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findProjectRoot, isWithinOrEqual, walkProject } from "@mrclrchtr/supi-core";
+
+// ── Types ─────────────────────────────────────────────────────────────
+
+export interface ArchitectureModel {
+  /** Absolute root directory of the project */
+  root: string;
+  /** Project name from root manifest */
+  name: string | null;
+  /** Project description from root manifest */
+  description: string | null;
+  /** Detected modules/packages */
+  modules: ModuleInfo[];
+  /** Internal dependency edges between modules */
+  edges: DependencyEdge[];
+}
+
+export interface ModuleInfo {
+  /** Package/module name */
+  name: string;
+  /** Short description from manifest */
+  description: string | null;
+  /** Absolute path to the module root */
+  root: string;
+  /** Relative path from project root */
+  relativePath: string;
+  /** Main entrypoint(s) from manifest */
+  entrypoints: string[];
+  /** Whether this is a leaf module (no internal dependents) */
+  isLeaf: boolean;
+  /** Internal dependency names */
+  internalDeps: string[];
+  /** External dependency names */
+  externalDeps: string[];
+}
+
+export interface DependencyEdge {
+  /** Source module name */
+  from: string;
+  /** Target module name */
+  to: string;
+}
+
+// ── Model building ────────────────────────────────────────────────────
+
+const PROJECT_MARKERS = [
+  "package.json",
+  "pnpm-workspace.yaml",
+  "deno.json",
+  "deno.jsonc",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+];
+
+/**
+ * Build an architecture model from project metadata.
+ * Starts from cheap manifest scanning — no deep AST or LSP analysis.
+ */
+export async function buildArchitectureModel(cwd: string): Promise<ArchitectureModel | null> {
+  const root = findProjectRoot(cwd, PROJECT_MARKERS, cwd);
+
+  // Read root manifest
+  const rootManifest = readPackageJson(root);
+  if (!rootManifest) {
+    // Try to detect at least some source structure
+    return buildMinimalModel(root);
+  }
+
+  const projectName = rootManifest.name ?? null;
+  const projectDescription = rootManifest.description ?? null;
+
+  // Detect workspace packages
+  const workspaceModules = await detectWorkspaceModules(root, rootManifest);
+
+  if (workspaceModules.length === 0) {
+    // Single-package project
+    return buildSinglePackageModel(root, rootManifest);
+  }
+
+  // Build dependency edges between workspace modules
+  const moduleNames = new Set(workspaceModules.map((m) => m.name));
+  const edges: DependencyEdge[] = [];
+
+  for (const mod of workspaceModules) {
+    for (const dep of mod.internalDeps) {
+      if (moduleNames.has(dep)) {
+        edges.push({ from: mod.name, to: dep });
+      }
+    }
+  }
+
+  // Mark leaf modules (no other module depends on them internally)
+  const dependedOn = new Set(edges.map((e) => e.to));
+  for (const mod of workspaceModules) {
+    mod.isLeaf = !dependedOn.has(mod.name);
+  }
+
+  return {
+    root,
+    name: projectName,
+    description: projectDescription,
+    modules: workspaceModules,
+    edges,
+  };
+}
+
+// ── Workspace detection ───────────────────────────────────────────────
+
+interface PackageJson {
+  name?: string;
+  description?: string;
+  main?: string;
+  module?: string;
+  exports?: unknown;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  workspaces?: string[] | { packages?: string[] };
+  pi?: { extensions?: string[] };
+}
+
+function readPackageJson(dir: string): PackageJson | null {
+  try {
+    const raw = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: workspace package detection with manifest parsing
+async function detectWorkspaceModules(
+  root: string,
+  rootManifest: PackageJson,
+): Promise<ModuleInfo[]> {
+  // Check for pnpm-workspace.yaml
+  let workspaceGlobs: string[] = [];
+
+  try {
+    const pnpmWs = fs.readFileSync(path.join(root, "pnpm-workspace.yaml"), "utf-8");
+    // Simple YAML parsing for packages array
+    const packagesMatch = pnpmWs.match(/packages:\s*\n((?:\s*-\s*.+\n?)*)/);
+    if (packagesMatch) {
+      workspaceGlobs = packagesMatch[1]
+        .split("\n")
+        .map((line) => line.replace(/^\s*-\s*/, "").replace(/['"\s]/g, ""))
+        .filter(Boolean);
+    }
+  } catch {
+    // Try npm/yarn workspaces from package.json
+    const ws = rootManifest.workspaces;
+    if (Array.isArray(ws)) {
+      workspaceGlobs = ws;
+    } else if (ws && Array.isArray(ws.packages)) {
+      workspaceGlobs = ws.packages;
+    }
+  }
+
+  if (workspaceGlobs.length === 0) return [];
+
+  // Resolve workspace globs to actual package directories
+  const modules: ModuleInfo[] = [];
+  const resolvedDirs = resolveWorkspaceGlobs(root, workspaceGlobs);
+
+  for (const dir of resolvedDirs) {
+    const manifest = readPackageJson(dir);
+    if (!manifest?.name) continue;
+
+    const relativePath = path.relative(root, dir);
+    const allDeps = {
+      ...manifest.dependencies,
+      ...manifest.peerDependencies,
+    };
+
+    // Separate internal vs external deps
+    const internalDeps: string[] = [];
+    const externalDeps: string[] = [];
+    for (const depName of Object.keys(allDeps)) {
+      // Internal if it matches a workspace package pattern
+      const depVersion = allDeps[depName];
+      if (depVersion?.startsWith("workspace:")) {
+        internalDeps.push(depName);
+      } else {
+        externalDeps.push(depName);
+      }
+    }
+
+    // Detect entrypoints
+    const entrypoints: string[] = [];
+    if (manifest.pi?.extensions) {
+      entrypoints.push(...manifest.pi.extensions);
+    } else if (manifest.main) {
+      entrypoints.push(manifest.main);
+    } else if (manifest.module) {
+      entrypoints.push(manifest.module);
+    }
+
+    modules.push({
+      name: manifest.name,
+      description: manifest.description ?? null,
+      root: dir,
+      relativePath,
+      entrypoints,
+      isLeaf: false, // Will be computed after edges
+      internalDeps,
+      externalDeps,
+    });
+  }
+
+  return modules;
+}
+
+function resolveWorkspaceGlobs(root: string, globs: string[]): string[] {
+  const dirs: string[] = [];
+
+  for (const glob of globs) {
+    if (glob.includes("*")) {
+      // Expand glob: "packages/*" -> list all dirs under packages/
+      const prefix = glob.replace(/\/?\*.*$/, "");
+      const baseDir = path.join(root, prefix);
+      const recursive = glob.includes("**");
+      try {
+        collectPackageDirs(baseDir, dirs, recursive ? 5 : 0);
+      } catch {
+        // Glob base directory doesn't exist
+      }
+    } else {
+      // Exact path
+      const fullPath = path.join(root, glob);
+      if (fs.existsSync(path.join(fullPath, "package.json"))) {
+        dirs.push(fullPath);
+      }
+    }
+  }
+
+  return dirs;
+}
+
+/**
+ * Collect directories containing a package.json.
+ * When depth > 0, recurse into subdirectories (for `**` globs).
+ */
+function collectPackageDirs(baseDir: string, dirs: string[], depth: number): void {
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    if (entry.name === "node_modules") continue;
+    const fullPath = path.join(baseDir, entry.name);
+    if (fs.existsSync(path.join(fullPath, "package.json"))) {
+      dirs.push(fullPath);
+    } else if (depth > 0) {
+      collectPackageDirs(fullPath, dirs, depth - 1);
+    }
+  }
+}
+
+// ── Fallback models ───────────────────────────────────────────────────
+
+function buildSinglePackageModel(root: string, manifest: PackageJson): ArchitectureModel {
+  const entrypoints: string[] = [];
+  if (manifest.pi?.extensions) {
+    entrypoints.push(...manifest.pi.extensions);
+  } else if (manifest.main) {
+    entrypoints.push(manifest.main);
+  }
+
+  const mod: ModuleInfo = {
+    name: manifest.name ?? path.basename(root),
+    description: manifest.description ?? null,
+    root,
+    relativePath: ".",
+    entrypoints,
+    isLeaf: true,
+    internalDeps: [],
+    externalDeps: Object.keys({
+      ...manifest.dependencies,
+      ...manifest.peerDependencies,
+    }),
+  };
+
+  return {
+    root,
+    name: manifest.name ?? null,
+    description: manifest.description ?? null,
+    modules: [mod],
+    edges: [],
+  };
+}
+
+function buildMinimalModel(root: string): ArchitectureModel | null {
+  // Check if there are any recognizable source files
+  let hasSource = false;
+  walkProject(root, 2, (_dir, entries) => {
+    for (const name of entries) {
+      if (
+        name.endsWith(".ts") ||
+        name.endsWith(".js") ||
+        name.endsWith(".tsx") ||
+        name.endsWith(".jsx") ||
+        name.endsWith(".py") ||
+        name.endsWith(".rs") ||
+        name.endsWith(".go")
+      ) {
+        hasSource = true;
+      }
+    }
+  });
+
+  if (!hasSource) return null;
+
+  return {
+    root,
+    name: path.basename(root),
+    description: null,
+    modules: [],
+    edges: [],
+  };
+}
+
+// ── Query helpers ─────────────────────────────────────────────────────
+
+/**
+ * Find the module containing a given file path.
+ * Returns the most specific (deepest) matching module.
+ */
+export function findModuleForPath(model: ArchitectureModel, filePath: string): ModuleInfo | null {
+  const resolved = path.resolve(filePath);
+  let best: ModuleInfo | null = null;
+
+  for (const mod of model.modules) {
+    if (isWithinOrEqual(mod.root, resolved)) {
+      if (!best || mod.root.length > best.root.length) {
+        best = mod;
+      }
+    }
+  }
+
+  return best;
+}
+
+/**
+ * Get modules that depend on a given module (reverse dependencies / dependents).
+ */
+export function getDependents(model: ArchitectureModel, moduleName: string): ModuleInfo[] {
+  return model.modules.filter((m) => m.internalDeps.includes(moduleName));
+}
+
+/**
+ * Get the internal dependencies of a module as ModuleInfo objects.
+ */
+export function getDependencies(model: ArchitectureModel, moduleName: string): ModuleInfo[] {
+  const mod = model.modules.find((m) => m.name === moduleName);
+  if (!mod) return [];
+  return model.modules.filter((m) => mod.internalDeps.includes(m.name));
+}