weavatrix 0.3.14 → 1.0.0

package/src/precision/typescript-provider/reference-usage.js

@@ -1,53 +0,0 @@
-import {extname} from 'node:path'
-import {createRequire} from 'node:module'
-
-const requireFromWeavatrix = createRequire(import.meta.url)
-
-function typeScriptScriptKind(ts, filePath) {
-    const extension = extname(String(filePath)).toLowerCase()
-    if (extension === '.tsx') return ts.ScriptKind.TSX
-    if (extension === '.jsx') return ts.ScriptKind.JSX
-    if (extension === '.js' || extension === '.mjs' || extension === '.cjs') return ts.ScriptKind.JS
-    return ts.ScriptKind.TS
-}
-
-// Unknown is deliberately fail-closed: callers must not promote it to runtime.
-export function classifyTypeScriptReferenceUsage(filePath, text, position) {
-    if (!Number.isInteger(position?.line) || !Number.isInteger(position?.character)) return 'unknown'
-    let ts
-    try { ts = requireFromWeavatrix('typescript') } catch { return 'unknown' }
-    let sourceFile
-    let offset
-    try {
-        sourceFile = ts.createSourceFile(
-            String(filePath || 'source.ts'),
-            String(text || ''),
-            ts.ScriptTarget.Latest,
-            true,
-            typeScriptScriptKind(ts, filePath),
-        )
-        if (sourceFile.parseDiagnostics?.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
-            return 'unknown'
-        }
-        offset = sourceFile.getPositionOfLineAndCharacter(position.line, position.character)
-    } catch { return 'unknown' }
-    let token
-    try { token = ts.getTokenAtPosition(sourceFile, offset) } catch { return 'unknown' }
-    if (!token || (!ts.isIdentifier(token) && !ts.isPrivateIdentifier(token))) return 'unknown'
-    if (offset < token.getStart(sourceFile) || offset >= token.getEnd()) return 'unknown'
-    for (let current = token; current && current !== sourceFile; current = current.parent) {
-        if ((ts.isImportSpecifier(current) || ts.isImportClause(current)
-            || ts.isExportSpecifier(current) || ts.isExportDeclaration(current))
-            && current.isTypeOnly === true) return 'type'
-        if (ts.isExpressionWithTypeArguments(current) && ts.isHeritageClause(current.parent)) {
-            const heritage = current.parent
-            if (heritage.token === ts.SyntaxKind.ExtendsKeyword && ts.isClassLike(heritage.parent)) {
-                const expression = current.expression
-                if (offset >= expression.getStart(sourceFile) && offset < expression.getEnd()) return 'value'
-            }
-            return 'type'
-        }
-        if (ts.isTypeNode(current)) return 'type'
-    }
-    return 'value'
-}

package/src/process.js

