opencroc 1.6.9 → 1.8.0

package/dist/cli/index.js

@@ -853,20 +853,20 @@ function detectCycles(dag) {
   const color = /* @__PURE__ */ new Map();
   for (const node of dag.nodes) color.set(node, 0 /* WHITE */);
   const warnings = [];
-  const path9 = [];
+  const path14 = [];
   function dfs(node) {
     color.set(node, 1 /* GRAY */);
-    path9.push(node);
+    path14.push(node);
     for (const neighbor of adjacency.get(node) || []) {
       const nc = color.get(neighbor);
       if (nc === 1 /* GRAY */) {
-        const cycleStart = path9.indexOf(neighbor);
-        warnings.push(`Cycle detected: ${path9.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
+        const cycleStart = path14.indexOf(neighbor);
+        warnings.push(`Cycle detected: ${path14.slice(cycleStart).concat(neighbor).join(" \u2192 ")}`);
       } else if (nc === 0 /* WHITE */) {
         dfs(neighbor);
       }
     }
-    path9.pop();
+    path14.pop();
     color.set(node, 2 /* BLACK */);
   }
   for (const node of dag.nodes) {
@@ -1863,50 +1863,50 @@ var init_dialog_loop_runner = __esm({
 import { existsSync as existsSync8, copyFileSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync } from "fs";
 import { dirname as dirname2 } from "path";
 async function applyControlledFix(opts) {
-  const fs8 = opts.fs ?? defaultFs;
+  const fs13 = 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 (!fs8.exists(configPath)) {
+  if (!fs13.exists(configPath)) {
     return { success: false, scope, fixedItems: [], rolledBack: false, error: `Config file not found: ${configPath}` };
   }
-  const originalContent = fs8.read(configPath);
-  fs8.write(backupPath, originalContent);
+  const originalContent = fs13.read(configPath);
+  fs13.write(backupPath, originalContent);
   const validation = opts.validator.validate(originalContent);
   if (validation.passed) {
-    cleanup(fs8, backupPath);
+    cleanup(fs13, backupPath);
     return { success: true, scope, fixedItems: [], rolledBack: false };
   }
   let fixResult;
   try {
     fixResult = opts.fixer.fix(originalContent, validation.errors);
   } catch (err) {
-    rollback(fs8, backupPath, configPath);
+    rollback(fs13, backupPath, configPath);
     return { success: false, scope, fixedItems: [], rolledBack: true, error: `Fix threw: ${err instanceof Error ? err.message : String(err)}` };
   }
   if (!fixResult.success) {
-    rollback(fs8, backupPath, configPath);
+    rollback(fs13, 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(fs8, backupPath, configPath);
+      rollback(fs13, backupPath, configPath);
       return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Dry-run validation failed: ${dryValidation.errors.join("; ")}` };
     }
   }
-  fs8.write(configPath, fixResult.fixedContent);
+  fs13.write(configPath, fixResult.fixedContent);
   if (verify) {
-    const reloaded = fs8.read(configPath);
+    const reloaded = fs13.read(configPath);
     const postValidation = opts.validator.validate(reloaded);
     if (!postValidation.passed) {
-      rollback(fs8, backupPath, configPath);
+      rollback(fs13, backupPath, configPath);
       return { success: false, scope, fixedItems: fixResult.fixedItems, rolledBack: true, error: `Post-write verification failed: ${postValidation.errors.join("; ")}` };
     }
   }
-  cleanup(fs8, backupPath);
+  cleanup(fs13, backupPath);
   let prUrl;
   if (scope === "config-and-source" && opts.attribution && opts.prGenerator) {
     try {
@@ -1916,16 +1916,16 @@ async function applyControlledFix(opts) {
   }
   return { success: true, scope, fixedItems: fixResult.fixedItems, rolledBack: false, prUrl };
 }
-function rollback(fs8, backupPath, configPath) {
-  if (fs8.exists(backupPath)) {
-    const backup = fs8.read(backupPath);
-    fs8.write(configPath, backup);
-    fs8.remove(backupPath);
+function rollback(fs13, backupPath, configPath) {
+  if (fs13.exists(backupPath)) {
+    const backup = fs13.read(backupPath);
+    fs13.write(configPath, backup);
+    fs13.remove(backupPath);
   }
 }
-function cleanup(fs8, backupPath) {
-  if (fs8.exists(backupPath)) {
-    fs8.remove(backupPath);
+function cleanup(fs13, backupPath) {
+  if (fs13.exists(backupPath)) {
+    fs13.remove(backupPath);
   }
 }
 var defaultFs;
@@ -4317,6 +4317,2218 @@ var init_agents = __esm({
   }
 });
 
+// src/scanner/language-detector.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+function detectProject(rootDir) {
+  const absRoot = path9.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 = fs8.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (totalFiles > MAX_FILES) break;
+      const fullPath = path9.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 = path9.extname(entry.name).toLowerCase();
+      const lang = detectLanguageByFile(entry.name, ext);
+      if (!lang) continue;
+      let lineCount = 0;
+      let fileSize = 0;
+      try {
+        const stat = fs8.statSync(fullPath);
+        fileSize = stat.size;
+        if (fileSize < 1048576) {
+          const content = fs8.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 = path9.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;
+}
+function detectFromPackageJson(root, dep, name) {
+  const candidates = [
+    path9.join(root, "package.json"),
+    path9.join(root, "backend", "package.json"),
+    path9.join(root, "server", "package.json"),
+    path9.join(root, "api", "package.json"),
+    path9.join(root, "frontend", "package.json"),
+    path9.join(root, "web", "package.json"),
+    path9.join(root, "client", "package.json")
+  ];
+  for (const pkgPath of candidates) {
+    try {
+      if (!fs8.existsSync(pkgPath)) continue;
+      const pkg = JSON.parse(fs8.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 ${path9.relative(root, pkgPath)}`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function detectFromRequirements(root, dep, name) {
+  const candidates = [
+    path9.join(root, "requirements.txt"),
+    path9.join(root, "Pipfile"),
+    path9.join(root, "pyproject.toml"),
+    path9.join(root, "setup.py"),
+    path9.join(root, "setup.cfg")
+  ];
+  for (const filePath of candidates) {
+    try {
+      if (!fs8.existsSync(filePath)) continue;
+      const content = fs8.readFileSync(filePath, "utf-8");
+      const pattern = new RegExp(`^${dep}([>=<~!\\s]|$)`, "im");
+      if (pattern.test(content)) {
+        return {
+          name,
+          confidence: 0.9,
+          evidence: `Found "${dep}" in ${path9.basename(filePath)}`
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function detectFromGoMod(root, module, name) {
+  const goModPath = path9.join(root, "go.mod");
+  try {
+    if (!fs8.existsSync(goModPath)) return null;
+    const content = fs8.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 = path9.join(root, "Cargo.toml");
+  try {
+    if (!fs8.existsSync(cargoPath)) return null;
+    const content = fs8.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 = path9.join(root, fileName);
+  try {
+    if (!fs8.existsSync(filePath)) return null;
+    if (searchTerm) {
+      const content = fs8.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 = fs8.existsSync(path9.join(root, "lerna.json"));
+  const hasPnpmWorkspace = fs8.existsSync(path9.join(root, "pnpm-workspace.yaml"));
+  const hasNxJson = fs8.existsSync(path9.join(root, "nx.json"));
+  const hasTurboJson = fs8.existsSync(path9.join(root, "turbo.json"));
+  let hasWorkspaces = false;
+  try {
+    const pkg = JSON.parse(fs8.readFileSync(path9.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(fs8.readFileSync(path9.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 (fs8.existsSync(path9.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs8.existsSync(path9.join(root, "yarn.lock"))) return "yarn";
+  if (fs8.existsSync(path9.join(root, "bun.lockb"))) return "bun";
+  if (fs8.existsSync(path9.join(root, "package-lock.json"))) return "npm";
+  if (fs8.existsSync(path9.join(root, "Pipfile.lock"))) return "pipenv";
+  if (fs8.existsSync(path9.join(root, "poetry.lock"))) return "poetry";
+  if (fs8.existsSync(path9.join(root, "go.sum"))) return "go-modules";
+  if (fs8.existsSync(path9.join(root, "Cargo.lock"))) return "cargo";
+  if (fs8.existsSync(path9.join(root, "Gemfile.lock"))) return "bundler";
+  if (fs8.existsSync(path9.join(root, "composer.lock"))) return "composer";
+  return void 0;
+}
+var EXTENSION_MAP, SKIP_DIRS, MAX_DEPTH, MAX_FILES, FRAMEWORK_RULES;
+var init_language_detector = __esm({
+  "src/scanner/language-detector.ts"() {
+    "use strict";
+    init_esm_shims();
+    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"
+    };
+    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"
+    ]);
+    MAX_DEPTH = 8;
+    MAX_FILES = 1e4;
+    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")
+      }
+    ];
+  }
+});
+
+// src/scanner/project-scanner.ts
+import * as fs9 from "fs";
+import * as path10 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 = path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({
+    id: fileId,
+    name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = fs9.readFileSync(fullPath, "utf-8");
+  const entities = [];
+  const relationships = [];
+  const fileId = `file:${relPath}`;
+  entities.push({ id: fileId, name: path10.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 = path10.join(rootDir, "package.json");
+  if (fs9.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs9.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 = path10.join(rootDir, apiFile);
+    if (fs9.existsSync(apiPath)) {
+      try {
+        const content = fs9.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 = path10.join(rootDir, composeFile);
+    if (fs9.existsSync(composePath)) {
+      try {
+        const content = fs9.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 = path10.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 = path10.dirname(currentFile);
+  let resolved = path10.posix.join(dir, importPath);
+  if (!path10.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";
+}
+var init_project_scanner = __esm({
+  "src/scanner/project-scanner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_language_detector();
+  }
+});
+
+// src/scanner/github-cloner.ts
+import * as fs10 from "fs";
+import * as os from "os";
+import * as path11 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 || path11.join(os.tmpdir(), "opencroc-scan");
+    fs10.mkdirSync(tempBase, { recursive: true });
+    projectDir = path11.join(tempBase, resolved.repoName);
+    if (fs10.existsSync(projectDir)) {
+      fs10.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 {
+      fs10.rmSync(projectDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  return {
+    ...scanResult,
+    clonedPath: resolved.type === "git" ? projectDir : void 0
+  };
+}
+function resolveTarget(target) {
+  const resolved = path11.resolve(target);
+  if (fs10.existsSync(resolved)) {
+    return {
+      type: "local",
+      path: resolved,
+      repoName: path11.basename(resolved)
+    };
+  }
+  if (target.startsWith("https://") || target.startsWith("http://") || target.startsWith("git@")) {
+    let url = target;
+    if (!url.endsWith(".git")) url += ".git";
+    const repoName = path11.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).`
+  );
+}
+var init_github_cloner = __esm({
+  "src/scanner/github-cloner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_scanner();
+  }
+});
+
+// src/graph/index.ts
+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 getNeighbors(graph, nodeId) {
+  return {
+    incoming: graph.edges.filter((e) => e.target === nodeId),
+    outgoing: graph.edges.filter((e) => e.source === nodeId)
+  };
+}
+function bfsTraversal(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 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, "_");
+}
+var init_graph = __esm({
+  "src/graph/index.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/insight/index.ts
+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 = bfsTraversal(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 ${sanitizeId(nodeId)} fill:#e94560,color:#fff
+`;
+  for (const dn of directNodes) {
+    mermaidText += `  style ${sanitizeId(dn)} fill:#f39c12,color:#000
+`;
+  }
+  for (const n of impactNodes) {
+    mermaidText += `  ${sanitizeId(n.id)}["${n.label.replace(/"/g, "'")}"]
+`;
+  }
+  for (const e of impactEdges) {
+    mermaidText += `  ${sanitizeId(e.source)} -->|${e.relation}| ${sanitizeId(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()
+  };
+}
+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 path14 = [];
+  function dfs(node) {
+    if (cycles.length >= 5) return;
+    visited.add(node);
+    inStack.add(node);
+    path14.push(node);
+    for (const neighbor of adjacency.get(node) || []) {
+      if (!visited.has(neighbor)) {
+        dfs(neighbor);
+      } else if (inStack.has(neighbor)) {
+        const cycleStart = path14.indexOf(neighbor);
+        if (cycleStart >= 0) {
+          cycles.push([...path14.slice(cycleStart), neighbor]);
+        }
+      }
+    }
+    path14.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 prompt2 = `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: prompt2 }]);
+  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 prompt2 = `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: prompt2 }]);
+  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 sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+var init_insight = __esm({
+  "src/insight/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_graph();
+  }
+});
+
+// src/server/routes/studio.ts
+function registerStudioRoutes(app, office) {
+  app.post("/api/studio/scan", async (req, reply) => {
+    const { target, branch, useLlm } = req.body || {};
+    if (!target || typeof target !== "string") {
+      reply.code(400).send({ error: 'Missing "target" field. Provide a local path or GitHub URL.' });
+      return;
+    }
+    office.log(`\u{1F50D} Starting scan: ${target}`, "info");
+    office.updateAgent("parser-croc", { status: "working", currentTask: `Scanning ${target}...`, progress: 0 });
+    try {
+      const scanResult = await cloneAndScan({
+        target,
+        branch,
+        useLlm,
+        keepClone: true,
+        onProgress: (phase, percent, detail) => {
+          office.updateAgent("parser-croc", { currentTask: detail || phase, progress: percent });
+          office.broadcast("scan:progress", { phase, percent, detail });
+        }
+      });
+      office.updateAgent("parser-croc", { status: "done", currentTask: "Scan complete", progress: 100 });
+      office.log(`\u2705 Scan complete: ${scanResult.entities.length} entities, ${scanResult.relationships.length} relationships`);
+      office.updateAgent("analyzer-croc", { status: "working", currentTask: "Building knowledge graph...", progress: 0 });
+      const projectName = target.includes("/") ? target.split("/").pop().replace(".git", "") : target.split(/[\\/]/).pop();
+      const graph = buildKnowledgeGraph(scanResult, {
+        projectName,
+        source: target.startsWith("http") || /^[\w.-]+\/[\w.-]+$/.test(target) ? "github" : "local",
+        sourceUrl: target,
+        rootPath: target
+      });
+      office.updateAgent("analyzer-croc", { status: "done", currentTask: "Graph built", progress: 100 });
+      office.log(`\u{1F4CA} Knowledge graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+      office.updateAgent("planner-croc", { status: "working", currentTask: "Analyzing risks...", progress: 0 });
+      const risks = await analyzeRisks(graph);
+      office.updateAgent("planner-croc", { status: "done", currentTask: `${risks.length} risks found`, progress: 100 });
+      store.graph = graph;
+      store.risks = risks;
+      store.scanTime = Date.now();
+      store.source = target;
+      office.broadcast("graph:update", {
+        nodes: graph.nodes.map((n) => ({
+          id: n.id,
+          label: n.label,
+          type: n.type,
+          module: n.module,
+          status: n.status
+        })),
+        edges: graph.edges.map((e) => ({
+          source: e.source,
+          target: e.target,
+          relation: e.relation
+        }))
+      });
+      return {
+        ok: true,
+        project: graph.projectInfo,
+        stats: getGraphStats(graph),
+        risks: risks.length,
+        duration: graph.buildDuration + scanResult.duration
+      };
+    } catch (err) {
+      office.updateAgent("parser-croc", { status: "error", currentTask: String(err) });
+      office.log(`\u274C Scan failed: ${err}`, "error");
+      reply.code(500).send({ error: `Scan failed: ${err.message}` });
+      return;
+    }
+  });
+  app.get("/api/studio/graph", async (_req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet. POST /api/studio/scan first." });
+      return;
+    }
+    return {
+      nodes: store.graph.nodes,
+      edges: store.graph.edges,
+      projectInfo: store.graph.projectInfo,
+      builtAt: store.graph.builtAt,
+      stats: getGraphStats(store.graph)
+    };
+  });
+  app.get("/api/studio/graph/mermaid", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    const nodeTypes = req.query.types?.split(",");
+    const maxNodes = req.query.maxNodes ? parseInt(req.query.maxNodes, 10) : 50;
+    return {
+      mermaid: toMermaid(store.graph, { nodeTypes, maxNodes })
+    };
+  });
+  app.get("/api/studio/risks", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    let risks = store.risks;
+    if (req.query.severity) {
+      risks = risks.filter((r) => r.severity === req.query.severity);
+    }
+    if (req.query.category) {
+      risks = risks.filter((r) => r.category === req.query.category);
+    }
+    return { total: risks.length, risks };
+  });
+  app.get("/api/studio/impact/:nodeId", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    const nodeId = decodeURIComponent(req.params.nodeId);
+    const impact = analyzeImpact(store.graph, nodeId);
+    return impact;
+  });
+  app.get("/api/studio/report/:perspective", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    const validPerspectives = ["developer", "architect", "tester", "product", "student", "executive"];
+    const perspective = req.params.perspective;
+    if (!validPerspectives.includes(perspective)) {
+      reply.code(400).send({ error: `Invalid perspective. Valid: ${validPerspectives.join(", ")}` });
+      return;
+    }
+    office.updateAgent("reporter-croc", { status: "working", currentTask: `Generating ${perspective} report...` });
+    const report2 = await generateReport(
+      store.graph,
+      perspective,
+      store.risks
+    );
+    office.updateAgent("reporter-croc", { status: "done", currentTask: "Report ready" });
+    return report2;
+  });
+  app.get("/api/studio/nodes", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    let nodes = store.graph.nodes;
+    if (req.query.type) nodes = nodes.filter((n) => n.type === req.query.type);
+    if (req.query.language) nodes = nodes.filter((n) => n.language === req.query.language);
+    if (req.query.module) nodes = nodes.filter((n) => n.module === req.query.module);
+    if (req.query.search) {
+      const q = req.query.search.toLowerCase();
+      nodes = nodes.filter((n) => n.label.toLowerCase().includes(q) || n.id.toLowerCase().includes(q));
+    }
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : 100;
+    return { total: nodes.length, nodes: nodes.slice(0, limit) };
+  });
+  app.get("/api/studio/node/:nodeId", async (req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    const nodeId = decodeURIComponent(req.params.nodeId);
+    const node = store.graph.nodes.find((n) => n.id === nodeId);
+    if (!node) {
+      reply.code(404).send({ error: "Node not found." });
+      return;
+    }
+    const incoming = store.graph.edges.filter((e) => e.target === nodeId);
+    const outgoing = store.graph.edges.filter((e) => e.source === nodeId);
+    const neighborIds = /* @__PURE__ */ new Set([...incoming.map((e) => e.source), ...outgoing.map((e) => e.target)]);
+    const neighbors = store.graph.nodes.filter((n) => neighborIds.has(n.id));
+    return { node, incoming, outgoing, neighbors };
+  });
+  app.get("/api/studio/summary", async (_req, reply) => {
+    if (!store.graph) {
+      reply.code(404).send({ error: "No project scanned yet." });
+      return;
+    }
+    const { projectInfo } = store.graph;
+    const stats = getGraphStats(store.graph);
+    const critical = store.risks.filter((r) => r.severity === "critical").length;
+    const high = store.risks.filter((r) => r.severity === "high").length;
+    const healthScore = Math.max(0, 100 - (critical * 20 + high * 10));
+    return {
+      name: projectInfo.name,
+      oneLiner: `A ${projectInfo.projectType} project using ${projectInfo.frameworks.join(", ") || "unknown"}, with ${stats.apiCount || 0} APIs and ${stats.modelCount || 0} data models.`,
+      healthScore,
+      stats,
+      topRisks: store.risks.slice(0, 5).map((r) => ({ severity: r.severity, title: r.title })),
+      source: store.source
+    };
+  });
+}
+var store;
+var init_studio = __esm({
+  "src/server/routes/studio.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_github_cloner();
+    init_graph();
+    init_insight();
+    store = {
+      graph: null,
+      risks: [],
+      scanTime: 0,
+      source: ""
+    };
+  }
+});
+
 // src/execution/coordinator.ts
 var coordinator_exports = {};
 __export(coordinator_exports, {
@@ -4339,7 +6551,7 @@ function getFailureLines(output) {
   return output.split(/\r?\n/).filter((line) => /fail|error|timeout/i.test(line)).slice(0, 5);
 }
 function createExecutionCoordinator(deps = {}) {
-  const execSync = deps.execSync ?? nodeExecSync;
+  const execSync2 = deps.execSync ?? nodeExecSync;
   const categorizeFailure2 = deps.categorizeFailure;
   return {
     async run(request) {
@@ -4348,7 +6560,7 @@ function createExecutionCoordinator(deps = {}) {
       const command = `npx playwright test ${request.testFiles.map((file) => `"${file}"`).join(" ")} --reporter=line 2>&1`;
       let output;
       try {
-        output = String(execSync(command, {
+        output = String(execSync2(command, {
           cwd: request.cwd,
           encoding: "utf-8",
           timeout: timeoutMs,
@@ -4419,7 +6631,7 @@ var backend_manager_exports = {};
 __export(backend_manager_exports, {
   createBackendManager: () => createBackendManager
 });
-import { resolve as resolve8 } from "path";
+import { resolve as resolve10 } from "path";
 import { spawn as nodeSpawn } from "child_process";
 function normalizeHealthUrl(server, baseURL) {
   if (server?.healthUrl) return server.healthUrl;
@@ -4481,7 +6693,7 @@ function createBackendManager(deps = {}) {
         throw new Error("BOOT_CONFIG_MISSING: runtime.server.command is required for managed mode");
       }
       const child = spawn(server.command, server.args ?? [], {
-        cwd: resolve8(request.cwd, server.cwd ?? "."),
+        cwd: resolve10(request.cwd, server.cwd ?? "."),
         shell: true,
         stdio: "pipe",
         env: process.env
@@ -4516,13 +6728,13 @@ var runtime_bootstrap_exports = {};
 __export(runtime_bootstrap_exports, {
   createRuntimeBootstrap: () => createRuntimeBootstrap
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname5, join as join13 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
 function ensureFile(filePath, content, force) {
-  if (existsSync15(filePath) && !force) {
+  if (existsSync18(filePath) && !force) {
     return false;
   }
-  mkdirSync10(dirname5(filePath), { recursive: true });
+  mkdirSync11(dirname6(filePath), { recursive: true });
   writeFileSync10(filePath, content, "utf-8");
   return true;
 }
@@ -4553,7 +6765,7 @@ function createRuntimeBootstrap(config) {
       const writtenFiles = [];
       const skippedFiles = [];
       for (const file of files) {
-        const filePath = join13(request.cwd, file.name);
+        const filePath = join16(request.cwd, file.name);
         const written = ensureFile(filePath, file.content, force);
         if (written) writtenFiles.push(file.name);
         else skippedFiles.push(file.name);
@@ -4822,13 +7034,13 @@ var init_croc_office = __esm({
           const fullResult = await pipeline.run(["scan", "er-diagram", "api-chain", "plan", "codegen"]);
           this.lastPipelineResult = fullResult;
           this.lastGeneratedFiles = fullResult.generatedFiles;
-          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
-          const { dirname: dirname7 } = await import("path");
+          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
+          const { dirname: dirname8 } = await import("path");
           let filesWritten = 0;
           for (const file of fullResult.generatedFiles) {
             const fullPath = resolvePath(this.cwd, file.filePath);
-            mkdirSync11(dirname7(fullPath), { recursive: true });
-            writeFileSync11(fullPath, file.content, "utf-8");
+            mkdirSync14(dirname8(fullPath), { recursive: true });
+            writeFileSync13(fullPath, file.content, "utf-8");
             filesWritten++;
           }
           this.updateNodeStatus("controller", "passed");
@@ -4912,14 +7124,14 @@ var init_croc_office = __esm({
         let backendStatus;
         try {
           const { resolve: resolvePath } = await import("path");
-          const { existsSync: existsSync17 } = await import("fs");
+          const { existsSync: existsSync21 } = await import("fs");
           const { createExecutionCoordinator: createExecutionCoordinator2 } = await Promise.resolve().then(() => (init_coordinator(), coordinator_exports));
           const { createBackendManager: createBackendManager2 } = await Promise.resolve().then(() => (init_backend_manager(), backend_manager_exports));
           const { createRuntimeBootstrap: createRuntimeBootstrap2 } = await Promise.resolve().then(() => (init_runtime_bootstrap(), runtime_bootstrap_exports));
           const { createAuthProvisioner: createAuthProvisioner2 } = await Promise.resolve().then(() => (init_auth_provisioner(), auth_provisioner_exports));
           const { buildExecutionQualityGate: buildExecutionQualityGate2 } = await Promise.resolve().then(() => (init_quality_gate(), quality_gate_exports));
           const { categorizeFailure: categorizeFailure2 } = await Promise.resolve().then(() => (init_self_healing(), self_healing_exports));
-          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync17(f));
+          const testFiles = this.lastGeneratedFiles.map((f) => resolvePath(this.cwd, f.filePath)).filter((f) => existsSync21(f));
           if (testFiles.length === 0) {
             this.log("\u26A0\uFE0F No test files found on disk", "warn");
             return { ok: false, task: "execute", duration: Date.now() - start, error: "No test files found on disk" };
@@ -5046,12 +7258,12 @@ var init_croc_office = __esm({
           });
           this.lastReports = reports;
           const { resolve: resolvePath } = await import("path");
-          const { writeFileSync: writeFileSync11, mkdirSync: mkdirSync11 } = await import("fs");
+          const { writeFileSync: writeFileSync13, mkdirSync: mkdirSync14 } = await import("fs");
           const outDir = resolvePath(this.cwd, this.config.outDir || "./opencroc-output");
-          mkdirSync11(outDir, { recursive: true });
+          mkdirSync14(outDir, { recursive: true });
           for (const report2 of reports) {
             const fullPath = resolvePath(outDir, report2.filename);
-            writeFileSync11(fullPath, report2.content, "utf-8");
+            writeFileSync13(fullPath, report2.content, "utf-8");
             this.log(`\u{1F4C4} Generated ${report2.format} report: ${report2.filename}`);
           }
           this.updateAgent("reporter-croc", { status: "done", currentTask: `${reports.length} reports generated`, progress: 100 });
@@ -5175,7 +7387,7 @@ var init_croc_office = __esm({
             page: "app",
             application: "app"
           };
-          const inferModule = (filePath, type) => {
+          const inferModule2 = (filePath, type) => {
             const parts = filePath.replace(/\\/g, "/").split("/");
             const typeDir = type === "model" ? "models" : "controllers";
             const typeDirIdx = parts.indexOf(typeDir);
@@ -5203,7 +7415,7 @@ var init_croc_office = __esm({
           });
           for (const file of modelFiles) {
             const parts = file.replace(/\\/g, "/").split("/");
-            const moduleName = inferModule(file, "model");
+            const moduleName = inferModule2(file, "model");
             const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "");
             const nodeId = `model:${fileName}`;
             moduleSet.add(moduleName);
@@ -5222,7 +7434,7 @@ var init_croc_office = __esm({
           });
           for (const file of controllerFiles) {
             const parts = file.replace(/\\/g, "/").split("/");
-            const moduleName = inferModule(file, "controller");
+            const moduleName = inferModule2(file, "controller");
             const fileName = parts[parts.length - 1].replace(/\.(ts|js)$/, "").replace(/Controller$/, "");
             const nodeId = `controller:${fileName}`;
             moduleSet.add(moduleName);
@@ -5296,13 +7508,13 @@ import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join14, resolve as resolve9 } from "path";
-import { existsSync as existsSync16 } from "fs";
+import { dirname as dirname7, join as join17, resolve as resolve11 } from "path";
+import { existsSync as existsSync19 } from "fs";
 async function startServer(opts) {
   const app = Fastify({ logger: false });
   await app.register(fastifyWebsocket);
-  const webDir = resolve9(__dirname2, "../web");
-  if (existsSync16(webDir)) {
+  const webDir = resolve11(__dirname2, "../web");
+  if (existsSync19(webDir)) {
     await app.register(fastifyStatic, {
       root: webDir,
       prefix: "/",
@@ -5312,6 +7524,7 @@ async function startServer(opts) {
   const office = new CrocOffice(opts.config, opts.cwd);
   registerProjectRoutes(app, office);
   registerAgentRoutes(app, office);
+  registerStudioRoutes(app, office);
   app.register(async (fastify) => {
     fastify.get("/ws", { websocket: true }, (socket) => {
       office.addClient(socket);
@@ -5323,8 +7536,11 @@ async function startServer(opts) {
       reply.code(404).send({ error: "Not found" });
       return;
     }
-    const indexPath = join14(webDir, "index.html");
-    if (existsSync16(indexPath)) {
+    const studioPath = join17(webDir, "index-studio.html");
+    const indexPath = join17(webDir, "index.html");
+    if (existsSync19(studioPath)) {
+      reply.sendFile("index-studio.html");
+    } else if (existsSync19(indexPath)) {
       reply.sendFile("index.html");
     } else {
       reply.code(200).header("content-type", "text/html").send(getEmbeddedHtml());
@@ -5473,9 +7689,10 @@ var init_server = __esm({
     init_esm_shims();
     init_project();
     init_agents();
+    init_studio();
     init_croc_office();
     __filename2 = fileURLToPath2(import.meta.url);
-    __dirname2 = dirname6(__filename2);
+    __dirname2 = dirname7(__filename2);
   }
 });
 
@@ -5520,6 +7737,248 @@ var init_serve = __esm({
   }
 });
 
+// src/cli/commands/scan.ts
+var scan_exports = {};
+__export(scan_exports, {
+  scan: () => scan
+});
+import * as fs11 from "fs";
+import * as path12 from "path";
+import chalk12 from "chalk";
+async function scan(target, opts) {
+  console.log("");
+  console.log(chalk12.green("\u{1F40A} OpenCroc Studio \u2014 Universal Project Scanner"));
+  console.log(chalk12.gray(`   Target: ${target}`));
+  console.log("");
+  const startTime = Date.now();
+  console.log(chalk12.cyan("\u{1F4E1} Phase 1: Scanning project..."));
+  const scanResult = await cloneAndScan({
+    target,
+    branch: opts.branch,
+    keepClone: true,
+    onProgress: (phase, percent, detail) => {
+      if (percent % 25 === 0 || phase === "clone") {
+        console.log(chalk12.gray(`   [${phase}] ${percent}% ${detail || ""}`));
+      }
+    }
+  });
+  console.log(chalk12.green(`   \u2705 Found ${scanResult.entities.length} entities, ${scanResult.relationships.length} relationships`));
+  console.log(chalk12.gray(`   Languages: ${Object.entries(scanResult.languages).filter(([k]) => !["json", "yaml", "markdown"].includes(k)).map(([k, v]) => `${k}(${v})`).join(", ")}`));
+  console.log(chalk12.gray(`   Frameworks: ${scanResult.frameworks.map((f) => f.name).join(", ") || "none detected"}`));
+  console.log("");
+  console.log(chalk12.cyan("\u{1F9E0} Phase 2: Building knowledge graph..."));
+  const projectName = target.includes("/") ? target.split("/").pop().replace(".git", "") : path12.basename(path12.resolve(target));
+  const isRemote = target.startsWith("http") || /^[\w.-]+\/[\w.-]+$/.test(target);
+  const graph = buildKnowledgeGraph(scanResult, {
+    projectName,
+    source: isRemote ? "github" : "local",
+    sourceUrl: target,
+    rootPath: target
+  });
+  const stats = getGraphStats(graph);
+  console.log(chalk12.green(`   \u2705 ${graph.nodes.length} nodes, ${graph.edges.length} edges`));
+  printStats(stats);
+  console.log("");
+  let risks = [];
+  if (opts.risks) {
+    console.log(chalk12.cyan("\u26A0\uFE0F  Phase 3: Analyzing risks..."));
+    risks = await analyzeRisks(graph);
+    printRisks(risks);
+    console.log("");
+  }
+  if (opts.report) {
+    console.log(chalk12.cyan(`\u{1F4CB} Phase 4: Generating ${opts.report} report...`));
+    const report2 = await generateReport(graph, opts.report, risks);
+    printReport(report2);
+    console.log("");
+  }
+  fs11.mkdirSync(opts.output, { recursive: true });
+  const graphPath = path12.join(opts.output, "knowledge-graph.json");
+  fs11.writeFileSync(graphPath, JSON.stringify({
+    projectInfo: graph.projectInfo,
+    stats: getGraphStats(graph),
+    nodes: graph.nodes.map((n) => ({ id: n.id, label: n.label, type: n.type, module: n.module, filePath: n.filePath })),
+    edges: graph.edges.map((e) => ({ source: e.source, target: e.target, relation: e.relation })),
+    risks: risks.length > 0 ? risks : void 0,
+    builtAt: graph.builtAt
+  }, null, 2));
+  console.log(chalk12.gray(`   \u{1F4C1} Graph saved: ${graphPath}`));
+  if (opts.json) {
+    const jsonPath = path12.join(opts.output, "scan-result.json");
+    fs11.writeFileSync(jsonPath, JSON.stringify({
+      project: graph.projectInfo,
+      stats,
+      risks: risks.length > 0 ? risks : void 0
+    }, null, 2));
+    console.log(chalk12.gray(`   \u{1F4C1} JSON saved: ${jsonPath}`));
+  }
+  if (opts.mermaid) {
+    const mermaidPath = path12.join(opts.output, "graph.mmd");
+    const mermaidText = toMermaid(graph, { nodeTypes: ["module", "model", "api", "service"], maxNodes: 40 });
+    fs11.writeFileSync(mermaidPath, mermaidText);
+    console.log(chalk12.gray(`   \u{1F4C1} Mermaid saved: ${mermaidPath}`));
+  }
+  const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
+  console.log("");
+  console.log(chalk12.green(`\u{1F40A} Done in ${duration}s`));
+  console.log(chalk12.gray(`   Run ${chalk12.white("opencroc serve")} to explore the knowledge graph in Studio UI`));
+  console.log("");
+}
+function printStats(stats) {
+  const items = [];
+  if (stats.moduleCount) items.push(`${stats.moduleCount} modules`);
+  if (stats.apiCount) items.push(`${stats.apiCount} APIs`);
+  if (stats.modelCount) items.push(`${stats.modelCount} models`);
+  if (stats.classCount) items.push(`${stats.classCount} classes`);
+  if (stats.functionCount) items.push(`${stats.functionCount} functions`);
+  if (stats.dependencyCount) items.push(`${stats.dependencyCount} dependencies`);
+  if (items.length > 0) {
+    console.log(chalk12.gray(`   ${items.join(" | ")}`));
+  }
+}
+function printRisks(risks) {
+  if (risks.length === 0) {
+    console.log(chalk12.green("   \u2705 No significant risks detected."));
+    return;
+  }
+  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 low = risks.filter((r) => r.severity === "low").length;
+  console.log(chalk12.yellow(`   Found ${risks.length} risks:`));
+  if (critical) console.log(chalk12.red(`     \u{1F534} Critical: ${critical}`));
+  if (high) console.log(chalk12.hex("#e67e22")(`     \u{1F7E0} High: ${high}`));
+  if (medium) console.log(chalk12.yellow(`     \u{1F7E1} Medium: ${medium}`));
+  if (low) console.log(chalk12.blue(`     \u{1F535} Low: ${low}`));
+  console.log("");
+  console.log(chalk12.white("   Top risks:"));
+  for (const r of risks.slice(0, 5)) {
+    const color = r.severity === "critical" ? chalk12.red : r.severity === "high" ? chalk12.hex("#e67e22") : r.severity === "medium" ? chalk12.yellow : chalk12.blue;
+    console.log(`     ${color(`[${r.severity.toUpperCase()}]`)} ${r.title}`);
+  }
+}
+function printReport(report2) {
+  console.log(chalk12.green(`   \u2705 ${report2.title}`));
+  console.log(chalk12.gray(`   ${report2.summary}`));
+  for (const section of report2.sections) {
+    console.log(chalk12.cyan(`
+   \u2500\u2500 ${section.heading} \u2500\u2500`));
+    const lines = section.content.split("\n").slice(0, 3);
+    for (const line of lines) {
+      console.log(chalk12.gray(`   ${line}`));
+    }
+    if (section.content.split("\n").length > 3) {
+      console.log(chalk12.gray("   ..."));
+    }
+  }
+}
+var init_scan = __esm({
+  "src/cli/commands/scan.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_github_cloner();
+    init_graph();
+    init_insight();
+  }
+});
+
+// src/cli/commands/analyze.ts
+var analyze_exports = {};
+__export(analyze_exports, {
+  analyze: () => analyze
+});
+import * as fs12 from "fs";
+import * as path13 from "path";
+import chalk13 from "chalk";
+async function analyze(target, opts) {
+  console.log("");
+  console.log(chalk13.green("\u{1F40A} OpenCroc Studio \u2014 Project Analysis"));
+  console.log("");
+  const absTarget = path13.resolve(target);
+  const graphPath = path13.join(opts.output, "knowledge-graph.json");
+  let graph;
+  if (fs12.existsSync(graphPath)) {
+    console.log(chalk13.gray(`   Loading cached graph from ${graphPath}...`));
+  }
+  console.log(chalk13.cyan("\u{1F4E1} Scanning project..."));
+  const scanResult = await scanProject({
+    rootDir: absTarget,
+    onProgress: (phase, percent, detail) => {
+      if (percent === 100) console.log(chalk13.gray(`   [${phase}] ${detail || "done"}`));
+    }
+  });
+  const projectName = path13.basename(absTarget);
+  graph = buildKnowledgeGraph(scanResult, {
+    projectName,
+    source: "local",
+    rootPath: absTarget
+  });
+  console.log(chalk13.green(`   \u2705 ${graph.nodes.length} nodes, ${graph.edges.length} edges`));
+  console.log("");
+  if (opts.risks) {
+    console.log(chalk13.cyan("\u26A0\uFE0F  Risk Analysis"));
+    const risks2 = await analyzeRisks(graph);
+    if (risks2.length === 0) {
+      console.log(chalk13.green("   \u2705 No significant risks detected."));
+    } else {
+      for (const r of risks2) {
+        const icon = r.severity === "critical" ? "\u{1F534}" : r.severity === "high" ? "\u{1F7E0}" : r.severity === "medium" ? "\u{1F7E1}" : "\u{1F535}";
+        console.log(`   ${icon} [${r.severity.toUpperCase()}] ${r.title}`);
+        console.log(chalk13.gray(`      ${r.description}`));
+        if (r.suggestion) {
+          console.log(chalk13.green(`      \u{1F4A1} ${r.suggestion}`));
+        }
+        console.log("");
+      }
+    }
+  }
+  if (opts.impact) {
+    console.log(chalk13.cyan(`\u{1F3AF} Impact Analysis: ${opts.impact}`));
+    const impact = analyzeImpact(graph, opts.impact);
+    console.log(`   ${impact.summary}`);
+    console.log(`   Direct impact: ${impact.directImpact.length} entities`);
+    console.log(`   Transitive impact: ${impact.transitiveImpact.length} entities`);
+    console.log(`   Risk level: ${impact.riskLevel}`);
+    console.log("");
+    if (impact.mermaidText) {
+      const mermaidPath = path13.join(opts.output, "impact.mmd");
+      fs12.mkdirSync(opts.output, { recursive: true });
+      fs12.writeFileSync(mermaidPath, impact.mermaidText);
+      console.log(chalk13.gray(`   \u{1F4C1} Impact diagram saved: ${mermaidPath}`));
+    }
+  }
+  const perspective = opts.perspective;
+  console.log(chalk13.cyan(`\u{1F4CB} ${perspective.charAt(0).toUpperCase() + perspective.slice(1)} Report`));
+  console.log("");
+  const risks = await analyzeRisks(graph);
+  const report2 = await generateReport(graph, perspective, risks);
+  console.log(chalk13.bold.green(`   ${report2.title}`));
+  console.log(chalk13.gray(`   ${report2.summary}`));
+  console.log("");
+  for (const section of report2.sections) {
+    console.log(chalk13.cyan(`   \u2501\u2501 ${section.heading} \u2501\u2501`));
+    const lines = section.content.split("\n");
+    for (const line of lines) {
+      console.log(`   ${line}`);
+    }
+    console.log("");
+  }
+  fs12.mkdirSync(opts.output, { recursive: true });
+  const reportPath = path13.join(opts.output, `report-${perspective}.json`);
+  fs12.writeFileSync(reportPath, JSON.stringify(report2, null, 2));
+  console.log(chalk13.gray(`   \u{1F4C1} Report saved: ${reportPath}`));
+  console.log("");
+}
+var init_analyze = __esm({
+  "src/cli/commands/analyze.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_scanner();
+    init_graph();
+    init_insight();
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
 import { Command } from "commander";
@@ -5569,5 +8028,13 @@ program.command("serve").description("Start OpenCroc Studio \u2014 pixel croc of
   const { serve: serve2 } = await Promise.resolve().then(() => (init_serve(), serve_exports));
   await serve2(opts);
 });
+program.command("scan").description("Scan any project and build knowledge graph (local path, GitHub URL, or user/repo)").argument("<target>", "Local path, GitHub URL (https://github.com/user/repo), or shorthand (user/repo)").option("-b, --branch <branch>", "Git branch to clone").option("-o, --output <dir>", "Output directory for results", "./opencroc-output").option("--json", "Output as JSON").option("--mermaid", "Output Mermaid diagram").option("--risks", "Include risk analysis").option("--report <perspective>", "Generate perspective report (developer/architect/tester/product/student/executive)").action(async (target, opts) => {
+  const { scan: scan2 } = await Promise.resolve().then(() => (init_scan(), scan_exports));
+  await scan2(target, opts);
+});
+program.command("analyze").description("Analyze a scanned project for risks and generate reports").argument("[target]", "Project path (default: current directory)", ".").option("--perspective <role>", "Report perspective (developer/architect/tester/product/student/executive)", "developer").option("--risks", "Show risk analysis", true).option("--impact <nodeId>", "Analyze impact of a specific node").option("-o, --output <dir>", "Output directory", "./opencroc-output").action(async (target, opts) => {
+  const { analyze: analyze2 } = await Promise.resolve().then(() => (init_analyze(), analyze_exports));
+  await analyze2(target, opts);
+});
 program.parse();
 //# sourceMappingURL=index.js.map