composto-ai 0.3.0 → 0.4.1

package/dist/chunk-AARGW2GV.js

@@ -1,1531 +0,0 @@
-#!/usr/bin/env node
-
-// src/config/loader.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { parse } from "yaml";
-var DEFAULT_CONFIG = {
-  watchers: {
-    security: {
-      enabled: true,
-      severity: { "src/**": "warning", "tests/**": "info" }
-    },
-    deadCode: { enabled: true, trigger: "on-commit" },
-    consoleLog: { enabled: true, severity: { "src/**": "warning", "tests/**": "info" } }
-  },
-  agents: {
-    fixer: { enabled: true, model: "haiku" },
-    reviewer: { enabled: false, model: "sonnet" }
-  },
-  ir: {
-    deltaContextLines: 3,
-    confidenceThreshold: 0.6,
-    genericPatterns: "default"
-  },
-  trends: {
-    enabled: true,
-    hotspotThreshold: 10,
-    bugFixRatioThreshold: 0.5,
-    decayCheckTrigger: "on-commit",
-    fullReportSchedule: "weekly"
-  }
-};
-function deepMerge(target, source) {
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
-      result[key] = deepMerge(target[key] ?? {}, source[key]);
-    } else {
-      result[key] = source[key];
-    }
-  }
-  return result;
-}
-function parseConfig(yamlContent) {
-  if (!yamlContent.trim()) return { ...DEFAULT_CONFIG };
-  const parsed = parse(yamlContent) ?? {};
-  return deepMerge(DEFAULT_CONFIG, parsed);
-}
-function loadConfig(projectPath) {
-  const configPath = join(projectPath, ".composto", "config.yaml");
-  if (!existsSync(configPath)) return { ...DEFAULT_CONFIG };
-  const content = readFileSync(configPath, "utf-8");
-  return parseConfig(content);
-}
-
-// src/watcher/detector.ts
-import picomatch from "picomatch";
-function getSeverity(filePath, severityMap) {
-  for (const [glob, severity] of Object.entries(severityMap)) {
-    if (picomatch.isMatch(filePath, glob)) return severity;
-  }
-  return "info";
-}
-var SECRET_PATTERNS = [
-  /["'](sk-[a-zA-Z0-9-]{20,})["']/,
-  /["'](AKIA[0-9A-Z]{16})["']/,
-  /["'](ghp_[a-zA-Z0-9]{36})["']/,
-  /(?:password|secret|token|api_?key)\s*[:=]\s*["']([^"']{8,})["']/i
-];
-function securityRule(code, filePath, severityMap) {
-  const findings = [];
-  const severity = getSeverity(filePath, severityMap);
-  const lines = code.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim().startsWith("//") || line.trim().startsWith("/*")) continue;
-    for (const pattern of SECRET_PATTERNS) {
-      if (pattern.test(line)) {
-        findings.push({
-          watcherId: "security",
-          severity,
-          file: filePath,
-          line: i + 1,
-          message: "Potential hardcoded secret detected",
-          action: {
-            type: "agent-required",
-            agentHint: { role: "fixer", model: "haiku", contextFiles: [filePath] }
-          }
-        });
-        break;
-      }
-    }
-  }
-  return findings;
-}
-function consoleLogRule(code, filePath, severityMap) {
-  const findings = [];
-  const severity = getSeverity(filePath, severityMap);
-  const lines = code.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    if (/\bconsole\.(log|debug|info|warn)\b/.test(lines[i])) {
-      findings.push({
-        watcherId: "consoleLog",
-        severity,
-        file: filePath,
-        line: i + 1,
-        message: "console.log detected \u2014 likely debug artifact",
-        action: { type: "auto-fix", autoFix: "remove-line" }
-      });
-    }
-  }
-  return findings;
-}
-var RULES = {
-  security: securityRule,
-  consoleLog: consoleLogRule
-};
-function runDetector(code, filePath, watcherConfigs) {
-  const findings = [];
-  for (const [name, config] of Object.entries(watcherConfigs)) {
-    if (!config.enabled) continue;
-    const rule = RULES[name];
-    if (rule && config.severity) {
-      findings.push(...rule(code, filePath, config.severity));
-    }
-  }
-  return findings;
-}
-
-// src/ir/health.ts
-var CHURN_THRESHOLD = 10;
-var FIX_RATIO_THRESHOLD = 0.5;
-function buildHealthTag(health) {
-  const parts = [];
-  if (health.churn > CHURN_THRESHOLD) parts.push(`HOT:${health.churn}/30`);
-  if (health.fixRatio > FIX_RATIO_THRESHOLD) parts.push(`FIX:${Math.round(health.fixRatio * 100)}%`);
-  if (health.coverageTrend === "down") parts.push("COV:\u2193");
-  if (health.consistency === "low") parts.push("INCON");
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
-}
-function annotateIR(ir, health) {
-  const tag = buildHealthTag(health);
-  if (!tag) return ir;
-  const lines = ir.split("\n");
-  lines[0] = `${lines[0]} ${tag}`;
-  return lines.join("\n");
-}
-function computeHealthFromTrends(file, trends) {
-  const hotspot = trends.hotspots.find((h) => h.file === file);
-  const decay = trends.decaySignals.find((d) => d.file === file);
-  const inconsistency = trends.inconsistencies.find((i) => i.file === file);
-  return {
-    churn: hotspot?.changesInLast30Commits ?? 0,
-    fixRatio: hotspot?.bugFixRatio ?? 0,
-    coverageTrend: decay?.trend === "declining" ? "down" : decay?.trend === "improving" ? "up" : "stable",
-    staleness: "",
-    authorCount: hotspot?.authorCount ?? 0,
-    consistency: inconsistency ? "low" : "high"
-  };
-}
-
-// src/ir/structure.ts
-var CLASSIFIERS = [
-  [/^(function|def|fn|func)\b/, "function-start"],
-  [/^(class|struct|interface)\b/, "type-start"],
-  [/^(if|else|elif|switch|match|case)\b/, "branch"],
-  [/^(for|while|loop|do)\b/, "loop"],
-  [/^(return|yield)\b/, "exit"],
-  [/^(import|require|use|from)\b/, "import"],
-  [/^(export|pub|public)\b/, "export"],
-  [/^(const|let|var|val|mut)\b/, "assignment"],
-  [/^(try|catch|except|finally)\b/, "error-handling"],
-  [/^(async|await)\b/, "async"],
-  [/^(\/\/|\/\*|#)/, "comment"]
-];
-function classifyLine(firstToken) {
-  if (firstToken === "") return "blank";
-  for (const [pattern, type] of CLASSIFIERS) {
-    if (pattern.test(firstToken)) return type;
-  }
-  return "unknown";
-}
-function extractStructure(code) {
-  const lines = code.split("\n");
-  return lines.map((raw, i) => {
-    const indent = raw.search(/\S/);
-    const trimmed = raw.trim();
-    const firstToken = trimmed.split(/[\s({<]/)[0];
-    const type = classifyLine(firstToken);
-    return {
-      line: i + 1,
-      indent: indent === -1 ? -1 : indent,
-      type,
-      raw
-    };
-  });
-}
-
-// src/ir/fingerprint.ts
-var PATTERNS = [
-  // import type { x, y } from "module"
-  {
-    match: /^import\s+type\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
-    transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
-    confidence: 0.95
-  },
-  // import { x, y } from "module"
-  {
-    match: /^import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["'];?\s*$/,
-    transform: (m) => `USE:${m[2]}{${m[1].replace(/\s/g, "")}}`,
-    confidence: 0.95
-  },
-  // import type x from "module"
-  {
-    match: /^import\s+type\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
-    transform: (m) => `USE:${m[2]}{${m[1]}}`,
-    confidence: 0.95
-  },
-  // import x from "module"
-  {
-    match: /^import\s+(\w+)\s+from\s+["']([^"']+)["'];?\s*$/,
-    transform: (m) => `USE:${m[2]}{${m[1]}}`,
-    confidence: 0.95
-  },
-  // const x = require("module")
-  {
-    match: /^(?:const|let|var)\s+(\w+)\s*=\s*require\(["']([^"']+)["']\);?\s*$/,
-    transform: (m) => `USE:${m[2]}{${m[1]}}`,
-    confidence: 0.95
-  },
-  // export function name(params) {
-  {
-    match: /^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{?\s*$/,
-    transform: (m) => `OUT FN:${m[1]}(${m[2].replace(/\s/g, "")})`,
-    confidence: 0.95
-  },
-  // function name(params) {
-  {
-    match: /^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{?\s*$/,
-    transform: (m) => `FN:${m[1]}(${m[2].replace(/\s/g, "")})`,
-    confidence: 0.95
-  },
-  // export class Name extends Base {
-  {
-    match: /^export\s+class\s+(\w+)(?:\s+extends\s+(\w+))?\s*(?:implements\s+\S+\s*)?\{?\s*$/,
-    transform: (m) => `OUT CLASS:${m[1]}${m[2] ? ` < ${m[2]}` : ""}`,
-    confidence: 0.95
-  },
-  // class Name extends Base {
-  {
-    match: /^class\s+(\w+)(?:\s+extends\s+(\w+))?\s*(?:implements\s+\S+\s*)?\{?\s*$/,
-    transform: (m) => `CLASS:${m[1]}${m[2] ? ` < ${m[2]}` : ""}`,
-    confidence: 0.95
-  },
-  // if (cond) return expr;
-  {
-    match: /^if\s*\(([^)]+)\)\s*return\s+(.+);?\s*$/,
-    transform: (m) => `IF:${m[1].trim()} -> RET ${m[2].trim().replace(/;$/, "")}`,
-    confidence: 0.95
-  },
-  // if (cond) {
-  {
-    match: /^if\s*\(([^)]+)\)\s*\{?\s*$/,
-    transform: (m) => `IF:${m[1].trim()}`,
-    confidence: 0.9
-  },
-  // for (... of/in ...) {
-  {
-    match: /^for\s*\((?:const|let|var)\s+(\w+)\s+(?:of|in)\s+(\w+)\)\s*\{?\s*$/,
-    transform: (m) => `LOOP:${m[2]} -> ${m[1]}`,
-    confidence: 0.9
-  },
-  // return expr
-  {
-    match: /^return\s+(.+);?\s*$/,
-    transform: (m) => `RET ${m[1].trim().replace(/;$/, "")}`,
-    confidence: 0.95
-  },
-  // return;
-  {
-    match: /^return;?\s*$/,
-    transform: () => "RET",
-    confidence: 0.95
-  },
-  // try {
-  {
-    match: /^try\s*\{\s*$/,
-    transform: () => "TRY:",
-    confidence: 0.9
-  },
-  // catch (e) {
-  {
-    match: /^(?:\}\s*)?catch\s*\((\w+)\)\s*\{?\s*$/,
-    transform: (m) => `CATCH:${m[1]}`,
-    confidence: 0.9
-  },
-  // switch (expr) {
-  {
-    match: /^switch\s*\(([^)]+)\)\s*\{?\s*$/,
-    transform: (m) => `SWITCH:${m[1].trim()}`,
-    confidence: 0.9
-  },
-  // case "value":  /  case value:
-  {
-    match: /^case\s+(.+)\s*:\s*$/,
-    transform: (m) => `CASE:${m[1].trim()}`,
-    confidence: 0.9
-  },
-  // default:
-  {
-    match: /^default\s*:\s*$/,
-    transform: () => "DEFAULT:",
-    confidence: 0.9
-  },
-  // export type Name = ...
-  {
-    match: /^export\s+type\s+(\w+)(?:<[^>]+>)?\s*=\s*(.+);?\s*$/,
-    transform: (m) => `OUT TYPE:${m[1]}`,
-    confidence: 0.9
-  },
-  // if (cond) expr;  (inline if with method call)
-  {
-    match: /^if\s*\(([^)]+)\)\s+(\w+.+);?\s*$/,
-    transform: (m) => `IF:${m[1].trim()} -> ${m[2].replace(/;$/, "").trim().slice(0, 50)}`,
-    confidence: 0.9
-  },
-  // export async function name(  (multiline signature)
-  {
-    match: /^export\s+(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(\s*$/,
-    transform: (m) => `OUT FN:${m[1]}(`,
-    confidence: 0.95
-  },
-  // interface/type property — name: type;
-  {
-    match: /^\s*(\w+)\??\s*:\s*(.+);?\s*$/,
-    transform: (m) => `PROP:${m[1]}: ${m[2].replace(/;$/, "").trim()}`,
-    confidence: 0.75
-  },
-  // const x = await expr;
-  {
-    match: /^(?:export\s+)?(?:const|let|var)\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*await\s+(.+);?\s*$/,
-    transform: (m) => {
-      const prefix = m[0].startsWith("export") ? "OUT " : "";
-      return `${prefix}AWAIT:VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
-    },
-    confidence: 0.85
-  },
-  // export const name = async (params) => {  OR  export const name = (params) => expr;
-  {
-    match: /^export\s+(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
-    transform: (m) => {
-      const asyncPrefix = m[2] ? "ASYNC " : "";
-      const body = m[4].replace(/[{;]\s*$/, "").trim();
-      return `OUT ${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
-    },
-    confidence: 0.9
-  },
-  // const name = async (params) => {  OR  const name = (params) => expr;
-  {
-    match: /^(?:const|let|var)\s+(\w+)\s*=\s*(async\s+)?\(([^)]*)\)\s*=>\s*(.*)$/,
-    transform: (m) => {
-      const asyncPrefix = m[2] ? "ASYNC " : "";
-      const body = m[4].replace(/[{;]\s*$/, "").trim();
-      return `${asyncPrefix}FN:${m[1]} = (${m[3].trim()}) => ${body || "{"}`;
-    },
-    confidence: 0.9
-  },
-  // get name() {
-  {
-    match: /^\s*get\s+(\w+)\s*\(\)\s*(?::\s*\S+\s*)?\{?\s*$/,
-    transform: (m) => `GET:${m[1]}()`,
-    confidence: 0.9
-  },
-  // set name(value) {
-  {
-    match: /^\s*set\s+(\w+)\s*\(([^)]*)\)\s*\{?\s*$/,
-    transform: (m) => `SET:${m[1]}(${m[2].replace(/\s/g, "")})`,
-    confidence: 0.9
-  },
-  // methodName(params) {  (inside class body, indented)
-  {
-    match: /^\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?\{\s*$/,
-    transform: (m) => {
-      const name = m[1];
-      if (["if", "for", "while", "switch", "catch", "function"].includes(name)) return `${name}`;
-      return `METHOD:${name}(${m[2].replace(/\s/g, "")})`;
-    },
-    confidence: 0.9
-  },
-  // const { a, b } = expr (object destructuring — before regular assignment)
-  {
-    match: /^(?:const|let|var)\s+\{([^}]+)\}\s*=\s*(.+);?\s*$/,
-    transform: (m) => `VAR:{${m[1].replace(/\s/g, "")}} = ${m[2].replace(/;$/, "").trim()}`,
-    confidence: 0.9
-  },
-  // const [a, b] = expr (destructuring — before regular assignment)
-  {
-    match: /^(?:const|let|var)\s+\[([^\]]+)\]\s*=\s*(.+);?\s*$/,
-    transform: (m) => `VAR:[${m[1].replace(/\s/g, "")}] = ${m[2].replace(/;$/, "").trim()}`,
-    confidence: 0.9
-  },
-  // const name = value;
-  {
-    match: /^(?:export\s+)?(?:const|let|var)\s+(\w+)(?:\s*:\s*[^=]+)?\s*=\s*(.+);?\s*$/,
-    transform: (m) => {
-      const prefix = m[0].startsWith("export") ? "OUT " : "";
-      return `${prefix}VAR:${m[1]} = ${m[2].replace(/;$/, "").trim()}`;
-    },
-    confidence: 0.85
-  }
-];
-function fingerprintLine(line) {
-  const trimmed = line.trim();
-  if (trimmed === "" || trimmed === "{" || trimmed === "}" || trimmed === "});" || trimmed === ");") {
-    return { type: "fingerprint", ir: "", confidence: 1 };
-  }
-  if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
-    return { type: "fingerprint", ir: "", confidence: 1 };
-  }
-  for (const pattern of PATTERNS) {
-    const match = trimmed.match(pattern.match);
-    if (match) {
-      const ir = pattern.transform(match);
-      if (pattern.confidence > 0.9) {
-        return { type: "fingerprint", ir, confidence: pattern.confidence };
-      }
-      return {
-        type: "fingerprint+hint",
-        ir,
-        hint: trimmed,
-        confidence: pattern.confidence
-      };
-    }
-  }
-  return { type: "raw", ir: trimmed, confidence: 0.1 };
-}
-function fingerprintFile(code, confidenceThreshold = 0.6) {
-  const lines = code.split("\n");
-  const irLines = [];
-  for (const line of lines) {
-    const indent = line.search(/\S/);
-    const indentStr = indent > 0 ? "  ".repeat(Math.floor(indent / 2)) : "";
-    const result = fingerprintLine(line);
-    if (result.ir === "") continue;
-    if (result.confidence >= confidenceThreshold) {
-      irLines.push(`${indentStr}${result.ir}`);
-    }
-  }
-  return irLines.join("\n");
-}
-
-// src/parser/init.ts
-import { Parser, Language } from "web-tree-sitter";
-import { resolve, dirname } from "path";
-import { existsSync as existsSync2 } from "fs";
-import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var initialized = false;
-var cache = /* @__PURE__ */ new Map();
-function grammarPath(lang) {
-  const distPath = resolve(__dirname, "grammars", `tree-sitter-${lang}.wasm`);
-  if (existsSync2(distPath)) return distPath;
-  const devPath = resolve(__dirname, "../../grammars", `tree-sitter-${lang}.wasm`);
-  if (existsSync2(devPath)) return devPath;
-  throw new Error(`Grammar not found for ${lang}`);
-}
-async function getParser(lang) {
-  if (!initialized) {
-    await Parser.init();
-    initialized = true;
-  }
-  const cached = cache.get(lang);
-  if (cached) return cached;
-  const parser = new Parser();
-  const language = await Language.load(grammarPath(lang));
-  parser.setLanguage(language);
-  const result = { parser, language };
-  cache.set(lang, result);
-  return result;
-}
-
-// src/parser/languages.ts
-import { extname } from "path";
-var EXT_MAP = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".mjs": "javascript",
-  ".py": "python",
-  ".go": "go",
-  ".rs": "rust"
-};
-var SUPPORTED_EXTENSIONS = Object.keys(EXT_MAP);
-function detectLanguage(filePath) {
-  const ext = extname(filePath);
-  return EXT_MAP[ext] ?? null;
-}
-
-// src/ir/ast-walker.ts
-var TIER_MAP = {
-  // Tier 1 — structural declarations (JS/TS)
-  import_statement: "T1_KEEP",
-  function_declaration: "T1_KEEP",
-  class_declaration: "T1_KEEP",
-  interface_declaration: "T1_KEEP",
-  type_alias_declaration: "T1_KEEP",
-  enum_declaration: "T1_KEEP",
-  // Tier 1 — Python
-  function_definition: "T1_KEEP",
-  class_definition: "T1_KEEP",
-  import_from_statement: "T1_KEEP",
-  decorated_definition: "T1_KEEP",
-  // Tier 1 — class members (qualified methods)
-  method_definition: "T1_KEEP",
-  // JS/TS class method
-  public_field_definition: "T1_KEEP",
-  // TS class property
-  // Tier 1 — Go
-  function_item: "T1_KEEP",
-  // Rust
-  method_declaration: "T1_KEEP",
-  // Go
-  type_declaration: "T1_KEEP",
-  // Go
-  import_declaration: "T1_KEEP",
-  // Go
-  use_declaration: "T1_KEEP",
-  // Rust
-  struct_item: "T1_KEEP",
-  // Rust
-  enum_item: "T1_KEEP",
-  // Rust
-  trait_item: "T1_KEEP",
-  // Rust
-  impl_item: "T1_KEEP",
-  // Rust
-  // Tier 2 — control flow (universal)
-  if_statement: "T2_CONTROL",
-  if_expression: "T2_CONTROL",
-  // Rust
-  else_clause: "WALK_ONLY",
-  elif_clause: "T2_CONTROL",
-  // Python
-  for_statement: "T2_CONTROL",
-  for_in_statement: "T2_CONTROL",
-  for_expression: "T2_CONTROL",
-  // Rust
-  while_statement: "T2_CONTROL",
-  do_statement: "T2_CONTROL",
-  switch_statement: "T2_CONTROL",
-  switch_case: "T2_CONTROL",
-  switch_default: "T2_CONTROL",
-  match_expression: "T2_CONTROL",
-  // Rust
-  return_statement: "T2_CONTROL",
-  return_expression: "T2_CONTROL",
-  // Rust
-  throw_statement: "T2_CONTROL",
-  raise_statement: "T2_CONTROL",
-  // Python
-  try_statement: "T2_CONTROL",
-  catch_clause: "T2_CONTROL",
-  except_clause: "T2_CONTROL",
-  // Python
-  with_statement: "T2_CONTROL",
-  // Python
-  defer_statement: "T2_CONTROL",
-  // Go
-  // Tier 3 — compressible expressions
-  lexical_declaration: "T3_COMPRESS",
-  expression_statement: "T3_COMPRESS",
-  assignment: "T3_COMPRESS",
-  // Python
-  short_var_declaration: "T3_COMPRESS",
-  // Go
-  // Walk-only — containers
-  program: "WALK_ONLY",
-  module: "WALK_ONLY",
-  // Python
-  statement_block: "WALK_ONLY",
-  block: "WALK_ONLY",
-  // Python/Go/Rust
-  class_body: "WALK_ONLY",
-  // JS/TS
-  switch_body: "WALK_ONLY",
-  export_statement: "WALK_ONLY",
-  source_file: "WALK_ONLY"
-  // Go/Rust
-};
-function tierOf(nodeType) {
-  return TIER_MAP[nodeType] ?? "T4_DROP";
-}
-function collapseText(text, maxLen) {
-  const collapsed = text.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
-  if (collapsed.length <= maxLen) return collapsed;
-  return collapsed.slice(0, maxLen - 3) + "...";
-}
-function getTypeParams(node) {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (child.type === "type_parameters") {
-      return child.text;
-    }
-  }
-  return "";
-}
-function isExported(node) {
-  return node.parent?.type === "export_statement";
-}
-function isAsync(node) {
-  return node.text.trimStart().startsWith("async");
-}
-function extractDocComment(node) {
-  let prev = node.previousNamedSibling;
-  if (!prev && node.parent?.type === "export_statement") {
-    prev = node.parent.previousNamedSibling;
-  }
-  if (!prev || prev.type !== "comment") return null;
-  const text = prev.text;
-  if (!text.startsWith("/**")) return null;
-  const body = text.replace(/^\/\*\*|\*\/$/g, "").replace(/^\s*\*\s?/gm, "").trim();
-  const tags = [];
-  const tagMatches = body.matchAll(/@(\w+)(?:\s+([^\n@]+))?/g);
-  for (const m of tagMatches) {
-    const tag = m[1];
-    const val = (m[2] ?? "").trim();
-    if (tag === "deprecated") tags.push("@deprecated");
-    else if (tag === "internal") tags.push("@internal");
-    else if (tag === "throws" && val) tags.push(`@throws:${val.length > 30 ? val.slice(0, 27) + "..." : val}`);
-  }
-  const beforeTags = body.split(/@\w+/)[0].trim();
-  const desc = beforeTags.split(/[.\n]/)[0].trim();
-  const parts = [];
-  if (tags.length > 0) parts.push(tags.join(" "));
-  if (desc && desc.length > 3) {
-    parts.push(`"${desc.length > 50 ? desc.slice(0, 47) + "..." : desc}"`);
-  }
-  return parts.length > 0 ? parts.join(" ") : null;
-}
-function extractPythonDocstring(bodyNode) {
-  if (!bodyNode) return null;
-  for (let i = 0; i < bodyNode.childCount; i++) {
-    const child = bodyNode.child(i);
-    if (child.type === "expression_statement" && child.childCount > 0) {
-      const expr = child.child(0);
-      if (expr.type === "string") {
-        const text = expr.text.replace(/^(['"]{3}|['"])|(['"]{3}|['"])$/g, "").trim();
-        const firstLine = text.split("\n")[0].trim();
-        return firstLine.length > 3 ? `"${firstLine.length > 50 ? firstLine.slice(0, 47) + "..." : firstLine}"` : null;
-      }
-      break;
-    }
-  }
-  return null;
-}
-function extractCondition(node) {
-  const condNode = node.childForFieldName("condition") ?? (() => {
-    for (let i = 0; i < node.childCount; i++) {
-      const c = node.child(i);
-      if (c.type === "parenthesized_expression") return c;
-    }
-    return null;
-  })();
-  if (!condNode) return "...";
-  const text = condNode.text.replace(/^\(/, "").replace(/\)$/, "").trim();
-  return text.length > 60 ? text.slice(0, 57) + "..." : text;
-}
-function emitTier2(node) {
-  switch (node.type) {
-    case "if_statement": {
-      const cond = extractCondition(node);
-      return `IF:${cond}`;
-    }
-    case "else_clause":
-      return "ELSE:";
-    case "for_statement":
-    case "for_in_statement":
-      return "LOOP";
-    case "while_statement": {
-      const cond = extractCondition(node);
-      return `WHILE:${cond}`;
-    }
-    case "do_statement": {
-      const cond = extractCondition(node);
-      return `WHILE:${cond}`;
-    }
-    case "switch_statement": {
-      const expr = node.childForFieldName("value") ?? node.childForFieldName("condition") ?? (() => {
-        for (let i = 0; i < node.childCount; i++) {
-          const c = node.child(i);
-          if (c.type === "parenthesized_expression") return c;
-        }
-        return null;
-      })();
-      const text = expr ? expr.text.replace(/^\(/, "").replace(/\)$/, "").trim() : "...";
-      return `SWITCH:${text.length > 60 ? text.slice(0, 57) + "..." : text}`;
-    }
-    case "switch_case": {
-      let value = null;
-      const valNode = node.childForFieldName("value");
-      if (valNode) {
-        value = valNode.text;
-      } else {
-        for (let i = 0; i < node.childCount; i++) {
-          const c = node.child(i);
-          if (c.type !== "case" && c.type !== ":" && c.childCount === 0 && c.text === "case") continue;
-          if (c.type !== "case" && c.text !== "case" && c.text !== ":") {
-            value = c.text;
-            break;
-          }
-        }
-      }
-      return `CASE:${value ?? "..."}`;
-    }
-    case "switch_default":
-      return "DEFAULT:";
-    case "return_statement": {
-      let retText = "";
-      for (let i = 0; i < node.childCount; i++) {
-        const c = node.child(i);
-        if (c.text !== "return" && c.text !== ";") {
-          retText += (retText ? " " : "") + c.text;
-        }
-      }
-      retText = retText.replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ").trim();
-      if (!retText) return "RET";
-      return `RET ${retText.length > 60 ? retText.slice(0, 57) + "..." : retText}`;
-    }
-    case "throw_statement": {
-      let throwText = "";
-      for (let i = 0; i < node.childCount; i++) {
-        const c = node.child(i);
-        if (c.text !== "throw" && c.text !== ";") {
-          throwText += (throwText ? " " : "") + c.text;
-        }
-      }
-      throwText = throwText.trim();
-      return `THROW:${throwText.length > 60 ? throwText.slice(0, 57) + "..." : throwText}`;
-    }
-    case "try_statement":
-      return "TRY";
-    case "catch_clause": {
-      const param = node.childForFieldName("parameter");
-      const paramText = param ? param.text : "...";
-      return `CATCH:${paramText}`;
-    }
-    // Python
-    case "raise_statement": {
-      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
-      return `RAISE:${val.length > 50 ? val.slice(0, 47) + "..." : val}`;
-    }
-    case "except_clause":
-      return "EXCEPT";
-    case "elif_clause": {
-      const cond = extractCondition(node);
-      return `ELIF:${cond}`;
-    }
-    case "with_statement":
-      return "WITH";
-    // Rust
-    case "if_expression": {
-      const cond = extractCondition(node);
-      return `IF:${cond}`;
-    }
-    case "for_expression":
-      return "LOOP";
-    case "match_expression":
-      return "MATCH";
-    case "return_expression": {
-      const val = node.childCount > 1 ? node.child(1)?.text ?? "" : "";
-      return `RET ${val.length > 60 ? val.slice(0, 57) + "..." : val}`.trimEnd();
-    }
-    // Go
-    case "defer_statement":
-      return "DEFER";
-    default:
-      return null;
-  }
-}
-function emitTier1(node) {
-  const exported = isExported(node);
-  const outPrefix = exported ? "OUT " : "";
-  switch (node.type) {
-    case "import_statement": {
-      const text = collapseText(node.text, 80);
-      return `USE:${text}`;
-    }
-    case "function_declaration": {
-      const name = node.childForFieldName("name")?.text ?? "anonymous";
-      const rawParams = node.childForFieldName("parameters")?.text ?? "()";
-      const params = collapseText(rawParams, 60);
-      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}${outPrefix}${asyncPrefix}FN:${name}${params}`;
-    }
-    case "class_declaration": {
-      const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      const typeParams = getTypeParams(node);
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}${outPrefix}CLASS:${name}${typeParams}`;
-    }
-    case "interface_declaration": {
-      const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      const typeParams = getTypeParams(node);
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}${outPrefix}INTERFACE:${name}${typeParams}`;
-    }
-    case "type_alias_declaration": {
-      const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}${outPrefix}TYPE:${name}`;
-    }
-    case "enum_declaration": {
-      const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}${outPrefix}ENUM:${name}`;
-    }
-    case "method_definition": {
-      let enclosingClass = null;
-      let parent = node.parent;
-      while (parent) {
-        if (parent.type === "class_declaration" || parent.type === "class_definition") {
-          enclosingClass = parent.childForFieldName("name")?.text ?? null;
-          break;
-        }
-        parent = parent.parent;
-      }
-      const name = node.childForFieldName("name")?.text ?? "anonymous";
-      const params = node.childForFieldName("parameters")?.text ?? "()";
-      const asyncPrefix = isAsync(node) ? "ASYNC " : "";
-      const doc = extractDocComment(node);
-      const docPrefix = doc ? `${doc} ` : "";
-      const qualifiedName = enclosingClass ? `${enclosingClass}.${name}` : name;
-      return `${docPrefix}${asyncPrefix}METHOD:${qualifiedName}${collapseText(params, 60)}`;
-    }
-    case "public_field_definition": {
-      const name = node.childForFieldName("name")?.text ?? "field";
-      return `FIELD:${name}`;
-    }
-    // Python
-    case "function_definition": {
-      const name = node.childForFieldName("name")?.text ?? "anonymous";
-      const params = node.childForFieldName("parameters")?.text ?? "()";
-      const returnType = node.childForFieldName("return_type")?.text ?? "";
-      const rt = returnType ? ` -> ${returnType}` : "";
-      const body = node.childForFieldName("body");
-      const doc = extractPythonDocstring(body);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}FN:${name}${collapseText(params, 60)}${rt}`;
-    }
-    case "class_definition": {
-      const name = node.childForFieldName("name")?.text ?? "Anonymous";
-      const superclass = node.childForFieldName("superclasses")?.text ?? "";
-      const sc = superclass ? `(${collapseText(superclass, 40)})` : "";
-      const body = node.childForFieldName("body");
-      const doc = extractPythonDocstring(body);
-      const docPrefix = doc ? `${doc} ` : "";
-      return `${docPrefix}CLASS:${name}${sc}`;
-    }
-    case "import_from_statement": {
-      return `USE:${collapseText(node.text, 80)}`;
-    }
-    case "decorated_definition": {
-      return null;
-    }
-    // Go
-    case "method_declaration":
-    case "type_declaration":
-    case "import_declaration": {
-      return `${collapseText(node.text, 80)}`;
-    }
-    // Rust
-    case "function_item": {
-      const name = node.childForFieldName("name")?.text ?? "anonymous";
-      const params = node.childForFieldName("parameters")?.text ?? "()";
-      return `FN:${name}${collapseText(params, 60)}`;
-    }
-    case "struct_item":
-    case "enum_item":
-    case "trait_item":
-    case "impl_item":
-    case "use_declaration": {
-      const firstLine = node.text.split("\n")[0];
-      return collapseText(firstLine, 80);
-    }
-    default:
-      return null;
-  }
-}
-function emitTier3(node) {
-  switch (node.type) {
-    case "lexical_declaration": {
-      let declarator = null;
-      for (let i = 0; i < node.childCount; i++) {
-        const c = node.child(i);
-        if (c.type === "variable_declarator") {
-          declarator = c;
-          break;
-        }
-      }
-      if (!declarator) return null;
-      const name = declarator.childForFieldName("name")?.text ?? "?";
-      const value = declarator.childForFieldName("value");
-      if (value) {
-        if (value.type === "arrow_function") {
-          const asyncPrefix = isAsync(value) ? "ASYNC " : "";
-          const params = value.childForFieldName("parameters")?.text ?? "()";
-          return `${asyncPrefix}FN:${name}${collapseText(params, 60)} => ...`;
-        }
-        if (value.type === "await_expression") {
-          const callee = value.childCount > 1 ? value.child(1).text : "...";
-          return `AWAIT:${name}=${collapseText(callee, 40)}`;
-        }
-        if (node.parent?.type === "statement_block") return null;
-        const vt = value.type;
-        if (vt === "number" || vt === "true" || vt === "false") return null;
-        if (vt === "object" || vt === "array") return null;
-        if (vt === "new_expression" || vt === "call_expression") return null;
-        const valText = value.text.replace(/"[^"]*"/g, '""').replace(/'[^']*'/g, "''").replace(/`[^`]*`/g, "``");
-        return `VAR:${name} = ${collapseText(valText, 50)}`;
-      }
-      return null;
-    }
-    case "expression_statement": {
-      const expr = node.child(0);
-      if (!expr) return null;
-      if (expr.type === "await_expression") {
-        return null;
-      }
-      if (expr.type === "call_expression") {
-        const callee = expr.child(0)?.text ?? "";
-        if (callee === "ObjectSetPrototypeOf" || callee === "Object.setPrototypeOf") {
-          const args = expr.child(1);
-          if (args && args.childCount >= 4) {
-            const child = args.child(1)?.text ?? "?";
-            const parent = args.child(3)?.text ?? "?";
-            const shortChild = child.length > 30 ? child.slice(0, 27) + "..." : child;
-            const shortParent = parent.length > 30 ? parent.slice(0, 27) + "..." : parent;
-            return `EXTENDS:${shortChild} < ${shortParent}`;
-          }
-        }
-        return null;
-      }
-      return null;
-    }
-    default:
-      return null;
-  }
-}
-function walkNode(node, depth, lines) {
-  const tier = tierOf(node.type);
-  switch (tier) {
-    case "T1_KEEP": {
-      const ir = emitTier1(node);
-      if (ir) lines.push(ir);
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        const childType = child.type;
-        if (childType === "statement_block" || childType === "class_body" || childType === "block" || // Python/Go/Rust
-        childType === "body" || // Python class/function body
-        childType === "declaration_list") {
-          walkNode(child, depth + 1, lines);
-        }
-      }
-      break;
-    }
-    case "T2_CONTROL": {
-      if (depth > 4 && node.type !== "return_statement" && node.type !== "throw_statement" && node.type !== "switch_case" && node.type !== "switch_default") break;
-      if (node.type === "if_statement") {
-        let hasElse = false;
-        for (let i = 0; i < node.childCount; i++) {
-          if (node.child(i).type === "else_clause") {
-            hasElse = true;
-            break;
-          }
-        }
-        if (!hasElse) {
-          const body = node.childForFieldName("consequence") ?? (() => {
-            for (let i = 0; i < node.childCount; i++) {
-              const c = node.child(i);
-              if (c.type === "statement_block") return c;
-            }
-            return null;
-          })();
-          if (body) {
-            let singleStmt = null;
-            if (body.type === "statement_block") {
-              const stmts = [];
-              for (let i = 0; i < body.childCount; i++) {
-                const c = body.child(i);
-                if (c.type !== "{" && c.type !== "}") stmts.push(c);
-              }
-              if (stmts.length === 1) singleStmt = stmts[0];
-            } else if (body.type === "return_statement" || body.type === "throw_statement") {
-              singleStmt = body;
-            }
-            if (singleStmt && (singleStmt.type === "return_statement" || singleStmt.type === "throw_statement")) {
-              const cond = extractCondition(node);
-              const retLine = emitTier2(singleStmt);
-              if (retLine) {
-                const indent2 = "  ".repeat(depth);
-                lines.push(`${indent2}IF:${cond} \u2192 ${retLine}`);
-                break;
-              }
-            }
-          }
-        }
-      }
-      const line = emitTier2(node);
-      const indent = "  ".repeat(depth);
-      if (line) lines.push(indent + line);
-      for (let i = 0; i < node.childCount; i++) {
-        walkNode(node.child(i), depth + 1, lines);
-      }
-      break;
-    }
-    case "T3_COMPRESS": {
-      if (depth > 4) break;
-      const line = emitTier3(node);
-      const indent = "  ".repeat(depth);
-      if (line) lines.push(indent + line);
-      break;
-    }
-    case "WALK_ONLY": {
-      for (let i = 0; i < node.childCount; i++) {
-        const child = node.child(i);
-        if (node.type === "export_statement") {
-          if (child.type === "export" || child.type === "default" || child.text === "export" || child.text === "default") {
-            if (child.childCount === 0 && (child.text === "export" || child.text === "default")) {
-              continue;
-            }
-          }
-        }
-        walkNode(child, depth + 1, lines);
-      }
-      break;
-    }
-    case "T4_DROP":
-    default:
-      break;
-  }
-}
-async function astWalkIR(code, filePath) {
-  const lang = detectLanguage(filePath);
-  if (!lang) return null;
-  const { parser } = await getParser(lang);
-  const tree = parser.parse(code);
-  const root = tree.rootNode;
-  const lines = [];
-  walkNode(root, 0, lines);
-  if (lines.length === 0) return null;
-  const pass1 = [];
-  let useBlock = [];
-  for (const line of lines) {
-    if (line.startsWith("USE:")) {
-      const m = line.match(/from\s+["']([^"']+)["']/);
-      useBlock.push(m ? m[1] : line.slice(4));
-    } else {
-      if (useBlock.length > 0) {
-        if (useBlock.length <= 3) {
-          for (const mod of useBlock) pass1.push(`USE:${mod}`);
-        } else {
-          pass1.push(`USE:[${useBlock.join(", ")}]`);
-        }
-        useBlock = [];
-      }
-      pass1.push(line);
-    }
-  }
-  if (useBlock.length > 0) {
-    if (useBlock.length <= 3) {
-      for (const mod of useBlock) pass1.push(`USE:${mod}`);
-    } else {
-      pass1.push(`USE:[${useBlock.join(", ")}]`);
-    }
-  }
-  const merged = [];
-  let guardBlock = [];
-  for (const line of pass1) {
-    const guardMatch = line.match(/^(\s*)IF:(.+?) \u2192 RET/);
-    if (guardMatch) {
-      guardBlock.push(guardMatch[2].trim());
-      continue;
-    }
-    if (guardBlock.length > 0) {
-      if (guardBlock.length < 3) {
-        for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
-      } else {
-        merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
-      }
-      guardBlock = [];
-    }
-    merged.push(line);
-  }
-  if (guardBlock.length > 0) {
-    if (guardBlock.length < 3) {
-      for (const g of guardBlock) merged.push(`  IF:${g} \u2192 RET`);
-    } else {
-      merged.push(`  GUARD:[${guardBlock.join(", ")}]`);
-    }
-  }
-  return merged.join("\n");
-}
-
-// src/ir/layers.ts
-function generateL0(code, filePath) {
-  const structure = extractStructure(code);
-  const topLevel = structure.filter(
-    (s) => s.indent === 0 && ["function-start", "type-start", "export"].includes(s.type)
-  );
-  const declarations = topLevel.map((s) => {
-    const name = s.raw.match(
-      /(?:function|class|interface|const|let|var|export\s+(?:default\s+)?(?:function|class|async\s+function))\s+(\w+)/
-    )?.[1] ?? "unknown";
-    return `  ${s.type === "type-start" ? "CLASS" : "FN"}:${name} L${s.line}`;
-  });
-  return `${filePath}
-${declarations.join("\n")}`;
-}
-async function generateL1(code, filePath, health) {
-  const ir = await astWalkIR(code, filePath) ?? fingerprintFile(code, 0.75);
-  const result = ir.length < code.length ? ir : code;
-  if (health) {
-    return annotateIR(result, health);
-  }
-  return result;
-}
-function generateL2(delta, health) {
-  const parts = [`FILE: ${delta.file}`];
-  for (const hunk of delta.hunks) {
-    if (hunk.functionScope) parts.push(`SCOPE: ${hunk.functionScope}`);
-    parts.push(`CHANGED: ${hunk.changed.join("\n         ")}`);
-    if (hunk.surroundingIR) parts.push(`CONTEXT: ${hunk.surroundingIR}`);
-    if (hunk.blame) {
-      parts.push(`BLAME: ${hunk.blame.author}, ${hunk.blame.date}, commit:"${hunk.blame.commitMessage}"`);
-    }
-  }
-  const ir = parts.join("\n");
-  if (health) return annotateIR(ir, health);
-  return ir;
-}
-function generateL3(code, startLine, endLine) {
-  const lines = code.split("\n");
-  return lines.slice(startLine - 1, endLine).join("\n");
-}
-async function generateLayer(layer, options) {
-  switch (layer) {
-    case "L0":
-      return generateL0(options.code, options.filePath);
-    case "L1":
-      return generateL1(options.code, options.filePath, options.health);
-    case "L2":
-      if (!options.delta) return generateL1(options.code, options.filePath, options.health);
-      return generateL2(options.delta, options.health);
-    case "L3":
-      if (options.lineRange) {
-        return generateL3(options.code, options.lineRange.start, options.lineRange.end);
-      }
-      return options.code;
-  }
-}
-
-// src/trends/git-log-parser.ts
-import { execSync } from "child_process";
-var BUG_FIX_PATTERNS = [
-  /\bfix\b/i,
-  /\bbugfix\b/i,
-  /\bhotfix\b/i,
-  /\bpatch\b/i,
-  /\bresolve\b/i,
-  /\bbug\b/i
-];
-function isBugFixCommit(message) {
-  return BUG_FIX_PATTERNS.some((p) => p.test(message));
-}
-function parseGitLogOutput(output) {
-  const entries = [];
-  const lines = output.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i].trim();
-    if (!line || !line.includes("|")) {
-      i++;
-      continue;
-    }
-    const [hash, author, date, ...messageParts] = line.split("|");
-    const message = messageParts.join("|");
-    const files = [];
-    i++;
-    while (i < lines.length && lines[i].trim() !== "" && !lines[i].includes("|")) {
-      const fileLine = lines[i].trim();
-      if (fileLine) files.push(fileLine);
-      i++;
-    }
-    entries.push({ hash, author, date, message, files });
-  }
-  return entries;
-}
-function getGitLog(repoPath, count = 100) {
-  try {
-    const output = execSync(
-      `git log --format="%h|%an|%as|%s" --name-only -n ${count}`,
-      { cwd: repoPath, encoding: "utf-8", timeout: 1e4 }
-    );
-    return parseGitLogOutput(output);
-  } catch {
-    return [];
-  }
-}
-
-// src/trends/hotspot.ts
-function detectHotspots(entries, options) {
-  const fileStats = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const isFix = isBugFixCommit(entry.message);
-    for (const file of entry.files) {
-      const stats = fileStats.get(file) ?? { changes: 0, fixes: 0, authors: /* @__PURE__ */ new Set() };
-      stats.changes++;
-      if (isFix) stats.fixes++;
-      stats.authors.add(entry.author);
-      fileStats.set(file, stats);
-    }
-  }
-  const hotspots = [];
-  for (const [file, stats] of fileStats) {
-    const fixRatio = stats.changes > 0 ? stats.fixes / stats.changes : 0;
-    if (stats.changes >= options.threshold && fixRatio >= options.fixRatioThreshold) {
-      hotspots.push({
-        file,
-        changesInLast30Commits: stats.changes,
-        bugFixRatio: fixRatio,
-        authorCount: stats.authors.size
-      });
-    }
-  }
-  return hotspots.sort((a, b) => b.changesInLast30Commits - a.changesInLast30Commits);
-}
-
-// src/trends/decay.ts
-function detectDecay(entries) {
-  const fileChanges = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const file of entry.files) {
-      const changes = fileChanges.get(file) ?? [];
-      changes.push({ date: entry.date });
-      fileChanges.set(file, changes);
-    }
-  }
-  const signals = [];
-  for (const [file, changes] of fileChanges) {
-    if (changes.length < 4) continue;
-    const sorted = [...changes].sort((a, b) => a.date.localeCompare(b.date));
-    const firstDate = new Date(sorted[0].date).getTime();
-    const lastDate = new Date(sorted[sorted.length - 1].date).getTime();
-    const midDate = firstDate + (lastDate - firstDate) / 2;
-    const firstHalfCount = sorted.filter((c) => new Date(c.date).getTime() <= midDate).length;
-    const secondHalfCount = sorted.length - firstHalfCount;
-    if (secondHalfCount > firstHalfCount) {
-      signals.push({
-        file,
-        metric: "churn",
-        trend: "declining",
-        dataPoints: sorted.map((c, i) => ({ date: c.date, value: i + 1 }))
-      });
-    }
-  }
-  return signals;
-}
-
-// src/trends/inconsistency.ts
-function detectInconsistencies(entries, minAuthors = 3) {
-  const fileAuthors = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    for (const file of entry.files) {
-      const authors = fileAuthors.get(file) ?? /* @__PURE__ */ new Map();
-      const commits = authors.get(entry.author) ?? [];
-      commits.push(entry.message);
-      authors.set(entry.author, commits);
-      fileAuthors.set(file, authors);
-    }
-  }
-  const inconsistencies = [];
-  for (const [file, authors] of fileAuthors) {
-    if (authors.size >= minAuthors) {
-      const patterns = Array.from(authors.entries()).map(([author, commits]) => ({
-        author,
-        style: categorizeStyle(commits)
-      }));
-      inconsistencies.push({ file, patterns });
-    }
-  }
-  return inconsistencies;
-}
-function categorizeStyle(commits) {
-  const types = commits.map((m) => {
-    if (m.match(/^fix/i)) return "fix";
-    if (m.match(/^feat/i)) return "feature";
-    if (m.match(/^refactor/i)) return "refactor";
-    return "other";
-  });
-  const primary = mode(types);
-  return `primarily ${primary} (${commits.length} commits)`;
-}
-function mode(arr) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const item of arr) {
-    counts.set(item, (counts.get(item) ?? 0) + 1);
-  }
-  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "unknown";
-}
-
-// src/benchmark/tokenizer.ts
-function estimateTokens(text) {
-  if (!text) return 0;
-  const tokens = text.split(/[\s]+|(?<=[{}()[\];,.:=<>!&|?+\-*/^~@#$%\\])|(?=[{}()[\];,.:=<>!&|?+\-*/^~@#$%\\])/).filter(Boolean);
-  return tokens.length;
-}
-
-// src/benchmark/runner.ts
-async function benchmarkFile(code, filePath) {
-  const rawTokens = estimateTokens(code);
-  const irL0 = await generateLayer("L0", { code, filePath, health: null });
-  const irL1 = await generateLayer("L1", { code, filePath, health: null });
-  const irL0Tokens = estimateTokens(irL0);
-  const irL1Tokens = estimateTokens(irL1);
-  const astResult = await astWalkIR(code, filePath);
-  const engine = astResult !== null ? "AST" : "FP";
-  const savedPercent = rawTokens > 0 ? (rawTokens - irL1Tokens) / rawTokens * 100 : 0;
-  return { file: filePath, rawTokens, irL0Tokens, irL1Tokens, savedPercent, engine };
-}
-function summarize(results) {
-  const totalRaw = results.reduce((s, r) => s + r.rawTokens, 0);
-  const totalIRL0 = results.reduce((s, r) => s + r.irL0Tokens, 0);
-  const totalIRL1 = results.reduce((s, r) => s + r.irL1Tokens, 0);
-  const totalSavedPercent = totalRaw > 0 ? (totalRaw - totalIRL1) / totalRaw * 100 : 0;
-  const astCount = results.filter((r) => r.engine === "AST").length;
-  const fpCount = results.filter((r) => r.engine === "FP").length;
-  return { fileCount: results.length, totalRaw, totalIRL0, totalIRL1, totalSavedPercent, astCount, fpCount };
-}
-
-// src/context/packer.ts
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function findTargetFile(files, target) {
-  const t = escapeRegex(target);
-  const declarationPatterns = [
-    // JS/TS declarations
-    new RegExp(`(?:export\\s+)?(?:async\\s+)?function\\s+${t}\\b`),
-    new RegExp(`(?:export\\s+)?class\\s+${t}\\b`),
-    new RegExp(`(?:export\\s+)?interface\\s+${t}\\b`),
-    new RegExp(`(?:export\\s+)?type\\s+${t}\\b`),
-    new RegExp(`(?:export\\s+)?enum\\s+${t}\\b`),
-    new RegExp(`(?:export\\s+)?(?:const|let|var)\\s+${t}\\b`),
-    // Python
-    new RegExp(`\\bdef\\s+${t}\\b`),
-    // Rust
-    new RegExp(`\\bfn\\s+${t}\\b`),
-    new RegExp(`\\bstruct\\s+${t}\\b`),
-    new RegExp(`\\btrait\\s+${t}\\b`),
-    // Go
-    new RegExp(`\\bfunc\\s+${t}\\b`),
-    new RegExp(`\\btype\\s+${t}\\b`),
-    // Object method shorthand
-    new RegExp(`\\b${t}\\s*:\\s*(?:async\\s+)?function\\b`),
-    new RegExp(`\\b${t}\\s*\\([^)]*\\)\\s*\\{`)
-  ];
-  for (const pattern of declarationPatterns) {
-    const match2 = files.find((f) => pattern.test(f.code));
-    if (match2) return match2.path;
-  }
-  const fallback = new RegExp(`\\b${t}\\s*\\(`);
-  const match = files.find((f) => fallback.test(f.code));
-  return match ? match.path : null;
-}
-function findRelatedFiles(files, targetPath) {
-  const related = /* @__PURE__ */ new Set();
-  const targetFile = files.find((f) => f.path === targetPath);
-  if (!targetFile) return related;
-  const importPattern = /(?:import|require)\s*(?:\([^)]*|\{[^}]*\}|\w+)?\s*(?:from)?\s*["']([^"']+)["']/g;
-  const imports = [...targetFile.code.matchAll(importPattern)].map((m) => m[1]);
-  for (const imp of imports) {
-    const match = files.find((f) => {
-      const basename = f.path.replace(/\.[^.]+$/, "");
-      return imp.includes(basename) || basename.endsWith(imp.replace(/^\.\.?\//, "").replace(/\.[^.]+$/, ""));
-    });
-    if (match) related.add(match.path);
-  }
-  const targetBasename = targetPath.replace(/\.[^.]+$/, "").split("/").pop() ?? "";
-  for (const file of files) {
-    if (file.path === targetPath) continue;
-    if (file.code.includes(targetBasename)) {
-      related.add(file.path);
-    }
-  }
-  return related;
-}
-async function packContext(files, options) {
-  const { budget, hotspots, target } = options;
-  const hotspotSet = new Set(hotspots.map((h) => h.file));
-  let targetPath = null;
-  let relatedFiles = /* @__PURE__ */ new Set();
-  if (target) {
-    targetPath = findTargetFile(files, target);
-    if (targetPath) {
-      relatedFiles = findRelatedFiles(files, targetPath);
-    }
-  }
-  const entries = [];
-  let totalTokens = 0;
-  let filesAtL3 = 0;
-  let targetDowngraded = false;
-  if (targetPath) {
-    const targetFile = files.find((f) => f.path === targetPath);
-    const rawTokens = estimateTokens(targetFile.code);
-    if (rawTokens <= budget * 0.6) {
-      entries.push({
-        path: targetPath,
-        layer: "L3",
-        ir: targetFile.code,
-        tokens: rawTokens,
-        isTarget: true
-      });
-      totalTokens += rawTokens;
-      filesAtL3 = 1;
-    } else {
-      targetDowngraded = true;
-      const l1 = await generateLayer("L1", { code: targetFile.code, filePath: targetFile.path, health: null });
-      const l1Tokens = estimateTokens(l1);
-      entries.push({
-        path: targetPath,
-        layer: "L1",
-        ir: l1,
-        tokens: l1Tokens,
-        isTarget: true
-      });
-      totalTokens += l1Tokens;
-    }
-  }
-  for (const file of files) {
-    if (file.path === targetPath) continue;
-    const l0 = await generateLayer("L0", { code: file.code, filePath: file.path, health: null });
-    const l0Tokens = estimateTokens(l0);
-    entries.push({ path: file.path, layer: "L0", ir: l0, tokens: l0Tokens });
-    totalTokens += l0Tokens;
-  }
-  if (totalTokens > budget) {
-    const truncated = entries.filter((e) => e.isTarget);
-    let used = truncated.reduce((s, e) => s + e.tokens, 0);
-    for (const entry of entries) {
-      if (entry.isTarget) continue;
-      if (used + entry.tokens <= budget) {
-        truncated.push(entry);
-        used += entry.tokens;
-      }
-    }
-    return {
-      entries: truncated,
-      totalTokens: used,
-      budget,
-      filesAtL0: truncated.filter((e) => e.layer === "L0").length,
-      filesAtL1: truncated.filter((e) => e.layer === "L1").length,
-      filesAtL3,
-      targetFile: targetPath ?? void 0,
-      targetDowngraded
-    };
-  }
-  const upgradeOrder = entries.map((e, i) => ({
-    index: i,
-    path: e.path,
-    rawTokens: files.find((f) => f.path === e.path)?.rawTokens ?? 0,
-    isHotspot: hotspotSet.has(e.path),
-    isRelated: relatedFiles.has(e.path),
-    isTarget: e.isTarget ?? false
-  })).filter((x) => x.isTarget === false && entries[x.index].layer === "L0").sort((a, b) => {
-    if (a.isRelated && !b.isRelated) return -1;
-    if (!a.isRelated && b.isRelated) return 1;
-    if (a.isHotspot && !b.isHotspot) return -1;
-    if (!a.isHotspot && b.isHotspot) return 1;
-    return b.rawTokens - a.rawTokens;
-  });
-  let filesAtL1 = 0;
-  for (const item of upgradeOrder) {
-    const file = files.find((f) => f.path === item.path);
-    const l1 = await generateLayer("L1", { code: file.code, filePath: file.path, health: null });
-    const l1Tokens = estimateTokens(l1);
-    const currentTokens = entries[item.index].tokens;
-    const additional = l1Tokens - currentTokens;
-    if (totalTokens + additional <= budget) {
-      entries[item.index] = {
-        path: item.path,
-        layer: "L1",
-        ir: l1,
-        tokens: l1Tokens
-      };
-      totalTokens += additional;
-      filesAtL1++;
-    }
-  }
-  return {
-    entries,
-    totalTokens,
-    budget,
-    filesAtL0: entries.filter((e) => e.layer === "L0").length,
-    filesAtL1,
-    filesAtL3,
-    targetFile: targetPath ?? void 0,
-    targetDowngraded
-  };
-}
-
-export {
-  loadConfig,
-  runDetector,
-  computeHealthFromTrends,
-  generateLayer,
-  getGitLog,
-  detectHotspots,
-  detectDecay,
-  detectInconsistencies,
-  estimateTokens,
-  benchmarkFile,
-  summarize,
-  packContext
-};