codecortex-ai 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1957 @@
+#!/usr/bin/env node
+import {
+  buildGraph,
+  cortexPath,
+  createManifest,
+  createSession,
+  enrichCouplingWithImports,
+  ensureDir,
+  getLatestSession,
+  listDecisions,
+  listModuleDocs,
+  listSessions,
+  readFile,
+  readManifest,
+  startServer,
+  updateManifest,
+  writeFile,
+  writeGraph,
+  writeJsonStream,
+  writeManifest,
+  writeSession
+} from "../chunk-F4WTE7R3.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import { resolve } from "path";
+
+// src/core/discovery.ts
+import { execSync } from "child_process";
+import { readFile as fsRead2, stat } from "fs/promises";
+import { join, relative, basename, extname } from "path";
+import { existsSync } from "fs";
+
+// src/extraction/parser.ts
+import { createRequire } from "module";
+import { readFile as fsRead } from "fs/promises";
+var require2 = createRequire(import.meta.url);
+var Parser = require2("tree-sitter");
+var parser = new Parser();
+var LANGUAGE_LOADERS = {
+  // TypeScript / JavaScript
+  typescript: () => require2("tree-sitter-typescript").typescript,
+  tsx: () => require2("tree-sitter-typescript").tsx,
+  javascript: () => require2("tree-sitter-javascript"),
+  // Python
+  python: () => require2("tree-sitter-python"),
+  // Go
+  go: () => require2("tree-sitter-go"),
+  // Rust
+  rust: () => require2("tree-sitter-rust"),
+  // Systems
+  c: () => require2("tree-sitter-c"),
+  cpp: () => require2("tree-sitter-cpp"),
+  objc: () => require2("tree-sitter-objc"),
+  zig: () => require2("tree-sitter-zig"),
+  // JVM
+  java: () => require2("tree-sitter-java"),
+  kotlin: () => require2("tree-sitter-kotlin"),
+  scala: () => require2("tree-sitter-scala"),
+  // .NET
+  c_sharp: () => require2("tree-sitter-c-sharp"),
+  // Mobile
+  swift: () => require2("tree-sitter-swift"),
+  dart: () => require2("tree-sitter-dart"),
+  // Scripting
+  ruby: () => require2("tree-sitter-ruby"),
+  php: () => require2("tree-sitter-php").php,
+  lua: () => require2("tree-sitter-lua"),
+  bash: () => require2("tree-sitter-bash"),
+  elixir: () => require2("tree-sitter-elixir"),
+  // Functional
+  ocaml: () => require2("tree-sitter-ocaml").ocaml,
+  elm: () => require2("tree-sitter-elm"),
+  elisp: () => require2("tree-sitter-elisp"),
+  // Web3 / Other
+  solidity: () => require2("tree-sitter-solidity"),
+  vue: () => require2("tree-sitter-vue"),
+  ql: () => require2("tree-sitter-ql")
+};
+var EXTENSION_MAP = {
+  // TypeScript / JavaScript
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  // Python
+  ".py": "python",
+  ".pyw": "python",
+  ".pyi": "python",
+  // Go
+  ".go": "go",
+  // Rust
+  ".rs": "rust",
+  // C / C++
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".hh": "cpp",
+  // Objective-C
+  ".m": "objc",
+  ".mm": "objc",
+  // Zig
+  ".zig": "zig",
+  // Java
+  ".java": "java",
+  // Kotlin
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  // Scala
+  ".scala": "scala",
+  ".sc": "scala",
+  // C#
+  ".cs": "c_sharp",
+  // Swift
+  ".swift": "swift",
+  // Dart
+  ".dart": "dart",
+  // Ruby
+  ".rb": "ruby",
+  ".rake": "ruby",
+  // PHP
+  ".php": "php",
+  // Lua
+  ".lua": "lua",
+  // Bash / Shell
+  ".sh": "bash",
+  ".bash": "bash",
+  // Elixir
+  ".ex": "elixir",
+  ".exs": "elixir",
+  // OCaml
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  // Elm
+  ".elm": "elm",
+  // Emacs Lisp
+  ".el": "elisp",
+  // Solidity
+  ".sol": "solidity",
+  // Vue
+  ".vue": "vue",
+  // CodeQL
+  ".ql": "ql"
+};
+var languageCache = /* @__PURE__ */ new Map();
+function loadLanguage(lang) {
+  const cached = languageCache.get(lang);
+  if (cached) return cached;
+  const loader = LANGUAGE_LOADERS[lang];
+  if (!loader) throw new Error(`Unsupported language: ${lang}`);
+  const language = loader();
+  languageCache.set(lang, language);
+  return language;
+}
+async function initParser() {
+}
+async function parseFile(filePath, language) {
+  const lang = loadLanguage(language);
+  parser.setLanguage(lang);
+  const source = await fsRead(filePath, "utf-8");
+  return parser.parse(source);
+}
+function languageFromPath(filePath) {
+  const ext = filePath.substring(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext] || null;
+}
+
+// src/core/discovery.ts
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".output",
+  "coverage",
+  "__pycache__",
+  ".mypy_cache",
+  ".pytest_cache",
+  "vendor",
+  "target",
+  ".codecortex"
+]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  ".DS_Store",
+  "Thumbs.db"
+]);
+async function discoverProject(root) {
+  const name = detectProjectName(root);
+  const type = detectProjectType(root);
+  const files = await discoverFiles(root);
+  const modules = detectModules(root, files);
+  const entryPoints = detectEntryPoints(root, files, type);
+  const languages = [...new Set(files.map((f) => f.language).filter(Boolean))];
+  return { name, root, type, files, modules, entryPoints, languages };
+}
+function detectProjectName(root) {
+  const pkgPath = join(root, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(execSync(`cat "${pkgPath}"`, { encoding: "utf-8" }));
+      if (pkg.name) return pkg.name;
+    } catch {
+    }
+  }
+  const cargoPath = join(root, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    try {
+      const cargo = execSync(`cat "${cargoPath}"`, { encoding: "utf-8" });
+      const match = cargo.match(/name\s*=\s*"(.+?)"/);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return basename(root);
+}
+function detectProjectType(root) {
+  if (existsSync(join(root, "package.json"))) return "node";
+  if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "setup.py")) || existsSync(join(root, "requirements.txt"))) return "python";
+  if (existsSync(join(root, "go.mod"))) return "go";
+  if (existsSync(join(root, "Cargo.toml"))) return "rust";
+  return "unknown";
+}
+async function discoverFiles(root) {
+  const files = [];
+  let filePaths;
+  try {
+    const output = execSync("git ls-files --cached --others --exclude-standard", {
+      cwd: root,
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    filePaths = output.trim().split("\n").filter(Boolean);
+  } catch {
+    filePaths = await walkDirectory(root, root);
+  }
+  for (const relPath of filePaths) {
+    const ext = extname(relPath);
+    const language = EXTENSION_MAP[ext];
+    if (!language) continue;
+    const parts = relPath.split("/");
+    if (parts.some((p) => IGNORED_DIRS.has(p))) continue;
+    if (IGNORED_FILES.has(basename(relPath))) continue;
+    const absPath = join(root, relPath);
+    try {
+      const s = await stat(absPath);
+      const content = await fsRead2(absPath, "utf-8");
+      const lines = content.split("\n").length;
+      files.push({
+        path: relPath,
+        absolutePath: absPath,
+        language,
+        lines,
+        bytes: s.size
+      });
+    } catch {
+    }
+  }
+  return files;
+}
+async function walkDirectory(root, baseRoot) {
+  const { readdir } = await import("fs/promises");
+  const paths = [];
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    if (IGNORED_FILES.has(entry.name)) continue;
+    const fullPath = join(root, entry.name);
+    if (entry.isDirectory()) {
+      const sub = await walkDirectory(fullPath, baseRoot);
+      paths.push(...sub);
+    } else if (entry.isFile()) {
+      paths.push(relative(baseRoot, fullPath));
+    }
+  }
+  return paths;
+}
+function detectModules(root, files) {
+  const MODULE_ROOTS = /* @__PURE__ */ new Set(["src", "lib", "pkg", "packages", "apps", "extensions", "crates", "internal", "cmd", "scripts", "tools", "rust"]);
+  const srcDirs = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parts = file.path.split("/");
+    if (parts.length >= 3) {
+      const topDir = parts[0];
+      const dir = parts[1];
+      if (!topDir || !dir) continue;
+      if (MODULE_ROOTS.has(topDir)) {
+        srcDirs.add(dir);
+      }
+    }
+  }
+  return [...srcDirs].sort();
+}
+function detectEntryPoints(root, files, type) {
+  const entryPoints = [];
+  if (type === "node") {
+    const pkgPath = join(root, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(execSync(`cat "${pkgPath}"`, { encoding: "utf-8" }));
+        if (pkg.main) entryPoints.push(pkg.main);
+        if (pkg.bin) {
+          const bins = typeof pkg.bin === "string" ? [pkg.bin] : Object.values(pkg.bin);
+          entryPoints.push(...bins);
+        }
+      } catch {
+      }
+    }
+  }
+  const commonEntries = ["src/index.ts", "src/main.ts", "src/app.ts", "index.ts", "main.ts", "main.go", "src/main.rs", "src/lib.rs"];
+  for (const entry of commonEntries) {
+    if (files.some((f) => f.path === entry)) {
+      if (!entryPoints.includes(entry)) entryPoints.push(entry);
+    }
+  }
+  return entryPoints;
+}
+
+// src/core/constitution.ts
+async function generateConstitution(projectRoot, data) {
+  const manifest = await readManifest(projectRoot);
+  const modules = await listModuleDocs(projectRoot);
+  const decisions = await listDecisions(projectRoot);
+  let graphModules = data?.modules;
+  let entryPoints = data?.entryPoints;
+  let externalDeps = data?.externalDeps;
+  let temporal = data?.temporal ?? null;
+  if (!graphModules) {
+    const graphContent = await readFile(cortexPath(projectRoot, "graph.json"));
+    if (graphContent) {
+      try {
+        const graph = JSON.parse(graphContent);
+        graphModules = graph.modules;
+        entryPoints = graph.entryPoints;
+        externalDeps = graph.externalDeps;
+      } catch {
+      }
+    }
+  }
+  if (temporal === null && !data) {
+    const temporalContent = await readFile(cortexPath(projectRoot, "temporal.json"));
+    if (temporalContent) {
+      try {
+        temporal = JSON.parse(temporalContent);
+      } catch {
+      }
+    }
+  }
+  const lines = [
+    `# ${manifest?.project || "Project"} \u2014 Constitution`,
+    "",
+    `> Auto-generated by CodeCortex. This is the AI's starting knowledge for this codebase.`,
+    ""
+  ];
+  if (manifest) {
+    lines.push(
+      `## Project`,
+      `- **Name:** ${manifest.project}`,
+      `- **Languages:** ${manifest.languages.join(", ")}`,
+      `- **Files:** ${manifest.totalFiles}`,
+      `- **Symbols:** ${manifest.totalSymbols}`,
+      `- **Modules:** ${manifest.totalModules}`,
+      `- **Last updated:** ${manifest.lastUpdated}`,
+      ""
+    );
+  }
+  if (graphModules) {
+    lines.push(`## Architecture`, "");
+    if (entryPoints && entryPoints.length > 0) {
+      lines.push(`**Entry points:** ${entryPoints.map((e) => `\`${e}\``).join(", ")}`, "");
+    }
+    lines.push(`**Modules:**`);
+    for (const mod of graphModules) {
+      lines.push(`- **${mod.name}** (${mod.files.length} files, ${mod.lines} lines) \u2014 ${mod.language}`);
+    }
+    lines.push("");
+    if (externalDeps) {
+      const extDeps = Object.keys(externalDeps);
+      if (extDeps.length > 0) {
+        lines.push(`**External dependencies:** ${extDeps.map((d) => `\`${d}\``).join(", ")}`, "");
+      }
+    }
+  }
+  if (temporal) {
+    lines.push(`## Risk Map`, "");
+    const topHotspots = temporal.hotspots.slice(0, 5);
+    if (topHotspots.length > 0) {
+      lines.push(`**Hottest files (most changes):**`);
+      for (const h of topHotspots) {
+        lines.push(`- \`${h.file}\` \u2014 ${h.changes} changes, ${h.stability.toUpperCase()}`);
+      }
+      lines.push("");
+    }
+    const hiddenCouplings = temporal.coupling.filter((c) => !c.hasImport && c.strength >= 0.5);
+    if (hiddenCouplings.length > 0) {
+      lines.push(`**Hidden dependencies (co-change but no import):**`);
+      for (const c of hiddenCouplings.slice(0, 5)) {
+        lines.push(`- \`${c.fileA}\` \u2194 \`${c.fileB}\` \u2014 ${c.cochanges} co-changes (${Math.round(c.strength * 100)}%)`);
+      }
+      lines.push("");
+    }
+    const buggy = temporal.bugHistory.filter((b) => b.fixCommits >= 2);
+    if (buggy.length > 0) {
+      lines.push(`**Bug-prone files:**`);
+      for (const b of buggy.slice(0, 5)) {
+        lines.push(`- \`${b.file}\` \u2014 ${b.fixCommits} fix commits`);
+        for (const lesson of b.lessons.slice(0, 3)) {
+          lines.push(`  - ${lesson}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  lines.push(`## Available Knowledge`, "");
+  if (modules.length > 0) {
+    lines.push(`**Module docs:** ${modules.map((m) => `\`${m}\``).join(", ")}`);
+  }
+  if (decisions.length > 0) {
+    lines.push(`**Decision records:** ${decisions.length}`);
+  }
+  lines.push(
+    ``,
+    `Use \`get_module_context\` to deep-dive into any module.`,
+    `Use \`get_change_coupling\` before editing a file to check what else must change.`,
+    `Use \`lookup_symbol\` to find any function, type, or class.`
+  );
+  const content = lines.join("\n") + "\n";
+  await writeFile(cortexPath(projectRoot, "constitution.md"), content);
+  return content;
+}
+
+// src/git/history.ts
+import simpleGit from "simple-git";
+async function getCommitHistory(root, days = 90) {
+  const git = simpleGit(root);
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+  const log = await git.log({
+    "--since": since,
+    "--stat": null,
+    maxCount: 500
+  });
+  return log.all.map((commit) => ({
+    hash: commit.hash,
+    date: commit.date,
+    message: commit.message,
+    author: commit.author_name,
+    filesChanged: parseStatFiles(commit.diff)
+  }));
+}
+function parseStatFiles(diff) {
+  if (!diff || !diff.files) return [];
+  return diff.files.map((f) => f.file);
+}
+async function isGitRepo(root) {
+  const git = simpleGit(root);
+  try {
+    await git.status();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getHeadCommit(root) {
+  const git = simpleGit(root);
+  try {
+    const log = await git.log({ maxCount: 1 });
+    return log.latest?.hash || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/git/temporal.ts
+var TEMPORAL_NOISE_FILES = /* @__PURE__ */ new Set([
+  "CHANGELOG.md",
+  "CHANGES.md",
+  "HISTORY.md",
+  "NEWS.md",
+  "package.json",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock",
+  "go.sum",
+  "poetry.lock",
+  "Pipfile.lock"
+]);
+function isTemporalNoise(file) {
+  const basename2 = file.split("/").pop() ?? "";
+  return TEMPORAL_NOISE_FILES.has(basename2);
+}
+async function analyzeTemporalData(root, days = 90) {
+  const commits = await getCommitHistory(root, days);
+  const hotspots = getHotspots(commits, days);
+  const coupling = getChangeCoupling(commits);
+  const bugHistory = getBugArchaeology(commits);
+  return {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    periodDays: days,
+    totalCommits: commits.length,
+    hotspots,
+    coupling,
+    bugHistory
+  };
+}
+function getHotspots(commits, days) {
+  const fileChanges = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.filesChanged) {
+      if (isTemporalNoise(file)) continue;
+      const existing = fileChanges.get(file) || { count: 0, lastDate: "" };
+      existing.count++;
+      if (commit.date > existing.lastDate) {
+        existing.lastDate = commit.date;
+      }
+      fileChanges.set(file, existing);
+    }
+  }
+  const now = /* @__PURE__ */ new Date();
+  const results = [];
+  for (const [file, data] of fileChanges) {
+    const lastChanged = new Date(data.lastDate);
+    const daysSinceChange = Math.floor((now.getTime() - lastChanged.getTime()) / (1e3 * 60 * 60 * 24));
+    let stability;
+    if (data.count >= 8 && daysSinceChange < 7) stability = "volatile";
+    else if (data.count >= 5 && daysSinceChange < 14) stability = "stabilizing";
+    else if (data.count >= 3) stability = "moderate";
+    else if (daysSinceChange > 30) stability = "very_stable";
+    else stability = "stable";
+    results.push({
+      file,
+      changes: data.count,
+      stability,
+      lastChanged: data.lastDate,
+      daysSinceChange
+    });
+  }
+  return results.sort((a, b) => b.changes - a.changes);
+}
+function getChangeCoupling(commits) {
+  const pairCounts = /* @__PURE__ */ new Map();
+  const fileCounts = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const files = commit.filesChanged.filter(
+      (f) => !f.endsWith(".md") && !f.endsWith(".json") && !f.endsWith(".lock") && !f.endsWith(".yaml") && !f.endsWith(".yml")
+    );
+    for (const file of files) {
+      fileCounts.set(file, (fileCounts.get(file) || 0) + 1);
+    }
+    if (files.length > 50) continue;
+    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("|");
+        pairCounts.set(key, (pairCounts.get(key) || 0) + 1);
+      }
+    }
+  }
+  const results = [];
+  for (const [key, cochanges] of pairCounts) {
+    if (cochanges < 3) continue;
+    const parts = key.split("|");
+    const fileA = parts[0] ?? "";
+    const fileB = parts[1] ?? "";
+    const maxChanges = Math.max(fileCounts.get(fileA) || 0, fileCounts.get(fileB) || 0);
+    const strength = maxChanges > 0 ? cochanges / maxChanges : 0;
+    const coupling = {
+      fileA,
+      fileB,
+      cochanges,
+      strength: Math.round(strength * 100) / 100,
+      hasImport: false
+      // Will be enriched by graph analysis
+    };
+    if (strength >= 0.7 && !coupling.hasImport) {
+      coupling.warning = `HIDDEN DEPENDENCY \u2014 ${Math.round(strength * 100)}% co-change rate`;
+    }
+    results.push(coupling);
+  }
+  return results.sort((a, b) => b.cochanges - a.cochanges);
+}
+function getBugArchaeology(commits) {
+  const bugPatterns = /^(fix|bug|hotfix|patch)[\s:(]/i;
+  const fileRecords = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    if (!bugPatterns.test(commit.message)) continue;
+    const lesson = commit.message.replace(/^(fix|bug|hotfix|patch)[\s:(]+/i, "").replace(/\s*\(#\d+\)$/, "").trim();
+    for (const file of commit.filesChanged) {
+      if (isTemporalNoise(file)) continue;
+      const existing = fileRecords.get(file) || { fixCommits: 0, lessons: /* @__PURE__ */ new Set() };
+      existing.fixCommits++;
+      if (lesson) existing.lessons.add(lesson);
+      fileRecords.set(file, existing);
+    }
+  }
+  const results = [];
+  for (const [file, data] of fileRecords) {
+    results.push({
+      file,
+      fixCommits: data.fixCommits,
+      lessons: [...data.lessons]
+    });
+  }
+  return results.sort((a, b) => b.fixCommits - a.fixCommits);
+}
+
+// src/extraction/symbols.ts
+var TS_JS_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "class_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+    "enum_declaration",
+    "lexical_declaration",
+    "variable_declaration",
+    "method_definition",
+    "public_field_definition",
+    "export_statement"
+  ]),
+  getKind(type) {
+    const map = {
+      function_declaration: "function",
+      class_declaration: "class",
+      interface_declaration: "interface",
+      type_alias_declaration: "type",
+      enum_declaration: "enum",
+      lexical_declaration: "const",
+      variable_declaration: "variable",
+      method_definition: "method",
+      public_field_definition: "property"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    if (node.type === "lexical_declaration" || node.type === "variable_declaration") {
+      const declarator = node.namedChildren.find(
+        (c) => c.type === "variable_declarator"
+      );
+      if (declarator) {
+        const name = declarator.childForFieldName("name");
+        return name?.text || null;
+      }
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    const line = lines[startLine];
+    if (!line) return void 0;
+    const sig = line.trim();
+    return sig.length > 200 ? sig.slice(0, 200) + "..." : sig;
+  },
+  isExported(node) {
+    const parent = node.parent;
+    if (!parent) return false;
+    if (parent.type === "export_statement") return true;
+    if (node.type === "lexical_declaration") {
+      return parent.type === "export_statement";
+    }
+    return false;
+  }
+};
+var PYTHON_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "function_definition",
+    "class_definition",
+    "assignment"
+  ]),
+  getKind(type) {
+    const map = {
+      function_definition: "function",
+      class_definition: "class",
+      assignment: "variable"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    if (node.type === "assignment") {
+      const left = node.childForFieldName("left");
+      return left?.text || null;
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    return lines[startLine]?.trim();
+  },
+  isExported(node) {
+    const name = PYTHON_QUERY.getName(node);
+    return name ? !name.startsWith("_") : false;
+  }
+};
+var GO_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "function_declaration",
+    "method_declaration",
+    "type_declaration",
+    "const_declaration",
+    "var_declaration"
+  ]),
+  getKind(type) {
+    const map = {
+      function_declaration: "function",
+      method_declaration: "method",
+      type_declaration: "type",
+      const_declaration: "const",
+      var_declaration: "variable"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    if (node.type === "type_declaration" || node.type === "const_declaration" || node.type === "var_declaration") {
+      for (const child of node.namedChildren) {
+        if (child.type === "type_spec" || child.type === "const_spec" || child.type === "var_spec") {
+          const specName = child.childForFieldName("name");
+          if (specName) return specName.text;
+        }
+      }
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    return lines[startLine]?.trim();
+  },
+  isExported(node) {
+    const name = GO_QUERY.getName(node);
+    return name ? /^[A-Z]/.test(name) : false;
+  }
+};
+var RUST_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "function_item",
+    "struct_item",
+    "enum_item",
+    "impl_item",
+    "trait_item",
+    "type_item",
+    "const_item",
+    "static_item"
+  ]),
+  getKind(type) {
+    const map = {
+      function_item: "function",
+      struct_item: "class",
+      enum_item: "enum",
+      impl_item: "class",
+      trait_item: "interface",
+      type_item: "type",
+      const_item: "const",
+      static_item: "variable"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    return nameNode?.text || null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    return lines[startLine]?.trim();
+  },
+  isExported(node) {
+    const text = node.text;
+    return text.startsWith("pub ");
+  }
+};
+var C_CPP_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "function_definition",
+    "declaration",
+    "struct_specifier",
+    "enum_specifier",
+    "union_specifier",
+    "type_definition",
+    "preproc_function_def",
+    // C++ additions
+    "class_specifier",
+    "namespace_definition"
+  ]),
+  getKind(type) {
+    const map = {
+      function_definition: "function",
+      declaration: "variable",
+      struct_specifier: "class",
+      enum_specifier: "enum",
+      union_specifier: "class",
+      type_definition: "type",
+      preproc_function_def: "function",
+      class_specifier: "class",
+      namespace_definition: "class"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    let declarator = node.childForFieldName("declarator");
+    while (declarator) {
+      if (declarator.type === "identifier" || declarator.type === "type_identifier" || declarator.type === "field_identifier") {
+        return declarator.text;
+      }
+      const inner = declarator.childForFieldName("declarator");
+      if (inner) {
+        declarator = inner;
+        continue;
+      }
+      const declName = declarator.childForFieldName("name");
+      if (declName) return declName.text;
+      break;
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    const line = lines[startLine];
+    if (!line) return void 0;
+    const sig = line.trim();
+    return sig.length > 200 ? sig.slice(0, 200) + "..." : sig;
+  },
+  isExported(node) {
+    if (node.text.startsWith("static ")) return false;
+    if (node.text.startsWith("public ")) return true;
+    return node.parent?.type === "translation_unit" || false;
+  }
+};
+var JAVA_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "field_declaration",
+    "annotation_type_declaration",
+    // Kotlin
+    "function_declaration",
+    "object_declaration"
+  ]),
+  getKind(type) {
+    const map = {
+      class_declaration: "class",
+      interface_declaration: "interface",
+      enum_declaration: "enum",
+      method_declaration: "method",
+      constructor_declaration: "method",
+      field_declaration: "property",
+      annotation_type_declaration: "interface",
+      function_declaration: "function",
+      object_declaration: "class"
+    };
+    return map[type] || "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    for (const child of node.namedChildren) {
+      if (child.type === "variable_declarator") {
+        const name = child.childForFieldName("name");
+        if (name) return name.text;
+      }
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    const line = lines[startLine];
+    if (!line) return void 0;
+    const sig = line.trim();
+    return sig.length > 200 ? sig.slice(0, 200) + "..." : sig;
+  },
+  isExported(node) {
+    return node.text.startsWith("public ") || node.text.startsWith("protected ");
+  }
+};
+var GENERIC_QUERY = {
+  nodeTypes: /* @__PURE__ */ new Set([
+    // Functions
+    "function_declaration",
+    "function_definition",
+    "function_item",
+    "method_declaration",
+    "method_definition",
+    "method",
+    // Classes / structs
+    "class_declaration",
+    "class_definition",
+    "class_specifier",
+    "struct_specifier",
+    "struct_item",
+    "struct_declaration",
+    "module_definition",
+    "module",
+    // Interfaces / traits / protocols
+    "interface_declaration",
+    "trait_item",
+    "protocol_declaration",
+    // Enums
+    "enum_declaration",
+    "enum_item",
+    "enum_specifier",
+    "enum_definition",
+    // Types
+    "type_declaration",
+    "type_alias_declaration",
+    "type_item",
+    "type_definition",
+    // Constants
+    "const_declaration",
+    "const_item"
+  ]),
+  getKind(type) {
+    if (type.includes("function") || type.includes("method")) return "function";
+    if (type.includes("class") || type.includes("struct") || type.includes("module")) return "class";
+    if (type.includes("interface") || type.includes("trait") || type.includes("protocol")) return "interface";
+    if (type.includes("enum")) return "enum";
+    if (type.includes("type")) return "type";
+    if (type.includes("const")) return "const";
+    return "variable";
+  },
+  getName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    let declarator = node.childForFieldName("declarator");
+    while (declarator) {
+      if (declarator.type === "identifier" || declarator.type === "type_identifier") return declarator.text;
+      const inner = declarator.childForFieldName("declarator") || declarator.childForFieldName("name");
+      if (inner) {
+        if (inner.type === "identifier" || inner.type === "type_identifier") return inner.text;
+        declarator = inner;
+        continue;
+      }
+      break;
+    }
+    for (const child of node.namedChildren) {
+      if (child.type === "identifier" || child.type === "type_identifier") return child.text;
+    }
+    return null;
+  },
+  getSignature(node, source) {
+    const startLine = node.startPosition.row;
+    const lines = source.split("\n");
+    const line = lines[startLine];
+    if (!line) return void 0;
+    const sig = line.trim();
+    return sig.length > 200 ? sig.slice(0, 200) + "..." : sig;
+  },
+  isExported(node) {
+    const text = node.text;
+    if (text.startsWith("pub ") || text.startsWith("public ") || text.startsWith("export ")) return true;
+    const parent = node.parent;
+    if (parent?.type === "export_statement") return true;
+    return false;
+  }
+};
+function getQuery(language) {
+  switch (language) {
+    case "typescript":
+    case "tsx":
+    case "javascript":
+      return TS_JS_QUERY;
+    case "python":
+      return PYTHON_QUERY;
+    case "go":
+      return GO_QUERY;
+    case "rust":
+      return RUST_QUERY;
+    case "c":
+    case "cpp":
+    case "objc":
+      return C_CPP_QUERY;
+    case "java":
+    case "kotlin":
+    case "c_sharp":
+    case "scala":
+    case "dart":
+      return JAVA_QUERY;
+    default:
+      return GENERIC_QUERY;
+  }
+}
+function extractSymbols(tree, file, language, source) {
+  const query = getQuery(language);
+  const symbols = [];
+  function walk(node, parentName) {
+    if (query.nodeTypes.has(node.type)) {
+      if (node.type === "export_statement") {
+        const declaration = node.namedChildren.find((c) => query.nodeTypes.has(c.type));
+        if (declaration) {
+          const name2 = query.getName(declaration);
+          if (name2) {
+            symbols.push({
+              name: name2,
+              kind: query.getKind(declaration.type),
+              file,
+              startLine: declaration.startPosition.row + 1,
+              endLine: declaration.endPosition.row + 1,
+              signature: query.getSignature(declaration, source),
+              exported: true,
+              parentName
+            });
+          }
+          for (const child of declaration.namedChildren) {
+            walk(child, name2 || parentName);
+          }
+          return;
+        }
+        return;
+      }
+      const name = query.getName(node);
+      if (name) {
+        symbols.push({
+          name,
+          kind: query.getKind(node.type),
+          file,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          signature: query.getSignature(node, source),
+          exported: query.isExported(node),
+          parentName
+        });
+      }
+      for (const child of node.namedChildren) {
+        walk(child, name || parentName);
+      }
+      return;
+    }
+    for (const child of node.namedChildren) {
+      walk(child, parentName);
+    }
+  }
+  walk(tree.rootNode);
+  return symbols;
+}
+
+// src/extraction/imports.ts
+import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+function extractImports(tree, file, language) {
+  switch (language) {
+    case "typescript":
+    case "tsx":
+    case "javascript":
+      return extractTsImports(tree, file);
+    case "python":
+      return extractPythonImports(tree, file);
+    case "go":
+      return extractGoImports(tree, file);
+    case "rust":
+      return extractRustImports(tree, file);
+    case "c":
+    case "cpp":
+    case "objc":
+      return extractCIncludes(tree, file);
+    case "java":
+    case "kotlin":
+    case "c_sharp":
+    case "scala":
+    case "dart":
+      return extractJavaImports(tree, file);
+    default:
+      return extractGenericImports(tree, file);
+  }
+}
+function extractTsImports(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "import_statement") {
+      const sourceNode = node.childForFieldName("source");
+      if (!sourceNode) {
+        for (const child of node.namedChildren) {
+          walk(child);
+        }
+        return;
+      }
+      const rawPath = sourceNode.text.replace(/['"]/g, "");
+      if (!rawPath.startsWith(".")) {
+        return;
+      }
+      const resolved = resolveImportPath(file, rawPath);
+      const specifiers = extractSpecifiers(node);
+      imports.push({
+        source: file,
+        target: resolved,
+        specifiers
+      });
+      return;
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function extractSpecifiers(importNode) {
+  const specifiers = [];
+  function walk(node) {
+    if (node.type === "import_specifier") {
+      const name = node.childForFieldName("name");
+      if (name) specifiers.push(name.text);
+    } else if (node.type === "namespace_import") {
+      specifiers.push("*");
+    } else if (node.type === "identifier" && node.parent?.type === "import_clause") {
+      specifiers.push(node.text);
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(importNode);
+  return specifiers;
+}
+function resolveImportPath(fromFile, importPath) {
+  const dir = dirname2(fromFile);
+  let resolved = join2(dir, importPath);
+  resolved = resolved.replace(/\.(js|ts|tsx|jsx|mjs)$/, "");
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", "/index.ts", "/index.js"];
+  for (const ext of extensions) {
+    if (existsSync2(resolved + ext)) {
+      return resolved + ext;
+    }
+  }
+  return resolved + ".ts";
+}
+function extractPythonImports(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "import_from_statement") {
+      const moduleNode = node.childForFieldName("module_name");
+      if (moduleNode) {
+        const modulePath = moduleNode.text;
+        if (modulePath.startsWith(".")) {
+          const specifiers = [];
+          for (const child of node.namedChildren) {
+            if (child.type === "dotted_name" && child !== moduleNode) {
+              specifiers.push(child.text);
+            }
+          }
+          imports.push({
+            source: file,
+            target: resolvePythonImport(file, modulePath),
+            specifiers
+          });
+        }
+      }
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function resolvePythonImport(fromFile, importPath) {
+  const dir = dirname2(fromFile);
+  const parts = importPath.replace(/^\.+/, "");
+  const dots = importPath.match(/^\.+/)?.[0].length || 1;
+  let base = dir;
+  for (let i = 1; i < dots; i++) base = dirname2(base);
+  return join2(base, parts.replace(/\./g, "/") + ".py");
+}
+function extractGoImports(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "import_spec") {
+      const pathNode = node.childForFieldName("path");
+      if (pathNode) {
+        imports.push({
+          source: file,
+          target: pathNode.text.replace(/"/g, ""),
+          specifiers: ["*"]
+        });
+      }
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function extractRustImports(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "use_declaration") {
+      const path = node.namedChildren.find((c) => c.type === "scoped_identifier" || c.type === "use_wildcard" || c.type === "use_list");
+      if (path) {
+        imports.push({
+          source: file,
+          target: path.text,
+          specifiers: ["*"]
+        });
+      }
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function extractCIncludes(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "preproc_include") {
+      const pathNode = node.childForFieldName("path");
+      if (pathNode) {
+        const raw = pathNode.text.replace(/['"<>]/g, "");
+        imports.push({ source: file, target: raw, specifiers: ["*"] });
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function extractJavaImports(tree, file) {
+  const imports = [];
+  function walk(node) {
+    if (node.type === "import_declaration") {
+      for (const child of node.namedChildren) {
+        if (child.type === "scoped_identifier" || child.type === "identifier") {
+          imports.push({ source: file, target: child.text, specifiers: ["*"] });
+          break;
+        }
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+function extractGenericImports(tree, file) {
+  const imports = [];
+  const importNodeTypes = /* @__PURE__ */ new Set([
+    "preproc_include",
+    "import_declaration",
+    "import_statement",
+    "import_from_statement",
+    "use_declaration",
+    "namespace_use_declaration"
+  ]);
+  function walk(node) {
+    if (importNodeTypes.has(node.type)) {
+      const pathNode = node.childForFieldName("path") || node.childForFieldName("source") || node.childForFieldName("module_name");
+      if (pathNode) {
+        const raw = pathNode.text.replace(/['"<>]/g, "");
+        imports.push({ source: file, target: raw, specifiers: ["*"] });
+      } else {
+        for (const child of node.namedChildren) {
+          if (child.type === "scoped_identifier" || child.type === "dotted_name" || child.type === "string_literal" || child.type === "string") {
+            imports.push({ source: file, target: child.text.replace(/['"]/g, ""), specifiers: ["*"] });
+            break;
+          }
+        }
+      }
+      return;
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return imports;
+}
+
+// src/extraction/calls.ts
+function extractCalls(tree, file, language) {
+  switch (language) {
+    case "typescript":
+    case "tsx":
+    case "javascript":
+      return extractTsCalls(tree, file);
+    case "python":
+      return extractPythonCalls(tree, file);
+    case "go":
+      return extractGoCalls(tree, file);
+    case "rust":
+      return extractRustCalls(tree, file);
+    default:
+      return extractGenericCalls(tree, file);
+  }
+}
+function extractTsCalls(tree, file) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function findEnclosingFunction(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_declaration" || current.type === "method_definition" || current.type === "arrow_function") {
+        const name = current.childForFieldName("name");
+        if (name) return name.text;
+        if (current.parent?.type === "variable_declarator") {
+          const varName = current.parent.childForFieldName("name");
+          if (varName) return varName.text;
+        }
+        return "<anonymous>";
+      }
+      current = current.parent;
+    }
+    return "<module>";
+  }
+  function walk(node) {
+    if (node.type === "call_expression") {
+      const funcNode = node.childForFieldName("function");
+      if (funcNode) {
+        let callee;
+        if (funcNode.type === "member_expression") {
+          const prop = funcNode.childForFieldName("property");
+          callee = prop?.text || funcNode.text;
+        } else {
+          callee = funcNode.text;
+        }
+        const caller = findEnclosingFunction(node);
+        const key = `${caller}:${callee}:${node.startPosition.row}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({
+            caller: `${file}:${caller}`,
+            callee,
+            file,
+            line: node.startPosition.row + 1
+          });
+        }
+      }
+    }
+    for (const child of node.namedChildren) {
+      walk(child);
+    }
+  }
+  walk(tree.rootNode);
+  return calls;
+}
+function extractPythonCalls(tree, file) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function findEnclosing(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_definition") {
+        const name = current.childForFieldName("name");
+        if (name) return name.text;
+      }
+      current = current.parent;
+    }
+    return "<module>";
+  }
+  function walk(node) {
+    if (node.type === "call") {
+      const funcNode = node.childForFieldName("function");
+      if (funcNode) {
+        const callee = funcNode.type === "attribute" ? funcNode.childForFieldName("attribute")?.text || funcNode.text : funcNode.text;
+        const caller = findEnclosing(node);
+        const key = `${caller}:${callee}:${node.startPosition.row}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({ caller: `${file}:${caller}`, callee, file, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return calls;
+}
+function extractGoCalls(tree, file) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function findEnclosing(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_declaration" || current.type === "method_declaration") {
+        const name = current.childForFieldName("name");
+        if (name) return name.text;
+      }
+      current = current.parent;
+    }
+    return "<module>";
+  }
+  function walk(node) {
+    if (node.type === "call_expression") {
+      const funcNode = node.childForFieldName("function");
+      if (funcNode) {
+        const callee = funcNode.type === "selector_expression" ? funcNode.childForFieldName("field")?.text || funcNode.text : funcNode.text;
+        const caller = findEnclosing(node);
+        const key = `${caller}:${callee}:${node.startPosition.row}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({ caller: `${file}:${caller}`, callee, file, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return calls;
+}
+function extractRustCalls(tree, file) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function findEnclosing(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === "function_item") {
+        const name = current.childForFieldName("name");
+        if (name) return name.text;
+      }
+      current = current.parent;
+    }
+    return "<module>";
+  }
+  function walk(node) {
+    if (node.type === "call_expression") {
+      const funcNode = node.childForFieldName("function");
+      if (funcNode) {
+        const callee = funcNode.text.split("::").pop() || funcNode.text;
+        const caller = findEnclosing(node);
+        const key = `${caller}:${callee}:${node.startPosition.row}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({ caller: `${file}:${caller}`, callee, file, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return calls;
+}
+function extractGenericCalls(tree, file) {
+  const calls = [];
+  const seen = /* @__PURE__ */ new Set();
+  function findEnclosing(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type.includes("function") || current.type.includes("method")) {
+        const name = current.childForFieldName("name");
+        if (name) return name.text;
+      }
+      current = current.parent;
+    }
+    return "<module>";
+  }
+  function walk(node) {
+    if (node.type === "call_expression" || node.type === "call") {
+      const funcNode = node.childForFieldName("function") || node.childForFieldName("method");
+      if (funcNode) {
+        let callee;
+        if (funcNode.type.includes("member") || funcNode.type.includes("selector") || funcNode.type === "attribute") {
+          const prop = funcNode.childForFieldName("property") || funcNode.childForFieldName("field") || funcNode.childForFieldName("attribute");
+          callee = prop?.text || funcNode.text;
+        } else {
+          callee = funcNode.text;
+        }
+        const caller = findEnclosing(node);
+        const key = `${caller}:${callee}:${node.startPosition.row}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          calls.push({ caller: `${file}:${caller}`, callee, file, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+    for (const child of node.namedChildren) walk(child);
+  }
+  walk(tree.rootNode);
+  return calls;
+}
+
+// src/cli/commands/init.ts
+import { readFile as readFile2 } from "fs/promises";
+async function initCommand(opts) {
+  const root = resolve(opts.root);
+  const days = parseInt(opts.days, 10);
+  console.log(`CodeCortex init \u2014 analyzing ${root}`);
+  console.log("");
+  console.log("Step 1/6: Discovering project structure...");
+  const project = await discoverProject(root);
+  console.log(`  Found ${project.files.length} files in ${project.modules.length} modules`);
+  console.log(`  Languages: ${project.languages.join(", ")}`);
+  console.log(`  Type: ${project.type}`);
+  console.log("");
+  console.log("Step 2/6: Extracting symbols with tree-sitter...");
+  await initParser();
+  const allSymbols = [];
+  const allImports = [];
+  const allCalls = [];
+  let extractionErrors = 0;
+  let parsed = 0;
+  const parseable = project.files.filter((f) => languageFromPath(f.path)).length;
+  const showProgress = parseable > 500;
+  for (const file of project.files) {
+    const lang = languageFromPath(file.path);
+    if (!lang) continue;
+    try {
+      const tree = await parseFile(file.absolutePath, lang);
+      const source = await readFile2(file.absolutePath, "utf-8");
+      const symbols = extractSymbols(tree, file.path, lang, source);
+      const imports = extractImports(tree, file.path, lang);
+      const calls = extractCalls(tree, file.path, lang);
+      allSymbols.push(...symbols);
+      allImports.push(...imports);
+      allCalls.push(...calls);
+    } catch {
+      extractionErrors++;
+    }
+    parsed++;
+    if (showProgress && parsed % 5e3 === 0) {
+      process.stdout.write(`\r  Progress: ${parsed}/${parseable} files (${allSymbols.length} symbols)`);
+    }
+  }
+  if (showProgress) process.stdout.write("\r" + " ".repeat(70) + "\r");
+  console.log(`  Extracted ${allSymbols.length} symbols, ${allImports.length} imports, ${allCalls.length} call edges`);
+  if (extractionErrors > 0) {
+    console.log(`  (${extractionErrors} files skipped due to parse errors)`);
+  }
+  console.log("");
+  console.log("Step 3/6: Building dependency graph...");
+  const MODULE_ROOTS = /* @__PURE__ */ new Set(["src", "lib", "pkg", "packages", "apps", "extensions", "crates", "internal", "cmd", "scripts", "tools", "rust"]);
+  const moduleNodes = project.modules.map((modName) => {
+    const modFiles = project.files.filter((f) => {
+      const parts = f.path.split("/");
+      const topDir2 = parts[0] ?? "";
+      return MODULE_ROOTS.has(topDir2) && parts[1] === modName || parts[0] === modName;
+    });
+    const topDir = modFiles[0]?.path.split("/")[0] ?? "src";
+    return {
+      path: `${topDir}/${modName}`,
+      name: modName,
+      files: modFiles.map((f) => f.path),
+      language: modFiles[0]?.language || "unknown",
+      lines: modFiles.reduce((sum, f) => sum + f.lines, 0),
+      symbols: allSymbols.filter((s) => modFiles.some((f) => f.path === s.file)).length
+    };
+  });
+  const externalDeps = {};
+  for (const file of project.files) {
+    try {
+      const content = await readFile2(file.absolutePath, "utf-8");
+      const importMatches = content.matchAll(/from\s+['"]([^.\/][^'"]*)['"]/g);
+      for (const match of importMatches) {
+        const raw = match[1];
+        if (!raw) continue;
+        const pkg = raw.startsWith("@") ? raw.split("/").slice(0, 2).join("/") : raw.split("/")[0] ?? raw;
+        if (!externalDeps[pkg]) externalDeps[pkg] = [];
+        externalDeps[pkg].push(file.path);
+      }
+    } catch {
+    }
+  }
+  const graph = buildGraph({
+    modules: moduleNodes,
+    imports: allImports,
+    calls: allCalls,
+    entryPoints: project.entryPoints,
+    externalDeps
+  });
+  console.log(`  ${moduleNodes.length} modules, ${Object.keys(externalDeps).length} external deps`);
+  console.log("");
+  console.log("Step 4/6: Analyzing git history...");
+  let temporalData = null;
+  const hasGit = await isGitRepo(root);
+  if (hasGit) {
+    temporalData = await analyzeTemporalData(root, days);
+    enrichCouplingWithImports(graph, temporalData.coupling);
+    console.log(`  ${temporalData.totalCommits} commits analyzed over ${days} days`);
+    console.log(`  ${temporalData.hotspots.length} hotspots, ${temporalData.coupling.length} coupling pairs, ${temporalData.bugHistory.length} bug records`);
+  } else {
+    console.log("  No git repository found, skipping temporal analysis");
+  }
+  console.log("");
+  console.log("Step 5/6: Writing knowledge files...");
+  await ensureDir(cortexPath(root));
+  await ensureDir(cortexPath(root, "modules"));
+  await ensureDir(cortexPath(root, "decisions"));
+  await ensureDir(cortexPath(root, "sessions"));
+  const symbolIndex = {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    total: allSymbols.length,
+    symbols: allSymbols
+  };
+  await writeJsonStream(cortexPath(root, "symbols.json"), symbolIndex, "symbols");
+  await writeGraph(root, graph);
+  if (temporalData) {
+    await writeFile(cortexPath(root, "temporal.json"), JSON.stringify(temporalData, null, 2));
+  }
+  const overview = generateOverview(project);
+  await writeFile(cortexPath(root, "overview.md"), overview);
+  const manifest = createManifest({
+    project: project.name,
+    root,
+    languages: project.languages,
+    totalFiles: project.files.length,
+    totalSymbols: allSymbols.length,
+    totalModules: project.modules.length
+  });
+  await writeManifest(root, manifest);
+  await writeFile(cortexPath(root, "patterns.md"), "# Coding Patterns\n\nNo patterns recorded yet. Use `update_patterns` to add patterns.\n");
+  console.log("  Written: cortex.yaml, symbols.json, graph.json, temporal.json, overview.md, patterns.md");
+  console.log("");
+  console.log("Step 6/6: Generating constitution...");
+  await generateConstitution(root, {
+    modules: moduleNodes,
+    entryPoints: project.entryPoints,
+    externalDeps,
+    temporal: temporalData
+  });
+  console.log("  Written: constitution.md");
+  console.log("");
+  const head = await getHeadCommit(root);
+  console.log("\u2500".repeat(50));
+  console.log("CodeCortex initialized successfully!");
+  console.log("");
+  console.log(`  Project: ${project.name}`);
+  console.log(`  Files:   ${project.files.length}`);
+  console.log(`  Symbols: ${allSymbols.length}`);
+  console.log(`  Modules: ${project.modules.length}`);
+  if (temporalData) {
+    console.log(`  Commits: ${temporalData.totalCommits} (last ${days} days)`);
+    const hidden = temporalData.coupling.filter((c) => !c.hasImport && c.strength >= 0.5);
+    if (hidden.length > 0) {
+      console.log(`  Hidden deps: ${hidden.length} (files that co-change but don't import each other)`);
+    }
+  }
+  if (head) {
+    console.log(`  Git HEAD: ${head.slice(0, 7)}`);
+  }
+  console.log("");
+  console.log(`Knowledge stored in: ${cortexPath(root)}`);
+  console.log("Run `codecortex serve` to start the MCP server.");
+}
+function generateOverview(project) {
+  const lines = [
+    `# ${project.name} \u2014 Overview`,
+    "",
+    `**Type:** ${project.type}`,
+    `**Languages:** ${project.languages.join(", ")}`,
+    `**Files:** ${project.files.length}`,
+    "",
+    `## Entry Points`,
+    ...project.entryPoints.map((e) => `- \`${e}\``),
+    "",
+    `## Modules`,
+    ...project.modules.map((m) => `- **${m}**`),
+    "",
+    `## File Map`
+  ];
+  const dirs = /* @__PURE__ */ new Map();
+  for (const file of project.files) {
+    const parts = file.path.split("/");
+    const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+    const existing = dirs.get(dir) || [];
+    const fileName = parts[parts.length - 1];
+    if (fileName) existing.push(fileName);
+    dirs.set(dir, existing);
+  }
+  for (const [dir, files] of [...dirs.entries()].sort()) {
+    lines.push(`
+### ${dir}/`);
+    for (const file of files.sort()) {
+      lines.push(`- ${file}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/cli/commands/serve.ts
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+async function serveCommand(opts) {
+  const root = resolve2(opts.root);
+  if (!existsSync3(cortexPath(root, "cortex.yaml"))) {
+    console.error("Error: No CodeCortex knowledge found.");
+    console.error(`Run 'codecortex init' first to analyze the codebase.`);
+    console.error(`Expected: ${cortexPath(root, "cortex.yaml")}`);
+    process.exit(1);
+  }
+  await startServer(root);
+}
+
+// src/cli/commands/update.ts
+import { resolve as resolve3 } from "path";
+import { existsSync as existsSync4 } from "fs";
+
+// src/git/diff.ts
+import simpleGit2 from "simple-git";
+async function getUncommittedDiff(root) {
+  const git = simpleGit2(root);
+  const diff = await git.diffSummary();
+  return {
+    filesChanged: diff.files.map((f) => f.file),
+    insertions: diff.insertions,
+    deletions: diff.deletions,
+    summary: `${diff.files.length} files changed, +${diff.insertions} -${diff.deletions}`
+  };
+}
+function mapFilesToModules(files) {
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parts = file.split("/");
+    let module = "root";
+    if (parts[0] === "src" && parts.length >= 3 && parts[1]) {
+      module = parts[1];
+    } else if (parts[0] === "lib" && parts.length >= 3 && parts[1]) {
+      module = parts[1];
+    }
+    const existing = moduleMap.get(module) || [];
+    existing.push(file);
+    moduleMap.set(module, existing);
+  }
+  return moduleMap;
+}
+
+// src/cli/commands/update.ts
+import { readFile as fsRead3 } from "fs/promises";
+async function updateCommand(opts) {
+  const root = resolve3(opts.root);
+  const days = parseInt(opts.days, 10);
+  if (!existsSync4(cortexPath(root, "cortex.yaml"))) {
+    console.error("Error: No CodeCortex knowledge found. Run `codecortex init` first.");
+    process.exit(1);
+  }
+  console.log("CodeCortex update \u2014 refreshing knowledge...");
+  console.log("");
+  console.log("Discovering changes...");
+  const project = await discoverProject(root);
+  console.log("Re-extracting symbols...");
+  await initParser();
+  const allSymbols = [];
+  const allImports = [];
+  const allCalls = [];
+  for (const file of project.files) {
+    const lang = languageFromPath(file.path);
+    if (!lang) continue;
+    try {
+      const tree = await parseFile(file.absolutePath, lang);
+      const source = await fsRead3(file.absolutePath, "utf-8");
+      allSymbols.push(...extractSymbols(tree, file.path, lang, source));
+      allImports.push(...extractImports(tree, file.path, lang));
+      allCalls.push(...extractCalls(tree, file.path, lang));
+    } catch {
+    }
+  }
+  console.log("Rebuilding dependency graph...");
+  const MODULE_ROOTS = /* @__PURE__ */ new Set(["src", "lib", "pkg", "packages", "apps", "extensions", "crates", "internal", "cmd", "scripts", "tools", "rust"]);
+  const moduleNodes = project.modules.map((modName) => {
+    const modFiles = project.files.filter((f) => {
+      const parts = f.path.split("/");
+      const topDir2 = parts[0] ?? "";
+      return MODULE_ROOTS.has(topDir2) && parts[1] === modName || parts[0] === modName;
+    });
+    const topDir = modFiles[0]?.path.split("/")[0] ?? "src";
+    return {
+      path: `${topDir}/${modName}`,
+      name: modName,
+      files: modFiles.map((f) => f.path),
+      language: modFiles[0]?.language || "unknown",
+      lines: modFiles.reduce((sum, f) => sum + f.lines, 0),
+      symbols: allSymbols.filter((s) => modFiles.some((f) => f.path === s.file)).length
+    };
+  });
+  const externalDeps = {};
+  for (const file of project.files) {
+    try {
+      const content = await fsRead3(file.absolutePath, "utf-8");
+      const importMatches = content.matchAll(/from\s+['"]([^.\/][^'"]*)['"]/g);
+      for (const match of importMatches) {
+        const raw = match[1];
+        if (!raw) continue;
+        const pkg = raw.startsWith("@") ? raw.split("/").slice(0, 2).join("/") : raw.split("/")[0] ?? raw;
+        if (!externalDeps[pkg]) externalDeps[pkg] = [];
+        externalDeps[pkg].push(file.path);
+      }
+    } catch {
+    }
+  }
+  const graph = buildGraph({
+    modules: moduleNodes,
+    imports: allImports,
+    calls: allCalls,
+    entryPoints: project.entryPoints,
+    externalDeps
+  });
+  console.log("Re-analyzing git history...");
+  let temporalData = null;
+  if (await isGitRepo(root)) {
+    temporalData = await analyzeTemporalData(root, days);
+    enrichCouplingWithImports(graph, temporalData.coupling);
+  }
+  console.log("Writing updated knowledge...");
+  const symbolIndex = {
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    total: allSymbols.length,
+    symbols: allSymbols
+  };
+  await writeJsonStream(cortexPath(root, "symbols.json"), symbolIndex, "symbols");
+  await writeGraph(root, graph);
+  if (temporalData) {
+    await writeFile(cortexPath(root, "temporal.json"), JSON.stringify(temporalData, null, 2));
+  }
+  await updateManifest(root, {
+    totalFiles: project.files.length,
+    totalSymbols: allSymbols.length,
+    totalModules: project.modules.length,
+    languages: project.languages
+  });
+  await generateConstitution(root, {
+    modules: moduleNodes,
+    entryPoints: project.entryPoints,
+    externalDeps,
+    temporal: temporalData
+  });
+  const diff = await getUncommittedDiff(root).catch(() => ({ filesChanged: [], summary: "no changes" }));
+  const previousSession = await getLatestSession(root);
+  const affectedModules = [...mapFilesToModules(diff.filesChanged).keys()];
+  const session = createSession({
+    filesChanged: diff.filesChanged,
+    modulesAffected: affectedModules,
+    summary: `Updated knowledge. ${allSymbols.length} symbols, ${project.modules.length} modules.`,
+    previousSession: previousSession || void 0
+  });
+  await writeSession(root, session);
+  console.log("");
+  console.log("\u2500".repeat(50));
+  console.log("Update complete!");
+  console.log(`  Symbols: ${allSymbols.length}`);
+  console.log(`  Modules: ${project.modules.length}`);
+  if (temporalData) {
+    console.log(`  Commits: ${temporalData.totalCommits}`);
+  }
+  console.log(`  Session: ${session.id}`);
+}
+
+// src/cli/commands/status.ts
+import { resolve as resolve4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+async function statusCommand(opts) {
+  const root = resolve4(opts.root);
+  if (!existsSync5(cortexPath(root, "cortex.yaml"))) {
+    console.log("No CodeCortex knowledge found.");
+    console.log(`Run 'codecortex init' to analyze this codebase.`);
+    return;
+  }
+  const manifest = await readManifest(root);
+  if (!manifest) {
+    console.log("Error reading cortex.yaml");
+    return;
+  }
+  console.log(`CodeCortex Status \u2014 ${manifest.project}`);
+  console.log("\u2500".repeat(50));
+  console.log("");
+  console.log("Knowledge Store:");
+  console.log(`  Version:     ${manifest.version}`);
+  console.log(`  Languages:   ${manifest.languages.join(", ")}`);
+  console.log(`  Files:       ${manifest.totalFiles}`);
+  console.log(`  Symbols:     ${manifest.totalSymbols}`);
+  console.log(`  Modules:     ${manifest.totalModules}`);
+  console.log(`  Generated:   ${manifest.generated}`);
+  console.log(`  Last updated: ${manifest.lastUpdated}`);
+  console.log("");
+  const lastUpdated = new Date(manifest.lastUpdated);
+  const ageHours = Math.floor((Date.now() - lastUpdated.getTime()) / (1e3 * 60 * 60));
+  const ageLabel = ageHours < 1 ? "just now" : ageHours < 24 ? `${ageHours} hours ago` : `${Math.floor(ageHours / 24)} days ago`;
+  console.log(`Freshness: ${ageLabel}`);
+  if (ageHours > 24) {
+    console.log("  Consider running `codecortex update` to refresh.");
+  }
+  console.log("");
+  const modules = await listModuleDocs(root);
+  const decisions = await listDecisions(root);
+  const sessions = await listSessions(root);
+  console.log("Knowledge Breakdown:");
+  console.log(`  Module docs:      ${modules.length}${modules.length > 0 ? ` (${modules.join(", ")})` : ""}`);
+  console.log(`  Decision records: ${decisions.length}`);
+  console.log(`  Session logs:     ${sessions.length}`);
+  const patterns = await readFile(cortexPath(root, "patterns.md"));
+  const patternCount = patterns ? (patterns.match(/^### /gm) || []).length : 0;
+  console.log(`  Coding patterns:  ${patternCount}`);
+  console.log("");
+  const symbolContent = await readFile(cortexPath(root, "symbols.json"));
+  if (symbolContent) {
+    const index = JSON.parse(symbolContent);
+    const byKind = /* @__PURE__ */ new Map();
+    for (const s of index.symbols) {
+      byKind.set(s.kind, (byKind.get(s.kind) || 0) + 1);
+    }
+    console.log("Symbol Index:");
+    for (const [kind, count] of [...byKind.entries()].sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${kind}: ${count}`);
+    }
+    const exported = index.symbols.filter((s) => s.exported).length;
+    console.log(`  Total exported: ${exported}/${index.total}`);
+    console.log("");
+  }
+  const temporalContent = await readFile(cortexPath(root, "temporal.json"));
+  if (temporalContent) {
+    const temporal = JSON.parse(temporalContent);
+    console.log("Temporal Analysis:");
+    console.log(`  Period: ${temporal.periodDays} days, ${temporal.totalCommits} commits`);
+    console.log(`  Hotspots: ${temporal.hotspots.filter((h) => h.stability === "volatile").length} volatile, ${temporal.hotspots.filter((h) => h.stability === "stabilizing").length} stabilizing`);
+    console.log(`  Couplings: ${temporal.coupling.length} pairs (${temporal.coupling.filter((c) => !c.hasImport).length} hidden)`);
+    console.log(`  Bug records: ${temporal.bugHistory.length} files with fix history`);
+    const top = temporal.hotspots.slice(0, 3);
+    if (top.length > 0) {
+      console.log(`  Top hotspots:`);
+      for (const h of top) {
+        console.log(`    ${h.file} \u2014 ${h.changes} changes (${h.stability})`);
+      }
+    }
+  }
+  const feedbackContent = await readFile(cortexPath(root, "feedback", "log.json"));
+  if (feedbackContent) {
+    const feedback = JSON.parse(feedbackContent);
+    if (feedback.length > 0) {
+      console.log("");
+      console.log(`Pending feedback: ${feedback.length} reports (will be addressed on next update)`);
+    }
+  }
+  const latestSession = await getLatestSession(root);
+  if (latestSession) {
+    console.log("");
+    console.log(`Latest session: ${latestSession}`);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("codecortex").description("Persistent, AI-powered codebase knowledge layer").version("0.1.0");
+program.command("init").description("Initialize codebase knowledge: discover files, extract symbols, analyze git history").option("-r, --root <path>", "Project root directory", process.cwd()).option("-d, --days <number>", "Days of git history to analyze", "90").action(initCommand);
+program.command("serve").description("Start MCP server (stdio transport) for AI agent access").option("-r, --root <path>", "Project root directory", process.cwd()).action(serveCommand);
+program.command("update").description("Update knowledge for changed files since last session").option("-r, --root <path>", "Project root directory", process.cwd()).option("-d, --days <number>", "Days of git history to re-analyze", "90").action(updateCommand);
+program.command("status").description("Show knowledge freshness, stale modules, and symbol counts").option("-r, --root <path>", "Project root directory", process.cwd()).action(statusCommand);
+program.parse();
+//# sourceMappingURL=index.js.map