opencroc 1.6.9 → 1.8.0

package/dist/index.js

@@ -819,20 +819,20 @@ function detectCycles(dag) {
   const color = /* @__PURE__ */ new Map();
   for (const node of dag.nodes) color.set(node, 0 /* WHITE */);
   const warnings = [];
-  const path14 = [];
+  const path17 = [];
   function dfs(node) {
     color.set(node, 1 /* GRAY */);
-    path14.push(node);
+    path17.push(node);
     for (const neighbor of adjacency.get(node) || []) {
       const nc = color.get(neighbor);
       if (nc === 1 /* GRAY */) {
-        const cycleStart = path14.indexOf(neighbor);
-        warnings.push(`Cycle detected: ${path14.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
+        const cycleStart = path17.indexOf(neighbor);
+        warnings.push(`Cycle detected: ${path17.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
       } else if (nc === 0 /* WHITE */) {
         dfs(neighbor);
       }
     }
-    path14.pop();
+    path17.pop();
     color.set(node, 2 /* BLACK */);
   }
   for (const node of dag.nodes) {
@@ -3896,50 +3896,50 @@ var defaultFs = {
   mkdirp: (d) => mkdirSync(d, { recursive: true })
 };
 async function applyControlledFix(opts) {
-  const fs12 = opts.fs ?? defaultFs;
+  const fs15 = opts.fs ?? defaultFs;
   const scope = opts.options?.scope ?? "config-only";
   const dryRun = opts.options?.dryRun ?? true;
   const verify = opts.options?.verify ?? true;
   const configPath = opts.configPath;
   const backupPath = configPath + ".backup";
-  if (!fs12.exists(configPath)) {
+  if (!fs15.exists(configPath)) {
     return { success: false, scope, fixedItems: [], rolledBack: false, error: `Config file not found: ${configPath}` };
   }
-  const originalContent = fs12.read(configPath);
-  fs12.write(backupPath, originalContent);
+  const originalContent = fs15.read(configPath);
+  fs15.write(backupPath, originalContent);
   const validation = opts.validator.validate(originalContent);
   if (validation.passed) {
-    cleanup(fs12, backupPath);
+    cleanup(fs15, backupPath);
     return { success: true, scope, fixedItems: [], rolledBack: false };
   }
   let fixResult;
   try {
     fixResult = opts.fixer.fix(originalContent, validation.errors);
   } catch (err) {
-    rollback(fs12, backupPath, configPath);
+    rollback(fs15, backupPath, configPath);
     return { success: false, scope, fixedItems: [], rolledBack: true, error: `Fix threw: ${err instanceof Error ? err.message : String(err)}` };
   }
   if (!fixResult.success) {
-    rollback(fs12, backupPath, configPath);
+    rollback(fs15, backupPath, configPath);
     return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Remaining errors: ${fixResult.remainingErrors.join("; ")}` };
   }
   if (dryRun) {
     const dryValidation = opts.validator.validate(fixResult.fixedContent);
     if (!dryValidation.passed) {
-      rollback(fs12, backupPath, configPath);
+      rollback(fs15, backupPath, configPath);
       return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Dry-run validation failed: ${dryValidation.errors.join("; ")}` };
     }
   }
-  fs12.write(configPath, fixResult.fixedContent);
+  fs15.write(configPath, fixResult.fixedContent);
   if (verify) {
-    const reloaded = fs12.read(configPath);
+    const reloaded = fs15.read(configPath);
     const postValidation = opts.validator.validate(reloaded);
     if (!postValidation.passed) {
-      rollback(fs12, backupPath, configPath);
+      rollback(fs15, backupPath, configPath);
       return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Post-write verification failed: ${postValidation.errors.join("; ")}` };
     }
   }
-  cleanup(fs12, backupPath);
+  cleanup(fs15, backupPath);
   let prUrl;
   if (scope === "config-and-source" && opts.attribution && opts.prGenerator) {
     try {
@@ -3949,16 +3949,16 @@ async function applyControlledFix(opts) {
   }
   return { success: true, scope, fixedItems: fixResult.fixedItems, rolledBack: false, prUrl };
 }
-function rollback(fs12, backupPath, configPath) {
-  if (fs12.exists(backupPath)) {
-    const backup = fs12.read(backupPath);
-    fs12.write(configPath, backup);
-    fs12.remove(backupPath);
+function rollback(fs15, backupPath, configPath) {
+  if (fs15.exists(backupPath)) {
+    const backup = fs15.read(backupPath);
+    fs15.write(configPath, backup);
+    fs15.remove(backupPath);
   }
 }
-function cleanup(fs12, backupPath) {
-  if (fs12.exists(backupPath)) {
-    fs12.remove(backupPath);
+function cleanup(fs15, backupPath) {
+  if (fs15.exists(backupPath)) {
+    fs15.remove(backupPath);
   }
 }
 
@@ -6648,21 +6648,21 @@ function extractPath(url) {
     return url;
   }
 }
-function shouldIgnore(path14) {
-  const lower = path14.toLowerCase();
+function shouldIgnore(path17) {
+  const lower = path17.toLowerCase();
   return IGNORE_KEYWORDS.some((kw) => lower.includes(kw));
 }
 function selectCandidates(responses, maxCount = 20) {
   const unique = /* @__PURE__ */ new Map();
   for (const item of responses) {
     if (!item.url.includes("/api/")) continue;
-    const path14 = extractPath(item.url);
-    if (shouldIgnore(path14)) continue;
+    const path17 = extractPath(item.url);
+    if (shouldIgnore(path17)) continue;
     const method = item.method.toUpperCase();
     if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method)) continue;
-    const key = item.requestId ? `rid:${item.requestId}` : `mp:${method}:${path14}`;
+    const key = item.requestId ? `rid:${item.requestId}` : `mp:${method}:${path17}`;
     if (!unique.has(key)) {
-      unique.set(key, { requestId: item.requestId, method, path: path14, url: item.url });
+      unique.set(key, { requestId: item.requestId, method, path: path17, url: item.url });
     }
   }
   return Array.from(unique.values()).slice(0, maxCount);
@@ -6675,12 +6675,12 @@ function selectCandidatesFromLogs(logs, maxCount = 20) {
     const method = getField(log, "method").toUpperCase();
     if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method)) continue;
     const rawPath = getField(log, "apiPath") || getField(log, "url");
-    const path14 = extractPath(rawPath);
-    if (!path14.includes("/api/") || shouldIgnore(path14)) continue;
+    const path17 = extractPath(rawPath);
+    if (!path17.includes("/api/") || shouldIgnore(path17)) continue;
     const requestId = getField(log, "requestId") || void 0;
-    const key = requestId ? `rid:${requestId}` : `mp:${method}:${path14}`;
+    const key = requestId ? `rid:${requestId}` : `mp:${method}:${path17}`;
     if (!unique.has(key)) {
-      unique.set(key, { requestId, method, path: path14, url: rawPath });
+      unique.set(key, { requestId, method, path: path17, url: rawPath });
     }
   }
   return Array.from(unique.values()).slice(0, maxCount);
@@ -7142,6 +7142,2072 @@ function printOrchestrationSummary(summary) {
   lines.push("");
   return lines;
 }
+
+// src/scanner/language-detector.ts
+init_esm_shims();
+import * as fs12 from "fs";
+import * as path14 from "path";
+var EXTENSION_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".pyw": "python",
+  ".pyi": "python",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro",
+  ".sql": "sql",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".proto": "protobuf",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".json": "json",
+  ".toml": "toml",
+  ".md": "markdown",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".sass": "sass",
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".ps1": "powershell",
+  ".dockerfile": "docker",
+  ".tf": "terraform",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".scala": "scala",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".zig": "zig"
+};
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  "out",
+  "target",
+  "__pycache__",
+  ".cache",
+  ".next",
+  ".nuxt",
+  ".output",
+  "vendor",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "coverage",
+  ".idea",
+  ".vscode",
+  ".vs",
+  ".turbo",
+  ".nx",
+  "bower_components",
+  "jspm_packages"
+]);
+var MAX_DEPTH = 8;
+var MAX_FILES = 1e4;
+function detectProject(rootDir) {
+  const absRoot = path14.resolve(rootDir);
+  const languages = {};
+  const linesByLanguage = {};
+  const files = [];
+  let totalFiles = 0;
+  let totalLines = 0;
+  function walk(dir, depth) {
+    if (depth > MAX_DEPTH || totalFiles > MAX_FILES) return;
+    let entries;
+    try {
+      entries = fs12.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (totalFiles > MAX_FILES) break;
+      const fullPath = path14.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+          walk(fullPath, depth + 1);
+        }
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const ext = path14.extname(entry.name).toLowerCase();
+      const lang = detectLanguageByFile(entry.name, ext);
+      if (!lang) continue;
+      let lineCount = 0;
+      let fileSize = 0;
+      try {
+        const stat = fs12.statSync(fullPath);
+        fileSize = stat.size;
+        if (fileSize < 1048576) {
+          const content = fs12.readFileSync(fullPath, "utf-8");
+          lineCount = content.split("\n").length;
+        }
+      } catch {
+        continue;
+      }
+      languages[lang] = (languages[lang] || 0) + 1;
+      linesByLanguage[lang] = (linesByLanguage[lang] || 0) + lineCount;
+      totalFiles++;
+      totalLines += lineCount;
+      const relPath = path14.relative(absRoot, fullPath).replace(/\\/g, "/");
+      files.push({ path: relPath, language: lang, lines: lineCount, size: fileSize });
+    }
+  }
+  walk(absRoot, 0);
+  const codeLangs = Object.entries(languages).filter(([k]) => !["json", "yaml", "toml", "markdown", "html", "css", "scss", "less", "sass"].includes(k)).sort((a, b) => b[1] - a[1]);
+  const primaryLanguage = codeLangs[0]?.[0] || "unknown";
+  const frameworks = detectFrameworks(absRoot, languages, files);
+  const projectType = detectProjectType(absRoot, languages, frameworks);
+  const packageManager = detectPackageManager(absRoot);
+  return {
+    languages,
+    linesByLanguage,
+    totalFiles,
+    totalLines,
+    primaryLanguage,
+    frameworks,
+    projectType,
+    packageManager,
+    files
+  };
+}
+function detectLanguageByFile(fileName, ext) {
+  if (fileName === "Dockerfile" || fileName.startsWith("Dockerfile.")) return "docker";
+  if (fileName === "Makefile") return "makefile";
+  if (fileName === "CMakeLists.txt") return "cmake";
+  if (fileName === "Vagrantfile") return "ruby";
+  if (fileName === "Gemfile") return "ruby";
+  if (fileName === "Rakefile") return "ruby";
+  if (fileName === "Cargo.toml") return "rust";
+  if (fileName === "go.mod" || fileName === "go.sum") return "go";
+  return EXTENSION_MAP[ext] || null;
+}
+var FRAMEWORK_RULES = [
+  // --- Node.js / JavaScript ---
+  {
+    name: "express",
+    detect: (root) => detectFromPackageJson(root, "express", "Express")
+  },
+  {
+    name: "nestjs",
+    detect: (root) => detectFromPackageJson(root, "@nestjs/core", "NestJS")
+  },
+  {
+    name: "fastify",
+    detect: (root) => detectFromPackageJson(root, "fastify", "Fastify")
+  },
+  {
+    name: "koa",
+    detect: (root) => detectFromPackageJson(root, "koa", "Koa")
+  },
+  {
+    name: "hapi",
+    detect: (root) => detectFromPackageJson(root, "@hapi/hapi", "Hapi")
+  },
+  {
+    name: "nextjs",
+    detect: (root) => detectFromPackageJson(root, "next", "Next.js")
+  },
+  {
+    name: "nuxtjs",
+    detect: (root) => detectFromPackageJson(root, "nuxt", "Nuxt.js")
+  },
+  {
+    name: "react",
+    detect: (root) => detectFromPackageJson(root, "react", "React")
+  },
+  {
+    name: "vue",
+    detect: (root) => detectFromPackageJson(root, "vue", "Vue")
+  },
+  {
+    name: "angular",
+    detect: (root) => detectFromPackageJson(root, "@angular/core", "Angular")
+  },
+  {
+    name: "svelte",
+    detect: (root) => detectFromPackageJson(root, "svelte", "Svelte")
+  },
+  {
+    name: "electron",
+    detect: (root) => detectFromPackageJson(root, "electron", "Electron")
+  },
+  {
+    name: "sequelize",
+    detect: (root) => detectFromPackageJson(root, "sequelize", "Sequelize")
+  },
+  {
+    name: "typeorm",
+    detect: (root) => detectFromPackageJson(root, "typeorm", "TypeORM")
+  },
+  {
+    name: "prisma",
+    detect: (root) => detectFromPackageJson(root, "prisma", "Prisma") || detectFromPackageJson(root, "@prisma/client", "Prisma")
+  },
+  {
+    name: "mongoose",
+    detect: (root) => detectFromPackageJson(root, "mongoose", "Mongoose")
+  },
+  {
+    name: "playwright",
+    detect: (root) => detectFromPackageJson(root, "@playwright/test", "Playwright")
+  },
+  // --- Python ---
+  {
+    name: "django",
+    detect: (root) => detectFromRequirements(root, "django", "Django") || detectFromFile(root, "manage.py", "Django")
+  },
+  {
+    name: "flask",
+    detect: (root) => detectFromRequirements(root, "flask", "Flask")
+  },
+  {
+    name: "fastapi",
+    detect: (root) => detectFromRequirements(root, "fastapi", "FastAPI")
+  },
+  {
+    name: "pytorch",
+    detect: (root) => detectFromRequirements(root, "torch", "PyTorch")
+  },
+  {
+    name: "tensorflow",
+    detect: (root) => detectFromRequirements(root, "tensorflow", "TensorFlow")
+  },
+  // --- Go ---
+  {
+    name: "gin",
+    detect: (root) => detectFromGoMod(root, "github.com/gin-gonic/gin", "Gin")
+  },
+  {
+    name: "echo",
+    detect: (root) => detectFromGoMod(root, "github.com/labstack/echo", "Echo")
+  },
+  {
+    name: "fiber",
+    detect: (root) => detectFromGoMod(root, "github.com/gofiber/fiber", "Fiber")
+  },
+  // --- Java ---
+  {
+    name: "spring-boot",
+    detect: (root) => detectFromFile(root, "pom.xml", "Spring Boot", "spring-boot") || detectFromFile(root, "build.gradle", "Spring Boot", "spring-boot")
+  },
+  // --- Rust ---
+  {
+    name: "actix-web",
+    detect: (root) => detectFromCargoToml(root, "actix-web", "Actix Web")
+  },
+  {
+    name: "axum",
+    detect: (root) => detectFromCargoToml(root, "axum", "Axum")
+  },
+  // --- Ruby ---
+  {
+    name: "rails",
+    detect: (root) => detectFromFile(root, "Gemfile", "Ruby on Rails", "rails")
+  },
+  // --- PHP ---
+  {
+    name: "laravel",
+    detect: (root) => detectFromFile(root, "artisan", "Laravel")
+  }
+];
+function detectFromPackageJson(root, dep, name) {
+  const candidates = [
+    path14.join(root, "package.json"),
+    path14.join(root, "backend", "package.json"),
+    path14.join(root, "server", "package.json"),
+    path14.join(root, "api", "package.json"),
+    path14.join(root, "frontend", "package.json"),
+    path14.join(root, "web", "package.json"),
+    path14.join(root, "client", "package.json")
+  ];
+  for (const pkgPath of candidates) {
+    try {
+      if (!fs12.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+      if (dep in allDeps) {
+        return {
+          name,
+          version: allDeps[dep]?.replace(/[\^~>=<]*/g, ""),
+          confidence: 0.95,
+          evidence: `Found "${dep}" in ${path14.relative(root, pkgPath)}`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function detectFromRequirements(root, dep, name) {
+  const candidates = [
+    path14.join(root, "requirements.txt"),
+    path14.join(root, "Pipfile"),
+    path14.join(root, "pyproject.toml"),
+    path14.join(root, "setup.py"),
+    path14.join(root, "setup.cfg")
+  ];
+  for (const filePath of candidates) {
+    try {
+      if (!fs12.existsSync(filePath)) continue;
+      const content = fs12.readFileSync(filePath, "utf-8");
+      const pattern = new RegExp(`^${dep}([>=<~!\\s]|$)`, "im");
+      if (pattern.test(content)) {
+        return {
+          name,
+          confidence: 0.9,
+          evidence: `Found "${dep}" in ${path14.basename(filePath)}`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function detectFromGoMod(root, module, name) {
+  const goModPath = path14.join(root, "go.mod");
+  try {
+    if (!fs12.existsSync(goModPath)) return null;
+    const content = fs12.readFileSync(goModPath, "utf-8");
+    if (content.includes(module)) {
+      return {
+        name,
+        confidence: 0.95,
+        evidence: `Found "${module}" in go.mod`
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function detectFromCargoToml(root, crate, name) {
+  const cargoPath = path14.join(root, "Cargo.toml");
+  try {
+    if (!fs12.existsSync(cargoPath)) return null;
+    const content = fs12.readFileSync(cargoPath, "utf-8");
+    if (content.includes(crate)) {
+      return {
+        name,
+        confidence: 0.9,
+        evidence: `Found "${crate}" in Cargo.toml`
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function detectFromFile(root, fileName, name, searchTerm) {
+  const filePath = path14.join(root, fileName);
+  try {
+    if (!fs12.existsSync(filePath)) return null;
+    if (searchTerm) {
+      const content = fs12.readFileSync(filePath, "utf-8");
+      if (!content.toLowerCase().includes(searchTerm.toLowerCase())) return null;
+    }
+    return {
+      name,
+      confidence: 0.8,
+      evidence: `Found ${fileName}${searchTerm ? ` containing "${searchTerm}"` : ""}`
+    };
+  } catch {
+    return null;
+  }
+}
+function detectFrameworks(root, langs, files) {
+  const detected = [];
+  for (const rule of FRAMEWORK_RULES) {
+    const result = rule.detect(root, langs, files);
+    if (result) detected.push(result);
+  }
+  return detected;
+}
+function detectProjectType(root, langs, frameworks) {
+  const frameworkNames = new Set(frameworks.map((f) => f.name.toLowerCase()));
+  const hasLerna = fs12.existsSync(path14.join(root, "lerna.json"));
+  const hasPnpmWorkspace = fs12.existsSync(path14.join(root, "pnpm-workspace.yaml"));
+  const hasNxJson = fs12.existsSync(path14.join(root, "nx.json"));
+  const hasTurboJson = fs12.existsSync(path14.join(root, "turbo.json"));
+  let hasWorkspaces = false;
+  try {
+    const pkg = JSON.parse(fs12.readFileSync(path14.join(root, "package.json"), "utf-8"));
+    hasWorkspaces = Array.isArray(pkg.workspaces) || typeof pkg.workspaces === "object";
+  } catch {
+  }
+  if (hasLerna || hasPnpmWorkspace || hasNxJson || hasTurboJson || hasWorkspaces) {
+    return "monorepo";
+  }
+  try {
+    const pkg = JSON.parse(fs12.readFileSync(path14.join(root, "package.json"), "utf-8"));
+    if (pkg.main || pkg.exports || pkg.module) {
+      const hasNoServer = !frameworkNames.has("express") && !frameworkNames.has("fastify") && !frameworkNames.has("koa") && !frameworkNames.has("nestjs");
+      const hasNoFrontend = !frameworkNames.has("react") && !frameworkNames.has("vue") && !frameworkNames.has("angular") && !frameworkNames.has("svelte");
+      if (hasNoServer && hasNoFrontend && pkg.keywords) return "library";
+    }
+    if (pkg.bin) return "cli-tool";
+  } catch {
+  }
+  if (frameworkNames.has("next.js") || frameworkNames.has("nuxt.js")) return "frontend-ssr";
+  if (frameworkNames.has("electron")) return "fullstack";
+  if (langs["dart"]) return "mobile";
+  if (langs["swift"] && !langs["typescript"] && !langs["python"]) return "mobile";
+  const hasBackend = frameworkNames.has("express") || frameworkNames.has("fastify") || frameworkNames.has("nestjs") || frameworkNames.has("koa") || frameworkNames.has("django") || frameworkNames.has("flask") || frameworkNames.has("fastapi") || frameworkNames.has("gin") || frameworkNames.has("spring boot") || frameworkNames.has("rails") || frameworkNames.has("laravel");
+  const hasFrontend = frameworkNames.has("react") || frameworkNames.has("vue") || frameworkNames.has("angular") || frameworkNames.has("svelte");
+  if (hasBackend && hasFrontend) return "fullstack";
+  if (hasBackend) return "backend-api";
+  if (hasFrontend) return "frontend-spa";
+  if (frameworkNames.has("actix web") || frameworkNames.has("axum") || frameworkNames.has("gin") || frameworkNames.has("echo") || frameworkNames.has("fiber")) {
+    return "backend-api";
+  }
+  return "unknown";
+}
+function detectPackageManager(root) {
+  if (fs12.existsSync(path14.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs12.existsSync(path14.join(root, "yarn.lock"))) return "yarn";
+  if (fs12.existsSync(path14.join(root, "bun.lockb"))) return "bun";
+  if (fs12.existsSync(path14.join(root, "package-lock.json"))) return "npm";
+  if (fs12.existsSync(path14.join(root, "Pipfile.lock"))) return "pipenv";
+  if (fs12.existsSync(path14.join(root, "poetry.lock"))) return "poetry";
+  if (fs12.existsSync(path14.join(root, "go.sum"))) return "go-modules";
+  if (fs12.existsSync(path14.join(root, "Cargo.lock"))) return "cargo";
+  if (fs12.existsSync(path14.join(root, "Gemfile.lock"))) return "bundler";
+  if (fs12.existsSync(path14.join(root, "composer.lock"))) return "composer";
+  return void 0;
+}
+
+// src/scanner/project-scanner.ts
+init_esm_shims();
+import * as fs13 from "fs";
+import * as path15 from "path";
+async function scanProject(options) {
+  const { rootDir, maxDeepScan = 500, onProgress } = options;
+  const startTime = Date.now();
+  onProgress?.("detecting", 0, "Detecting languages and frameworks...");
+  const detection = detectProject(rootDir);
+  onProgress?.("detecting", 100, `Found ${detection.totalFiles} files, primary: ${detection.primaryLanguage}`);
+  const entities = [];
+  const relationships = [];
+  const sourceFiles = detection.files.filter((f) => {
+    const lang = f.language;
+    return !["json", "yaml", "toml", "markdown", "html", "css", "scss", "less", "sass", "docker", "shell", "powershell"].includes(lang);
+  });
+  const filesToAnalyze = sourceFiles.slice(0, maxDeepScan);
+  for (let i = 0; i < filesToAnalyze.length; i++) {
+    const file = filesToAnalyze[i];
+    const percent = Math.round(i / filesToAnalyze.length * 100);
+    if (i % 20 === 0) {
+      onProgress?.("scanning", percent, `Scanning ${file.path}...`);
+    }
+    const fullPath = path15.join(rootDir, file.path);
+    try {
+      const extracted = extractEntitiesFromFile(fullPath, file.path, file.language);
+      entities.push(...extracted.entities);
+      relationships.push(...extracted.relationships);
+    } catch {
+    }
+  }
+  onProgress?.("scanning", 100, `Extracted ${entities.length} entities`);
+  onProgress?.("configs", 0, "Parsing config files...");
+  const configEntities = extractFromConfigs(rootDir, detection);
+  entities.push(...configEntities.entities);
+  relationships.push(...configEntities.relationships);
+  onProgress?.("configs", 100, "Config parsing complete");
+  onProgress?.("relations", 0, "Building relationships...");
+  const inferredRelations = inferRelationships(entities, rootDir);
+  relationships.push(...inferredRelations);
+  onProgress?.("relations", 100, `${relationships.length} total relationships`);
+  const discoveredFiles = detection.files.map((f) => ({
+    path: f.path,
+    language: f.language,
+    category: categorizeFile(f.path, f.language),
+    lines: f.lines,
+    size: f.size
+  }));
+  return {
+    languages: detection.languages,
+    frameworks: detection.frameworks,
+    files: discoveredFiles,
+    entities,
+    relationships,
+    duration: Date.now() - startTime
+  };
+}
+function extractEntitiesFromFile(fullPath, relPath, language) {
+  switch (language) {
+    case "typescript":
+    case "javascript":
+      return extractFromTsJs(fullPath, relPath, language);
+    case "python":
+      return extractFromPython(fullPath, relPath);
+    case "go":
+      return extractFromGo(fullPath, relPath);
+    case "java":
+    case "kotlin":
+      return extractFromJavaKotlin(fullPath, relPath, language);
+    case "rust":
+      return extractFromRust(fullPath, relPath);
+    case "ruby":
+      return extractFromRuby(fullPath, relPath);
+    case "php":
+      return extractFromPHP(fullPath, relPath);
+    case "vue":
+    case "svelte":
+      return extractFromTsJs(fullPath, relPath, "typescript");
+    // Extract script section
+    default:
+      return { entities: [], relationships: [] };
+  }
+}
+function extractFromTsJs(fullPath, relPath, language) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({
+    id: fileId,
+    name: path15.basename(relPath),
+    type: "file",
+    filePath: relPath,
+    language,
+    metadata: {}
+  });
+  const classRegex = /(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?\s*\{/g;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const extendsClass = match[2];
+    const classId = `class:${relPath}:${className}`;
+    entities.push({
+      id: classId,
+      name: className,
+      type: detectClassType(className, content),
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: { extends: extendsClass }
+    });
+    relationships.push({ sourceId: classId, targetId: fileId, relation: "belongs-to" });
+    if (extendsClass) {
+      relationships.push({
+        sourceId: classId,
+        targetId: `class:*:${extendsClass}`,
+        relation: "extends"
+      });
+    }
+  }
+  const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({
+      id: funcId,
+      name: funcName,
+      type: "function",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: {}
+    });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  const arrowFuncRegex = /export\s+(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?\(/g;
+  while ((match = arrowFuncRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({
+      id: funcId,
+      name: funcName,
+      type: "function",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: { arrow: true }
+    });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  const routeRegex = /(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+  while ((match = routeRegex.exec(content)) !== null) {
+    const method = match[1].toUpperCase();
+    const routePath = match[2];
+    const apiId = `api:${method}:${routePath}`;
+    entities.push({
+      id: apiId,
+      name: `${method} ${routePath}`,
+      type: "api",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: { method, path: routePath }
+    });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  const importRegex = /(?:import\s+.*from\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\))/g;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[1] || match[2];
+    if (importPath.startsWith(".")) {
+      const resolved = resolveRelativeImport(relPath, importPath);
+      relationships.push({
+        sourceId: fileId,
+        targetId: `file:${resolved}`,
+        relation: "imports"
+      });
+    } else {
+      const depName = importPath.startsWith("@") ? importPath.split("/").slice(0, 2).join("/") : importPath.split("/")[0];
+      const depId = `dep:${depName}`;
+      entities.push({
+        id: depId,
+        name: depName,
+        type: "dependency",
+        filePath: "",
+        language: "external",
+        metadata: { external: true }
+      });
+      relationships.push({ sourceId: fileId, targetId: depId, relation: "depends-on" });
+    }
+  }
+  if (content.includes(".init(") || content.includes("Model.init") || content.includes("@Entity") || content.includes("defineModel")) {
+    const tableMatch = content.match(/tableName:\s*['"`](\w+)['"`]/);
+    if (tableMatch) {
+      const tableName = tableMatch[1];
+      const modelId = `model:${tableName}`;
+      entities.push({
+        id: modelId,
+        name: tableName,
+        type: "model",
+        filePath: relPath,
+        language,
+        metadata: { orm: "sequelize" }
+      });
+      relationships.push({ sourceId: modelId, targetId: fileId, relation: "belongs-to" });
+    }
+  }
+  return { entities, relationships };
+}
+function extractFromPython(fullPath, relPath) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language: "python", metadata: {} });
+  const classRegex = /^class\s+(\w+)(?:\(([^)]*)\))?\s*:/gm;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const bases = match[2];
+    const classId = `class:${relPath}:${className}`;
+    entities.push({
+      id: classId,
+      name: className,
+      type: detectPythonClassType(className, bases || "", content),
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "python",
+      metadata: { bases }
+    });
+    relationships.push({ sourceId: classId, targetId: fileId, relation: "belongs-to" });
+  }
+  const funcRegex = /^(?:async\s+)?def\s+(\w+)\s*\(/gm;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    if (funcName.startsWith("_") && funcName !== "__init__") continue;
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({
+      id: funcId,
+      name: funcName,
+      type: "function",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "python",
+      metadata: {}
+    });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  const routeRegex = /@(?:app|router)\.(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi;
+  while ((match = routeRegex.exec(content)) !== null) {
+    const method = match[1].toUpperCase();
+    const routePath = match[2];
+    const apiId = `api:${method}:${routePath}`;
+    entities.push({
+      id: apiId,
+      name: `${method} ${routePath}`,
+      type: "api",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "python",
+      metadata: { method, path: routePath }
+    });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  const djangoUrlRegex = /path\s*\(\s*['"]([^'"]+)['"],\s*(\w+)/g;
+  while ((match = djangoUrlRegex.exec(content)) !== null) {
+    const routePath = match[1];
+    const apiId = `api:ANY:${routePath}`;
+    entities.push({
+      id: apiId,
+      name: routePath,
+      type: "route",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "python",
+      metadata: { handler: match[2] }
+    });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  const djangoModelRegex = /class\s+(\w+)\((?:models\.)?Model\)/g;
+  while ((match = djangoModelRegex.exec(content)) !== null) {
+    const modelName = match[1];
+    const modelId = `model:${modelName}`;
+    entities.push({
+      id: modelId,
+      name: modelName,
+      type: "model",
+      filePath: relPath,
+      language: "python",
+      metadata: { orm: "django" }
+    });
+    relationships.push({ sourceId: modelId, targetId: fileId, relation: "belongs-to" });
+  }
+  const sqlalchemyRegex = /class\s+(\w+)\(.*(?:Base|DeclarativeBase|db\.Model)\)/g;
+  while ((match = sqlalchemyRegex.exec(content)) !== null) {
+    const modelName = match[1];
+    const modelId = `model:${modelName}`;
+    entities.push({
+      id: modelId,
+      name: modelName,
+      type: "model",
+      filePath: relPath,
+      language: "python",
+      metadata: { orm: "sqlalchemy" }
+    });
+    relationships.push({ sourceId: modelId, targetId: fileId, relation: "belongs-to" });
+  }
+  const importRegex = /^(?:from\s+([\w.]+)\s+import|import\s+([\w.]+))/gm;
+  while ((match = importRegex.exec(content)) !== null) {
+    const mod = match[1] || match[2];
+    if (mod.startsWith(".")) {
+      relationships.push({ sourceId: fileId, targetId: `file:${mod}`, relation: "imports" });
+    } else {
+      const depName = mod.split(".")[0];
+      entities.push({ id: `dep:${depName}`, name: depName, type: "dependency", filePath: "", language: "external", metadata: { external: true } });
+      relationships.push({ sourceId: fileId, targetId: `dep:${depName}`, relation: "depends-on" });
+    }
+  }
+  return { entities, relationships };
+}
+function extractFromGo(fullPath, relPath) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language: "go", metadata: {} });
+  const structRegex = /type\s+(\w+)\s+struct\s*\{/g;
+  let match;
+  while ((match = structRegex.exec(content)) !== null) {
+    const structName = match[1];
+    const structId = `class:${relPath}:${structName}`;
+    entities.push({
+      id: structId,
+      name: structName,
+      type: structName.endsWith("Model") || structName.endsWith("Entity") ? "model" : "class",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "go",
+      metadata: {}
+    });
+    relationships.push({ sourceId: structId, targetId: fileId, relation: "belongs-to" });
+  }
+  const funcRegex = /func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\(/g;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    if (funcName[0] !== funcName[0].toUpperCase()) continue;
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({
+      id: funcId,
+      name: funcName,
+      type: "function",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "go",
+      metadata: {}
+    });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  const ginRouteRegex = /\.(GET|POST|PUT|PATCH|DELETE)\s*\(\s*"([^"]+)"/gi;
+  while ((match = ginRouteRegex.exec(content)) !== null) {
+    const method = match[1].toUpperCase();
+    const routePath = match[2];
+    const apiId = `api:${method}:${routePath}`;
+    entities.push({
+      id: apiId,
+      name: `${method} ${routePath}`,
+      type: "api",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language: "go",
+      metadata: { method, path: routePath }
+    });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  return { entities, relationships };
+}
+function extractFromJavaKotlin(fullPath, relPath, language) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language, metadata: {} });
+  const classRegex = /(?:public\s+)?(?:abstract\s+)?(?:class|interface|enum)\s+(\w+)(?:\s+extends\s+(\w+))?/g;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const classId = `class:${relPath}:${className}`;
+    entities.push({
+      id: classId,
+      name: className,
+      type: content.includes("@Entity") || content.includes("@Table") ? "model" : "class",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: {}
+    });
+    relationships.push({ sourceId: classId, targetId: fileId, relation: "belongs-to" });
+  }
+  const springRegex = /@(?:Get|Post|Put|Patch|Delete|Request)Mapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/g;
+  while ((match = springRegex.exec(content)) !== null) {
+    const routePath = match[1];
+    const apiId = `api:ANY:${routePath}`;
+    entities.push({
+      id: apiId,
+      name: routePath,
+      type: "api",
+      filePath: relPath,
+      line: getLineNumber(content, match.index),
+      language,
+      metadata: { path: routePath }
+    });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  return { entities, relationships };
+}
+function extractFromRust(fullPath, relPath) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language: "rust", metadata: {} });
+  const structRegex = /pub\s+struct\s+(\w+)/g;
+  let match;
+  while ((match = structRegex.exec(content)) !== null) {
+    const structName = match[1];
+    const structId = `class:${relPath}:${structName}`;
+    entities.push({ id: structId, name: structName, type: "class", filePath: relPath, line: getLineNumber(content, match.index), language: "rust", metadata: {} });
+    relationships.push({ sourceId: structId, targetId: fileId, relation: "belongs-to" });
+  }
+  const funcRegex = /pub\s+(?:async\s+)?fn\s+(\w+)/g;
+  while ((match = funcRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({ id: funcId, name: funcName, type: "function", filePath: relPath, line: getLineNumber(content, match.index), language: "rust", metadata: {} });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  return { entities, relationships };
+}
+function extractFromRuby(fullPath, relPath) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language: "ruby", metadata: {} });
+  const classRegex = /class\s+(\w+)(?:\s*<\s*(\w+))?/g;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const base = match[2];
+    const classId = `class:${relPath}:${className}`;
+    const type = base === "ApplicationRecord" || base === "ActiveRecord::Base" ? "model" : "class";
+    entities.push({ id: classId, name: className, type, filePath: relPath, line: getLineNumber(content, match.index), language: "ruby", metadata: { extends: base } });
+    relationships.push({ sourceId: classId, targetId: fileId, relation: "belongs-to" });
+  }
+  const defRegex = /def\s+(?:self\.)?(\w+)/g;
+  while ((match = defRegex.exec(content)) !== null) {
+    const funcName = match[1];
+    if (funcName.startsWith("_")) continue;
+    const funcId = `func:${relPath}:${funcName}`;
+    entities.push({ id: funcId, name: funcName, type: "function", filePath: relPath, line: getLineNumber(content, match.index), language: "ruby", metadata: {} });
+    relationships.push({ sourceId: funcId, targetId: fileId, relation: "belongs-to" });
+  }
+  return { entities, relationships };
+}
+function extractFromPHP(fullPath, relPath) {
+  const content = fs13.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path15.basename(relPath), type: "file", filePath: relPath, language: "php", metadata: {} });
+  const classRegex = /(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/g;
+  let match;
+  while ((match = classRegex.exec(content)) !== null) {
+    const className = match[1];
+    const base = match[2];
+    const classId = `class:${relPath}:${className}`;
+    const type = base === "Model" || base === "Eloquent" ? "model" : "class";
+    entities.push({ id: classId, name: className, type, filePath: relPath, line: getLineNumber(content, match.index), language: "php", metadata: {} });
+    relationships.push({ sourceId: classId, targetId: fileId, relation: "belongs-to" });
+  }
+  const laravelRouteRegex = /Route::(get|post|put|patch|delete)\s*\(\s*['"]([^'"]+)['"]/gi;
+  while ((match = laravelRouteRegex.exec(content)) !== null) {
+    const method = match[1].toUpperCase();
+    const routePath = match[2];
+    const apiId = `api:${method}:${routePath}`;
+    entities.push({ id: apiId, name: `${method} ${routePath}`, type: "api", filePath: relPath, line: getLineNumber(content, match.index), language: "php", metadata: { method, path: routePath } });
+    relationships.push({ sourceId: apiId, targetId: fileId, relation: "belongs-to" });
+  }
+  return { entities, relationships };
+}
+function extractFromConfigs(rootDir, _detection) {
+  const entities = [];
+  const relationships = [];
+  const pkgPath = path15.join(rootDir, "package.json");
+  if (fs13.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs13.readFileSync(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies };
+      for (const [name, version] of Object.entries(allDeps)) {
+        const depId = `dep:${name}`;
+        entities.push({
+          id: depId,
+          name,
+          type: "dependency",
+          filePath: "package.json",
+          language: "external",
+          metadata: { version, source: "npm", external: true }
+        });
+      }
+    } catch {
+    }
+  }
+  const openAPIFiles = ["openapi.json", "openapi.yaml", "openapi.yml", "swagger.json", "swagger.yaml"];
+  for (const apiFile of openAPIFiles) {
+    const apiPath = path15.join(rootDir, apiFile);
+    if (fs13.existsSync(apiPath)) {
+      try {
+        const content = fs13.readFileSync(apiPath, "utf-8");
+        const pathRegex = /"(\/[^"]+)":\s*\{/g;
+        let match;
+        while ((match = pathRegex.exec(content)) !== null) {
+          const routePath = match[1];
+          const apiId = `api:ANY:${routePath}`;
+          entities.push({
+            id: apiId,
+            name: routePath,
+            type: "api",
+            filePath: apiFile,
+            language: "openapi",
+            metadata: { source: "openapi" }
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  const composeFiles = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const composeFile of composeFiles) {
+    const composePath = path15.join(rootDir, composeFile);
+    if (fs13.existsSync(composePath)) {
+      try {
+        const content = fs13.readFileSync(composePath, "utf-8");
+        const serviceRegex = /^\s{2}(\w[\w-]*):\s*$/gm;
+        let match;
+        while ((match = serviceRegex.exec(content)) !== null) {
+          const serviceName = match[1];
+          if (serviceName === "services" || serviceName === "volumes" || serviceName === "networks") continue;
+          entities.push({
+            id: `service:${serviceName}`,
+            name: serviceName,
+            type: detectServiceType(serviceName),
+            filePath: composeFile,
+            language: "docker",
+            metadata: { source: "docker-compose" }
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return { entities, relationships };
+}
+function inferRelationships(entities, _rootDir) {
+  const relationships = [];
+  const models = entities.filter((e) => e.type === "model");
+  const apis = entities.filter((e) => e.type === "api");
+  for (const api of apis) {
+    const apiPath = api.metadata.path || api.name;
+    for (const model of models) {
+      const modelName = model.name.toLowerCase().replace(/_/g, "");
+      const pathLower = apiPath.toLowerCase().replace(/[/-]/g, "");
+      if (pathLower.includes(modelName) || modelName.includes(pathLower.split("/").pop() || "")) {
+        const method = api.metadata.method || "ANY";
+        const relation = ["POST", "PUT", "PATCH", "DELETE"].includes(method) ? "writes" : "reads";
+        relationships.push({ sourceId: api.id, targetId: model.id, relation });
+      }
+    }
+  }
+  const fileEntities = entities.filter((e) => e.type === "file");
+  for (const file of fileEntities) {
+    const dir = path15.dirname(file.filePath).split("/")[0];
+    if (dir && dir !== ".") {
+      const moduleId = `module:${dir}`;
+      if (!entities.some((e) => e.id === moduleId)) {
+        entities.push({
+          id: moduleId,
+          name: dir,
+          type: "module",
+          filePath: dir,
+          language: "directory",
+          metadata: {}
+        });
+      }
+      relationships.push({ sourceId: file.id, targetId: moduleId, relation: "belongs-to" });
+    }
+  }
+  return relationships;
+}
+function getLineNumber(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+function resolveRelativeImport(currentFile, importPath) {
+  const dir = path15.dirname(currentFile);
+  let resolved = path15.posix.join(dir, importPath);
+  if (!path15.extname(resolved)) {
+    resolved += ".ts";
+  }
+  return resolved;
+}
+function categorizeFile(filePath, language) {
+  const lower = filePath.toLowerCase();
+  if (lower.includes(".test.") || lower.includes(".spec.") || lower.includes("__tests__") || lower.includes("/test/") || lower.includes("/tests/")) return "test";
+  if (["json", "yaml", "toml"].includes(language) || lower.includes("config") || lower.includes(".env")) return "config";
+  if (language === "markdown" || lower.includes("/docs/") || lower.includes("/doc/")) return "docs";
+  if (language === "docker" || lower.includes("makefile") || lower.includes("webpack") || lower.includes("rollup") || lower.includes("vite")) return "build";
+  if (["html", "css", "scss", "less"].includes(language)) return "asset";
+  return "source";
+}
+function detectClassType(name, content) {
+  if (content.includes(".init(") || content.includes("@Entity") || content.includes("tableName")) return "model";
+  if (name.includes("Controller") || name.includes("Handler")) return "service";
+  if (name.includes("Service") || name.includes("Provider")) return "service";
+  if (name.includes("Middleware")) return "middleware";
+  if (name.includes("Component") || name.includes("Widget")) return "component";
+  return "class";
+}
+function detectPythonClassType(name, bases, _content) {
+  if (bases.includes("Model") || bases.includes("Base") || bases.includes("db.Model")) return "model";
+  if (name.includes("View") || name.includes("ViewSet") || bases.includes("APIView")) return "service";
+  if (name.includes("Serializer")) return "class";
+  return "class";
+}
+function detectServiceType(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes("redis") || lower.includes("memcache")) return "cache";
+  if (lower.includes("rabbit") || lower.includes("kafka") || lower.includes("nats")) return "queue";
+  if (lower.includes("postgres") || lower.includes("mysql") || lower.includes("mongo") || lower.includes("db")) return "database";
+  return "external-api";
+}
+
+// src/scanner/github-cloner.ts
+init_esm_shims();
+import * as fs14 from "fs";
+import * as os from "os";
+import * as path16 from "path";
+import { execSync } from "child_process";
+async function cloneAndScan(options) {
+  const { target, cloneDir, branch, depth = 1, keepClone, onProgress, ...scanOpts } = options;
+  const resolved = resolveTarget(target);
+  let projectDir;
+  if (resolved.type === "local") {
+    projectDir = resolved.path;
+    onProgress?.("clone", 100, `Using local directory: ${projectDir}`);
+  } else {
+    const tempBase = cloneDir || path16.join(os.tmpdir(), "opencroc-scan");
+    fs14.mkdirSync(tempBase, { recursive: true });
+    projectDir = path16.join(tempBase, resolved.repoName);
+    if (fs14.existsSync(projectDir)) {
+      fs14.rmSync(projectDir, { recursive: true, force: true });
+    }
+    onProgress?.("clone", 10, `Cloning ${resolved.url}...`);
+    const branchArg = branch ? `--branch ${branch}` : "";
+    const depthArg = depth > 0 ? `--depth ${depth}` : "";
+    const cmd = `git clone ${branchArg} ${depthArg} --single-branch ${resolved.url} "${projectDir}"`;
+    try {
+      execSync(cmd, {
+        stdio: "pipe",
+        timeout: 12e4
+        // 2 minutes max
+      });
+    } catch (err) {
+      throw new Error(`Failed to clone repository: ${err.message}`);
+    }
+    onProgress?.("clone", 100, `Cloned to ${projectDir}`);
+  }
+  const scanResult = await scanProject({
+    rootDir: projectDir,
+    ...scanOpts,
+    onProgress
+  });
+  if (resolved.type === "git" && !keepClone) {
+    try {
+      fs14.rmSync(projectDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return {
+    ...scanResult,
+    clonedPath: resolved.type === "git" ? projectDir : void 0
+  };
+}
+function resolveTarget(target) {
+  const resolved = path16.resolve(target);
+  if (fs14.existsSync(resolved)) {
+    return {
+      type: "local",
+      path: resolved,
+      repoName: path16.basename(resolved)
+    };
+  }
+  if (target.startsWith("https://") || target.startsWith("http://") || target.startsWith("git@")) {
+    let url = target;
+    if (!url.endsWith(".git")) url += ".git";
+    const repoName = path16.basename(url, ".git");
+    return { type: "git", path: "", url, repoName };
+  }
+  if (/^[\w.-]+\/[\w.-]+$/.test(target)) {
+    const url = `https://github.com/${target}.git`;
+    const repoName = target.split("/")[1];
+    return { type: "git", path: "", url, repoName };
+  }
+  throw new Error(
+    `Cannot resolve target "${target}". Expected: local path, GitHub URL, or shorthand (user/repo).`
+  );
+}
+
+// src/graph/index.ts
+init_esm_shims();
+function buildKnowledgeGraph(scanResult, options) {
+  const startTime = Date.now();
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const entity of scanResult.entities) {
+    if (!entityMap.has(entity.id)) {
+      entityMap.set(entity.id, entity);
+    }
+  }
+  const nodes = [];
+  for (const entity of entityMap.values()) {
+    nodes.push({
+      id: entity.id,
+      label: entity.name,
+      type: entity.type,
+      filePath: entity.filePath || void 0,
+      line: entity.line,
+      module: inferModule(entity),
+      language: entity.language,
+      metadata: entity.metadata,
+      status: "idle"
+    });
+  }
+  const edges = [];
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const rel of scanResult.relationships) {
+    let targetId = rel.targetId;
+    if (targetId.includes(":*:")) {
+      const suffix = targetId.split(":*:")[1];
+      const resolved = findMatchingEntity(entityMap, targetId.split(":")[0], suffix);
+      if (resolved) {
+        targetId = resolved;
+      } else {
+        continue;
+      }
+    }
+    if (rel.sourceId === targetId) continue;
+    if (!entityMap.has(rel.sourceId) && !entityMap.has(targetId)) continue;
+    const edgeKey = `${rel.sourceId}->${targetId}:${rel.relation}`;
+    if (edgeSet.has(edgeKey)) continue;
+    edgeSet.add(edgeKey);
+    edges.push({
+      id: `edge-${edges.length}`,
+      source: rel.sourceId,
+      target: targetId,
+      relation: rel.relation,
+      metadata: rel.metadata
+    });
+  }
+  const projectInfo = buildProjectMetadata(scanResult, options, nodes);
+  return {
+    nodes,
+    edges,
+    projectInfo,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    buildDuration: Date.now() - startTime
+  };
+}
+function queryNodes(graph, filter) {
+  return graph.nodes.filter((n) => {
+    if (filter.type && n.type !== filter.type) return false;
+    if (filter.language && n.language !== filter.language) return false;
+    if (filter.module && n.module !== filter.module) return false;
+    return true;
+  });
+}
+function getNeighbors(graph, nodeId) {
+  return {
+    incoming: graph.edges.filter((e) => e.target === nodeId),
+    outgoing: graph.edges.filter((e) => e.source === nodeId)
+  };
+}
+function bfsTraversal2(graph, startNodeId, maxDepth = 3) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [{ id: startNodeId, depth: 0 }];
+  visited.add(startNodeId);
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
+    adjacency.get(edge.source).push(edge.target);
+    if (!adjacency.has(edge.target)) adjacency.set(edge.target, []);
+    adjacency.get(edge.target).push(edge.source);
+  }
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current.depth >= maxDepth) continue;
+    const neighbors = adjacency.get(current.id) || [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        visited.add(neighbor);
+        queue.push({ id: neighbor, depth: current.depth + 1 });
+      }
+    }
+  }
+  visited.delete(startNodeId);
+  return [...visited];
+}
+function findPaths(graph, fromId, toId, maxPaths = 5, maxDepth = 6) {
+  const paths = [];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
+    adjacency.get(edge.source).push(edge.target);
+  }
+  function dfs(current, target, path17, visited2) {
+    if (paths.length >= maxPaths) return;
+    if (path17.length > maxDepth) return;
+    if (current === target) {
+      paths.push([...path17]);
+      return;
+    }
+    const neighbors = adjacency.get(current) || [];
+    for (const neighbor of neighbors) {
+      if (!visited2.has(neighbor)) {
+        visited2.add(neighbor);
+        path17.push(neighbor);
+        dfs(neighbor, target, path17, visited2);
+        path17.pop();
+        visited2.delete(neighbor);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set([fromId]);
+  dfs(fromId, toId, [fromId], visited);
+  return paths;
+}
+function toMermaid(graph, options) {
+  const maxNodes = options?.maxNodes || 50;
+  const nodeTypes = options?.nodeTypes;
+  let filteredNodes = graph.nodes;
+  if (nodeTypes) {
+    filteredNodes = filteredNodes.filter((n) => nodeTypes.includes(n.type));
+  }
+  filteredNodes = filteredNodes.slice(0, maxNodes);
+  const nodeIds = new Set(filteredNodes.map((n) => n.id));
+  const filteredEdges = graph.edges.filter((e) => nodeIds.has(e.source) && nodeIds.has(e.target));
+  const lines = ["graph TD"];
+  lines.push("  classDef model fill:#4ecca3,color:#000,stroke:#2d9970");
+  lines.push("  classDef api fill:#e94560,color:#fff,stroke:#c23049");
+  lines.push("  classDef service fill:#3498db,color:#fff,stroke:#2378b8");
+  lines.push("  classDef module fill:#f39c12,color:#000,stroke:#c27d0e");
+  lines.push("  classDef component fill:#9b59b6,color:#fff,stroke:#7d3c98");
+  lines.push("  classDef file fill:#555,color:#fff,stroke:#333");
+  for (const node of filteredNodes) {
+    const safeId = sanitizeMermaidId(node.id);
+    const safeLabel = node.label.replace(/"/g, "'");
+    lines.push(`  ${safeId}["${safeLabel}"]:::${node.type}`);
+  }
+  for (const edge of filteredEdges) {
+    const safeSource = sanitizeMermaidId(edge.source);
+    const safeTarget = sanitizeMermaidId(edge.target);
+    const label = edge.relation;
+    lines.push(`  ${safeSource} -->|${label}| ${safeTarget}`);
+  }
+  return lines.join("\n");
+}
+function getGraphStats(graph) {
+  const stats = {
+    totalNodes: graph.nodes.length,
+    totalEdges: graph.edges.length
+  };
+  for (const node of graph.nodes) {
+    const key = `${node.type}Count`;
+    stats[key] = (stats[key] || 0) + 1;
+  }
+  for (const edge of graph.edges) {
+    const key = `${edge.relation}Count`;
+    stats[key] = (stats[key] || 0) + 1;
+  }
+  return stats;
+}
+function inferModule(entity) {
+  if (!entity.filePath) return void 0;
+  const parts = entity.filePath.split("/");
+  if (parts.length > 1) {
+    const dir = parts[0];
+    if (dir === "src" && parts.length > 2) return parts[1];
+    return dir;
+  }
+  return void 0;
+}
+function findMatchingEntity(entityMap, typePrefix, nameSuffix) {
+  for (const [id, entity] of entityMap) {
+    if (id.startsWith(`${typePrefix}:`) && entity.name === nameSuffix) {
+      return id;
+    }
+  }
+  return null;
+}
+function buildProjectMetadata(scanResult, options, nodes) {
+  const stats = {
+    totalFiles: scanResult.files.length,
+    totalLines: scanResult.files.reduce((sum, f) => sum + f.lines, 0),
+    modules: nodes.filter((n) => n.type === "module").length,
+    classes: nodes.filter((n) => n.type === "class").length,
+    functions: nodes.filter((n) => n.type === "function").length,
+    apiEndpoints: nodes.filter((n) => n.type === "api").length,
+    dataModels: nodes.filter((n) => n.type === "model").length,
+    dependencies: nodes.filter((n) => n.type === "dependency").length,
+    linesByLanguage: scanResult.languages
+  };
+  return {
+    name: options.projectName,
+    source: options.source,
+    sourceUrl: options.sourceUrl,
+    rootPath: options.rootPath,
+    languages: scanResult.languages,
+    frameworks: scanResult.frameworks.map((f) => f.name),
+    packageManager: void 0,
+    projectType: "unknown",
+    stats
+  };
+}
+function sanitizeMermaidId(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+// src/insight/index.ts
+init_esm_shims();
+async function analyzeRisks(graph, options) {
+  const risks = [];
+  let riskCounter = 0;
+  options?.onProgress?.("risk-analysis", 0, "Starting risk analysis...");
+  const apis = graph.nodes.filter((n) => n.type === "api");
+  const middlewares = graph.nodes.filter((n) => n.type === "middleware");
+  const hasAuthMiddleware = middlewares.some(
+    (m) => m.label.toLowerCase().includes("auth") || m.label.toLowerCase().includes("jwt") || m.label.toLowerCase().includes("session")
+  );
+  for (const api of apis) {
+    const incoming = graph.edges.filter((e) => e.target === api.id);
+    const hasAuth = incoming.some((e) => {
+      const sourceNode = graph.nodes.find((n) => n.id === e.source);
+      return sourceNode?.type === "middleware" && (sourceNode.label.toLowerCase().includes("auth") || e.relation === "middleware-of");
+    });
+    if (!hasAuth && !hasAuthMiddleware) {
+      const apiPath = api.metadata.path || api.label;
+      const isSensitive = /user|admin|password|token|secret|key|delete|payment/i.test(apiPath);
+      if (isSensitive) {
+        risks.push({
+          id: `risk-${++riskCounter}`,
+          category: "security",
+          severity: "high",
+          title: `Potentially unprotected sensitive endpoint: ${api.label}`,
+          description: `The endpoint ${api.label} appears to handle sensitive data but no authentication middleware was detected in the graph.`,
+          affectedNodes: [api.id],
+          suggestion: "Add authentication middleware to protect this endpoint.",
+          confidence: 0.6
+        });
+      }
+    }
+  }
+  options?.onProgress?.("risk-analysis", 20, "Checking data integrity...");
+  const models = graph.nodes.filter((n) => n.type === "model");
+  for (const model of models) {
+    const writeEdges = graph.edges.filter((e) => e.target === model.id && e.relation === "writes");
+    if (writeEdges.length > 3) {
+      risks.push({
+        id: `risk-${++riskCounter}`,
+        category: "data-integrity",
+        severity: "medium",
+        title: `High write fan-in on model: ${model.label}`,
+        description: `Model "${model.label}" is written to by ${writeEdges.length} different endpoints. This increases risk of data conflicts and race conditions.`,
+        affectedNodes: [model.id, ...writeEdges.map((e) => e.source)],
+        suggestion: "Consider adding transaction boundaries or an optimistic locking strategy.",
+        confidence: 0.7
+      });
+    }
+  }
+  const foreignKeyEdges = graph.edges.filter((e) => e.relation === "foreign-key" || e.relation === "cascade-delete");
+  for (const fk of foreignKeyEdges) {
+    const sourceNode = graph.nodes.find((n) => n.id === fk.source);
+    const targetNode = graph.nodes.find((n) => n.id === fk.target);
+    if (sourceNode && targetNode) {
+      const dependents = graph.edges.filter(
+        (e) => (e.relation === "foreign-key" || e.relation === "cascade-delete") && e.target === fk.target
+      );
+      if (dependents.length >= 3) {
+        risks.push({
+          id: `risk-${++riskCounter}`,
+          category: "data-integrity",
+          severity: "high",
+          title: `Cascade risk: ${targetNode.label} has ${dependents.length} dependent tables`,
+          description: `Deleting records from "${targetNode.label}" could cascade to ${dependents.length} other tables.`,
+          affectedNodes: [fk.target, ...dependents.map((d) => d.source)],
+          suggestion: "Implement soft deletes or add cascade protection.",
+          confidence: 0.85
+        });
+      }
+    }
+  }
+  options?.onProgress?.("risk-analysis", 40, "Checking performance...");
+  const moduleNodes = graph.nodes.filter((n) => n.type === "module");
+  for (const mod of moduleNodes) {
+    const children = graph.edges.filter((e) => e.target === mod.id && e.relation === "belongs-to");
+    if (children.length > 50) {
+      risks.push({
+        id: `risk-${++riskCounter}`,
+        category: "maintainability",
+        severity: "medium",
+        title: `Large module: ${mod.label} (${children.length} entities)`,
+        description: `Module "${mod.label}" contains ${children.length} entities. Consider splitting for better maintainability.`,
+        affectedNodes: [mod.id],
+        suggestion: "Split into smaller, focused sub-modules.",
+        confidence: 0.75
+      });
+    }
+  }
+  const cycles = detectCycles2(graph);
+  for (const cycle of cycles) {
+    risks.push({
+      id: `risk-${++riskCounter}`,
+      category: "logic",
+      severity: "high",
+      title: `Circular dependency detected: ${cycle.map((id) => graph.nodes.find((n) => n.id === id)?.label || id).join(" \u2192 ")}`,
+      description: `A circular dependency was found involving ${cycle.length} entities. This can cause initialization issues and makes testing harder.`,
+      affectedNodes: cycle,
+      suggestion: "Break the cycle by introducing an interface or Event-based decoupling.",
+      confidence: 0.9
+    });
+  }
+  options?.onProgress?.("risk-analysis", 60, "Checking maintainability...");
+  for (const node of graph.nodes) {
+    if (node.type === "file" || node.type === "dependency") continue;
+    const outgoing = graph.edges.filter((e) => e.source === node.id);
+    const incoming = graph.edges.filter((e) => e.target === node.id);
+    const coupling = outgoing.length + incoming.length;
+    if (coupling > 15) {
+      risks.push({
+        id: `risk-${++riskCounter}`,
+        category: "maintainability",
+        severity: "medium",
+        title: `High coupling: ${node.label} (${coupling} connections)`,
+        description: `"${node.label}" has ${coupling} connections (${outgoing.length} outgoing, ${incoming.length} incoming). Changes here will have wide impact.`,
+        affectedNodes: [node.id],
+        suggestion: "Consider extracting shared logic or adding an abstraction layer.",
+        confidence: 0.7
+      });
+    }
+  }
+  for (const api of apis) {
+    const apiPath = api.metadata.path || api.label;
+    if (apiPath.includes(":") || apiPath.includes("{")) {
+      const method = api.metadata.method || "";
+      if (["DELETE", "PUT", "PATCH"].includes(method)) {
+        risks.push({
+          id: `risk-${++riskCounter}`,
+          category: "security",
+          severity: "low",
+          title: `Verify input validation: ${api.label}`,
+          description: `Endpoint ${api.label} accepts path parameters. Ensure proper input validation and authorization checks.`,
+          affectedNodes: [api.id],
+          suggestion: "Add input validation middleware and verify the user has permission to modify the specified resource.",
+          confidence: 0.5
+        });
+      }
+    }
+  }
+  options?.onProgress?.("risk-analysis", 80, `Found ${risks.length} risks`);
+  if (options?.useLlm && options.llm) {
+    try {
+      const llmRisks = await getLlmRisks(graph, risks, options.llm);
+      risks.push(...llmRisks);
+    } catch {
+    }
+  }
+  const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+  risks.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  options?.onProgress?.("risk-analysis", 100, `Analysis complete: ${risks.length} risks found`);
+  return risks;
+}
+function analyzeImpact(graph, nodeId) {
+  const node = graph.nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    return {
+      sourceNode: nodeId,
+      directImpact: [],
+      transitiveImpact: [],
+      riskLevel: "low",
+      summary: `Node "${nodeId}" not found in the graph.`,
+      mermaidText: ""
+    };
+  }
+  const { incoming, outgoing } = getNeighbors(graph, nodeId);
+  const directNodes = /* @__PURE__ */ new Set([
+    ...incoming.map((e) => e.source),
+    ...outgoing.map((e) => e.target)
+  ]);
+  directNodes.delete(nodeId);
+  const transitiveNodes = bfsTraversal2(graph, nodeId, 3);
+  const totalImpact = transitiveNodes.length;
+  let riskLevel;
+  if (totalImpact > 20) riskLevel = "critical";
+  else if (totalImpact > 10) riskLevel = "high";
+  else if (totalImpact > 5) riskLevel = "medium";
+  else riskLevel = "low";
+  const summary = `Changing "${node.label}" directly affects ${directNodes.size} entities and transitively impacts ${transitiveNodes.length} entities (risk: ${riskLevel}).`;
+  const impactNodeIds = /* @__PURE__ */ new Set([nodeId, ...directNodes, ...transitiveNodes.slice(0, 20)]);
+  const impactNodes = graph.nodes.filter((n) => impactNodeIds.has(n.id));
+  const impactEdges = graph.edges.filter((e) => impactNodeIds.has(e.source) && impactNodeIds.has(e.target));
+  let mermaidText = "graph TD\n";
+  mermaidText += `  style ${sanitizeId2(nodeId)} fill:#e94560,color:#fff
+`;
+  for (const dn of directNodes) {
+    mermaidText += `  style ${sanitizeId2(dn)} fill:#f39c12,color:#000
+`;
+  }
+  for (const n of impactNodes) {
+    mermaidText += `  ${sanitizeId2(n.id)}["${n.label.replace(/"/g, "'")}"]
+`;
+  }
+  for (const e of impactEdges) {
+    mermaidText += `  ${sanitizeId2(e.source)} -->|${e.relation}| ${sanitizeId2(e.target)}
+`;
+  }
+  return {
+    sourceNode: nodeId,
+    directImpact: [...directNodes],
+    transitiveImpact: transitiveNodes,
+    riskLevel,
+    summary,
+    mermaidText
+  };
+}
+async function generateReport(graph, perspective, risks, options) {
+  if (options?.useLlm && options.llm) {
+    return generateLlmReport(graph, perspective, risks, options.llm);
+  }
+  switch (perspective) {
+    case "developer":
+      return buildDeveloperReport(graph, risks);
+    case "architect":
+      return buildArchitectReport(graph, risks);
+    case "tester":
+      return buildTesterReport(graph, risks);
+    case "product":
+      return buildProductReport(graph, risks);
+    case "student":
+      return buildStudentReport(graph, risks);
+    case "executive":
+      return buildExecutiveReport(graph, risks);
+    default:
+      return buildDeveloperReport(graph, risks);
+  }
+}
+function buildDeveloperReport(graph, risks) {
+  const { projectInfo } = graph;
+  const stats = projectInfo.stats;
+  const sections = [
+    {
+      heading: "Project Overview",
+      content: `**${projectInfo.name}** is a ${projectInfo.projectType} project using ${projectInfo.frameworks.join(", ") || "unknown frameworks"}.
+
+- **Files**: ${stats.totalFiles} | **Lines**: ${stats.totalLines.toLocaleString()}
+- **Languages**: ${Object.entries(projectInfo.languages).map(([k, v]) => `${k}(${v})`).join(", ")}
+- **APIs**: ${stats.apiEndpoints} | **Models**: ${stats.dataModels} | **Functions**: ${stats.functions}`
+    },
+    {
+      heading: "Architecture Map",
+      content: "Module-level dependency graph:",
+      visualization: {
+        type: "mermaid",
+        data: toMermaid(graph, { nodeTypes: ["module", "model", "api"], maxNodes: 30 })
+      }
+    },
+    {
+      heading: "API Endpoints",
+      content: graph.nodes.filter((n) => n.type === "api").map((a) => `- \`${a.label}\` (${a.filePath || "unknown"})`).join("\n") || "No API endpoints detected."
+    },
+    {
+      heading: "Data Models",
+      content: graph.nodes.filter((n) => n.type === "model").map((m) => `- **${m.label}** (${m.filePath || "unknown"})`).join("\n") || "No data models detected."
+    },
+    {
+      heading: "Risk Report",
+      content: risks.length === 0 ? "No significant risks detected." : risks.slice(0, 10).map(
+        (r) => `- **[${r.severity.toUpperCase()}]** ${r.title}
+  ${r.description}`
+      ).join("\n\n")
+    }
+  ];
+  return {
+    perspective: "developer",
+    title: `Developer Report: ${projectInfo.name}`,
+    summary: `${projectInfo.name} \u2014 ${stats.apiEndpoints} APIs, ${stats.dataModels} models, ${risks.length} risks detected.`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildArchitectReport(graph, risks) {
+  const { projectInfo } = graph;
+  const modules = graph.nodes.filter((n) => n.type === "module");
+  const criticalRisks = risks.filter((r) => r.severity === "critical" || r.severity === "high");
+  const sections = [
+    {
+      heading: "System Architecture",
+      content: `**Type**: ${projectInfo.projectType}
+**Frameworks**: ${projectInfo.frameworks.join(", ")}
+**Modules**: ${modules.length}
+
+The system is organized into ${modules.length} modules with ${graph.edges.length} relationships.`,
+      visualization: {
+        type: "mermaid",
+        data: toMermaid(graph, { nodeTypes: ["module"], maxNodes: 20 })
+      }
+    },
+    {
+      heading: "Module Coupling Analysis",
+      content: modules.map((m) => {
+        const edges = graph.edges.filter((e) => e.source === m.id || e.target === m.id);
+        return `- **${m.label}**: ${edges.length} connections`;
+      }).join("\n")
+    },
+    {
+      heading: "Technical Debt & Risk",
+      content: criticalRisks.length === 0 ? "No critical or high-severity risks." : criticalRisks.map((r) => `- **[${r.severity}]** ${r.title}
+  _Suggestion_: ${r.suggestion || "N/A"}`).join("\n\n")
+    },
+    {
+      heading: "Recommendations",
+      content: generateArchitectRecommendations(graph, risks)
+    }
+  ];
+  return {
+    perspective: "architect",
+    title: `Architecture Report: ${projectInfo.name}`,
+    summary: `${modules.length} modules, ${graph.edges.length} relationships, ${criticalRisks.length} critical/high risks.`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildTesterReport(graph, risks) {
+  const apis = graph.nodes.filter((n) => n.type === "api");
+  const tests = graph.nodes.filter((n) => n.type === "test");
+  const riskyApis = risks.filter((r) => r.category === "security" || r.category === "data-integrity");
+  const sections = [
+    {
+      heading: "Test Coverage Overview",
+      content: `- **API Endpoints**: ${apis.length}
+- **Test Files Found**: ${tests.length}
+- **Estimated Coverage**: ${tests.length > 0 ? Math.min(Math.round(tests.length / Math.max(apis.length, 1) * 100), 100) : 0}%`
+    },
+    {
+      heading: "Priority Test Targets",
+      content: "Endpoints with highest risk that need testing first:\n\n" + riskyApis.slice(0, 10).map((r, i) => `${i + 1}. **${r.title}** (${r.severity})
+   ${r.description}`).join("\n\n")
+    },
+    {
+      heading: "Edge Cases to Consider",
+      content: apis.slice(0, 10).map((api) => {
+        const method = api.metadata.method || "ANY";
+        const suggestions = [];
+        if (method === "POST" || method === "PUT") suggestions.push("Empty body", "Invalid types", "Missing required fields", "Extremely long strings");
+        if (method === "DELETE") suggestions.push("Non-existent ID", "Already deleted", "ID with dependencies");
+        if (method === "GET") suggestions.push("Invalid query params", "Large pagination", "Non-existent ID");
+        return `- **${api.label}**: ${suggestions.join(", ")}`;
+      }).join("\n")
+    }
+  ];
+  return {
+    perspective: "tester",
+    title: `Testing Report: ${graph.projectInfo.name}`,
+    summary: `${apis.length} endpoints to test, ${riskyApis.length} high-risk areas identified.`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildProductReport(graph, risks) {
+  const { projectInfo } = graph;
+  const modules = graph.nodes.filter((n) => n.type === "module");
+  const sections = [
+    {
+      heading: "What Does This System Do?",
+      content: `This is a **${projectInfo.projectType}** system built with ${projectInfo.frameworks.join(", ")}. It contains ${modules.length} functional modules and ${projectInfo.stats.apiEndpoints} service interfaces.`
+    },
+    {
+      heading: "Feature Map",
+      content: modules.map((m) => {
+        const children = graph.edges.filter((e) => e.target === m.id).length;
+        return `- **${m.label}** \u2014 ${children} components`;
+      }).join("\n")
+    },
+    {
+      heading: "Health Status",
+      content: (() => {
+        const critical = risks.filter((r) => r.severity === "critical").length;
+        const high = risks.filter((r) => r.severity === "high").length;
+        if (critical > 0) return `\u26A0\uFE0F **Needs Attention**: ${critical} critical issues found that could affect users.`;
+        if (high > 3) return `\u26A1 **Minor Concerns**: ${high} areas that should be improved.`;
+        return "\u2705 **Healthy**: No critical issues detected. System is in good shape.";
+      })()
+    }
+  ];
+  return {
+    perspective: "product",
+    title: `Product Overview: ${projectInfo.name}`,
+    summary: `${modules.length} feature modules, ${risks.filter((r) => r.severity === "critical").length} critical issues.`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildStudentReport(graph, risks) {
+  const { projectInfo } = graph;
+  const sections = [
+    {
+      heading: "What is this project?",
+      content: `This is a **${projectInfo.projectType}** project. Let's break it down step by step!
+
+**Languages used**: ${Object.keys(projectInfo.languages).join(", ")}
+**Frameworks**: ${projectInfo.frameworks.join(", ") || "None detected"}
+
+Think of this project like a building:
+- The **frameworks** are the building's foundation
+- The **modules** are different rooms
+- The **APIs** are the doors and windows (interfaces to the outside world)
+- The **models** are the furniture and storage (data structures)`
+    },
+    {
+      heading: "How is it organized?",
+      content: `The project has **${projectInfo.stats.modules}** modules (think: folders of related code).
+
+Each module typically contains:
+1. **Controllers/Routes** \u2014 Handle incoming requests (like a receptionist)
+2. **Services** \u2014 Business logic (like the workers)
+3. **Models** \u2014 Data structures (like forms and documents)
+
+Here's a simplified view:`,
+      visualization: {
+        type: "mermaid",
+        data: toMermaid(graph, { nodeTypes: ["module", "model"], maxNodes: 15 })
+      }
+    },
+    {
+      heading: "Key Concepts to Learn",
+      content: `Based on this project, you should study:
+
+` + (projectInfo.frameworks.includes("Express") ? "- **Express.js** \u2014 Node.js web framework for building APIs\n" : "") + (projectInfo.frameworks.includes("React") ? "- **React** \u2014 Frontend UI library for building user interfaces\n" : "") + (projectInfo.frameworks.includes("Sequelize") ? "- **Sequelize** \u2014 ORM for database operations\n" : "") + `- **REST APIs** \u2014 How the frontend talks to the backend
+- **MVC Pattern** \u2014 Model-View-Controller architecture
+- **Authentication** \u2014 How users log in and stay logged in`
+    },
+    {
+      heading: "Things to Watch Out For",
+      content: risks.length > 0 ? `Here are ${Math.min(risks.length, 5)} interesting issues found:
+
+` + risks.slice(0, 5).map((r, i) => `${i + 1}. **${r.title}**
+   _Why it matters_: ${r.description}
+   _How to fix_: ${r.suggestion || "Research this topic!"}`).join("\n\n") : "This project looks clean! No major issues found."
+    }
+  ];
+  return {
+    perspective: "student",
+    title: `Learning Guide: ${projectInfo.name}`,
+    summary: `A ${projectInfo.projectType} project \u2014 great for learning ${Object.keys(projectInfo.languages).join(", ")}!`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildExecutiveReport(graph, risks) {
+  const { projectInfo } = graph;
+  const critical = risks.filter((r) => r.severity === "critical").length;
+  const high = risks.filter((r) => r.severity === "high").length;
+  const medium = risks.filter((r) => r.severity === "medium").length;
+  const healthScore = Math.max(0, 100 - (critical * 20 + high * 10 + medium * 3));
+  const sections = [
+    {
+      heading: "Health Score",
+      content: `# ${healthScore}/100
+
+` + (healthScore >= 80 ? "\u2705 System is healthy and well-maintained." : healthScore >= 60 ? "\u26A1 System needs some attention. Address high-priority items." : "\u26A0\uFE0F System has significant issues that need immediate attention.")
+    },
+    {
+      heading: "Key Metrics",
+      content: `| Metric | Value |
+|--------|-------|
+| Codebase Size | ${projectInfo.stats.totalLines.toLocaleString()} lines |
+| Technologies | ${projectInfo.frameworks.length} frameworks |
+| API Surface | ${projectInfo.stats.apiEndpoints} endpoints |
+| Data Models | ${projectInfo.stats.dataModels} tables |
+| Critical Issues | ${critical} |
+| High Issues | ${high} |`
+    },
+    {
+      heading: "Top 3 Risks Needing Action",
+      content: risks.slice(0, 3).map(
+        (r, i) => `${i + 1}. **${r.title}** (${r.severity})`
+      ).join("\n") || "No significant risks."
+    }
+  ];
+  return {
+    perspective: "executive",
+    title: `Executive Summary: ${projectInfo.name}`,
+    summary: `Health: ${healthScore}/100 | ${critical} critical, ${high} high risks | ${projectInfo.stats.apiEndpoints} APIs`,
+    sections,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function simulateScenario(graph, scenario, llm) {
+  const relatedNodes = scenario.steps.map((s) => s.endpoint).filter(Boolean).flatMap((endpoint) => graph.nodes.filter((n) => n.type === "api" && n.label.includes(endpoint))).map((n) => n.id);
+  const context = relatedNodes.flatMap((nodeId) => {
+    const neighbors = getNeighbors(graph, nodeId);
+    return [
+      ...neighbors.outgoing.map((e) => {
+        const target = graph.nodes.find((n) => n.id === e.target);
+        return `${e.relation}: ${target?.label || e.target}`;
+      })
+    ];
+  });
+  const prompt = `You are an expert software engineer analyzing a system.
+
+Project: ${graph.projectInfo.name}
+Frameworks: ${graph.projectInfo.frameworks.join(", ")}
+
+Scenario: ${scenario.name}
+Description: ${scenario.description}
+
+Steps:
+${scenario.steps.map((s, i) => `${i + 1}. ${s.action} \u2014 ${s.endpoint || "N/A"}`).join("\n")}
+
+Related context from knowledge graph:
+${context.join("\n")}
+
+Predict:
+1. What would happen when executing this scenario?
+2. What anomalies or edge cases could occur?
+3. Rate the risk (0-100) of this scenario failing in production.
+
+Respond in JSON: { "prediction": "...", "anomalies": ["..."], "riskScore": N, "confidence": 0.X }`;
+  const response = await llm.chat([{ role: "user", content: prompt }]);
+  try {
+    const parsed = JSON.parse(cleanJsonResponse(response));
+    return {
+      scenario,
+      prediction: parsed.prediction || "Unable to predict.",
+      anomalies: parsed.anomalies || [],
+      riskScore: parsed.riskScore || 50,
+      confidence: parsed.confidence || 0.5
+    };
+  } catch {
+    return {
+      scenario,
+      prediction: response,
+      anomalies: [],
+      riskScore: 50,
+      confidence: 0.3
+    };
+  }
+}
+function detectCycles2(graph) {
+  const cycles = [];
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.relation !== "imports" && edge.relation !== "depends-on" && edge.relation !== "calls") continue;
+    if (!adjacency.has(edge.source)) adjacency.set(edge.source, []);
+    adjacency.get(edge.source).push(edge.target);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const path17 = [];
+  function dfs(node) {
+    if (cycles.length >= 5) return;
+    visited.add(node);
+    inStack.add(node);
+    path17.push(node);
+    for (const neighbor of adjacency.get(node) || []) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (inStack.has(neighbor)) {
+        const cycleStart = path17.indexOf(neighbor);
+        if (cycleStart >= 0) {
+          cycles.push([...path17.slice(cycleStart), neighbor]);
+        }
+      }
+    }
+    path17.pop();
+    inStack.delete(node);
+  }
+  for (const node of adjacency.keys()) {
+    if (!visited.has(node)) {
+      dfs(node);
+    }
+  }
+  return cycles;
+}
+function generateArchitectRecommendations(_graph, risks) {
+  const items = [];
+  const securityRisks = risks.filter((r) => r.category === "security");
+  if (securityRisks.length > 0) {
+    items.push(`1. **Security Hardening**: Address ${securityRisks.length} security findings before next release.`);
+  }
+  const couplingRisks = risks.filter((r) => r.category === "maintainability");
+  if (couplingRisks.length > 2) {
+    items.push(`2. **Reduce Coupling**: ${couplingRisks.length} modules show high coupling. Consider introducing service boundaries.`);
+  }
+  const dataRisks = risks.filter((r) => r.category === "data-integrity");
+  if (dataRisks.length > 0) {
+    items.push(`3. **Data Protection**: ${dataRisks.length} data integrity concerns. Add transaction boundaries and cascade protections.`);
+  }
+  if (items.length === 0) {
+    items.push("Architecture looks solid. Continue monitoring coupling metrics as the system grows.");
+  }
+  return items.join("\n\n");
+}
+async function getLlmRisks(graph, existingRisks, llm) {
+  const prompt = `Analyze this project knowledge graph for additional risks not already identified.
+
+Project: ${graph.projectInfo.name}
+Type: ${graph.projectInfo.projectType}
+Frameworks: ${graph.projectInfo.frameworks.join(", ")}
+Stats: ${graph.projectInfo.stats.apiEndpoints} APIs, ${graph.projectInfo.stats.dataModels} models
+
+Already identified risks (${existingRisks.length}):
+${existingRisks.slice(0, 5).map((r) => `- [${r.severity}] ${r.title}`).join("\n")}
+
+API Endpoints: ${graph.nodes.filter((n) => n.type === "api").slice(0, 20).map((n) => n.label).join(", ")}
+Models: ${graph.nodes.filter((n) => n.type === "model").slice(0, 20).map((n) => n.label).join(", ")}
+
+Return up to 3 additional risks in JSON array format:
+[{ "category": "security|performance|data-integrity|logic|maintainability|reliability", "severity": "critical|high|medium|low", "title": "...", "description": "...", "suggestion": "..." }]`;
+  const response = await llm.chat([{ role: "user", content: prompt }]);
+  try {
+    const parsed = JSON.parse(cleanJsonResponse(response));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.slice(0, 3).map((r, i) => ({
+      id: `risk-llm-${i}`,
+      category: r.category || "logic",
+      severity: r.severity || "medium",
+      title: r.title || "LLM-detected risk",
+      description: r.description || "",
+      affectedNodes: [],
+      suggestion: r.suggestion,
+      confidence: 0.6
+    }));
+  } catch {
+    return [];
+  }
+}
+async function generateLlmReport(graph, perspective, risks, llm) {
+  const perspectiveDescriptions = {
+    developer: "a software developer who wants technical details, code patterns, and API documentation",
+    architect: "a software architect who cares about modularity, coupling, tech debt, and system design",
+    tester: "a QA engineer who wants to know what to test, edge cases, and risk areas",
+    product: "a product manager who wants to understand features in business terms, not code",
+    student: "a computer science student learning from this codebase, explain concepts step by step",
+    executive: "a CTO/VP who wants a one-page health summary with actionable insights"
+  };
+  const prompt = `Generate a project analysis report for ${graph.projectInfo.name} from the perspective of ${perspectiveDescriptions[perspective]}.
+
+Project Info:
+- Type: ${graph.projectInfo.projectType}
+- Frameworks: ${graph.projectInfo.frameworks.join(", ")}
+- Stats: ${graph.projectInfo.stats.totalFiles} files, ${graph.projectInfo.stats.apiEndpoints} APIs, ${graph.projectInfo.stats.dataModels} models
+- Languages: ${Object.entries(graph.projectInfo.languages).map(([k, v]) => `${k}(${v} files)`).join(", ")}
+
+Top risks:
+${risks.slice(0, 5).map((r) => `- [${r.severity}] ${r.title}`).join("\n")}
+
+Generate 3-5 report sections with clear headings and content. Use markdown formatting.
+Respond in JSON: { "title": "...", "summary": "...", "sections": [{ "heading": "...", "content": "..." }] }`;
+  const response = await llm.chat([{ role: "user", content: prompt }]);
+  try {
+    const parsed = JSON.parse(cleanJsonResponse(response));
+    return {
+      perspective,
+      title: parsed.title || `${perspective} Report`,
+      summary: parsed.summary || "",
+      sections: (parsed.sections || []).map((s) => ({
+        heading: s.heading || "Section",
+        content: s.content || ""
+      })),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return buildDeveloperReport(graph, risks);
+  }
+}
+function cleanJsonResponse(response) {
+  let cleaned = response.trim();
+  if (cleaned.startsWith("```json")) cleaned = cleaned.slice(7);
+  else if (cleaned.startsWith("```")) cleaned = cleaned.slice(3);
+  if (cleaned.endsWith("```")) cleaned = cleaned.slice(0, -3);
+  return cleaned.trim();
+}
+function sanitizeId2(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
 export {
   NetworkMonitor,
   SYSTEM_PROMPTS,
@@ -7149,14 +9215,18 @@ export {
   COMMANDS as VSCODE_COMMANDS,
   aggregateLogCompletion,
   analyzeFailureWithLLM,
+  analyzeImpact,
+  analyzeRisks,
   applyControlledFix,
   autoFix,
+  bfsTraversal2 as bfsTraversal,
   buildBackendChecklist,
   buildClassToTableMap,
   buildDashboardDataFromPipeline,
   buildDashboardDataFromReportJson,
   buildFailureSummary,
   buildGraph,
+  buildKnowledgeGraph,
   buildModuleTree,
   buildPath,
   buildStatusTree,
@@ -7165,6 +9235,7 @@ export {
   categorizeFailure,
   classNameToTableName,
   classifyFailure,
+  cloneAndScan,
   compareTestRuns,
   createAdapter,
   createApiChainAnalyzer,
@@ -7195,9 +9266,11 @@ export {
   definePlugin,
   detectAdapter,
   detectCycles,
+  detectProject,
   extractIdFromText,
   extractParamNames,
   extractParamsFromHref,
+  findPaths,
   formatComparisonReport,
   formatValidationResult,
   generateAllModuleConfigs,
@@ -7212,6 +9285,7 @@ export {
   generateGlobalSetup,
   generateGlobalTeardown,
   generateHtmlReport,
+  generateReport as generateInsightReport,
   generateJsonReport,
   generateMarkdownReport,
   generateModuleConfig,
@@ -7219,7 +9293,9 @@ export {
   generateReports,
   generateVisualDashboard,
   generateVisualDashboardHtml,
+  getGraphStats,
   getModulePreset,
+  getNeighbors,
   inferDependencies,
   inferRelatedTables,
   listCiPlatforms,
@@ -7238,6 +9314,7 @@ export {
   parsePlaywrightReport,
   parseValidatorRules,
   printOrchestrationSummary,
+  queryNodes,
   recoverJSON,
   renderChecklistMarkdown,
   renderTokenReportMarkdown,
@@ -7247,8 +9324,11 @@ export {
   resolveFromSeedData,
   runDialogLoop,
   scanModuleMetadata,
+  scanProject,
   selectCandidates,
   selectCandidatesFromLogs,
+  simulateScenario,
+  toMermaid,
   topologicalSort,
   validateConfig,
   validateDryrun,