@vohongtho.infotech/code-intel 0.1.3 → 0.1.4

package/dist/cli/main.js

@@ -1,282 +1,3446 @@
 #!/usr/bin/env node
+import { Database, Connection } from '@ladybugdb/core';
+import path, { dirname, join } from 'path';
+import fs8, { readFileSync } from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
 import { Command } from 'commander';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createKnowledgeGraph } from '../graph/knowledge-graph.js';
-import { runPipeline } from '../pipeline/orchestrator.js';
-import { scanPhase, structurePhase, parsePhase, resolvePhase, clusterPhase, flowPhase, } from '../pipeline/phases/index.js';
-import { startHttpServer } from '../http/app.js';
-import { startMcpStdio } from '../mcp-server/server.js';
-import { textSearch } from '../search/text-search.js';
-import { saveMetadata, loadMetadata, getDbPath } from '../storage/metadata.js';
-import { writeSkillFiles } from './skill-writer.js';
-import { writeContextFiles } from './context-writer.js';
-import { upsertRepo, loadRegistry, removeRepo } from '../storage/repo-registry.js';
-import { DbManager, loadGraphToDB } from '../storage/index.js';
-const program = new Command();
-program
-    .name('code-intel')
-    .description('Code Intelligence Platform — Static Analysis + Knowledge Graph')
-    .version('0.1.0');
-async function analyzeWorkspace(targetPath, options) {
-    const workspaceRoot = path.resolve(targetPath);
-    if (!options?.silent)
-        console.log(`Analyzing: ${workspaceRoot}`);
-    const graph = createKnowledgeGraph();
-    const context = {
-        workspaceRoot,
-        graph,
-        filePaths: [],
-        onProgress: options?.silent ? undefined : (phase, msg) => console.log(`  [${phase}] ${msg}`),
+import express from 'express';
+import cors from 'cors';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+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 });
+};
+var DbManager;
+var init_db_manager = __esm({
+  "src/storage/db-manager.ts"() {
+    DbManager = class {
+      db = null;
+      conn = null;
+      dbPath;
+      constructor(dbPath) {
+        this.dbPath = dbPath;
+      }
+      async init() {
+        fs8.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+        this.db = new Database(this.dbPath);
+        await this.db.init();
+        this.conn = new Connection(this.db);
+        await this.conn.init();
+      }
+      async query(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        const rows = await qr.getAll();
+        qr.close();
+        return rows;
+      }
+      async execute(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        qr.close();
+      }
+      close() {
+        try {
+          this.conn?.close();
+        } catch {
+        }
+        try {
+          this.db?.close();
+        } catch {
+        }
+        this.conn = null;
+        this.db = null;
+      }
+      get isOpen() {
+        return this.conn !== null;
+      }
     };
-    const phases = [scanPhase, structurePhase, parsePhase, resolvePhase, clusterPhase, flowPhase];
-    const result = await runPipeline(phases, context);
-    // Save metadata
-    const repoName = path.basename(workspaceRoot);
-    saveMetadata(workspaceRoot, {
-        indexedAt: new Date().toISOString(),
-        stats: {
-            nodes: graph.size.nodes,
-            edges: graph.size.edges,
-            files: context.filePaths.length,
-            duration: result.totalDuration,
-        },
-    });
-    upsertRepo({
-        name: repoName,
-        path: workspaceRoot,
-        indexedAt: new Date().toISOString(),
-        stats: {
-            nodes: graph.size.nodes,
-            edges: graph.size.edges,
-            files: context.filePaths.length,
-        },
-    });
-    // Persist graph to LadybugDB
+  }
+});
+
+// src/storage/schema.ts
+function getCreateNodeTableDDL(tableName) {
+  return `CREATE NODE TABLE IF NOT EXISTS ${tableName} (
+  id STRING,
+  name STRING,
+  file_path STRING,
+  start_line INT64,
+  end_line INT64,
+  exported BOOLEAN,
+  content STRING,
+  metadata STRING,
+  PRIMARY KEY (id)
+)`;
+}
+function getCreateEdgeTableDDL() {
+  const ddls = [];
+  const uniqueTables = ALL_NODE_TABLES;
+  const fromToPairs = [];
+  for (const from of uniqueTables) {
+    for (const to of uniqueTables) {
+      fromToPairs.push(`FROM ${from} TO ${to}`);
+    }
+  }
+  ddls.push(`CREATE REL TABLE IF NOT EXISTS code_edges (
+  ${fromToPairs.join(",\n  ")},
+  kind STRING,
+  weight DOUBLE,
+  label STRING
+)`);
+  return ddls;
+}
+var NODE_TABLE_MAP, ALL_NODE_TABLES;
+var init_schema = __esm({
+  "src/storage/schema.ts"() {
+    NODE_TABLE_MAP = {
+      file: "file_nodes",
+      directory: "dir_nodes",
+      function: "func_nodes",
+      class: "class_nodes",
+      interface: "iface_nodes",
+      method: "method_nodes",
+      constructor: "ctor_nodes",
+      variable: "var_nodes",
+      property: "prop_nodes",
+      struct: "struct_nodes",
+      enum: "enum_nodes",
+      trait: "trait_nodes",
+      namespace: "ns_nodes",
+      module: "mod_nodes",
+      type_alias: "type_nodes",
+      constant: "const_nodes",
+      route: "route_nodes",
+      cluster: "cluster_nodes",
+      flow: "flow_nodes"
+    };
+    ALL_NODE_TABLES = [...new Set(Object.values(NODE_TABLE_MAP))];
+  }
+});
+function writeNodeCSVs(graph, outputDir) {
+  fs8.mkdirSync(outputDir, { recursive: true });
+  const tableFiles = /* @__PURE__ */ new Map();
+  const tableFilePaths = /* @__PURE__ */ new Map();
+  const header = "id,name,file_path,start_line,end_line,exported,content,metadata\n";
+  for (const node of graph.allNodes()) {
+    const table = NODE_TABLE_MAP[node.kind];
+    if (!tableFiles.has(table)) {
+      const filePath = path.join(outputDir, `${table}.csv`);
+      const stream2 = fs8.createWriteStream(filePath);
+      stream2.write(header);
+      tableFiles.set(table, stream2);
+      tableFilePaths.set(table, filePath);
+    }
+    const stream = tableFiles.get(table);
+    stream.write(csvRow([
+      node.id,
+      node.name,
+      node.filePath,
+      String(node.startLine ?? ""),
+      String(node.endLine ?? ""),
+      String(node.exported ?? false),
+      (node.content ?? "").slice(0, 1e3),
+      node.metadata ? JSON.stringify(node.metadata) : ""
+    ]) + "\n");
+  }
+  for (const stream of tableFiles.values()) {
+    stream.end();
+  }
+  return tableFilePaths;
+}
+function writeEdgeCSV(graph, outputDir) {
+  fs8.mkdirSync(outputDir, { recursive: true });
+  const groups = /* @__PURE__ */ new Map();
+  const header = "from_id,to_id,kind,weight,label\n";
+  for (const edge of graph.allEdges()) {
+    const sourceNode = graph.getNode(edge.source);
+    const targetNode = graph.getNode(edge.target);
+    if (!sourceNode || !targetNode) continue;
+    const fromTable = NODE_TABLE_MAP[sourceNode.kind];
+    const toTable = NODE_TABLE_MAP[targetNode.kind];
+    const key = `${fromTable}->${toTable}`;
+    if (!groups.has(key)) {
+      const filePath = path.join(outputDir, `edges_${fromTable}_${toTable}.csv`);
+      const stream = fs8.createWriteStream(filePath);
+      stream.write(header);
+      groups.set(key, { stream, filePath, from: fromTable, to: toTable });
+    }
+    const group = groups.get(key);
+    group.stream.write(csvRow([
+      edge.source,
+      edge.target,
+      edge.kind,
+      String(edge.weight ?? 1),
+      edge.label ?? ""
+    ]) + "\n");
+  }
+  const result = [];
+  for (const group of groups.values()) {
+    group.stream.end();
+    result.push({ fromTable: group.from, toTable: group.to, filePath: group.filePath });
+  }
+  return result;
+}
+function csvRow(fields) {
+  return fields.map((f) => {
+    if (f.includes(",") || f.includes('"') || f.includes("\n")) {
+      return '"' + f.replace(/"/g, '""') + '"';
+    }
+    return f;
+  }).join(",");
+}
+var init_csv_writer = __esm({
+  "src/storage/csv-writer.ts"() {
+    init_schema();
+  }
+});
+
+// src/storage/graph-loader.ts
+async function loadGraphToDB(graph, dbManager) {
+  for (const table of ALL_NODE_TABLES) {
+    await dbManager.execute(getCreateNodeTableDDL(table));
+  }
+  const edgeDDLs = getCreateEdgeTableDDL();
+  for (const ddl of edgeDDLs) {
     try {
-        const dbPath = getDbPath(workspaceRoot);
-        const db = new DbManager(dbPath);
-        await db.init();
-        const { nodeCount, edgeCount } = await loadGraphToDB(graph, db);
-        db.close();
-        if (!options?.silent) {
-            console.log(`  DB: ${nodeCount} nodes, ${edgeCount} edges persisted`);
+      await dbManager.execute(ddl);
+    } catch {
+    }
+  }
+  let nodeCount = 0;
+  for (const node of graph.allNodes()) {
+    const table = NODE_TABLE_MAP[node.kind];
+    const props = buildNodeProps(node);
+    try {
+      await dbManager.execute(`CREATE (:${table} ${props})`);
+      nodeCount++;
+    } catch {
+    }
+  }
+  let edgeCount = 0;
+  for (const edge of graph.allEdges()) {
+    const sourceNode = graph.getNode(edge.source);
+    const targetNode = graph.getNode(edge.target);
+    if (!sourceNode || !targetNode) continue;
+    const fromTable = NODE_TABLE_MAP[sourceNode.kind];
+    const toTable = NODE_TABLE_MAP[targetNode.kind];
+    try {
+      await dbManager.execute(
+        `MATCH (a:${fromTable} {id: '${escCypher(edge.source)}'}), (b:${toTable} {id: '${escCypher(edge.target)}'}) CREATE (a)-[:code_edges {kind: '${edge.kind}', weight: ${edge.weight ?? 1}, label: '${escCypher(edge.label ?? "")}'}]->(b)`
+      );
+      edgeCount++;
+    } catch {
+    }
+  }
+  return { nodeCount, edgeCount };
+}
+function buildNodeProps(node) {
+  const parts = [
+    `id: '${escCypher(node.id)}'`,
+    `name: '${escCypher(node.name)}'`,
+    `file_path: '${escCypher(node.filePath)}'`
+  ];
+  if (node.startLine !== void 0) parts.push(`start_line: ${node.startLine}`);
+  if (node.endLine !== void 0) parts.push(`end_line: ${node.endLine}`);
+  if (node.exported !== void 0) parts.push(`exported: ${node.exported}`);
+  if (node.content) parts.push(`content: '${escCypher(node.content.slice(0, 500))}'`);
+  if (node.metadata) parts.push(`metadata: '${escCypher(JSON.stringify(node.metadata))}'`);
+  return `{${parts.join(", ")}}`;
+}
+function escCypher(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+var init_graph_loader = __esm({
+  "src/storage/graph-loader.ts"() {
+    init_schema();
+  }
+});
+function loadRegistry() {
+  try {
+    const data = fs8.readFileSync(REPOS_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function saveRegistry(entries) {
+  fs8.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs8.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+}
+function upsertRepo(entry) {
+  const entries = loadRegistry();
+  const idx = entries.findIndex((e) => e.path === entry.path);
+  if (idx >= 0) {
+    entries[idx] = entry;
+  } else {
+    entries.push(entry);
+  }
+  saveRegistry(entries);
+}
+function removeRepo(repoPath) {
+  const entries = loadRegistry().filter((e) => e.path !== repoPath);
+  saveRegistry(entries);
+}
+var GLOBAL_DIR, REPOS_FILE;
+var init_repo_registry = __esm({
+  "src/storage/repo-registry.ts"() {
+    GLOBAL_DIR = path.join(os.homedir(), ".code-intel");
+    REPOS_FILE = path.join(GLOBAL_DIR, "repos.json");
+  }
+});
+function saveMetadata(repoDir, metadata) {
+  const metaDir = path.join(repoDir, ".code-intel");
+  fs8.mkdirSync(metaDir, { recursive: true });
+  fs8.writeFileSync(path.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+}
+function loadMetadata(repoDir) {
+  try {
+    const data = fs8.readFileSync(path.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function getDbPath(repoDir) {
+  return path.join(repoDir, ".code-intel", "graph.db");
+}
+function getVectorDbPath(repoDir) {
+  return path.join(repoDir, ".code-intel", "vector.db");
+}
+var init_metadata = __esm({
+  "src/storage/metadata.ts"() {
+  }
+});
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  ALL_NODE_TABLES: () => ALL_NODE_TABLES,
+  DbManager: () => DbManager,
+  NODE_TABLE_MAP: () => NODE_TABLE_MAP,
+  getCreateEdgeTableDDL: () => getCreateEdgeTableDDL,
+  getCreateNodeTableDDL: () => getCreateNodeTableDDL,
+  getDbPath: () => getDbPath,
+  getVectorDbPath: () => getVectorDbPath,
+  loadGraphToDB: () => loadGraphToDB,
+  loadMetadata: () => loadMetadata,
+  loadRegistry: () => loadRegistry,
+  removeRepo: () => removeRepo,
+  saveMetadata: () => saveMetadata,
+  saveRegistry: () => saveRegistry,
+  upsertRepo: () => upsertRepo,
+  writeEdgeCSV: () => writeEdgeCSV,
+  writeNodeCSVs: () => writeNodeCSVs
+});
+var init_storage = __esm({
+  "src/storage/index.ts"() {
+    init_db_manager();
+    init_schema();
+    init_csv_writer();
+    init_graph_loader();
+    init_repo_registry();
+    init_metadata();
+  }
+});
+
+// src/search/vector-index.ts
+var vector_index_exports = {};
+__export(vector_index_exports, {
+  VectorIndex: () => VectorIndex
+});
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+var EMBED_TABLE, EMBED_DIM, INDEX_NAME, VectorIndex;
+var init_vector_index = __esm({
+  "src/search/vector-index.ts"() {
+    EMBED_TABLE = "embed_nodes";
+    EMBED_DIM = 384;
+    INDEX_NAME = "embed_vec_idx";
+    VectorIndex = class {
+      db;
+      constructor(db) {
+        this.db = db;
+      }
+      async init() {
+        await this.db.execute("INSTALL VECTOR");
+        await this.db.execute("LOAD EXTENSION VECTOR");
+        await this.db.execute(`
+      CREATE NODE TABLE IF NOT EXISTS ${EMBED_TABLE} (
+        id STRING,
+        name STRING,
+        kind STRING,
+        file_path STRING,
+        text STRING,
+        embedding FLOAT[${EMBED_DIM}],
+        PRIMARY KEY (id)
+      )
+    `);
+      }
+      async buildIndex(nodes) {
+        await this.db.execute(`MATCH (n:${EMBED_TABLE}) DETACH DELETE n`).catch(() => {
+        });
+        for (const node of nodes) {
+          const vecLiteral = `[${node.embedding.join(",")}]`;
+          await this.db.execute(
+            `CREATE (:${EMBED_TABLE} {
+          id: '${esc(node.id)}',
+          name: '${esc(node.name)}',
+          kind: '${esc(node.kind)}',
+          file_path: '${esc(node.filePath)}',
+          text: '${esc(node.text)}',
+          embedding: ${vecLiteral}
+        })`
+          );
+        }
+        await this.db.execute(`CALL DROP_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}')`).catch(() => {
+        });
+        await this.db.execute(`CALL CREATE_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}', 'embedding')`);
+      }
+      async search(queryEmbedding, topK = 10) {
+        const vecLiteral = `[${queryEmbedding.join(",")}]`;
+        const rows = await this.db.query(
+          `CALL QUERY_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}', ${vecLiteral}, ${topK}) RETURN node.id, node.name, node.kind, node.file_path, distance`
+        );
+        return rows.map((r) => ({
+          nodeId: String(r["node.id"]),
+          name: String(r["node.name"]),
+          kind: String(r["node.kind"]),
+          filePath: String(r["node.file_path"]),
+          score: 1 - Number(r["distance"])
+          // cosine distance → similarity
+        }));
+      }
+      async isBuilt() {
+        try {
+          const rows = await this.db.query(`MATCH (n:${EMBED_TABLE}) RETURN count(n) AS cnt`);
+          return Number(rows[0]?.cnt ?? 0) > 0;
+        } catch {
+          return false;
         }
+      }
+    };
+  }
+});
+
+// src/multi-repo/group-registry.ts
+var group_registry_exports = {};
+__export(group_registry_exports, {
+  addMember: () => addMember,
+  deleteGroup: () => deleteGroup,
+  groupExists: () => groupExists,
+  listGroups: () => listGroups,
+  loadGroup: () => loadGroup,
+  loadSyncResult: () => loadSyncResult,
+  removeMember: () => removeMember,
+  saveGroup: () => saveGroup,
+  saveSyncResult: () => saveSyncResult
+});
+function groupFile(name) {
+  return path.join(GROUPS_DIR, `${name}.json`);
+}
+function loadGroup(name) {
+  try {
+    return JSON.parse(fs8.readFileSync(groupFile(name), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveGroup(group) {
+  fs8.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs8.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+}
+function listGroups() {
+  const groups = [];
+  try {
+    for (const file of fs8.readdirSync(GROUPS_DIR)) {
+      if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
+      try {
+        const g = JSON.parse(
+          fs8.readFileSync(path.join(GROUPS_DIR, file), "utf-8")
+        );
+        groups.push(g);
+      } catch {
+      }
     }
-    catch (err) {
-        if (!options?.silent) {
-            console.warn(`  DB persist warning: ${err instanceof Error ? err.message : err}`);
+  } catch {
+  }
+  return groups;
+}
+function deleteGroup(name) {
+  try {
+    fs8.unlinkSync(groupFile(name));
+  } catch {
+  }
+  try {
+    fs8.unlinkSync(path.join(GROUPS_DIR, `${name}.sync.json`));
+  } catch {
+  }
+}
+function groupExists(name) {
+  return fs8.existsSync(groupFile(name));
+}
+function addMember(groupName, member) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const idx = group.members.findIndex((m) => m.groupPath === member.groupPath);
+  if (idx >= 0) {
+    group.members[idx] = member;
+  } else {
+    group.members.push(member);
+  }
+  saveGroup(group);
+  return group;
+}
+function removeMember(groupName, groupPath) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const before = group.members.length;
+  group.members = group.members.filter((m) => m.groupPath !== groupPath);
+  if (group.members.length === before) {
+    throw new Error(`No member at path "${groupPath}" in group "${groupName}".`);
+  }
+  saveGroup(group);
+  return group;
+}
+function saveSyncResult(result) {
+  fs8.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs8.writeFileSync(
+    path.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+    JSON.stringify(result, null, 2) + "\n"
+  );
+}
+function loadSyncResult(groupName) {
+  try {
+    return JSON.parse(
+      fs8.readFileSync(path.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+    );
+  } catch {
+    return null;
+  }
+}
+var GROUPS_DIR;
+var init_group_registry = __esm({
+  "src/multi-repo/group-registry.ts"() {
+    GROUPS_DIR = path.join(os.homedir(), ".code-intel", "groups");
+  }
+});
+
+// src/search/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  embedNodes: () => embedNodes
+});
+async function getEmbedder() {
+  if (!pipelineInstance) {
+    const { pipeline } = await import('@huggingface/transformers');
+    pipelineInstance = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+  }
+  return pipelineInstance;
+}
+async function embedNodes(graph, opts = {}) {
+  const { batchSize = 32, onProgress } = opts;
+  const candidates = [];
+  for (const node of graph.allNodes()) {
+    if (["cluster", "directory", "flow"].includes(node.kind)) continue;
+    const text = buildText(node);
+    candidates.push({ id: node.id, name: node.name, kind: node.kind, filePath: node.filePath, text });
+  }
+  const embedder = await getEmbedder();
+  const results = [];
+  for (let i = 0; i < candidates.length; i += batchSize) {
+    const batch = candidates.slice(i, i + batchSize);
+    const texts = batch.map((c) => c.text);
+    for (let j = 0; j < texts.length; j++) {
+      const out = await embedder(texts[j], { pooling: "mean", normalize: true });
+      results.push({ ...batch[j], embedding: Array.from(out.data) });
+    }
+    onProgress?.(Math.min(i + batchSize, candidates.length), candidates.length);
+  }
+  return results;
+}
+function buildText(node) {
+  const parts = [`${node.kind} ${node.name}`];
+  const sig = node.metadata?.signature;
+  if (sig) parts.push(sig);
+  if (node.content) parts.push(node.content.slice(0, 256));
+  parts.push(node.filePath);
+  return parts.join(" ").slice(0, 512);
+}
+var pipelineInstance;
+var init_embedder = __esm({
+  "src/search/embedder.ts"() {
+    pipelineInstance = null;
+  }
+});
+
+// src/graph/knowledge-graph.ts
+function createKnowledgeGraph() {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByKind = /* @__PURE__ */ new Map();
+  const edgesFromNode = /* @__PURE__ */ new Map();
+  const edgesToNode = /* @__PURE__ */ new Map();
+  function indexEdge(edge) {
+    let kindSet = edgesByKind.get(edge.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      edgesByKind.set(edge.kind, kindSet);
+    }
+    kindSet.add(edge.id);
+    let fromSet = edgesFromNode.get(edge.source);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      edgesFromNode.set(edge.source, fromSet);
+    }
+    fromSet.add(edge.id);
+    let toSet = edgesToNode.get(edge.target);
+    if (!toSet) {
+      toSet = /* @__PURE__ */ new Set();
+      edgesToNode.set(edge.target, toSet);
+    }
+    toSet.add(edge.id);
+  }
+  function unindexEdge(edge) {
+    edgesByKind.get(edge.kind)?.delete(edge.id);
+    edgesFromNode.get(edge.source)?.delete(edge.id);
+    edgesToNode.get(edge.target)?.delete(edge.id);
+  }
+  return {
+    addNode(node) {
+      nodes.set(node.id, node);
+    },
+    addEdge(edge) {
+      edges.set(edge.id, edge);
+      indexEdge(edge);
+    },
+    getNode(id) {
+      return nodes.get(id);
+    },
+    getEdge(id) {
+      return edges.get(id);
+    },
+    *findEdgesByKind(kind) {
+      const ids = edgesByKind.get(kind);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesFrom(sourceId) {
+      const ids = edgesFromNode.get(sourceId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesTo(targetId) {
+      const ids = edgesToNode.get(targetId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    removeNodeCascade(id) {
+      const fromEdges = edgesFromNode.get(id);
+      if (fromEdges) {
+        for (const edgeId of [...fromEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
         }
+      }
+      const toEdges = edgesToNode.get(id);
+      if (toEdges) {
+        for (const edgeId of [...toEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      edgesFromNode.delete(id);
+      edgesToNode.delete(id);
+      nodes.delete(id);
+    },
+    removeEdge(id) {
+      const edge = edges.get(id);
+      if (edge) {
+        unindexEdge(edge);
+        edges.delete(id);
+      }
+    },
+    *allNodes() {
+      yield* nodes.values();
+    },
+    *allEdges() {
+      yield* edges.values();
+    },
+    get size() {
+      return { nodes: nodes.size, edges: edges.size };
+    },
+    clear() {
+      nodes.clear();
+      edges.clear();
+      edgesByKind.clear();
+      edgesFromNode.clear();
+      edgesToNode.clear();
+    }
+  };
+}
+
+// src/pipeline/dag-validator.ts
+function validateDAG(phases) {
+  const errors = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const phase of phases) {
+    if (names.has(phase.name)) {
+      errors.push({ type: "duplicate", message: `Duplicate phase name: ${phase.name}` });
+    }
+    names.add(phase.name);
+  }
+  for (const phase of phases) {
+    for (const dep of phase.dependencies) {
+      if (!names.has(dep)) {
+        errors.push({
+          type: "missing-dep",
+          message: `Phase "${phase.name}" depends on missing phase "${dep}"`
+        });
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const phaseMap = new Map(phases.map((p) => [p.name, p]));
+  function dfs(name, path15) {
+    if (visiting.has(name)) {
+      const cycleStart = path15.indexOf(name);
+      const cycle = path15.slice(cycleStart).concat(name);
+      errors.push({ type: "cycle", message: `Cycle detected: ${cycle.join(" \u2192 ")}` });
+      return true;
+    }
+    if (visited.has(name)) return false;
+    visiting.add(name);
+    path15.push(name);
+    const phase = phaseMap.get(name);
+    if (phase) {
+      for (const dep of phase.dependencies) {
+        if (dfs(dep, path15)) return true;
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    path15.pop();
+    return false;
+  }
+  for (const phase of phases) {
+    if (!visited.has(phase.name)) {
+      dfs(phase.name, []);
+    }
+  }
+  return errors;
+}
+function topologicalSort(phases) {
+  const phaseMap = new Map(phases.map((p) => [p.name, p]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const phase of phases) {
+    inDegree.set(phase.name, 0);
+    adjList.set(phase.name, []);
+  }
+  for (const phase of phases) {
+    for (const dep of phase.dependencies) {
+      adjList.get(dep)?.push(phase.name);
+      inDegree.set(phase.name, (inDegree.get(phase.name) ?? 0) + 1);
     }
-    // Generate .claude/skills/code-intel/ skill files
-    let skillSummaries = [];
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) queue.push(name);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(phaseMap.get(current));
+    for (const neighbor of adjList.get(current) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  return sorted;
+}
+
+// src/pipeline/orchestrator.ts
+async function runPipeline(phases, context) {
+  const errors = validateDAG(phases);
+  if (errors.length > 0) {
+    throw new Error(`Pipeline validation failed:
+${errors.map((e) => e.message).join("\n")}`);
+  }
+  const sorted = topologicalSort(phases);
+  const results = /* @__PURE__ */ new Map();
+  const startTime = Date.now();
+  let success = true;
+  for (const phase of sorted) {
+    context.onProgress?.(phase.name, "running");
+    const phaseStart = Date.now();
     try {
-        const { skills } = await writeSkillFiles(graph, workspaceRoot, repoName);
-        skillSummaries = skills;
-        if (!options?.silent && skills.length > 0) {
-            console.log(`  Skills: ${skills.length} generated → .claude/skills/code-intel/`);
+      const depResults = /* @__PURE__ */ new Map();
+      for (const dep of phase.dependencies) {
+        const depResult = results.get(dep);
+        if (depResult) depResults.set(dep, depResult);
+      }
+      const result = await phase.execute(context, depResults);
+      results.set(phase.name, result);
+      context.onProgress?.(phase.name, result.status);
+      if (result.status === "failed") {
+        success = false;
+        break;
+      }
+    } catch (err) {
+      const result = {
+        status: "failed",
+        duration: Date.now() - phaseStart,
+        message: err instanceof Error ? err.message : String(err)
+      };
+      results.set(phase.name, result);
+      context.onProgress?.(phase.name, "failed");
+      success = false;
+      break;
+    }
+  }
+  return {
+    success,
+    results,
+    totalDuration: Date.now() - startTime
+  };
+}
+
+// src/shared/detection.ts
+var EXTENSION_MAP = {
+  ".ts": "typescript" /* TypeScript */,
+  ".tsx": "typescript" /* TypeScript */,
+  ".mts": "typescript" /* TypeScript */,
+  ".cts": "typescript" /* TypeScript */,
+  ".js": "javascript" /* JavaScript */,
+  ".jsx": "javascript" /* JavaScript */,
+  ".mjs": "javascript" /* JavaScript */,
+  ".cjs": "javascript" /* JavaScript */,
+  ".py": "python" /* Python */,
+  ".pyi": "python" /* Python */,
+  ".java": "java" /* Java */,
+  ".go": "go" /* Go */,
+  ".c": "c" /* C */,
+  ".h": "c" /* C */,
+  ".cpp": "cpp" /* Cpp */,
+  ".cxx": "cpp" /* Cpp */,
+  ".cc": "cpp" /* Cpp */,
+  ".hpp": "cpp" /* Cpp */,
+  ".hxx": "cpp" /* Cpp */,
+  ".cs": "csharp" /* CSharp */,
+  ".rs": "rust" /* Rust */,
+  ".php": "php" /* PHP */,
+  ".kt": "kotlin" /* Kotlin */,
+  ".kts": "kotlin" /* Kotlin */,
+  ".rb": "ruby" /* Ruby */,
+  ".swift": "swift" /* Swift */,
+  ".dart": "dart" /* Dart */
+};
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext] ?? null;
+}
+function getSupportedExtensions() {
+  return Object.keys(EXTENSION_MAP);
+}
+
+// src/graph/id-generator.ts
+function generateNodeId(kind, filePath, qualifiedName) {
+  return `${kind}:${filePath}:${qualifiedName}`;
+}
+function generateEdgeId(source, target, kind) {
+  return `${kind}:${source}->${target}`;
+}
+
+// src/pipeline/phases/scan-phase.ts
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "dist-tests",
+  "build",
+  "out",
+  "__pycache__",
+  ".tox",
+  ".pytest_cache",
+  ".mypy_cache",
+  "vendor",
+  "target",
+  ".code-intel",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  "tmp",
+  "temp",
+  ".parcel-cache"
+]);
+function loadIgnorePatterns(workspaceRoot) {
+  try {
+    const raw = fs8.readFileSync(path.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const extras = /* @__PURE__ */ new Set();
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) extras.add(trimmed);
+    }
+    return extras;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var scanPhase = {
+  name: "scan",
+  dependencies: [],
+  async execute(context) {
+    const start = Date.now();
+    const extensions = new Set(getSupportedExtensions());
+    const filePaths = [];
+    const extraIgnore = loadIgnorePatterns(context.workspaceRoot);
+    function walk(dir) {
+      let entries;
+      try {
+        entries = fs8.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") && entry.isDirectory()) continue;
+        if (IGNORED_DIRS.has(entry.name) && entry.isDirectory()) continue;
+        if (extraIgnore.has(entry.name) && entry.isDirectory()) continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name);
+          const fullName = entry.name;
+          if (fullName.endsWith(".d.ts") || fullName.endsWith(".js.map") || fullName.endsWith(".d.ts.map")) continue;
+          if (extensions.has(ext)) {
+            filePaths.push(fullPath);
+          }
         }
+      }
+    }
+    walk(context.workspaceRoot);
+    context.filePaths.push(...filePaths);
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Found ${filePaths.length} source files`
+    };
+  }
+};
+var structurePhase = {
+  name: "structure",
+  dependencies: ["scan"],
+  async execute(context) {
+    const start = Date.now();
+    const dirs = /* @__PURE__ */ new Set();
+    for (const filePath of context.filePaths) {
+      const relativePath = path.relative(context.workspaceRoot, filePath);
+      const lang = detectLanguage(filePath);
+      context.graph.addNode({
+        id: generateNodeId("file", relativePath, relativePath),
+        kind: "file",
+        name: path.basename(filePath),
+        filePath: relativePath,
+        metadata: lang ? { language: lang } : void 0
+      });
+      let dir = path.dirname(relativePath);
+      while (dir && dir !== "." && dir !== "") {
+        if (dirs.has(dir)) break;
+        dirs.add(dir);
+        dir = path.dirname(dir);
+      }
     }
-    catch (err) {
-        if (!options?.silent) {
-            console.warn(`  Skills warning: ${err instanceof Error ? err.message : err}`);
+    for (const dir of dirs) {
+      context.graph.addNode({
+        id: generateNodeId("directory", dir, dir),
+        kind: "directory",
+        name: path.basename(dir),
+        filePath: dir
+      });
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Created ${context.filePaths.length} file nodes, ${dirs.size} directory nodes`
+    };
+  }
+};
+var parsePhase = {
+  name: "parse",
+  dependencies: ["structure"],
+  async execute(context) {
+    const start = Date.now();
+    let symbolCount = 0;
+    for (const filePath of context.filePaths) {
+      const lang = detectLanguage(filePath);
+      if (!lang) {
+        if (context.verbose) {
+          const relativePath2 = path.relative(context.workspaceRoot, filePath);
+          console.log(`  [parse] skipped (no parser): ${relativePath2}`);
         }
+        continue;
+      }
+      const relativePath = path.relative(context.workspaceRoot, filePath);
+      const fileNodeId = generateNodeId("file", relativePath, relativePath);
+      let source;
+      try {
+        source = fs8.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const fileNode = context.graph.getNode(fileNodeId);
+      if (fileNode) {
+        fileNode.content = source.slice(0, 2e3);
+      }
+      const nodes = [];
+      const edges = [];
+      const seen = /* @__PURE__ */ new Set();
+      const lines = source.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+        const extracted = extractSymbol(trimmed, lang);
+        if (!extracted) continue;
+        if (seen.has(extracted.name + ":" + extracted.kind)) continue;
+        seen.add(extracted.name + ":" + extracted.kind);
+        const nodeId = generateNodeId(extracted.kind, relativePath, extracted.name);
+        nodes.push({
+          id: nodeId,
+          kind: extracted.kind,
+          name: extracted.name,
+          filePath: relativePath,
+          startLine: i + 1,
+          exported: extracted.exported,
+          content: extractBlock(lines, i, 20)
+        });
+        edges.push({
+          id: generateEdgeId(fileNodeId, nodeId, "contains"),
+          source: fileNodeId,
+          target: nodeId,
+          kind: "contains",
+          weight: 1
+        });
+        if (extracted.ownerName) {
+          const ownerId = generateNodeId("class", relativePath, extracted.ownerName);
+          if (context.graph.getNode(ownerId) || nodes.some((n) => n.id === ownerId)) {
+            edges.push({
+              id: generateEdgeId(ownerId, nodeId, "has_member"),
+              source: ownerId,
+              target: nodeId,
+              kind: "has_member",
+              weight: 1
+            });
+          }
+        }
+        symbolCount++;
+      }
+      for (const n of nodes) context.graph.addNode(n);
+      for (const e of edges) context.graph.addEdge(e);
     }
-    // Write AGENTS.md + CLAUDE.md context blocks
-    try {
-        writeContextFiles(workspaceRoot, repoName, {
-            nodes: graph.size.nodes,
-            edges: graph.size.edges,
-            files: context.filePaths.length,
-            duration: result.totalDuration,
-        }, skillSummaries);
-        if (!options?.silent) {
-            console.log(`  Context: AGENTS.md + CLAUDE.md updated`);
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Extracted ${symbolCount} symbols`
+    };
+  }
+};
+function extractSymbol(line, lang, _lineNum, _filePath) {
+  if (lang === "typescript" /* TypeScript */ || lang === "javascript" /* JavaScript */) {
+    const func = line.match(/^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.includes("export") };
+    const arrowFunc = line.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+    if (arrowFunc) return { kind: "function", name: arrowFunc[1], exported: line.includes("export") };
+    const arrowFunc2 = line.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/);
+    if (arrowFunc2) return { kind: "function", name: arrowFunc2[1], exported: line.includes("export") };
+    const cls = line.match(/^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("export") };
+    const iface = line.match(/^(?:export\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("export") };
+    const enumM = line.match(/^(?:export\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.includes("export") };
+    const typeAlias = line.match(/^(?:export\s+)?type\s+(\w+)\s*[=<]/);
+    if (typeAlias) return { kind: "type_alias", name: typeAlias[1], exported: line.includes("export") };
+    const constVar = line.match(/^(?:export\s+)?const\s+(\w+)\s*(?::\s*\w[^=]*)?\s*=/);
+    if (constVar && /^[A-Z_]+$/.test(constVar[1])) {
+      return { kind: "constant", name: constVar[1], exported: line.includes("export") };
+    }
+    const method = line.match(/^(?:(?:public|private|protected|static|async|readonly)\s+)*(\w+)\s*\(/);
+    if (method && !["if", "for", "while", "switch", "catch", "return", "constructor"].includes(method[1])) {
+      if (method[1] === "constructor") {
+        return { kind: "constructor", name: "constructor", exported: false };
+      }
+    }
+  }
+  if (lang === "python" /* Python */) {
+    const func = line.match(/^(?:async\s+)?def\s+(\w+)/);
+    if (func) return { kind: func[1].startsWith("__") ? "method" : "function", name: func[1], exported: !func[1].startsWith("_") };
+    const cls = line.match(/^class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !cls[1].startsWith("_") };
+  }
+  if (lang === "java" /* Java */) {
+    const cls = line.match(/(?:public|private|protected)?\s*(?:static\s+)?(?:abstract\s+)?(?:final\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("public") };
+    const iface = line.match(/(?:public\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("public") };
+    const enumM = line.match(/(?:public\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.includes("public") };
+    const method = line.match(/(?:public|private|protected)\s+(?:static\s+)?(?:[\w<>\[\]]+)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: line.includes("public") };
+  }
+  if (lang === "go" /* Go */) {
+    const func = line.match(/^func\s+(\w+)\s*\(/);
+    if (func) return { kind: "function", name: func[1], exported: func[1][0] === func[1][0].toUpperCase() };
+    const method = line.match(/^func\s+\([^)]+\)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: method[1][0] === method[1][0].toUpperCase() };
+    const structM = line.match(/^type\s+(\w+)\s+struct\b/);
+    if (structM) return { kind: "struct", name: structM[1], exported: structM[1][0] === structM[1][0].toUpperCase() };
+    const ifaceM = line.match(/^type\s+(\w+)\s+interface\b/);
+    if (ifaceM) return { kind: "interface", name: ifaceM[1], exported: ifaceM[1][0] === ifaceM[1][0].toUpperCase() };
+  }
+  if (lang === "rust" /* Rust */) {
+    const func = line.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.startsWith("pub") };
+    const structM = line.match(/^(?:pub\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: line.startsWith("pub") };
+    const enumM = line.match(/^(?:pub\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.startsWith("pub") };
+    const traitM = line.match(/^(?:pub\s+)?trait\s+(\w+)/);
+    if (traitM) return { kind: "trait", name: traitM[1], exported: line.startsWith("pub") };
+    const implM = line.match(/^impl(?:<[^>]*>)?\s+(\w+)/);
+    if (implM) return { kind: "class", name: implM[1], exported: false };
+  }
+  if (lang === "c" /* C */ || lang === "cpp" /* Cpp */) {
+    const cls = line.match(/^(?:class|struct)\s+(\w+)/);
+    if (cls) return { kind: lang === "cpp" /* Cpp */ ? "class" : "struct", name: cls[1], exported: true };
+    const nsM = line.match(/^namespace\s+(\w+)/);
+    if (nsM) return { kind: "namespace", name: nsM[1], exported: true };
+    const func = line.match(/^(?:[\w:*&<>\[\]]+\s+)+(\w+)\s*\([^;]*$/);
+    if (func && !["if", "for", "while", "switch", "return"].includes(func[1])) {
+      return { kind: "function", name: func[1], exported: true };
+    }
+  }
+  if (lang === "csharp" /* CSharp */) {
+    const cls = line.match(/(?:public|internal|private)?\s*(?:static\s+)?(?:abstract\s+)?(?:partial\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("public") };
+    const iface = line.match(/(?:public\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("public") };
+    const structM = line.match(/(?:public\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: line.includes("public") };
+    const method = line.match(/(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:[\w<>\[\]?]+)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: line.includes("public") };
+    const nsM = line.match(/namespace\s+([\w.]+)/);
+    if (nsM) return { kind: "namespace", name: nsM[1], exported: true };
+  }
+  if (lang === "php" /* PHP */) {
+    const cls = line.match(/(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: true };
+    const func = line.match(/(?:public|private|protected|static\s+)*function\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.includes("public") || !line.includes("private") };
+    const iface = line.match(/interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: true };
+    const traitM = line.match(/trait\s+(\w+)/);
+    if (traitM) return { kind: "trait", name: traitM[1], exported: true };
+  }
+  if (lang === "kotlin" /* Kotlin */) {
+    const cls = line.match(/(?:data\s+|sealed\s+|abstract\s+|open\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !line.includes("private") };
+    const iface = line.match(/interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: !line.includes("private") };
+    const func = line.match(/(?:suspend\s+)?fun\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: !line.includes("private") };
+    const obj = line.match(/object\s+(\w+)/);
+    if (obj) return { kind: "class", name: obj[1], exported: !line.includes("private") };
+  }
+  if (lang === "ruby" /* Ruby */) {
+    const cls = line.match(/^class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: true };
+    const modM = line.match(/^module\s+(\w+)/);
+    if (modM) return { kind: "module", name: modM[1], exported: true };
+    const method = line.match(/^(?:def\s+(?:self\.)?(\w+))/);
+    if (method) return { kind: "method", name: method[1], exported: true };
+  }
+  if (lang === "swift" /* Swift */) {
+    const cls = line.match(/(?:public\s+|open\s+)?(?:final\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !line.includes("private") };
+    const structM = line.match(/(?:public\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: !line.includes("private") };
+    const proto = line.match(/(?:public\s+)?protocol\s+(\w+)/);
+    if (proto) return { kind: "interface", name: proto[1], exported: !line.includes("private") };
+    const enumM = line.match(/(?:public\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: !line.includes("private") };
+    const func = line.match(/(?:public\s+|private\s+|internal\s+)?(?:static\s+)?func\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: !line.includes("private") };
+  }
+  if (lang === "dart" /* Dart */) {
+    const cls = line.match(/(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !cls[1].startsWith("_") };
+    const func = line.match(/^(?:\w+\s+)?(\w+)\s*\(/);
+    if (func && !["if", "for", "while", "switch", "catch", "return"].includes(func[1])) {
+      return { kind: "function", name: func[1], exported: !func[1].startsWith("_") };
+    }
+  }
+  return null;
+}
+function extractBlock(lines, startIdx, maxLines) {
+  const end = Math.min(startIdx + maxLines, lines.length);
+  return lines.slice(startIdx, end).join("\n");
+}
+var resolvePhase = {
+  name: "resolve",
+  dependencies: ["parse"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph, workspaceRoot, filePaths } = context;
+    let importEdges = 0;
+    let callEdges = 0;
+    let heritageEdges = 0;
+    const fileIndex = /* @__PURE__ */ new Map();
+    for (const fp of filePaths) {
+      const rel = path.relative(workspaceRoot, fp);
+      fileIndex.set(rel, fp);
+      const noExt = rel.replace(/\.\w+$/, "");
+      if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
+      const base = path.basename(rel, path.extname(rel));
+      if (!fileIndex.has(base)) fileIndex.set(base, fp);
+    }
+    const symbolIndex = /* @__PURE__ */ new Map();
+    const fileSymbolIndex = /* @__PURE__ */ new Map();
+    for (const node of graph.allNodes()) {
+      if (["function", "class", "interface", "method", "enum", "type_alias", "variable", "constant", "struct", "trait"].includes(node.kind)) {
+        symbolIndex.set(node.name, node.id);
+        let fileMap = fileSymbolIndex.get(node.filePath);
+        if (!fileMap) {
+          fileMap = /* @__PURE__ */ new Map();
+          fileSymbolIndex.set(node.filePath, fileMap);
         }
+        fileMap.set(node.name, node.id);
+      }
     }
-    catch (err) {
-        if (!options?.silent) {
-            console.warn(`  Context warning: ${err instanceof Error ? err.message : err}`);
+    for (const filePath of filePaths) {
+      const lang = detectLanguage(filePath);
+      if (!lang) continue;
+      const relativePath = path.relative(workspaceRoot, filePath);
+      const fileNodeId = generateNodeId("file", relativePath, relativePath);
+      let source;
+      try {
+        source = fs8.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = source.split("\n");
+      const imports = extractImports(lines, lang === "python");
+      const calls = extractCalls(lines);
+      const heritages = extractHeritage(lines);
+      for (const imp of imports) {
+        const cleaned = imp.rawPath.replace(/['"]/g, "");
+        let resolvedRelPath = null;
+        if (cleaned.startsWith(".")) {
+          const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
+          const fromDir = path.dirname(relativePath);
+          for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
+            const candidate = path.join(fromDir, cleanedNoJs + ext);
+            const normalized = path.normalize(candidate);
+            if (fileIndex.has(normalized)) {
+              const absPath = fileIndex.get(normalized);
+              resolvedRelPath = path.relative(workspaceRoot, absPath);
+              break;
+            }
+          }
+        } else {
+          for (const ext of ["", ".ts", ".js", ".py", ".java", ".go"]) {
+            if (fileIndex.has(cleaned + ext)) {
+              resolvedRelPath = cleaned + ext;
+              break;
+            }
+          }
+          const asPath = cleaned.replace(/\./g, "/");
+          for (const ext of ["", ".ts", ".js", ".py", ".java", ".go", "/index.ts", "/__init__.py"]) {
+            if (fileIndex.has(asPath + ext)) {
+              resolvedRelPath = asPath + ext;
+              break;
+            }
+          }
         }
+        if (resolvedRelPath) {
+          const targetFileId = generateNodeId("file", resolvedRelPath, resolvedRelPath);
+          if (graph.getNode(targetFileId)) {
+            const edgeId = generateEdgeId(fileNodeId, targetFileId, "imports");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: fileNodeId,
+                target: targetFileId,
+                kind: "imports",
+                weight: 0.95,
+                label: cleaned
+              });
+              importEdges++;
+            }
+          }
+        }
+      }
+      const localSymbols = fileSymbolIndex.get(relativePath);
+      for (const call of calls) {
+        let targetId = localSymbols?.get(call.name);
+        let confidence = 0.95;
+        if (!targetId) {
+          targetId = symbolIndex.get(call.name);
+          confidence = 0.5;
+        }
+        if (targetId) {
+          const callerNodeId = findEnclosingFunction(graph, relativePath, call.line);
+          const sourceId = callerNodeId ?? fileNodeId;
+          if (sourceId !== targetId) {
+            const edgeId = generateEdgeId(sourceId, targetId, "calls");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: sourceId,
+                target: targetId,
+                kind: "calls",
+                weight: confidence,
+                label: call.name
+              });
+              callEdges++;
+            }
+          }
+        }
+      }
+      for (const h of heritages) {
+        const classNodeId = localSymbols?.get(h.className) ?? symbolIndex.get(h.className);
+        if (!classNodeId) continue;
+        for (const ext of h.extendsNames) {
+          const targetId = symbolIndex.get(ext);
+          if (targetId) {
+            const edgeId = generateEdgeId(classNodeId, targetId, "extends");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: classNodeId,
+                target: targetId,
+                kind: "extends",
+                weight: 1,
+                label: `extends ${ext}`
+              });
+              heritageEdges++;
+            }
+          }
+        }
+        for (const impl of h.implementsNames) {
+          const targetId = symbolIndex.get(impl);
+          if (targetId) {
+            const edgeId = generateEdgeId(classNodeId, targetId, "implements");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: classNodeId,
+                target: targetId,
+                kind: "implements",
+                weight: 1,
+                label: `implements ${impl}`
+              });
+              heritageEdges++;
+            }
+          }
+        }
+      }
     }
-    if (!options?.silent) {
-        console.log(`\nDone in ${result.totalDuration}ms`);
-        console.log(`  Nodes: ${graph.size.nodes}`);
-        console.log(`  Edges: ${graph.size.edges}`);
-        console.log(`  Files: ${context.filePaths.length}`);
-        console.log(`  Success: ${result.success}`);
-    }
-    return { graph, result, repoName, workspaceRoot };
-}
-program
-    .command('analyze')
-    .description('Analyze a codebase and build the knowledge graph')
-    .argument('[path]', 'Path to analyze', '.')
-    .action(async (targetPath) => {
-    await analyzeWorkspace(targetPath);
-});
-program
-    .command('serve')
-    .description('Start the HTTP API server')
-    .option('-p, --port <port>', 'Port number', '4747')
-    .argument('[path]', 'Path to analyze', '.')
-    .action(async (targetPath, options) => {
-    const { graph, repoName, workspaceRoot } = await analyzeWorkspace(targetPath);
-    startHttpServer(graph, repoName, parseInt(options.port, 10), workspaceRoot);
-});
-program
-    .command('mcp')
-    .description('Start MCP server (stdio transport)')
-    .argument('[path]', 'Path to analyze', '.')
-    .action(async (targetPath) => {
-    const { graph, repoName } = await analyzeWorkspace(targetPath, { silent: true });
-    await startMcpStdio(graph, repoName);
-});
-program
-    .command('search')
-    .description('Search the knowledge graph')
-    .argument('<query>', 'Search query')
-    .option('-l, --limit <limit>', 'Max results', '20')
-    .option('-p, --path <path>', 'Path to analyze', '.')
-    .action(async (query, options) => {
-    const { graph } = await analyzeWorkspace(options.path, { silent: true });
-    const results = textSearch(graph, query, parseInt(options.limit, 10));
-    if (results.length === 0) {
-        console.log('No results found.');
-        return;
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Resolved ${importEdges} imports, ${callEdges} calls, ${heritageEdges} heritage edges. Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`
+    };
+  }
+};
+function extractImports(lines, isPython) {
+  const imports = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const tsImport = line.match(/import\s+.*?from\s+['"]([^'"]+)['"]/);
+    if (tsImport) {
+      const names = [];
+      const namedMatch = line.match(/\{([^}]+)\}/);
+      if (namedMatch) {
+        names.push(...namedMatch[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean));
+      }
+      const defaultMatch = line.match(/import\s+(\w+)/);
+      if (defaultMatch && defaultMatch[1] !== "type") {
+        names.push(defaultMatch[1]);
+      }
+      imports.push({
+        rawPath: tsImport[1],
+        localNames: names,
+        isDefault: !namedMatch,
+        line: i + 1
+      });
+      continue;
     }
-    console.log(`Found ${results.length} results for "${query}":\n`);
-    for (const r of results) {
-        console.log(`  ${r.kind.padEnd(12)} ${r.name.padEnd(30)} ${r.filePath}`);
+    if (isPython) {
+      const fromImport = line.match(/from\s+([\w.]+)\s+import\s+(.+)/);
+      if (fromImport) {
+        const names = fromImport[2].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean);
+        imports.push({ rawPath: fromImport[1], localNames: names, isDefault: false, line: i + 1 });
+        continue;
+      }
+      const directImport = line.match(/^import\s+([\w.]+)(?:\s+as\s+(\w+))?/);
+      if (directImport) {
+        imports.push({
+          rawPath: directImport[1],
+          localNames: [directImport[2] ?? directImport[1].split(".").pop()],
+          isDefault: false,
+          line: i + 1
+        });
+        continue;
+      }
     }
-});
-program
-    .command('inspect')
-    .description('Inspect a symbol')
-    .argument('<symbol>', 'Symbol name')
-    .option('-p, --path <path>', 'Path to analyze', '.')
-    .action(async (symbol, options) => {
-    const { graph } = await analyzeWorkspace(options.path, { silent: true });
-    let found = false;
+    const javaImport = line.match(/^import\s+(?:static\s+)?([\w.]+)/);
+    if (javaImport && !line.includes("from")) {
+      const parts = javaImport[1].split(".");
+      imports.push({
+        rawPath: javaImport[1],
+        localNames: [parts[parts.length - 1]],
+        isDefault: false,
+        line: i + 1
+      });
+      continue;
+    }
+    const goImport = line.match(/^\s*"([^"]+)"/);
+    if (goImport && (i > 0 && lines[i - 1]?.includes("import") || line.match(/^import\s+"/))) {
+      const parts = goImport[1].split("/");
+      imports.push({
+        rawPath: goImport[1],
+        localNames: [parts[parts.length - 1]],
+        isDefault: false,
+        line: i + 1
+      });
+      continue;
+    }
+    const includeMatch = line.match(/#include\s+[<"]([^>"]+)[>"]/);
+    if (includeMatch) {
+      imports.push({
+        rawPath: includeMatch[1],
+        localNames: [],
+        isDefault: false,
+        line: i + 1
+      });
+      continue;
+    }
+    const rustUse = line.match(/^use\s+([\w:]+)/);
+    if (rustUse) {
+      const parts = rustUse[1].split("::");
+      imports.push({
+        rawPath: rustUse[1],
+        localNames: [parts[parts.length - 1]],
+        isDefault: false,
+        line: i + 1
+      });
+      continue;
+    }
+    const usingMatch = line.match(/^using\s+([\w.]+)/);
+    if (usingMatch) {
+      const parts = usingMatch[1].split(".");
+      imports.push({
+        rawPath: usingMatch[1],
+        localNames: [parts[parts.length - 1]],
+        isDefault: false,
+        line: i + 1
+      });
+    }
+    const requireMatch = line.match(/require\s+['"]([^'"]+)['"]/);
+    if (requireMatch) {
+      imports.push({
+        rawPath: requireMatch[1],
+        localNames: [],
+        isDefault: false,
+        line: i + 1
+      });
+    }
+  }
+  return imports;
+}
+function extractCalls(lines) {
+  const calls = [];
+  const callRegex = /(?:new\s+)?(\w+)\s*\(/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(export\s+)?(async\s+)?function\s/.test(line)) continue;
+    if (/^\s*(export\s+)?(abstract\s+)?class\s/.test(line)) continue;
+    if (/^\s*(export\s+)?interface\s/.test(line)) continue;
+    if (/^\s*(export\s+)?enum\s/.test(line)) continue;
+    if (/^\s*(export\s+)?type\s+\w+\s*=/.test(line)) continue;
+    if (/^\s*import\s/.test(line)) continue;
+    if (/^\s*\/\//.test(line)) continue;
+    let match;
+    callRegex.lastIndex = 0;
+    while ((match = callRegex.exec(line)) !== null) {
+      const name = match[1];
+      if (["if", "for", "while", "switch", "catch", "return", "throw", "typeof", "instanceof", "delete", "void", "new", "import", "export", "from", "const", "let", "var", "function", "class", "interface", "type", "enum", "extends", "implements"].includes(name)) continue;
+      const isNew = line.substring(Math.max(0, match.index - 4), match.index).includes("new");
+      calls.push({ name, isNew, line: i + 1 });
+    }
+    const memberCallRegex = /(\w+)\.(\w+)\s*\(/g;
+    memberCallRegex.lastIndex = 0;
+    while ((match = memberCallRegex.exec(line)) !== null) {
+      calls.push({
+        name: match[2],
+        receiverText: match[1],
+        isNew: false,
+        line: i + 1
+      });
+    }
+  }
+  return calls;
+}
+function extractHeritage(lines) {
+  const heritages = [];
+  for (const line of lines) {
+    const classMatch = line.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/);
+    if (classMatch) {
+      const extendsNames = classMatch[2] ? [classMatch[2]] : [];
+      const implementsNames = classMatch[3] ? classMatch[3].split(",").map((n) => n.trim()).filter(Boolean) : [];
+      heritages.push({ className: classMatch[1], extendsNames, implementsNames });
+      continue;
+    }
+    const pyClassMatch = line.match(/class\s+(\w+)\(([^)]+)\)/);
+    if (pyClassMatch) {
+      const bases = pyClassMatch[2].split(",").map((n) => n.trim()).filter(Boolean);
+      heritages.push({ className: pyClassMatch[1], extendsNames: bases, implementsNames: [] });
+    }
+  }
+  return heritages;
+}
+function findEnclosingFunction(graph, filePath, line) {
+  let best = null;
+  for (const node of graph.allNodes()) {
+    if (node.filePath !== filePath) continue;
+    if (!["function", "method"].includes(node.kind)) continue;
+    if (!node.startLine) continue;
+    if (node.startLine <= line) {
+      if (!best || node.startLine > best.startLine) {
+        best = { id: node.id, startLine: node.startLine };
+      }
+    }
+  }
+  return best?.id ?? null;
+}
+
+// src/pipeline/phases/cluster-phase.ts
+var clusterPhase = {
+  name: "cluster",
+  dependencies: ["resolve"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph } = context;
+    const relevantKinds = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "struct", "trait", "enum"]);
+    const nodesByDir = /* @__PURE__ */ new Map();
     for (const node of graph.allNodes()) {
-        if (node.name === symbol) {
-            found = true;
-            console.log(`\n${node.kind}: ${node.name}`);
-            console.log(`  File: ${node.filePath}:${node.startLine ?? '?'}`);
-            console.log(`  Exported: ${node.exported ?? 'unknown'}`);
-            const incoming = [...graph.findEdgesTo(node.id)];
-            const outgoing = [...graph.findEdgesFrom(node.id)];
-            const callers = incoming.filter((e) => e.kind === 'calls');
-            const callees = outgoing.filter((e) => e.kind === 'calls');
-            if (callers.length > 0) {
-                console.log(`  Callers (${callers.length}):`);
-                for (const c of callers.slice(0, 10)) {
-                    const n = graph.getNode(c.source);
-                    console.log(`    ← ${n?.name ?? c.source} (${n?.filePath})`);
-                }
+      if (!relevantKinds.has(node.kind)) continue;
+      const dir = node.filePath.split("/").slice(0, -1).join("/") || ".";
+      let group = nodesByDir.get(dir);
+      if (!group) {
+        group = [];
+        nodesByDir.set(dir, group);
+      }
+      group.push({ id: node.id, name: node.name });
+    }
+    let clusterCount = 0;
+    for (const [dir, members] of nodesByDir) {
+      if (members.length < 2) continue;
+      const clusterId = generateNodeId("cluster", dir, `cluster-${clusterCount}`);
+      const label = dir.split("/").filter(Boolean).pop() ?? `cluster-${clusterCount}`;
+      graph.addNode({
+        id: clusterId,
+        kind: "cluster",
+        name: label,
+        filePath: dir,
+        metadata: { memberCount: members.length }
+      });
+      for (const member of members) {
+        graph.addEdge({
+          id: generateEdgeId(member.id, clusterId, "belongs_to"),
+          source: member.id,
+          target: clusterId,
+          kind: "belongs_to",
+          weight: 1
+        });
+      }
+      clusterCount++;
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Created ${clusterCount} clusters`
+    };
+  }
+};
+
+// src/pipeline/phases/flow-phase.ts
+var flowPhase = {
+  name: "flow",
+  dependencies: ["resolve"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph } = context;
+    const calledNodes = /* @__PURE__ */ new Set();
+    for (const edge of graph.findEdgesByKind("calls")) {
+      calledNodes.add(edge.target);
+    }
+    const entryPoints = [];
+    for (const node of graph.allNodes()) {
+      if (!["function", "method"].includes(node.kind)) continue;
+      let score = 0;
+      const hasCallers = calledNodes.has(node.id);
+      const outCalls = [...graph.findEdgesFrom(node.id)].filter((e) => e.kind === "calls");
+      if (!hasCallers && outCalls.length > 0) score += 10;
+      if (node.exported) score += 5;
+      if (/^(main|handle|init|start|run|execute|process|serve|listen|bootstrap)/.test(node.name)) score += 3;
+      if (node.filePath.includes("test") || node.filePath.includes("spec") || node.filePath.includes("__test")) score -= 20;
+      if (node.filePath.includes("route") || node.filePath.includes("controller") || node.filePath.includes("handler")) score += 8;
+      if (score >= 5) {
+        entryPoints.push({ id: node.id, name: node.name, score, filePath: node.filePath });
+      }
+    }
+    entryPoints.sort((a, b) => b.score - a.score);
+    const maxFlows = 75;
+    const maxDepth = 10;
+    const maxBranching = 4;
+    let flowCount = 0;
+    for (const ep of entryPoints.slice(0, 20)) {
+      if (flowCount >= maxFlows) break;
+      const queue = [{ nodeId: ep.id, path: [ep.id] }];
+      const visited = /* @__PURE__ */ new Set();
+      while (queue.length > 0 && flowCount < maxFlows) {
+        const { nodeId, path: path15 } = queue.shift();
+        if (path15.length > maxDepth) continue;
+        const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
+        if (callEdges.length === 0 && path15.length >= 3) {
+          const flowId = generateNodeId("flow", ep.filePath, `flow-${flowCount}`);
+          graph.addNode({
+            id: flowId,
+            kind: "flow",
+            name: `${ep.name} flow ${flowCount}`,
+            filePath: ep.filePath,
+            metadata: { steps: path15, entryPoint: ep.name }
+          });
+          for (let i = 0; i < path15.length; i++) {
+            graph.addEdge({
+              id: generateEdgeId(path15[i], flowId, `step_of_${i}`),
+              source: path15[i],
+              target: flowId,
+              kind: "step_of",
+              weight: 1,
+              label: `step ${i + 1}`
+            });
+          }
+          flowCount++;
+          continue;
+        }
+        for (const edge of callEdges) {
+          if (visited.has(edge.target)) continue;
+          visited.add(edge.target);
+          queue.push({ nodeId: edge.target, path: [...path15, edge.target] });
+        }
+      }
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Found ${entryPoints.length} entry points, traced ${flowCount} flows`
+    };
+  }
+};
+
+// src/search/text-search.ts
+function textSearch(graph, query, limit = 20) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const results = [];
+  const isTestPath = (fp) => fp.includes("test") || fp.includes("spec") || fp.includes("__test");
+  const isDistPath = (fp) => fp.includes("/dist") || fp.includes("\\dist") || fp.includes(".d.ts");
+  for (const node of graph.allNodes()) {
+    if (["directory", "cluster", "flow"].includes(node.kind)) continue;
+    let score = 0;
+    const nameLC = node.name.toLowerCase();
+    const pathLC = node.filePath.toLowerCase();
+    for (const term of terms) {
+      if (nameLC === term) score += 10;
+      else if (nameLC.startsWith(term)) score += 7;
+      else if (nameLC.includes(term)) score += 5;
+      if (pathLC.includes(term)) score += 2;
+      if (node.content?.toLowerCase().includes(term)) score += 3;
+    }
+    if (score > 0) {
+      if (isDistPath(node.filePath)) score -= 8;
+      if (isTestPath(node.filePath)) score -= 4;
+      if (["function", "class", "interface", "method"].includes(node.kind)) score += 1;
+    }
+    if (score > 0) {
+      results.push({
+        nodeId: node.id,
+        name: node.name,
+        kind: node.kind,
+        filePath: node.filePath,
+        score,
+        snippet: node.content?.slice(0, 200)
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function reciprocalRankFusion(...rankings) {
+  const K = 60;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const ranking of rankings) {
+    for (let rank = 0; rank < ranking.length; rank++) {
+      const result = ranking[rank];
+      const existing = scoreMap.get(result.nodeId);
+      const rrfContribution = 1 / (K + rank + 1);
+      if (existing) {
+        existing.rrfScore += rrfContribution;
+      } else {
+        scoreMap.set(result.nodeId, {
+          result,
+          rrfScore: rrfContribution
+        });
+      }
+    }
+  }
+  return [...scoreMap.values()].sort((a, b) => b.rrfScore - a.rrfScore).map((entry) => ({ ...entry.result, score: entry.rrfScore }));
+}
+
+// src/http/app.ts
+init_storage();
+init_vector_index();
+init_group_registry();
+
+// src/multi-repo/group-sync.ts
+init_repo_registry();
+init_db_manager();
+
+// src/multi-repo/graph-from-db.ts
+init_schema();
+var TABLE_TO_KIND = Object.fromEntries(
+  Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
+);
+function parseRow(row, kind) {
+  return {
+    id: String(row["id"] ?? ""),
+    kind,
+    name: String(row["name"] ?? ""),
+    filePath: String(row["file_path"] ?? ""),
+    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
+    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
+    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
+    content: row["content"] ? String(row["content"]) : void 0,
+    metadata: row["metadata"] ? (() => {
+      try {
+        return JSON.parse(String(row["metadata"]));
+      } catch {
+        return void 0;
+      }
+    })() : void 0
+  };
+}
+async function loadGraphFromDB(graph, db) {
+  for (const table of ALL_NODE_TABLES) {
+    const kind = TABLE_TO_KIND[table];
+    if (!kind) continue;
+    let rows = [];
+    try {
+      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
+    } catch {
+      continue;
+    }
+    for (const row of rows) {
+      const node = parseRow({
+        id: row["n.id"],
+        name: row["n.name"],
+        file_path: row["n.file_path"],
+        start_line: row["n.start_line"],
+        end_line: row["n.end_line"],
+        exported: row["n.exported"],
+        content: row["n.content"],
+        metadata: row["n.metadata"]
+      }, kind);
+      if (node.id && node.name) graph.addNode(node);
+    }
+  }
+  try {
+    const edgeRows = await db.query(
+      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
+    );
+    for (const row of edgeRows) {
+      const sourceId = String(row["a.id"] ?? "");
+      const targetId = String(row["b.id"] ?? "");
+      const kind = String(row["e.kind"] ?? "");
+      if (!sourceId || !targetId || !kind) continue;
+      const edge = {
+        id: `${sourceId}::${kind}::${targetId}`,
+        source: sourceId,
+        target: targetId,
+        kind,
+        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
+        label: row["e.label"] ? String(row["e.label"]) : void 0
+      };
+      graph.addEdge(edge);
+    }
+  } catch {
+  }
+}
+
+// src/multi-repo/group-sync.ts
+function extractContracts(graph, repoName, repoPath) {
+  const contracts = [];
+  for (const node of graph.allNodes()) {
+    if (node.exported === true && ["function", "class", "interface", "method", "type_alias", "constant", "enum", "struct", "trait"].includes(node.kind)) {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "export",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim()
+      });
+    }
+    if (node.kind === "route") {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "route",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim()
+      });
+    }
+    if (["interface", "type_alias"].includes(node.kind)) {
+      const nameLower = node.name.toLowerCase();
+      if (nameLower.includes("event") || nameLower.includes("message")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "event",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      } else if (nameLower.includes("schema") || nameLower.includes("dto") || nameLower.includes("request") || nameLower.includes("response")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "schema",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      }
+    }
+  }
+  return contracts;
+}
+function matchContracts(allContracts) {
+  const links = [];
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const c of allContracts) {
+    const arr = byRepo.get(c.repoName) ?? [];
+    arr.push(c);
+    byRepo.set(c.repoName, arr);
+  }
+  const repoNames = [...byRepo.keys()];
+  for (let i = 0; i < repoNames.length; i++) {
+    for (let j = 0; j < repoNames.length; j++) {
+      if (i === j) continue;
+      const providerContracts = byRepo.get(repoNames[i]);
+      const consumerContracts = byRepo.get(repoNames[j]);
+      const consumerByName = /* @__PURE__ */ new Map();
+      for (const c of consumerContracts) consumerByName.set(c.name, c);
+      for (const provider of providerContracts) {
+        const consumer = consumerByName.get(provider.name);
+        if (consumer) {
+          const sameKind = provider.kind === consumer.kind;
+          links.push({
+            providerRepo: provider.repoName,
+            providerContract: provider.name,
+            consumerRepo: consumer.repoName,
+            consumerContract: consumer.name,
+            matchKind: provider.kind === "route" ? "route-match" : "name-match",
+            confidence: sameKind ? 0.9 : 0.6
+          });
+        } else {
+          const providerLC = provider.name.toLowerCase();
+          for (const c of consumerContracts) {
+            if (c.name.toLowerCase().includes(providerLC) || providerLC.includes(c.name.toLowerCase())) {
+              if (c.name.length >= 4 && provider.name.length >= 4) {
+                links.push({
+                  providerRepo: provider.repoName,
+                  providerContract: provider.name,
+                  consumerRepo: c.repoName,
+                  consumerContract: c.name,
+                  matchKind: "name-match",
+                  confidence: 0.4
+                });
+              }
             }
-            if (callees.length > 0) {
-                console.log(`  Callees (${callees.length}):`);
-                for (const c of callees.slice(0, 10)) {
-                    const n = graph.getNode(c.target);
-                    console.log(`    → ${n?.name ?? c.target} (${n?.filePath})`);
-                }
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const key = `${link.providerRepo}:${link.providerContract}:${link.consumerRepo}:${link.consumerContract}`;
+    const existing = seen.get(key);
+    if (!existing || link.confidence > existing.confidence) {
+      seen.set(key, link);
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.confidence - a.confidence);
+}
+async function syncGroup(group) {
+  const registry = loadRegistry();
+  const allContracts = [];
+  for (const member of group.members) {
+    const regEntry = registry.find((r) => r.name === member.registryName);
+    if (!regEntry) {
+      console.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
+      continue;
+    }
+    const dbPath = path.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs8.existsSync(dbPath)) {
+      console.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
+      continue;
+    }
+    const graph = createKnowledgeGraph();
+    const db = new DbManager(dbPath);
+    try {
+      await db.init();
+      await loadGraphFromDB(graph, db);
+      db.close();
+    } catch (err) {
+      db.close();
+      console.warn(`  \u26A0 Could not load graph for "${member.registryName}": ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const contracts = extractContracts(graph, member.registryName, regEntry.path);
+    console.log(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
+    allContracts.push(...contracts);
+  }
+  const links = matchContracts(allContracts);
+  return {
+    groupName: group.name,
+    syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    memberCount: group.members.length,
+    contracts: allContracts,
+    links
+  };
+}
+init_repo_registry();
+init_db_manager();
+async function queryGroup(group, query, limit = 20) {
+  const registry = loadRegistry();
+  const perRepo = [];
+  const allRankings = [];
+  for (const member of group.members) {
+    const regEntry = registry.find((r) => r.name === member.registryName);
+    if (!regEntry) continue;
+    const dbPath = path.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs8.existsSync(dbPath)) continue;
+    const graph = createKnowledgeGraph();
+    const db = new DbManager(dbPath);
+    try {
+      await db.init();
+      await loadGraphFromDB(graph, db);
+      db.close();
+    } catch {
+      db.close();
+      continue;
+    }
+    const results = textSearch(graph, query, limit);
+    const taggedResults = results.map((r) => ({
+      ...r,
+      snippet: `[${member.registryName}] ${r.snippet ?? ""}`.trim()
+    }));
+    perRepo.push({
+      repoName: member.registryName,
+      repoPath: regEntry.path,
+      groupPath: member.groupPath,
+      results: taggedResults
+    });
+    allRankings.push(taggedResults);
+  }
+  const merged = reciprocalRankFusion(...allRankings).slice(0, limit);
+  return { perRepo, merged };
+}
+
+// src/http/app.ts
+init_repo_registry();
+var __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+var WEB_DIST = path.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+function createApp(graph, repoName, workspaceRoot) {
+  const app = express();
+  app.use(cors({ origin: true }));
+  app.use(express.json({ limit: "10mb" }));
+  let vectorIndex = null;
+  let vectorIndexBuilding = false;
+  let vectorIndexReady = false;
+  async function ensureVectorIndex() {
+    if (vectorIndexReady && vectorIndex) return vectorIndex;
+    if (!workspaceRoot || vectorIndexBuilding) return null;
+    vectorIndexBuilding = true;
+    try {
+      const { embedNodes: embedNodes2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+      const dbPath = getVectorDbPath(workspaceRoot);
+      const db = new DbManager(dbPath);
+      await db.init();
+      const idx = new VectorIndex(db);
+      await idx.init();
+      const alreadyBuilt = await idx.isBuilt();
+      if (!alreadyBuilt) {
+        console.log("  [vector] Building embeddings\u2026");
+        const nodes = await embedNodes2(graph, {
+          onProgress: (done, total) => {
+            if (done % 50 === 0 || done === total) process.stdout.write(`\r  [vector] ${done}/${total}`);
+          }
+        });
+        console.log("");
+        await idx.buildIndex(nodes);
+        console.log(`  [vector] Index built: ${nodes.length} embeddings`);
+      } else {
+        console.log("  [vector] Index already exists, skipping rebuild.");
+      }
+      vectorIndex = idx;
+      vectorIndexReady = true;
+      return idx;
+    } catch (err) {
+      console.warn("  [vector] Index build failed:", err instanceof Error ? err.message : err);
+      return null;
+    } finally {
+      vectorIndexBuilding = false;
+    }
+  }
+  if (workspaceRoot) {
+    setImmediate(() => ensureVectorIndex().catch(() => {
+    }));
+  }
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", nodes: graph.size.nodes, edges: graph.size.edges });
+  });
+  app.get("/api/repos", (_req, res) => {
+    res.json([{ name: repoName, nodes: graph.size.nodes, edges: graph.size.edges }]);
+  });
+  app.get("/api/graph/:repo", (_req, res) => {
+    const nodes = [...graph.allNodes()];
+    const edges = [...graph.allEdges()];
+    res.json({ nodes, edges });
+  });
+  app.post("/api/search", (req, res) => {
+    const { query, limit } = req.body;
+    const results = textSearch(graph, query, limit ?? 20);
+    res.json({ results });
+  });
+  app.post("/api/vector-search", async (req, res) => {
+    const { query, limit = 10 } = req.body;
+    if (!query) {
+      res.status(400).json({ error: "Missing query" });
+      return;
+    }
+    const idx = await ensureVectorIndex();
+    if (!idx) {
+      const results = textSearch(graph, query, limit);
+      res.json({ results, source: "text-fallback", vectorReady: false });
+      return;
+    }
+    try {
+      const { pipeline } = await import('@huggingface/transformers');
+      const embedder = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+      const out = await embedder(query, { pooling: "mean", normalize: true });
+      const queryEmbedding = Array.from(out.data);
+      const hits = await idx.search(queryEmbedding, limit);
+      const results = hits.map((h) => ({
+        nodeId: h.nodeId,
+        name: h.name,
+        kind: h.kind,
+        filePath: h.filePath,
+        score: h.score
+      }));
+      res.json({ results, source: "vector", vectorReady: true });
+    } catch (err) {
+      const results = textSearch(graph, query, limit);
+      res.json({ results, source: "text-fallback", vectorReady: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.get("/api/vector-status", (_req, res) => {
+    res.json({ ready: vectorIndexReady, building: vectorIndexBuilding });
+  });
+  app.post("/api/files/read", (req, res) => {
+    const { file_path } = req.body;
+    try {
+      const content = fs8.readFileSync(file_path, "utf-8");
+      res.json({ content });
+    } catch {
+      res.status(404).json({ error: "File not found" });
+    }
+  });
+  app.post("/api/grep", (req, res) => {
+    const { pattern, file_paths } = req.body;
+    const results = [];
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const paths = file_paths ?? [];
+      if (paths.length === 0) {
+        for (const node of graph.allNodes()) {
+          if (node.kind === "file" && node.content) {
+            const lines = node.content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (regex.test(lines[i])) {
+                results.push({ file: node.filePath, line: i + 1, text: lines[i].trim() });
+              }
+              regex.lastIndex = 0;
             }
-            break;
+          }
         }
+      }
+      res.json({ results: results.slice(0, 100) });
+    } catch {
+      res.status(400).json({ error: "Invalid regex pattern" });
     }
-    if (!found)
-        console.log(`Symbol "${symbol}" not found.`);
-});
-program
-    .command('impact')
-    .description('Show blast radius for a symbol')
-    .argument('<symbol>', 'Symbol name')
-    .option('-p, --path <path>', 'Path to analyze', '.')
-    .option('-d, --depth <depth>', 'Max hops', '5')
-    .action(async (symbol, options) => {
-    const { graph } = await analyzeWorkspace(options.path, { silent: true });
-    const maxHops = parseInt(options.depth, 10);
+  });
+  app.post("/api/cypher", async (req, res) => {
+    const { query: q } = req.body;
+    if (!q) {
+      res.status(400).json({ error: "Missing query" });
+      return;
+    }
+    if (workspaceRoot) {
+      try {
+        const dbPath = getDbPath(workspaceRoot);
+        const dbm = new DbManager(dbPath);
+        await dbm.init();
+        const rows = await dbm.query(q);
+        dbm.close();
+        res.json({ results: rows });
+        return;
+      } catch (err) {
+      }
+    }
+    try {
+      const nameMatch = q?.match(/name\s*=\s*['"]([^'"]+)['"]/i);
+      if (nameMatch) {
+        const name = nameMatch[1];
+        const results = [];
+        for (const node of graph.allNodes()) {
+          if (node.name === name) {
+            const incoming = [...graph.findEdgesTo(node.id)];
+            const outgoing = [...graph.findEdgesFrom(node.id)];
+            results.push({ node, incoming: incoming.length, outgoing: outgoing.length });
+          }
+        }
+        res.json({ results });
+        return;
+      }
+      const kindMatch = q?.match(/:\s*(\w+)/);
+      if (kindMatch) {
+        const kind = kindMatch[1];
+        const results = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === kind) results.push(node);
+          if (results.length >= 50) break;
+        }
+        res.json({ results });
+        return;
+      }
+      res.json({ results: [], message: "Query not recognized." });
+    } catch {
+      res.status(400).json({ error: "Invalid query" });
+    }
+  });
+  app.get("/api/nodes/:id", (req, res) => {
+    const nodeId = decodeURIComponent(req.params.id);
+    const node = graph.getNode(nodeId);
+    if (!node) {
+      res.status(404).json({ error: "Node not found" });
+      return;
+    }
+    const incoming = [...graph.findEdgesTo(nodeId)];
+    const outgoing = [...graph.findEdgesFrom(nodeId)];
+    res.json({
+      node,
+      callers: incoming.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.source,
+        name: graph.getNode(e.source)?.name,
+        weight: e.weight
+      })),
+      callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name,
+        weight: e.weight
+      })),
+      imports: outgoing.filter((e) => e.kind === "imports").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name
+      })),
+      importedBy: incoming.filter((e) => e.kind === "imports").map((e) => ({
+        id: e.source,
+        name: graph.getNode(e.source)?.name
+      })),
+      extends: outgoing.filter((e) => e.kind === "extends").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name
+      })),
+      implementsEdges: outgoing.filter((e) => e.kind === "implements").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name
+      })),
+      members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({
+        id: e.target,
+        name: graph.getNode(e.target)?.name,
+        kind: graph.getNode(e.target)?.kind
+      })),
+      cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0]
+    });
+  });
+  app.post("/api/blast-radius", (req, res) => {
+    const { target, direction = "both", max_hops = 5 } = req.body;
     let targetNode = null;
     for (const node of graph.allNodes()) {
-        if (node.name === symbol) {
-            targetNode = node;
-            break;
-        }
+      if (node.name === target || node.id === target) {
+        targetNode = node;
+        break;
+      }
     }
     if (!targetNode) {
-        console.log(`Symbol "${symbol}" not found.`);
-        return;
+      res.status(404).json({ error: `Symbol "${target}" not found` });
+      return;
     }
-    const affected = new Set();
+    const affected = /* @__PURE__ */ new Map();
     const queue = [{ id: targetNode.id, depth: 0 }];
-    const visited = new Set();
+    const visited = /* @__PURE__ */ new Set();
     while (queue.length > 0) {
-        const { id, depth } = queue.shift();
-        if (visited.has(id) || depth > maxHops)
-            continue;
-        visited.add(id);
-        affected.add(id);
+      const { id, depth } = queue.shift();
+      if (visited.has(id) || depth > max_hops) continue;
+      visited.add(id);
+      const node = graph.getNode(id);
+      if (node) {
+        affected.set(id, { name: node.name, kind: node.kind, depth });
+      }
+      if (direction === "callers" || direction === "both") {
         for (const edge of graph.findEdgesTo(id)) {
-            if (edge.kind === 'calls' || edge.kind === 'imports') {
-                queue.push({ id: edge.source, depth: depth + 1 });
+          if (edge.kind === "calls" || edge.kind === "imports") {
+            queue.push({ id: edge.source, depth: depth + 1 });
+          }
+        }
+      }
+      if (direction === "callees" || direction === "both") {
+        for (const edge of graph.findEdgesFrom(id)) {
+          if (edge.kind === "calls" || edge.kind === "imports") {
+            queue.push({ id: edge.target, depth: depth + 1 });
+          }
+        }
+      }
+    }
+    res.json({
+      target: targetNode.name,
+      affectedCount: [...affected.values()].filter((a) => a.depth > 0).length,
+      affected: [...affected.entries()].map(([id, info]) => ({ id, ...info })).filter((a) => a.depth > 0)
+    });
+  });
+  app.get("/api/flows", (_req, res) => {
+    const flows = [];
+    for (const node of graph.allNodes()) {
+      if (node.kind === "flow") {
+        flows.push({
+          id: node.id,
+          name: node.name,
+          steps: node.metadata?.steps
+        });
+      }
+    }
+    res.json({ flows });
+  });
+  app.get("/api/clusters", (_req, res) => {
+    const clusters = [];
+    for (const node of graph.allNodes()) {
+      if (node.kind === "cluster") {
+        clusters.push({
+          id: node.id,
+          name: node.name,
+          memberCount: node.metadata?.memberCount ?? 0
+        });
+      }
+    }
+    res.json({ clusters });
+  });
+  app.get("/api/groups", (_req, res) => {
+    const groups = listGroups();
+    res.json(groups.map((g) => ({
+      name: g.name,
+      memberCount: g.members.length,
+      lastSync: g.lastSync ?? null,
+      createdAt: g.createdAt
+    })));
+  });
+  app.get("/api/groups/:name", (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    res.json(group);
+  });
+  app.get("/api/groups/:name/contracts", (req, res) => {
+    const result = loadSyncResult(req.params.name);
+    if (!result) {
+      res.status(404).json({ error: "No sync result. Run sync first." });
+      return;
+    }
+    res.json(result);
+  });
+  app.post("/api/groups/:name/sync", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    try {
+      const result = await syncGroup(group);
+      saveSyncResult(result);
+      group.lastSync = result.syncedAt;
+      const { saveGroup: saveGroup2 } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
+      saveGroup2(group);
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/api/groups/:name/search", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    const { q, limit = 20 } = req.body;
+    if (!q) {
+      res.status(400).json({ error: "Missing query q" });
+      return;
+    }
+    try {
+      const { perRepo, merged } = await queryGroup(group, q, limit);
+      res.json({ perRepo, merged });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.get("/api/groups/:name/graph", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    const registry = loadRegistry();
+    const mergedGraph = createKnowledgeGraph();
+    for (const member of group.members) {
+      const regEntry = registry.find((r) => r.name === member.registryName);
+      if (!regEntry) continue;
+      const dbPath = path.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs8.existsSync(dbPath)) continue;
+      const db = new DbManager(dbPath);
+      try {
+        await db.init();
+        await loadGraphFromDB(mergedGraph, db);
+        db.close();
+      } catch {
+        db.close();
+      }
+    }
+    res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
+  });
+  if (fs8.existsSync(WEB_DIST)) {
+    app.use(express.static(WEB_DIST));
+    app.get("/{*path}", (_req, res) => {
+      res.sendFile(path.join(WEB_DIST, "index.html"));
+    });
+  }
+  return app;
+}
+function startHttpServer(graph, repoName, port = 4747, workspaceRoot) {
+  const app = createApp(graph, repoName, workspaceRoot);
+  app.listen(port, () => {
+    console.log(`Code Intelligence server running at http://localhost:${port}`);
+    console.log(`  Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`);
+  });
+}
+function createMcpServer(graph, repoName) {
+  const server = new Server(
+    { name: "code-intel", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "repos",
+        description: "List indexed repositories",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "search",
+        description: "Hybrid search across the codebase knowledge graph",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            limit: { type: "number", description: "Max results (default 20)" }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "inspect",
+        description: "360\xB0 view of a symbol: definition, callers, callees, heritage, references",
+        inputSchema: {
+          type: "object",
+          properties: {
+            symbol_name: { type: "string", description: "Symbol name to inspect" }
+          },
+          required: ["symbol_name"]
+        }
+      },
+      {
+        name: "blast_radius",
+        description: "Impact analysis: what depends on / is affected by this symbol",
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: { type: "string", description: "Target symbol name" },
+            direction: { type: "string", enum: ["callers", "callees", "both"], description: "Direction to trace" },
+            max_hops: { type: "number", description: "Max hops (default 5)" }
+          },
+          required: ["target"]
+        }
+      },
+      {
+        name: "routes",
+        description: "List route handler mappings in the codebase",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "raw_query",
+        description: "Execute a graph query (simplified Cypher-like)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            cypher: { type: "string", description: "Query string (name='X' or :kind patterns)" }
+          },
+          required: ["cypher"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const a = args ?? {};
+    switch (name) {
+      case "repos": {
+        return { content: [{ type: "text", text: JSON.stringify([{ name: repoName, nodes: graph.size.nodes, edges: graph.size.edges }], null, 2) }] };
+      }
+      case "search": {
+        const query = a.query;
+        const limit = a.limit ?? 20;
+        const results = textSearch(graph, query, limit);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+      }
+      case "inspect": {
+        const symbolName = a.symbol_name;
+        const node = findNodeByName(graph, symbolName);
+        if (!node) return { content: [{ type: "text", text: `Symbol "${symbolName}" not found` }] };
+        const incoming = [...graph.findEdgesTo(node.id)];
+        const outgoing = [...graph.findEdgesFrom(node.id)];
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              node: { id: node.id, kind: node.kind, name: node.name, filePath: node.filePath, startLine: node.startLine, endLine: node.endLine, exported: node.exported },
+              callers: incoming.filter((e) => e.kind === "calls").map((e) => ({ id: e.source, name: graph.getNode(e.source)?.name })),
+              callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({ id: e.target, name: graph.getNode(e.target)?.name })),
+              extends: outgoing.filter((e) => e.kind === "extends").map((e) => graph.getNode(e.target)?.name),
+              implements: outgoing.filter((e) => e.kind === "implements").map((e) => graph.getNode(e.target)?.name),
+              members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({ name: graph.getNode(e.target)?.name, kind: graph.getNode(e.target)?.kind })),
+              cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0],
+              content: node.content?.slice(0, 500)
+            }, null, 2)
+          }]
+        };
+      }
+      case "blast_radius": {
+        const target = a.target;
+        const direction = a.direction ?? "both";
+        const maxHops = a.max_hops ?? 5;
+        const node = findNodeByName(graph, target);
+        if (!node) return { content: [{ type: "text", text: `Symbol "${target}" not found` }] };
+        const affected = /* @__PURE__ */ new Set();
+        const queue = [{ id: node.id, depth: 0 }];
+        const visited = /* @__PURE__ */ new Set();
+        while (queue.length > 0) {
+          const { id, depth } = queue.shift();
+          if (visited.has(id) || depth > maxHops) continue;
+          visited.add(id);
+          affected.add(id);
+          if (direction === "callers" || direction === "both") {
+            for (const edge of graph.findEdgesTo(id)) {
+              if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.source, depth: depth + 1 });
+            }
+          }
+          if (direction === "callees" || direction === "both") {
+            for (const edge of graph.findEdgesFrom(id)) {
+              if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.target, depth: depth + 1 });
             }
+          }
         }
+        const affectedDetails = [...affected].map((id) => {
+          const n = graph.getNode(id);
+          return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ target: node.name, affectedCount: affected.size, affected: affectedDetails }, null, 2) }] };
+      }
+      case "routes": {
+        const routes = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === "route" || node.kind === "function" && /route|handler|controller/i.test(node.filePath)) {
+            routes.push({ name: node.name, filePath: node.filePath });
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(routes, null, 2) }] };
+      }
+      case "raw_query": {
+        const q = a.cypher;
+        const nameMatch = q?.match(/name\s*=\s*['"]([^'"]+)['"]/i);
+        if (nameMatch) {
+          const results = [];
+          for (const node of graph.allNodes()) {
+            if (node.name === nameMatch[1]) results.push(node);
+          }
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        const kindMatch = q?.match(/:\s*(\w+)/);
+        if (kindMatch) {
+          const results = [];
+          for (const node of graph.allNodes()) {
+            if (node.kind === kindMatch[1]) results.push(node);
+            if (results.length >= 50) break;
+          }
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        return { content: [{ type: "text", text: "Query not recognized" }] };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+      { uri: `codeintel://repo/${repoName}/overview`, name: `${repoName} Overview`, mimeType: "application/json" },
+      { uri: `codeintel://repo/${repoName}/clusters`, name: `${repoName} Clusters`, mimeType: "application/json" },
+      { uri: `codeintel://repo/${repoName}/flows`, name: `${repoName} Flows`, mimeType: "application/json" }
+    ]
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri.endsWith("/overview")) {
+      const kindCounts = {};
+      for (const node of graph.allNodes()) {
+        kindCounts[node.kind] = (kindCounts[node.kind] ?? 0) + 1;
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
+    }
+    if (uri.endsWith("/clusters")) {
+      const clusters = [];
+      for (const node of graph.allNodes()) {
+        if (node.kind === "cluster") clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount });
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(clusters) }] };
+    }
+    if (uri.endsWith("/flows")) {
+      const flows = [];
+      for (const node of graph.allNodes()) {
+        if (node.kind === "flow") flows.push({ id: node.id, name: node.name, steps: node.metadata?.steps, entryPoint: node.metadata?.entryPoint });
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(flows) }] };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+  return server;
+}
+async function startMcpStdio(graph, repoName) {
+  const server = createMcpServer(graph, repoName);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function findNodeByName(graph, name) {
+  for (const node of graph.allNodes()) {
+    if (node.name === name) return node;
+  }
+  return void 0;
+}
+
+// src/cli/main.ts
+init_metadata();
+async function writeSkillFiles(graph, workspaceRoot, projectName) {
+  const outputDir = path.join(workspaceRoot, ".claude", "skills", "code-intel");
+  const areas = buildAreaMap(graph, workspaceRoot);
+  if (areas.length === 0) return { skills: [], outputDir };
+  fs8.rmSync(outputDir, { recursive: true, force: true });
+  fs8.mkdirSync(outputDir, { recursive: true });
+  const skills = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const area of areas) {
+    const kebab = uniqueKebab(area.label, usedNames);
+    usedNames.add(kebab);
+    const content = renderSkill(area, projectName, kebab);
+    const dir = path.join(outputDir, kebab);
+    fs8.mkdirSync(dir, { recursive: true });
+    fs8.writeFileSync(path.join(dir, "SKILL.md"), content, "utf-8");
+    skills.push({ name: kebab, label: area.label, symbolCount: area.nodes.length, fileCount: area.files.size });
+  }
+  return { skills, outputDir };
+}
+function buildAreaMap(graph, workspaceRoot) {
+  const clusterLabel = /* @__PURE__ */ new Map();
+  const clusterMembers = /* @__PURE__ */ new Map();
+  for (const node of graph.allNodes()) {
+    if (node.kind === "cluster") {
+      clusterLabel.set(node.id, node.name);
+      clusterMembers.set(node.id, []);
+    }
+  }
+  for (const edge of graph.findEdgesByKind("belongs_to")) {
+    const bucket = clusterMembers.get(edge.target);
+    const node = graph.getNode(edge.source);
+    if (bucket && node) bucket.push(node);
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  const outDeg = /* @__PURE__ */ new Map();
+  const calledIds = /* @__PURE__ */ new Set();
+  for (const edge of graph.findEdgesByKind("calls")) {
+    calledIds.add(edge.target);
+    inDeg.set(edge.target, (inDeg.get(edge.target) ?? 0) + 1);
+    outDeg.set(edge.source, (outDeg.get(edge.source) ?? 0) + 1);
+  }
+  const areas = [];
+  for (const [clusterId, members] of clusterMembers) {
+    if (members.length < 3) continue;
+    const label = clusterLabel.get(clusterId) ?? "unknown";
+    const dir = members[0]?.filePath.split("/").slice(0, -1).join("/") ?? "";
+    const files = /* @__PURE__ */ new Map();
+    for (const n of members) {
+      const rel = relPath(n.filePath, workspaceRoot);
+      let list = files.get(rel);
+      if (!list) {
+        list = [];
+        files.set(rel, list);
+      }
+      list.push(n);
+    }
+    const entryPoints = members.filter((n) => n.exported && !calledIds.has(n.id) && ["function", "method", "class"].includes(n.kind)).slice(0, 6);
+    const memberIds = new Set(members.map((n) => n.id));
+    const hotNodes = members.map((n) => ({ node: n, inDeg: inDeg.get(n.id) ?? 0, outDeg: outDeg.get(n.id) ?? 0 })).sort((a, b) => b.inDeg + b.outDeg - (a.inDeg + a.outDeg)).slice(0, 12);
+    let callEdgesInArea = 0;
+    for (const edge of graph.findEdgesByKind("calls")) {
+      if (memberIds.has(edge.source) && memberIds.has(edge.target)) callEdgesInArea++;
+    }
+    const flowIds = [];
+    for (const node of graph.allNodes()) {
+      if (node.kind !== "flow") continue;
+      const steps = node.metadata?.steps;
+      if (steps?.some((s) => memberIds.has(s))) flowIds.push(node.id);
+      if (flowIds.length >= 8) break;
+    }
+    areas.push({ label, dir, nodes: members, files, entryPoints, hotNodes, callEdgesInArea, flowIds });
+  }
+  areas.sort((a, b) => b.nodes.length - a.nodes.length);
+  return areas.slice(0, 20);
+}
+function renderSkill(area, projectName, kebabName) {
+  const density = area.nodes.length > 0 ? Math.round(area.callEdgesInArea / area.nodes.length * 10) / 10 : 0;
+  const topEntryNames = area.entryPoints.slice(0, 3).map((n) => n.name);
+  const topHotNames = area.hotNodes.slice(0, 3).map((h) => h.node.name);
+  const triggerNames = topEntryNames.length > 0 ? topEntryNames : topHotNames;
+  const triggerStr = triggerNames.map((n) => `\`${n}\``).join(", ");
+  const dirs = [...area.files.keys()].map((f) => f.split("/").slice(0, -1).join("/") || ".");
+  const dirCounts = /* @__PURE__ */ new Map();
+  for (const d of dirs) dirCounts.set(d, (dirCounts.get(d) ?? 0) + 1);
+  const dominantDir = [...dirCounts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? area.dir;
+  const lines = [];
+  const description = [
+    `Covers the **${area.label}** subsystem of ${projectName}.`,
+    `${area.nodes.length} symbols across ${area.files.size} files.`,
+    triggerStr ? `Key symbols: ${triggerStr}.` : "",
+    `Internal call density: ${density} calls/symbol.`,
+    area.flowIds.length > 0 ? `Participates in ${area.flowIds.length} execution flow(s).` : ""
+  ].filter(Boolean).join(" ");
+  lines.push("---");
+  lines.push(`name: ${kebabName}`);
+  lines.push(`description: "${description.replace(/"/g, "'")}"`);
+  lines.push("---", "");
+  lines.push(`# ${area.label}`);
+  lines.push("");
+  lines.push(`> **${area.nodes.length} symbols** | **${area.files.size} files** | path: \`${dominantDir}/\` | call density: ${density}/sym`);
+  lines.push("");
+  lines.push("## When to Use");
+  lines.push("");
+  lines.push("Load this skill when:");
+  lines.push(`- The task involves code in \`${dominantDir}/\``);
+  if (triggerStr) lines.push(`- The user mentions ${triggerStr} or asks how they work`);
+  lines.push(`- Adding, modifying, or debugging ${area.label.toLowerCase()}-related functionality`);
+  lines.push(`- Tracing call chains that pass through the ${area.label} layer`);
+  lines.push("");
+  lines.push("## Key Files");
+  lines.push("");
+  lines.push("| File | Symbols | Notes |");
+  lines.push("|------|---------|-------|");
+  const sortedFiles = [...area.files.entries()].sort((a, b) => b[1].length - a[1].length);
+  for (const [file, nodes] of sortedFiles.slice(0, 10)) {
+    const exported = nodes.filter((n) => n.exported);
+    const names = nodes.slice(0, 4).map((n) => `\`${n.name}\``).join(", ");
+    const extra = nodes.length > 4 ? ` +(${nodes.length - 4})` : "";
+    const note = exported.length > 0 ? `${exported.length} exported` : "internal";
+    lines.push(`| \`${file}\` | ${names}${extra} | ${note} |`);
+  }
+  lines.push("");
+  if (area.entryPoints.length > 0) {
+    lines.push("## Entry Points");
+    lines.push("");
+    lines.push("Start exploration here \u2014 exported symbols with no external callers:");
+    lines.push("");
+    for (const ep of area.entryPoints) {
+      const loc = ep.startLine ? `:${ep.startLine}` : "";
+      lines.push(`- **\`${ep.name}\`** \`(${ep.kind})\` \u2192 \`${ep.filePath}${loc}\``);
+    }
+    lines.push("");
+  }
+  lines.push("## Hot Symbols");
+  lines.push("");
+  lines.push("Sorted by call graph degree (changing these has the highest blast radius):");
+  lines.push("");
+  lines.push("| Symbol | Kind | In \u2190 | \u2192 Out | File |");
+  lines.push("|--------|------|-----:|------:|------|");
+  for (const { node: n, inDeg: i, outDeg: o } of area.hotNodes) {
+    lines.push(`| \`${n.name}\` | ${n.kind} | ${i} | ${o} | \`${relFile(n.filePath)}\` |`);
+  }
+  lines.push("");
+  if (area.flowIds.length > 0) {
+    lines.push("## Execution Flows");
+    lines.push("");
+    lines.push(`**${area.flowIds.length}** execution path(s) pass through this area.`);
+    lines.push("Run `code-intel inspect <symbol>` on a hot symbol to trace the full call chain.");
+    lines.push("");
+  }
+  lines.push("## Impact Guidance");
+  lines.push("");
+  lines.push("Before modifying any symbol in this area:");
+  lines.push(`1. **High-degree symbols** (In \u2190 \u2265 3) \u2014 check all callers before changing signatures`);
+  lines.push(`2. **Entry points** \u2014 changes propagate to external consumers`);
+  lines.push(`3. Run \`code-intel impact <symbol>\` to get full blast radius`);
+  lines.push("");
+  const firstHot = area.hotNodes[0]?.node.name ?? area.nodes[0]?.name ?? area.label;
+  const firstEntry = area.entryPoints[0]?.name ?? firstHot;
+  lines.push("## Quick Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(`# Inspect most-connected symbol`);
+  lines.push(`code-intel inspect ${firstHot}`);
+  lines.push(`# Blast radius for entry point`);
+  lines.push(`code-intel impact ${firstEntry}`);
+  lines.push(`# Search this area`);
+  lines.push(`code-intel search "${area.label.toLowerCase()}"`);
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+function uniqueKebab(label, used) {
+  let base = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50) || "skill";
+  let candidate = base;
+  let n = 2;
+  while (used.has(candidate)) {
+    candidate = `${base}-${n++}`;
+  }
+  return candidate;
+}
+function relPath(filePath, workspaceRoot) {
+  const norm = filePath.replace(/\\/g, "/");
+  const root = workspaceRoot.replace(/\\/g, "/").replace(/\/?$/, "/");
+  return norm.startsWith(root) ? norm.slice(root.length) : norm.replace(/^\//, "");
+}
+function relFile(filePath) {
+  const parts = filePath.replace(/\\/g, "/").split("/");
+  return parts.slice(-2).join("/");
+}
+var BLOCK_START = "<!-- code-intel:start -->";
+var BLOCK_END = "<!-- code-intel:end -->";
+function writeContextFiles(workspaceRoot, projectName, stats, skills) {
+  const block = buildBlock(projectName, stats, skills);
+  upsertFile(path.join(workspaceRoot, "AGENTS.md"), block);
+  upsertFile(path.join(workspaceRoot, "CLAUDE.md"), block);
+}
+function buildBlock(projectName, stats, skills) {
+  const skillRows = skills.map((s) => `| Work in \`${s.label}\` (${s.symbolCount} symbols) | \`.claude/skills/code-intel/${s.name}/SKILL.md\` |`).join("\n");
+  const skillTable = `| Task | Skill file |
+|------|------------|
+| Understand architecture / "How does X work?" | Load \`code-intel-exploring\` skill |
+| Blast radius / "What breaks if I change X?" | Load \`code-intel-impact\` skill |
+| Debugging / "Why is X failing?" | Load \`code-intel-debugging\` skill |
+${skillRows ? skillRows + "\n" : ""}`;
+  return `${BLOCK_START}
+# Code Intelligence \u2014 ${projectName}
+
+Indexed: **${stats.nodes.toLocaleString()} nodes** | **${stats.edges.toLocaleString()} edges** | **${stats.files} files** | analyzed in ${(stats.duration / 1e3).toFixed(1)}s
+
+> If the index is stale, re-run: \`code-intel analyze\`
+
+## Always Do
+
+- **Before editing any symbol**, run \`code-intel impact <symbol>\` and review blast radius.
+- **Before committing**, verify scope with \`code-intel inspect <symbol>\`.
+- Use \`code-intel search "<concept>"\` to find related symbols instead of grepping.
+- Warn the user if impact shows \u2265 5 direct callers (HIGH risk).
+
+## Never Do
+
+- NEVER rename symbols with find-and-replace \u2014 use \`code-intel inspect\` to find all usages first.
+- NEVER ignore impact warnings \u2014 always report blast radius to the user.
+
+## CLI Quick Reference
+
+\`\`\`bash
+code-intel analyze [path]          # Build / refresh the knowledge graph
+code-intel serve [path]            # Start HTTP API + Web UI on :4747
+code-intel search <query>          # Text search across all symbols
+code-intel inspect <symbol>        # Callers, callees, imports, cluster
+code-intel impact <symbol>         # Blast radius (who breaks if this changes)
+code-intel status [path]           # Index freshness and stats
+code-intel clean [path]            # Remove index data
+\`\`\`
+
+## Skills
+
+${skillTable}
+${BLOCK_END}`;
+}
+function upsertFile(filePath, block) {
+  if (!fs8.existsSync(filePath)) {
+    fs8.writeFileSync(filePath, block + "\n", "utf-8");
+    return;
+  }
+  const existing = fs8.readFileSync(filePath, "utf-8");
+  const startIdx = findLineMarker(existing, BLOCK_START);
+  const endIdx = findLineMarker(existing, BLOCK_END, startIdx === -1 ? 0 : startIdx);
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + BLOCK_END.length);
+    fs8.writeFileSync(filePath, (before + block + after).trimEnd() + "\n", "utf-8");
+    return;
+  }
+  fs8.writeFileSync(filePath, existing.trimEnd() + "\n\n" + block + "\n", "utf-8");
+}
+function findLineMarker(content, marker, startFrom = 0) {
+  let idx = content.indexOf(marker, startFrom);
+  while (idx !== -1) {
+    const atStart = idx === 0 || content[idx - 1] === "\n";
+    const end = idx + marker.length;
+    const atEnd = end === content.length || content[end] === "\n" || content[end] === "\r";
+    if (atStart && atEnd) return idx;
+    idx = content.indexOf(marker, idx + 1);
+  }
+  return -1;
+}
+
+// src/cli/main.ts
+init_repo_registry();
+init_storage();
+init_group_registry();
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename$1);
+var _pkg = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
+var program = new Command();
+program.name("code-intel").description("Code Intelligence Platform \u2014 Static Analysis + Knowledge Graph").version(_pkg.version);
+async function analyzeWorkspace(targetPath, options) {
+  const workspaceRoot = path.resolve(targetPath);
+  if (!options?.silent) console.log(`Analyzing: ${workspaceRoot}`);
+  if (!options?.skipGit) {
+    const gitDir = path.join(workspaceRoot, ".git");
+    if (!fs8.existsSync(gitDir)) {
+      console.warn(`  Warning: ${workspaceRoot} is not a Git repository. Use --skip-git to suppress this warning.`);
+    }
+  }
+  const graph = createKnowledgeGraph();
+  const context = {
+    workspaceRoot,
+    graph,
+    filePaths: [],
+    verbose: options?.verbose,
+    onProgress: options?.silent ? void 0 : (phase, msg) => console.log(`  [${phase}] ${msg}`)
+  };
+  const phases = [scanPhase, structurePhase, parsePhase, resolvePhase, clusterPhase, flowPhase];
+  const result = await runPipeline(phases, context);
+  const repoName = path.basename(workspaceRoot);
+  saveMetadata(workspaceRoot, {
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: {
+      nodes: graph.size.nodes,
+      edges: graph.size.edges,
+      files: context.filePaths.length,
+      duration: result.totalDuration
+    }
+  });
+  upsertRepo({
+    name: repoName,
+    path: workspaceRoot,
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: {
+      nodes: graph.size.nodes,
+      edges: graph.size.edges,
+      files: context.filePaths.length
+    }
+  });
+  try {
+    const dbPath = getDbPath(workspaceRoot);
+    const db = new DbManager(dbPath);
+    await db.init();
+    const { nodeCount, edgeCount } = await loadGraphToDB(graph, db);
+    db.close();
+    if (!options?.silent) {
+      console.log(`  DB: ${nodeCount} nodes, ${edgeCount} edges persisted`);
+    }
+  } catch (err) {
+    if (!options?.silent) {
+      console.warn(`  DB persist warning: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  const doEmbeddings = options?.embeddings && !options?.skipEmbeddings;
+  if (doEmbeddings) {
+    if (!options?.silent) console.log("  Embeddings: building vector index\u2026");
+    try {
+      const { embedNodes: embedNodes2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+      const { getVectorDbPath: getVectorDbPath2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+      const { VectorIndex: VectorIndex2 } = await Promise.resolve().then(() => (init_vector_index(), vector_index_exports));
+      const vdbPath = getVectorDbPath2(workspaceRoot);
+      const vdb = new DbManager(vdbPath);
+      await vdb.init();
+      const idx = new VectorIndex2(vdb);
+      await idx.init();
+      const nodes = await embedNodes2(graph, {
+        onProgress: (done, total) => {
+          if (!options?.silent) process.stdout.write(`\r  [vector] ${done}/${total}`);
+        }
+      });
+      if (!options?.silent) console.log("");
+      await idx.buildIndex(nodes);
+      if (!options?.silent) console.log(`  Embeddings: ${nodes.length} vectors built`);
+      vdb.close();
+    } catch (err) {
+      if (!options?.silent) {
+        console.warn(`  Embeddings warning: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  } else if (!options?.skipEmbeddings && !options?.silent) {
+    console.log("  Embeddings: skipped (use --embeddings to enable)");
+  }
+  const doSkills = options?.skills !== false;
+  let skillSummaries = [];
+  if (doSkills) {
+    try {
+      const { skills } = await writeSkillFiles(graph, workspaceRoot, repoName);
+      skillSummaries = skills;
+      if (!options?.silent && skills.length > 0) {
+        console.log(`  Skills: ${skills.length} generated \u2192 .claude/skills/code-intel/`);
+      }
+    } catch (err) {
+      if (!options?.silent) {
+        console.warn(`  Skills warning: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  if (!options?.skipAgentsMd) {
+    try {
+      writeContextFiles(workspaceRoot, repoName, {
+        nodes: graph.size.nodes,
+        edges: graph.size.edges,
+        files: context.filePaths.length,
+        duration: result.totalDuration
+      }, skillSummaries);
+      if (!options?.silent) {
+        console.log(`  Context: AGENTS.md + CLAUDE.md updated`);
+      }
+    } catch (err) {
+      if (!options?.silent) {
+        console.warn(`  Context warning: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  if (!options?.silent) {
+    console.log(`
+Done in ${result.totalDuration}ms`);
+    console.log(`  Nodes: ${graph.size.nodes}`);
+    console.log(`  Edges: ${graph.size.edges}`);
+    console.log(`  Files: ${context.filePaths.length}`);
+    console.log(`  Success: ${result.success}`);
+  }
+  return { graph, result, repoName, workspaceRoot };
+}
+program.command("setup").description("Configure MCP server for your editors (one-time setup)").action(() => {
+  const configDir = process.env.HOME ? `${process.env.HOME}/.config/claude` : null;
+  console.log("\n\u{1F4E1} Code Intelligence MCP Setup\n");
+  console.log("Add the following to your editor MCP configuration:\n");
+  const mcpConfig = {
+    mcpServers: {
+      "code-intel": {
+        command: "npx",
+        args: ["@vohongtho.infotech/code-intel", "mcp", "."]
+      }
     }
-    console.log(`\nBlast radius for "${symbol}": ${affected.size} affected symbols\n`);
-    for (const id of affected) {
-        const n = graph.getNode(id);
-        if (n)
-            console.log(`  ${n.kind.padEnd(12)} ${n.name.padEnd(30)} ${n.filePath}`);
+  };
+  console.log("For Claude Desktop / Claude Code (~/.config/claude/claude_desktop_config.json):");
+  console.log(JSON.stringify(mcpConfig, null, 2));
+  if (configDir) {
+    const configFile = `${configDir}/claude_desktop_config.json`;
+    try {
+      let existing = {};
+      if (fs8.existsSync(configFile)) {
+        existing = JSON.parse(fs8.readFileSync(configFile, "utf-8"));
+      }
+      const merged = {
+        ...existing,
+        mcpServers: {
+          ...existing.mcpServers ?? {},
+          ...mcpConfig.mcpServers
+        }
+      };
+      fs8.mkdirSync(configDir, { recursive: true });
+      fs8.writeFileSync(configFile, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      console.log(`
+\u2705 Written to ${configFile}`);
+    } catch (err) {
+      console.warn(`
+\u26A0 Could not auto-write config: ${err instanceof Error ? err.message : err}`);
+      console.log("Please add the config above manually.");
     }
+  }
+  console.log("\nFor VS Code (settings.json or .vscode/mcp.json), use the same mcpServers block.");
+  console.log("\nThen run `code-intel analyze` in your project to index it.\n");
+});
+program.command("analyze").description("Index a repository (or update stale index)").argument("[path]", "Path to analyze", ".").option("--force", "Force full re-index even if already indexed").option("--skills", "Generate repo-specific skill files from detected communities").option("--skip-embeddings", "Skip embedding generation (faster)").option("--skip-agents-md", "Preserve custom AGENTS.md/CLAUDE.md code-intel section edits").option("--skip-git", "Index folders that are not Git repositories").option("--embeddings", "Enable embedding generation (slower, better search)").option("--verbose", "Log skipped files when parsers are unavailable").addHelpText("after", `
+Examples:
+  code-intel analyze                       Index current directory
+  code-intel analyze ./my-project          Index a specific path
+  code-intel analyze --force               Force full re-index
+  code-intel analyze --skills              Also generate .claude/skills/ files
+  code-intel analyze --skip-embeddings     Skip vector embeddings (faster)
+  code-intel analyze --skip-agents-md      Preserve custom AGENTS.md edits
+  code-intel analyze --skip-git            Allow non-Git folders
+  code-intel analyze --embeddings          Enable vector embeddings
+  code-intel analyze --verbose             Show skipped files`).action(async (targetPath, opts) => {
+  await analyzeWorkspace(targetPath, {
+    force: opts.force,
+    skills: opts.skills,
+    skipEmbeddings: opts.skipEmbeddings,
+    skipAgentsMd: opts.skipAgentsMd,
+    skipGit: opts.skipGit,
+    embeddings: opts.embeddings,
+    verbose: opts.verbose
+  });
+});
+program.command("mcp").description("Start MCP server (stdio) \u2014 serves all indexed repos").argument("[path]", "Path to analyze", ".").action(async (targetPath) => {
+  const { graph, repoName } = await analyzeWorkspace(targetPath, { silent: true });
+  await startMcpStdio(graph, repoName);
+});
+program.command("serve").description("Start local HTTP server + web UI (http://localhost:4747)").argument("[path]", "Path to analyze", ".").option("-p, --port <port>", "Port number", "4747").action(async (targetPath, options) => {
+  const { graph, repoName, workspaceRoot } = await analyzeWorkspace(targetPath);
+  startHttpServer(graph, repoName, parseInt(options.port, 10), workspaceRoot);
+});
+program.command("list").description("List all indexed repositories").action(() => {
+  const repos = loadRegistry();
+  if (repos.length === 0) {
+    console.log("No indexed repositories. Run `code-intel analyze <path>` first.");
+    return;
+  }
+  console.log(`
+Indexed repositories (${repos.length}):
+`);
+  for (const r of repos) {
+    console.log(`  ${r.name.padEnd(25)} ${r.stats.nodes} nodes, ${r.stats.edges} edges, ${r.stats.files} files`);
+    console.log(`    Path:    ${r.path}`);
+    console.log(`    Indexed: ${r.indexedAt}`);
+  }
+});
+program.command("status").description("Show index status for current repo").argument("[path]", "Path to check", ".").action((targetPath) => {
+  const workspaceRoot = path.resolve(targetPath);
+  const meta = loadMetadata(workspaceRoot);
+  if (!meta) {
+    console.log("Not indexed. Run `code-intel analyze` first.");
+    return;
+  }
+  console.log(`
+Index status for ${workspaceRoot}:`);
+  console.log(`  Indexed at: ${meta.indexedAt}`);
+  console.log(`  Nodes:      ${meta.stats.nodes}`);
+  console.log(`  Edges:      ${meta.stats.edges}`);
+  console.log(`  Files:      ${meta.stats.files}`);
+  console.log(`  Duration:   ${meta.stats.duration}ms`);
 });
-program
-    .command('list')
-    .description('List indexed repositories')
-    .action(() => {
+program.command("clean").description("Delete index for current repo (or all repos with --all --force)").argument("[path]", "Path to clean", ".").option("--all", "Clean all indexed repositories").option("--force", "Required with --all to confirm destructive operation").action((targetPath, opts) => {
+  if (opts.all) {
+    if (!opts.force) {
+      console.error("Error: --all requires --force to confirm. Run: code-intel clean --all --force");
+      process.exit(1);
+    }
     const repos = loadRegistry();
     if (repos.length === 0) {
-        console.log('No indexed repositories. Run `code-intel analyze <path>` first.');
-        return;
+      console.log("No indexed repositories to clean.");
+      return;
     }
-    console.log(`\nIndexed repositories (${repos.length}):\n`);
     for (const r of repos) {
-        console.log(`  ${r.name.padEnd(25)} ${r.stats.nodes} nodes, ${r.stats.edges} edges, ${r.stats.files} files`);
-        console.log(`    Path: ${r.path}`);
-        console.log(`    Indexed: ${r.indexedAt}`);
-    }
-});
-program
-    .command('status')
-    .description('Show index status for current directory')
-    .argument('[path]', 'Path to check', '.')
-    .action((targetPath) => {
-    const workspaceRoot = path.resolve(targetPath);
-    const meta = loadMetadata(workspaceRoot);
-    if (!meta) {
-        console.log('Not indexed. Run `code-intel analyze` first.');
-        return;
+      const codeIntelDir2 = path.join(r.path, ".code-intel");
+      if (fs8.existsSync(codeIntelDir2)) {
+        fs8.rmSync(codeIntelDir2, { recursive: true, force: true });
+        console.log(`  Removed ${codeIntelDir2}`);
+      }
+      removeRepo(r.path);
+    }
+    console.log(`
+Cleaned ${repos.length} repositor${repos.length === 1 ? "y" : "ies"}.`);
+    return;
+  }
+  const workspaceRoot = path.resolve(targetPath);
+  const codeIntelDir = path.join(workspaceRoot, ".code-intel");
+  if (fs8.existsSync(codeIntelDir)) {
+    fs8.rmSync(codeIntelDir, { recursive: true, force: true });
+    console.log(`Removed ${codeIntelDir}`);
+  }
+  removeRepo(workspaceRoot);
+  console.log("Index cleaned.");
+});
+program.command("search").description("Search the knowledge graph").argument("<query>", "Search query").option("-l, --limit <limit>", "Max results", "20").option("-p, --path <path>", "Path to analyze", ".").action(async (query, options) => {
+  const { graph } = await analyzeWorkspace(options.path, { silent: true });
+  const results = textSearch(graph, query, parseInt(options.limit, 10));
+  if (results.length === 0) {
+    console.log("No results found.");
+    return;
+  }
+  console.log(`Found ${results.length} results for "${query}":
+`);
+  for (const r of results) {
+    console.log(`  ${r.kind.padEnd(12)} ${r.name.padEnd(30)} ${r.filePath}`);
+  }
+});
+program.command("inspect").description("Inspect a symbol: callers, callees, location").argument("<symbol>", "Symbol name").option("-p, --path <path>", "Path to analyze", ".").action(async (symbol, options) => {
+  const { graph } = await analyzeWorkspace(options.path, { silent: true });
+  let found = false;
+  for (const node of graph.allNodes()) {
+    if (node.name === symbol) {
+      found = true;
+      console.log(`
+${node.kind}: ${node.name}`);
+      console.log(`  File:     ${node.filePath}:${node.startLine ?? "?"}`);
+      console.log(`  Exported: ${node.exported ?? "unknown"}`);
+      const incoming = [...graph.findEdgesTo(node.id)];
+      const outgoing = [...graph.findEdgesFrom(node.id)];
+      const callers = incoming.filter((e) => e.kind === "calls");
+      const callees = outgoing.filter((e) => e.kind === "calls");
+      if (callers.length > 0) {
+        console.log(`  Callers (${callers.length}):`);
+        for (const c of callers.slice(0, 10)) {
+          const n = graph.getNode(c.source);
+          console.log(`    \u2190 ${n?.name ?? c.source} (${n?.filePath})`);
+        }
+      }
+      if (callees.length > 0) {
+        console.log(`  Callees (${callees.length}):`);
+        for (const c of callees.slice(0, 10)) {
+          const n = graph.getNode(c.target);
+          console.log(`    \u2192 ${n?.name ?? c.target} (${n?.filePath})`);
+        }
+      }
+      break;
+    }
+  }
+  if (!found) console.log(`Symbol "${symbol}" not found.`);
+});
+program.command("impact").description("Show blast radius for a symbol").argument("<symbol>", "Symbol name").option("-p, --path <path>", "Path to analyze", ".").option("-d, --depth <depth>", "Max hops", "5").action(async (symbol, options) => {
+  const { graph } = await analyzeWorkspace(options.path, { silent: true });
+  const maxHops = parseInt(options.depth, 10);
+  let targetNode = null;
+  for (const node of graph.allNodes()) {
+    if (node.name === symbol) {
+      targetNode = node;
+      break;
+    }
+  }
+  if (!targetNode) {
+    console.log(`Symbol "${symbol}" not found.`);
+    return;
+  }
+  const affected = /* @__PURE__ */ new Set();
+  const queue = [{ id: targetNode.id, depth: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { id, depth } = queue.shift();
+    if (visited.has(id) || depth > maxHops) continue;
+    visited.add(id);
+    affected.add(id);
+    for (const edge of graph.findEdgesTo(id)) {
+      if (edge.kind === "calls" || edge.kind === "imports") {
+        queue.push({ id: edge.source, depth: depth + 1 });
+      }
+    }
+  }
+  console.log(`
+Blast radius for "${symbol}": ${affected.size} affected symbols
+`);
+  for (const id of affected) {
+    const n = graph.getNode(id);
+    if (n) console.log(`  ${n.kind.padEnd(12)} ${n.name.padEnd(30)} ${n.filePath}`);
+  }
+});
+var groupCmd = program.command("group").description("Manage repository groups (multi-repo / monorepo service tracking)");
+groupCmd.command("create <name>").description("Create a repository group").action((name) => {
+  if (groupExists(name)) {
+    console.error(`Error: Group "${name}" already exists.`);
+    process.exit(1);
+  }
+  saveGroup({ name, createdAt: (/* @__PURE__ */ new Date()).toISOString(), members: [] });
+  console.log(`\u2705 Group "${name}" created.`);
+});
+groupCmd.command("add <group> <groupPath> <registryName>").description("Add a repo to a group. <groupPath> is a hierarchy path (e.g. hr/hiring/backend); <registryName> is from `code-intel list`").action((group, groupPath, registryName) => {
+  const registry = loadRegistry();
+  const regEntry = registry.find((r) => r.name === registryName);
+  if (!regEntry) {
+    console.error(`Error: Registry entry "${registryName}" not found. Run \`code-intel list\` to see available repos.`);
+    process.exit(1);
+  }
+  if (!groupExists(group)) {
+    console.error(`Error: Group "${group}" does not exist. Create it first with \`code-intel group create ${group}\`.`);
+    process.exit(1);
+  }
+  addMember(group, { groupPath, registryName });
+  console.log(`\u2705 Added "${registryName}" to group "${group}" at path "${groupPath}".`);
+});
+groupCmd.command("remove <group> <groupPath>").description("Remove a repo from a group by its hierarchy path").action((group, groupPath) => {
+  if (!groupExists(group)) {
+    console.error(`Error: Group "${group}" does not exist.`);
+    process.exit(1);
+  }
+  try {
+    removeMember(group, groupPath);
+    console.log(`\u2705 Removed member at path "${groupPath}" from group "${group}".`);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+groupCmd.command("list [name]").description("List all groups, or show one group's config").action((name) => {
+  if (name) {
+    const group = loadGroup(name);
+    if (!group) {
+      console.error(`Error: Group "${name}" not found.`);
+      process.exit(1);
+    }
+    console.log(`
+Group: ${group.name}`);
+    console.log(`Created: ${group.createdAt}`);
+    if (group.lastSync) console.log(`Last sync: ${group.lastSync}`);
+    console.log(`
+Members (${group.members.length}):`);
+    if (group.members.length === 0) {
+      console.log("  (none \u2014 use `code-intel group add` to add repos)");
+    } else {
+      for (const m of group.members) {
+        console.log(`  ${m.groupPath.padEnd(35)} \u2192 ${m.registryName}`);
+      }
+    }
+  } else {
+    const groups = listGroups();
+    if (groups.length === 0) {
+      console.log("No groups found. Create one with `code-intel group create <name>`.");
+      return;
+    }
+    console.log(`
+Repository groups (${groups.length}):
+`);
+    for (const g of groups) {
+      const sync = g.lastSync ? `synced ${g.lastSync}` : "not synced";
+      console.log(`  ${g.name.padEnd(25)} ${g.members.length} member(s)  [${sync}]`);
+    }
+  }
+});
+groupCmd.command("sync <name>").description("Extract contracts and match across repos/services in a group").action(async (name) => {
+  const group = loadGroup(name);
+  if (!group) {
+    console.error(`Error: Group "${name}" not found.`);
+    process.exit(1);
+  }
+  if (group.members.length === 0) {
+    console.error(`Error: Group "${name}" has no members. Add repos with \`code-intel group add\`.`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F504} Syncing group "${name}" (${group.members.length} member(s))\u2026
+`);
+  const result = await syncGroup(group);
+  saveSyncResult(result);
+  group.lastSync = result.syncedAt;
+  saveGroup(group);
+  console.log(`
+\u2705 Sync complete:`);
+  console.log(`   Repos synced:  ${result.memberCount}`);
+  console.log(`   Contracts:     ${result.contracts.length}`);
+  console.log(`   Cross-links:   ${result.links.length}`);
+  if (result.links.length > 0) {
+    console.log(`
+Top cross-repo links:`);
+    for (const link of result.links.slice(0, 10)) {
+      const conf = (link.confidence * 100).toFixed(0).padStart(3);
+      console.log(`  ${conf}%  ${link.providerRepo} \u2237 ${link.providerContract.padEnd(30)} \u2194  ${link.consumerRepo} \u2237 ${link.consumerContract}`);
+    }
+    if (result.links.length > 10) {
+      console.log(`  \u2026 and ${result.links.length - 10} more. Run \`code-intel group contracts ${name}\` for full details.`);
+    }
+  }
+});
+groupCmd.command("contracts <name>").description("Inspect extracted contracts and cross-links from the last sync").option("--kind <kind>", "Filter by contract kind: export | route | schema | event").option("--repo <repo>", "Filter by registry name").option("--min-confidence <pct>", "Minimum link confidence 0-100 (default: 0)", "0").action((name, opts) => {
+  const result = loadSyncResult(name);
+  if (!result) {
+    console.error(`No sync data for group "${name}". Run \`code-intel group sync ${name}\` first.`);
+    process.exit(1);
+  }
+  const minConf = parseInt(opts.minConfidence, 10) / 100;
+  let contracts = result.contracts;
+  if (opts.kind) contracts = contracts.filter((c) => c.kind === opts.kind);
+  if (opts.repo) contracts = contracts.filter((c) => c.repoName === opts.repo);
+  let links = result.links.filter((l) => l.confidence >= minConf);
+  if (opts.repo) links = links.filter((l) => l.providerRepo === opts.repo || l.consumerRepo === opts.repo);
+  console.log(`
+\u{1F4E6} Group "${name}" \u2014 synced ${result.syncedAt}
+`);
+  console.log(`Contracts (${contracts.length}):`);
+  for (const c of contracts) {
+    const sig = c.signature ? `  ${c.signature.slice(0, 60)}` : "";
+    console.log(`  [${c.kind.padEnd(6)}] ${c.repoName.padEnd(20)} ${c.name.padEnd(35)}${sig}`);
+  }
+  console.log(`
+Cross-repo links (${links.length}):`);
+  if (links.length === 0) {
+    console.log("  (none)");
+  } else {
+    for (const link of links) {
+      const conf = (link.confidence * 100).toFixed(0).padStart(3);
+      console.log(`  ${conf}%  [${link.matchKind}]  ${link.providerRepo} \u2237 ${link.providerContract.padEnd(30)} \u2194  ${link.consumerRepo} \u2237 ${link.consumerContract}`);
+    }
+  }
+});
+groupCmd.command("query <name> <q>").description("Search execution flows across all repos in a group").option("-l, --limit <limit>", "Max results per repo", "10").action(async (name, q, opts) => {
+  const group = loadGroup(name);
+  if (!group) {
+    console.error(`Error: Group "${name}" not found.`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F50D} Querying group "${name}" for: "${q}"
+`);
+  const limit = parseInt(opts.limit, 10);
+  const { perRepo, merged } = await queryGroup(group, q, limit);
+  if (merged.length === 0) {
+    console.log("No results found across any repo in this group.");
+    return;
+  }
+  console.log(`Merged results (${merged.length} total, ranked by Reciprocal Rank Fusion):
+`);
+  for (const r of merged) {
+    console.log(`  ${r.kind.padEnd(12)} ${r.name.padEnd(30)} ${r.filePath}`);
+    if (r.snippet) console.log(`             ${r.snippet.slice(0, 100)}`);
+  }
+  console.log(`
+Per-repo breakdown:`);
+  for (const rr of perRepo) {
+    console.log(`  ${rr.repoName} (${rr.groupPath}): ${rr.results.length} result(s)`);
+  }
+});
+groupCmd.command("status <name>").description("Check staleness of repos in a group").action((name) => {
+  const group = loadGroup(name);
+  if (!group) {
+    console.error(`Error: Group "${name}" not found.`);
+    process.exit(1);
+  }
+  const registry = loadRegistry();
+  const now = Date.now();
+  console.log(`
+\u{1F4CA} Group "${name}" status
+`);
+  if (group.lastSync) {
+    const age = Math.round((now - new Date(group.lastSync).getTime()) / 6e4);
+    console.log(`Last sync: ${group.lastSync} (${age} min ago)`);
+  } else {
+    console.log("Last sync: never  (run `code-intel group sync " + name + "`)");
+  }
+  console.log(`
+Members (${group.members.length}):
+`);
+  for (const m of group.members) {
+    const regEntry = registry.find((r) => r.name === m.registryName);
+    if (!regEntry) {
+      console.log(`  \u2717 ${m.groupPath.padEnd(35)} [${m.registryName}]  \u2014 NOT IN REGISTRY`);
+      continue;
+    }
+    const metaPath = path.join(regEntry.path, ".code-intel", "meta.json");
+    let indexedAt = regEntry.indexedAt;
+    try {
+      const meta = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
+      indexedAt = meta.indexedAt;
+      const ageMin = Math.round((now - new Date(indexedAt).getTime()) / 6e4);
+      const stale = ageMin > 1440 ? " \u26A0 STALE (>24h)" : "";
+      console.log(`  \u2713 ${m.groupPath.padEnd(35)} [${m.registryName}]  indexed ${indexedAt} (${ageMin} min ago)${stale}`);
+      console.log(`    ${regEntry.path}`);
+      console.log(`    ${meta.stats.nodes} nodes, ${meta.stats.edges} edges, ${meta.stats.files} files`);
+    } catch {
+      console.log(`  \u2717 ${m.groupPath.padEnd(35)} [${m.registryName}]  \u2014 NOT INDEXED  (run: code-intel analyze ${regEntry.path})`);
     }
-    console.log(`\nIndex status for ${workspaceRoot}:`);
-    console.log(`  Indexed at: ${meta.indexedAt}`);
-    console.log(`  Nodes: ${meta.stats.nodes}`);
-    console.log(`  Edges: ${meta.stats.edges}`);
-    console.log(`  Files: ${meta.stats.files}`);
-    console.log(`  Duration: ${meta.stats.duration}ms`);
-});
-program
-    .command('clean')
-    .description('Remove index data')
-    .argument('[path]', 'Path to clean', '.')
-    .action((targetPath) => {
-    const workspaceRoot = path.resolve(targetPath);
-    const codeIntelDir = path.join(workspaceRoot, '.code-intel');
-    if (fs.existsSync(codeIntelDir)) {
-        fs.rmSync(codeIntelDir, { recursive: true, force: true });
-        console.log(`Removed ${codeIntelDir}`);
-    }
-    removeRepo(workspaceRoot);
-    console.log('Index cleaned.');
+  }
 });
 program.parse();
+//# sourceMappingURL=main.js.map
 //# sourceMappingURL=main.js.map