ctxo-mcp 0.2.0

package/dist/cli-router-PIWHLS5F.js

@@ -0,0 +1,1118 @@
+#!/usr/bin/env node
+import {
+  RevertDetector,
+  SimpleGitAdapter,
+  SqliteStorageAdapter
+} from "./chunk-P7JUSY3I.js";
+import {
+  JsonIndexReader
+} from "./chunk-54ETLIQX.js";
+
+// 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";
+
+// src/core/staleness/content-hasher.ts
+import { createHash } from "crypto";
+var ContentHasher = class {
+  hash(content) {
+    return createHash("sha256").update(content, "utf-8").digest("hex");
+  }
+};
+
+// src/adapters/language/ts-morph-adapter.ts
+import {
+  Project,
+  SyntaxKind,
+  Node,
+  ScriptTarget
+} from "ts-morph";
+import { extname, dirname, join, normalize } from "path";
+var SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var TsMorphAdapter = class {
+  extensions = SUPPORTED_EXTENSIONS;
+  tier = "full";
+  project;
+  constructor() {
+    this.project = new Project({
+      compilerOptions: {
+        target: ScriptTarget.ES2022,
+        allowJs: true,
+        jsx: 2,
+        // React
+        skipLibCheck: true
+      },
+      useInMemoryFileSystem: true
+    });
+  }
+  isSupported(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return SUPPORTED_EXTENSIONS.includes(ext);
+  }
+  extractSymbols(filePath, source) {
+    const sourceFile = this.parseSource(filePath, source);
+    if (!sourceFile) return [];
+    try {
+      const symbols = [];
+      this.extractFunctions(sourceFile, filePath, symbols);
+      this.extractClasses(sourceFile, filePath, symbols);
+      this.extractInterfaces(sourceFile, filePath, symbols);
+      this.extractTypeAliases(sourceFile, filePath, symbols);
+      this.extractVariables(sourceFile, filePath, symbols);
+      return symbols;
+    } catch (err) {
+      console.error(`[ctxo:ts-morph] Symbol extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    } finally {
+      this.cleanupSourceFile(filePath);
+    }
+  }
+  extractEdges(filePath, source) {
+    const sourceFile = this.parseSource(filePath, source);
+    if (!sourceFile) return [];
+    try {
+      const edges = [];
+      this.extractImportEdges(sourceFile, filePath, edges);
+      this.extractInheritanceEdges(sourceFile, filePath, edges);
+      this.extractCallEdges(sourceFile, filePath, edges);
+      return edges;
+    } catch (err) {
+      console.error(`[ctxo:ts-morph] Edge extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    } finally {
+      this.cleanupSourceFile(filePath);
+    }
+  }
+  extractComplexity(filePath, source) {
+    const sourceFile = this.parseSource(filePath, source);
+    if (!sourceFile) return [];
+    try {
+      const metrics = [];
+      for (const fn of sourceFile.getFunctions()) {
+        if (!this.isExported(fn)) continue;
+        const name = fn.getName();
+        if (!name) continue;
+        const symbolId = this.buildSymbolId(filePath, name, "function");
+        metrics.push({ symbolId, cyclomatic: this.countCyclomaticComplexity(fn) });
+      }
+      for (const cls of sourceFile.getClasses()) {
+        const className = cls.getName();
+        if (!className || !this.isExported(cls)) continue;
+        for (const method of cls.getMethods()) {
+          const methodName = method.getName();
+          const symbolId = this.buildSymbolId(filePath, `${className}.${methodName}`, "method");
+          metrics.push({ symbolId, cyclomatic: this.countCyclomaticComplexity(method) });
+        }
+      }
+      return metrics;
+    } catch (err) {
+      console.error(`[ctxo:ts-morph] Complexity extraction failed for ${filePath}: ${err.message}`);
+      return [];
+    } finally {
+      this.cleanupSourceFile(filePath);
+    }
+  }
+  // ── Symbol Extraction ───────────────────────────────────────
+  extractFunctions(sourceFile, filePath, symbols) {
+    for (const fn of sourceFile.getFunctions()) {
+      if (!this.isExported(fn)) continue;
+      const name = fn.getName();
+      if (!name) continue;
+      symbols.push({
+        symbolId: this.buildSymbolId(filePath, name, "function"),
+        name,
+        kind: "function",
+        startLine: fn.getStartLineNumber() - 1,
+        endLine: fn.getEndLineNumber() - 1
+      });
+    }
+  }
+  extractClasses(sourceFile, filePath, symbols) {
+    for (const cls of sourceFile.getClasses()) {
+      const name = cls.getName();
+      if (!name || !this.isExported(cls)) continue;
+      symbols.push({
+        symbolId: this.buildSymbolId(filePath, name, "class"),
+        name,
+        kind: "class",
+        startLine: cls.getStartLineNumber() - 1,
+        endLine: cls.getEndLineNumber() - 1
+      });
+      for (const method of cls.getMethods()) {
+        const methodName = method.getName();
+        symbols.push({
+          symbolId: this.buildSymbolId(filePath, `${name}.${methodName}`, "method"),
+          name: `${name}.${methodName}`,
+          kind: "method",
+          startLine: method.getStartLineNumber() - 1,
+          endLine: method.getEndLineNumber() - 1
+        });
+      }
+    }
+  }
+  extractInterfaces(sourceFile, filePath, symbols) {
+    for (const iface of sourceFile.getInterfaces()) {
+      if (!this.isExported(iface)) continue;
+      const name = iface.getName();
+      symbols.push({
+        symbolId: this.buildSymbolId(filePath, name, "interface"),
+        name,
+        kind: "interface",
+        startLine: iface.getStartLineNumber() - 1,
+        endLine: iface.getEndLineNumber() - 1
+      });
+    }
+  }
+  extractTypeAliases(sourceFile, filePath, symbols) {
+    for (const typeAlias of sourceFile.getTypeAliases()) {
+      if (!this.isExported(typeAlias)) continue;
+      const name = typeAlias.getName();
+      symbols.push({
+        symbolId: this.buildSymbolId(filePath, name, "type"),
+        name,
+        kind: "type",
+        startLine: typeAlias.getStartLineNumber() - 1,
+        endLine: typeAlias.getEndLineNumber() - 1
+      });
+    }
+  }
+  extractVariables(sourceFile, filePath, symbols) {
+    for (const stmt of sourceFile.getVariableStatements()) {
+      if (!this.isExported(stmt)) continue;
+      for (const decl of stmt.getDeclarations()) {
+        const name = decl.getName();
+        symbols.push({
+          symbolId: this.buildSymbolId(filePath, name, "variable"),
+          name,
+          kind: "variable",
+          startLine: stmt.getStartLineNumber() - 1,
+          endLine: stmt.getEndLineNumber() - 1
+        });
+      }
+    }
+  }
+  // ── Edge Extraction ─────────────────────────────────────────
+  extractImportEdges(sourceFile, filePath, edges) {
+    const fileSymbolId = this.buildSymbolId(filePath, sourceFile.getBaseName().replace(/\.[^.]+$/, ""), "variable");
+    const fromSymbols = this.findExportedSymbolsInFile(filePath);
+    const fromSymbol = fromSymbols.length > 0 ? fromSymbols[0] : fileSymbolId;
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
+        continue;
+      }
+      const normalizedTarget = this.resolveRelativeImport(filePath, moduleSpecifier);
+      for (const named of imp.getNamedImports()) {
+        const importedName = named.getName();
+        edges.push({
+          from: fromSymbol,
+          to: this.resolveImportTarget(normalizedTarget, importedName),
+          kind: "imports"
+        });
+      }
+      const defaultImport = imp.getDefaultImport();
+      if (defaultImport) {
+        edges.push({
+          from: fromSymbol,
+          to: this.resolveImportTarget(normalizedTarget, defaultImport.getText()),
+          kind: "imports"
+        });
+      }
+    }
+  }
+  extractInheritanceEdges(sourceFile, filePath, edges) {
+    for (const cls of sourceFile.getClasses()) {
+      const className = cls.getName();
+      if (!className || !this.isExported(cls)) continue;
+      const classSymbolId = this.buildSymbolId(filePath, className, "class");
+      const baseClass = cls.getExtends();
+      if (baseClass) {
+        const baseName = baseClass.getExpression().getText();
+        edges.push({
+          from: classSymbolId,
+          to: this.resolveSymbolReference(sourceFile, baseName, "class"),
+          kind: "extends"
+        });
+      }
+      for (const impl of cls.getImplements()) {
+        const ifaceName = impl.getExpression().getText();
+        edges.push({
+          from: classSymbolId,
+          to: this.resolveSymbolReference(sourceFile, ifaceName, "interface"),
+          kind: "implements"
+        });
+      }
+    }
+  }
+  extractCallEdges(sourceFile, filePath, edges) {
+    for (const fn of sourceFile.getFunctions()) {
+      if (!this.isExported(fn)) continue;
+      const fnName = fn.getName();
+      if (!fnName) continue;
+      const fnSymbolId = this.buildSymbolId(filePath, fnName, "function");
+      for (const call of fn.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const calledName = call.getExpression().getText().split(".").pop();
+        if (!calledName || calledName === fnName) 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();
+      if (!className || !this.isExported(cls)) continue;
+      for (const method of cls.getMethods()) {
+        const methodName = method.getName();
+        const methodSymbolId = this.buildSymbolId(filePath, `${className}.${methodName}`, "method");
+        for (const call of method.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+          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);
+          if (resolved) {
+            edges.push({ from: methodSymbolId, to: resolved, kind: "calls" });
+          }
+        }
+      }
+    }
+  }
+  resolveLocalCallTarget(sourceFile, filePath, calledName) {
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) continue;
+      for (const named of imp.getNamedImports()) {
+        if (named.getName() === calledName) {
+          const targetFile = this.resolveRelativeImport(filePath, moduleSpecifier);
+          return this.resolveImportTarget(targetFile, calledName);
+        }
+      }
+    }
+    for (const fn of sourceFile.getFunctions()) {
+      if (fn.getName() === calledName) {
+        return this.buildSymbolId(filePath, calledName, "function");
+      }
+    }
+    return void 0;
+  }
+  // ── Helpers ─────────────────────────────────────────────────
+  parseSource(filePath, source) {
+    try {
+      const existing = this.project.getSourceFile(filePath);
+      if (existing) {
+        this.project.removeSourceFile(existing);
+      }
+      return this.project.createSourceFile(filePath, source, { overwrite: true });
+    } catch (err) {
+      console.error(`[ctxo:ts-morph] Parse failed for ${filePath}: ${err.message}`);
+      return void 0;
+    }
+  }
+  cleanupSourceFile(filePath) {
+    const existing = this.project.getSourceFile(filePath);
+    if (existing) {
+      this.project.removeSourceFile(existing);
+    }
+  }
+  buildSymbolId(filePath, name, kind) {
+    return `${filePath}::${name}::${kind}`;
+  }
+  resolveRelativeImport(fromFile, moduleSpecifier) {
+    const fromDir = dirname(fromFile);
+    let resolved = normalize(join(fromDir, moduleSpecifier)).replace(/\\/g, "/");
+    if (resolved.endsWith(".js")) {
+      resolved = resolved.slice(0, -3) + ".ts";
+    } else if (resolved.endsWith(".jsx")) {
+      resolved = resolved.slice(0, -4) + ".tsx";
+    } else if (!extname(resolved)) {
+      resolved += ".ts";
+    }
+    return resolved;
+  }
+  resolveImportTarget(targetFile, name) {
+    const targetSourceFile = this.project.getSourceFile(targetFile);
+    if (targetSourceFile) {
+      for (const fn of targetSourceFile.getFunctions()) {
+        if (fn.getName() === name && this.isExported(fn)) {
+          return this.buildSymbolId(targetFile, name, "function");
+        }
+      }
+      for (const cls of targetSourceFile.getClasses()) {
+        if (cls.getName() === name && this.isExported(cls)) {
+          return this.buildSymbolId(targetFile, name, "class");
+        }
+      }
+      for (const iface of targetSourceFile.getInterfaces()) {
+        if (iface.getName() === name && this.isExported(iface)) {
+          return this.buildSymbolId(targetFile, name, "interface");
+        }
+      }
+      for (const t of targetSourceFile.getTypeAliases()) {
+        if (t.getName() === name && this.isExported(t)) {
+          return this.buildSymbolId(targetFile, name, "type");
+        }
+      }
+    }
+    const kind = this.inferSymbolKind(name);
+    return `${targetFile}::${name}::${kind}`;
+  }
+  resolveSymbolReference(sourceFile, name, defaultKind) {
+    for (const imp of sourceFile.getImportDeclarations()) {
+      const moduleSpecifier = imp.getModuleSpecifierValue();
+      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}`;
+        }
+      }
+    }
+    return `${sourceFile.getFilePath()}::${name}::${defaultKind}`;
+  }
+  inferSymbolKind(name) {
+    if (/^I[A-Z]/.test(name) && name.length > 2) return "interface";
+    if (/^[A-Z][A-Z_0-9]+$/.test(name)) return "variable";
+    if (/^[A-Z]/.test(name)) return "class";
+    return "function";
+  }
+  normalizeFilePath(filePath) {
+    return filePath.replace(/^\//, "");
+  }
+  findExportedSymbolsInFile(filePath) {
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) return [];
+    const ids = [];
+    for (const fn of sourceFile.getFunctions()) {
+      if (!this.isExported(fn)) continue;
+      const name = fn.getName();
+      if (name) ids.push(this.buildSymbolId(filePath, name, "function"));
+    }
+    for (const cls of sourceFile.getClasses()) {
+      if (!this.isExported(cls)) continue;
+      const name = cls.getName();
+      if (name) ids.push(this.buildSymbolId(filePath, name, "class"));
+    }
+    for (const iface of sourceFile.getInterfaces()) {
+      if (!this.isExported(iface)) continue;
+      ids.push(this.buildSymbolId(filePath, iface.getName(), "interface"));
+    }
+    for (const t of sourceFile.getTypeAliases()) {
+      if (!this.isExported(t)) continue;
+      ids.push(this.buildSymbolId(filePath, t.getName(), "type"));
+    }
+    for (const stmt of sourceFile.getVariableStatements()) {
+      if (!this.isExported(stmt)) continue;
+      for (const decl of stmt.getDeclarations()) {
+        ids.push(this.buildSymbolId(filePath, decl.getName(), "variable"));
+      }
+    }
+    return ids;
+  }
+  isExported(node) {
+    if (Node.isExportable(node)) {
+      return node.isExported();
+    }
+    return false;
+  }
+  countCyclomaticComplexity(node) {
+    let complexity = 1;
+    node.forEachDescendant((child) => {
+      switch (child.getKind()) {
+        case SyntaxKind.IfStatement:
+        case SyntaxKind.ConditionalExpression:
+        case SyntaxKind.ForStatement:
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement:
+        case SyntaxKind.WhileStatement:
+        case SyntaxKind.DoStatement:
+        case SyntaxKind.CaseClause:
+        case SyntaxKind.CatchClause:
+        case SyntaxKind.BinaryExpression: {
+          const text = child.getText();
+          if (child.getKind() === SyntaxKind.BinaryExpression) {
+            if (text.includes("&&") || text.includes("||") || text.includes("??")) {
+              complexity++;
+            }
+          } else {
+            complexity++;
+          }
+          break;
+        }
+      }
+    });
+    return complexity;
+  }
+};
+
+// src/adapters/language/language-adapter-registry.ts
+import { extname as extname2 } from "path";
+var LanguageAdapterRegistry = class {
+  adaptersByExtension = /* @__PURE__ */ new Map();
+  register(adapter) {
+    for (const ext of adapter.extensions) {
+      this.adaptersByExtension.set(ext.toLowerCase(), adapter);
+    }
+  }
+  getAdapter(filePath) {
+    if (!filePath) return void 0;
+    const ext = extname2(filePath).toLowerCase();
+    if (!ext) return void 0;
+    return this.adaptersByExtension.get(ext);
+  }
+};
+
+// src/adapters/storage/json-index-writer.ts
+import { writeFileSync, mkdirSync, unlinkSync, existsSync } from "fs";
+import { dirname as dirname2, join as join2, resolve, sep } from "path";
+var JsonIndexWriter = class {
+  indexDir;
+  constructor(ctxoRoot) {
+    this.indexDir = join2(ctxoRoot, "index");
+  }
+  write(fileIndex) {
+    if (!fileIndex.file) {
+      throw new Error("FileIndex.file must not be empty");
+    }
+    const targetPath = this.resolveIndexPath(fileIndex.file);
+    mkdirSync(dirname2(targetPath), { recursive: true });
+    const sorted = this.sortKeys(fileIndex);
+    const json = JSON.stringify(sorted, null, 2);
+    writeFileSync(targetPath, json, "utf-8");
+  }
+  delete(relativePath) {
+    const targetPath = this.resolveIndexPath(relativePath);
+    if (existsSync(targetPath)) {
+      unlinkSync(targetPath);
+    }
+  }
+  resolveIndexPath(relativePath) {
+    const resolved = resolve(this.indexDir, `${relativePath}.json`);
+    const normalizedDir = resolve(this.indexDir) + sep;
+    if (!resolved.startsWith(normalizedDir)) {
+      throw new Error(`Path traversal detected: ${relativePath}`);
+    }
+    return resolved;
+  }
+  sortKeys(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.sortKeys(item));
+    }
+    if (obj !== null && typeof obj === "object") {
+      const sorted = {};
+      for (const key of Object.keys(obj).sort()) {
+        sorted[key] = this.sortKeys(obj[key]);
+      }
+      return sorted;
+    }
+    return obj;
+  }
+};
+
+// src/adapters/storage/schema-manager.ts
+import { readFileSync, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+var CURRENT_SCHEMA_VERSION = "1.0.0";
+var SchemaManager = class {
+  versionFilePath;
+  constructor(ctxoRoot) {
+    this.versionFilePath = join3(ctxoRoot, "index", "schema-version");
+  }
+  currentVersion() {
+    return CURRENT_SCHEMA_VERSION;
+  }
+  readStoredVersion() {
+    if (!existsSync2(this.versionFilePath)) {
+      return void 0;
+    }
+    return readFileSync(this.versionFilePath, "utf-8").trim();
+  }
+  writeVersion() {
+    mkdirSync2(dirname3(this.versionFilePath), { recursive: true });
+    writeFileSync2(this.versionFilePath, CURRENT_SCHEMA_VERSION, "utf-8");
+  }
+  isCompatible() {
+    const stored = this.readStoredVersion();
+    if (!stored) return false;
+    return stored === CURRENT_SCHEMA_VERSION;
+  }
+};
+
+// src/cli/index-command.ts
+var IndexCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot, ctxoRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = ctxoRoot ?? join4(projectRoot, ".ctxo");
+  }
+  async run(options = {}) {
+    if (options.check) {
+      return this.runCheck();
+    }
+    const registry = new LanguageAdapterRegistry();
+    registry.register(new TsMorphAdapter());
+    const writer = new JsonIndexWriter(this.ctxoRoot);
+    const schemaManager = new SchemaManager(this.ctxoRoot);
+    const hasher = new ContentHasher();
+    const gitAdapter = new SimpleGitAdapter(this.projectRoot);
+    const revertDetector = new RevertDetector();
+    let files;
+    if (options.file) {
+      const fullPath = join4(this.projectRoot, options.file);
+      files = [fullPath];
+      console.error(`[ctxo] Incremental re-index: ${options.file}`);
+    } else {
+      const workspaces = this.discoverWorkspaces();
+      files = [];
+      for (const ws of workspaces) {
+        const wsFiles = this.discoverFilesIn(ws);
+        files.push(...wsFiles);
+      }
+      console.error(`[ctxo] Building codebase index... Found ${files.length} source files`);
+    }
+    const indices = [];
+    let processed = 0;
+    for (const filePath of files) {
+      const adapter = registry.getAdapter(filePath);
+      if (!adapter) continue;
+      const relativePath = relative(this.projectRoot, filePath).replace(/\\/g, "/");
+      try {
+        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);
+        }
+        const fileIndex = {
+          file: relativePath,
+          lastModified,
+          contentHash: hasher.hash(source),
+          symbols,
+          edges,
+          complexity,
+          intent,
+          antiPatterns
+        };
+        writer.write(fileIndex);
+        indices.push(fileIndex);
+        processed++;
+        if (processed % 50 === 0) {
+          console.error(`[ctxo] Processed ${processed}/${files.length} files`);
+        }
+      } catch (err) {
+        console.error(`[ctxo] Skipped ${relativePath}: ${err.message}`);
+      }
+    }
+    schemaManager.writeVersion();
+    const storage = new SqliteStorageAdapter(this.ctxoRoot);
+    try {
+      await storage.initEmpty();
+      storage.bulkWrite(indices);
+    } finally {
+      storage.close();
+    }
+    if (!options.skipSideEffects) {
+      this.ensureGitignore();
+    }
+    console.error(`[ctxo] Index complete: ${processed} files indexed`);
+  }
+  discoverFilesIn(root) {
+    try {
+      const output = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+        cwd: root,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => this.isSupportedExtension(line)).map((line) => join4(root, line));
+    } catch {
+      console.error(`[ctxo] git ls-files failed for ${root}`);
+      return [];
+    }
+  }
+  discoverWorkspaces() {
+    const pkgPath = join4(this.projectRoot, "package.json");
+    if (!existsSync3(pkgPath)) return [this.projectRoot];
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
+      if (!workspaces || workspaces.length === 0) return [this.projectRoot];
+      const resolved = [];
+      for (const ws of workspaces) {
+        if (ws.endsWith("/*") || ws.endsWith("\\*")) {
+          const parentDir = join4(this.projectRoot, ws.slice(0, -2));
+          if (existsSync3(parentDir)) {
+            for (const entry of readdirSync(parentDir, { withFileTypes: true })) {
+              if (entry.isDirectory()) {
+                resolved.push(join4(parentDir, entry.name));
+              }
+            }
+          }
+        } else {
+          const wsPath = join4(this.projectRoot, ws);
+          if (existsSync3(wsPath)) {
+            resolved.push(wsPath);
+          }
+        }
+      }
+      if (resolved.length === 0) return [this.projectRoot];
+      console.error(`[ctxo] Monorepo detected: ${resolved.length} workspace(s)`);
+      return resolved;
+    } catch {
+      return [this.projectRoot];
+    }
+  }
+  isSupportedExtension(filePath) {
+    const ext = extname3(filePath).toLowerCase();
+    return [".ts", ".tsx", ".js", ".jsx"].includes(ext);
+  }
+  async runCheck() {
+    console.error("[ctxo] Checking index freshness...");
+    const hasher = new ContentHasher();
+    const files = this.discoverFilesIn(this.projectRoot);
+    const reader = new (await import("./json-index-reader-PNLPAS42.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;
+      const relativePath = relative(this.projectRoot, filePath).replace(/\\/g, "/");
+      const indexed = indexedMap.get(relativePath);
+      if (!indexed) {
+        console.error(`[ctxo] NOT INDEXED: ${relativePath}`);
+        staleCount++;
+        continue;
+      }
+      if (!existsSync3(filePath)) {
+        console.error(`[ctxo] DELETED: ${relativePath}`);
+        staleCount++;
+        continue;
+      }
+      const mtime = Math.floor(statSync(filePath).mtimeMs / 1e3);
+      if (mtime <= indexed.lastModified) continue;
+      if (indexed.contentHash) {
+        const source = readFileSync2(filePath, "utf-8");
+        const currentHash = hasher.hash(source);
+        if (currentHash === indexed.contentHash) continue;
+      }
+      console.error(`[ctxo] STALE: ${relativePath}`);
+      staleCount++;
+    }
+    if (staleCount > 0) {
+      console.error(`[ctxo] ${staleCount} file(s) need re-indexing. Run "ctxo index"`);
+      process.exit(1);
+    }
+    console.error("[ctxo] Index is up to date");
+  }
+  ensureGitignore() {
+    const gitignorePath = join4(this.projectRoot, ".gitignore");
+    const cachePattern = ".ctxo/.cache/";
+    const suffix = `
+# Ctxo local cache (never committed)
+${cachePattern}
+`;
+    const existing = existsSync3(gitignorePath) ? readFileSync2(gitignorePath, "utf-8") : "";
+    if (existing.includes(cachePattern)) return;
+    writeFileSync3(gitignorePath, existing + suffix, "utf-8");
+    console.error("[ctxo] Added .ctxo/.cache/ to .gitignore");
+  }
+};
+
+// src/cli/sync-command.ts
+import { join as join5 } from "path";
+var SyncCommand = class {
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.ctxoRoot = join5(projectRoot, ".ctxo");
+  }
+  async run() {
+    console.error("[ctxo] Rebuilding SQLite cache from committed JSON index...");
+    const storage = new SqliteStorageAdapter(this.ctxoRoot);
+    try {
+      await storage.init();
+    } finally {
+      storage.close();
+    }
+    console.error("[ctxo] Sync complete");
+  }
+};
+
+// src/cli/status-command.ts
+import { join as join6 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
+var StatusCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join6(projectRoot, ".ctxo");
+  }
+  run() {
+    const indexDir = join6(this.ctxoRoot, "index");
+    if (!existsSync4(indexDir)) {
+      console.error('[ctxo] No index found. Run "ctxo index" first.');
+      return;
+    }
+    const schemaManager = new SchemaManager(this.ctxoRoot);
+    const version = schemaManager.readStoredVersion() ?? "unknown";
+    const reader = new JsonIndexReader(this.ctxoRoot);
+    const indices = reader.readAll();
+    const totalSymbols = indices.reduce((sum, idx) => sum + idx.symbols.length, 0);
+    const totalEdges = indices.reduce((sum, idx) => sum + idx.edges.length, 0);
+    console.error(`[ctxo] Index Status`);
+    console.error(`  Schema version: ${version}`);
+    console.error(`  Indexed files:  ${indices.length}`);
+    console.error(`  Total symbols:  ${totalSymbols}`);
+    console.error(`  Total edges:    ${totalEdges}`);
+    const cacheExists = existsSync4(join6(this.ctxoRoot, ".cache", "symbols.db"));
+    console.error(`  SQLite cache:   ${cacheExists ? "present" : "missing (run ctxo sync)"}`);
+    if (indices.length > 0) {
+      console.error("");
+      console.error("  Files:");
+      const sourceFiles = this.getSourceFiles();
+      for (const idx of indices.sort((a, b) => a.file.localeCompare(b.file))) {
+        const ts = new Date(idx.lastModified * 1e3).toISOString();
+        const isOrphaned = sourceFiles.size > 0 && !sourceFiles.has(idx.file);
+        const badge = isOrphaned ? " [orphaned]" : "";
+        console.error(`    ${idx.file}  ${ts}  (${idx.symbols.length} symbols, ${idx.edges.length} edges)${badge}`);
+      }
+    }
+  }
+  getSourceFiles() {
+    try {
+      const output = execFileSync2("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+        cwd: this.projectRoot,
+        encoding: "utf-8"
+      });
+      return new Set(output.split("\n").map((l) => l.trim()).filter((l) => l.length > 0));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+};
+
+// src/cli/verify-command.ts
+import { mkdtempSync, rmSync } from "fs";
+import { join as join7 } from "path";
+import { tmpdir } from "os";
+var VerifyCommand = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async run() {
+    console.error("[ctxo] Verifying index freshness...");
+    const tempDir = mkdtempSync(join7(tmpdir(), "ctxo-verify-"));
+    try {
+      const tempCtxo = join7(tempDir, ".ctxo");
+      const indexCmd = new IndexCommand(this.projectRoot, tempCtxo);
+      await indexCmd.run({ skipSideEffects: true });
+      const committedReader = new JsonIndexReader(join7(this.projectRoot, ".ctxo"));
+      const freshReader = new JsonIndexReader(tempCtxo);
+      const committedIndices = committedReader.readAll();
+      const freshIndices = freshReader.readAll();
+      const serialize = (i) => JSON.stringify({ symbols: i.symbols, edges: i.edges, intent: i.intent, antiPatterns: i.antiPatterns });
+      const committedMap = new Map(committedIndices.map((i) => [i.file, serialize(i)]));
+      const freshMap = new Map(freshIndices.map((i) => [i.file, serialize(i)]));
+      let stale = false;
+      for (const [file, freshData] of freshMap) {
+        const committed = committedMap.get(file);
+        if (committed !== freshData) {
+          console.error(`[ctxo] STALE: ${file}`);
+          stale = true;
+        }
+      }
+      for (const file of committedMap.keys()) {
+        if (!freshMap.has(file)) {
+          console.error(`[ctxo] REMOVED: ${file}`);
+          stale = true;
+        }
+      }
+      if (stale) {
+        console.error('[ctxo] Index is STALE \u2014 run "ctxo index" and commit .ctxo/index/');
+        process.exit(1);
+      }
+      console.error("[ctxo] Index is up to date");
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+};
+
+// src/cli/init-command.ts
+import { join as join8 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, chmodSync } from "fs";
+var CTXO_START = "# ctxo-start";
+var CTXO_END = "# ctxo-end";
+var POST_COMMIT_CONTENT = `
+${CTXO_START}
+# Incremental re-index on commit (only changed files)
+if command -v ctxo >/dev/null 2>&1; then
+  for file in $(git diff --name-only HEAD~1 HEAD 2>/dev/null); do
+    ctxo index --file "$file" 2>/dev/null || true
+  done
+fi
+${CTXO_END}
+`.trim();
+var POST_MERGE_CONTENT = `
+${CTXO_START}
+# Rebuild SQLite cache after merge (index updated via git pull)
+if command -v ctxo >/dev/null 2>&1; then
+  ctxo sync 2>/dev/null || true
+fi
+${CTXO_END}
+`.trim();
+var InitCommand = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  run() {
+    const hooksDir = join8(this.projectRoot, ".git", "hooks");
+    if (!existsSync5(join8(this.projectRoot, ".git"))) {
+      console.error('[ctxo] Not a git repository. Run "git init" first.');
+      process.exit(1);
+    }
+    mkdirSync3(hooksDir, { recursive: true });
+    this.installHook(hooksDir, "post-commit", POST_COMMIT_CONTENT);
+    this.installHook(hooksDir, "post-merge", POST_MERGE_CONTENT);
+    console.error("[ctxo] Git hooks installed (post-commit, post-merge)");
+  }
+  installHook(hooksDir, hookName, hookContent) {
+    const hookPath = join8(hooksDir, hookName);
+    let existing = "";
+    if (existsSync5(hookPath)) {
+      existing = readFileSync3(hookPath, "utf-8");
+      if (existing.includes(CTXO_START)) {
+        console.error(`[ctxo] ${hookName} hook already has ctxo block \u2014 skipping`);
+        return;
+      }
+    } else {
+      existing = "#!/bin/sh\n";
+    }
+    const updated = existing.endsWith("\n") ? existing + "\n" + hookContent + "\n" : existing + "\n\n" + hookContent + "\n";
+    writeFileSync4(hookPath, updated, "utf-8");
+    chmodSync(hookPath, 493);
+  }
+};
+
+// src/cli/watch-command.ts
+import { join as join9, extname as extname4, relative as relative2 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+
+// src/adapters/watcher/chokidar-watcher-adapter.ts
+import { watch } from "chokidar";
+var DEFAULT_IGNORED = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.ctxo/**",
+  "**/dist/**",
+  "**/coverage/**"
+];
+var ChokidarWatcherAdapter = class {
+  projectRoot;
+  ignored;
+  watcher;
+  constructor(projectRoot, ignored) {
+    this.projectRoot = projectRoot;
+    this.ignored = ignored ?? DEFAULT_IGNORED;
+  }
+  start(handler) {
+    if (this.watcher) {
+      throw new Error("Watcher already started. Call stop() before starting again.");
+    }
+    this.watcher = watch(this.projectRoot, {
+      ignored: this.ignored,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (path) => handler("add", path));
+    this.watcher.on("change", (path) => handler("change", path));
+    this.watcher.on("unlink", (path) => handler("unlink", path));
+  }
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = void 0;
+    }
+  }
+};
+
+// src/cli/watch-command.ts
+var SUPPORTED_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var DEBOUNCE_MS = 300;
+var WatchCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join9(projectRoot, ".ctxo");
+  }
+  async run() {
+    console.error("[ctxo] Starting file watcher...");
+    const registry = new LanguageAdapterRegistry();
+    registry.register(new TsMorphAdapter());
+    const writer = new JsonIndexWriter(this.ctxoRoot);
+    const storage = new SqliteStorageAdapter(this.ctxoRoot);
+    await storage.init();
+    const hasher = new ContentHasher();
+    const gitAdapter = new SimpleGitAdapter(this.projectRoot);
+    const revertDetector = new RevertDetector();
+    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, "/");
+      try {
+        const source = readFileSync4(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);
+        const commits = await gitAdapter.getCommitHistory(relativePath);
+        const intent = commits.map((c) => ({
+          hash: c.hash,
+          message: c.message,
+          date: c.date,
+          kind: "commit"
+        }));
+        const antiPatterns = revertDetector.detect(commits);
+        const fileIndex = {
+          file: relativePath,
+          lastModified,
+          contentHash: hasher.hash(source),
+          symbols,
+          edges,
+          complexity,
+          intent,
+          antiPatterns
+        };
+        writer.write(fileIndex);
+        storage.writeSymbolFile(fileIndex);
+        console.error(`[ctxo] Re-indexed: ${relativePath}`);
+      } catch (err) {
+        console.error(`[ctxo] Failed to re-index ${relativePath}: ${err.message}`);
+      }
+    };
+    const debouncedReindex = (filePath) => {
+      const existing = pendingFiles.get(filePath);
+      if (existing) clearTimeout(existing);
+      pendingFiles.set(
+        filePath,
+        setTimeout(() => {
+          pendingFiles.delete(filePath);
+          reindexFile(filePath);
+        }, DEBOUNCE_MS)
+      );
+    };
+    watcher.start((event, filePath) => {
+      if (event === "unlink") {
+        const ext = extname4(filePath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS2.has(ext)) return;
+        const relativePath = relative2(this.projectRoot, filePath).replace(/\\/g, "/");
+        writer.delete(relativePath);
+        storage.deleteSymbolFile(relativePath);
+        console.error(`[ctxo] Removed from index: ${relativePath}`);
+      } else {
+        debouncedReindex(filePath);
+      }
+    });
+    console.error("[ctxo] Watching for file changes... (Ctrl+C to stop)");
+    const cleanup = () => {
+      console.error("\n[ctxo] Stopping watcher...");
+      for (const timeout of pendingFiles.values()) {
+        clearTimeout(timeout);
+      }
+      watcher.stop().then(() => {
+        storage.close();
+        console.error("[ctxo] Watcher stopped");
+        process.exit(0);
+      });
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+};
+
+// src/cli/cli-router.ts
+var CliRouter = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  async route(args) {
+    const command = args[0];
+    if (!command || command === "--help" || command === "-h") {
+      this.printHelp();
+      return;
+    }
+    switch (command) {
+      case "index": {
+        const fileIdx = args.indexOf("--file");
+        const fileArg = fileIdx !== -1 ? args[fileIdx + 1] : void 0;
+        if (fileIdx !== -1 && (!fileArg || fileArg.startsWith("--"))) {
+          console.error("[ctxo] --file requires a path argument");
+          process.exit(1);
+        }
+        const checkArg = args.includes("--check");
+        const skipHistory = args.includes("--skip-history");
+        await new IndexCommand(this.projectRoot).run({ file: fileArg, check: checkArg, skipHistory });
+        break;
+      }
+      case "sync":
+        await new SyncCommand(this.projectRoot).run();
+        break;
+      case "watch":
+        await new WatchCommand(this.projectRoot).run();
+        break;
+      case "verify-index":
+        await new VerifyCommand(this.projectRoot).run();
+        break;
+      case "status":
+        new StatusCommand(this.projectRoot).run();
+        break;
+      case "init":
+        new InitCommand(this.projectRoot).run();
+        break;
+      default:
+        console.error(`[ctxo] Unknown command: "${command}". Run "ctxo --help" for usage.`);
+        process.exit(1);
+    }
+  }
+  printHelp() {
+    console.error(`
+ctxo \u2014 MCP server for dependency-aware codebase context
+
+Usage:
+  ctxo                      Start MCP server (stdio transport)
+  ctxo index                Build full codebase index
+  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
+  ctxo status               Show index manifest
+  ctxo init                 Install git hooks
+  ctxo --help               Show this help message
+`.trim());
+  }
+};
+export {
+  CliRouter
+};
+//# sourceMappingURL=cli-router-PIWHLS5F.js.map