codebrief 1.0.0

package/dist/index.js

@@ -0,0 +1,3578 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ensureDir: () => ensureDir,
+  estimateTokens: () => estimateTokens,
+  fileExists: () => fileExists,
+  formatBytes: () => formatBytes,
+  readDirSafe: () => readDirSafe,
+  readFileOr: () => readFileOr,
+  readJsonFile: () => readJsonFile,
+  writeFileSafe: () => writeFileSafe
+});
+import fs from "fs/promises";
+import path from "path";
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileOr(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function readJsonFile(filePath) {
+  const content = await readFileOr(filePath);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function estimateTokens(text2) {
+  if (text2.length === 0) return 0;
+  const symbolCount = text2.replace(/[\w\s]/g, "").length;
+  const symbolRatio = symbolCount / text2.length;
+  const charsPerToken = symbolRatio > 0.08 ? 3.2 : 3.5;
+  return Math.ceil(text2.length / charsPerToken);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  return `${(bytes / 1024).toFixed(1)} KB`;
+}
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+async function writeFileSafe(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readDirSafe(dirPath) {
+  try {
+    return await fs.readdir(dirPath);
+  } catch {
+    return [];
+  }
+}
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+import path8 from "path";
+import * as p4 from "@clack/prompts";
+import pc3 from "picocolors";
+
+// src/detect.ts
+init_utils();
+import path2 from "path";
+import fg from "fast-glob";
+var KNOWN_DIRS = [
+  "src",
+  "app",
+  "pages",
+  "components",
+  "services",
+  "stores",
+  "store",
+  "lib",
+  "utils",
+  "hooks",
+  "api",
+  "tests",
+  "__tests__",
+  "test",
+  "public",
+  "assets",
+  "styles",
+  "config",
+  "scripts",
+  "docs",
+  "types"
+];
+var FRAMEWORK_MAP = {
+  // JS/TS
+  expo: "Expo",
+  "react-native": "React Native",
+  next: "Next.js",
+  react: "React",
+  vue: "Vue",
+  nuxt: "Nuxt",
+  svelte: "Svelte",
+  "@sveltejs/kit": "SvelteKit",
+  angular: "Angular",
+  "@angular/core": "Angular",
+  express: "Express",
+  fastify: "Fastify",
+  hono: "Hono",
+  "nestjs/core": "NestJS",
+  "@nestjs/core": "NestJS",
+  electron: "Electron",
+  tauri: "Tauri",
+  // State management
+  zustand: "Zustand",
+  redux: "Redux",
+  "@reduxjs/toolkit": "Redux Toolkit",
+  pinia: "Pinia",
+  mobx: "MobX",
+  jotai: "Jotai",
+  recoil: "Recoil",
+  // Testing
+  jest: "Jest",
+  vitest: "Vitest",
+  playwright: "Playwright",
+  cypress: "Cypress",
+  // Styling
+  tailwindcss: "Tailwind CSS",
+  nativewind: "NativeWind",
+  "styled-components": "styled-components",
+  "@emotion/react": "Emotion",
+  // ORM/DB
+  prisma: "Prisma",
+  "@prisma/client": "Prisma",
+  drizzle: "Drizzle",
+  "drizzle-orm": "Drizzle",
+  typeorm: "TypeORM",
+  mongoose: "Mongoose"
+};
+var PYTHON_FRAMEWORK_MAP = {
+  django: "Django",
+  flask: "Flask",
+  fastapi: "FastAPI",
+  starlette: "Starlette",
+  sqlalchemy: "SQLAlchemy",
+  pydantic: "Pydantic",
+  pytest: "pytest",
+  celery: "Celery"
+};
+async function detectContext(rootDir, onProgress) {
+  const ctx = {
+    rootDir,
+    language: "other",
+    hasTypeScript: false,
+    packageManager: "none",
+    linter: "none",
+    frameworks: [],
+    directories: [],
+    dependencies: [],
+    isGitRepo: false,
+    totalSourceBytes: 0,
+    sourceFileCount: 0,
+    monorepo: null
+  };
+  onProgress?.("Checking project markers...");
+  const [
+    hasGit,
+    hasPackageJson,
+    hasGoMod,
+    hasCargo,
+    hasPyproject,
+    hasRequirements,
+    hasTsConfig,
+    hasBiome,
+    hasPnpmLock,
+    hasYarnLock,
+    hasBunLock,
+    topEntries
+  ] = await Promise.all([
+    fileExists(path2.join(rootDir, ".git")),
+    readJsonFile(path2.join(rootDir, "package.json")),
+    fileExists(path2.join(rootDir, "go.mod")),
+    fileExists(path2.join(rootDir, "Cargo.toml")),
+    readJsonFile(path2.join(rootDir, "pyproject.toml")),
+    // won't parse TOML but that's ok
+    fileExists(path2.join(rootDir, "requirements.txt")),
+    fileExists(path2.join(rootDir, "tsconfig.json")),
+    fileExists(path2.join(rootDir, "biome.json")),
+    fileExists(path2.join(rootDir, "pnpm-lock.yaml")),
+    fileExists(path2.join(rootDir, "yarn.lock")),
+    fileExists(path2.join(rootDir, "bun.lockb")),
+    readDirSafe(rootDir)
+  ]);
+  ctx.isGitRepo = hasGit;
+  if (hasPackageJson) {
+    const pkg = hasPackageJson;
+    ctx.language = hasTsConfig ? "typescript" : "javascript";
+    ctx.hasTypeScript = hasTsConfig;
+    if (hasPnpmLock) ctx.packageManager = "pnpm";
+    else if (hasYarnLock) ctx.packageManager = "yarn";
+    else if (hasBunLock) ctx.packageManager = "bun";
+    else ctx.packageManager = "npm";
+    const deps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    ctx.dependencies = Object.keys(deps);
+    const seen = /* @__PURE__ */ new Set();
+    for (const dep of ctx.dependencies) {
+      const framework = FRAMEWORK_MAP[dep];
+      if (framework && !seen.has(framework)) {
+        seen.add(framework);
+        const version = deps[dep]?.replace(/^[\^~>=<]/, "");
+        ctx.frameworks.push({ name: framework, version });
+      }
+    }
+    if (hasBiome) {
+      ctx.linter = "biome";
+    } else {
+      const hasEslint = ctx.dependencies.includes("eslint") || topEntries.some((e) => e.startsWith(".eslintrc"));
+      const hasPrettier = ctx.dependencies.includes("prettier") || topEntries.some((e) => e.startsWith(".prettierrc"));
+      if (hasEslint) ctx.linter = "eslint";
+      else if (hasPrettier) ctx.linter = "prettier";
+    }
+  } else if (hasGoMod) {
+    ctx.language = "go";
+    ctx.packageManager = "go";
+    ctx.linter = "gofmt";
+  } else if (hasCargo) {
+    ctx.language = "rust";
+    ctx.packageManager = "cargo";
+    ctx.linter = "rustfmt";
+  } else if (hasPyproject || hasRequirements) {
+    ctx.language = "python";
+    if (topEntries.includes("poetry.lock")) ctx.packageManager = "poetry";
+    else ctx.packageManager = "pip";
+    if (hasRequirements) {
+      const { readFileOr: readFileOr2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+      const reqContent = await readFileOr2(path2.join(rootDir, "requirements.txt"));
+      if (reqContent) {
+        const pkgs = reqContent.split("\n").map((l) => l.trim().split(/[=<>!~[]/)[0].toLowerCase()).filter(Boolean);
+        for (const pkg of pkgs) {
+          const framework = PYTHON_FRAMEWORK_MAP[pkg];
+          if (framework) {
+            ctx.frameworks.push({ name: framework });
+          }
+        }
+        ctx.dependencies = pkgs;
+      }
+    }
+    const hasRuff = topEntries.includes("ruff.toml") || topEntries.some((e) => e === "pyproject.toml");
+    if (hasRuff) ctx.linter = "ruff";
+    else ctx.linter = "none";
+  }
+  if (ctx.frameworks.length > 0) {
+    const fwNames = ctx.frameworks.map((f) => f.name).join(", ");
+    const lang = ctx.hasTypeScript ? "TypeScript" : ctx.language !== "other" ? ctx.language : "";
+    const parts = [lang, fwNames].filter(Boolean);
+    onProgress?.(`Detected: ${parts.join(" + ")}`);
+  }
+  onProgress?.("Scanning directories...");
+  for (const dir of KNOWN_DIRS) {
+    if (topEntries.includes(dir)) {
+      ctx.directories.push(dir);
+    }
+  }
+  if (topEntries.includes("src")) {
+    const srcEntries = await readDirSafe(path2.join(rootDir, "src"));
+    for (const entry of srcEntries) {
+      if (KNOWN_DIRS.includes(entry)) {
+        ctx.directories.push(`src/${entry}`);
+      }
+    }
+  }
+  try {
+    const extensions = getExtensionsForLanguage(ctx.language);
+    const sourceFiles = await fg(
+      extensions.map((ext) => `**/*${ext}`),
+      {
+        cwd: rootDir,
+        ignore: [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.next/**",
+          "**/target/**",
+          "**/vendor/**",
+          "**/__pycache__/**",
+          "**/venv/**",
+          "**/.venv/**"
+        ],
+        stats: true
+      }
+    );
+    ctx.sourceFileCount = sourceFiles.length;
+    onProgress?.(`Counting ${sourceFiles.length} source files...`);
+    ctx.totalSourceBytes = sourceFiles.reduce(
+      (sum, f) => sum + (f.stats?.size ?? 0),
+      0
+    );
+  } catch {
+  }
+  ctx.testFramework = detectTestFramework(ctx.dependencies);
+  ctx.ciProvider = await detectCiProvider(rootDir, topEntries);
+  ctx.monorepo = await detectMonorepo(rootDir, topEntries);
+  return ctx;
+}
+var TEST_FRAMEWORK_MAP = {
+  vitest: "Vitest",
+  jest: "Jest",
+  playwright: "Playwright",
+  cypress: "Cypress",
+  mocha: "Mocha",
+  pytest: "pytest"
+};
+function detectTestFramework(dependencies) {
+  for (const [dep, name] of Object.entries(TEST_FRAMEWORK_MAP)) {
+    if (dependencies.includes(dep)) return name;
+  }
+  return void 0;
+}
+var CI_PATTERNS = [
+  { path: ".github/workflows", name: "GitHub Actions", isDir: true },
+  { path: ".gitlab-ci.yml", name: "GitLab CI" },
+  { path: ".circleci", name: "CircleCI", isDir: true },
+  { path: "Jenkinsfile", name: "Jenkins" },
+  { path: ".travis.yml", name: "Travis CI" }
+];
+async function detectCiProvider(rootDir, topEntries) {
+  for (const ci of CI_PATTERNS) {
+    if (ci.isDir) {
+      if (await fileExists(path2.join(rootDir, ci.path))) return ci.name;
+    } else {
+      if (topEntries.includes(ci.path)) return ci.name;
+    }
+  }
+  return void 0;
+}
+function getExtensionsForLanguage(lang) {
+  switch (lang) {
+    case "typescript":
+      return [".ts", ".tsx"];
+    case "javascript":
+      return [".js", ".jsx", ".mjs"];
+    case "python":
+      return [".py"];
+    case "go":
+      return [".go"];
+    case "rust":
+      return [".rs"];
+    case "java":
+      return [".java"];
+    default:
+      return [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"];
+  }
+}
+async function detectMonorepo(rootDir, topEntries) {
+  const hasTurboJson = topEntries.includes("turbo.json");
+  const hasNxJson = topEntries.includes("nx.json");
+  const hasPnpmWorkspace = topEntries.includes("pnpm-workspace.yaml");
+  let type = null;
+  if (hasTurboJson) type = "turborepo";
+  else if (hasNxJson) type = "nx";
+  else if (hasPnpmWorkspace) type = "pnpm-workspaces";
+  if (!type) return null;
+  let packageGlobs = [];
+  if (hasPnpmWorkspace || hasTurboJson) {
+    const yamlContent = await readFileOr(
+      path2.join(rootDir, "pnpm-workspace.yaml")
+    );
+    if (yamlContent) {
+      const lines = yamlContent.split("\n");
+      let inPackages = false;
+      for (const line of lines) {
+        if (/^packages:/i.test(line.trim())) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          const match = line.match(/^\s+-\s+['"]?([^'"]+)['"]?/);
+          if (match) {
+            packageGlobs.push(match[1].trim());
+          } else if (line.trim() && !line.startsWith(" ") && !line.startsWith("	")) {
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (packageGlobs.length === 0 && hasNxJson) {
+    for (const dir of ["packages", "libs", "apps"]) {
+      if (topEntries.includes(dir)) {
+        packageGlobs.push(`${dir}/*`);
+      }
+    }
+  }
+  if (packageGlobs.length === 0) {
+    const pkg = await readJsonFile(path2.join(rootDir, "package.json"));
+    if (pkg) {
+      const workspaces = pkg.workspaces;
+      if (Array.isArray(workspaces)) {
+        packageGlobs = workspaces;
+      } else if (workspaces && typeof workspaces === "object" && Array.isArray(workspaces.packages)) {
+        packageGlobs = workspaces.packages;
+      }
+    }
+  }
+  if (packageGlobs.length === 0) return null;
+  const resolvedDirs = await fg(packageGlobs, {
+    cwd: rootDir,
+    onlyDirectories: true,
+    ignore: ["**/node_modules/**"],
+    absolute: false
+  });
+  const packages = [];
+  for (const dir of resolvedDirs) {
+    const pkgJsonPath = path2.join(rootDir, dir, "package.json");
+    const pkgJson = await readJsonFile(pkgJsonPath);
+    if (!pkgJson) continue;
+    const deps = {
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies
+    };
+    const depNames = Object.keys(deps);
+    const frameworks = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dep of depNames) {
+      const framework = FRAMEWORK_MAP[dep];
+      if (framework && !seen.has(framework)) {
+        seen.add(framework);
+        const version = deps[dep]?.replace(/^[\^~>=<]/, "");
+        frameworks.push({ name: framework, version });
+      }
+    }
+    packages.push({
+      name: pkgJson.name ?? path2.basename(dir),
+      path: dir,
+      dependencies: depNames,
+      frameworks
+    });
+  }
+  if (packages.length === 0) return null;
+  return { type, packages };
+}
+function buildReverseFrameworkMap() {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [dep, name] of Object.entries(FRAMEWORK_MAP)) {
+    const deps = reverse.get(name) ?? [];
+    deps.push(dep);
+    reverse.set(name, deps);
+  }
+  return reverse;
+}
+function enrichFrameworksWithUsage(frameworks, externalImportCounts) {
+  const reverseMap = buildReverseFrameworkMap();
+  return frameworks.map((fw) => {
+    const depNames = reverseMap.get(fw.name) ?? [];
+    let totalCount = 0;
+    for (const dep of depNames) {
+      totalCount += externalImportCounts.get(dep) ?? 0;
+    }
+    return { ...fw, importCount: totalCount };
+  }).filter((fw) => fw.importCount === void 0 || fw.importCount > 0);
+}
+function summarizeDetection(ctx) {
+  const parts = [];
+  if (ctx.frameworks.length > 0) {
+    parts.push(ctx.frameworks.map((f) => f.name).join(" + "));
+  }
+  if (ctx.hasTypeScript) {
+    parts.push("TypeScript");
+  } else if (ctx.language !== "other") {
+    parts.push(ctx.language.charAt(0).toUpperCase() + ctx.language.slice(1));
+  }
+  if (ctx.linter !== "none") {
+    parts.push(ctx.linter.charAt(0).toUpperCase() + ctx.linter.slice(1));
+  }
+  if (ctx.packageManager !== "none") {
+    parts.push(ctx.packageManager);
+  }
+  return parts.join(" + ");
+}
+
+// src/prompts.ts
+import * as p from "@clack/prompts";
+async function runPrompts(detected, defaults) {
+  const ideOptions = [
+    { value: "claude", label: "Claude Code" },
+    { value: "cursor", label: "Cursor" },
+    { value: "opencode", label: "OpenCode" },
+    { value: "copilot", label: "GitHub Copilot" },
+    { value: "windsurf", label: "Windsurf" },
+    { value: "cline", label: "Cline" },
+    { value: "continue", label: "Continue.dev" },
+    { value: "aider", label: "Aider" },
+    { value: "generic", label: "Other (generic CONTEXT.md)" }
+  ];
+  const ide = await p.select({
+    message: "Which AI coding tool are you using?",
+    options: ideOptions,
+    initialValue: defaults?.ide
+  });
+  if (p.isCancel(ide)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const stackSummary = summarizeDetection(detected);
+  let stackConfirmed = true;
+  let stackCorrections = defaults?.stackCorrections ?? "";
+  if (stackSummary) {
+    const confirm3 = await p.confirm({
+      message: `Detected: ${stackSummary}. Correct?`
+    });
+    if (p.isCancel(confirm3)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    stackConfirmed = confirm3;
+    if (!confirm3) {
+      const corrections = await p.text({
+        message: "What should I correct? (describe your actual stack)",
+        placeholder: "e.g. It's actually Next.js 15 + Prisma, not plain React",
+        defaultValue: defaults?.stackCorrections || void 0
+      });
+      if (p.isCancel(corrections)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+      }
+      stackCorrections = corrections;
+    }
+  }
+  const projectPurpose = await p.text({
+    message: "What does this project do? (1-2 sentences)",
+    placeholder: "e.g. A mobile AI chat app connecting to OpenAI, Anthropic, and Google APIs",
+    defaultValue: defaults?.projectPurpose || void 0,
+    validate: (value) => {
+      if (!value?.trim()) return "Please describe your project briefly.";
+    }
+  });
+  if (p.isCancel(projectPurpose)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const keyPatterns = await p.text({
+    message: "Any key coding patterns or conventions? (optional, press Enter to skip)",
+    placeholder: "e.g. Zustand slices for state, NativeWind for styling, expo/fetch for SSE",
+    defaultValue: defaults?.keyPatterns || ""
+  });
+  if (p.isCancel(keyPatterns)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const gotchas = await p.text({
+    message: "Any critical gotchas or anti-patterns to avoid? (optional)",
+    placeholder: "e.g. Never use FadeIn/FadeOut on ternary components, no @expo/vector-icons",
+    defaultValue: defaults?.gotchas || ""
+  });
+  if (p.isCancel(gotchas)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  let generateSnapshot2 = false;
+  let snapshotPaths = defaults?.snapshotPaths ?? [];
+  if (detected.language === "typescript" || detected.language === "javascript") {
+    const snapshotChoice = await p.select({
+      message: "Generate a code snapshot? (extracts types, store shapes, component props)",
+      options: [
+        { value: "auto", label: "Yes, auto-detect key files" },
+        { value: "no", label: "No, skip code snapshot" },
+        { value: "custom", label: "Yes, but let me specify paths" }
+      ],
+      initialValue: defaults?.generateSnapshot ? defaults.snapshotPaths.length > 0 ? "custom" : "auto" : void 0
+    });
+    if (p.isCancel(snapshotChoice)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (snapshotChoice === "auto") {
+      generateSnapshot2 = true;
+      snapshotPaths = [];
+    } else if (snapshotChoice === "custom") {
+      generateSnapshot2 = true;
+      const paths = await p.text({
+        message: "Paths to scan (comma-separated, relative to project root)",
+        placeholder: "e.g. src/types, src/stores, src/components",
+        defaultValue: defaults?.snapshotPaths.length ? defaults.snapshotPaths.join(", ") : void 0
+      });
+      if (p.isCancel(paths)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+      }
+      snapshotPaths = paths.split(",").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  let generatePerPackage = false;
+  if (detected.monorepo && detected.monorepo.packages.length > 0) {
+    const mono = detected.monorepo;
+    const pkgNames = mono.packages.map((pkg) => pkg.name).join(", ");
+    const perPkg = await p.confirm({
+      message: `Monorepo detected (${mono.type}, ${mono.packages.length} packages: ${pkgNames}). Generate per-package context files?`,
+      initialValue: defaults?.generatePerPackage ?? false
+    });
+    if (p.isCancel(perPkg)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    generatePerPackage = perPkg;
+  }
+  return {
+    ide,
+    projectPurpose,
+    keyPatterns: keyPatterns ?? "",
+    gotchas: gotchas ?? "",
+    generateSnapshot: generateSnapshot2,
+    snapshotPaths,
+    stackConfirmed,
+    stackCorrections,
+    generatePerPackage
+  };
+}
+
+// src/snapshot.ts
+init_utils();
+import path4 from "path";
+import fg3 from "fast-glob";
+
+// src/graph.ts
+init_utils();
+import path3 from "path";
+import fg2 from "fast-glob";
+var JS_IMPORT_FROM = /import\s+(?:type\s+)?(?:\{([^}]*)\}|(\*\s+as\s+\w+|\w+)(?:\s*,\s*\{([^}]*)\})?)\s+from\s+['"]([^'"]+)['"]/g;
+var JS_IMPORT_SIDE = /import\s+['"]([^'"]+)['"]/g;
+var JS_REQUIRE = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+var JS_DYNAMIC = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+var PY_FROM_IMPORT = /^from\s+(\.+[\w.]*|[\w][\w.]*)\s+import\s+(.+)/gm;
+var PY_IMPORT = /^import\s+([\w., ]+)/gm;
+var GO_IMPORT_SINGLE = /import\s+"([^"]+)"/g;
+var GO_IMPORT_BLOCK = /import\s*\(([^)]+)\)/gs;
+var RUST_USE = /(?:pub\s+)?use\s+((?:crate|super|self)(?:::\w+)*(?:::\{[^}]*\})?)/g;
+var RUST_MOD = /mod\s+(\w+)\s*;/g;
+var JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+var INDEX_FILES = JS_EXTENSIONS.map((e) => `/index${e}`);
+function getSourceGlob(lang) {
+  switch (lang) {
+    case "typescript":
+    case "javascript":
+      return ["**/*.{ts,tsx,js,jsx,mjs}"];
+    case "python":
+      return ["**/*.py"];
+    case "go":
+      return ["**/*.go"];
+    case "rust":
+      return ["**/*.rs"];
+    default:
+      return ["**/*.{ts,tsx,js,jsx,py,go,rs}"];
+  }
+}
+function parseJsImports(content) {
+  const imports = [];
+  for (const m of content.matchAll(JS_IMPORT_FROM)) {
+    const names = [];
+    if (m[1]) names.push(...m[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean));
+    if (m[2]) {
+      const group2 = m[2].trim();
+      if (!group2.startsWith("*")) {
+        names.push(group2);
+      }
+    }
+    if (m[3]) names.push(...m[3].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean));
+    imports.push({ specifier: m[4], importedNames: names });
+  }
+  for (const m of content.matchAll(JS_IMPORT_SIDE)) {
+    if (!content.includes(`from '${m[1]}'`) && !content.includes(`from "${m[1]}"`)) {
+      imports.push({ specifier: m[1], importedNames: [] });
+    }
+  }
+  for (const m of content.matchAll(JS_REQUIRE)) {
+    imports.push({ specifier: m[1], importedNames: [] });
+  }
+  for (const m of content.matchAll(JS_DYNAMIC)) {
+    imports.push({ specifier: m[1], importedNames: [] });
+  }
+  return imports;
+}
+function parsePythonImports(content) {
+  const imports = [];
+  for (const m of content.matchAll(PY_FROM_IMPORT)) {
+    const module = m[1];
+    const names = m[2].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    imports.push({ specifier: module, importedNames: names });
+  }
+  for (const m of content.matchAll(PY_IMPORT)) {
+    const modules = m[1].split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    for (const mod of modules) {
+      imports.push({ specifier: mod, importedNames: [] });
+    }
+  }
+  return imports;
+}
+function parseGoImports(content) {
+  const imports = [];
+  for (const m of content.matchAll(GO_IMPORT_SINGLE)) {
+    imports.push({ specifier: m[1], importedNames: [] });
+  }
+  for (const m of content.matchAll(GO_IMPORT_BLOCK)) {
+    const block = m[1];
+    for (const line of block.split("\n")) {
+      if (line.trim().startsWith("//")) continue;
+      const match = line.match(/["']([^"']+)["']/);
+      if (match) {
+        imports.push({ specifier: match[1], importedNames: [] });
+      }
+    }
+  }
+  return imports;
+}
+function parseRustImports(content) {
+  const imports = [];
+  for (const m of content.matchAll(RUST_USE)) {
+    const usePath = m[1];
+    const globMatch = usePath.match(/::\{([^}]*)\}$/);
+    if (globMatch) {
+      const names = globMatch[1].split(",").map((n) => n.trim()).filter(Boolean);
+      imports.push({ specifier: usePath, importedNames: names });
+    } else {
+      const parts = usePath.split("::");
+      const name = parts[parts.length - 1];
+      imports.push({ specifier: usePath, importedNames: name ? [name] : [] });
+    }
+  }
+  for (const m of content.matchAll(RUST_MOD)) {
+    imports.push({ specifier: m[1], importedNames: [] });
+  }
+  return imports;
+}
+function parseImports(content, lang) {
+  switch (lang) {
+    case "typescript":
+    case "javascript":
+      return parseJsImports(content);
+    case "python":
+      return parsePythonImports(content);
+    case "go":
+      return parseGoImports(content);
+    case "rust":
+      return parseRustImports(content);
+    default:
+      return parseJsImports(content);
+  }
+}
+function isRelativeSpecifier(spec, lang) {
+  if (lang === "typescript" || lang === "javascript") {
+    return spec.startsWith("./") || spec.startsWith("../");
+  }
+  if (lang === "python") {
+    return spec.startsWith(".");
+  }
+  if (lang === "rust") {
+    return spec.startsWith("crate::") || spec.startsWith("super::") || spec.startsWith("self::");
+  }
+  return spec.startsWith("./") || spec.startsWith("../");
+}
+function resolveJsImport(specifier, fromFile, allFiles) {
+  const dir = path3.dirname(fromFile);
+  const raw = path3.join(dir, specifier).replace(/\\/g, "/");
+  const stripped = raw.replace(/\.(jsx?|mjs)$/, "");
+  const bases = stripped !== raw ? [raw, stripped] : [raw];
+  for (const base of bases) {
+    if (allFiles.has(base)) return base;
+    for (const ext of JS_EXTENSIONS) {
+      if (allFiles.has(base + ext)) return base + ext;
+    }
+    for (const idx of INDEX_FILES) {
+      if (allFiles.has(base + idx)) return base + idx;
+    }
+  }
+  return null;
+}
+function resolvePythonImport(specifier, fromFile, allFiles) {
+  if (!specifier.startsWith(".")) return null;
+  const dir = path3.dirname(fromFile);
+  let dots = 0;
+  while (specifier[dots] === ".") dots++;
+  const modulePath = specifier.slice(dots).replace(/\./g, "/");
+  let baseDir = dir;
+  for (let i = 1; i < dots; i++) {
+    baseDir = path3.dirname(baseDir);
+  }
+  const base = modulePath ? path3.join(baseDir, modulePath).replace(/\\/g, "/") : baseDir;
+  if (allFiles.has(base + ".py")) return base + ".py";
+  if (allFiles.has(base + "/__init__.py")) return base + "/__init__.py";
+  return null;
+}
+function resolveImport(specifier, fromFile, lang, allFiles) {
+  switch (lang) {
+    case "typescript":
+    case "javascript":
+      return resolveJsImport(specifier, fromFile, allFiles);
+    case "python":
+      return resolvePythonImport(specifier, fromFile, allFiles);
+    default:
+      return null;
+  }
+}
+function computePageRank(files, edges, iterations = 5, damping = 0.85) {
+  const n = files.length;
+  if (n === 0) return /* @__PURE__ */ new Map();
+  const outLinks = /* @__PURE__ */ new Map();
+  for (const file of files) outLinks.set(file, []);
+  for (const edge of edges) {
+    if (!edge.isExternal && outLinks.has(edge.from)) {
+      outLinks.get(edge.from).push(edge.to);
+    }
+  }
+  let scores = /* @__PURE__ */ new Map();
+  const init = 1 / n;
+  for (const file of files) scores.set(file, init);
+  for (let iter = 0; iter < iterations; iter++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const file of files) next.set(file, (1 - damping) / n);
+    for (const file of files) {
+      const links = outLinks.get(file) ?? [];
+      if (links.length === 0) continue;
+      const share = damping * (scores.get(file) ?? 0) / links.length;
+      for (const target of links) {
+        next.set(target, (next.get(target) ?? 0) + share);
+      }
+    }
+    scores = next;
+  }
+  let max = 0;
+  for (const v of scores.values()) {
+    if (v > max) max = v;
+  }
+  if (max > 0) {
+    for (const [k, v] of scores) {
+      scores.set(k, v / max);
+    }
+  }
+  return scores;
+}
+async function buildImportGraph(rootDir, language, onProgress) {
+  const globs = getSourceGlob(language);
+  const files = await fg2(globs, {
+    cwd: rootDir,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/target/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+      "**/venv/**",
+      "**/.venv/**"
+    ],
+    absolute: false
+  });
+  onProgress?.(`Found ${files.length} source files to analyze`);
+  const fileSet = new Set(files);
+  const edges = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  const externalImportCounts = /* @__PURE__ */ new Map();
+  for (const file of files) inDegree.set(file, 0);
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if ((i + 1) % 50 === 0 || i === files.length - 1) {
+      onProgress?.(`Parsing imports... ${i + 1}/${files.length} files`);
+    }
+    const absPath = path3.join(rootDir, file);
+    const content = await readFileOr(absPath);
+    if (!content) continue;
+    const rawImports = parseImports(content, language);
+    for (const raw of rawImports) {
+      const isRelative = isRelativeSpecifier(raw.specifier, language);
+      if (isRelative) {
+        const resolved = resolveImport(raw.specifier, file, language, fileSet);
+        if (resolved) {
+          edges.push({
+            from: file,
+            to: resolved,
+            isExternal: false,
+            specifier: raw.specifier,
+            importedNames: raw.importedNames
+          });
+          inDegree.set(resolved, (inDegree.get(resolved) ?? 0) + 1);
+        }
+      } else {
+        const pkgName = getPackageName(raw.specifier);
+        edges.push({
+          from: file,
+          to: pkgName,
+          isExternal: true,
+          specifier: raw.specifier,
+          importedNames: raw.importedNames
+        });
+        externalImportCounts.set(
+          pkgName,
+          (externalImportCounts.get(pkgName) ?? 0) + 1
+        );
+      }
+    }
+  }
+  onProgress?.("Computing centrality (PageRank)...");
+  const centrality = computePageRank(files, edges);
+  return { edges, inDegree, centrality, externalImportCounts };
+}
+function getPackageName(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    return parts.slice(0, 2).join("/");
+  }
+  return specifier.split("/")[0];
+}
+function findUsedExports(edges) {
+  const used = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    if (edge.isExternal) continue;
+    for (const name of edge.importedNames) {
+      used.add(`${edge.to}::${name}`);
+    }
+  }
+  return used;
+}
+function getHubFiles(graph, limit = 8) {
+  const outCount = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!edge.isExternal) {
+      outCount.set(edge.from, (outCount.get(edge.from) ?? 0) + 1);
+    }
+  }
+  const files = [];
+  for (const [filePath, centrality] of graph.centrality) {
+    const importedBy = graph.inDegree.get(filePath) ?? 0;
+    const imports = outCount.get(filePath) ?? 0;
+    if (importedBy > 0 || imports > 0) {
+      files.push({ path: filePath, centrality, importedBy, imports });
+    }
+  }
+  files.sort((a, b) => b.centrality - a.centrality);
+  return files.slice(0, limit);
+}
+function findSCCs(graph) {
+  const adj = /* @__PURE__ */ new Map();
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.isExternal) continue;
+    allFiles.add(edge.from);
+    allFiles.add(edge.to);
+    const list = adj.get(edge.from) ?? [];
+    list.push(edge.to);
+    adj.set(edge.from, list);
+  }
+  let index = 0;
+  const indices = /* @__PURE__ */ new Map();
+  const lowlinks = /* @__PURE__ */ new Map();
+  const onStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const sccs = [];
+  function strongconnect(v) {
+    indices.set(v, index);
+    lowlinks.set(v, index);
+    index++;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of adj.get(v) ?? []) {
+      if (!indices.has(w)) {
+        strongconnect(w);
+        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+      } else if (onStack.has(w)) {
+        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+      }
+    }
+    if (lowlinks.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      if (scc.length > 1) {
+        sccs.push(scc);
+      }
+    }
+  }
+  for (const file of allFiles) {
+    if (!indices.has(file)) {
+      strongconnect(file);
+    }
+  }
+  return sccs;
+}
+function findCircularDeps(graph, maxCycles = 10) {
+  const sccs = findSCCs(graph);
+  sccs.sort((a, b) => a.length - b.length);
+  const cycles = [];
+  for (const scc of sccs) {
+    if (cycles.length >= maxCycles) break;
+    cycles.push({ chain: [...scc, scc[0]] });
+  }
+  return cycles;
+}
+var LAYER_PATTERNS = [
+  { name: "types", pattern: /(?:^|\/)types?\// },
+  { name: "stores", pattern: /(?:^|\/)stores?\// },
+  { name: "hooks", pattern: /(?:^|\/)hooks?\// },
+  { name: "services", pattern: /(?:^|\/)(?:services?|api)\// },
+  { name: "components", pattern: /(?:^|\/)components?\// },
+  { name: "pages", pattern: /(?:^|\/)(?:pages?|app|routes?)\// },
+  { name: "utils", pattern: /(?:^|\/)(?:utils?|lib|helpers?)\// },
+  { name: "config", pattern: /(?:^|\/)config\// }
+];
+function detectArchitecturalLayers(graph) {
+  const layerFiles = /* @__PURE__ */ new Map();
+  const fileToLayer = /* @__PURE__ */ new Map();
+  for (const [filePath] of graph.centrality) {
+    for (const { name, pattern } of LAYER_PATTERNS) {
+      if (pattern.test(filePath)) {
+        const files = layerFiles.get(name) ?? [];
+        files.push(filePath);
+        layerFiles.set(name, files);
+        fileToLayer.set(filePath, name);
+        break;
+      }
+    }
+  }
+  const layerImportedBy = /* @__PURE__ */ new Map();
+  const layerDependsOn = /* @__PURE__ */ new Map();
+  for (const name of layerFiles.keys()) {
+    layerImportedBy.set(name, /* @__PURE__ */ new Set());
+    layerDependsOn.set(name, /* @__PURE__ */ new Set());
+  }
+  for (const edge of graph.edges) {
+    if (edge.isExternal) continue;
+    const fromLayer = fileToLayer.get(edge.from);
+    const toLayer = fileToLayer.get(edge.to);
+    if (fromLayer && toLayer && fromLayer !== toLayer) {
+      layerImportedBy.get(toLayer)?.add(fromLayer);
+      layerDependsOn.get(fromLayer)?.add(toLayer);
+    }
+  }
+  const layerEdges = [];
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const [from, deps] of layerDependsOn) {
+    for (const to of deps) {
+      const key = `${from}->${to}`;
+      if (!edgeSet.has(key)) {
+        edgeSet.add(key);
+        layerEdges.push({ from, to });
+      }
+    }
+  }
+  const layers = [];
+  for (const [name, files] of layerFiles) {
+    layers.push({
+      name,
+      files,
+      importedByLayers: layerImportedBy.get(name)?.size ?? 0,
+      dependsOn: [...layerDependsOn.get(name) ?? []]
+    });
+  }
+  layers.sort((a, b) => b.importedByLayers - a.importedByLayers || a.name.localeCompare(b.name));
+  return { layers, layerEdges };
+}
+function computeInstability(graph) {
+  const fanOutMap = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (!edge.isExternal) {
+      fanOutMap.set(edge.from, (fanOutMap.get(edge.from) ?? 0) + 1);
+    }
+  }
+  const results = [];
+  for (const [filePath, fanIn] of graph.inDegree) {
+    const fanOut = fanOutMap.get(filePath) ?? 0;
+    const total = fanIn + fanOut;
+    if (total === 0) continue;
+    const instability = fanOut / total;
+    if (instability > 0.7 && fanIn >= 3) {
+      results.push({ path: filePath, fanIn, fanOut, instability });
+    }
+  }
+  results.sort((a, b) => b.instability - a.instability);
+  return results;
+}
+function detectCommunities(graph) {
+  const adj = /* @__PURE__ */ new Map();
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.isExternal) continue;
+    allFiles.add(edge.from);
+    allFiles.add(edge.to);
+    if (!adj.has(edge.from)) adj.set(edge.from, /* @__PURE__ */ new Set());
+    if (!adj.has(edge.to)) adj.set(edge.to, /* @__PURE__ */ new Set());
+    adj.get(edge.from).add(edge.to);
+    adj.get(edge.to).add(edge.from);
+  }
+  const files = [...allFiles];
+  if (files.length === 0) return [];
+  const labels = /* @__PURE__ */ new Map();
+  for (let i = 0; i < files.length; i++) {
+    labels.set(files[i], i);
+  }
+  for (let iter = 0; iter < 10; iter++) {
+    let changed = false;
+    const shuffled = [...files];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    for (const file of shuffled) {
+      const neighbors = adj.get(file);
+      if (!neighbors || neighbors.size === 0) continue;
+      const labelCounts = /* @__PURE__ */ new Map();
+      for (const neighbor of neighbors) {
+        const lbl = labels.get(neighbor);
+        labelCounts.set(lbl, (labelCounts.get(lbl) ?? 0) + 1);
+      }
+      let maxCount = 0;
+      let bestLabel = labels.get(file);
+      for (const [lbl, count] of labelCounts) {
+        if (count > maxCount) {
+          maxCount = count;
+          bestLabel = lbl;
+        }
+      }
+      if (bestLabel !== labels.get(file)) {
+        labels.set(file, bestLabel);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [file, label] of labels) {
+    const group = groups.get(label) ?? [];
+    group.push(file);
+    groups.set(label, group);
+  }
+  const communities = [];
+  let id = 0;
+  for (const files2 of groups.values()) {
+    if (files2.length < 3) continue;
+    const label = deriveLabel(files2);
+    communities.push({ id: id++, files: files2.sort(), label });
+  }
+  communities.sort((a, b) => b.files.length - a.files.length);
+  return communities;
+}
+function deriveLabel(files) {
+  if (files.length === 0) return "unknown";
+  const dirs = files.map((f) => {
+    const parts = f.split("/");
+    return parts.slice(0, -1).join("/");
+  });
+  const first = dirs[0];
+  let prefixLen = first.length;
+  for (const dir of dirs) {
+    let i = 0;
+    while (i < prefixLen && i < dir.length && first[i] === dir[i]) i++;
+    prefixLen = i;
+  }
+  let common = first.slice(0, prefixLen);
+  if (common.includes("/")) {
+    common = common.slice(0, common.lastIndexOf("/") + 1);
+  }
+  common = common.replace(/\/$/, "");
+  return common || files[0].split("/")[0] || "root";
+}
+function computeExportCoverage(graph) {
+  const usedExports = findUsedExports(graph.edges);
+  const allExportsByFile = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    if (edge.isExternal) continue;
+    for (const name of edge.importedNames) {
+      if (!allExportsByFile.has(edge.to)) allExportsByFile.set(edge.to, /* @__PURE__ */ new Set());
+      allExportsByFile.get(edge.to).add(name);
+    }
+  }
+  const results = [];
+  for (const [file, exports] of allExportsByFile) {
+    const totalExports = exports.size;
+    if (totalExports === 0) continue;
+    let usedCount = 0;
+    for (const name of exports) {
+      if (usedExports.has(`${file}::${name}`)) usedCount++;
+    }
+    results.push({
+      file,
+      totalExports,
+      usedExports: usedCount,
+      coverage: usedCount / totalExports
+    });
+  }
+  results.sort((a, b) => a.coverage - b.coverage);
+  return results;
+}
+
+// src/snapshot.ts
+function getDefaultScanPaths(ctx) {
+  const paths = [];
+  const dirs = ctx.directories;
+  for (const d of dirs) {
+    if (d.endsWith("types") || d.endsWith("typings")) paths.push(d);
+  }
+  for (const d of dirs) {
+    if (d.endsWith("stores") || d.endsWith("store")) paths.push(d);
+  }
+  for (const d of dirs) {
+    if (d.endsWith("services") || d.endsWith("api")) paths.push(d);
+  }
+  for (const d of dirs) {
+    if (d.endsWith("hooks")) paths.push(d);
+  }
+  for (const d of dirs) {
+    if (d.endsWith("components")) paths.push(d);
+  }
+  for (const d of dirs) {
+    if (d.endsWith("lib") || d.endsWith("utils")) paths.push(d);
+  }
+  if (paths.length === 0) {
+    paths.push("src", "app", "lib");
+  }
+  return paths;
+}
+var PATTERNS = {
+  /** export interface Foo { ... } or export type Foo = ... */
+  exportedType: /^export\s+(interface|type)\s+(\w+)/,
+  /** interface FooProps { ... } (component props, even if not exported) */
+  propsInterface: /^(?:export\s+)?interface\s+(\w+Props)\s*\{/,
+  /** export function foo(...) or export const foo = */
+  exportedFunction: /^export\s+(?:async\s+)?(?:function|const)\s+(\w+)/,
+  /** StateCreator<...> pattern (Zustand slices) */
+  zustandSlice: /StateCreator<\s*(\w+)/,
+  /** export interface FooSlice { ... } */
+  sliceInterface: /^export\s+interface\s+(\w+Slice)\s*\{/
+};
+async function extractFromFile(filePath, relPath) {
+  const content = await readFileOr(filePath);
+  if (!content) return [];
+  const entries = [];
+  const lines = content.split("\n");
+  const isStore = /stores?[/\\]/.test(relPath);
+  const isHook = /hooks?[/\\]/.test(relPath) || relPath.includes("use");
+  const isComponent = /components?[/\\]/.test(relPath);
+  const isService = /services?[/\\]|api[/\\]/.test(relPath);
+  const isType = /types?[/\\]/.test(relPath) || relPath.endsWith(".types.ts");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trimStart();
+    const typeMatch = trimmed.match(PATTERNS.exportedType);
+    if (typeMatch) {
+      const [, kind, name] = typeMatch;
+      const category = name.endsWith("Slice") ? "store" : name.endsWith("Props") ? "component" : kind === "interface" ? "interface" : "type";
+      const block = extractBlock(lines, i);
+      entries.push({ file: relPath, category, signature: block });
+      continue;
+    }
+    if (isComponent) {
+      const propsMatch = trimmed.match(PATTERNS.propsInterface);
+      if (propsMatch && !trimmed.startsWith("export")) {
+        const block = extractBlock(lines, i);
+        entries.push({ file: relPath, category: "component", signature: block });
+        continue;
+      }
+    }
+    const funcMatch = trimmed.match(PATTERNS.exportedFunction);
+    if (funcMatch) {
+      const [, name] = funcMatch;
+      if (isComponent && name[0] === name[0].toUpperCase() && !name.startsWith("use")) {
+        continue;
+      }
+      let category = "function";
+      if (isHook || name.startsWith("use")) category = "hook";
+      else if (isStore) category = "store";
+      const sig = extractSignatureLine(lines, i);
+      entries.push({ file: relPath, category, signature: sig });
+    }
+  }
+  return entries;
+}
+function extractBlock(lines, startIdx) {
+  const firstLine = lines[startIdx];
+  if (!firstLine.includes("{")) {
+    let result2 = "";
+    for (let i = startIdx; i < lines.length && i < startIdx + 10; i++) {
+      result2 += (result2 ? "\n" : "") + lines[i];
+      if (lines[i].includes(";")) break;
+    }
+    return result2.trim();
+  }
+  let depth = 0;
+  let result = "";
+  const maxLines = 30;
+  for (let i = startIdx; i < lines.length && i < startIdx + maxLines; i++) {
+    const line = lines[i];
+    result += (result ? "\n" : "") + line;
+    for (const ch of line) {
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+    }
+    if (depth <= 0 && i > startIdx) break;
+  }
+  return result.trim();
+}
+function extractSignatureLine(lines, startIdx) {
+  let sig = "";
+  for (let i = startIdx; i < lines.length && i < startIdx + 5; i++) {
+    sig += (sig ? " " : "") + lines[i].trim();
+    if (sig.includes("{") || sig.includes("=>")) {
+      const braceIdx = sig.indexOf("{");
+      const arrowIdx = sig.indexOf("=>");
+      const cutIdx = braceIdx >= 0 && arrowIdx >= 0 ? Math.min(braceIdx, arrowIdx) : braceIdx >= 0 ? braceIdx : arrowIdx >= 0 ? arrowIdx + 2 : sig.length;
+      sig = sig.slice(0, cutIdx).trim();
+      break;
+    }
+  }
+  return sig;
+}
+function annotateSignature(entry) {
+  if (entry.importedByCount && entry.importedByCount > 2) {
+    const firstLine = entry.signature.split("\n")[0];
+    const rest = entry.signature.split("\n").slice(1);
+    const annotated = `${firstLine}  // imported by ${entry.importedByCount} files`;
+    return rest.length > 0 ? [annotated, ...rest].join("\n") : annotated;
+  }
+  return entry.signature;
+}
+function renderSnapshot(entries) {
+  if (entries.length === 0) return "";
+  const byFile = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const list = byFile.get(e.file) ?? [];
+    list.push(e);
+    byFile.set(e.file, list);
+  }
+  let md = "";
+  const types = entries.filter((e) => e.category === "type" || e.category === "interface");
+  const stores = entries.filter((e) => e.category === "store");
+  const hooks = entries.filter((e) => e.category === "hook");
+  const components = entries.filter((e) => e.category === "component");
+  const functions = entries.filter((e) => e.category === "function");
+  if (types.length > 0) {
+    md += "### Core Types\n\n```ts\n";
+    md += types.map((e) => annotateSignature(e)).join("\n\n");
+    md += "\n```\n\n";
+  }
+  if (stores.length > 0) {
+    md += "### Store Shape\n\n```ts\n";
+    md += stores.map((e) => annotateSignature(e)).join("\n\n");
+    md += "\n```\n\n";
+  }
+  if (components.length > 0) {
+    md += "### Component Props\n\n```ts\n";
+    md += components.map((e) => annotateSignature(e)).join("\n\n");
+    md += "\n```\n\n";
+  }
+  if (hooks.length > 0) {
+    md += "### Hooks\n\n```ts\n";
+    md += hooks.map((e) => annotateSignature(e)).join("\n\n");
+    md += "\n```\n\n";
+  }
+  if (functions.length > 0) {
+    md += "### Key Functions\n\n```ts\n";
+    md += functions.map((e) => annotateSignature(e)).join("\n\n");
+    md += "\n```\n\n";
+  }
+  return md.trimEnd();
+}
+async function generateSnapshot(ctx, customPaths, graph, maxTokens, onProgress, gitActivity) {
+  const scanPaths = customPaths.length > 0 ? customPaths : getDefaultScanPaths(ctx);
+  if (scanPaths.length === 0) {
+    return { entries: [], markdown: "" };
+  }
+  const dirNames = scanPaths.map((p5) => p5.split("/").pop() ?? p5);
+  onProgress?.(`Scanning ${scanPaths.length} directories: ${dirNames.join(", ")}...`);
+  const patterns = scanPaths.map((p5) => `${p5}/**/*.{ts,tsx,js,jsx}`);
+  const files = await fg3(patterns, {
+    cwd: ctx.rootDir,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/__tests__/**"
+    ],
+    absolute: false
+  });
+  const allEntries = [];
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if ((i + 1) % 20 === 0 || i === files.length - 1) {
+      const dir = path4.dirname(file).split("/").pop() ?? "";
+      onProgress?.(`Extracting signatures... ${i + 1}/${files.length} files (${dir}/)`);
+    }
+    const absPath = path4.join(ctx.rootDir, file);
+    const entries = await extractFromFile(absPath, file);
+    allEntries.push(...entries);
+  }
+  if (graph) {
+    for (const entry of allEntries) {
+      const count = graph.inDegree.get(entry.file) ?? 0;
+      if (count > 0) {
+        entry.importedByCount = count;
+      }
+    }
+  }
+  onProgress?.("Filtering dead exports...");
+  const liveEntries = filterDeadExports(allEntries, graph);
+  const budget = maxTokens ?? Math.min(16e3, 4e3 + Math.floor(ctx.sourceFileCount / 25) * 500);
+  onProgress?.(`Applying token budget (${budget.toLocaleString()} tokens)...`);
+  const { selected, excluded } = applyTokenBudget(liveEntries, budget, graph, gitActivity);
+  const markdown = renderSnapshot(selected);
+  return {
+    entries: selected,
+    markdown,
+    budgetExcluded: excluded,
+    estimatedTokens: estimateTokens(markdown)
+  };
+}
+var ENTRY_POINT_PATTERNS = [
+  /(?:^|\/)index\.[jt]sx?$/,
+  /(?:^|\/)App\.[jt]sx?$/,
+  /(?:^|\/)main\.[jt]sx?$/,
+  /(?:^|\/)pages\//,
+  /(?:^|\/)app\//,
+  /(?:^|\/)routes?\//,
+  /(?:^|\/)middleware\//
+];
+function extractNameFromSignature(sig) {
+  const m = sig.match(
+    /export\s+(?:default\s+)?(?:async\s+)?(?:interface|type|function|const|let|var|class|enum)\s+(\w+)/
+  );
+  return m?.[1] ?? null;
+}
+function isEntryPoint(filePath) {
+  return ENTRY_POINT_PATTERNS.some((p5) => p5.test(filePath));
+}
+function filterDeadExports(entries, graph) {
+  if (!graph || graph.edges.length === 0) return entries;
+  const usedExports = findUsedExports(graph.edges);
+  return entries.filter((entry) => {
+    if (isEntryPoint(entry.file)) return true;
+    const name = extractNameFromSignature(entry.signature);
+    if (!name) return true;
+    return usedExports.has(`${entry.file}::${name}`);
+  });
+}
+function applyTokenBudget(entries, budget, graph, gitActivity) {
+  if (entries.length === 0) return { selected: [], excluded: 0 };
+  const scored = entries.map((entry) => {
+    const tokens = Math.max(1, estimateTokens(entry.signature));
+    const centrality = graph?.centrality.get(entry.file) ?? 0.5;
+    let categoryBoost = 1;
+    if (entry.category === "type" || entry.category === "interface") categoryBoost = 1.3;
+    let gitBoost = 1;
+    if (gitActivity) {
+      const commits = gitActivity.commitCounts.get(entry.file) ?? 0;
+      gitBoost = 1 + Math.min(0.5, commits / 20);
+    }
+    const value = centrality * categoryBoost * gitBoost / tokens;
+    return { entry, tokens, value };
+  });
+  scored.sort((a, b) => b.value - a.value);
+  let remaining = budget;
+  const selected = [];
+  for (const { entry, tokens } of scored) {
+    if (tokens <= remaining) {
+      selected.push(entry);
+      remaining -= tokens;
+    }
+  }
+  return {
+    selected,
+    excluded: entries.length - selected.length
+  };
+}
+
+// src/generate.ts
+init_utils();
+import path5 from "path";
+import * as p2 from "@clack/prompts";
+
+// src/templates/framework-hints.ts
+function getFrameworkHints(ctx) {
+  const hints = [];
+  const frameworkNames = new Set(ctx.frameworks.map((f) => f.name));
+  for (const gen of HINT_GENERATORS) {
+    if (frameworkNames.has(gen.name)) {
+      const lines = gen.getHints(ctx);
+      if (lines.length > 0) hints.push(...lines);
+    }
+  }
+  return hints;
+}
+function getFrameworkHintsSection(ctx) {
+  const hints = getFrameworkHints(ctx);
+  if (hints.length === 0) return "";
+  const lines = ["## Framework Conventions", ""];
+  for (const h of hints) {
+    lines.push(h);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+var HINT_GENERATORS = [
+  {
+    name: "Next.js",
+    getHints: (ctx) => {
+      const hints = [];
+      const hasAppDir = ctx.directories.some(
+        (d) => d === "app" || d.startsWith("app/") || d === "src/app"
+      );
+      const hasPagesDir = ctx.directories.some(
+        (d) => d === "pages" || d.startsWith("pages/") || d === "src/pages"
+      );
+      if (hasAppDir && !hasPagesDir) {
+        hints.push("### Next.js (App Router)");
+        hints.push("");
+        hints.push(
+          "- **App Router** \u2014 all routes in `app/` use React Server Components by default"
+        );
+        hints.push(
+          '- Add `"use client"` directive at the top of files that need browser APIs, hooks, or event handlers'
+        );
+        hints.push(
+          "- `layout.tsx` wraps child routes; `page.tsx` is the route's UI; `loading.tsx` / `error.tsx` for boundaries"
+        );
+        hints.push(
+          "- Data fetching: `async` server components with direct `fetch()` or DB calls (no `getServerSideProps`)"
+        );
+        hints.push(
+          "- Route handlers: `app/api/*/route.ts` with exported `GET`, `POST`, etc. functions"
+        );
+        hints.push(
+          "- Middleware in `middleware.ts` at project root for auth, redirects, rewrites"
+        );
+        hints.push(
+          "- Use `next/image` for optimized images, `next/font` for font loading"
+        );
+      } else if (hasPagesDir && !hasAppDir) {
+        hints.push("### Next.js (Pages Router)");
+        hints.push("");
+        hints.push("- **Pages Router** \u2014 routes in `pages/` directory");
+        hints.push(
+          "- `getServerSideProps` for server-side data fetching, `getStaticProps` for static generation"
+        );
+        hints.push(
+          "- `_app.tsx` for global layout/providers, `_document.tsx` for HTML customization"
+        );
+        hints.push("- API routes in `pages/api/`");
+      } else if (hasAppDir && hasPagesDir) {
+        hints.push("### Next.js (Hybrid \u2014 App + Pages Router)");
+        hints.push("");
+        hints.push(
+          "- Both `app/` (App Router) and `pages/` (Pages Router) coexist \u2014 new routes should use App Router"
+        );
+        hints.push(
+          '- App Router components are server components by default; add `"use client"` for client components'
+        );
+        hints.push(
+          "- Pages Router uses `getServerSideProps` / `getStaticProps` for data fetching"
+        );
+      } else {
+        hints.push("### Next.js");
+        hints.push("");
+        hints.push(
+          "- Use `next/image` for optimized images, `next/font` for font loading"
+        );
+        hints.push(
+          "- Middleware in `middleware.ts` at project root for auth, redirects, rewrites"
+        );
+      }
+      return hints;
+    }
+  },
+  {
+    name: "Express",
+    getHints: () => [
+      "### Express",
+      "",
+      "- Middleware chain: `app.use()` for global, router-level for scoped. Order matters.",
+      "- Error handling: define a 4-arg middleware `(err, req, res, next)` at the end of the chain",
+      "- Organize routes with `express.Router()` in separate files, mount with `app.use('/prefix', router)`",
+      "- Validate request bodies/params at the route level (e.g. with zod, joi, or express-validator)",
+      "- Use `async` handlers with try/catch or an async wrapper to avoid unhandled promise rejections",
+      "- Set `res.status()` before `res.json()` \u2014 don't rely on defaults for error responses"
+    ]
+  },
+  {
+    name: "Fastify",
+    getHints: () => [
+      "### Fastify",
+      "",
+      "- Plugin architecture: register plugins with `fastify.register()` for encapsulation",
+      "- Schema-based validation: use JSON Schema for request/response validation (built-in)",
+      "- Hooks: `onRequest`, `preHandler`, `onSend` etc. for request lifecycle",
+      "- Use `fastify-plugin` for plugins that should not be encapsulated",
+      "- Serialization: define response schemas for 2x faster JSON serialization"
+    ]
+  },
+  {
+    name: "Hono",
+    getHints: () => [
+      "### Hono",
+      "",
+      "- Middleware with `app.use()` \u2014 compose with `c.next()` pattern",
+      "- Validators: use `hono/validator` or `@hono/zod-validator` for type-safe request parsing",
+      "- Context (`c`): `c.json()`, `c.text()`, `c.html()` for responses; `c.req` for request",
+      "- Supports multiple runtimes (Node, Deno, Bun, Cloudflare Workers) \u2014 avoid Node-specific APIs"
+    ]
+  },
+  {
+    name: "NestJS",
+    getHints: () => [
+      "### NestJS",
+      "",
+      "- **Modules** organize the app into cohesive blocks; every feature gets a module",
+      "- **Controllers** handle HTTP requests (decorators: `@Get()`, `@Post()`, etc.)",
+      "- **Providers** (services) hold business logic \u2014 injected via constructor DI",
+      "- **Guards** for auth (`@UseGuards()`), **Pipes** for validation (`@UsePipes()`)",
+      "- **Interceptors** for response transformation, logging, caching",
+      "- DTOs with `class-validator` decorators for request validation",
+      "- Use `@Injectable()` on all services/providers"
+    ]
+  },
+  {
+    name: "Expo",
+    getHints: (ctx) => {
+      const hasRN = ctx.frameworks.some((f) => f.name === "React Native");
+      const hints = ["### Expo / React Native", ""];
+      hints.push(
+        "- **expo-router** for file-based routing (if using); Stack, Tabs, Drawer navigators"
+      );
+      hints.push(
+        "- Expo Go has limited native module support \u2014 some packages require a dev build (`npx expo run:ios`)"
+      );
+      hints.push(
+        "- Use `expo-constants`, `expo-device` etc. instead of raw RN APIs when available"
+      );
+      hints.push(
+        "- Platform-specific files: `*.ios.tsx` / `*.android.tsx` or `Platform.select()`"
+      );
+      if (hasRN) {
+        hints.push(
+          '- **Reanimated**: worklet functions need the `"worklet"` directive on the first line'
+        );
+        hints.push(
+          "- Avoid `FadeIn`/`FadeOut` entering/exiting animations on conditionally rendered components \u2014 they cause flashes"
+        );
+      }
+      return hints;
+    }
+  },
+  {
+    name: "React Native",
+    getHints: (ctx) => {
+      if (ctx.frameworks.some((f) => f.name === "Expo")) return [];
+      return [
+        "### React Native",
+        "",
+        "- Use `StyleSheet.create()` for styles \u2014 avoid inline style objects in render",
+        "- Platform-specific: `*.ios.tsx` / `*.android.tsx` or `Platform.select()`",
+        '- **Reanimated**: worklet functions need the `"worklet"` directive',
+        "- Navigation: React Navigation with Stack/Tab/Drawer navigators",
+        "- Test with both iOS and Android \u2014 layout behavior differs"
+      ];
+    }
+  },
+  {
+    name: "React",
+    getHints: (ctx) => {
+      const skip = ["Next.js", "Expo", "React Native"];
+      if (ctx.frameworks.some((f) => skip.includes(f.name))) return [];
+      return [
+        "### React",
+        "",
+        "- Functional components with hooks \u2014 no class components",
+        "- Use `React.memo()` for expensive renders, `useMemo`/`useCallback` for referential stability",
+        "- Lift state up or use context for shared state; avoid prop drilling beyond 2-3 levels",
+        "- Prefer controlled components for forms",
+        "- Use `Suspense` boundaries with `lazy()` for code splitting"
+      ];
+    }
+  },
+  {
+    name: "Vue",
+    getHints: () => [
+      "### Vue",
+      "",
+      "- Composition API with `<script setup>` for new components",
+      "- Reactive state: `ref()` for primitives, `reactive()` for objects",
+      "- `computed()` for derived state, `watch()` / `watchEffect()` for side effects",
+      "- Props: define with `defineProps<T>()`, emits with `defineEmits<T>()`",
+      "- Use `provide` / `inject` for deep dependency injection"
+    ]
+  },
+  {
+    name: "Nuxt",
+    getHints: () => [
+      "### Nuxt",
+      "",
+      "- Auto-imports: components, composables, and utils are auto-imported \u2014 no manual import needed",
+      "- File-based routing in `pages/` \u2014 dynamic params with `[id].vue` syntax",
+      "- Data fetching: `useFetch()` / `useAsyncData()` \u2014 they handle SSR hydration automatically",
+      "- Server routes in `server/api/` \u2014 auto-registered, use `defineEventHandler()`",
+      "- Middleware in `middleware/` \u2014 `defineNuxtRouteMiddleware()` for route guards",
+      "- State: `useState()` for SSR-safe shared state, Pinia for complex stores"
+    ]
+  },
+  {
+    name: "Svelte",
+    getHints: (ctx) => {
+      if (ctx.frameworks.some((f) => f.name === "SvelteKit")) return [];
+      return [
+        "### Svelte",
+        "",
+        "- Reactive declarations with `$:` for derived state",
+        "- Props: `export let propName` in component script",
+        "- Stores: `writable()`, `readable()`, `derived()` \u2014 auto-subscribe with `$store` syntax",
+        "- Use `{#if}`, `{#each}`, `{#await}` blocks for conditional/list/async rendering"
+      ];
+    }
+  },
+  {
+    name: "SvelteKit",
+    getHints: () => [
+      "### SvelteKit",
+      "",
+      "- File-based routing in `src/routes/` \u2014 `+page.svelte`, `+layout.svelte`, `+server.ts`",
+      "- `+page.ts` (universal) or `+page.server.ts` (server-only) for `load` functions",
+      "- Form actions in `+page.server.ts` with `actions` export for progressive enhancement",
+      "- Hooks in `src/hooks.server.ts` for auth, session, error handling",
+      "- Use `$app/stores` for page, navigating, updated stores"
+    ]
+  },
+  {
+    name: "Angular",
+    getHints: () => [
+      "### Angular",
+      "",
+      "- Components, services, pipes, directives all use decorators (`@Component`, `@Injectable`, etc.)",
+      "- Dependency injection: provide services in module or component `providers` array",
+      "- RxJS Observables for async data \u2014 use `async` pipe in templates, unsubscribe on destroy",
+      "- Lazy-load feature modules with `loadChildren` in routes",
+      "- Use Angular CLI (`ng generate`) for scaffolding"
+    ]
+  },
+  {
+    name: "Django",
+    getHints: () => [
+      "### Django",
+      "",
+      "- Apps structure: each feature is a Django app with `models.py`, `views.py`, `urls.py`, `admin.py`",
+      "- Models: define in `models.py`, create migrations with `python manage.py makemigrations`",
+      "- Views: function-based (FBV) or class-based (CBV) \u2014 CBV for CRUD, FBV for custom logic",
+      "- URL routing in `urls.py` using `path()` and `include()` for app-level URLs",
+      "- Templates in `templates/` \u2014 use template inheritance with `{% extends %}` and `{% block %}`",
+      "- Management commands in `management/commands/` for custom CLI tasks",
+      "- Settings: use `django-environ` or `python-decouple` for environment-based config"
+    ]
+  },
+  {
+    name: "Flask",
+    getHints: () => [
+      "### Flask",
+      "",
+      "- Blueprints for modular route organization \u2014 register with `app.register_blueprint()`",
+      "- Use application factory pattern (`create_app()`) for testing and config flexibility",
+      "- Error handlers with `@app.errorhandler(404)` etc.",
+      "- Use Flask-SQLAlchemy for ORM, Flask-Migrate for database migrations",
+      "- Request context: `request`, `g`, `session` globals \u2014 available inside request handlers"
+    ]
+  },
+  {
+    name: "FastAPI",
+    getHints: () => [
+      "### FastAPI",
+      "",
+      "- **Dependency injection**: use `Depends()` for shared logic (auth, DB sessions, validation)",
+      "- **Pydantic models** for request/response schemas \u2014 automatic validation and OpenAPI docs",
+      "- Async endpoints by default (`async def`); use sync `def` only for blocking I/O with threadpool",
+      "- Routers: `APIRouter()` for modular route organization, mount with `app.include_router()`",
+      '- Middleware with `@app.middleware("http")` or Starlette middleware classes',
+      "- Background tasks with `BackgroundTasks` parameter for fire-and-forget work",
+      "- Auto-generated docs at `/docs` (Swagger) and `/redoc`"
+    ]
+  },
+  {
+    name: "Prisma",
+    getHints: () => [
+      "### Prisma",
+      "",
+      "- Schema in `prisma/schema.prisma` \u2014 run `npx prisma generate` after changes",
+      "- Migrations: `npx prisma migrate dev` for development, `npx prisma migrate deploy` for production",
+      "- Use `prisma.$transaction()` for atomic operations",
+      "- Relation queries: use `include` for eager loading, `select` for field filtering"
+    ]
+  },
+  {
+    name: "Drizzle",
+    getHints: () => [
+      "### Drizzle",
+      "",
+      "- Schema defined in TypeScript \u2014 type-safe queries with no code generation step",
+      "- Migrations: `drizzle-kit generate` then `drizzle-kit migrate`",
+      "- Use `db.select()`, `db.insert()`, `db.update()`, `db.delete()` for queries",
+      "- Relations: define with `relations()` helper for type-safe joins"
+    ]
+  },
+  {
+    name: "Tailwind CSS",
+    getHints: (ctx) => {
+      if (ctx.frameworks.some((f) => f.name === "NativeWind")) return [];
+      return [
+        "### Tailwind CSS",
+        "",
+        "- Utility-first: compose styles with `className` \u2014 avoid custom CSS unless truly needed",
+        "- Use `@apply` sparingly in CSS modules for repeated patterns",
+        "- Responsive: mobile-first with `sm:`, `md:`, `lg:` breakpoint prefixes",
+        "- Dark mode: `dark:` variant (class or media strategy per `tailwind.config`)",
+        "- Extract reusable component classes into shared components, not `@apply` blocks"
+      ];
+    }
+  },
+  {
+    name: "Electron",
+    getHints: () => [
+      "### Electron",
+      "",
+      "- **Main process** (Node.js) and **renderer process** (Chromium) \u2014 communicate via IPC",
+      "- Use `contextBridge` + `preload.js` to expose safe APIs to renderer (no `nodeIntegration`)",
+      "- `ipcMain.handle()` / `ipcRenderer.invoke()` for async request-response patterns",
+      "- Package with `electron-builder` or `electron-forge`"
+    ]
+  }
+];
+
+// src/templates/main-context.ts
+function buildMainContext(ctx, answers, snapshot, analysis) {
+  const projectName = getProjectName(ctx);
+  const stackSummary = answers.stackConfirmed ? summarizeDetection(ctx) : answers.stackCorrections || summarizeDetection(ctx);
+  const sections = [];
+  sections.push(`# ${projectName}`);
+  sections.push("");
+  sections.push(
+    "> **Keep this file up to date.** When you change the architecture, add a dependency, create a new pattern, or learn a gotcha, update this file in the same step. This is the source of truth for how the project works."
+  );
+  if (answers.ide === "cursor") {
+    sections.push(
+      "> Scoped rules are in `.cursor/rules/` -- update them when conventions change."
+    );
+  }
+  sections.push("");
+  sections.push("## What Is This");
+  sections.push("");
+  sections.push(answers.projectPurpose);
+  sections.push("");
+  sections.push("## Tech Stack");
+  sections.push("");
+  sections.push(buildTechStackSection(ctx, stackSummary));
+  sections.push("");
+  const fwHints = getFrameworkHintsSection(ctx);
+  if (fwHints) {
+    sections.push(fwHints);
+  }
+  if (ctx.directories.length > 0) {
+    sections.push("## Project Structure");
+    sections.push("");
+    sections.push("```");
+    sections.push(buildStructureTree(ctx));
+    sections.push("```");
+    sections.push("");
+  }
+  if (ctx.monorepo && ctx.monorepo.packages.length > 0) {
+    sections.push("## Monorepo Structure");
+    sections.push("");
+    sections.push(
+      `${ctx.monorepo.type} workspace with ${ctx.monorepo.packages.length} packages:`
+    );
+    sections.push("");
+    for (const pkg of ctx.monorepo.packages) {
+      const fws = pkg.frameworks.length > 0 ? ` \u2014 ${pkg.frameworks.map((f) => f.name).join(", ")}` : "";
+      sections.push(`- **${pkg.name}** (\`${pkg.path}\`)${fws}`);
+    }
+    sections.push("");
+  }
+  if (snapshot?.markdown) {
+    sections.push("## Code Snapshot");
+    sections.push("");
+    sections.push(
+      "<!-- CODE SNAPSHOT (auto-generated, update when types/stores/services change) -->"
+    );
+    sections.push("");
+    sections.push(snapshot.markdown);
+    sections.push("");
+    sections.push("<!-- /CODE SNAPSHOT -->");
+    sections.push("");
+  }
+  if (analysis?.hubFiles && analysis.hubFiles.length > 0) {
+    const instabilityMap = /* @__PURE__ */ new Map();
+    if (analysis.instabilities) {
+      for (const inst of analysis.instabilities) {
+        instabilityMap.set(inst.path, inst.instability);
+      }
+    }
+    sections.push("## Key Files");
+    sections.push("");
+    sections.push(
+      "These are the most interconnected files. Read these first for architectural understanding."
+    );
+    sections.push("");
+    sections.push("| File | Imported By | Stability |");
+    sections.push("|------|-------------|-----------|");
+    for (const hub of analysis.hubFiles) {
+      const inst = instabilityMap.get(hub.path);
+      const stabilityCell = inst != null ? `${(inst * 100).toFixed(0)}% unstable \u26A0\uFE0F` : "stable";
+      sections.push(
+        `| \`${hub.path}\` | ${hub.importedBy} file${hub.importedBy === 1 ? "" : "s"} | ${stabilityCell} |`
+      );
+    }
+    sections.push("");
+  }
+  if (analysis?.layers && analysis.layers.length > 1) {
+    sections.push("## Architecture");
+    sections.push("");
+    const diagram = renderArchitectureDiagram(analysis.layers, analysis.layerEdges ?? []);
+    sections.push(diagram);
+    sections.push("");
+  }
+  if (analysis?.gitActivity && analysis.gitActivity.hotFiles.length > 0) {
+    sections.push("## Recently Active Files");
+    sections.push("");
+    sections.push("| File | Commits (90d) | Last Changed |");
+    sections.push("|------|--------------|--------------|");
+    for (const hot of analysis.gitActivity.hotFiles.slice(0, 10)) {
+      sections.push(
+        `| \`${hot.path}\` | ${hot.commits} | ${hot.lastChanged} |`
+      );
+    }
+    sections.push("");
+  }
+  if (analysis?.gitActivity?.changeCoupling && analysis.gitActivity.changeCoupling.length > 0) {
+    sections.push("## Change Coupling");
+    sections.push("");
+    sections.push(
+      "Files that frequently change together. Consider whether they should be colocated or decoupled."
+    );
+    sections.push("");
+    sections.push("| File A | File B | Co-changes | Confidence |");
+    sections.push("|--------|--------|------------|------------|");
+    for (const pair of analysis.gitActivity.changeCoupling) {
+      sections.push(
+        `| \`${pair.fileA}\` | \`${pair.fileB}\` | ${pair.coChangeCount} | ${(pair.confidence * 100).toFixed(0)}% |`
+      );
+    }
+    sections.push("");
+  }
+  if (analysis?.circularDeps && analysis.circularDeps.length > 0) {
+    sections.push("## Circular Dependencies");
+    sections.push("");
+    sections.push(
+      "> These circular import chains may cause unexpected behavior when modified."
+    );
+    sections.push("");
+    for (const dep of analysis.circularDeps) {
+      sections.push(`- ${dep.chain.map((f) => `\`${f}\``).join(" -> ")}`);
+    }
+    sections.push("");
+  }
+  if (analysis?.exportCoverage && analysis.exportCoverage.length > 0) {
+    const underCovered = analysis.exportCoverage.filter((e) => e.coverage < 1);
+    if (underCovered.length > 0) {
+      sections.push("## Export Coverage");
+      sections.push("");
+      sections.push(
+        "Files with unused exports. Consider removing dead exports to reduce surface area."
+      );
+      sections.push("");
+      sections.push("| File | Used | Total | Coverage |");
+      sections.push("|------|------|-------|----------|");
+      for (const entry of underCovered.slice(0, 10)) {
+        sections.push(
+          `| \`${entry.file}\` | ${entry.usedExports} | ${entry.totalExports} | ${(entry.coverage * 100).toFixed(0)}% |`
+        );
+      }
+      sections.push("");
+    }
+  }
+  if (analysis?.communities && analysis.communities.length > 0) {
+    sections.push("## Module Clusters");
+    sections.push("");
+    sections.push(
+      "Automatically detected groups of tightly-connected files."
+    );
+    sections.push("");
+    for (const community of analysis.communities) {
+      sections.push(`- **${community.label}** (${community.files.length} files): ${community.files.map((f) => `\`${f}\``).join(", ")}`);
+    }
+    sections.push("");
+  }
+  if (answers.keyPatterns) {
+    sections.push("## Key Patterns");
+    sections.push("");
+    const patterns = answers.keyPatterns.split(/[.\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const p5 of patterns) {
+      sections.push(`- ${p5}`);
+    }
+    sections.push("");
+  }
+  if (answers.gotchas) {
+    sections.push("## Gotchas");
+    sections.push("");
+    const gotchas = answers.gotchas.split(/[.\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const g of gotchas) {
+      sections.push(`- ${g}`);
+    }
+    sections.push("");
+  }
+  sections.push("## Development");
+  sections.push("");
+  sections.push(buildDevSection(ctx));
+  sections.push("");
+  return sections.join("\n").trimEnd() + "\n";
+}
+function renderArchitectureDiagram(layers, layerEdges) {
+  if (layers.length > 6 || layerEdges.length === 0) {
+    const layerNames = layers.map((l) => `\`${l.name}\``);
+    return "Dependency flow (foundational \u2192 consumer):\n\n" + layerNames.join(" \u2192 ");
+  }
+  const maxPerRow = 3;
+  const rows = [];
+  for (let i = 0; i < layers.length; i += maxPerRow) {
+    rows.push(layers.slice(i, i + maxPerRow));
+  }
+  const boxWidth = 14;
+  const boxOuter = boxWidth + 2;
+  const gap = 4;
+  const layerSet = new Set(layers.map((l) => l.name));
+  const layerRowIndex = /* @__PURE__ */ new Map();
+  const layerColIndex = /* @__PURE__ */ new Map();
+  for (let r = 0; r < rows.length; r++) {
+    for (let c = 0; c < rows[r].length; c++) {
+      layerRowIndex.set(rows[r][c].name, r);
+      layerColIndex.set(rows[r][c].name, c);
+    }
+  }
+  const horizontalEdges = [];
+  const verticalEdges = [];
+  for (const edge of layerEdges) {
+    if (!layerSet.has(edge.from) || !layerSet.has(edge.to)) continue;
+    const fromRow = layerRowIndex.get(edge.from);
+    const toRow = layerRowIndex.get(edge.to);
+    if (fromRow === toRow) {
+      horizontalEdges.push(edge);
+    } else {
+      verticalEdges.push(edge);
+    }
+  }
+  const lines = [];
+  lines.push("```");
+  for (let r = 0; r < rows.length; r++) {
+    const row = rows[r];
+    const topLine = row.map((l) => {
+      const name = l.name;
+      const pad = boxWidth - name.length;
+      return "\u250C" + "\u2500".repeat(boxWidth) + "\u2510";
+    }).join(" ".repeat(gap));
+    lines.push(topLine);
+    const midLine = row.map((l) => {
+      const name = l.name;
+      const padLeft = Math.floor((boxWidth - name.length) / 2);
+      const padRight = boxWidth - name.length - padLeft;
+      return "\u2502" + " ".repeat(padLeft) + name + " ".repeat(padRight) + "\u2502";
+    }).join(" ".repeat(gap));
+    lines.push(midLine);
+    const botLine = row.map(() => "\u2514" + "\u2500".repeat(boxWidth) + "\u2518").join(" ".repeat(gap));
+    lines.push(botLine);
+    if (r < rows.length - 1) {
+      const nextRow = rows[r + 1];
+      const downEdges = verticalEdges.filter((e) => {
+        const fromR = layerRowIndex.get(e.from);
+        const toR = layerRowIndex.get(e.to);
+        return fromR === r && toR === r + 1 || fromR === r + 1 && toR === r;
+      });
+      if (downEdges.length > 0) {
+        const rowWidth = row.length * boxOuter + (row.length - 1) * gap;
+        const arrowLine1 = buildArrowLine(row, "\u2502", boxOuter, gap, rowWidth);
+        const arrowLine2 = buildArrowLine(nextRow.length > row.length ? nextRow : row, "\u25BC", boxOuter, gap, rowWidth);
+        lines.push(arrowLine1);
+        lines.push(arrowLine2);
+      }
+    }
+  }
+  if (horizontalEdges.length > 0) {
+    lines.push("");
+    for (const edge of horizontalEdges) {
+      lines.push(`  ${edge.from} \u2500\u2500\u2500\u2500\u25B6 ${edge.to}`);
+    }
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function buildArrowLine(row, char, boxOuter, gap, _totalWidth) {
+  const parts = [];
+  for (let c = 0; c < row.length; c++) {
+    const center = Math.floor(boxOuter / 2);
+    if (c > 0) {
+      parts.push(" ".repeat(gap));
+    }
+    parts.push(" ".repeat(center) + char + " ".repeat(boxOuter - center - 1));
+  }
+  return parts.join("");
+}
+function getProjectName(ctx) {
+  const dirName = ctx.rootDir.split("/").pop() ?? "Project";
+  return dirName.charAt(0).toUpperCase() + dirName.slice(1);
+}
+function buildTechStackSection(ctx, summary) {
+  const lines = [];
+  if (ctx.frameworks.length > 0) {
+    for (const fw of ctx.frameworks) {
+      const ver = fw.version ? ` ${fw.version}` : "";
+      const usage = fw.importCount != null ? ` (used in ${fw.importCount} file${fw.importCount === 1 ? "" : "s"})` : "";
+      lines.push(`- **${fw.name}**${ver}${usage}`);
+    }
+  }
+  if (ctx.hasTypeScript) {
+    lines.push("- **TypeScript**");
+  }
+  if (ctx.linter !== "none") {
+    const name = ctx.linter.charAt(0).toUpperCase() + ctx.linter.slice(1);
+    lines.push(`- **${name}** (linter/formatter)`);
+  }
+  if (ctx.packageManager !== "none") {
+    lines.push(`- **${ctx.packageManager}** (package manager)`);
+  }
+  if (lines.length === 0) {
+    lines.push(`Stack: ${summary}`);
+  }
+  return lines.join("\n");
+}
+function buildStructureTree(ctx) {
+  const lines = [];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const dir of ctx.directories) {
+    const parts = dir.split("/");
+    if (parts.length === 1) {
+      if (!grouped.has(dir)) grouped.set(dir, []);
+    } else {
+      const parent = parts[0];
+      const child = parts.slice(1).join("/");
+      const children = grouped.get(parent) ?? [];
+      children.push(child);
+      grouped.set(parent, children);
+    }
+  }
+  for (const [dir, children] of grouped) {
+    lines.push(`${dir}/`);
+    for (const child of children) {
+      lines.push(`  ${child}/`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildDevSection(ctx) {
+  const lines = [];
+  switch (ctx.packageManager) {
+    case "pnpm":
+      lines.push("```bash");
+      lines.push("pnpm install");
+      lines.push("pnpm dev");
+      lines.push("```");
+      break;
+    case "yarn":
+      lines.push("```bash");
+      lines.push("yarn install");
+      lines.push("yarn dev");
+      lines.push("```");
+      break;
+    case "bun":
+      lines.push("```bash");
+      lines.push("bun install");
+      lines.push("bun dev");
+      lines.push("```");
+      break;
+    case "npm":
+      lines.push("```bash");
+      lines.push("npm install");
+      lines.push("npm run dev");
+      lines.push("```");
+      break;
+    case "pip":
+    case "poetry":
+      lines.push("```bash");
+      lines.push(
+        ctx.packageManager === "poetry" ? "poetry install" : "pip install -r requirements.txt"
+      );
+      lines.push("```");
+      break;
+    case "cargo":
+      lines.push("```bash");
+      lines.push("cargo build");
+      lines.push("cargo run");
+      lines.push("```");
+      break;
+    case "go":
+      lines.push("```bash");
+      lines.push("go build ./...");
+      lines.push("go run .");
+      lines.push("```");
+      break;
+    default:
+      lines.push("(add your build/run commands here)");
+  }
+  if (ctx.linter !== "none") {
+    lines.push("");
+    lines.push(`Linter: **${ctx.linter}**`);
+  }
+  return lines.join("\n");
+}
+function getMainContextFilename(ide) {
+  switch (ide) {
+    case "claude":
+      return "CLAUDE.md";
+    case "cursor":
+      return "CLAUDE.md";
+    case "opencode":
+      return "AGENTS.md";
+    case "copilot":
+      return ".github/copilot-instructions.md";
+    case "windsurf":
+      return ".windsurfrules";
+    case "cline":
+      return ".clinerules";
+    case "continue":
+      return ".continuerules";
+    case "aider":
+      return ".aider.conf.yml";
+    case "generic":
+      return "CONTEXT.md";
+  }
+}
+
+// src/templates/cursor-rules.ts
+function buildCursorRules(ctx, answers, analysis) {
+  const rules = [];
+  rules.push(buildGlobalRule(ctx, answers, analysis));
+  const hasComponents = ctx.directories.some(
+    (d) => d.endsWith("components") || d.includes("components/")
+  );
+  if (hasComponents) {
+    rules.push(buildComponentsRule(ctx));
+  }
+  const hasServices = ctx.directories.some(
+    (d) => d.endsWith("services") || d.endsWith("api") || d.includes("services/") || d.includes("api/")
+  );
+  if (hasServices) {
+    rules.push(buildServicesRule(ctx));
+  }
+  const hasStores = ctx.directories.some(
+    (d) => d.endsWith("stores") || d.endsWith("store") || d.includes("stores/") || d.includes("store/")
+  );
+  if (hasStores) {
+    rules.push(buildStoresRule(ctx));
+  }
+  return rules;
+}
+function buildGlobalRule(ctx, answers, analysis) {
+  const bodyLines = [
+    "# Global Rules",
+    "",
+    `> Update this rule and the main context file after any architectural or convention change.`,
+    ""
+  ];
+  if (answers.gotchas) {
+    bodyLines.push("## Gotchas");
+    bodyLines.push("");
+    const gotchas = answers.gotchas.split(/[.\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const g of gotchas) {
+      bodyLines.push(`- ${g}`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis?.instabilities && analysis.instabilities.length > 0) {
+    bodyLines.push("## High-Instability Files");
+    bodyLines.push("");
+    bodyLines.push(
+      "> These files have many dependents but also many dependencies (unstable). Changes here have high blast radius."
+    );
+    bodyLines.push("");
+    for (const inst of analysis.instabilities) {
+      bodyLines.push(`- \`${inst.path}\` \u2014 ${(inst.instability * 100).toFixed(0)}% unstable (${inst.fanIn} dependents, ${inst.fanOut} dependencies)`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis?.gitActivity?.changeCoupling && analysis.gitActivity.changeCoupling.length > 0) {
+    bodyLines.push("## Change Coupling");
+    bodyLines.push("");
+    bodyLines.push(
+      "> These file pairs frequently change together. When modifying one, check the other."
+    );
+    bodyLines.push("");
+    for (const pair of analysis.gitActivity.changeCoupling.slice(0, 5)) {
+      bodyLines.push(`- \`${pair.fileA}\` \u2194 \`${pair.fileB}\` (${pair.coChangeCount} co-changes, ${(pair.confidence * 100).toFixed(0)}% confidence)`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis?.circularDeps && analysis.circularDeps.length > 0) {
+    bodyLines.push("## Circular Dependencies");
+    bodyLines.push("");
+    bodyLines.push(
+      "> These circular import chains may cause unexpected behavior. Avoid adding to them."
+    );
+    bodyLines.push("");
+    for (const dep of analysis.circularDeps) {
+      bodyLines.push(`- ${dep.chain.join(" -> ")}`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis?.communities && analysis.communities.length > 0) {
+    bodyLines.push("## Module Clusters");
+    bodyLines.push("");
+    bodyLines.push(
+      "> Tightly-connected file groups. Changes in one file likely affect others in the same cluster."
+    );
+    bodyLines.push("");
+    for (const community of analysis.communities.slice(0, 5)) {
+      bodyLines.push(`- **${community.label}** (${community.files.length} files): ${community.files.map((f) => `\`${f}\``).join(", ")}`);
+    }
+    bodyLines.push("");
+  }
+  const fwHints = getFrameworkHints(ctx);
+  if (fwHints.length > 0) {
+    bodyLines.push("## Framework Conventions");
+    bodyLines.push("");
+    for (const hint of fwHints) {
+      bodyLines.push(hint);
+    }
+    bodyLines.push("");
+  }
+  if (ctx.linter !== "none") {
+    bodyLines.push(
+      `- Linter: **${ctx.linter}**. Run lint before committing.`
+    );
+  }
+  bodyLines.push(
+    "- After any architectural or convention change, update the relevant context files."
+  );
+  const ext = getExtGlob(ctx);
+  return {
+    filename: "global.md",
+    description: "Universal project rules",
+    globs: `**/*.${ext}`,
+    body: bodyLines.join("\n")
+  };
+}
+function buildComponentsRule(ctx) {
+  const compDir = ctx.directories.find(
+    (d) => d.endsWith("components") || d.includes("components/")
+  ) ?? "src/components";
+  const bodyLines = [
+    "# UI Components",
+    "",
+    "> Update this rule when component conventions change.",
+    "",
+    "## Conventions",
+    ""
+  ];
+  const hasReact = ctx.frameworks.some(
+    (f) => f.name === "React" || f.name === "React Native"
+  );
+  const hasTailwind = ctx.frameworks.some(
+    (f) => f.name === "Tailwind CSS" || f.name === "NativeWind"
+  );
+  if (hasReact) {
+    bodyLines.push("- Functional components with hooks (no class components)");
+    bodyLines.push("- Use `memo()` for expensive renders");
+  }
+  if (hasTailwind) {
+    bodyLines.push(
+      "- Use `className` for layout/styling via Tailwind. Inline `style` only for dynamic/theme values."
+    );
+  }
+  bodyLines.push(
+    "- Props interfaces defined adjacent to the component"
+  );
+  bodyLines.push("- Keep components focused -- extract sub-components when complexity grows");
+  const appGlob = ctx.directories.includes("app") ? ", app/**/*.tsx" : "";
+  return {
+    filename: "ui-components.md",
+    description: "Component conventions and patterns",
+    globs: `${compDir}/**/*.{ts,tsx,js,jsx}${appGlob}`,
+    body: bodyLines.join("\n")
+  };
+}
+function buildServicesRule(ctx) {
+  const svcDir = ctx.directories.find(
+    (d) => d.endsWith("services") || d.endsWith("api") || d.includes("services/") || d.includes("api/")
+  ) ?? "src/services";
+  const hooksGlob = ctx.directories.some((d) => d.endsWith("hooks")) ? `, ${ctx.directories.find((d) => d.endsWith("hooks"))}/**/*.{ts,js}` : "";
+  const bodyLines = [
+    "# Services & API Layer",
+    "",
+    "> Update this rule when service patterns or API conventions change.",
+    "",
+    "## Conventions",
+    "",
+    "- Services should be pure functions or classes, not React hooks",
+    "- Error handling: always catch and provide meaningful error messages",
+    "- Keep service functions focused on a single responsibility"
+  ];
+  return {
+    filename: "services.md",
+    description: "Service and API layer patterns",
+    globs: `${svcDir}/**/*.{ts,js}${hooksGlob}`,
+    body: bodyLines.join("\n")
+  };
+}
+function buildStoresRule(ctx) {
+  const storeDir = ctx.directories.find(
+    (d) => d.endsWith("stores") || d.endsWith("store") || d.includes("stores/") || d.includes("store/")
+  ) ?? "src/stores";
+  const bodyLines = [
+    "# State Management",
+    "",
+    "> Update this rule when state patterns change.",
+    "",
+    "## Conventions",
+    ""
+  ];
+  const hasZustand = ctx.frameworks.some((f) => f.name === "Zustand");
+  const hasRedux = ctx.frameworks.some(
+    (f) => f.name === "Redux" || f.name === "Redux Toolkit"
+  );
+  const hasPinia = ctx.frameworks.some((f) => f.name === "Pinia");
+  if (hasZustand) {
+    bodyLines.push(
+      "- **Zustand** slice architecture: each slice is a `StateCreator` accessing full state via `get()`"
+    );
+    bodyLines.push("- Immutable updates: always spread state");
+    bodyLines.push("- Cross-slice access via `get()` (not separate store imports)");
+  } else if (hasRedux) {
+    bodyLines.push("- **Redux Toolkit** slices with `createSlice`");
+    bodyLines.push("- Async logic in thunks (`createAsyncThunk`)");
+    bodyLines.push("- Selectors for reading state, dispatches for writing");
+  } else if (hasPinia) {
+    bodyLines.push("- **Pinia** stores with composition API");
+    bodyLines.push("- Getters for derived state, actions for mutations");
+  } else {
+    bodyLines.push("- Keep state updates immutable");
+    bodyLines.push("- Separate concerns into distinct store modules");
+  }
+  bodyLines.push("- Silent failures for persistence (app should work even if storage fails)");
+  return {
+    filename: "stores.md",
+    description: "State management patterns",
+    globs: `${storeDir}/**/*.{ts,js}`,
+    body: bodyLines.join("\n")
+  };
+}
+function getExtGlob(ctx) {
+  switch (ctx.language) {
+    case "typescript":
+      return "{ts,tsx}";
+    case "javascript":
+      return "{js,jsx}";
+    case "python":
+      return "py";
+    case "go":
+      return "go";
+    case "rust":
+      return "rs";
+    default:
+      return "{ts,tsx,js,jsx}";
+  }
+}
+function renderCursorRule(rule) {
+  return [
+    "---",
+    `description: ${rule.description}`,
+    `globs: ${rule.globs}`,
+    "---",
+    "",
+    rule.body,
+    ""
+  ].join("\n");
+}
+
+// src/templates/claude-skills.ts
+function buildClaudeSkills(ctx, answers, analysis, scripts) {
+  const skills = [];
+  if (scripts) {
+    skills.push(...buildScriptSkills(ctx, scripts));
+  }
+  const archSkill = buildArchitectureSkill(analysis);
+  if (archSkill) skills.push(archSkill);
+  return skills;
+}
+function buildScriptSkills(ctx, scripts) {
+  const skills = [];
+  const scriptMap = {
+    test: { description: "Run the test suite", keywords: ["test", "test:unit", "test:e2e"] },
+    build: { description: "Build the project", keywords: ["build", "build:prod"] },
+    lint: { description: "Run linter", keywords: ["lint", "lint:fix"] },
+    dev: { description: "Start development server", keywords: ["dev", "start:dev"] },
+    typecheck: { description: "Run type checking", keywords: ["typecheck", "type-check", "check-types"] }
+  };
+  const runCmd = getRunCommand(ctx);
+  for (const [skillName, config] of Object.entries(scriptMap)) {
+    const matchedScript = config.keywords.find((kw) => kw in scripts);
+    if (!matchedScript) continue;
+    const command = `${runCmd} ${matchedScript}`;
+    skills.push({
+      name: skillName,
+      description: config.description,
+      disableModelInvocation: true,
+      body: [
+        `# ${config.description}`,
+        "",
+        `Run: \`${command}\``
+      ].join("\n")
+    });
+  }
+  return skills;
+}
+function getRunCommand(ctx) {
+  switch (ctx.packageManager) {
+    case "pnpm":
+      return "pnpm";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun run";
+    case "npm":
+      return "npm run";
+    case "cargo":
+      return "cargo";
+    case "go":
+      return "go";
+    default:
+      return "npm run";
+  }
+}
+function buildArchitectureSkill(analysis) {
+  if (!analysis) return null;
+  const bodyLines = [
+    "# Architecture Explorer",
+    "",
+    "Use this skill to understand the project architecture before making changes.",
+    ""
+  ];
+  if (analysis.hubFiles.length > 0) {
+    bodyLines.push("## Key Files (by centrality)");
+    bodyLines.push("");
+    for (const hub of analysis.hubFiles) {
+      bodyLines.push(`- \`${hub.path}\` \u2014 imported by ${hub.importedBy} file${hub.importedBy === 1 ? "" : "s"}`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis.layers.length > 0) {
+    bodyLines.push("## Architecture Layers");
+    bodyLines.push("");
+    bodyLines.push("Dependency flow (foundational \u2192 consumer):");
+    bodyLines.push("");
+    bodyLines.push(analysis.layers.map((l) => `\`${l.name}\``).join(" \u2192 "));
+    bodyLines.push("");
+  }
+  if (analysis.circularDeps.length > 0) {
+    bodyLines.push("## Circular Dependencies");
+    bodyLines.push("");
+    for (const dep of analysis.circularDeps) {
+      bodyLines.push(`- ${dep.chain.map((f) => `\`${f}\``).join(" -> ")}`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis.communities.length > 0) {
+    bodyLines.push("## Module Clusters");
+    bodyLines.push("");
+    for (const community of analysis.communities) {
+      bodyLines.push(`- **${community.label}** (${community.files.length} files)`);
+    }
+    bodyLines.push("");
+  }
+  if (analysis.hubFiles.length === 0 && analysis.layers.length === 0) {
+    return null;
+  }
+  return {
+    name: "architecture",
+    description: "Explore project architecture and key files",
+    disableModelInvocation: false,
+    allowedTools: "Read, Grep, Glob",
+    body: bodyLines.join("\n")
+  };
+}
+function renderClaudeSkill(skill) {
+  const lines = [
+    "---",
+    `description: ${skill.description}`
+  ];
+  if (skill.disableModelInvocation) {
+    lines.push("disable-model-invocation: true");
+  }
+  if (skill.allowedTools) {
+    lines.push(`allowed-tools: ${skill.allowedTools}`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(skill.body);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/templates/aider-context.ts
+function buildAiderContext(ctx, answers, snapshot, analysis) {
+  const lines = [];
+  lines.push("# .aider.conf.yml \u2014 Generated by codebrief");
+  lines.push("# Keep this file up to date as the project evolves.");
+  lines.push("");
+  const stackSummary = answers.stackConfirmed ? summarizeDetection(ctx) : answers.stackCorrections || summarizeDetection(ctx);
+  lines.push("conventions:");
+  lines.push(`  - "Project: ${escapeYaml(answers.projectPurpose)}"`);
+  lines.push(`  - "Stack: ${escapeYaml(stackSummary)}"`);
+  if (ctx.frameworks.length > 0) {
+    const fws = ctx.frameworks.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`).join(", ");
+    lines.push(`  - "Frameworks: ${escapeYaml(fws)}"`);
+  }
+  if (ctx.packageManager !== "none") {
+    lines.push(`  - "Package manager: ${ctx.packageManager}"`);
+  }
+  if (ctx.linter !== "none") {
+    lines.push(`  - "Linter: ${ctx.linter}"`);
+  }
+  if (ctx.directories.length > 0) {
+    const dirs = ctx.directories.join(", ");
+    lines.push(`  - "Key directories: ${escapeYaml(dirs)}"`);
+  }
+  if (answers.keyPatterns) {
+    const patterns = answers.keyPatterns.split(/[.\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const p5 of patterns) {
+      lines.push(`  - "${escapeYaml(p5)}"`);
+    }
+  }
+  if (answers.gotchas) {
+    const gotchas = answers.gotchas.split(/[.\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const g of gotchas) {
+      lines.push(`  - "GOTCHA: ${escapeYaml(g)}"`);
+    }
+  }
+  const fwHints = getFrameworkHints(ctx);
+  if (fwHints.length > 0) {
+    for (const hint of fwHints) {
+      const trimmed = hint.trim();
+      if (trimmed && trimmed.startsWith("- ")) {
+        lines.push(`  - "${escapeYaml(trimmed.slice(2))}"`);
+      }
+    }
+  }
+  if (ctx.monorepo && ctx.monorepo.packages.length > 0) {
+    lines.push(
+      `  - "Monorepo: ${ctx.monorepo.type} with ${ctx.monorepo.packages.length} packages"`
+    );
+    for (const pkg of ctx.monorepo.packages) {
+      const fws = pkg.frameworks.length > 0 ? ` (${pkg.frameworks.map((f) => f.name).join(", ")})` : "";
+      lines.push(`  - "Package: ${escapeYaml(pkg.name)} at ${escapeYaml(pkg.path)}${escapeYaml(fws)}"`);
+    }
+  }
+  if (analysis?.hubFiles && analysis.hubFiles.length > 0) {
+    lines.push(`  - "Key files (read these first for architecture): ${escapeYaml(analysis.hubFiles.map((h) => h.path).join(", "))}"`);
+  }
+  if (analysis?.layers && analysis.layers.length > 1) {
+    const flow = analysis.layers.map((l) => l.name).join(" \u2192 ");
+    lines.push(`  - "Architecture dependency flow: ${escapeYaml(flow)}"`);
+  }
+  if (analysis?.instabilities && analysis.instabilities.length > 0) {
+    for (const inst of analysis.instabilities) {
+      lines.push(`  - "UNSTABLE: ${escapeYaml(inst.path)} \u2014 ${(inst.instability * 100).toFixed(0)}% unstable (${inst.fanIn} dependents, ${inst.fanOut} deps)"`);
+    }
+  }
+  if (analysis?.gitActivity?.changeCoupling && analysis.gitActivity.changeCoupling.length > 0) {
+    for (const pair of analysis.gitActivity.changeCoupling.slice(0, 5)) {
+      lines.push(`  - "CO-CHANGE: ${escapeYaml(pair.fileA)} <-> ${escapeYaml(pair.fileB)} (${pair.coChangeCount} co-changes, ${(pair.confidence * 100).toFixed(0)}% confidence)"`);
+    }
+  }
+  if (analysis?.circularDeps && analysis.circularDeps.length > 0) {
+    for (const dep of analysis.circularDeps) {
+      lines.push(`  - "CIRCULAR DEP: ${escapeYaml(dep.chain.join(" -> "))}"`);
+    }
+  }
+  if (analysis?.gitActivity && analysis.gitActivity.hotFiles.length > 0) {
+    const hot = analysis.gitActivity.hotFiles.slice(0, 5).map((h) => `${h.path} (${h.commits} commits)`).join(", ");
+    lines.push(`  - "Recently active: ${escapeYaml(hot)}"`);
+  }
+  if (snapshot?.markdown) {
+    lines.push("");
+    lines.push(
+      "# CODE SNAPSHOT (auto-generated, update when types/stores/services change)"
+    );
+    lines.push("# Formatted as a multi-line read block for Aider context.");
+    lines.push("read:");
+    lines.push(
+      "  # To include the code snapshot, create a file and add it here:"
+    );
+    lines.push("  # - .aider.context.md");
+    lines.push("");
+    lines.push("# --- Code Snapshot (for reference) ---");
+    for (const line of snapshot.markdown.split("\n")) {
+      lines.push(`# ${line}`);
+    }
+    lines.push("# --- /Code Snapshot ---");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function escapeYaml(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/generate.ts
+async function generateFiles(ctx, answers, snapshot, force = false, dryRun = false, analysis, generateSkills = false, onVerbose) {
+  const files = [];
+  const mainFilename = getMainContextFilename(answers.ide);
+  const mainPath = path5.join(ctx.rootDir, mainFilename);
+  const mainContent = answers.ide === "aider" ? buildAiderContext(ctx, answers, snapshot, analysis) : buildMainContext(ctx, answers, snapshot, analysis);
+  files.push({
+    path: mainFilename,
+    content: mainContent,
+    existed: await fileExists(mainPath)
+  });
+  onVerbose?.(`Prepared ${mainFilename} (${mainContent.length} bytes)`);
+  if (answers.ide === "cursor") {
+    const rules = buildCursorRules(ctx, answers, analysis);
+    for (const rule of rules) {
+      const rulePath = `.cursor/rules/${rule.filename}`;
+      const absPath = path5.join(ctx.rootDir, rulePath);
+      const ruleContent = renderCursorRule(rule);
+      files.push({
+        path: rulePath,
+        content: ruleContent,
+        existed: await fileExists(absPath)
+      });
+      onVerbose?.(`Prepared ${rulePath} (${ruleContent.length} bytes)`);
+    }
+  }
+  if (generateSkills) {
+    const pkgJson = await readJsonFile(path5.join(ctx.rootDir, "package.json"));
+    const scripts = pkgJson?.scripts ?? void 0;
+    const skills = buildClaudeSkills(ctx, answers, analysis, scripts);
+    for (const skill of skills) {
+      const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
+      const absPath = path5.join(ctx.rootDir, skillPath);
+      const skillContent = renderClaudeSkill(skill);
+      files.push({
+        path: skillPath,
+        content: skillContent,
+        existed: await fileExists(absPath)
+      });
+      onVerbose?.(`Prepared ${skillPath} (${skillContent.length} bytes)`);
+    }
+  }
+  if (answers.ide === "opencode") {
+    const claudePath = path5.join(ctx.rootDir, "CLAUDE.md");
+    const claudeExists = await fileExists(claudePath);
+    if (!claudeExists) {
+      files.push({
+        path: "CLAUDE.md",
+        content: `# ${path5.basename(ctx.rootDir)}
+
+> See AGENTS.md for full project context.
+`,
+        existed: false
+      });
+    }
+  }
+  if (answers.generatePerPackage && ctx.monorepo && ctx.monorepo.packages.length > 0) {
+    const pkgMainFilename = answers.ide === "aider" ? ".aider.conf.yml" : getMainContextFilename(answers.ide);
+    for (const pkg of ctx.monorepo.packages) {
+      const pkgRootDir = path5.join(ctx.rootDir, pkg.path);
+      const pkgCtx = await detectContext(pkgRootDir);
+      let pkgSnapshot = null;
+      if (answers.generateSnapshot) {
+        pkgSnapshot = await generateSnapshot(pkgCtx, []);
+        if (pkgSnapshot.entries.length === 0) pkgSnapshot = null;
+      }
+      const pkgAnswers = {
+        ...answers,
+        projectPurpose: `${pkg.name} \u2014 part of the ${path5.basename(ctx.rootDir)} monorepo. ${answers.projectPurpose}`,
+        generatePerPackage: false
+        // don't recurse
+      };
+      const pkgContent = answers.ide === "aider" ? buildAiderContext(pkgCtx, pkgAnswers, pkgSnapshot) : buildMainContext(pkgCtx, pkgAnswers, pkgSnapshot);
+      const pkgFilePath = path5.join(pkg.path, pkgMainFilename);
+      const pkgAbsPath = path5.join(ctx.rootDir, pkgFilePath);
+      files.push({
+        path: pkgFilePath,
+        content: pkgContent,
+        existed: await fileExists(pkgAbsPath)
+      });
+    }
+  }
+  if (dryRun) {
+    return files;
+  }
+  const existingFiles = files.filter((f) => f.existed);
+  if (existingFiles.length > 0 && !force) {
+    p2.log.warn(
+      `The following files already exist:
+${existingFiles.map((f) => `  - ${f.path}`).join("\n")}`
+    );
+    const overwrite = await p2.confirm({
+      message: "Overwrite existing files?"
+    });
+    if (p2.isCancel(overwrite) || !overwrite) {
+      const newFiles = files.filter((f) => !f.existed);
+      if (newFiles.length === 0) {
+        p2.log.info("No new files to write. Exiting.");
+        return [];
+      }
+      p2.log.info(`Writing ${newFiles.length} new file(s), skipping existing.`);
+      for (const file of newFiles) {
+        await writeFileSafe(path5.join(ctx.rootDir, file.path), file.content);
+      }
+      return newFiles;
+    }
+  }
+  for (const file of files) {
+    await writeFileSafe(path5.join(ctx.rootDir, file.path), file.content);
+    onVerbose?.(`Wrote ${file.path}`);
+  }
+  return files;
+}
+
+// src/summary.ts
+init_utils();
+import pc from "picocolors";
+function printSummary(files, ctx, snapshot, analysis) {
+  if (files.length === 0) return;
+  console.log("");
+  console.log(pc.bold("  Files created:"));
+  console.log("");
+  let totalBytes = 0;
+  let totalTokens = 0;
+  let alwaysOnTokens = 0;
+  let scopedRuleTokens = [];
+  const mainFiles = files.filter((f) => !f.path.includes(".cursor/rules/"));
+  const ruleFiles = files.filter((f) => f.path.includes(".cursor/rules/"));
+  const fileRows = [];
+  for (const file of mainFiles) {
+    const bytes = Buffer.byteLength(file.content, "utf-8");
+    const tokens = estimateTokens(file.content);
+    totalBytes += bytes;
+    totalTokens += tokens;
+    alwaysOnTokens += tokens;
+    fileRows.push({
+      indent: "    ",
+      name: file.path,
+      size: formatBytes(bytes),
+      tokens: `(~${formatNumber(tokens)} tokens)`,
+      isUpdated: !!file.existed,
+      isHeader: false
+    });
+  }
+  if (ruleFiles.length > 0) {
+    fileRows.push({
+      indent: "    ",
+      name: ".cursor/rules/",
+      size: "",
+      tokens: "",
+      isUpdated: false,
+      isHeader: true
+    });
+    for (const file of ruleFiles) {
+      const bytes = Buffer.byteLength(file.content, "utf-8");
+      const tokens = estimateTokens(file.content);
+      totalBytes += bytes;
+      totalTokens += tokens;
+      const filename = file.path.split("/").pop() ?? file.path;
+      const isGlobal = filename === "global.md";
+      if (isGlobal) {
+        alwaysOnTokens += tokens;
+      } else {
+        scopedRuleTokens.push(tokens);
+      }
+      fileRows.push({
+        indent: "      ",
+        name: filename,
+        size: formatBytes(bytes),
+        tokens: `(~${formatNumber(tokens)} tokens)`,
+        isUpdated: !!file.existed,
+        isHeader: false
+      });
+    }
+  }
+  const dataFileRows = fileRows.filter((r) => !r.isHeader);
+  const maxNameCol = Math.max(...fileRows.map((r) => r.indent.length + r.name.length));
+  const maxSizeWidth = Math.max(...dataFileRows.map((r) => r.size.length));
+  const maxTokenWidth = Math.max(...dataFileRows.map((r) => r.tokens.length));
+  for (const row of fileRows) {
+    if (row.isHeader) {
+      console.log(`${row.indent}${pc.cyan(row.name)}`);
+    } else {
+      const status = row.isUpdated ? pc.yellow("(updated)") : pc.green("(new)");
+      const paddedName = row.name.padEnd(maxNameCol - row.indent.length);
+      console.log(
+        `${row.indent}${pc.cyan(paddedName)}  ${row.size.padStart(maxSizeWidth)}  ${pc.dim(row.tokens.padEnd(maxTokenWidth))}  ${status}`
+      );
+    }
+  }
+  console.log("");
+  console.log(
+    pc.dim(
+      `    Total: ${formatBytes(totalBytes)}, ~${formatNumber(totalTokens)} tokens`
+    )
+  );
+  if (snapshot?.budgetExcluded && snapshot.budgetExcluded > 0) {
+    console.log(
+      pc.dim(
+        `    (${snapshot.budgetExcluded} snapshot entries excluded by token budget)`
+      )
+    );
+  }
+  if (analysis) {
+    const parts = [];
+    if (analysis.hubFiles.length > 0) parts.push(`${analysis.hubFiles.length} key files`);
+    if (analysis.layers.length > 0) parts.push(`${analysis.layers.length} architecture layers`);
+    if (analysis.circularDeps.length > 0) parts.push(`${analysis.circularDeps.length} circular deps`);
+    if (analysis.communities.length > 0) parts.push(`${analysis.communities.length} module clusters`);
+    if (analysis.gitActivity) parts.push(`${analysis.gitActivity.hotFiles.length} recently active files`);
+    if (parts.length > 0) {
+      console.log(
+        pc.dim(`    Includes: ${parts.join(", ")}`)
+      );
+    }
+  }
+  console.log("");
+  console.log(pc.bold("  Estimated context cost per conversation:"));
+  console.log("");
+  const explorationTokens = estimateExplorationCost(ctx);
+  const avgScopedTokens = scopedRuleTokens.length > 0 ? Math.round(
+    scopedRuleTokens.reduce((a, b) => a + b, 0) / scopedRuleTokens.length
+  ) : 0;
+  const residualExploration = Math.round(explorationTokens * 0.05);
+  const afterTotal = alwaysOnTokens + avgScopedTokens + residualExploration;
+  const savings = Math.round(
+    (explorationTokens - afterTotal) / explorationTokens * 100
+  );
+  const costRows = [
+    { label: "Always loaded", desc: "main context + global rule", value: `~${formatNumber(alwaysOnTokens)} tokens` }
+  ];
+  if (avgScopedTokens > 0) {
+    costRows.push({ label: "Per-task (avg)", desc: "1 scoped rule", value: `~${formatNumber(avgScopedTokens)} tokens` });
+  }
+  costRows.push({ label: "Exploration", desc: "mostly eliminated", value: `~${formatNumber(residualExploration)} tokens` });
+  const maxCostLabel = Math.max(...costRows.map((r) => r.label.length));
+  const maxCostDesc = Math.max(...costRows.map((r) => r.desc.length));
+  const maxCostValue = Math.max(...costRows.map((r) => r.value.length));
+  const afterContentWidth = maxCostLabel + 3 + maxCostDesc + 2 + maxCostValue;
+  const beforeValue = `~${formatNumber(explorationTokens)} tokens`;
+  const beforeLabel = "Exploration to understand codebase";
+  const beforeGap = afterContentWidth - beforeLabel.length - beforeValue.length;
+  console.log(pc.dim("    Before (no context files):"));
+  if (beforeGap >= 2) {
+    console.log(
+      `      ${beforeLabel}${" ".repeat(beforeGap)}${pc.red(beforeValue)}`
+    );
+  } else {
+    console.log(
+      `      ${beforeLabel}  ${pc.red(beforeValue)}`
+    );
+  }
+  console.log("");
+  console.log(pc.dim("    After:"));
+  for (const row of costRows) {
+    console.log(
+      `      ${row.label.padEnd(maxCostLabel)}   ${row.desc.padEnd(maxCostDesc)}  ${pc.green(row.value.padStart(maxCostValue))}`
+    );
+  }
+  const totalText = `Total: ~${formatNumber(afterTotal)} tokens`;
+  const totalPad = afterContentWidth > totalText.length ? " ".repeat(afterContentWidth - totalText.length) : "";
+  console.log(
+    `      ${totalPad}${pc.bold(totalText)}`
+  );
+  console.log("");
+  if (savings > 0) {
+    console.log(
+      pc.green(
+        `    Estimated savings: ~${savings}% fewer tokens before real work begins`
+      )
+    );
+  }
+  if (analysis) {
+    console.log("");
+    console.log(pc.bold("  What we analyzed:"));
+    const recapRows = [];
+    if (analysis.hubFiles.length > 0) {
+      recapRows.push({ label: "PageRank hub detection", result: `found ${analysis.hubFiles.length} key architectural files` });
+    }
+    recapRows.push({
+      label: "Tarjan cycle detection",
+      result: analysis.circularDeps.length === 0 ? "no circular dependencies found" : `${analysis.circularDeps.length} circular dep${analysis.circularDeps.length === 1 ? "" : "s"} found`
+    });
+    if (analysis.layers.length > 0) {
+      const tierNames = analysis.layers.map((l) => l.name).join(" \u2192 ");
+      recapRows.push({ label: "Layer analysis", result: `${analysis.layers.length} tiers: ${tierNames}` });
+    }
+    if (analysis.gitActivity) {
+      const coupledPairs = analysis.gitActivity.changeCoupling.length;
+      recapRows.push({
+        label: "Git history (90 days)",
+        result: `${analysis.gitActivity.hotFiles.length} hot files, ${coupledPairs} change-coupled pair${coupledPairs === 1 ? "" : "s"}`
+      });
+    }
+    const ec = analysis.exportCoverage;
+    if (ec && ec.length > 0) {
+      const totalExports = ec.reduce((sum, e) => sum + e.totalExports, 0);
+      const totalUsed = ec.reduce((sum, e) => sum + e.usedExports, 0);
+      const coveragePct = totalExports > 0 ? Math.round(totalUsed / totalExports * 100) : 100;
+      const unused = totalExports - totalUsed;
+      recapRows.push({ label: "Export coverage", result: `${coveragePct}% (${unused} unused export${unused === 1 ? "" : "s"})` });
+    }
+    if (analysis.communities.length > 0) {
+      recapRows.push({ label: "Community detection", result: `${analysis.communities.length} module cluster${analysis.communities.length === 1 ? "" : "s"}` });
+    }
+    const maxRecapLabel = Math.max(...recapRows.map((r) => r.label.length));
+    for (const row of recapRows) {
+      console.log(
+        pc.dim(`    ${row.label.padEnd(maxRecapLabel)} \u2192 ${row.result}`)
+      );
+    }
+  }
+  const exportCoverage = analysis?.exportCoverage;
+  if (exportCoverage && exportCoverage.length > 0) {
+    const totalExports = exportCoverage.reduce((sum, e) => sum + e.totalExports, 0);
+    const totalUsed = exportCoverage.reduce((sum, e) => sum + e.usedExports, 0);
+    const unusedExports = totalExports - totalUsed;
+    const coveragePct = totalExports > 0 ? Math.round(totalUsed / totalExports * 100) : 100;
+    const filesWithUnused = exportCoverage.filter((e) => e.usedExports < e.totalExports).length;
+    if (unusedExports > 0) {
+      console.log("");
+      console.log(
+        pc.dim(
+          `    Export coverage: ${coveragePct}% of exports are used (${unusedExports} unused exports in ${filesWithUnused} file${filesWithUnused === 1 ? "" : "s"})`
+        )
+      );
+    }
+  }
+  console.log("");
+}
+function estimateExplorationCost(ctx) {
+  if (ctx.totalSourceBytes === 0 || ctx.sourceFileCount === 0) {
+    return 15e3;
+  }
+  const bytesRead = ctx.totalSourceBytes * 0.4;
+  const readTokens = Math.ceil(bytesRead / 3.2);
+  const overhead = Math.ceil(readTokens * 0.3);
+  return Math.max(5e3, readTokens + overhead);
+}
+function formatNumber(n) {
+  if (n >= 1e3) {
+    return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}k`;
+  }
+  return String(n);
+}
+
+// src/config.ts
+init_utils();
+import { createHash } from "crypto";
+import path6 from "path";
+import fg4 from "fast-glob";
+var CONFIG_FILENAME = ".codebrief.json";
+var CONFIG_VERSION = 1;
+async function loadConfig(rootDir) {
+  const configPath = path6.join(rootDir, CONFIG_FILENAME);
+  const raw = await readJsonFile(configPath);
+  if (!raw) return null;
+  const cfg = raw;
+  if (!cfg.ide || !cfg.projectPurpose) return null;
+  return {
+    ide: cfg.ide,
+    projectPurpose: cfg.projectPurpose,
+    keyPatterns: cfg.keyPatterns ?? "",
+    gotchas: cfg.gotchas ?? "",
+    generateSnapshot: cfg.generateSnapshot ?? false,
+    snapshotPaths: cfg.snapshotPaths ?? [],
+    stackCorrections: cfg.stackCorrections ?? "",
+    generatePerPackage: cfg.generatePerPackage ?? false,
+    snapshotHash: cfg.snapshotHash,
+    snapshotGeneratedAt: cfg.snapshotGeneratedAt,
+    language: cfg.language
+  };
+}
+async function saveConfig(rootDir, answers, snapshotHash, language) {
+  const configPath = path6.join(rootDir, CONFIG_FILENAME);
+  const cfg = {
+    _version: CONFIG_VERSION,
+    ide: answers.ide,
+    projectPurpose: answers.projectPurpose,
+    keyPatterns: answers.keyPatterns,
+    gotchas: answers.gotchas,
+    generateSnapshot: answers.generateSnapshot,
+    snapshotPaths: answers.snapshotPaths,
+    stackCorrections: answers.stackCorrections,
+    generatePerPackage: answers.generatePerPackage,
+    ...snapshotHash ? { snapshotHash, snapshotGeneratedAt: Date.now() } : {},
+    ...language ? { language } : {}
+  };
+  await writeFileSafe(configPath, JSON.stringify(cfg, null, 2) + "\n");
+}
+function configToAnswers(config) {
+  return {
+    ide: config.ide,
+    projectPurpose: config.projectPurpose,
+    keyPatterns: config.keyPatterns,
+    gotchas: config.gotchas,
+    generateSnapshot: config.generateSnapshot,
+    snapshotPaths: config.snapshotPaths,
+    stackConfirmed: true,
+    stackCorrections: config.stackCorrections,
+    generatePerPackage: config.generatePerPackage
+  };
+}
+async function computeSnapshotHash(rootDir, language) {
+  const extMap = {
+    typescript: ["**/*.{ts,tsx}"],
+    javascript: ["**/*.{js,jsx,mjs}"],
+    python: ["**/*.py"],
+    go: ["**/*.go"],
+    rust: ["**/*.rs"],
+    java: ["**/*.java"],
+    other: ["**/*.{ts,tsx,js,jsx,py,go,rs}"]
+  };
+  const files = await fg4(extMap[language] ?? extMap.other, {
+    cwd: rootDir,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/target/**",
+      "**/vendor/**"
+    ],
+    stats: true,
+    absolute: false
+  });
+  const entries = files.map((f) => `${f.path}:${f.stats?.mtimeMs ?? 0}`).sort();
+  const hash = createHash("sha256").update(entries.join("\n")).digest("hex").slice(0, 16);
+  return hash;
+}
+
+// src/refresh.ts
+import path7 from "path";
+import * as p3 from "@clack/prompts";
+import pc2 from "picocolors";
+init_utils();
+var CONTEXT_FILES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".github/copilot-instructions.md",
+  ".windsurfrules",
+  ".clinerules",
+  ".continuerules",
+  "CONTEXT.md"
+];
+var MD_START = /<!-- CODE SNAPSHOT[^>]*-->/;
+var MD_END = /<!-- \/CODE SNAPSHOT -->/;
+var AIDER_START = /^# --- Code Snapshot/m;
+var AIDER_END = /^# --- \/Code Snapshot ---$/m;
+async function findContextFile(rootDir) {
+  const aiderPath = path7.join(rootDir, ".aider.conf.yml");
+  if (await fileExists(aiderPath)) {
+    const content = await readFileOr(aiderPath);
+    if (content && AIDER_START.test(content)) {
+      return { path: ".aider.conf.yml", isAider: true };
+    }
+  }
+  for (const file of CONTEXT_FILES) {
+    const absPath = path7.join(rootDir, file);
+    if (await fileExists(absPath)) {
+      return { path: file, isAider: false };
+    }
+  }
+  return null;
+}
+async function refreshSnapshot(rootDir) {
+  const spinner3 = p3.spinner();
+  const found = await findContextFile(rootDir);
+  if (!found) {
+    p3.log.error(
+      "No context file found. Run " + pc2.cyan("codebrief") + " first to generate one."
+    );
+    process.exit(1);
+  }
+  const absPath = path7.join(rootDir, found.path);
+  const content = await readFileOr(absPath);
+  if (!content) {
+    p3.log.error(`Could not read ${found.path}`);
+    process.exit(1);
+  }
+  if (found.isAider) {
+    if (!AIDER_START.test(content) || !AIDER_END.test(content)) {
+      p3.log.error(
+        `No code snapshot markers found in ${found.path}. Re-generate the file with code snapshot enabled.`
+      );
+      process.exit(1);
+    }
+  } else {
+    if (!MD_START.test(content) || !MD_END.test(content)) {
+      p3.log.error(
+        `No code snapshot markers found in ${found.path}. Re-generate the file with code snapshot enabled.`
+      );
+      process.exit(1);
+    }
+  }
+  p3.log.info(`Refreshing snapshot in ${pc2.cyan(found.path)}`);
+  spinner3.start("Scanning source files...");
+  const progress = (msg) => spinner3.message(msg);
+  const detected = await detectContext(rootDir, progress);
+  const graph = await buildImportGraph(rootDir, detected.language, progress);
+  const config = await loadConfig(rootDir);
+  const snapshotPaths = config?.snapshotPaths ?? [];
+  const snapshot = await generateSnapshot(detected, snapshotPaths, graph, void 0, progress);
+  spinner3.stop(
+    snapshot.entries.length > 0 ? `Found ${snapshot.entries.length} type${snapshot.entries.length === 1 ? "" : "s"}/signature${snapshot.entries.length === 1 ? "" : "s"}.` : "No extractable types found."
+  );
+  if (snapshot.entries.length === 0) {
+    p3.log.warn("No types found \u2014 snapshot section will be empty.");
+  }
+  let updated;
+  if (found.isAider) {
+    const startMatch = content.match(AIDER_START);
+    const endMatch = content.match(AIDER_END);
+    if (!startMatch || !endMatch) {
+      p3.log.error("Failed to parse snapshot markers.");
+      process.exit(1);
+    }
+    const startIdx = content.indexOf(startMatch[0]);
+    const endIdx = content.indexOf(endMatch[0]) + endMatch[0].length;
+    let newBlock = "# --- Code Snapshot (for reference) ---";
+    if (snapshot.markdown) {
+      for (const line of snapshot.markdown.split("\n")) {
+        newBlock += `
+# ${line}`;
+      }
+    }
+    newBlock += "\n# --- /Code Snapshot ---";
+    updated = content.slice(0, startIdx) + newBlock + content.slice(endIdx);
+  } else {
+    const startMatch = content.match(MD_START);
+    const endMatch = content.match(MD_END);
+    if (!startMatch || !endMatch) {
+      p3.log.error("Failed to parse snapshot markers.");
+      process.exit(1);
+    }
+    const startIdx = content.indexOf(startMatch[0]);
+    const endIdx = content.indexOf(endMatch[0]) + endMatch[0].length;
+    let newBlock = "<!-- CODE SNAPSHOT (auto-generated, update when types/stores/services change) -->";
+    if (snapshot.markdown) {
+      newBlock += "\n\n" + snapshot.markdown + "\n";
+    }
+    newBlock += "\n<!-- /CODE SNAPSHOT -->";
+    updated = content.slice(0, startIdx) + newBlock + content.slice(endIdx);
+  }
+  await writeFileSafe(absPath, updated);
+  p3.log.success(`Updated snapshot in ${pc2.cyan(found.path)}`);
+}
+
+// src/git-analysis.ts
+import { execSync } from "child_process";
+function analyzeGitActivity(rootDir, onProgress) {
+  try {
+    onProgress?.("Analyzing git history (last 90 days)...");
+    const logOutput = execSync(
+      'git log --since="90 days ago" --name-only --pretty=format:""',
+      { cwd: rootDir, encoding: "utf-8", timeout: 1e4 }
+    );
+    const commitCounts = /* @__PURE__ */ new Map();
+    for (const line of logOutput.split("\n")) {
+      const file = line.trim();
+      if (file && !file.startsWith("commit ")) {
+        commitCounts.set(file, (commitCounts.get(file) ?? 0) + 1);
+      }
+    }
+    if (commitCounts.size === 0) {
+      return null;
+    }
+    onProgress?.(`Found activity in ${commitCounts.size} files`);
+    const sorted = [...commitCounts.entries()].sort((a, b) => b[1] - a[1]);
+    const hotFiles = [];
+    for (const [filePath, commits] of sorted.slice(0, 15)) {
+      let lastChanged = "";
+      try {
+        lastChanged = execSync(
+          `git log -1 --format="%ar" -- "${filePath}"`,
+          { cwd: rootDir, encoding: "utf-8", timeout: 5e3 }
+        ).trim();
+      } catch {
+      }
+      hotFiles.push({ path: filePath, commits, lastChanged });
+    }
+    onProgress?.("Analyzing change coupling...");
+    const changeCoupling = analyzeChangeCoupling(rootDir);
+    return { commitCounts, hotFiles, changeCoupling };
+  } catch {
+    return null;
+  }
+}
+function analyzeChangeCoupling(rootDir) {
+  try {
+    const hashOutput = execSync(
+      'git log --format="%H" --since="90 days ago"',
+      { cwd: rootDir, encoding: "utf-8", timeout: 1e4 }
+    ).trim();
+    if (!hashOutput) return [];
+    const hashes = hashOutput.split("\n").filter(Boolean);
+    if (hashes.length === 0) return [];
+    const filesPerCommit = [];
+    const commitCountPerFile = /* @__PURE__ */ new Map();
+    for (const hash of hashes) {
+      try {
+        const filesOutput = execSync(
+          `git show --name-only --format="" ${hash}`,
+          { cwd: rootDir, encoding: "utf-8", timeout: 5e3 }
+        ).trim();
+        const files = filesOutput.split("\n").map((f) => f.trim()).filter(Boolean);
+        if (files.length >= 2 && files.length <= 20) {
+          filesPerCommit.push(files);
+          for (const file of files) {
+            commitCountPerFile.set(file, (commitCountPerFile.get(file) ?? 0) + 1);
+          }
+        }
+      } catch {
+      }
+    }
+    const coChanges = /* @__PURE__ */ new Map();
+    for (const files of filesPerCommit) {
+      for (let i = 0; i < files.length; i++) {
+        for (let j = i + 1; j < files.length; j++) {
+          const key = [files[i], files[j]].sort().join("||");
+          coChanges.set(key, (coChanges.get(key) ?? 0) + 1);
+        }
+      }
+    }
+    const results = [];
+    const totalCommits = filesPerCommit.length;
+    for (const [key, coChangeCount] of coChanges) {
+      if (coChangeCount < 3) continue;
+      const [fileA, fileB] = key.split("||");
+      const commitsA = commitCountPerFile.get(fileA) ?? 0;
+      const commitsB = commitCountPerFile.get(fileB) ?? 0;
+      const confidence = coChangeCount / Math.max(commitsA, commitsB);
+      const support = coChangeCount / totalCommits;
+      if (confidence >= 0.5) {
+        results.push({ fileA, fileB, coChangeCount, support, confidence });
+      }
+    }
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results.slice(0, 10);
+  } catch {
+    return [];
+  }
+}
+
+// src/index.ts
+init_utils();
+async function main() {
+  const startTime = performance.now();
+  const args = process.argv.slice(2);
+  const force = args.includes("--force");
+  const dryRun = args.includes("--dry-run");
+  const refresh = args.includes("--refresh-snapshot");
+  const reconfigure = args.includes("--reconfigure");
+  const check = args.includes("--check");
+  const verbose = args.includes("--verbose") || args.includes("-v");
+  const generateSkills = args.includes("--generate-skills");
+  const maxTokensArg = args.find((a) => a.startsWith("--max-tokens="));
+  const maxTokens = maxTokensArg ? parseInt(maxTokensArg.split("=")[1], 10) : void 0;
+  const targetDir = args.find((a) => !a.startsWith("-") && a !== "-v") ?? process.cwd();
+  const rootDir = path8.resolve(targetDir);
+  const verboseLog = (msg) => {
+    if (verbose) p4.log.info(pc3.dim(msg));
+  };
+  if (check) {
+    const config = await loadConfig(rootDir);
+    if (!config?.snapshotHash) {
+      process.exit(0);
+    }
+    const lang = config.language ?? "other";
+    const currentHash = await computeSnapshotHash(rootDir, lang);
+    if (currentHash !== config.snapshotHash) {
+      const daysSince = config.snapshotGeneratedAt ? Math.floor((Date.now() - config.snapshotGeneratedAt) / (1e3 * 60 * 60 * 24)) : 0;
+      const staleMsg = daysSince > 0 ? ` (last generated ${daysSince}d ago)` : "";
+      console.log(`codebrief: snapshot is stale${staleMsg}. Run npx codebrief --refresh-snapshot`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  console.log("");
+  p4.intro(pc3.bold(" codebrief "));
+  if (refresh) {
+    await refreshSnapshot(rootDir);
+    p4.outro(pc3.green("Snapshot refreshed!"));
+    return;
+  }
+  if (dryRun) {
+    p4.log.warn(pc3.yellow("DRY RUN \u2014 no files will be written"));
+  }
+  p4.log.info(`Analyzing ${pc3.cyan(rootDir)}`);
+  const spinner3 = p4.spinner();
+  const spinnerProgress = (msg) => spinner3.message(msg);
+  spinner3.start("Detecting tech stack...");
+  const detected = await detectContext(rootDir, spinnerProgress);
+  spinner3.stop("Detection complete.");
+  spinner3.start(`Building import graph (${detected.sourceFileCount} files)...`);
+  const graph = await buildImportGraph(rootDir, detected.language, verbose ? verboseLog : spinnerProgress);
+  const topHub = getHubFiles(graph, 1)[0];
+  spinner3.stop(
+    `Import graph: ${graph.edges.length} edges, ${graph.externalImportCounts.size} packages.` + (topHub ? ` Top hub: ${topHub.path}` : "")
+  );
+  detected.frameworks = enrichFrameworksWithUsage(
+    detected.frameworks,
+    graph.externalImportCounts
+  );
+  {
+    const lines = [];
+    const lang = detected.hasTypeScript ? "TypeScript" : detected.language !== "other" ? detected.language.charAt(0).toUpperCase() + detected.language.slice(1) : "";
+    if (lang) lines.push(`  Language:   ${lang}`);
+    if (detected.frameworks.length > 0) {
+      lines.push(`  Frameworks: ${detected.frameworks.map((f) => f.name).join(", ")}`);
+    }
+    if (detected.linter !== "none") {
+      lines.push(`  Linter:     ${detected.linter.charAt(0).toUpperCase() + detected.linter.slice(1)}`);
+    }
+    if (detected.packageManager !== "none") {
+      lines.push(`  Pkg mgr:    ${detected.packageManager}`);
+    }
+    if (detected.testFramework) {
+      lines.push(`  Testing:    ${detected.testFramework}`);
+    }
+    if (detected.ciProvider) {
+      lines.push(`  CI:         ${detected.ciProvider}`);
+    }
+    if (detected.monorepo) {
+      lines.push(`  Monorepo:   ${detected.monorepo.type} (${detected.monorepo.packages.length} package${detected.monorepo.packages.length === 1 ? "" : "s"})`);
+    }
+    if (detected.sourceFileCount > 0) {
+      lines.push(`  Files:      ${detected.sourceFileCount} (${formatBytes(detected.totalSourceBytes)})`);
+    }
+    if (lines.length > 0) {
+      p4.note(lines.join("\n"), "Detected Stack");
+    }
+  }
+  const fileCount = graph.centrality.size;
+  spinner3.start(`Running PageRank on ${fileCount} files...`);
+  const hubFiles = getHubFiles(graph);
+  verboseLog(`PageRank: found ${hubFiles.length} hub files`);
+  spinner3.message("Finding circular dependencies...");
+  const circularDeps = findCircularDeps(graph);
+  verboseLog(`Tarjan SCC: ${circularDeps.length === 0 ? "no cycles found" : `${circularDeps.length} cycle(s)`}`);
+  spinner3.message("Detecting architecture layers...");
+  const { layers, layerEdges } = detectArchitecturalLayers(graph);
+  verboseLog(`Layers: ${layers.map((l) => l.name).join(", ") || "none detected"}`);
+  spinner3.message("Computing instability metrics...");
+  const instabilities = computeInstability(graph);
+  verboseLog(`Instability: ${instabilities.length} high-risk file(s)`);
+  spinner3.message("Detecting module communities...");
+  const communities = detectCommunities(graph);
+  verboseLog(`Communities: ${communities.length} cluster(s)`);
+  spinner3.message("Computing export coverage...");
+  const exportCoverage = computeExportCoverage(graph);
+  verboseLog(`Export coverage: ${exportCoverage.length} files analyzed`);
+  spinner3.message("Analyzing git history...");
+  const gitActivity = detected.isGitRepo ? analyzeGitActivity(rootDir, verbose ? verboseLog : spinnerProgress) : null;
+  if (gitActivity) verboseLog(`Git: ${gitActivity.hotFiles.length} active files, ${gitActivity.changeCoupling.length} coupled pairs`);
+  const analysis = { hubFiles, circularDeps, layers, layerEdges, gitActivity, instabilities, communities, exportCoverage };
+  const analysisParts = [];
+  if (hubFiles.length > 0) analysisParts.push(`${hubFiles.length} hub files`);
+  if (layers.length > 0) analysisParts.push(`${layers.length} layers`);
+  if (circularDeps.length > 0) analysisParts.push(`${circularDeps.length} circular dep${circularDeps.length === 1 ? "" : "s"}`);
+  if (communities.length > 0) analysisParts.push(`${communities.length} module cluster${communities.length === 1 ? "" : "s"}`);
+  if (gitActivity) analysisParts.push(`${gitActivity.hotFiles.length} active files`);
+  spinner3.stop(
+    analysisParts.length > 0 ? `Analysis: ${analysisParts.join(", ")}.` : "Analysis complete."
+  );
+  const savedConfig = await loadConfig(rootDir);
+  if (savedConfig?.snapshotHash) {
+    const currentHash = await computeSnapshotHash(rootDir, detected.language);
+    if (currentHash !== savedConfig.snapshotHash && savedConfig.snapshotGeneratedAt) {
+      const daysSince = Math.floor(
+        (Date.now() - savedConfig.snapshotGeneratedAt) / (1e3 * 60 * 60 * 24)
+      );
+      p4.log.warn(
+        pc3.yellow(
+          `Code snapshot may be stale (source files changed${daysSince > 0 ? `, last generated ${daysSince}d ago` : ""}). Run with ${pc3.bold("--refresh-snapshot")} to update.`
+        )
+      );
+    }
+  }
+  let answers;
+  if (savedConfig && !reconfigure) {
+    p4.log.info(
+      `Using saved config from ${pc3.cyan(".codebrief.json")} ` + pc3.dim("(run with --reconfigure to change)")
+    );
+    answers = configToAnswers(savedConfig);
+    if (detected.monorepo && detected.monorepo.packages.length > 0 && !savedConfig.generatePerPackage) {
+    }
+  } else {
+    answers = await runPrompts(detected, reconfigure ? savedConfig : null);
+    if (!dryRun) {
+      const hash = await computeSnapshotHash(rootDir, detected.language);
+      await saveConfig(rootDir, answers, hash, detected.language);
+      p4.log.info(
+        pc3.dim("Saved config to .codebrief.json for future runs.")
+      );
+    }
+  }
+  let snapshot = null;
+  if (answers.generateSnapshot) {
+    spinner3.start("Scanning source files for code snapshot...");
+    snapshot = await generateSnapshot(detected, answers.snapshotPaths, graph, maxTokens, verbose ? verboseLog : spinnerProgress, gitActivity);
+    const count = snapshot.entries.length;
+    const budgetNote = snapshot.budgetExcluded ? ` (${snapshot.budgetExcluded} excluded by token budget)` : "";
+    spinner3.stop(
+      count > 0 ? `Found ${count} type${count === 1 ? "" : "s"}/signature${count === 1 ? "" : "s"}.${budgetNote}` : "No extractable types found (snapshot will be skipped)."
+    );
+    if (count === 0) {
+      snapshot = null;
+    }
+  }
+  spinner3.start(
+    dryRun ? "Preparing context files..." : "Generating context files..."
+  );
+  const shouldGenerateSkills = generateSkills || answers.ide === "claude";
+  const files = await generateFiles(detected, answers, snapshot, force, dryRun, analysis, shouldGenerateSkills, verbose ? verboseLog : void 0);
+  spinner3.stop(
+    dryRun ? `Would generate ${files.length} file${files.length === 1 ? "" : "s"}.` : `Generated ${files.length} file${files.length === 1 ? "" : "s"}.`
+  );
+  if (files.length === 0) {
+    p4.outro("Nothing to write. Done!");
+    return;
+  }
+  printSummary(files, detected, snapshot, analysis);
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(1);
+  if (dryRun) {
+    p4.outro(
+      pc3.yellow("DRY RUN complete \u2014 ") + pc3.dim(`no files were written. Remove --dry-run to generate. (${elapsed}s)`)
+    );
+    return;
+  }
+  p4.outro(
+    pc3.green(`Done in ${elapsed}s! `) + pc3.dim(
+      "Your context files are ready. They are living documents \u2014 keep them up to date as your project evolves."
+    )
+  );
+}
+main().catch((err) => {
+  console.error(pc3.red("Fatal error:"), err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map