@@ -1,95 +0,0 @@
-// Subprocess runner shared by the search engines and security sweeps.
-import { spawn, spawnSync } from "node:child_process";
-import { childProcessEnv } from "./child-env.js";
-
-// Windows: .cmd/.ps1 shims (npx, etc.) can't be spawned directly by Node — they need a
-// shell. With shell:true Node does NOT quote args, so we build a quoted command line ourselves
-// (repo paths contain spaces). POSIX uses the normal argv array, no shell.
-export function winQuote(value) {
-  const s = String(value);
-  return /[\s&()[\]{}^=;!'+,`~|<>"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
-}
-
-export function runCommand(command, args = [], options = {}) {
-  // Windows: .cmd/.ps1/bare-name shims (npx, …) need a cmd.exe shell. But a real .exe
-  // (rg.exe, where.exe) must be spawned DIRECTLY — wrapping an .exe in the shell breaks stdin
-  // piping, which surfaced as "command returned no output".
-  const needsShell = process.platform === "win32" && !/\.exe$/i.test(command);
-  return new Promise((resolve, reject) => {
-    const child = needsShell
-      ? spawn([command, ...args].map(winQuote).join(" "), [], {
-          cwd: options.cwd || undefined,
-          env: childProcessEnv(options.env || {}),
-          shell: true,
-          windowsHide: true
-        })
-      : spawn(command, args, {
-          cwd: options.cwd || undefined,
-          env: childProcessEnv(options.env || {}),
-          windowsHide: true
-        });
-
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    let settled = false;
-    let hardTimer = null;
-    const finish = (fn) => {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      if (hardTimer) clearTimeout(hardTimer);
-      fn();
-    };
-    // On timeout, kill the WHOLE process tree. With shell:true the child is cmd.exe; child.kill() would only
-    // kill the shell, leaving npx→node→tool running and the stdio pipes open → 'close' never fires → the
-    // caller hangs forever. taskkill /T kills the tree; SIGKILL group on POSIX.
-    const killTree = () => {
-      if (process.platform === "win32" && child.pid) {
-        try {
-          spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { windowsHide: true, env: childProcessEnv() });
-        } catch {
-          try { child.kill(); } catch { /* process may already be gone */ }
-        }
-      } else {
-        try { child.kill("SIGKILL"); } catch { /* process may already be gone */ }
-      }
-      // hard fallback: if 'close' still never fires after the kill, settle anyway so the caller can't hang
-      hardTimer = setTimeout(() => finish(() => reject(new Error("Command timed out"))), 4000);
-    };
-    const timer = options.timeoutMs
-      ? setTimeout(() => {
-          timedOut = true;
-          killTree();
-        }, options.timeoutMs)
-      : null;
-
-    child.stdout?.on("data", (chunk) => (stdout += chunk));
-    child.stderr?.on("data", (chunk) => (stderr += chunk));
-    if (options.stdin) {
-      child.stdin.write(options.stdin);
-      child.stdin.end();
-    } else {
-      child.stdin?.end();
-    }
-    child.on("error", (error) => finish(() => reject(error)));
-    child.on("close", (code) => finish(() => (timedOut ? reject(new Error("Command timed out")) : resolve({ stdout, stderr, exitCode: code }))));
-  });
-}
-
-// Synchronous run-and-collect variant for callers that resolve a real binary and read its output in
-// one shot (ripgrep resolution/search, tar extraction). These launch a resolved .exe or bare binary
-// directly, so no shell quoting is needed; the child env is stripped of connector secrets and a
-// bounded timeout/buffer applies. Returns the raw spawnSync result ({status, stdout, stderr, error}).
-export function runCommandSync(command, args = [], options = {}) {
-  const spawnOptions = {
-    cwd: options.cwd || undefined,
-    encoding: options.encoding ?? "utf8",
-    env: childProcessEnv(options.env),
-    windowsHide: true,
-  };
-  if (options.timeout != null) spawnOptions.timeout = options.timeout;
-  if (options.maxBuffer != null) spawnOptions.maxBuffer = options.maxBuffer;
-  if (options.stdio != null) spawnOptions.stdio = options.stdio;
-  return spawnSync(command, args, spawnOptions);
-}

package/src/repo-path.js

