ctxo-mcp 0.2.0 → 0.3.1

package/dist/{cli-router-PIWHLS5F.js → cli-router-NRUGPICL.js}

@@ -2,16 +2,520 @@
 import {
   RevertDetector,
   SimpleGitAdapter,
-  SqliteStorageAdapter
-} from "./chunk-P7JUSY3I.js";
+  SqliteStorageAdapter,
+  aggregateCoChanges
+} from "./chunk-XSHNN6PU.js";
 import {
-  JsonIndexReader
-} from "./chunk-54ETLIQX.js";
+  JsonIndexReader,
+  SYMBOL_KINDS
+} from "./chunk-N6GPODUY.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-JIDIH7DS.js";
+
+// src/adapters/language/tree-sitter-adapter.ts
+import Parser from "tree-sitter";
+import { extname as extname3 } from "path";
+var TreeSitterAdapter;
+var init_tree_sitter_adapter = __esm({
+  "src/adapters/language/tree-sitter-adapter.ts"() {
+    "use strict";
+    TreeSitterAdapter = class {
+      tier = "syntax";
+      parser;
+      symbolRegistry = /* @__PURE__ */ new Map();
+      constructor(language) {
+        this.parser = new Parser();
+        this.parser.setLanguage(language);
+      }
+      isSupported(filePath) {
+        const ext = extname3(filePath).toLowerCase();
+        return this.extensions.includes(ext);
+      }
+      setSymbolRegistry(registry) {
+        this.symbolRegistry = registry;
+      }
+      parse(source) {
+        return this.parser.parse(source);
+      }
+      buildSymbolId(filePath, name, kind) {
+        return `${filePath}::${name}::${kind}`;
+      }
+      nodeToLineRange(node) {
+        return {
+          startLine: node.startPosition.row,
+          endLine: node.endPosition.row,
+          startOffset: node.startIndex,
+          endOffset: node.endIndex
+        };
+      }
+      countCyclomaticComplexity(node, branchTypes) {
+        let complexity = 1;
+        const visit = (n) => {
+          if (branchTypes.includes(n.type)) {
+            complexity++;
+          }
+          for (let i = 0; i < n.childCount; i++) {
+            visit(n.child(i));
+          }
+        };
+        visit(node);
+        return complexity;
+      }
+    };
+  }
+});
+
+// src/adapters/language/go-adapter.ts
+var go_adapter_exports = {};
+__export(go_adapter_exports, {
+  GoAdapter: () => GoAdapter
+});
+import GoLanguage from "tree-sitter-go";
+var GO_BRANCH_TYPES, GoAdapter;
+var init_go_adapter = __esm({
+  "src/adapters/language/go-adapter.ts"() {
+    "use strict";
+    init_tree_sitter_adapter();
+    GO_BRANCH_TYPES = [
+      "if_statement",
+      "for_statement",
+      "expression_switch_statement",
+      "type_switch_statement",
+      "expression_case",
+      "type_case",
+      "select_statement",
+      "communication_case"
+    ];
+    GoAdapter = class extends TreeSitterAdapter {
+      extensions = [".go"];
+      constructor() {
+        super(GoLanguage);
+      }
+      extractSymbols(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const symbols = [];
+          for (let i = 0; i < tree.rootNode.childCount; i++) {
+            const node = tree.rootNode.child(i);
+            if (node.type === "function_declaration") {
+              const name = node.childForFieldName("name")?.text;
+              if (!name || !this.isExported(name)) continue;
+              const range = this.nodeToLineRange(node);
+              symbols.push({
+                symbolId: this.buildSymbolId(filePath, name, "function"),
+                name,
+                kind: "function",
+                ...range
+              });
+            }
+            if (node.type === "method_declaration") {
+              const methodName = node.childForFieldName("name")?.text;
+              if (!methodName || !this.isExported(methodName)) continue;
+              const receiverType = this.extractReceiverType(node);
+              const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
+              const range = this.nodeToLineRange(node);
+              symbols.push({
+                symbolId: this.buildSymbolId(filePath, qualifiedName, "method"),
+                name: qualifiedName,
+                kind: "method",
+                ...range
+              });
+            }
+            if (node.type === "type_declaration") {
+              this.extractTypeSymbols(node, filePath, symbols);
+            }
+          }
+          return symbols;
+        } catch (err) {
+          console.error(`[ctxo:go] Symbol extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      extractEdges(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const edges = [];
+          const firstExportedSymbol = this.findFirstExportedSymbolId(tree.rootNode, filePath);
+          if (!firstExportedSymbol) return edges;
+          for (let i = 0; i < tree.rootNode.childCount; i++) {
+            const node = tree.rootNode.child(i);
+            if (node.type === "import_declaration") {
+              this.extractImportEdges(node, filePath, firstExportedSymbol, edges);
+            }
+          }
+          return edges;
+        } catch (err) {
+          console.error(`[ctxo:go] Edge extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      extractComplexity(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const metrics = [];
+          for (let i = 0; i < tree.rootNode.childCount; i++) {
+            const node = tree.rootNode.child(i);
+            if (node.type === "function_declaration") {
+              const name = node.childForFieldName("name")?.text;
+              if (!name || !this.isExported(name)) continue;
+              metrics.push({
+                symbolId: this.buildSymbolId(filePath, name, "function"),
+                cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES)
+              });
+            }
+            if (node.type === "method_declaration") {
+              const methodName = node.childForFieldName("name")?.text;
+              if (!methodName || !this.isExported(methodName)) continue;
+              const receiverType = this.extractReceiverType(node);
+              const qualifiedName = receiverType ? `${receiverType}.${methodName}` : methodName;
+              metrics.push({
+                symbolId: this.buildSymbolId(filePath, qualifiedName, "method"),
+                cyclomatic: this.countCyclomaticComplexity(node, GO_BRANCH_TYPES)
+              });
+            }
+          }
+          return metrics;
+        } catch (err) {
+          console.error(`[ctxo:go] Complexity extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      // ── Private helpers ─────────────────────────────────────────
+      isExported(name) {
+        return name.length > 0 && name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
+      }
+      extractReceiverType(methodNode) {
+        const params = methodNode.child(1);
+        if (params?.type !== "parameter_list") return void 0;
+        for (let i = 0; i < params.childCount; i++) {
+          const param = params.child(i);
+          if (param.type === "parameter_declaration") {
+            const typeNode = param.childForFieldName("type");
+            if (typeNode) {
+              const text = typeNode.text;
+              return text.replace(/^\*/, "");
+            }
+          }
+        }
+        return void 0;
+      }
+      extractTypeSymbols(typeDecl, filePath, symbols) {
+        for (let i = 0; i < typeDecl.childCount; i++) {
+          const spec = typeDecl.child(i);
+          if (spec.type !== "type_spec") continue;
+          const name = spec.childForFieldName("name")?.text;
+          if (!name || !this.isExported(name)) continue;
+          const typeBody = spec.childForFieldName("type");
+          let kind = "type";
+          if (typeBody?.type === "struct_type") kind = "class";
+          else if (typeBody?.type === "interface_type") kind = "interface";
+          const range = this.nodeToLineRange(spec);
+          symbols.push({
+            symbolId: this.buildSymbolId(filePath, name, kind),
+            name,
+            kind,
+            ...range
+          });
+        }
+      }
+      extractImportEdges(importDecl, _filePath, fromSymbol, edges) {
+        const visit = (node) => {
+          if (node.type === "import_spec") {
+            const pathNode = node.childForFieldName("path") ?? node.child(0);
+            if (pathNode) {
+              const importPath = pathNode.text.replace(/"/g, "");
+              edges.push({
+                from: fromSymbol,
+                to: `${importPath}::${importPath.split("/").pop()}::variable`,
+                kind: "imports"
+              });
+            }
+          }
+          for (let i = 0; i < node.childCount; i++) {
+            visit(node.child(i));
+          }
+        };
+        visit(importDecl);
+      }
+      findFirstExportedSymbolId(rootNode, filePath) {
+        for (let i = 0; i < rootNode.childCount; i++) {
+          const node = rootNode.child(i);
+          if (node.type === "function_declaration") {
+            const name = node.childForFieldName("name")?.text;
+            if (name && this.isExported(name)) return this.buildSymbolId(filePath, name, "function");
+          }
+          if (node.type === "type_declaration") {
+            for (let j = 0; j < node.childCount; j++) {
+              const spec = node.child(j);
+              if (spec.type === "type_spec") {
+                const name = spec.childForFieldName("name")?.text;
+                if (name && this.isExported(name)) {
+                  const typeBody = spec.childForFieldName("type");
+                  const kind = typeBody?.type === "struct_type" ? "class" : typeBody?.type === "interface_type" ? "interface" : "type";
+                  return this.buildSymbolId(filePath, name, kind);
+                }
+              }
+            }
+          }
+        }
+        return void 0;
+      }
+    };
+  }
+});
+
+// src/adapters/language/csharp-adapter.ts
+var csharp_adapter_exports = {};
+__export(csharp_adapter_exports, {
+  CSharpAdapter: () => CSharpAdapter
+});
+import CSharpLanguage from "tree-sitter-c-sharp";
+var CSHARP_BRANCH_TYPES, CSharpAdapter;
+var init_csharp_adapter = __esm({
+  "src/adapters/language/csharp-adapter.ts"() {
+    "use strict";
+    init_tree_sitter_adapter();
+    CSHARP_BRANCH_TYPES = [
+      "if_statement",
+      "for_statement",
+      "foreach_statement",
+      "while_statement",
+      "do_statement",
+      "switch_section",
+      "catch_clause",
+      "conditional_expression"
+    ];
+    CSharpAdapter = class extends TreeSitterAdapter {
+      extensions = [".cs"];
+      constructor() {
+        super(CSharpLanguage);
+      }
+      extractSymbols(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const symbols = [];
+          this.visitSymbols(tree.rootNode, filePath, "", symbols);
+          return symbols;
+        } catch (err) {
+          console.error(`[ctxo:csharp] Symbol extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      extractEdges(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const edges = [];
+          const symbols = this.extractSymbols(filePath, source);
+          const firstSymbol = symbols.length > 0 ? symbols[0].symbolId : void 0;
+          if (!firstSymbol) return edges;
+          this.visitEdges(tree.rootNode, filePath, firstSymbol, "", edges);
+          return edges;
+        } catch (err) {
+          console.error(`[ctxo:csharp] Edge extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      extractComplexity(filePath, source) {
+        try {
+          const tree = this.parse(source);
+          const metrics = [];
+          this.visitComplexity(tree.rootNode, filePath, "", metrics);
+          return metrics;
+        } catch (err) {
+          console.error(`[ctxo:csharp] Complexity extraction failed for ${filePath}: ${err.message}`);
+          return [];
+        }
+      }
+      // ── Symbol visitor ──────────────────────────────────────────
+      visitSymbols(node, filePath, namespace, symbols) {
+        if (node.type === "namespace_declaration") {
+          const name = node.childForFieldName("name")?.text ?? "";
+          const ns = namespace ? `${namespace}.${name}` : name;
+          for (let i = 0; i < node.childCount; i++) {
+            this.visitSymbols(node.child(i), filePath, ns, symbols);
+          }
+          return;
+        }
+        if (node.type === "declaration_list") {
+          for (let i = 0; i < node.childCount; i++) {
+            this.visitSymbols(node.child(i), filePath, namespace, symbols);
+          }
+          return;
+        }
+        const typeMapping = {
+          class_declaration: "class",
+          struct_declaration: "class",
+          record_declaration: "class",
+          interface_declaration: "interface",
+          enum_declaration: "type"
+        };
+        const kind = typeMapping[node.type];
+        if (kind) {
+          if (!this.isPublic(node)) return;
+          const name = node.childForFieldName("name")?.text;
+          if (!name) return;
+          const qualifiedName = namespace ? `${namespace}.${name}` : name;
+          const range = this.nodeToLineRange(node);
+          symbols.push({
+            symbolId: this.buildSymbolId(filePath, qualifiedName, kind),
+            name: qualifiedName,
+            kind,
+            ...range
+          });
+          if (kind === "class") {
+            this.extractMethodSymbols(node, filePath, qualifiedName, symbols);
+          }
+          return;
+        }
+        for (let i = 0; i < node.childCount; i++) {
+          this.visitSymbols(node.child(i), filePath, namespace, symbols);
+        }
+      }
+      extractMethodSymbols(classNode, filePath, className, symbols) {
+        const declList = classNode.children.find((c) => c.type === "declaration_list");
+        if (!declList) return;
+        for (let i = 0; i < declList.childCount; i++) {
+          const child = declList.child(i);
+          if (child.type !== "method_declaration" && child.type !== "constructor_declaration") continue;
+          if (!this.isPublic(child)) continue;
+          const name = child.childForFieldName("name")?.text;
+          if (!name) continue;
+          const paramCount = this.countParameters(child);
+          const qualifiedName = `${className}.${name}(${paramCount})`;
+          const range = this.nodeToLineRange(child);
+          symbols.push({
+            symbolId: this.buildSymbolId(filePath, qualifiedName, "method"),
+            name: qualifiedName,
+            kind: "method",
+            ...range
+          });
+        }
+      }
+      // ── Edge visitor ────────────────────────────────────────────
+      visitEdges(node, filePath, fromSymbol, namespace, edges) {
+        if (node.type === "using_directive") {
+          const nameNode = node.children.find((c) => c.type === "identifier" || c.type === "qualified_name");
+          if (nameNode) {
+            edges.push({
+              from: fromSymbol,
+              to: `${nameNode.text}::${nameNode.text.split(".").pop()}::variable`,
+              kind: "imports"
+            });
+          }
+          return;
+        }
+        if (node.type === "namespace_declaration") {
+          const name = node.childForFieldName("name")?.text ?? "";
+          const ns = namespace ? `${namespace}.${name}` : name;
+          for (let i = 0; i < node.childCount; i++) {
+            this.visitEdges(node.child(i), filePath, fromSymbol, ns, edges);
+          }
+          return;
+        }
+        if (node.type === "class_declaration" || node.type === "struct_declaration") {
+          if (!this.isPublic(node)) return;
+          const name = node.childForFieldName("name")?.text;
+          if (!name) return;
+          const qualifiedName = namespace ? `${namespace}.${name}` : name;
+          const classSymbolId = this.buildSymbolId(filePath, qualifiedName, "class");
+          const baseList = node.children.find((c) => c.type === "base_list");
+          if (baseList) {
+            for (let i = 0; i < baseList.childCount; i++) {
+              const child = baseList.child(i);
+              if (child.type === "identifier" || child.type === "qualified_name") {
+                const baseName = child.text;
+                const edgeKind = baseName.match(/^I[A-Z]/) ? "implements" : "extends";
+                const targetKind = edgeKind === "implements" ? "interface" : "class";
+                edges.push({
+                  from: classSymbolId,
+                  to: this.resolveBaseType(baseName, namespace, targetKind),
+                  kind: edgeKind
+                });
+              }
+            }
+          }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+          this.visitEdges(node.child(i), filePath, fromSymbol, namespace, edges);
+        }
+      }
+      // ── Complexity visitor ──────────────────────────────────────
+      visitComplexity(node, filePath, namespace, metrics) {
+        if (node.type === "namespace_declaration") {
+          const name = node.childForFieldName("name")?.text ?? "";
+          const ns = namespace ? `${namespace}.${name}` : name;
+          for (let i = 0; i < node.childCount; i++) {
+            this.visitComplexity(node.child(i), filePath, ns, metrics);
+          }
+          return;
+        }
+        const typeMapping = {
+          class_declaration: true,
+          struct_declaration: true,
+          record_declaration: true
+        };
+        if (typeMapping[node.type]) {
+          if (!this.isPublic(node)) return;
+          const className = node.childForFieldName("name")?.text;
+          if (!className) return;
+          const qualifiedClass = namespace ? `${namespace}.${className}` : className;
+          const declList = node.children.find((c) => c.type === "declaration_list");
+          if (!declList) return;
+          for (let i = 0; i < declList.childCount; i++) {
+            const child = declList.child(i);
+            if (child.type !== "method_declaration") continue;
+            if (!this.isPublic(child)) continue;
+            const methodName = child.childForFieldName("name")?.text;
+            if (!methodName) continue;
+            const paramCount = this.countParameters(child);
+            metrics.push({
+              symbolId: this.buildSymbolId(filePath, `${qualifiedClass}.${methodName}(${paramCount})`, "method"),
+              cyclomatic: this.countCyclomaticComplexity(child, CSHARP_BRANCH_TYPES)
+            });
+          }
+          return;
+        }
+        for (let i = 0; i < node.childCount; i++) {
+          this.visitComplexity(node.child(i), filePath, namespace, metrics);
+        }
+      }
+      // ── Helpers ─────────────────────────────────────────────────
+      countParameters(methodNode) {
+        const paramList = methodNode.childForFieldName("parameters");
+        if (!paramList) return 0;
+        let count = 0;
+        for (let i = 0; i < paramList.childCount; i++) {
+          if (paramList.child(i).type === "parameter") count++;
+        }
+        return count;
+      }
+      isPublic(node) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child.type === "modifier" && child.text === "public") return true;
+        }
+        return false;
+      }
+      resolveBaseType(baseName, namespace, defaultKind) {
+        const prefix = namespace ? `${namespace}.${baseName}` : baseName;
+        for (const [id] of this.symbolRegistry) {
+          if (id.includes(`::${prefix}::`)) return id;
+          if (id.includes(`::${baseName}::`)) return id;
+        }
+        const qualifiedName = namespace ? `${namespace}.${baseName}` : baseName;
+        return `${qualifiedName}::${baseName}::${defaultKind}`;
+      }
+    };
+  }
+});
 
 // src/cli/index-command.ts
 import { execFileSync } from "child_process";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync3, statSync, readdirSync } from "fs";
-import { join as join4, relative, extname as extname3 } from "path";
+import { join as join4, relative, extname as extname4 } from "path";
 
 // src/core/staleness/content-hasher.ts
 import { createHash } from "crypto";
@@ -34,6 +538,8 @@ var TsMorphAdapter = class {
   extensions = SUPPORTED_EXTENSIONS;
   tier = "full";
   project;
+  symbolRegistry = /* @__PURE__ */ new Map();
+  projectPreloaded = false;
   constructor() {
     this.project = new Project({
       compilerOptions: {
@@ -50,6 +556,27 @@ var TsMorphAdapter = class {
     const ext = extname(filePath).toLowerCase();
     return SUPPORTED_EXTENSIONS.includes(ext);
   }
+  setSymbolRegistry(registry) {
+    this.symbolRegistry = registry;
+  }
+  loadProjectSources(files) {
+    for (const [filePath, source] of files) {
+      try {
+        const existing = this.project.getSourceFile(filePath);
+        if (existing) this.project.removeSourceFile(existing);
+        this.project.createSourceFile(filePath, source, { overwrite: true });
+      } catch (err) {
+        console.error(`[ctxo:ts-morph] Failed to preload ${filePath}: ${err.message}`);
+      }
+    }
+    this.projectPreloaded = true;
+  }
+  clearProjectSources() {
+    for (const sf of this.project.getSourceFiles()) {
+      this.project.removeSourceFile(sf);
+    }
+    this.projectPreloaded = false;
+  }
   extractSymbols(filePath, source) {
     const sourceFile = this.parseSource(filePath, source);
     if (!sourceFile) return [];
@@ -76,12 +603,15 @@ var TsMorphAdapter = class {
       this.extractImportEdges(sourceFile, filePath, edges);
       this.extractInheritanceEdges(sourceFile, filePath, edges);
       this.extractCallEdges(sourceFile, filePath, edges);
+      this.extractReferenceEdges(sourceFile, filePath, edges);
       return edges;
     } catch (err) {
       console.error(`[ctxo:ts-morph] Edge extraction failed for ${filePath}: ${err.message}`);
       return [];
     } finally {
-      this.cleanupSourceFile(filePath);
+      if (!this.projectPreloaded) {
+        this.cleanupSourceFile(filePath);
+      }
     }
   }
   extractComplexity(filePath, source) {
@@ -124,7 +654,9 @@ var TsMorphAdapter = class {
         name,
         kind: "function",
         startLine: fn.getStartLineNumber() - 1,
-        endLine: fn.getEndLineNumber() - 1
+        endLine: fn.getEndLineNumber() - 1,
+        startOffset: fn.getStart(),
+        endOffset: fn.getEnd()
       });
     }
   }
@@ -137,7 +669,9 @@ var TsMorphAdapter = class {
         name,
         kind: "class",
         startLine: cls.getStartLineNumber() - 1,
-        endLine: cls.getEndLineNumber() - 1
+        endLine: cls.getEndLineNumber() - 1,
+        startOffset: cls.getStart(),
+        endOffset: cls.getEnd()
       });
       for (const method of cls.getMethods()) {
         const methodName = method.getName();
@@ -146,7 +680,9 @@ var TsMorphAdapter = class {
           name: `${name}.${methodName}`,
           kind: "method",
           startLine: method.getStartLineNumber() - 1,
-          endLine: method.getEndLineNumber() - 1
+          endLine: method.getEndLineNumber() - 1,
+          startOffset: method.getStart(),
+          endOffset: method.getEnd()
         });
       }
     }
@@ -160,7 +696,9 @@ var TsMorphAdapter = class {
         name,
         kind: "interface",
         startLine: iface.getStartLineNumber() - 1,
-        endLine: iface.getEndLineNumber() - 1
+        endLine: iface.getEndLineNumber() - 1,
+        startOffset: iface.getStart(),
+        endOffset: iface.getEnd()
       });
     }
   }
@@ -173,7 +711,9 @@ var TsMorphAdapter = class {
         name,
         kind: "type",
         startLine: typeAlias.getStartLineNumber() - 1,
-        endLine: typeAlias.getEndLineNumber() - 1
+        endLine: typeAlias.getEndLineNumber() - 1,
+        startOffset: typeAlias.getStart(),
+        endOffset: typeAlias.getEnd()
       });
     }
   }
@@ -187,7 +727,9 @@ var TsMorphAdapter = class {
           name,
           kind: "variable",
           startLine: stmt.getStartLineNumber() - 1,
-          endLine: stmt.getEndLineNumber() - 1
+          endLine: stmt.getEndLineNumber() - 1,
+          startOffset: decl.getStart(),
+          endOffset: decl.getEnd()
         });
       }
     }
@@ -195,7 +737,7 @@ var TsMorphAdapter = class {
   // ── Edge Extraction ─────────────────────────────────────────
   extractImportEdges(sourceFile, filePath, edges) {
     const fileSymbolId = this.buildSymbolId(filePath, sourceFile.getBaseName().replace(/\.[^.]+$/, ""), "variable");
-    const fromSymbols = this.findExportedSymbolsInFile(filePath);
+    const fromSymbols = this.getExportedSymbolIds(sourceFile, filePath);
     const fromSymbol = fromSymbols.length > 0 ? fromSymbols[0] : fileSymbolId;
     for (const imp of sourceFile.getImportDeclarations()) {
       const moduleSpecifier = imp.getModuleSpecifierValue();
@@ -203,21 +745,36 @@ var TsMorphAdapter = class {
         continue;
       }
       const normalizedTarget = this.resolveRelativeImport(filePath, moduleSpecifier);
+      const isTypeOnly = imp.isTypeOnly();
       for (const named of imp.getNamedImports()) {
         const importedName = named.getName();
-        edges.push({
+        const edge = {
           from: fromSymbol,
           to: this.resolveImportTarget(normalizedTarget, importedName),
           kind: "imports"
-        });
+        };
+        if (isTypeOnly || named.isTypeOnly()) edge.typeOnly = true;
+        edges.push(edge);
       }
       const defaultImport = imp.getDefaultImport();
       if (defaultImport) {
-        edges.push({
+        const edge = {
           from: fromSymbol,
           to: this.resolveImportTarget(normalizedTarget, defaultImport.getText()),
           kind: "imports"
-        });
+        };
+        if (isTypeOnly) edge.typeOnly = true;
+        edges.push(edge);
+      }
+      const nsImport = imp.getNamespaceImport();
+      if (nsImport) {
+        const edge = {
+          from: fromSymbol,
+          to: this.buildSymbolId(normalizedTarget, nsImport.getText(), "variable"),
+          kind: "imports"
+        };
+        if (isTypeOnly) edge.typeOnly = true;
+        edges.push(edge);
       }
     }
   }
@@ -228,7 +785,7 @@ var TsMorphAdapter = class {
       const classSymbolId = this.buildSymbolId(filePath, className, "class");
       const baseClass = cls.getExtends();
       if (baseClass) {
-        const baseName = baseClass.getExpression().getText();
+        const baseName = baseClass.getExpression().getText().replace(/<.*>$/, "");
         edges.push({
           from: classSymbolId,
           to: this.resolveSymbolReference(sourceFile, baseName, "class"),
@@ -236,7 +793,7 @@ var TsMorphAdapter = class {
         });
       }
       for (const impl of cls.getImplements()) {
-        const ifaceName = impl.getExpression().getText();
+        const ifaceName = impl.getExpression().getText().replace(/<.*>$/, "");
         edges.push({
           from: classSymbolId,
           to: this.resolveSymbolReference(sourceFile, ifaceName, "interface"),
@@ -259,6 +816,14 @@ var TsMorphAdapter = class {
           edges.push({ from: fnSymbolId, to: resolved, kind: "calls" });
         }
       }
+      for (const newExpr of fn.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+        const calledName = newExpr.getExpression().getText().split(".").pop();
+        if (!calledName) continue;
+        const resolved = this.resolveLocalCallTarget(sourceFile, filePath, calledName);
+        if (resolved) {
+          edges.push({ from: fnSymbolId, to: resolved, kind: "calls" });
+        }
+      }
     }
     for (const cls of sourceFile.getClasses()) {
       const className = cls.getName();
@@ -270,8 +835,26 @@ var TsMorphAdapter = class {
           const calledText = call.getExpression().getText();
           const calledName = calledText.split(".").pop();
           if (!calledName || calledName === methodName) continue;
-          if (calledText.startsWith("this.")) continue;
-          const resolved = this.resolveLocalCallTarget(sourceFile, filePath, calledName);
+          let resolved;
+          if (calledText.startsWith("this.")) {
+            resolved = this.resolveThisMethodCall(sourceFile, filePath, className, calledName);
+          } else {
+            resolved = this.resolveLocalCallTarget(sourceFile, filePath, calledName);
+          }
+          if (resolved) {
+            edges.push({ from: methodSymbolId, to: resolved, kind: "calls" });
+          }
+        }
+        for (const newExpr of method.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+          const calledText = newExpr.getExpression().getText();
+          const calledName = calledText.split(".").pop();
+          if (!calledName) continue;
+          let resolved;
+          if (calledText.startsWith("this.")) {
+            resolved = this.resolveThisMethodCall(sourceFile, filePath, className, calledName);
+          } else {
+            resolved = this.resolveLocalCallTarget(sourceFile, filePath, calledName);
+          }
           if (resolved) {
             edges.push({ from: methodSymbolId, to: resolved, kind: "calls" });
           }
@@ -279,6 +862,48 @@ var TsMorphAdapter = class {
       }
     }
   }
+  extractReferenceEdges(sourceFile, filePath, edges) {
+    const importMap = /* @__PURE__ */ new Map();
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const mod = imp.getModuleSpecifierValue();
+      if (!mod.startsWith(".") && !mod.startsWith("/")) continue;
+      const targetFile = this.resolveRelativeImport(filePath, mod);
+      for (const named of imp.getNamedImports()) {
+        importMap.set(named.getName(), this.resolveImportTarget(targetFile, named.getName()));
+      }
+      const defaultImport = imp.getDefaultImport();
+      if (defaultImport) {
+        importMap.set(defaultImport.getText(), this.resolveImportTarget(targetFile, defaultImport.getText()));
+      }
+    }
+    if (importMap.size === 0) return;
+    for (const fn of sourceFile.getFunctions()) {
+      if (!this.isExported(fn)) continue;
+      const fnName = fn.getName();
+      if (!fnName) continue;
+      const fromId = this.buildSymbolId(filePath, fnName, "function");
+      this.emitUsesEdges(fn, fromId, importMap, edges);
+    }
+    for (const cls of sourceFile.getClasses()) {
+      if (!this.isExported(cls)) continue;
+      const className = cls.getName();
+      if (!className) continue;
+      const classId = this.buildSymbolId(filePath, className, "class");
+      this.emitUsesEdges(cls, classId, importMap, edges);
+    }
+  }
+  emitUsesEdges(node, fromId, importMap, edges) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of node.getDescendantsOfKind(SyntaxKind.Identifier)) {
+      const name = id.getText();
+      if (seen.has(name)) continue;
+      const target = importMap.get(name);
+      if (target) {
+        seen.add(name);
+        edges.push({ from: fromId, to: target, kind: "uses" });
+      }
+    }
+  }
   resolveLocalCallTarget(sourceFile, filePath, calledName) {
     for (const imp of sourceFile.getImportDeclarations()) {
       const moduleSpecifier = imp.getModuleSpecifierValue();
@@ -297,10 +922,24 @@ var TsMorphAdapter = class {
     }
     return void 0;
   }
+  resolveThisMethodCall(sourceFile, filePath, className, calledName) {
+    for (const cls of sourceFile.getClasses()) {
+      if (cls.getName() !== className) continue;
+      for (const method of cls.getMethods()) {
+        if (method.getName() === calledName) {
+          return this.buildSymbolId(filePath, `${className}.${calledName}`, "method");
+        }
+      }
+    }
+    return void 0;
+  }
   // ── Helpers ─────────────────────────────────────────────────
   parseSource(filePath, source) {
     try {
       const existing = this.project.getSourceFile(filePath);
+      if (existing && this.projectPreloaded) {
+        return existing;
+      }
       if (existing) {
         this.project.removeSourceFile(existing);
       }
@@ -332,6 +971,12 @@ var TsMorphAdapter = class {
     return resolved;
   }
   resolveImportTarget(targetFile, name) {
+    const prefix = `${targetFile}::${name}::`;
+    for (const kind2 of SYMBOL_KINDS) {
+      if (this.symbolRegistry.has(`${prefix}${kind2}`)) {
+        return `${prefix}${kind2}`;
+      }
+    }
     const targetSourceFile = this.project.getSourceFile(targetFile);
     if (targetSourceFile) {
       for (const fn of targetSourceFile.getFunctions()) {
@@ -364,8 +1009,13 @@ var TsMorphAdapter = class {
       if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) continue;
       for (const named of imp.getNamedImports()) {
         if (named.getName() === name) {
-          const targetFile = imp.getModuleSpecifierSourceFile()?.getFilePath() ?? moduleSpecifier;
-          return `${this.normalizeFilePath(targetFile)}::${name}::${defaultKind}`;
+          const resolved = imp.getModuleSpecifierSourceFile()?.getFilePath();
+          if (resolved) {
+            return `${this.normalizeFilePath(resolved)}::${name}::${defaultKind}`;
+          }
+          const sourceDir = dirname(this.normalizeFilePath(sourceFile.getFilePath()));
+          const resolvedPath = normalize(join(sourceDir, moduleSpecifier)).replace(/\\/g, "/").replace(/\.jsx$/, ".tsx").replace(/\.js$/, ".ts");
+          return `${resolvedPath}::${name}::${defaultKind}`;
         }
       }
     }
@@ -380,9 +1030,7 @@ var TsMorphAdapter = class {
   normalizeFilePath(filePath) {
     return filePath.replace(/^\//, "");
   }
-  findExportedSymbolsInFile(filePath) {
-    const sourceFile = this.project.getSourceFile(filePath);
-    if (!sourceFile) return [];
+  getExportedSymbolIds(sourceFile, filePath) {
     const ids = [];
     for (const fn of sourceFile.getFunctions()) {
       if (!this.isExported(fn)) continue;
@@ -455,6 +1103,9 @@ var LanguageAdapterRegistry = class {
       this.adaptersByExtension.set(ext.toLowerCase(), adapter);
     }
   }
+  getSupportedExtensions() {
+    return new Set(this.adaptersByExtension.keys());
+  }
   getAdapter(filePath) {
     if (!filePath) return void 0;
     const ext = extname2(filePath).toLowerCase();
@@ -464,7 +1115,7 @@ var LanguageAdapterRegistry = class {
 };
 
 // src/adapters/storage/json-index-writer.ts
-import { writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { writeFileSync, renameSync, mkdirSync, unlinkSync, existsSync } from "fs";
 import { dirname as dirname2, join as join2, resolve, sep } from "path";
 var JsonIndexWriter = class {
   indexDir;
@@ -479,7 +1130,17 @@ var JsonIndexWriter = class {
     mkdirSync(dirname2(targetPath), { recursive: true });
     const sorted = this.sortKeys(fileIndex);
     const json = JSON.stringify(sorted, null, 2);
-    writeFileSync(targetPath, json, "utf-8");
+    this.atomicWrite(targetPath, json);
+  }
+  writeCoChanges(matrix) {
+    mkdirSync(this.indexDir, { recursive: true });
+    const targetPath = join2(this.indexDir, "co-changes.json");
+    this.atomicWrite(targetPath, JSON.stringify(matrix, null, 2));
+  }
+  atomicWrite(targetPath, content) {
+    const tmpPath = `${targetPath}.${process.pid}.tmp`;
+    writeFileSync(tmpPath, content, "utf-8");
+    renameSync(tmpPath, targetPath);
   }
   delete(relativePath) {
     const targetPath = this.resolveIndexPath(relativePath);
@@ -543,16 +1204,21 @@ var SchemaManager = class {
 var IndexCommand = class {
   projectRoot;
   ctxoRoot;
+  supportedExtensions;
   constructor(projectRoot, ctxoRoot) {
     this.projectRoot = projectRoot;
     this.ctxoRoot = ctxoRoot ?? join4(projectRoot, ".ctxo");
+    this.supportedExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".go", ".cs"]);
   }
   async run(options = {}) {
     if (options.check) {
       return this.runCheck();
     }
     const registry = new LanguageAdapterRegistry();
-    registry.register(new TsMorphAdapter());
+    const tsMorphAdapter = new TsMorphAdapter();
+    registry.register(tsMorphAdapter);
+    this.registerTreeSitterAdapters(registry);
+    this.supportedExtensions = registry.getSupportedExtensions();
     const writer = new JsonIndexWriter(this.ctxoRoot);
     const schemaManager = new SchemaManager(this.ctxoRoot);
     const hasher = new ContentHasher();
@@ -572,7 +1238,8 @@ var IndexCommand = class {
       }
       console.error(`[ctxo] Building codebase index... Found ${files.length} source files`);
     }
-    const indices = [];
+    const symbolRegistry = /* @__PURE__ */ new Map();
+    const pendingIndices = [];
     let processed = 0;
     for (const filePath of files) {
       const adapter = registry.getAdapter(filePath);
@@ -582,40 +1249,73 @@ var IndexCommand = class {
         const source = readFileSync2(filePath, "utf-8");
         const lastModified = Math.floor(Date.now() / 1e3);
         const symbols = adapter.extractSymbols(relativePath, source);
-        const edges = adapter.extractEdges(relativePath, source);
         const complexity = adapter.extractComplexity(relativePath, source);
-        let intent = [];
-        let antiPatterns = [];
-        if (!options.skipHistory) {
-          const commits = await gitAdapter.getCommitHistory(relativePath);
-          intent = commits.map((c) => ({
-            hash: c.hash,
-            message: c.message,
-            date: c.date,
-            kind: "commit"
-          }));
-          antiPatterns = revertDetector.detect(commits);
+        for (const sym of symbols) {
+          symbolRegistry.set(sym.symbolId, sym.kind);
         }
-        const fileIndex = {
-          file: relativePath,
-          lastModified,
-          contentHash: hasher.hash(source),
-          symbols,
-          edges,
-          complexity,
-          intent,
-          antiPatterns
-        };
-        writer.write(fileIndex);
-        indices.push(fileIndex);
+        pendingIndices.push({
+          relativePath,
+          source,
+          fileIndex: {
+            file: relativePath,
+            lastModified,
+            contentHash: hasher.hash(source),
+            symbols,
+            edges: [],
+            complexity,
+            intent: [],
+            antiPatterns: []
+          }
+        });
         processed++;
         if (processed % 50 === 0) {
-          console.error(`[ctxo] Processed ${processed}/${files.length} files`);
+          console.error(`[ctxo] Processed ${processed}/${files.length} files (symbols)`);
         }
       } catch (err) {
         console.error(`[ctxo] Skipped ${relativePath}: ${err.message}`);
       }
     }
+    const allSources = /* @__PURE__ */ new Map();
+    for (const entry of pendingIndices) {
+      allSources.set(entry.relativePath, entry.source);
+    }
+    tsMorphAdapter.loadProjectSources(allSources);
+    for (const entry of pendingIndices) {
+      const adapter = registry.getAdapter(entry.relativePath);
+      if (!adapter) continue;
+      try {
+        adapter.setSymbolRegistry?.(symbolRegistry);
+        entry.fileIndex.edges = adapter.extractEdges(entry.relativePath, entry.source);
+      } catch (err) {
+        console.error(`[ctxo] Edge extraction failed for ${entry.relativePath}: ${err.message}`);
+      }
+    }
+    tsMorphAdapter.clearProjectSources();
+    if (!options.skipHistory && pendingIndices.length > 0) {
+      const maxHistory = options.maxHistory ?? 20;
+      const batchHistory = await gitAdapter.getBatchHistory?.(maxHistory) ?? /* @__PURE__ */ new Map();
+      for (const { relativePath, fileIndex } of pendingIndices) {
+        const commits = batchHistory.get(relativePath) ?? [];
+        fileIndex.intent = commits.map((c) => ({
+          hash: c.hash,
+          message: c.message,
+          date: c.date,
+          kind: "commit"
+        }));
+        fileIndex.antiPatterns = revertDetector.detect(commits);
+      }
+    }
+    if (!options.skipHistory && pendingIndices.length > 0) {
+      const fileIndices = pendingIndices.map((e) => e.fileIndex);
+      const coChangeMatrix = aggregateCoChanges(fileIndices);
+      writer.writeCoChanges(coChangeMatrix);
+      console.error(`[ctxo] Co-change analysis: ${coChangeMatrix.entries.length} file pairs detected`);
+    }
+    const indices = [];
+    for (const { fileIndex } of pendingIndices) {
+      writer.write(fileIndex);
+      indices.push(fileIndex);
+    }
     schemaManager.writeVersion();
     const storage = new SqliteStorageAdapter(this.ctxoRoot);
     try {
@@ -629,6 +1329,20 @@ var IndexCommand = class {
     }
     console.error(`[ctxo] Index complete: ${processed} files indexed`);
   }
+  registerTreeSitterAdapters(registry) {
+    try {
+      const { GoAdapter: GoAdapter2 } = (init_go_adapter(), __toCommonJS(go_adapter_exports));
+      registry.register(new GoAdapter2());
+    } catch {
+      console.error("[ctxo] Go adapter unavailable (tree-sitter-go not installed)");
+    }
+    try {
+      const { CSharpAdapter: CSharpAdapter2 } = (init_csharp_adapter(), __toCommonJS(csharp_adapter_exports));
+      registry.register(new CSharpAdapter2());
+    } catch {
+      console.error("[ctxo] C# adapter unavailable (tree-sitter-c-sharp not installed)");
+    }
+  }
   discoverFilesIn(root) {
     try {
       const output = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
@@ -675,20 +1389,23 @@ var IndexCommand = class {
     }
   }
   isSupportedExtension(filePath) {
-    const ext = extname3(filePath).toLowerCase();
-    return [".ts", ".tsx", ".js", ".jsx"].includes(ext);
+    const ext = extname4(filePath).toLowerCase();
+    return this.supportedExtensions.has(ext);
   }
   async runCheck() {
     console.error("[ctxo] Checking index freshness...");
+    const registry = new LanguageAdapterRegistry();
+    registry.register(new TsMorphAdapter());
+    this.registerTreeSitterAdapters(registry);
+    this.supportedExtensions = registry.getSupportedExtensions();
     const hasher = new ContentHasher();
     const files = this.discoverFilesIn(this.projectRoot);
-    const reader = new (await import("./json-index-reader-PNLPAS42.js")).JsonIndexReader(this.ctxoRoot);
+    const reader = new (await import("./json-index-reader-FCKSKA6R.js")).JsonIndexReader(this.ctxoRoot);
     const indices = reader.readAll();
     const indexedMap = new Map(indices.map((i) => [i.file, i]));
     let staleCount = 0;
     for (const filePath of files) {
-      const ext = extname3(filePath).toLowerCase();
-      if (![".ts", ".tsx", ".js", ".jsx"].includes(ext)) continue;
+      if (!this.isSupportedExtension(filePath)) continue;
       const relativePath = relative(this.projectRoot, filePath).replace(/\\/g, "/");
       const indexed = indexedMap.get(relativePath);
       if (!indexed) {
@@ -911,7 +1628,7 @@ var InitCommand = class {
 };
 
 // src/cli/watch-command.ts
-import { join as join9, extname as extname4, relative as relative2 } from "path";
+import { join as join9, extname as extname5, relative as relative2 } from "path";
 import { readFileSync as readFileSync4 } from "fs";
 
 // src/adapters/watcher/chokidar-watcher-adapter.ts
@@ -953,7 +1670,6 @@ var ChokidarWatcherAdapter = class {
 };
 
 // src/cli/watch-command.ts
-var SUPPORTED_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
 var DEBOUNCE_MS = 300;
 var WatchCommand = class {
   projectRoot;
@@ -966,6 +1682,8 @@ var WatchCommand = class {
     console.error("[ctxo] Starting file watcher...");
     const registry = new LanguageAdapterRegistry();
     registry.register(new TsMorphAdapter());
+    this.registerTreeSitterAdapters(registry);
+    const supportedExtensions = registry.getSupportedExtensions();
     const writer = new JsonIndexWriter(this.ctxoRoot);
     const storage = new SqliteStorageAdapter(this.ctxoRoot);
     await storage.init();
@@ -975,8 +1693,6 @@ var WatchCommand = class {
     const watcher = new ChokidarWatcherAdapter(this.projectRoot);
     const pendingFiles = /* @__PURE__ */ new Map();
     const reindexFile = async (filePath) => {
-      const ext = extname4(filePath).toLowerCase();
-      if (!SUPPORTED_EXTENSIONS2.has(ext)) return;
       const adapter = registry.getAdapter(filePath);
       if (!adapter) return;
       const relativePath = relative2(this.projectRoot, filePath).replace(/\\/g, "/");
@@ -1024,8 +1740,8 @@ var WatchCommand = class {
     };
     watcher.start((event, filePath) => {
       if (event === "unlink") {
-        const ext = extname4(filePath).toLowerCase();
-        if (!SUPPORTED_EXTENSIONS2.has(ext)) return;
+        const ext = extname5(filePath).toLowerCase();
+        if (!supportedExtensions.has(ext)) return;
         const relativePath = relative2(this.projectRoot, filePath).replace(/\\/g, "/");
         writer.delete(relativePath);
         storage.deleteSymbolFile(relativePath);
@@ -1049,6 +1765,20 @@ var WatchCommand = class {
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
   }
+  registerTreeSitterAdapters(registry) {
+    try {
+      const { GoAdapter: GoAdapter2 } = (init_go_adapter(), __toCommonJS(go_adapter_exports));
+      registry.register(new GoAdapter2());
+    } catch {
+      console.error("[ctxo] Go adapter unavailable (tree-sitter-go not installed)");
+    }
+    try {
+      const { CSharpAdapter: CSharpAdapter2 } = (init_csharp_adapter(), __toCommonJS(csharp_adapter_exports));
+      registry.register(new CSharpAdapter2());
+    } catch {
+      console.error("[ctxo] C# adapter unavailable (tree-sitter-c-sharp not installed)");
+    }
+  }
 };
 
 // src/cli/cli-router.ts
@@ -1070,10 +1800,18 @@ var CliRouter = class {
         if (fileIdx !== -1 && (!fileArg || fileArg.startsWith("--"))) {
           console.error("[ctxo] --file requires a path argument");
           process.exit(1);
+          return;
         }
         const checkArg = args.includes("--check");
         const skipHistory = args.includes("--skip-history");
-        await new IndexCommand(this.projectRoot).run({ file: fileArg, check: checkArg, skipHistory });
+        const maxHistoryIdx = args.indexOf("--max-history");
+        const maxHistoryArg = maxHistoryIdx !== -1 ? Number(args[maxHistoryIdx + 1]) : void 0;
+        if (maxHistoryIdx !== -1 && (!maxHistoryArg || isNaN(maxHistoryArg) || maxHistoryArg < 1)) {
+          console.error("[ctxo] --max-history requires a positive integer");
+          process.exit(1);
+          return;
+        }
+        await new IndexCommand(this.projectRoot).run({ file: fileArg, check: checkArg, skipHistory, maxHistory: maxHistoryArg });
         break;
       }
       case "sync":
@@ -1094,6 +1832,7 @@ var CliRouter = class {
       default:
         console.error(`[ctxo] Unknown command: "${command}". Run "ctxo --help" for usage.`);
         process.exit(1);
+        return;
     }
   }
   printHelp() {
@@ -1102,7 +1841,7 @@ ctxo \u2014 MCP server for dependency-aware codebase context
 
 Usage:
   ctxo                      Start MCP server (stdio transport)
-  ctxo index                Build full codebase index
+  ctxo index                Build full codebase index (--max-history N, default 20)
   ctxo sync                 Rebuild SQLite cache from committed JSON index
   ctxo watch                Start file watcher for incremental re-indexing
   ctxo verify-index         CI gate: fail if index is stale
@@ -1115,4 +1854,4 @@ Usage:
 export {
   CliRouter
 };
-//# sourceMappingURL=cli-router-PIWHLS5F.js.map
+//# sourceMappingURL=cli-router-NRUGPICL.js.map