@@ -1,53 +0,0 @@
-import { realpathSync } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-
-export function isPathInside(root, target) {
-  const rel = relative(root, target);
-  return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
-}
-
-// Cache the canonical root for callers that resolve many graph-derived paths.
-export function createRepoBoundary(repoRoot) {
-  let root;
-  let rootError;
-  try {
-    root = realpathSync.native(repoRoot);
-  } catch (error) {
-    rootError = error;
-  }
-
-  return {
-    root,
-    resolve(candidate) {
-      if (!root) return { ok: false, reason: "invalid-root", error: rootError };
-      const input = String(candidate ?? "");
-      if (!input || input.includes("\0")) return { ok: false, reason: "invalid-path" };
-      if (isAbsolute(input)) return { ok: false, reason: "escape" };
-
-      let lexical;
-      try {
-        lexical = resolve(root, input);
-      } catch (error) {
-        return { ok: false, reason: "invalid-path", error };
-      }
-      if (!isPathInside(root, lexical)) return { ok: false, reason: "escape" };
-
-      let target;
-      try {
-        target = realpathSync.native(lexical);
-      } catch (error) {
-        return { ok: false, reason: error?.code === "ENOENT" ? "not-found" : "unreadable", error };
-      }
-      if (!isPathInside(root, target)) return { ok: false, reason: "escape" };
-
-      return { ok: true, path: target };
-    },
-  };
-}
-
-// Resolve one existing repo-relative path without allowing lexical traversal or
-// symlink/junction escapes. Callers get a reason instead of an exception so MCP
-// tools can refuse the read without exposing host filesystem details.
-export function resolveRepoPath(repoRoot, candidate) {
-  return createRepoBoundary(repoRoot).resolve(candidate);
-}

package/src/scan/discover.inventory.js

@@ -1,78 +0,0 @@
-// Filesystem inventory helpers for repo discovery: size proxy, file/extension census, last commit.
-import { readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-
-// Directories never worth walking when sizing a repo (vendored deps, build output, caches).
-const SIZE_SKIP_DIRS = new Set([
-  ".git", "node_modules", "dist", "build", "out", ".next", "coverage", "vendor",
-  ".venv", "venv", "env", "target", "__pycache__", ".idea", ".vscode", ".cache", "bin", "obj"
-]);
-
-// Cheap "size" proxy: count source files in the working tree (skipping the heavy dirs above).
-// Bounded so a pathological tree can't stall the scan.
-export function repoFileCount(dir) {
-  let count = 0;
-  const stack = [dir];
-  while (stack.length) {
-    const cur = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync(cur, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (!SIZE_SKIP_DIRS.has(entry.name)) stack.push(join(cur, entry.name));
-      } else if (entry.isFile()) {
-        if (++count >= 100000) return count;
-      }
-    }
-  }
-  return count;
-}
-
-export function repoInventory(dir) {
-  let count = 0;
-  const ext = {};
-  const files = new Set();
-  const stack = [dir];
-  while (stack.length) {
-    const cur = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync(cur, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (!SIZE_SKIP_DIRS.has(entry.name)) stack.push(join(cur, entry.name));
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (++count >= 100000) return { count, ext, files };
-      const full = join(cur, entry.name);
-      const rel = full.slice(dir.length).replace(/^[\\/]/, "").replace(/\\/g, "/").toLowerCase();
-      files.add(rel);
-      const m = entry.name.toLowerCase().match(/(\.[a-z0-9]+)$/);
-      if (m) ext[m[1]] = (ext[m[1]] || 0) + 1;
-    }
-  }
-  return { count, ext, files };
-}
-
-// Last commit time (ms) read straight from .git/logs/HEAD — no `git` spawn. Each reflog line is
-// "<old> <new> <Name> <email> <unixtime> <tz>\t<message>"; the unixtime is the token before the tz.
-export function repoLastCommit(dir) {
-  try {
-    const log = readFileSync(join(dir, ".git", "logs", "HEAD"), "utf8").trimEnd();
-    if (!log) return 0;
-    const lastLine = log.slice(log.lastIndexOf("\n") + 1).split("\t")[0];
-    const tokens = lastLine.trim().split(/\s+/);
-    const unixTime = Number(tokens[tokens.length - 2]);
-    return Number.isFinite(unixTime) ? unixTime * 1000 : 0;
-  } catch {
-    return 0;
-  }
-}

package/src/scan/discover.js

@@ -1,5 +0,0 @@
-// Discover local git repos under a folder, browse child folders, and persist per-repo run results.
-// Facade: implementation lives in discover.inventory.js (fs walking / git metadata),
-// discover.stack.js (framework + badge detection) and discover.list.js (repo/folder listing).
-export { cleanVersion, detectFramework, detectRepoStack } from "./discover.stack.js";
-export { listGitRepos, repoBaseName, listChildFolders } from "./discover.list.js";

package/src/scan/discover.list.js

@@ -1,79 +0,0 @@
-// Repo listing: describe direct child git repos of a folder and browse child folders.
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { ROOT_DIR } from "../config.js";
-import { repoFileCount, repoInventory, repoLastCommit } from "./discover.inventory.js";
-import { detectFramework, detectRepoStack } from "./discover.stack.js";
-
-function reposDefaultFolder() {
-  return join(ROOT_DIR, "..", "..");
-}
-
-function describeRepo(dir, name) {
-  const has = (file) => existsSync(join(dir, file));
-  // RUNTIME first — a Bun/Deno project also has a package.json, so check its markers before falling
-  // back to "node". (Fixes Bun repos like edge-analytics being mislabelled "node".)
-  let language = "other";
-  if (has("bun.lock") || has("bun.lockb") || has("bunfig.toml")) language = "bun";
-  else if (has("deno.json") || has("deno.jsonc") || has("deno.lock")) language = "deno";
-  else if (has("package.json")) language = "node";
-  else if (has("go.mod")) language = "go";
-  else if (has("pom.xml") || has("build.gradle")) language = "java";
-  else if (has("requirements.txt") || has("pyproject.toml") || has("setup.py") || has("Pipfile")) language = "python";
-  else if (has("Cargo.toml")) language = "rust";
-  else if (has("composer.json")) language = "php";
-  else if (has("Gemfile")) language = "ruby";
-  // framework detection uses the JS-ecosystem table for bun/deno too (they run npm packages)
-  const fwRuntime = language === "bun" || language === "deno" ? "node" : language;
-  const inventory = repoInventory(dir);
-  const stack = detectRepoStack(dir, inventory);
-  language = stack.languages[0]?.id || stack.runtimes[0]?.id || language;
-  const stackRunsJs = stack.runtimes.some((badge) => ["node", "bun", "deno"].includes(badge.id)) || ["javascript", "typescript"].includes(language);
-  const stackFwRuntime = stackRunsJs ? "node" : language;
-  return {
-    name,
-    path: dir,
-    language,
-    stack,
-    framework: detectFramework(dir, stackFwRuntime || fwRuntime),
-    knipEligible: has("package.json"),
-    size: inventory.count || repoFileCount(dir),
-    lastCommit: repoLastCommit(dir)
-  };
-}
-
-// Only DIRECT child git repos of the opened folder. We do not descend into folders or into
-// repos, so nested/sub-repos are not listed.
-export function listGitRepos(folder) {
-  const root = folder && String(folder).trim() ? String(folder).trim() : reposDefaultFolder();
-  if (!existsSync(root)) throw new Error(`Folder not found: ${root}`);
-  let entries;
-  try {
-    entries = readdirSync(root, { withFileTypes: true });
-  } catch (error) {
-    throw new Error(`Cannot read folder: ${error.message}`);
-  }
-  const repos = entries
-    .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, ".git")))
-    .map((entry) => describeRepo(join(root, entry.name), entry.name))
-    .sort((left, right) => left.name.localeCompare(right.name));
-  return { root, repos };
-}
-
-export function repoBaseName(repoPath) {
-  return String(repoPath).split(/[\\/]/).filter(Boolean).pop() || repoPath;
-}
-
-export function listChildFolders(folder) {
-  const root = folder && existsSync(folder) ? folder : reposDefaultFolder();
-  const entries = readdirSync(root, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules")
-    .map((entry) => ({
-      name: entry.name,
-      path: join(root, entry.name),
-      isRepo: existsSync(join(root, entry.name, ".git"))
-    }))
-    .sort((left, right) => left.name.localeCompare(right.name));
-  const parent = join(root, "..");
-  return { path: root, parent: parent !== root ? parent : null, entries };
-}

package/src/scan/discover.stack.js

@@ -1,227 +0,0 @@
-// Stack detection for repo cards: frameworks, languages/runtimes, test/infra/deploy badges.
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { INFRA_SERVICES } from "../infra/infra-registry.js";
-import { depMatches, depsFromManifest } from "../infra/infra.js";
-import { repoInventory } from "./discover.inventory.js";
-
-// Web/app frameworks worth surfacing on the repo card, per ecosystem. token → display name; first
-// match (in array order) wins, so list server frameworks before generic UI libs. Versions come from
-// the manifest's declared range (not the installed lockfile — close enough for "which version").
-const FRAMEWORKS = {
-  node: [
-    ["@nestjs/core", "NestJS"], ["express", "Express"], ["fastify", "Fastify"], ["koa", "Koa"],
-    ["@hapi/hapi", "Hapi"], ["hapi", "Hapi"], ["restify", "Restify"], ["hono", "Hono"],
-    ["@adonisjs/core", "AdonisJS"], ["@feathersjs/feathers", "Feathers"], ["sails", "Sails"],
-    ["next", "Next.js"], ["nuxt", "Nuxt"], ["@sveltejs/kit", "SvelteKit"], ["@remix-run/server-runtime", "Remix"],
-    ["@angular/core", "Angular"], ["react", "React"], ["vue", "Vue"], ["svelte", "Svelte"],
-  ],
-  python: [
-    ["django", "Django"], ["fastapi", "FastAPI"], ["flask", "Flask"], ["sanic", "Sanic"],
-    ["tornado", "Tornado"], ["aiohttp", "aiohttp"], ["falcon", "Falcon"], ["bottle", "Bottle"],
-  ],
-  go: [
-    ["github.com/gin-gonic/gin", "Gin"], ["github.com/labstack/echo", "Echo"], ["github.com/gofiber/fiber", "Fiber"],
-    ["github.com/go-chi/chi", "Chi"], ["github.com/gorilla/mux", "Gorilla"], ["github.com/beego/beego", "Beego"],
-  ],
-};
-
-// "^5.2.0" / "~4.18" / "v1.9.1" / ">=2,<3" / "==4.2" → "5.2" (major.minor, range operators stripped).
-export function cleanVersion(raw) {
-  const m = String(raw || "").match(/(\d+)(?:\.(\d+))?/);
-  return m ? (m[2] != null ? `${m[1]}.${m[2]}` : m[1]) : "";
-}
-
-// Read a manifest and return the first framework {name, version} it declares. Cheap: one file read.
-export function detectFramework(dir, runtime) {
-  const read = (file) => { try { return readFileSync(join(dir, file), "utf8"); } catch { return ""; } };
-  const list = FRAMEWORKS[runtime];
-  if (!list) return null;
-  if (runtime === "node") {
-    let pkg;
-    try { pkg = JSON.parse(read("package.json")); } catch { return null; }
-    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-    for (const [tok, label] of list) if (deps[tok] != null) return { name: label, version: cleanVersion(deps[tok]) };
-  } else if (runtime === "python") {
-    const text = (read("requirements.txt") + "\n" + read("pyproject.toml") + "\n" + read("Pipfile")).toLowerCase();
-    for (const [tok, label] of list) {
-      const m = text.match(new RegExp(`(?:^|[\\s"'\\[])${tok}\\s*[~^>=<! ]*\\s*([0-9][0-9.]*)`, "m"));
-      if (m || new RegExp(`(?:^|[\\s"'\\[])${tok}(?:$|[\\s"'\\],~^>=<])`, "m").test(text)) return { name: label, version: m ? cleanVersion(m[1]) : "" };
-    }
-  } else if (runtime === "go") {
-    const text = read("go.mod");
-    for (const [tok, label] of list) {
-      const m = text.match(new RegExp(`${tok.replace(/[.\\]/g, "\\$&")}(?:/v\\d+)?\\s+v([0-9][0-9.]*)`));
-      if (m) return { name: label, version: cleanVersion(m[1]) };
-    }
-  }
-  return null;
-}
-
-function readRootFile(dir, file) {
-  try {
-    return readFileSync(join(dir, file), "utf8");
-  } catch {
-    return "";
-  }
-}
-
-function readPackage(dir) {
-  try {
-    return JSON.parse(readRootFile(dir, "package.json"));
-  } catch {
-    return null;
-  }
-}
-
-function packageDeps(pkg, includeDev = true) {
-  if (!pkg || typeof pkg !== "object") return {};
-  return {
-    ...(pkg.dependencies || {}),
-    ...(pkg.optionalDependencies || {}),
-    ...(pkg.peerDependencies || {}),
-    ...(includeDev ? pkg.devDependencies || {} : {})
-  };
-}
-
-function manifestDeps(dir) {
-  const out = new Set();
-  for (const file of [
-    "package.json", "go.mod", "go.sum", "requirements.txt", "constraints.txt", "pyproject.toml",
-    "Pipfile", "Cargo.toml", "pom.xml", "build.gradle", "build.gradle.kts", "composer.json", "Gemfile"
-  ]) {
-    if (!existsSync(join(dir, file))) continue;
-    for (const dep of depsFromManifest(file, readRootFile(dir, file))) out.add(dep);
-  }
-  return out;
-}
-
-function addBadge(list, seen, id, label, extra = {}) {
-  if (!id || seen.has(id)) return;
-  seen.add(id);
-  list.push({ id, label, ...extra });
-}
-
-function infraDisplayName(service) {
-  const names = {
-    postgres: "Postgres",
-    mysql: "MySQL",
-    mariadb: "MariaDB",
-    sqlserver: "SQL Server",
-    sqlite: "SQLite",
-    mongodb: "MongoDB",
-    dynamodb: "DynamoDB",
-    elasticsearch: "Elastic",
-    clickhouse: "ClickHouse",
-    influxdb: "InfluxDB",
-    timescaledb: "Timescale",
-    redis: "Redis",
-    valkey: "Valkey",
-    memcached: "Memcached",
-    kafka: "Kafka",
-    rabbitmq: "RabbitMQ",
-    "gcp-pubsub": "Pub/Sub",
-    "azure-servicebus": "Service Bus",
-    keycloak: "Keycloak",
-    "firebase-auth": "Firebase Auth",
-    "oidc-generic": "OIDC",
-    "azure-blob": "Azure Blob"
-  };
-  return names[service.id] || String(service.name || service.id || "").replace(/_/g, " ").replace(/\b\w/g, (m) => m.toUpperCase());
-}
-
-function detectInfraBadges(prodDeps) {
-  const badges = [];
-  const seen = new Set();
-  const visibleKinds = new Set(["db", "ts", "cache", "queue", "cloud"]);
-  for (const service of INFRA_SERVICES) {
-    if (!visibleKinds.has(service.kind)) continue;
-    const hit = (service.deps || []).some((token) => [...prodDeps].some((dep) => depMatches(dep, token)));
-    if (hit) addBadge(badges, seen, service.id, infraDisplayName(service), { kind: service.kind });
-  }
-  return badges;
-}
-
-function detectTestBadges({ dir, pkg, inventory, allDeps }) {
-  const badges = [];
-  const seen = new Set();
-  const deps = new Set(Object.keys(allDeps || {}).map((x) => x.toLowerCase()));
-  const scripts = Object.values(pkg?.scripts || {}).join("\n").toLowerCase();
-  const hasDep = (...names) => names.some((name) => deps.has(name.toLowerCase()));
-  const hasFile = (re) => [...(inventory.files || [])].some((file) => re.test(file));
-  const hasScript = (re) => re.test(scripts);
-
-  if (hasDep("@playwright/test", "playwright") || hasFile(/(^|\/)playwright\.config\.[cm]?[jt]s$/) || hasScript(/\bplaywright\b/)) {
-    addBadge(badges, seen, "playwright", "Playwright", { kind: "e2e" });
-  }
-  if (hasDep("vitest") || hasFile(/(^|\/)vitest\.config\.[cm]?[jt]s$/) || hasScript(/\bvitest\b/)) {
-    addBadge(badges, seen, "vitest", "Vitest", { kind: "unit" });
-  }
-  if (hasDep("jest", "@jest/globals", "ts-jest") || hasFile(/(^|\/)jest\.config\.[cm]?[jt]s$/) || hasScript(/\bjest\b/)) {
-    addBadge(badges, seen, "jest", "Jest", { kind: "unit" });
-  }
-  if (hasDep("cypress") || hasFile(/(^|\/)cypress\.config\.[cm]?[jt]s$/) || hasScript(/\bcypress\b/)) {
-    addBadge(badges, seen, "cypress", "Cypress", { kind: "e2e" });
-  }
-  if (hasDep("mocha") || hasScript(/\bmocha\b/)) addBadge(badges, seen, "mocha", "Mocha", { kind: "unit" });
-  if (hasDep("ava") || hasScript(/\bava\b/)) addBadge(badges, seen, "ava", "AVA", { kind: "unit" });
-  if (hasDep("pytest") || existsSync(join(dir, "pytest.ini")) || hasFile(/(^|\/)test_.*\.py$/)) {
-    addBadge(badges, seen, "pytest", "pytest", { kind: "unit" });
-  }
-  if (existsSync(join(dir, "go.mod")) && hasFile(/_test\.go$/)) addBadge(badges, seen, "go-test", "go test", { kind: "unit" });
-  if (existsSync(join(dir, "Cargo.toml")) && hasFile(/(^|\/)tests\/.*\.rs$/)) addBadge(badges, seen, "cargo-test", "cargo test", { kind: "unit" });
-  return badges;
-}
-
-// Deployment / infra-as-code tooling, detected by file presence. inventory.files is a lowercased,
-// "/"-joined recursive path list (vendored/build dirs already skipped), so a repo's Dockerfile,
-// skaffold.yaml, k8s manifests, helm chart or *.tf light up even when nested.
-function detectDeployBadges(inventory) {
-  const badges = [];
-  const seen = new Set();
-  const files = [...(inventory.files || [])];
-  const hasFile = (re) => files.some((file) => re.test(file));
-  if (hasFile(/(^|\/)(dockerfile|containerfile)(\.[\w.-]+)?$/) || hasFile(/\.dockerfile$/)) addBadge(badges, seen, "docker", "Docker", { kind: "container" });
-  if (hasFile(/(^|\/)(docker-)?compose(\.[\w.-]+)?\.ya?ml$/)) addBadge(badges, seen, "compose", "Compose", { kind: "container" });
-  if (hasFile(/(^|\/)skaffold(\.[\w.-]+)?\.ya?ml$/)) addBadge(badges, seen, "skaffold", "Skaffold", { kind: "deploy" });
-  if (hasFile(/(^|\/)chart\.ya?ml$/) || hasFile(/(^|\/)helm\//)) addBadge(badges, seen, "helm", "Helm", { kind: "orchestration" });
-  if (hasFile(/(^|\/)kustomization\.ya?ml$/) || hasFile(/(^|\/)(k8s|kubernetes|manifests)\/.*\.ya?ml$/)) addBadge(badges, seen, "kubernetes", "K8s", { kind: "orchestration" });
-  if (hasFile(/(^|\/)[^/]+\.tf$/)) addBadge(badges, seen, "terraform", "Terraform", { kind: "iac" });
-  return badges;
-}
-
-export function detectRepoStack(dir, inventory = repoInventory(dir)) {
-  const has = (file) => existsSync(join(dir, file));
-  const pkg = readPackage(dir);
-  const allDeps = packageDeps(pkg, true);
-  const prodDeps = manifestDeps(dir);
-  const ext = inventory.ext || {};
-  const languages = [];
-  const runtimes = [];
-  const seenLang = new Set();
-  const seenRuntime = new Set();
-  const depNames = new Set(Object.keys(allDeps).map((x) => x.toLowerCase()));
-
-  const hasTs = !!(ext[".ts"] || ext[".tsx"] || has("tsconfig.json") || depNames.has("typescript"));
-  const hasJs = !!(ext[".js"] || ext[".jsx"] || ext[".mjs"] || ext[".cjs"] || pkg);
-  if (hasTs) addBadge(languages, seenLang, "typescript", "TS", { title: "TypeScript" });
-  if (hasJs) addBadge(languages, seenLang, "javascript", "JS", { title: "JavaScript" });
-  if (ext[".go"] || has("go.mod")) addBadge(languages, seenLang, "go", "Go", { title: "Go" });
-  if (ext[".py"] || has("requirements.txt") || has("pyproject.toml") || has("setup.py") || has("Pipfile")) addBadge(languages, seenLang, "python", "Python");
-  if (ext[".java"] || has("pom.xml") || has("build.gradle")) addBadge(languages, seenLang, "java", "Java");
-  if (ext[".rs"] || has("Cargo.toml")) addBadge(languages, seenLang, "rust", "Rust");
-  if (ext[".php"] || has("composer.json")) addBadge(languages, seenLang, "php", "PHP");
-  if (ext[".rb"] || has("Gemfile")) addBadge(languages, seenLang, "ruby", "Ruby");
-
-  if (has("bun.lock") || has("bun.lockb") || has("bunfig.toml")) addBadge(runtimes, seenRuntime, "bun", "Bun");
-  if (has("deno.json") || has("deno.jsonc") || has("deno.lock")) addBadge(runtimes, seenRuntime, "deno", "Deno");
-  if (pkg && !seenRuntime.has("bun") && !seenRuntime.has("deno")) addBadge(runtimes, seenRuntime, "node", "Node");
-
-  return {
-    languages,
-    runtimes,
-    tests: detectTestBadges({ dir, pkg, inventory, allDeps }),
-    infra: detectInfraBadges(prodDeps),
-    deploy: detectDeployBadges(inventory)
-  };
-}

package/src/scan/search.core.js

@@ -1,24 +0,0 @@
-// Orchestrator for the cross-repo search: picks ripgrep → git grep → pure-Node engine per the
-// configured engine and delegates to the matching module. Split out of search.js.
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { resolveRg, rgSearch } from "./search.rg.js";
-import { gitSearch } from "./search.git.js";
-import { nodeSearch } from "./search.node.js";
-
-// repos: array of absolute repo paths; mode: "content" | "filename"; engine/rgPath: see resolveRg.
-// Returns { ok, engine, truncated, results:[{repo, path, line, column, preview}] }.
-export async function searchAcrossRepos({ repos, query, mode = "content", cap = 300, engine = "auto", rgPath = "", gitPath = "" } = {}) {
-  const roots = [...new Set((Array.isArray(repos) ? repos : []).filter((p) => p && existsSync(p)).map((p) => resolve(p)))].sort((a, b) => b.length - a.length);
-  const q = String(query || "");
-  if (!roots.length || q.trim().length < 2) return { ok: true, engine: "none", truncated: false, results: [] };
-  const rg = await resolveRg(engine, rgPath);
-  const git = (engine === "auto" || engine === "git") ? String(gitPath || "").trim() || "git" : "";
-  try {
-    if (rg) return await rgSearch(rg, roots, q, mode, cap);
-    if (git) return await gitSearch(git, roots, q, mode, cap);
-    return await nodeSearch(roots, q, mode, cap);
-  } catch (error) {
-    return { ok: false, error: error.message, engine: rg ? "ripgrep" : git ? "git-grep" : "node-fallback", results: [] };
-  }
-}