@ctxo/cli 0.0.1 → 0.7.0-alpha.0

package/dist/cli-router-RA4EBMVV.js

@@ -0,0 +1,3330 @@
+#!/usr/bin/env node
+import {
+  ArchitecturalOverlay,
+  DeadCodeDetector,
+  PageRankCalculator,
+  RevertDetector,
+  SessionRecorderAdapter,
+  SimpleGitAdapter,
+  SqliteStorageAdapter,
+  SymbolGraph,
+  aggregateCoChanges,
+  createLogger,
+  detectWorkspace
+} from "./chunk-O3L56NY6.js";
+import {
+  JsonIndexReader
+} from "./chunk-I4TUA7CD.js";
+import {
+  StalenessDetector
+} from "./chunk-PSKDDLSF.js";
+import {
+  __require
+} from "./chunk-7OCVIDC7.js";
+
+// src/cli/cli-router.ts
+import { readFileSync as readFileSync13, existsSync as existsSync21 } from "fs";
+import { dirname as dirname8, join as join23 } from "path";
+
+// src/cli/index-command.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync8, statSync, readdirSync as readdirSync2 } from "fs";
+import { join as join7, relative, extname as extname3 } from "path";
+import { createRequire } from "module";
+
+// 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/language-adapter-registry.ts
+import { extname } from "path";
+var LanguageAdapterRegistry = class {
+  adaptersByExtension = /* @__PURE__ */ new Map();
+  register(extensions, adapter) {
+    for (const ext of extensions) {
+      this.adaptersByExtension.set(ext.toLowerCase(), adapter);
+    }
+  }
+  getSupportedExtensions() {
+    return new Set(this.adaptersByExtension.keys());
+  }
+  getAdapter(filePath) {
+    if (!filePath) return void 0;
+    const ext = extname(filePath).toLowerCase();
+    if (!ext) return void 0;
+    return this.adaptersByExtension.get(ext);
+  }
+};
+
+// src/cli/plugin-loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join } from "path";
+
+// src/adapters/language/plugin-discovery.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+import { pathToFileURL } from "url";
+import { SUPPORTED_API_VERSION } from "@ctxo/plugin-api";
+var log = createLogger("ctxo:plugin-discovery");
+var OFFICIAL_PREFIX = "@ctxo/lang-";
+var COMMUNITY_PREFIX = "ctxo-lang-";
+function readManifestDeps(manifestPath) {
+  try {
+    const raw = readFileSync(manifestPath, "utf-8");
+    const manifest = JSON.parse(raw);
+    const all = {
+      ...manifest.dependencies,
+      ...manifest.devDependencies,
+      ...manifest.peerDependencies
+    };
+    return Object.keys(all).filter(
+      (name) => name.startsWith(OFFICIAL_PREFIX) || name.startsWith(COMMUNITY_PREFIX)
+    );
+  } catch (err) {
+    log.warn(`Failed to read manifest ${manifestPath}: ${err.message}`);
+    return [];
+  }
+}
+function isLocalSpecifier(spec) {
+  return spec.startsWith(".") || spec.startsWith("/") || isAbsolute(spec);
+}
+async function tryLoad(specifier, baseDir) {
+  try {
+    const target = isLocalSpecifier(specifier) ? pathToFileURL(resolve(baseDir, specifier)).href : specifier;
+    const mod = await import(target);
+    const candidate = mod.default ?? mod.plugin ?? mod;
+    if (!candidate || typeof candidate !== "object") {
+      return { specifier, reason: "module export is not an object" };
+    }
+    if (candidate.apiVersion !== SUPPORTED_API_VERSION) {
+      return {
+        specifier,
+        reason: `unsupported apiVersion ${String(candidate.apiVersion)} (want '${SUPPORTED_API_VERSION}')`
+      };
+    }
+    if (typeof candidate.createAdapter !== "function") {
+      return { specifier, reason: "missing createAdapter()" };
+    }
+    if (typeof candidate.id !== "string" || candidate.id.length === 0) {
+      return { specifier, reason: "missing or empty id" };
+    }
+    if (!Array.isArray(candidate.extensions)) {
+      return { specifier, reason: "extensions must be an array" };
+    }
+    if (candidate.tier !== "syntax" && candidate.tier !== "full") {
+      return { specifier, reason: `invalid tier ${String(candidate.tier)}` };
+    }
+    return candidate;
+  } catch (err) {
+    return { specifier, reason: err.message };
+  }
+}
+async function discoverPlugins(options) {
+  const { manifestPath } = options;
+  if (!existsSync(manifestPath)) {
+    log.info(`Manifest not found at ${manifestPath} \u2014 no plugins discovered`);
+    return { plugins: [], failures: [] };
+  }
+  const baseDir = dirname(manifestPath);
+  const specifiers = options.explicit ?? readManifestDeps(manifestPath);
+  const plugins = [];
+  const failures = [];
+  for (const spec of specifiers) {
+    const result = await tryLoad(spec, baseDir);
+    if ("apiVersion" in result) {
+      plugins.push({ plugin: result, specifier: spec });
+    } else {
+      failures.push(result);
+      log.warn(`Skipped plugin ${spec}: ${result.reason}`);
+    }
+  }
+  return { plugins, failures };
+}
+
+// src/cli/plugin-loader.ts
+var log2 = createLogger("ctxo:plugin-loader");
+function manifestHasPlugins(path) {
+  try {
+    const raw = JSON.parse(readFileSync2(path, "utf-8"));
+    const all = { ...raw.dependencies, ...raw.devDependencies, ...raw.peerDependencies };
+    return Object.keys(all).some((n) => n.startsWith("@ctxo/lang-") || n.startsWith("ctxo-lang-"));
+  } catch {
+    return false;
+  }
+}
+function loadManifestPath(projectRoot) {
+  return resolveManifestPath(projectRoot);
+}
+function resolveManifestPath(projectRoot) {
+  const projectManifest = join(projectRoot, "package.json");
+  if (existsSync2(projectManifest) && manifestHasPlugins(projectManifest)) {
+    return projectManifest;
+  }
+  let dir = import.meta.dirname;
+  for (let i = 0; i < 12; i++) {
+    const candidate = join(dir, "package.json");
+    if (existsSync2(candidate) && manifestHasPlugins(candidate)) return candidate;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return existsSync2(projectManifest) ? projectManifest : null;
+}
+function buildContext(projectRoot, workspace, pluginId) {
+  const pluginLog = createLogger(`ctxo:plugin:${pluginId}`);
+  return {
+    logger: {
+      debug: (msg, ...args) => pluginLog.info(String(msg), ...args),
+      info: (msg, ...args) => pluginLog.info(String(msg), ...args),
+      warn: (msg, ...args) => pluginLog.warn(String(msg), ...args),
+      error: (msg, ...args) => pluginLog.error(String(msg), ...args)
+    },
+    projectRoot,
+    workspace,
+    config: {}
+  };
+}
+async function loadPlugins(projectRoot) {
+  const manifestPath = resolveManifestPath(projectRoot);
+  if (!manifestPath) {
+    log2.info("No package.json found for plugin discovery");
+    return [];
+  }
+  const workspace = detectWorkspace(projectRoot);
+  const result = await discoverPlugins({ manifestPath });
+  const loaded = [];
+  for (const { plugin, specifier } of result.plugins) {
+    try {
+      const ctx = buildContext(projectRoot, workspace, plugin.id);
+      const adapter = plugin.createAdapter(ctx);
+      loaded.push({ plugin, adapter, specifier });
+    } catch (err) {
+      log2.warn(`Plugin ${plugin.id} createAdapter failed: ${err.message}`);
+    }
+  }
+  return loaded;
+}
+
+// src/cli/install-command.ts
+import { existsSync as existsSync5 } from "fs";
+import { spawn } from "child_process";
+import { join as join4 } from "path";
+
+// src/core/detection/detect-languages.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, readdirSync } from "fs";
+import { extname as extname2, join as join2 } from "path";
+var KNOWN_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "go",
+  "csharp",
+  "python",
+  "java",
+  "rust",
+  "ruby",
+  "kotlin"
+];
+var EXTENSION_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".go": "go",
+  ".cs": "csharp",
+  ".py": "python",
+  ".pyi": "python",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".rs": "rust",
+  ".rb": "ruby"
+};
+var MANIFEST_PROBES = [
+  {
+    id: "typescript",
+    check: (root) => existsSync3(join2(root, "tsconfig.json")) ? "tsconfig.json" : null
+  },
+  {
+    id: "python",
+    check: (root) => {
+      if (existsSync3(join2(root, "pyproject.toml"))) return "pyproject.toml";
+      if (existsSync3(join2(root, "setup.py"))) return "setup.py";
+      if (existsSync3(join2(root, "requirements.txt"))) return "requirements.txt";
+      return null;
+    }
+  },
+  {
+    id: "java",
+    check: (root) => {
+      if (existsSync3(join2(root, "pom.xml"))) return "pom.xml";
+      if (existsSync3(join2(root, "build.gradle"))) return "build.gradle";
+      if (existsSync3(join2(root, "build.gradle.kts"))) return "build.gradle.kts";
+      return null;
+    }
+  },
+  {
+    id: "go",
+    check: (root) => existsSync3(join2(root, "go.mod")) ? "go.mod" : null
+  },
+  {
+    id: "csharp",
+    check: (root) => {
+      try {
+        for (const entry of readdirSync(root, { withFileTypes: true })) {
+          if (entry.isFile() && (entry.name.endsWith(".csproj") || entry.name.endsWith(".sln"))) {
+            return entry.name;
+          }
+        }
+      } catch {
+      }
+      return null;
+    }
+  },
+  {
+    id: "rust",
+    check: (root) => existsSync3(join2(root, "Cargo.toml")) ? "Cargo.toml" : null
+  },
+  {
+    id: "ruby",
+    check: (root) => existsSync3(join2(root, "Gemfile")) ? "Gemfile" : null
+  }
+];
+function listGitFiles(root) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard"],
+      { cwd: root, encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 }
+    );
+    return out.split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function detectLanguages(root) {
+  const byManifest = {};
+  for (const probe of MANIFEST_PROBES) {
+    const manifest = probe.check(root);
+    if (manifest) byManifest[probe.id] = manifest;
+  }
+  const byExtension = {};
+  const unknownExtensions = {};
+  let totalFiles = 0;
+  for (const file of listGitFiles(root)) {
+    const ext = extname2(file).toLowerCase();
+    if (!ext) continue;
+    totalFiles += 1;
+    const lang = EXTENSION_LANGUAGE[ext];
+    if (lang) {
+      byExtension[lang] = (byExtension[lang] ?? 0) + 1;
+    } else {
+      unknownExtensions[ext] = (unknownExtensions[ext] ?? 0) + 1;
+    }
+  }
+  return { byManifest, byExtension, totalFiles, unknownExtensions };
+}
+function decideNeededLanguages(result, options = {}) {
+  const minFiles = options.minFiles ?? 5;
+  const minRatio = options.minRatio ?? 0.02;
+  const needed = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(result.byManifest)) {
+    needed.add(id);
+  }
+  for (const [id, count] of Object.entries(result.byExtension)) {
+    if (result.byManifest[id]) continue;
+    const ratio = result.totalFiles > 0 ? count / result.totalFiles : 0;
+    if (count >= minFiles && ratio >= minRatio) {
+      needed.add(id);
+    }
+  }
+  return [...needed];
+}
+function officialPluginFor(language) {
+  return `@ctxo/lang-${language}`;
+}
+
+// src/core/install/package-manager.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+function resolvePackageManager(options) {
+  const env = options.env ?? process.env;
+  if (options.flag) {
+    if (!isPackageManager(options.flag)) {
+      throw new Error(
+        `Unknown --pm value "${options.flag}". Supported: ${PACKAGE_MANAGERS.join(", ")}`
+      );
+    }
+    return { manager: options.flag, source: "flag" };
+  }
+  const envValue = env["CTXO_PM"];
+  if (envValue) {
+    if (!isPackageManager(envValue)) {
+      throw new Error(
+        `CTXO_PM="${envValue}" is not a supported package manager. Expected one of: ${PACKAGE_MANAGERS.join(", ")}`
+      );
+    }
+    return { manager: envValue, source: "env" };
+  }
+  const configured = readConfigPackageManager(options.projectRoot);
+  if (configured) return { manager: configured, source: "config" };
+  const corepack = readPackageManagerField(options.projectRoot);
+  if (corepack) return { manager: corepack.manager, source: "config", detail: corepack.detail };
+  const lockHit = detectFromLockfileWalkUp(options.projectRoot);
+  if (lockHit) return { manager: lockHit.manager, source: "lockfile", detail: lockHit.detail };
+  return { manager: "npm", source: "default" };
+}
+function readPackageManagerField(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 12; i++) {
+    const pkg = join3(dir, "package.json");
+    if (existsSync4(pkg)) {
+      try {
+        const parsed = JSON.parse(readFileSync3(pkg, "utf-8"));
+        const value = parsed.packageManager;
+        if (typeof value === "string") {
+          const [nameRaw] = value.split("@");
+          const name = (nameRaw ?? "").trim();
+          if (isPackageManager(name)) {
+            return { manager: name, detail: `packageManager: ${value}` };
+          }
+        }
+      } catch {
+      }
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function readConfigPackageManager(projectRoot) {
+  const path = join3(projectRoot, ".ctxo", "config.yaml");
+  if (!existsSync4(path)) return null;
+  try {
+    const raw = readFileSync3(path, "utf-8");
+    const match = raw.match(/^packageManager:\s*(\S+)\s*$/m);
+    if (!match) return null;
+    const value = match[1];
+    return isPackageManager(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function detectFromLockfileWalkUp(startDir) {
+  const probes = [
+    { file: "bun.lockb", manager: "bun" },
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "pnpm-workspace.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  let dir = startDir;
+  for (let i = 0; i < 12; i++) {
+    for (const probe of probes) {
+      const path = join3(dir, probe.file);
+      if (existsSync4(path)) {
+        return { manager: probe.manager, detail: probe.file };
+      }
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function buildInstallCommand(manager, packages, options = {}) {
+  if (packages.length === 0) {
+    throw new Error("buildInstallCommand requires at least one package");
+  }
+  switch (manager) {
+    case "npm":
+      return {
+        command: "npm",
+        args: options.global ? ["install", "-g", ...packages] : ["install", "-D", ...packages]
+      };
+    case "pnpm":
+      return {
+        command: "pnpm",
+        args: options.global ? ["add", "-g", ...packages] : ["add", "-D", ...packages]
+      };
+    case "yarn":
+      return {
+        command: "yarn",
+        args: options.global ? ["global", "add", ...packages] : ["add", "--dev", ...packages]
+      };
+    case "bun":
+      return {
+        command: "bun",
+        args: options.global ? ["add", "-g", ...packages] : ["add", "-d", ...packages]
+      };
+  }
+}
+
+// src/cli/install-command.ts
+var InstallCommand = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  projectRoot;
+  async run(options = {}) {
+    const resolvedLangs = this.resolveLanguages(options);
+    if (resolvedLangs.length === 0) {
+      console.error('[ctxo] Nothing to install. Specify a language (e.g. "ctxo install python") or add one to your project.');
+      process.exitCode = 0;
+      return;
+    }
+    let resolution;
+    try {
+      resolution = resolvePackageManager({
+        flag: options.pm,
+        projectRoot: this.projectRoot
+      });
+    } catch (err) {
+      console.error(`[ctxo] ${err.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.global && !existsSync5(join4(this.projectRoot, "package.json"))) {
+      console.error("[ctxo] No package.json in the current project. Re-run with --global or create a package.json first.");
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.force && !options.global && isLockedCI(process.env)) {
+      console.error("[ctxo] CI environment detected with a frozen lockfile. Refusing to mutate dependencies. Use --force or switch to --global.");
+      process.exitCode = 1;
+      return;
+    }
+    const specifiers = resolvedLangs.map(
+      (lang) => options.version ? `${officialPluginFor(lang)}@${options.version}` : officialPluginFor(lang)
+    );
+    const invocation = buildInstallCommand(resolution.manager, specifiers, {
+      global: options.global
+    });
+    const plan = {
+      languages: resolvedLangs,
+      packages: specifiers,
+      manager: resolution.manager,
+      managerSource: resolution.source,
+      global: options.global ?? false,
+      command: invocation.command,
+      args: [...invocation.args]
+    };
+    console.error(`[ctxo] Plan: install ${plan.packages.join(", ")}`);
+    console.error(`[ctxo] Using ${plan.manager} (${plan.managerSource}${resolution.detail ? `: ${resolution.detail}` : ""})${plan.global ? ", global" : ""}`);
+    console.error(`[ctxo] Command: ${plan.command} ${plan.args.join(" ")}`);
+    if (options.dryRun) {
+      console.error("[ctxo] --dry-run set; not executing.");
+      return;
+    }
+    const code = await spawnInstall(plan.command, plan.args, this.projectRoot);
+    if (code !== 0) {
+      console.error(`[ctxo] ${plan.command} exited with code ${code}`);
+      process.exitCode = code;
+      return;
+    }
+    console.error(`[ctxo] Installed ${plan.packages.join(", ")}`);
+  }
+  resolveLanguages(options) {
+    const requested = options.languages ?? [];
+    if (requested.length > 0) {
+      const out = [];
+      for (const raw of requested) {
+        const lang = normalizeLanguage(raw);
+        if (!lang) {
+          console.error(
+            `[ctxo] Unknown language "${raw}". Known: ${KNOWN_LANGUAGES.join(", ")}. Community plugins: see the ctxo-lang-template scaffolding guide.`
+          );
+          process.exitCode = 1;
+          return [];
+        }
+        if (!out.includes(lang)) out.push(lang);
+      }
+      return out;
+    }
+    const detection = detectLanguages(this.projectRoot);
+    const needed = decideNeededLanguages(detection);
+    if (needed.length === 0) return [];
+    const missing = needed.filter((lang) => !isPluginInstalled(lang));
+    if (missing.length === 0) {
+      console.error("[ctxo] All detected languages already have plugins installed.");
+      return [];
+    }
+    console.error(`[ctxo] Detected missing plugins for: ${missing.join(", ")}`);
+    return missing;
+  }
+};
+function normalizeLanguage(input) {
+  const lowered = input.toLowerCase();
+  if (KNOWN_LANGUAGES.includes(lowered)) {
+    return lowered;
+  }
+  const aliases = {
+    ts: "typescript",
+    js: "javascript",
+    py: "python",
+    "c#": "csharp",
+    "cs": "csharp",
+    "net": "csharp",
+    golang: "go",
+    kt: "kotlin",
+    rb: "ruby",
+    rs: "rust"
+  };
+  return aliases[lowered] ?? null;
+}
+function isPluginInstalled(lang) {
+  try {
+    const { createRequire: createRequire5 } = __require("module");
+    const r = createRequire5(import.meta.url);
+    r.resolve(`${officialPluginFor(lang)}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isLockedCI(env) {
+  if (env["CI"] !== "true" && env["CI"] !== "1") return false;
+  return true;
+}
+function spawnInstall(command, args, cwd) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, [...args], { cwd, stdio: "inherit", shell: process.platform === "win32" });
+    child.on("exit", (code) => resolve3(code ?? 0));
+    child.on("error", (err) => reject(err));
+  });
+}
+
+// src/adapters/storage/json-index-writer.ts
+import { writeFileSync, renameSync, mkdirSync, unlinkSync, existsSync as existsSync6 } from "fs";
+import { dirname as dirname4, join as join5, resolve as resolve2, sep } from "path";
+var JsonIndexWriter = class {
+  indexDir;
+  constructor(ctxoRoot) {
+    this.indexDir = join5(ctxoRoot, "index");
+  }
+  write(fileIndex) {
+    if (!fileIndex.file) {
+      throw new Error("FileIndex.file must not be empty");
+    }
+    const targetPath = this.resolveIndexPath(fileIndex.file);
+    mkdirSync(dirname4(targetPath), { recursive: true });
+    const sorted = this.sortKeys(fileIndex);
+    const json = JSON.stringify(sorted, null, 2);
+    this.atomicWrite(targetPath, json);
+  }
+  writeCoChanges(matrix) {
+    mkdirSync(this.indexDir, { recursive: true });
+    const targetPath = join5(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);
+    if (existsSync6(targetPath)) {
+      unlinkSync(targetPath);
+    }
+  }
+  resolveIndexPath(relativePath) {
+    const resolved = resolve2(this.indexDir, `${relativePath}.json`);
+    const normalizedDir = resolve2(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 as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { join as join6, dirname as dirname5 } from "path";
+var CURRENT_SCHEMA_VERSION = "1.0.0";
+var SchemaManager = class {
+  versionFilePath;
+  constructor(ctxoRoot) {
+    this.versionFilePath = join6(ctxoRoot, "index", "schema-version");
+  }
+  currentVersion() {
+    return CURRENT_SCHEMA_VERSION;
+  }
+  readStoredVersion() {
+    if (!existsSync7(this.versionFilePath)) {
+      return void 0;
+    }
+    return readFileSync4(this.versionFilePath, "utf-8").trim();
+  }
+  writeVersion() {
+    mkdirSync2(dirname5(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 requireCjs = createRequire(import.meta.url);
+var IndexCommand = class {
+  projectRoot;
+  ctxoRoot;
+  supportedExtensions;
+  constructor(projectRoot, ctxoRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = ctxoRoot ?? join7(projectRoot, ".ctxo");
+    this.supportedExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".go", ".cs"]);
+  }
+  async run(options = {}) {
+    if (options.check) {
+      return this.runCheck();
+    }
+    if (options.installMissing) {
+      await this.autoInstallMissingPlugins();
+    }
+    const registry = new LanguageAdapterRegistry();
+    const { tsMorphLike, roslynAdapter, csharpTier } = await this.registerDiscoveredPlugins(registry);
+    this.supportedExtensions = registry.getSupportedExtensions();
+    this.printLanguagePreview();
+    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 = join7(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`);
+    }
+    if (roslynAdapter?.isReady()) {
+      const hasCsFiles = files.some((f) => f.endsWith(".cs"));
+      if (hasCsFiles) {
+        await roslynAdapter.batchIndex();
+      }
+    }
+    const symbolRegistry = /* @__PURE__ */ new Map();
+    const pendingIndices = [];
+    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 = readFileSync5(filePath, "utf-8");
+        const lastModified = Math.floor(Date.now() / 1e3);
+        const symbols = await adapter.extractSymbols(relativePath, source);
+        const complexity = await adapter.extractComplexity(relativePath, source);
+        for (const sym of symbols) {
+          symbolRegistry.set(sym.symbolId, sym.kind);
+        }
+        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 (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);
+    }
+    tsMorphLike?.loadProjectSources(allSources);
+    for (const entry of pendingIndices) {
+      const adapter = registry.getAdapter(entry.relativePath);
+      if (!adapter) continue;
+      try {
+        adapter.setSymbolRegistry?.(symbolRegistry);
+        entry.fileIndex.edges = await adapter.extractEdges(entry.relativePath, entry.source);
+      } catch (err) {
+        console.error(`[ctxo] Edge extraction failed for ${entry.relativePath}: ${err.message}`);
+      }
+    }
+    tsMorphLike?.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 {
+      await storage.initEmpty();
+      storage.bulkWrite(indices);
+    } finally {
+      storage.close();
+    }
+    if (!options.skipSideEffects) {
+      this.ensureGitignore();
+    }
+    const csCount = pendingIndices.filter((e) => e.relativePath.endsWith(".cs")).length;
+    const tsCount = pendingIndices.filter((e) => /\.(ts|tsx|js|jsx)$/.test(e.relativePath)).length;
+    const goCount = pendingIndices.filter((e) => e.relativePath.endsWith(".go")).length;
+    console.error(`[ctxo] Index complete: ${processed} files indexed`);
+    if (tsCount > 0) console.error(`[ctxo]   TypeScript/JS: ${tsCount} files (full tier)`);
+    if (csCount > 0) console.error(`[ctxo]   C#: ${csCount} files (${csharpTier} tier${csharpTier === "syntax" ? " - .NET SDK 8+ for full analysis" : ""})`);
+    if (goCount > 0) console.error(`[ctxo]   Go: ${goCount} files (syntax tier)`);
+    if (roslynAdapter) await roslynAdapter.dispose();
+  }
+  async autoInstallMissingPlugins() {
+    const detection = detectLanguages(this.projectRoot);
+    const needed = decideNeededLanguages(detection);
+    const missing = [];
+    for (const lang of needed) {
+      try {
+        requireCjs.resolve(`${officialPluginFor(lang)}/package.json`);
+      } catch {
+        missing.push(lang);
+      }
+    }
+    if (missing.length === 0) return;
+    console.error(`[ctxo] --install-missing: installing ${missing.join(", ")}`);
+    await new InstallCommand(this.projectRoot).run({ languages: missing, yes: true });
+  }
+  printLanguagePreview() {
+    const detection = detectLanguages(this.projectRoot);
+    const lines = [];
+    for (const [lang, count] of Object.entries(detection.byExtension)) {
+      const hasPlugin = this.supportedExtensions.size > 0 && Object.entries(EXTENSION_LANGUAGE).some(([ext, id]) => id === lang && this.supportedExtensions.has(ext));
+      const status = hasPlugin ? "plugin available" : "no plugin \u2014 skipped";
+      lines.push(`  ${lang.padEnd(10)} ${String(count).padStart(5)} files (${status})`);
+    }
+    if (lines.length === 0) return;
+    console.error("[ctxo] Language scan:");
+    for (const line of lines) console.error(line);
+  }
+  async registerDiscoveredPlugins(registry) {
+    const loaded = await loadPlugins(this.projectRoot);
+    let tsMorphLike;
+    let roslynAdapter = null;
+    let csharpTier = "unavailable";
+    for (const { plugin, adapter } of loaded) {
+      if (typeof adapter.initialize === "function") {
+        try {
+          await adapter.initialize(this.projectRoot);
+        } catch (err) {
+          console.error(`[ctxo] Plugin ${plugin.id} initialize failed: ${err.message}`);
+          continue;
+        }
+      }
+      registry.register(plugin.extensions, adapter);
+      const tsCandidate = adapter;
+      if (typeof tsCandidate.loadProjectSources === "function" && typeof tsCandidate.clearProjectSources === "function") {
+        tsMorphLike = tsCandidate;
+      }
+      const csCandidate = adapter;
+      if (typeof csCandidate.getRoslynDelegate === "function" && typeof csCandidate.getTier === "function") {
+        csharpTier = csCandidate.getTier();
+        roslynAdapter = csCandidate.getRoslynDelegate() ?? null;
+      }
+      const tierSuffix = plugin.id === "csharp" && csharpTier !== "full" ? ` (active: ${csharpTier})` : "";
+      console.error(`[ctxo] Plugin ${plugin.id}@${plugin.version} (${plugin.tier} tier${tierSuffix}) \u2014 ${plugin.extensions.join(", ")}`);
+    }
+    return { tsMorphLike, roslynAdapter, csharpTier };
+  }
+  discoverFilesIn(root) {
+    try {
+      const output = execFileSync2("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) => join7(root, line));
+    } catch {
+      console.error(`[ctxo] git ls-files failed for ${root}`);
+      return [];
+    }
+  }
+  discoverWorkspaces() {
+    const pkgPath = join7(this.projectRoot, "package.json");
+    if (!existsSync8(pkgPath)) return [this.projectRoot];
+    try {
+      const pkg = JSON.parse(readFileSync5(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 = join7(this.projectRoot, ws.slice(0, -2));
+          if (existsSync8(parentDir)) {
+            for (const entry of readdirSync2(parentDir, { withFileTypes: true })) {
+              if (entry.isDirectory()) {
+                resolved.push(join7(parentDir, entry.name));
+              }
+            }
+          }
+        } else {
+          const wsPath = join7(this.projectRoot, ws);
+          if (existsSync8(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 this.supportedExtensions.has(ext);
+  }
+  async runCheck() {
+    console.error("[ctxo] Checking index freshness...");
+    const registry = new LanguageAdapterRegistry();
+    const { roslynAdapter: _roslyn } = await this.registerDiscoveredPlugins(registry);
+    this.supportedExtensions = registry.getSupportedExtensions();
+    if (_roslyn) await _roslyn.dispose();
+    const hasher = new ContentHasher();
+    const files = this.discoverFilesIn(this.projectRoot);
+    const reader = new (await import("./json-index-reader-NNKOVCOG.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) {
+      if (!this.isSupportedExtension(filePath)) 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 (!existsSync8(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 = readFileSync5(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 = join7(this.projectRoot, ".gitignore");
+    const cachePattern = ".ctxo/.cache/";
+    const suffix = `
+# Ctxo local cache (never committed)
+${cachePattern}
+`;
+    const existing = existsSync8(gitignorePath) ? readFileSync5(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 join8 } from "path";
+var SyncCommand = class {
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.ctxoRoot = join8(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 join9 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+var StatusCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join9(projectRoot, ".ctxo");
+  }
+  run() {
+    const indexDir = join9(this.ctxoRoot, "index");
+    if (!existsSync9(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 = existsSync9(join9(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 = execFileSync3("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 join10 } 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(join10(tmpdir(), "ctxo-verify-"));
+    try {
+      const tempCtxo = join10(tempDir, ".ctxo");
+      const indexCmd = new IndexCommand(this.projectRoot, tempCtxo);
+      await indexCmd.run({ skipSideEffects: true });
+      const committedReader = new JsonIndexReader(join10(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 join12 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, chmodSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+
+// src/cli/ai-rules.ts
+import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join11, dirname as dirname6 } from "path";
+var PLATFORMS = [
+  { id: "claude-code", name: "Claude Code", file: "CLAUDE.md", mode: "append", detectPaths: ["CLAUDE.md", ".claude"], starred: true },
+  { id: "cursor", name: "Cursor", file: ".cursor/rules/ctxo.mdc", mode: "create", detectPaths: [".cursor", ".cursorrules"], starred: false },
+  { id: "github-copilot", name: "GitHub Copilot", file: ".github/copilot-instructions.md", mode: "create", detectPaths: [".github", ".vscode"], starred: false },
+  { id: "windsurf", name: "Windsurf", file: ".windsurfrules", mode: "create", detectPaths: [".windsurfrules", ".windsurf"], starred: false },
+  { id: "antigravity", name: "Google Antigravity", file: "AGENTS.md", mode: "create", detectPaths: ["AGENTS.md", "GEMINI.md", ".gemini"], starred: false },
+  { id: "augment", name: "Augment Code", file: "augment-guidelines.md", mode: "create", detectPaths: ["augment-guidelines.md", ".augment"], starred: false },
+  { id: "amazonq", name: "Amazon Q", file: ".amazonq/rules/ctxo.md", mode: "create", detectPaths: [".amazonq"], starred: false }
+];
+function detectPlatforms(projectRoot) {
+  const detected = /* @__PURE__ */ new Set();
+  for (const p of PLATFORMS) {
+    if (p.detectPaths.some((d) => existsSync10(join11(projectRoot, d)))) {
+      detected.add(p.id);
+    }
+  }
+  return detected;
+}
+var SECTION_START = "<!-- ctxo-rules-start -->";
+var SECTION_END = "<!-- ctxo-rules-end -->";
+function ruleBody() {
+  return `## ctxo MCP Tool Usage (MANDATORY)
+
+**ALWAYS use ctxo MCP tools before reading source files or making code changes.** The ctxo index contains dependency graphs, git intent, anti-patterns, and change health that cannot be derived from reading files alone. Skipping these tools leads to blind edits and broken dependencies.
+
+### Before ANY Code Modification
+1. Call \`get_blast_radius\` for the symbol you are about to change \u2014 understand what breaks
+2. Call \`get_why_context\` for the same symbol \u2014 check for revert history or anti-patterns
+3. Only then read and edit source files
+
+### Before Starting a Task
+| Task Type | REQUIRED First Call |
+|---|---|
+| Fixing a bug | \`get_context_for_task(taskType: "fix")\` |
+| Adding/extending a feature | \`get_context_for_task(taskType: "extend")\` |
+| Refactoring | \`get_context_for_task(taskType: "refactor")\` |
+| Understanding code | \`get_context_for_task(taskType: "understand")\` |
+
+### Before Reviewing a PR or Diff
+- Call \`get_pr_impact\` \u2014 single call gives full risk assessment with co-change analysis
+
+### When Exploring or Searching Code
+- Use \`search_symbols\` for name/regex lookup \u2014 DO NOT grep source files for symbol discovery
+- Use \`get_ranked_context\` for natural language queries \u2014 DO NOT manually browse directories
+
+### Orientation in Unfamiliar Areas
+- Call \`get_architectural_overlay\` to understand layer boundaries
+- Call \`get_symbol_importance\` to identify critical symbols
+
+### NEVER Do These
+- NEVER edit a function without first calling \`get_blast_radius\` on it
+- NEVER skip \`get_why_context\` \u2014 reverted code and anti-patterns are invisible without it
+- NEVER grep source files to find symbols when \`search_symbols\` exists
+- NEVER manually trace imports when \`find_importers\` gives the full reverse dependency graph`;
+}
+function cursorFrontmatter() {
+  return `---
+description: ctxo MCP tool usage rules \u2014 always applied
+globs:
+alwaysApply: true
+---
+
+`;
+}
+function generateRules(platformId) {
+  const body = ruleBody();
+  if (platformId === "cursor") {
+    return cursorFrontmatter() + body + "\n";
+  }
+  return body + "\n";
+}
+function installRules(projectRoot, platformId) {
+  const platform = PLATFORMS.find((p) => p.id === platformId);
+  if (!platform) throw new Error(`Unknown platform: ${platformId}`);
+  const filePath = join11(projectRoot, platform.file);
+  const content = generateRules(platformId);
+  const dir = dirname6(filePath);
+  if (!existsSync10(dir)) mkdirSync3(dir, { recursive: true });
+  if (platform.mode === "create") {
+    writeFileSync4(filePath, content, "utf-8");
+    return { file: platform.file, action: existsSync10(filePath) ? "updated" : "created" };
+  }
+  if (!existsSync10(filePath)) {
+    writeFileSync4(filePath, content, "utf-8");
+    return { file: platform.file, action: "created" };
+  }
+  const existing = readFileSync6(filePath, "utf-8");
+  if (existing.includes(SECTION_START)) {
+    const re = new RegExp(`${escapeRegExp(SECTION_START)}[\\s\\S]*?${escapeRegExp(SECTION_END)}`, "m");
+    const updated2 = existing.replace(re, `${SECTION_START}
+${content}${SECTION_END}`);
+    writeFileSync4(filePath, updated2, "utf-8");
+    return { file: platform.file, action: "updated" };
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  const updated = existing + separator + `${SECTION_START}
+${content}${SECTION_END}
+`;
+  writeFileSync4(filePath, updated, "utf-8");
+  return { file: platform.file, action: "updated" };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var GITIGNORE_ENTRY = ".ctxo/.cache/";
+function ensureGitignore(projectRoot) {
+  const filePath = join11(projectRoot, ".gitignore");
+  if (!existsSync10(filePath)) {
+    writeFileSync4(filePath, `# Ctxo local cache (auto-rebuilt, never committed)
+${GITIGNORE_ENTRY}
+`, "utf-8");
+    return { file: ".gitignore", action: "created" };
+  }
+  const existing = readFileSync6(filePath, "utf-8");
+  if (existing.includes(GITIGNORE_ENTRY)) {
+    return { file: ".gitignore", action: "skipped" };
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  const updated = existing + `${separator}# Ctxo local cache (auto-rebuilt, never committed)
+${GITIGNORE_ENTRY}
+`;
+  writeFileSync4(filePath, updated, "utf-8");
+  return { file: ".gitignore", action: "updated" };
+}
+var DEFAULT_CONFIG = `# ctxo project configuration
+# Docs: https://github.com/alperhankendi/Ctxo
+version: "1.0"
+`;
+function ensureConfig(projectRoot) {
+  const filePath = join11(projectRoot, ".ctxo", "config.yaml");
+  const dir = dirname6(filePath);
+  if (!existsSync10(dir)) mkdirSync3(dir, { recursive: true });
+  if (existsSync10(filePath)) {
+    return { file: ".ctxo/config.yaml", action: "skipped" };
+  }
+  writeFileSync4(filePath, DEFAULT_CONFIG, "utf-8");
+  return { file: ".ctxo/config.yaml", action: "created" };
+}
+var CTXO_MCP_ENTRY = { command: "npx", args: ["-y", "@ctxo/cli"] };
+function getMcpConfigTargets(selectedPlatformIds) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const id of selectedPlatformIds) {
+    switch (id) {
+      case "claude-code":
+      case "cursor":
+      case "windsurf":
+      case "augment":
+      case "antigravity":
+        targets.set(".mcp.json", { file: ".mcp.json", serverKey: "mcpServers" });
+        break;
+      case "github-copilot":
+        targets.set(".vscode/mcp.json", { file: ".vscode/mcp.json", serverKey: "servers", extraFields: { type: "stdio" } });
+        break;
+      case "amazonq":
+        targets.set(".amazonq/mcp.json", { file: ".amazonq/mcp.json", serverKey: "mcpServers" });
+        break;
+    }
+  }
+  return [...targets.values()];
+}
+function ensureMcpConfig(projectRoot, target) {
+  const filePath = join11(projectRoot, target.file);
+  const dir = dirname6(filePath);
+  if (!existsSync10(dir)) mkdirSync3(dir, { recursive: true });
+  const entry = target.extraFields ? { ...target.extraFields, ...CTXO_MCP_ENTRY } : { ...CTXO_MCP_ENTRY };
+  if (!existsSync10(filePath)) {
+    const config = { [target.serverKey]: { ctxo: entry } };
+    writeFileSync4(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return { file: target.file, action: "created" };
+  }
+  let existing;
+  try {
+    existing = JSON.parse(readFileSync6(filePath, "utf-8"));
+  } catch {
+    const config = { [target.serverKey]: { ctxo: entry } };
+    writeFileSync4(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return { file: target.file, action: "updated" };
+  }
+  const servers = existing[target.serverKey] ?? {};
+  if (servers["ctxo"]) {
+    return { file: target.file, action: "skipped" };
+  }
+  servers["ctxo"] = entry;
+  existing[target.serverKey] = servers;
+  writeFileSync4(filePath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+  return { file: target.file, action: "updated" };
+}
+
+// src/cli/init-command.ts
+var requireCjs2 = createRequire2(import.meta.url);
+function resolveInstalledPlugins(needed) {
+  const installed = [];
+  const missing = [];
+  for (const lang of needed) {
+    try {
+      requireCjs2.resolve(`${officialPluginFor(lang)}/package.json`);
+      installed.push(lang);
+    } catch {
+      missing.push(lang);
+    }
+  }
+  return { installed, missing };
+}
+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 STRIP_ANSI = /\u001b\[[0-9;]*m/g;
+var strip = (s) => s.replace(STRIP_ANSI, "");
+function box(lines, opts, pc) {
+  const border = opts.border ?? pc.dim;
+  const w = opts.width ?? Math.max(...lines.map((l) => strip(l).length), strip(opts.title ?? "").length + 4, 48);
+  const pad = (s) => s + " ".repeat(Math.max(0, w - strip(s).length));
+  const hr = "\u2500".repeat(w + 2);
+  let top;
+  if (opts.title) {
+    const tLen = strip(opts.title).length;
+    top = border("\u256D\u2500 ") + opts.title + border(` ${"\u2500".repeat(Math.max(0, w - tLen - 2))}\u256E`);
+  } else {
+    top = border(`\u256D${hr}\u256E`);
+  }
+  const bot = border(`\u2570${hr}\u256F`);
+  const body = lines.map((l) => `${border("\u2502")} ${pad(l)} ${border("\u2502")}`).join("\n");
+  return `${top}
+${body}
+${bot}`;
+}
+function stepHeader(step, total, title, desc, pc) {
+  const stepLabel = pc.bold(pc.cyan(`${step}/${total}`));
+  const titleStr = pc.bold(title);
+  return box(
+    [`${pc.dim(desc)}`],
+    { title: `${stepLabel} ${titleStr}`, border: pc.cyan },
+    pc
+  );
+}
+function renderBanner(_version, pc) {
+  const art = [
+    "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+    "  \u2588\u2588\u2554\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557",
+    "  \u2588\u2588\u2551       \u2588\u2588\u2551    \u255A\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551",
+    "  \u2588\u2588\u2551       \u2588\u2588\u2551    \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551",
+    "  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551   \u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+    "   \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D "
+  ];
+  const colors = [pc.cyan, pc.cyan, pc.blueBright, pc.blueBright, pc.magentaBright, pc.magentaBright];
+  const coloredArt = art.map((line, i) => colors[i](line));
+  const tagline1 = pc.bold(pc.white("  Code intelligence for AI agents."));
+  const tagline2 = pc.dim("  One call instead of hundreds.");
+  const inner = [
+    "",
+    ...coloredArt,
+    "",
+    tagline1,
+    tagline2,
+    ""
+  ];
+  return box(inner, { border: pc.dim }, pc);
+}
+var InitCommand = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  installHooks() {
+    const hooksDir = join12(this.projectRoot, ".git", "hooks");
+    mkdirSync4(hooksDir, { recursive: true });
+    this.installHook(hooksDir, "post-commit", POST_COMMIT_CONTENT);
+    this.installHook(hooksDir, "post-merge", POST_MERGE_CONTENT);
+  }
+  async run(options = {}) {
+    if (!existsSync11(join12(this.projectRoot, ".git"))) {
+      console.error('[ctxo] Not a git repository. Run "git init" first.');
+      process.exit(1);
+    }
+    if (options.dryRun) return this.dryRun(options);
+    if (options.yes || options.tools) return await this.runNonInteractive(options);
+    return this.runInteractive(options);
+  }
+  /* ---------------------------------------------------------------- */
+  /*  Interactive flow                                                 */
+  /* ---------------------------------------------------------------- */
+  async runInteractive(options) {
+    const clack = await import("@clack/prompts");
+    const pc = (await import("picocolors")).default;
+    const version = await this.getVersion();
+    const totalSteps = options.rulesOnly ? 1 : 3;
+    console.error("");
+    console.error(renderBanner(version, pc));
+    console.error("");
+    let stepNum = 0;
+    if (!options.rulesOnly) {
+      stepNum++;
+      console.error(stepHeader(stepNum, totalSteps, "Index Directory", "Where ctxo stores the symbol graph and metadata.", pc));
+      console.error("");
+      const indexDir = await clack.text({
+        message: pc.cyan("Directory path"),
+        placeholder: ".ctxo/index",
+        initialValue: ".ctxo/index",
+        validate: (val) => {
+          if (!val?.trim()) return "Directory path is required";
+          return void 0;
+        }
+      });
+      if (clack.isCancel(indexDir)) {
+        clack.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+      const fullPath = join12(this.projectRoot, indexDir);
+      if (!existsSync11(fullPath)) mkdirSync4(fullPath, { recursive: true });
+      console.error("");
+    }
+    stepNum++;
+    const detected = detectPlatforms(this.projectRoot);
+    const detectedCount = detected.size;
+    const detectedHint = detectedCount > 0 ? pc.green(` ${detectedCount} detected`) : "";
+    console.error(stepHeader(stepNum, totalSteps, `AI Tools${detectedHint}`, "Select your tools. Generates MCP usage rules for each.", pc));
+    console.error("");
+    const toolChoices = PLATFORMS.map((p) => {
+      const isDetected = detected.has(p.id);
+      const star = p.starred ? pc.yellow(" \u2605") : "";
+      const detect = isDetected ? pc.green(" (detected)") : "";
+      return {
+        value: p.id,
+        label: `${p.name}${star}${detect}`,
+        hint: isDetected ? void 0 : pc.dim(p.file)
+      };
+    });
+    const selectedTools = await clack.multiselect({
+      message: pc.cyan("Select tools"),
+      options: toolChoices,
+      initialValues: [...detected],
+      required: false
+    });
+    if (clack.isCancel(selectedTools)) {
+      clack.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    console.error("");
+    let pluginsToInstall = [];
+    if (!options.rulesOnly && !options.noInstall) {
+      const detection = detectLanguages(this.projectRoot);
+      const needed = decideNeededLanguages(detection);
+      const { missing } = resolveInstalledPlugins(needed);
+      if (missing.length > 0) {
+        console.error(stepHeader(
+          stepNum + 1,
+          totalSteps + 1,
+          `Language Plugins ${pc.yellow("missing")}`,
+          `Detected: ${missing.join(", ")} \u2014 ctxo needs a plugin per language to index it.`,
+          pc
+        ));
+        console.error("");
+        const confirm = await clack.confirm({
+          message: pc.cyan(`Install ${missing.map(officialPluginFor).join(" ")}?`),
+          initialValue: true
+        });
+        if (clack.isCancel(confirm)) {
+          clack.cancel("Setup cancelled.");
+          process.exit(0);
+        }
+        if (confirm) {
+          pluginsToInstall = missing;
+          stepNum++;
+        }
+        console.error("");
+      }
+    }
+    let installGitHooks = false;
+    if (!options.rulesOnly) {
+      stepNum++;
+      console.error(stepHeader(stepNum, totalSteps, `Git Hooks ${pc.yellow("recommended")}`, "Auto-updates index on every commit and pull.", pc));
+      console.error("");
+      const hooks = await clack.confirm({
+        message: pc.cyan("Install hooks?"),
+        initialValue: true
+      });
+      if (clack.isCancel(hooks)) {
+        clack.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+      installGitHooks = hooks;
+      console.error("");
+    }
+    const s = clack.spinner();
+    s.start(pc.dim("Configuring..."));
+    const results = [];
+    const gitignoreResult = ensureGitignore(this.projectRoot);
+    const configResult = ensureConfig(this.projectRoot);
+    if (!options.rulesOnly) {
+      results.push(`${pc.green("\u2713")} ${pc.bold(".ctxo/index/")}  ${pc.dim("index directory")}`);
+    }
+    if (configResult.action !== "skipped") {
+      results.push(`${pc.green("\u2713")} ${pc.bold(configResult.file)}  ${pc.dim(configResult.action)}`);
+    }
+    if (gitignoreResult.action !== "skipped") {
+      results.push(`${pc.green("\u2713")} ${pc.bold(gitignoreResult.file)}  ${pc.dim(gitignoreResult.action)}`);
+    }
+    for (const toolId of selectedTools) {
+      const result = installRules(this.projectRoot, toolId);
+      results.push(`${pc.green("\u2713")} ${pc.bold(result.file)}  ${pc.dim(result.action)}`);
+    }
+    const mcpTargets = getMcpConfigTargets(selectedTools);
+    for (const target of mcpTargets) {
+      const result = ensureMcpConfig(this.projectRoot, target);
+      if (result.action !== "skipped") {
+        results.push(`${pc.green("\u2713")} ${pc.bold(result.file)}  ${pc.dim(result.action + " \u2014 MCP server registered")}`);
+      }
+    }
+    if (installGitHooks) {
+      this.installHooks();
+      results.push(`${pc.green("\u2713")} ${pc.bold("post-commit, post-merge")}  ${pc.dim("hooks installed")}`);
+    }
+    if (pluginsToInstall.length > 0) {
+      s.stop(pc.dim("Installing language plugins..."));
+      const installer = new InstallCommand(this.projectRoot);
+      await installer.run({ languages: pluginsToInstall, yes: true });
+      results.push(`${pc.green("\u2713")} ${pc.bold(pluginsToInstall.map(officialPluginFor).join(", "))}  ${pc.dim("language plugins installed")}`);
+      s.start(pc.dim("Finalizing..."));
+    }
+    s.stop(pc.green("Done!"));
+    if (results.length > 0) {
+      console.error("");
+      console.error(box(results, { title: pc.green("\u2713 Created"), border: pc.green }, pc));
+    }
+    const hasWork = selectedTools.length > 0 || installGitHooks;
+    if (hasWork) {
+      const steps = [
+        `${pc.cyan("\u25B6")} npx ctxo index     ${pc.dim("\u2500 build codebase index")}`,
+        `${pc.cyan("\u25B6")} npx ctxo doctor    ${pc.dim("\u2500 verify everything works")}`
+      ];
+      console.error("");
+      console.error(box(steps, { title: pc.cyan("\u2192 Next steps"), border: pc.cyan }, pc));
+    }
+    console.error("");
+    console.error(`  ${pc.dim("Happy coding!")} ${pc.magentaBright("\u2764")}`);
+    console.error("");
+  }
+  /* ---------------------------------------------------------------- */
+  /*  Non-interactive flow                                             */
+  /* ---------------------------------------------------------------- */
+  async runNonInteractive(options) {
+    const toolIds = options.tools ?? [];
+    for (const id of toolIds) {
+      if (!PLATFORMS.find((p) => p.id === id)) {
+        console.error(`[ctxo] Unknown tool: "${id}". Valid: ${PLATFORMS.map((p) => p.id).join(", ")}`);
+        process.exit(1);
+      }
+    }
+    const gitignoreResult = ensureGitignore(this.projectRoot);
+    const configResult = ensureConfig(this.projectRoot);
+    if (!options.rulesOnly) {
+      const indexDir = join12(this.projectRoot, ".ctxo", "index");
+      if (!existsSync11(indexDir)) mkdirSync4(indexDir, { recursive: true });
+      console.error("[ctxo] \u2713 .ctxo/index/ ready");
+    }
+    if (configResult.action !== "skipped") {
+      console.error(`[ctxo] \u2713 ${configResult.file} \u2014 ${configResult.action}`);
+    }
+    if (gitignoreResult.action !== "skipped") {
+      console.error(`[ctxo] \u2713 ${gitignoreResult.file} \u2014 ${gitignoreResult.action}`);
+    }
+    for (const toolId of toolIds) {
+      const result = installRules(this.projectRoot, toolId);
+      console.error(`[ctxo] \u2713 ${result.file} \u2014 ${result.action}`);
+    }
+    const mcpTargets = getMcpConfigTargets(toolIds);
+    for (const target of mcpTargets) {
+      const result = ensureMcpConfig(this.projectRoot, target);
+      if (result.action !== "skipped") {
+        console.error(`[ctxo] \u2713 ${result.file} \u2014 ${result.action} (MCP server registered)`);
+      }
+    }
+    if (!options.rulesOnly) {
+      this.installHooks();
+      console.error("[ctxo] \u2713 Git hooks installed");
+    }
+    if (!options.rulesOnly && !options.noInstall) {
+      const detection = detectLanguages(this.projectRoot);
+      const needed = decideNeededLanguages(detection);
+      const { missing } = resolveInstalledPlugins(needed);
+      if (missing.length > 0) {
+        if (options.yes) {
+          console.error(`[ctxo] Installing missing plugins: ${missing.join(", ")}`);
+          await new InstallCommand(this.projectRoot).run({ languages: missing, yes: true });
+        } else {
+          console.error(
+            `[ctxo] Detected missing plugins: ${missing.join(", ")}. Run "ctxo install ${missing.join(" ")}" to install.`
+          );
+        }
+      }
+    }
+  }
+  /* ---------------------------------------------------------------- */
+  /*  Dry run                                                          */
+  /* ---------------------------------------------------------------- */
+  dryRun(options) {
+    const toolIds = options.tools ?? PLATFORMS.map((p) => p.id);
+    console.error("[ctxo] Dry run \u2014 the following files would be created/updated:\n");
+    if (!options.rulesOnly) {
+      console.error("  .ctxo/index/              (index directory)");
+    }
+    for (const id of toolIds) {
+      const platform = PLATFORMS.find((p) => p.id === id);
+      if (platform) {
+        const exists = existsSync11(join12(this.projectRoot, platform.file));
+        const action = platform.mode === "append" && exists ? "append section" : "create";
+        console.error(`  ${platform.file.padEnd(42)} (${action})`);
+      }
+    }
+    if (!options.rulesOnly) {
+      console.error("  .git/hooks/post-commit    (git hook)");
+      console.error("  .git/hooks/post-merge     (git hook)");
+    }
+  }
+  /* ---------------------------------------------------------------- */
+  /*  Helpers                                                          */
+  /* ---------------------------------------------------------------- */
+  async getVersion() {
+    try {
+      const pkgPath = join12(this.projectRoot, "node_modules", "@ctxo", "cli", "package.json");
+      if (existsSync11(pkgPath)) {
+        return JSON.parse(readFileSync7(pkgPath, "utf-8")).version;
+      }
+      const { createRequire: createRequire5 } = await import("module");
+      const require4 = createRequire5(import.meta.url);
+      return require4("../../package.json").version;
+    } catch {
+      return void 0;
+    }
+  }
+  installHook(hooksDir, hookName, hookContent) {
+    const hookPath = join12(hooksDir, hookName);
+    let existing = "";
+    if (existsSync11(hookPath)) {
+      existing = readFileSync7(hookPath, "utf-8");
+      if (existing.includes(CTXO_START)) return;
+    } else {
+      existing = "#!/bin/sh\n";
+    }
+    const updated = existing.endsWith("\n") ? existing + "\n" + hookContent + "\n" : existing + "\n\n" + hookContent + "\n";
+    writeFileSync5(hookPath, updated, "utf-8");
+    chmodSync(hookPath, 493);
+  }
+};
+
+// src/cli/watch-command.ts
+import { join as join13, extname as extname4, relative as relative2 } from "path";
+import { readFileSync as readFileSync8 } 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 DEBOUNCE_MS = 300;
+var WatchCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join13(projectRoot, ".ctxo");
+  }
+  async run() {
+    console.error("[ctxo] Starting file watcher...");
+    const registry = new LanguageAdapterRegistry();
+    let roslynAdapter = null;
+    for (const { plugin, adapter } of await loadPlugins(this.projectRoot)) {
+      if (typeof adapter.initialize === "function") {
+        try {
+          await adapter.initialize(this.projectRoot);
+        } catch (err) {
+          console.error(`[ctxo] Plugin ${plugin.id} initialize failed: ${err.message}`);
+          continue;
+        }
+      }
+      registry.register(plugin.extensions, adapter);
+      const csCandidate = adapter;
+      if (typeof csCandidate.getRoslynDelegate === "function") {
+        const roslyn = csCandidate.getRoslynDelegate();
+        if (roslyn?.isReady()) {
+          const started = await roslyn.startKeepAlive();
+          if (started) {
+            roslynAdapter = roslyn;
+            console.error("[ctxo] C# watch: Roslyn keep-alive active (full tier, <100ms per change)");
+          }
+        }
+      }
+      console.error(`[ctxo] Plugin ${plugin.id}@${plugin.version} (${plugin.tier} tier)`);
+    }
+    const supportedExtensions = registry.getSupportedExtensions();
+    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 adapter = registry.getAdapter(filePath);
+      if (!adapter) return;
+      const relativePath = relative2(this.projectRoot, filePath).replace(/\\/g, "/");
+      try {
+        if (roslynAdapter?.isReady() && filePath.endsWith(".cs")) {
+          const result = await roslynAdapter.reindexFile(relativePath);
+          if (result) {
+            const commits2 = await gitAdapter.getCommitHistory(relativePath);
+            const intent2 = commits2.map((c) => ({
+              hash: c.hash,
+              message: c.message,
+              date: c.date,
+              kind: "commit"
+            }));
+            const antiPatterns2 = revertDetector.detect(commits2);
+            const source2 = readFileSync8(filePath, "utf-8");
+            const fileIndex2 = {
+              file: relativePath,
+              lastModified: Math.floor(Date.now() / 1e3),
+              contentHash: hasher.hash(source2),
+              symbols: result.symbols.map((s) => ({
+                symbolId: s.symbolId,
+                name: s.name,
+                kind: s.kind,
+                startLine: s.startLine,
+                endLine: s.endLine
+              })),
+              edges: result.edges.filter((e) => !e.to.startsWith("ns:")).map((e) => ({
+                from: e.from,
+                to: e.to,
+                kind: e.kind
+              })),
+              complexity: result.complexity.map((c) => ({
+                symbolId: c.symbolId,
+                cyclomatic: c.cyclomatic
+              })),
+              intent: intent2,
+              antiPatterns: antiPatterns2
+            };
+            writer.write(fileIndex2);
+            storage.writeSymbolFile(fileIndex2);
+            console.error(`[ctxo] Re-indexed (Roslyn): ${relativePath}`);
+            return;
+          }
+        }
+        const source = readFileSync8(filePath, "utf-8");
+        const lastModified = Math.floor(Date.now() / 1e3);
+        const symbols = await adapter.extractSymbols(relativePath, source);
+        const edges = await adapter.extractEdges(relativePath, source);
+        const complexity = await 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 (!supportedExtensions.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);
+      }
+      const roslynShutdown = roslynAdapter ? roslynAdapter.dispose() : Promise.resolve();
+      roslynShutdown.then(() => {
+        watcher.stop().then(() => {
+          storage.close();
+          console.error("[ctxo] Watcher stopped");
+          process.exit(0);
+        });
+      });
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+};
+
+// src/cli/stats-command.ts
+import { join as join14 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import initSqlJs from "sql.js";
+var StatsCommand = class {
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.ctxoRoot = join14(projectRoot, ".ctxo");
+  }
+  async run(options) {
+    if (!this.isStatsEnabled()) {
+      console.error("[ctxo] Stats collection is disabled in .ctxo/config.yaml");
+      return;
+    }
+    const dbPath = join14(this.ctxoRoot, ".cache", "symbols.db");
+    if (!existsSync12(dbPath)) {
+      if (options.json) {
+        process.stdout.write(JSON.stringify(this.emptyReport(options.days)) + "\n");
+      } else {
+        console.error("[ctxo] No usage data yet. Start using Ctxo MCP tools to collect stats.");
+      }
+      return;
+    }
+    const SQL = await initSqlJs();
+    const buffer = readFileSync9(dbPath);
+    const db = new SQL.Database(buffer);
+    const recorder = new SessionRecorderAdapter(db);
+    try {
+      if (options.clear) {
+        recorder.clear();
+        const data = db.export();
+        const { writeFileSync: writeFileSync7 } = await import("fs");
+        writeFileSync7(dbPath, Buffer.from(data));
+        console.error("[ctxo] Session data cleared.");
+        return;
+      }
+      if (options.days != null) {
+        if (!Number.isInteger(options.days) || options.days <= 0) {
+          console.error("[ctxo] --days must be a positive integer");
+          process.exit(1);
+          return;
+        }
+      }
+      const stats = recorder.queryStats(options.days);
+      if (stats.totalCalls === 0) {
+        if (options.json) {
+          process.stdout.write(JSON.stringify(this.emptyReport(options.days)) + "\n");
+        } else {
+          console.error("[ctxo] No usage data yet. Start using Ctxo MCP tools to collect stats.");
+        }
+        return;
+      }
+      if (options.json) {
+        process.stdout.write(JSON.stringify(this.buildReport(stats, options.days), null, 2) + "\n");
+      } else {
+        this.printHumanReadable(stats, options.days);
+      }
+    } finally {
+      db.close();
+    }
+  }
+  isStatsEnabled() {
+    const configPath = join14(this.ctxoRoot, "config.yaml");
+    if (!existsSync12(configPath)) return true;
+    try {
+      const raw = readFileSync9(configPath, "utf-8");
+      const match = raw.match(/stats:\s*\n\s*enabled:\s*(true|false)/);
+      if (match) return match[1] !== "false";
+      return true;
+    } catch {
+      return true;
+    }
+  }
+  buildReport(stats, days) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const from = days != null ? new Date(Date.now() - days * 864e5).toISOString() : null;
+    return {
+      timeRange: { from, to: now, daysFilter: days ?? null },
+      summary: {
+        totalCalls: stats.totalCalls,
+        totalTokensServed: stats.totalTokensServed
+      },
+      topTools: stats.topTools,
+      topSymbols: stats.topSymbols,
+      detailLevelDistribution: stats.detailLevelDistribution.map((d) => ({
+        level: d.level,
+        count: d.count,
+        percentage: d.percentage
+      }))
+    };
+  }
+  emptyReport(days) {
+    return this.buildReport({
+      totalCalls: 0,
+      totalTokensServed: 0,
+      topTools: [],
+      topSymbols: [],
+      detailLevelDistribution: []
+    }, days);
+  }
+  printHumanReadable(stats, days) {
+    const header = days != null ? `last ${days} days` : "all time";
+    console.error("");
+    console.error(`  Usage Summary (${header})`);
+    console.error("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.error(`  Total tool calls:      ${this.formatNumber(stats.totalCalls)}`);
+    console.error(`  Total tokens served:   ${this.formatTokens(stats.totalTokensServed)}`);
+    if (stats.topTools.length > 0) {
+      console.error("");
+      console.error("  Top Tools");
+      console.error("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      for (const t of stats.topTools) {
+        const name = t.tool.padEnd(24);
+        const calls = `${this.formatNumber(t.calls)} calls`.padEnd(14);
+        console.error(`  ${name}${calls}avg ${this.formatNumber(t.avgTokens)} tokens`);
+      }
+    }
+    if (stats.topSymbols.length > 0) {
+      console.error("");
+      console.error("  Top Queried Symbols");
+      console.error("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      for (const s of stats.topSymbols) {
+        const name = s.name.padEnd(32);
+        console.error(`  ${name}${this.formatNumber(s.queries)} queries`);
+      }
+    }
+    if (stats.detailLevelDistribution.length > 0) {
+      console.error("");
+      console.error("  Detail Level Distribution");
+      console.error("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      for (const d of stats.detailLevelDistribution) {
+        const bar = this.renderBar(d.percentage);
+        const pct = `${d.percentage}%`.padStart(4);
+        console.error(`  ${d.level}: ${bar}  ${pct}`);
+      }
+    }
+    console.error("");
+  }
+  renderBar(percentage) {
+    const filled = Math.round(percentage / 10);
+    const empty = 10 - filled;
+    return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  }
+  formatNumber(n) {
+    return n.toLocaleString("en-US");
+  }
+  formatTokens(n) {
+    if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+    if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+    return String(n);
+  }
+};
+
+// src/cli/doctor-command.ts
+import { join as join21 } from "path";
+import { existsSync as existsSync19 } from "fs";
+
+// src/adapters/diagnostics/health-checker.ts
+var log3 = createLogger("ctxo:doctor");
+var HealthChecker = class {
+  checks;
+  constructor(checks) {
+    this.checks = checks;
+  }
+  async runAll(ctx) {
+    const settled = await Promise.allSettled(
+      this.checks.map((check) => check.run(ctx))
+    );
+    const results = settled.map((outcome, i) => {
+      const check = this.checks[i];
+      if (outcome.status === "fulfilled") {
+        const r = outcome.value;
+        log3.info(`${r.id}: ${r.status.toUpperCase()} (${r.message})`);
+        return r;
+      }
+      const message = outcome.reason?.message ?? "Unknown error";
+      log3.error(`${check.id}: FAIL (${message})`);
+      return {
+        id: check.id,
+        title: check.title,
+        status: "fail",
+        message: `Check crashed: ${message}`
+      };
+    });
+    const summary = {
+      pass: results.filter((r) => r.status === "pass").length,
+      warn: results.filter((r) => r.status === "warn").length,
+      fail: results.filter((r) => r.status === "fail").length
+    };
+    const exitCode = summary.fail > 0 ? 1 : 0;
+    return { checks: results, summary, exitCode };
+  }
+};
+
+// src/adapters/diagnostics/doctor-reporter.ts
+var ICONS = {
+  pass: "\u2713",
+  warn: "\u26A0",
+  fail: "\u2717"
+};
+var DoctorReporter = class {
+  formatHuman(report) {
+    const lines = ["ctxo doctor \u2014 Health Check", ""];
+    for (const check of report.checks) {
+      lines.push(this.formatCheckLine(check));
+    }
+    lines.push("");
+    lines.push(`  Summary: ${report.summary.pass} passed, ${report.summary.warn} warnings, ${report.summary.fail} failures`);
+    return lines.join("\n");
+  }
+  formatQuiet(report) {
+    const lines = [];
+    for (const check of report.checks) {
+      if (check.status === "warn" || check.status === "fail") {
+        lines.push(this.formatCheckLine(check));
+      }
+    }
+    if (lines.length > 0) lines.push("");
+    lines.push(`  Summary: ${report.summary.pass} passed, ${report.summary.warn} warnings, ${report.summary.fail} failures`);
+    return lines.join("\n");
+  }
+  formatJson(report) {
+    return JSON.stringify({
+      checks: report.checks.map((c) => ({
+        name: c.id,
+        status: c.status,
+        value: c.value ?? null,
+        message: c.message,
+        ...c.fix ? { fix: c.fix } : {}
+      })),
+      summary: report.summary,
+      exitCode: report.exitCode
+    }, null, 2);
+  }
+  formatCheckLine(check) {
+    const icon = ICONS[check.status] ?? "?";
+    const title = check.title.padEnd(24);
+    const suffix = check.fix ? ` (${check.fix})` : "";
+    return `  ${icon} ${title} ${check.message}${suffix}`;
+  }
+};
+
+// src/adapters/diagnostics/checks/runtime-check.ts
+import { createRequire as createRequire3 } from "module";
+var require2 = createRequire3(import.meta.url);
+function pass(id, title, message) {
+  return { id, title, status: "pass", message };
+}
+function warn(id, title, message, fix) {
+  return { id, title, status: "warn", message, fix };
+}
+function checkNodeVersion(version) {
+  const id = "node_version";
+  const title = "Node.js version";
+  const major = parseInt(version.slice(1).split(".")[0] ?? "0", 10);
+  if (major >= 20) return { id, title, status: "pass", message: `Node.js ${version} (required: \u226520)`, value: version };
+  if (major >= 18) return { id, title, status: "warn", message: `Node.js ${version} \u2014 v20+ recommended`, fix: "Upgrade to Node.js 20 or later", value: version };
+  return { id, title, status: "fail", message: `Node.js ${version} \u2014 v20+ required`, fix: "Upgrade to Node.js 20 or later", value: version };
+}
+var NodeVersionCheck = class {
+  id = "node_version";
+  title = "Node.js version";
+  async run(_ctx) {
+    return checkNodeVersion(process.version);
+  }
+};
+var TsMorphCheck = class {
+  id = "ts_morph";
+  title = "TypeScript plugin (@ctxo/lang-typescript)";
+  async run(_ctx) {
+    if (tryResolve("@ctxo/lang-typescript")) {
+      return pass(this.id, this.title, "available");
+    }
+    return warn(
+      this.id,
+      this.title,
+      "@ctxo/lang-typescript not installed \u2014 TypeScript/JavaScript indexing disabled",
+      'Run "npm install @ctxo/lang-typescript" (or "ctxo install typescript")'
+    );
+  }
+};
+var TreeSitterCheck = class {
+  id = "tree_sitter";
+  title = "Go / C# plugins (@ctxo/lang-go, @ctxo/lang-csharp)";
+  async run(_ctx) {
+    const goOk = tryResolve("@ctxo/lang-go");
+    const csOk = tryResolve("@ctxo/lang-csharp");
+    if (goOk && csOk) return pass(this.id, this.title, "both plugins available");
+    if (goOk || csOk) {
+      const missing = goOk ? "@ctxo/lang-csharp" : "@ctxo/lang-go";
+      return warn(
+        this.id,
+        this.title,
+        `${missing} not installed`,
+        `Run "npm install ${missing}" (or "ctxo install ${missing === "@ctxo/lang-go" ? "go" : "csharp"}")`
+      );
+    }
+    return warn(
+      this.id,
+      this.title,
+      "No Go/C# plugin installed \u2014 extended language indexing disabled",
+      'Run "npm install @ctxo/lang-go @ctxo/lang-csharp"'
+    );
+  }
+};
+function tryResolve(packageName) {
+  try {
+    require2.resolve(`${packageName}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/version-command.ts
+import { SUPPORTED_API_VERSION as SUPPORTED_API_VERSION2 } from "@ctxo/plugin-api";
+function gatherVersionInfo(discovered) {
+  const plugins = discovered.map(({ plugin, specifier }) => ({
+    name: specifier,
+    id: plugin.id,
+    version: plugin.version,
+    apiVersion: plugin.apiVersion,
+    compatible: plugin.apiVersion === SUPPORTED_API_VERSION2
+  }));
+  return {
+    ctxo: getVersion(),
+    pluginApiVersion: SUPPORTED_API_VERSION2,
+    plugins,
+    runtime: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch
+    }
+  };
+}
+function formatShort(info) {
+  return `ctxo ${info.ctxo}`;
+}
+function formatVerbose(info) {
+  const lines = [];
+  lines.push(`ctxo ${info.ctxo}`);
+  lines.push(`Plugin API: ${info.pluginApiVersion}`);
+  lines.push(`Runtime:    Node ${info.runtime.node} on ${info.runtime.platform}/${info.runtime.arch}`);
+  lines.push("");
+  if (info.plugins.length === 0) {
+    lines.push("Plugins:    (none installed)");
+    lines.push("");
+    lines.push('Install a language plugin, e.g. "npm i -D @ctxo/lang-typescript"');
+    return lines.join("\n");
+  }
+  const nameCol = Math.max(7, ...info.plugins.map((p) => p.name.length));
+  const verCol = Math.max(7, ...info.plugins.map((p) => p.version.length));
+  const apiCol = Math.max(3, ...info.plugins.map((p) => p.apiVersion.length));
+  lines.push(`Plugins:    ${info.plugins.length} installed`);
+  lines.push(
+    `  ${"NAME".padEnd(nameCol)}  ${"VERSION".padEnd(verCol)}  ${"API".padEnd(apiCol)}  STATUS`
+  );
+  for (const p of info.plugins) {
+    const status = p.compatible ? "OK" : `incompatible (core wants ${info.pluginApiVersion})`;
+    lines.push(
+      `  ${p.name.padEnd(nameCol)}  ${p.version.padEnd(verCol)}  ${p.apiVersion.padEnd(apiCol)}  ${status}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatJson(info) {
+  return JSON.stringify(info, null, 2);
+}
+var VersionCommand = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  projectRoot;
+  async run(options = {}) {
+    const info = await this.collect();
+    if (options.json) {
+      process.stdout.write(formatJson(info) + "\n");
+      return;
+    }
+    if (options.verbose) {
+      process.stdout.write(formatVerbose(info) + "\n");
+      return;
+    }
+    process.stdout.write(formatShort(info) + "\n");
+  }
+  async collect() {
+    const manifestPath = loadManifestPath(this.projectRoot);
+    if (!manifestPath) {
+      return gatherVersionInfo([]);
+    }
+    const { plugins } = await discoverPlugins({ manifestPath });
+    return gatherVersionInfo(plugins);
+  }
+};
+
+// src/adapters/diagnostics/checks/versions-check.ts
+var VersionsCheck = class {
+  id = "versions";
+  title = "Versions";
+  async run(ctx) {
+    const info = await collectInfo(ctx);
+    const incompatible = info.plugins.filter((p) => !p.compatible);
+    const message = buildSummary(info);
+    if (incompatible.length > 0) {
+      return {
+        id: this.id,
+        title: this.title,
+        status: "warn",
+        message,
+        fix: `Upgrade or replace plugins with apiVersion != ${info.pluginApiVersion}: ${incompatible.map((p) => p.name).join(", ")}`,
+        value: formatVerbose(info)
+      };
+    }
+    return {
+      id: this.id,
+      title: this.title,
+      status: "pass",
+      message,
+      value: formatVerbose(info)
+    };
+  }
+};
+async function collectInfo(ctx) {
+  const manifestPath = loadManifestPath(ctx.projectRoot);
+  if (!manifestPath) return gatherVersionInfo([]);
+  const { plugins } = await discoverPlugins({ manifestPath });
+  return gatherVersionInfo(plugins);
+}
+function buildSummary(info) {
+  const pluginCount = info.plugins.length;
+  const pluginLabel = pluginCount === 0 ? "no plugins" : `${pluginCount} plugin${pluginCount === 1 ? "" : "s"}`;
+  return `ctxo ${info.ctxo} (API ${info.pluginApiVersion}) \u2014 ${pluginLabel}, Node ${info.runtime.node}`;
+}
+
+// src/adapters/diagnostics/checks/language-coverage-check.ts
+import { createRequire as createRequire4 } from "module";
+var require3 = createRequire4(import.meta.url);
+var LanguageCoverageCheck = class {
+  id = "language_coverage";
+  title = "Language coverage";
+  async run(ctx) {
+    const detection = detectLanguages(ctx.projectRoot);
+    const needed = decideNeededLanguages(detection);
+    if (needed.length === 0) {
+      return {
+        id: this.id,
+        title: this.title,
+        status: "pass",
+        message: "no source languages detected"
+      };
+    }
+    const missing = [];
+    for (const lang of needed) {
+      if (!pluginResolves(officialPluginFor(lang))) {
+        missing.push(lang);
+      }
+    }
+    if (missing.length === 0) {
+      const summary = needed.map((l) => `${l}`).join(", ");
+      return {
+        id: this.id,
+        title: this.title,
+        status: "pass",
+        message: `plugins installed for: ${summary}`
+      };
+    }
+    const packages = missing.map(officialPluginFor).join(" ");
+    const shortList = missing.join(", ");
+    return {
+      id: this.id,
+      title: this.title,
+      status: "warn",
+      message: `missing plugins for: ${shortList}`,
+      fix: `Run "ctxo install ${missing.join(" ")}" or "npm install -D ${packages}"`
+    };
+  }
+};
+function pluginResolves(packageName) {
+  try {
+    require3.resolve(`${packageName}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/diagnostics/checks/git-check.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync13 } from "fs";
+import { join as join15 } from "path";
+var GitBinaryCheck = class {
+  id = "git_binary";
+  title = "Git available";
+  async run(_ctx) {
+    try {
+      const version = execFileSync4("git", ["--version"], { encoding: "utf-8" }).trim();
+      return { id: this.id, title: this.title, status: "pass", message: version, value: version };
+    } catch {
+      return { id: this.id, title: this.title, status: "fail", message: "git not found in PATH", fix: "Install git and ensure it is in your PATH" };
+    }
+  }
+};
+var GitRepoCheck = class {
+  id = "git_repo";
+  title = "Git repository";
+  async run(ctx) {
+    if (existsSync13(join15(ctx.projectRoot, ".git"))) {
+      return { id: this.id, title: this.title, status: "pass", message: ctx.projectRoot, value: ctx.projectRoot };
+    }
+    return { id: this.id, title: this.title, status: "fail", message: "Not a git repository", fix: 'Run "git init" or clone a repository' };
+  }
+};
+
+// src/adapters/diagnostics/checks/index-check.ts
+import { existsSync as existsSync14 } from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
+import { join as join16 } from "path";
+function pass2(id, title, message, value) {
+  return { id, title, status: "pass", message, value };
+}
+function warn2(id, title, message, fix, value) {
+  return { id, title, status: "warn", message, fix, value };
+}
+function fail(id, title, message, fix, value) {
+  return { id, title, status: "fail", message, fix, value };
+}
+function getIndices(ctx) {
+  return ctx.indices ?? new JsonIndexReader(ctx.ctxoRoot).readAll();
+}
+var IndexDirectoryCheck = class {
+  id = "index_directory";
+  title = "Index directory";
+  async run(ctx) {
+    const indexDir = join16(ctx.ctxoRoot, "index");
+    if (!existsSync14(indexDir)) {
+      return fail(this.id, this.title, "No index directory", 'Run "ctxo index"');
+    }
+    const indices = getIndices(ctx);
+    if (indices.length === 0) {
+      return fail(this.id, this.title, "Index directory empty", 'Run "ctxo index"');
+    }
+    return pass2(this.id, this.title, `${indices.length} files indexed`, String(indices.length));
+  }
+};
+var IndexFreshnessCheck = class {
+  id = "index_freshness";
+  title = "Index freshness";
+  async run(ctx) {
+    const indices = getIndices(ctx);
+    if (indices.length === 0) {
+      return fail(this.id, this.title, "No indexed files to check", 'Run "ctxo index"');
+    }
+    const indexedFiles = indices.map((idx) => idx.file);
+    const staleness = new StalenessDetector(ctx.projectRoot, ctx.ctxoRoot);
+    const warning = staleness.check(indexedFiles);
+    if (!warning) {
+      return pass2(this.id, this.title, `All ${indices.length} files fresh`, `0/${indices.length} stale`);
+    }
+    const staleCount = warning.staleFiles.length;
+    const pct = staleCount / indices.length;
+    const value = `${staleCount}/${indices.length} stale`;
+    if (pct <= 0.1) {
+      return warn2(this.id, this.title, `${staleCount} of ${indices.length} files stale`, 'Run "ctxo index"', value);
+    }
+    return fail(this.id, this.title, `${staleCount} of ${indices.length} files stale (${Math.round(pct * 100)}%)`, 'Run "ctxo index"', value);
+  }
+};
+var SymbolCountCheck = class {
+  id = "symbol_count";
+  title = "Symbol count";
+  async run(ctx) {
+    const indices = getIndices(ctx);
+    const total = indices.reduce((sum, idx) => sum + idx.symbols.length, 0);
+    if (total > 0) {
+      return pass2(this.id, this.title, `${total.toLocaleString()} symbols`, String(total));
+    }
+    return fail(this.id, this.title, "0 symbols (index empty)", 'Run "ctxo index"', "0");
+  }
+};
+var EdgeCountCheck = class {
+  id = "edge_count";
+  title = "Edge count";
+  async run(ctx) {
+    const indices = getIndices(ctx);
+    const total = indices.reduce((sum, idx) => sum + idx.edges.length, 0);
+    if (total > 0) {
+      return pass2(this.id, this.title, `${total.toLocaleString()} edges`, String(total));
+    }
+    return warn2(this.id, this.title, "0 edges (possible isolated files)", void 0, "0");
+  }
+};
+var OrphanedFilesCheck = class {
+  id = "orphaned_files";
+  title = "Orphaned index files";
+  async run(ctx) {
+    const indices = getIndices(ctx);
+    if (indices.length === 0) {
+      return pass2(this.id, this.title, "no index files to check");
+    }
+    const sourceFiles = this.getSourceFiles(ctx.projectRoot);
+    if (sourceFiles.size === 0) {
+      return pass2(this.id, this.title, "none (git ls-files unavailable)");
+    }
+    const orphaned = indices.filter((idx) => !sourceFiles.has(idx.file));
+    if (orphaned.length === 0) {
+      return pass2(this.id, this.title, "none", "0");
+    }
+    if (orphaned.length <= 5) {
+      return warn2(this.id, this.title, `${orphaned.length} orphaned index files`, "Delete orphaned files from .ctxo/index/", String(orphaned.length));
+    }
+    return fail(this.id, this.title, `${orphaned.length} orphaned index files`, "Delete orphaned files from .ctxo/index/", String(orphaned.length));
+  }
+  getSourceFiles(projectRoot) {
+    try {
+      const output = execFileSync5("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+        cwd: projectRoot,
+        encoding: "utf-8"
+      });
+      return new Set(output.split("\n").map((l) => l.trim()).filter((l) => l.length > 0));
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+};
+var CoChangesCacheCheck = class {
+  id = "co_changes_cache";
+  title = "Co-changes cache";
+  async run(ctx) {
+    const coChangesPath = join16(ctx.ctxoRoot, "index", "co-changes.json");
+    if (existsSync14(coChangesPath)) {
+      return pass2(this.id, this.title, "present");
+    }
+    return warn2(this.id, this.title, "missing (co-change analysis disabled)", 'Run "ctxo index" with git history');
+  }
+};
+var SchemaVersionCheck = class {
+  id = "schema_version";
+  title = "Schema version";
+  async run(ctx) {
+    const manager = new SchemaManager(ctx.ctxoRoot);
+    const stored = manager.readStoredVersion();
+    const current = manager.currentVersion();
+    if (!stored) {
+      return fail(this.id, this.title, "No schema version found", 'Run "ctxo index"');
+    }
+    if (manager.isCompatible()) {
+      return pass2(this.id, this.title, `${stored} (current)`, stored);
+    }
+    return fail(this.id, this.title, `${stored} (expected ${current})`, 'Run "ctxo index" to re-index with current schema', stored);
+  }
+};
+
+// src/adapters/diagnostics/checks/storage-check.ts
+import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
+import { join as join17 } from "path";
+var SqliteCacheCheck = class {
+  id = "sqlite_cache";
+  title = "SQLite cache";
+  async run(ctx) {
+    const dbPath = join17(ctx.ctxoRoot, ".cache", "symbols.db");
+    if (!existsSync15(dbPath)) {
+      return { id: this.id, title: this.title, status: "warn", message: "SQLite cache missing", fix: 'Run "ctxo sync" to rebuild' };
+    }
+    try {
+      const { default: initSqlJs2 } = await import("sql.js");
+      const SQL = await initSqlJs2();
+      const buffer = readFileSync10(dbPath);
+      const db = new SQL.Database(new Uint8Array(buffer));
+      const result = db.exec("PRAGMA integrity_check");
+      db.close();
+      const firstRow = result[0]?.values[0];
+      if (firstRow && firstRow[0] === "ok") {
+        return { id: this.id, title: this.title, status: "pass", message: "integrity_check passed" };
+      }
+      return { id: this.id, title: this.title, status: "fail", message: `SQLite corrupt: ${String(firstRow?.[0])}`, fix: 'Run "ctxo sync" to rebuild' };
+    } catch (err) {
+      return { id: this.id, title: this.title, status: "fail", message: `SQLite unreadable: ${err.message}`, fix: 'Run "ctxo sync" to rebuild' };
+    }
+  }
+};
+
+// src/adapters/diagnostics/checks/config-check.ts
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { join as join18 } from "path";
+var ConfigFileCheck = class {
+  id = "config_file";
+  title = "Config file";
+  async run(ctx) {
+    const configPath = join18(ctx.ctxoRoot, "config.yaml");
+    if (!existsSync16(configPath)) {
+      return { id: this.id, title: this.title, status: "warn", message: "No config.yaml (using defaults)" };
+    }
+    try {
+      const content = readFileSync11(configPath, "utf-8");
+      if (content.trim().length === 0) {
+        return { id: this.id, title: this.title, status: "warn", message: "config.yaml is empty (using defaults)" };
+      }
+      if (content.includes("	")) {
+        return { id: this.id, title: this.title, status: "fail", message: "Invalid config.yaml: tabs are not allowed in YAML", fix: "Replace tabs with spaces in .ctxo/config.yaml" };
+      }
+      return { id: this.id, title: this.title, status: "pass", message: ".ctxo/config.yaml valid" };
+    } catch (err) {
+      return { id: this.id, title: this.title, status: "fail", message: `Cannot read config.yaml: ${err.message}`, fix: "Check file permissions for .ctxo/config.yaml" };
+    }
+  }
+};
+
+// src/adapters/diagnostics/checks/disk-check.ts
+import { existsSync as existsSync17, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join19 } from "path";
+var DEFAULT_THRESHOLDS = { warnMb: 100, failMb: 500 };
+var DiskUsageCheck = class {
+  id = "disk_usage";
+  title = "Disk usage";
+  thresholds;
+  constructor(thresholds = DEFAULT_THRESHOLDS) {
+    this.thresholds = thresholds;
+  }
+  async run(ctx) {
+    if (!existsSync17(ctx.ctxoRoot)) {
+      return { id: this.id, title: this.title, status: "pass", message: "no .ctxo/ directory", value: "0" };
+    }
+    const bytes = this.getDirSize(ctx.ctxoRoot);
+    const mb = bytes / (1024 * 1024);
+    const formatted = mb < 1 ? `${Math.round(bytes / 1024)} KB` : `${mb.toFixed(1)} MB`;
+    if (mb < this.thresholds.warnMb) {
+      return { id: this.id, title: this.title, status: "pass", message: formatted, value: formatted };
+    }
+    if (mb < this.thresholds.failMb) {
+      return { id: this.id, title: this.title, status: "warn", message: `${formatted} \u2014 consider pruning orphaned index files`, value: formatted };
+    }
+    return { id: this.id, title: this.title, status: "fail", message: `${formatted} \u2014 unusually large`, fix: "Check for stale data in .ctxo/", value: formatted };
+  }
+  getDirSize(dirPath) {
+    let total = 0;
+    try {
+      const entries = readdirSync3(dirPath, { withFileTypes: true, recursive: true });
+      for (const entry of entries) {
+        if (entry.isFile()) {
+          try {
+            const parent = entry.parentPath ?? entry.path ?? dirPath;
+            total += statSync2(join19(parent, entry.name)).size;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return total;
+  }
+};
+
+// src/cli/doctor-fix.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import { appendFileSync, existsSync as existsSync18, mkdirSync as mkdirSync5, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname7, join as join20 } from "path";
+async function applyFixes(report, options) {
+  if (isCI(process.env) && !options.yes && !options.dryRun) {
+    return {
+      attempts: [],
+      halted: true,
+      reason: "CI environment detected; refuse to mutate without --yes"
+    };
+  }
+  const attempts = [];
+  const fixableIds = new Set(report.checks.filter((c) => c.status !== "pass").map((c) => c.id));
+  let configOk = true;
+  if (fixableIds.has("config_file")) {
+    const attempt = await run(
+      "Config",
+      "create from template",
+      () => fixConfig(options.projectRoot),
+      options
+    );
+    attempts.push(attempt);
+    configOk = attempt.status === "success" || attempt.status === "skipped" || attempt.status === "planned";
+  }
+  if (!configOk) {
+    return finish(attempts, options, true, "Config fix failed; halting before hooks/plugins/index");
+  }
+  if (fixableIds.has("git_hooks") || fixableIds.has("hooks")) {
+    attempts.push(
+      await run(
+        "Git hooks",
+        "re-install ctxo git hooks",
+        () => fixHooks(options.projectRoot),
+        options
+      )
+    );
+  }
+  let pluginsOk = true;
+  if (fixableIds.has("language_coverage") || hasMissingPlugins(options.projectRoot)) {
+    const attempt = await run(
+      "Language plugins",
+      "install missing @ctxo/lang-* packages",
+      () => fixLanguageCoverage(options.projectRoot, options.dryRun ?? false),
+      options
+    );
+    attempts.push(attempt);
+    pluginsOk = attempt.status === "success" || attempt.status === "skipped" || attempt.status === "planned";
+  }
+  if (pluginsOk) {
+    if (fixableIds.has("index_directory") || fixableIds.has("index_freshness") || fixableIds.has("symbol_count")) {
+      attempts.push(
+        await run(
+          "Index",
+          "rebuild JSON index",
+          () => fixIndex(options.projectRoot, options.dryRun ?? false),
+          options
+        )
+      );
+    }
+    if (fixableIds.has("orphaned_files")) {
+      attempts.push(
+        await run(
+          "Orphaned index files",
+          "delete index entries without a matching source file",
+          () => pruneOrphans(options.projectRoot, options.ctxoRoot, options.dryRun ?? false),
+          options
+        )
+      );
+    }
+  } else {
+    attempts.push({ name: "Index", action: "rebuild JSON index", status: "skipped", error: "plugin install failed" });
+  }
+  if (fixableIds.has("sqlite_cache") || fixableIds.has("schema_version") || fixableIds.has("co_changes_cache")) {
+    attempts.push(
+      await run(
+        "SQLite cache",
+        "delete .ctxo/.cache and resync",
+        () => fixSqliteCache(options.projectRoot, options.ctxoRoot, options.dryRun ?? false),
+        options
+      )
+    );
+  }
+  return finish(attempts, options, false);
+}
+function finish(attempts, options, halted, reason) {
+  writeLog(options.ctxoRoot, attempts, halted, reason);
+  return reason ? { attempts, halted, reason } : { attempts, halted };
+}
+async function run(name, action, body, options) {
+  if (options.dryRun) {
+    return { name, action, status: "planned" };
+  }
+  const start = Date.now();
+  try {
+    await body();
+    return { name, action, status: "success", durationMs: Date.now() - start };
+  } catch (err) {
+    return {
+      name,
+      action,
+      status: "failed",
+      durationMs: Date.now() - start,
+      error: err.message
+    };
+  }
+}
+async function fixConfig(projectRoot) {
+  const result = ensureConfig(projectRoot);
+  if (result.action === "skipped") {
+    return;
+  }
+}
+async function fixHooks(projectRoot) {
+  new InitCommand(projectRoot).installHooks();
+}
+function hasMissingPlugins(projectRoot) {
+  const detection = detectLanguages(projectRoot);
+  const needed = decideNeededLanguages(detection);
+  for (const lang of needed) {
+    if (!canResolvePlugin(lang)) return true;
+  }
+  return false;
+}
+async function fixLanguageCoverage(projectRoot, dryRun) {
+  const detection = detectLanguages(projectRoot);
+  const needed = decideNeededLanguages(detection);
+  const missing = needed.filter((lang) => !canResolvePlugin(lang));
+  if (missing.length === 0) return;
+  if (dryRun) return;
+  await new InstallCommand(projectRoot).run({ languages: missing, yes: true });
+}
+async function fixIndex(projectRoot, dryRun) {
+  if (dryRun) return;
+  await new IndexCommand(projectRoot).run({});
+}
+async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
+  if (dryRun) return;
+  const indexDir = join20(ctxoRoot, "index");
+  if (!existsSync18(indexDir)) return;
+  const sourceFiles = listGitFiles2(projectRoot);
+  if (sourceFiles.size === 0) return;
+  const reader = new JsonIndexReader(ctxoRoot);
+  const indices = reader.readAll();
+  let removed = 0;
+  for (const idx of indices) {
+    if (sourceFiles.has(idx.file)) continue;
+    const jsonPath = join20(indexDir, `${idx.file}.json`);
+    try {
+      if (existsSync18(jsonPath)) {
+        unlinkSync2(jsonPath);
+        removed += 1;
+        pruneEmptyParents(jsonPath, indexDir);
+      }
+    } catch {
+    }
+  }
+  if (removed === 0) return;
+}
+function pruneEmptyParents(filePath, stopAt) {
+  let dir = dirname7(filePath);
+  while (dir !== stopAt && dir.startsWith(stopAt)) {
+    try {
+      rmSync2(dir, { recursive: false });
+    } catch {
+      return;
+    }
+    dir = dirname7(dir);
+  }
+}
+function listGitFiles2(projectRoot) {
+  try {
+    const out = execFileSync6(
+      "git",
+      ["ls-files", "--cached", "--others", "--exclude-standard"],
+      { cwd: projectRoot, encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 }
+    );
+    return new Set(out.split("\n").filter(Boolean));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function fixSqliteCache(projectRoot, ctxoRoot, dryRun) {
+  const cacheDir = join20(ctxoRoot, ".cache");
+  if (dryRun) return;
+  if (existsSync18(cacheDir)) rmSync2(cacheDir, { recursive: true, force: true });
+  await new SyncCommand(projectRoot).run();
+}
+function canResolvePlugin(lang) {
+  try {
+    const { createRequire: createRequire5 } = __require("module");
+    const r = createRequire5(import.meta.url);
+    r.resolve(`${officialPluginFor(lang)}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCI(env) {
+  return env["CI"] === "true" || env["CI"] === "1";
+}
+function writeLog(ctxoRoot, attempts, halted, reason) {
+  try {
+    if (!existsSync18(ctxoRoot)) mkdirSync5(ctxoRoot, { recursive: true });
+    const path = join20(ctxoRoot, "doctor-fix.log");
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const lines = [`# ${ts} doctor --fix${halted ? " (halted: " + reason + ")" : ""}`];
+    for (const a of attempts) {
+      const dur = a.durationMs != null ? ` (${a.durationMs}ms)` : "";
+      const err = a.error ? ` \u2014 ${a.error}` : "";
+      lines.push(`- [${a.status}] ${a.name}: ${a.action}${dur}${err}`);
+    }
+    lines.push("");
+    appendFileSync(path, lines.join("\n"));
+  } catch {
+  }
+}
+function formatFixReport(report) {
+  const lines = [];
+  for (const a of report.attempts) {
+    const icon = a.status === "success" ? "\u2713" : a.status === "planned" ? "\xB7" : a.status === "skipped" ? "-" : "\u2717";
+    const dur = a.durationMs != null ? ` (${a.durationMs}ms)` : "";
+    const err = a.error ? ` \u2014 ${a.error}` : "";
+    lines.push(`  ${icon} ${a.name}: ${a.action}${dur}${err}`);
+  }
+  if (report.halted && report.reason) {
+    lines.push(`  ! halted: ${report.reason}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/doctor-command.ts
+var DoctorCommand = class {
+  projectRoot;
+  ctxoRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join21(projectRoot, ".ctxo");
+  }
+  async run(options = {}) {
+    const { getVersion: getVersion2 } = await import("./cli-router-RA4EBMVV.js");
+    console.error(`ctxo v${getVersion2()} \u2014 health check
+`);
+    const checks = [
+      new VersionsCheck(),
+      new NodeVersionCheck(),
+      new GitBinaryCheck(),
+      new GitRepoCheck(),
+      new IndexDirectoryCheck(),
+      new IndexFreshnessCheck(),
+      new SqliteCacheCheck(),
+      new ConfigFileCheck(),
+      new TsMorphCheck(),
+      new TreeSitterCheck(),
+      new LanguageCoverageCheck(),
+      new DiskUsageCheck(),
+      new SymbolCountCheck(),
+      new EdgeCountCheck(),
+      new OrphanedFilesCheck(),
+      new CoChangesCacheCheck(),
+      new SchemaVersionCheck()
+    ];
+    const indexDir = join21(this.ctxoRoot, "index");
+    const indices = existsSync19(indexDir) ? new JsonIndexReader(this.ctxoRoot).readAll() : [];
+    const checker = new HealthChecker(checks);
+    const report = await checker.runAll({
+      projectRoot: this.projectRoot,
+      ctxoRoot: this.ctxoRoot,
+      indices
+    });
+    const reporter = new DoctorReporter();
+    let output;
+    if (options.json) {
+      output = reporter.formatJson(report);
+      process.stdout.write(output + "\n");
+    } else if (options.quiet) {
+      output = reporter.formatQuiet(report);
+      console.error(output);
+    } else {
+      output = reporter.formatHuman(report);
+      console.error(output);
+    }
+    if (options.fix) {
+      console.error("");
+      console.error(options.dryRun ? "[ctxo] --fix --dry-run: planned actions" : "[ctxo] --fix: applying remediation");
+      const fixReport = await applyFixes(report, {
+        projectRoot: this.projectRoot,
+        ctxoRoot: this.ctxoRoot,
+        yes: options.yes,
+        dryRun: options.dryRun
+      });
+      console.error(formatFixReport(fixReport));
+      if (fixReport.halted) {
+        process.exitCode = 2;
+      }
+      return;
+    }
+    if (report.exitCode !== 0) {
+      process.exitCode = 1;
+    }
+  }
+};
+
+// src/cli/visualize-command.ts
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, existsSync as existsSync20 } from "fs";
+import { join as join22, basename } from "path";
+import { execFile } from "child_process";
+var VisualizeCommand = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.ctxoRoot = join22(projectRoot, ".ctxo");
+  }
+  projectRoot;
+  ctxoRoot;
+  async run(options = {}) {
+    const reader = new JsonIndexReader(this.ctxoRoot);
+    const indices = reader.readAll();
+    if (indices.length === 0) {
+      console.error('[ctxo] No index found. Run "ctxo index" first.');
+      process.exit(1);
+      return;
+    }
+    console.error(`[ctxo] Building graph from ${indices.length} files...`);
+    const graph = new SymbolGraph();
+    for (const fileIndex of indices) {
+      for (const sym of fileIndex.symbols) {
+        graph.addNode(sym);
+      }
+    }
+    for (const fileIndex of indices) {
+      for (const edge of fileIndex.edges) {
+        graph.addEdge(edge);
+      }
+    }
+    console.error(`[ctxo] Graph: ${graph.nodeCount} symbols, ${graph.edgeCount} edges`);
+    const pageRank = new PageRankCalculator();
+    const prResult = pageRank.calculate(graph, { limit: 1e5 });
+    const prMap = /* @__PURE__ */ new Map();
+    for (const entry of prResult.rankings) {
+      prMap.set(entry.symbolId, entry.score);
+    }
+    const deadDetector = new DeadCodeDetector();
+    const deadResult = deadDetector.detect(graph);
+    const deadMap = /* @__PURE__ */ new Map();
+    for (const d of deadResult.deadSymbols) {
+      deadMap.set(d.symbolId, { confidence: d.confidence, reason: d.reason });
+    }
+    const complexityMap = /* @__PURE__ */ new Map();
+    for (const fileIndex of indices) {
+      if (fileIndex.complexity) {
+        for (const c of fileIndex.complexity) {
+          complexityMap.set(c.symbolId, c.cyclomatic);
+        }
+      }
+    }
+    const antiPatternFiles = /* @__PURE__ */ new Set();
+    for (const fileIndex of indices) {
+      if (fileIndex.antiPatterns.length > 0) {
+        antiPatternFiles.add(fileIndex.file);
+      }
+    }
+    const filePaths = [...new Set(indices.map((i) => i.file))];
+    const overlay = new ArchitecturalOverlay();
+    const overlayResult = overlay.classify(filePaths);
+    const fileLayerMap = /* @__PURE__ */ new Map();
+    for (const [layer, files] of Object.entries(overlayResult.layers)) {
+      for (const file of files) {
+        fileLayerMap.set(file, layer);
+      }
+    }
+    const totalSymbols = graph.nodeCount;
+    let nodes = graph.allNodes().map((sym) => {
+      const file = sym.symbolId.split("::")[0] ?? "";
+      const dead = deadMap.get(sym.symbolId);
+      return {
+        id: sym.symbolId,
+        name: sym.name,
+        kind: sym.kind,
+        file,
+        startLine: sym.startLine,
+        layer: fileLayerMap.get(file) ?? "Unknown",
+        pageRank: prMap.get(sym.symbolId) ?? 0,
+        isDead: dead !== void 0,
+        ...dead ? { deadConfidence: dead.confidence, deadReason: dead.reason } : {},
+        cyclomatic: complexityMap.get(sym.symbolId),
+        hasAntiPattern: antiPatternFiles.has(file),
+        inDegree: graph.getReverseEdges(sym.symbolId).length,
+        outDegree: graph.getForwardEdges(sym.symbolId).length
+      };
+    });
+    if (options.maxNodes && nodes.length > options.maxNodes) {
+      nodes.sort((a, b) => b.pageRank - a.pageRank);
+      nodes = nodes.slice(0, options.maxNodes);
+    }
+    const nodeIds = new Set(nodes.map((n) => n.id));
+    const edges = graph.allEdges().filter((e) => nodeIds.has(e.from) && nodeIds.has(e.to)).map((e) => ({ source: e.from, target: e.to, kind: e.kind }));
+    const filesInfo = indices.filter((fi) => nodeIds.has(fi.symbols[0]?.symbolId ?? "___") || fi.symbols.some((s) => nodeIds.has(s.symbolId))).map((fi) => ({
+      file: fi.file,
+      intent: fi.intent.map((i) => ({ hash: i.hash, message: i.message, date: i.date })),
+      antiPatterns: fi.antiPatterns.map((a) => ({ hash: a.hash, message: a.message, date: a.date }))
+    }));
+    const payload = {
+      projectName: basename(this.projectRoot),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      totalSymbols,
+      shownSymbols: nodes.length,
+      nodes,
+      edges,
+      layers: overlayResult.layers,
+      files: filesInfo
+    };
+    const templatePath = this.getTemplatePath();
+    const template = readFileSync12(templatePath, "utf-8");
+    const html = template.replace("/*__CTXO_DATA__*/null", JSON.stringify(payload));
+    const outputPath = options.output ?? join22(this.ctxoRoot, "visualize.html");
+    writeFileSync6(outputPath, html, "utf-8");
+    console.error(`[ctxo] Wrote visualization to ${outputPath}`);
+    console.error(`[ctxo] ${nodes.length} symbols, ${edges.length} edges, ${deadResult.deadSymbols.length} dead`);
+    if (!options.noBrowser) {
+      this.openInBrowser(outputPath);
+    }
+  }
+  getTemplatePath() {
+    let dir = import.meta.dirname;
+    for (let i = 0; i < 10; i++) {
+      const candidate = join22(dir, "pages", "visualize-template.html");
+      if (existsSync20(candidate)) return candidate;
+      const parent = join22(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+    throw new Error("Could not find visualize-template.html. Ensure the pages/ directory exists.");
+  }
+  openInBrowser(filePath) {
+    const onError = (err) => {
+      if (err) {
+        console.error(`[ctxo] Could not open browser: ${err.message}`);
+        console.error(`[ctxo] Open manually: ${filePath}`);
+      }
+    };
+    if (process.platform === "win32") {
+      execFile("cmd.exe", ["/c", "start", "", filePath], onError);
+    } else if (process.platform === "darwin") {
+      execFile("open", [filePath], onError);
+    } else {
+      execFile("xdg-open", [filePath], onError);
+    }
+  }
+};
+
+// src/cli/cli-router.ts
+function getVersion() {
+  let dir = import.meta.dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join23(dir, "package.json");
+    if (existsSync21(pkg)) {
+      try {
+        const json = JSON.parse(readFileSync13(pkg, "utf-8"));
+        return json.version ?? "unknown";
+      } catch {
+        break;
+      }
+    }
+    const parent = join23(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+function locateGitRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 12; i++) {
+    if (existsSync21(join23(dir, ".git"))) return dir;
+    const parent = dirname8(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+var CliRouter = class {
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = locateGitRoot(projectRoot) ?? projectRoot;
+  }
+  async route(args) {
+    const command = args[0];
+    if (command === "--version" || command === "-v" || command === "-V") {
+      const verbose = args.includes("--verbose");
+      const json = args.includes("--json");
+      await new VersionCommand(this.projectRoot).run({ verbose, json });
+      return;
+    }
+    if (command === "version") {
+      const json = args.includes("--json");
+      const short = args.includes("--short");
+      await new VersionCommand(this.projectRoot).run({
+        verbose: !json && !short,
+        json
+      });
+      return;
+    }
+    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);
+          return;
+        }
+        const checkArg = args.includes("--check");
+        const skipHistory = args.includes("--skip-history");
+        const installMissing = args.includes("--install-missing");
+        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,
+          installMissing
+        });
+        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": {
+        const toolsIdx = args.indexOf("--tools");
+        const toolsArg = toolsIdx !== -1 ? args[toolsIdx + 1] : void 0;
+        const yesArg = args.includes("--yes") || args.includes("-y");
+        const rulesOnly = args.includes("--rules");
+        const dryRun = args.includes("--dry-run");
+        const noInstall = args.includes("--no-install");
+        const tools = toolsArg ? toolsArg.split(",").map((t) => t.trim()) : void 0;
+        await new InitCommand(this.projectRoot).run({ tools, yes: yesArg, rulesOnly, dryRun, noInstall });
+        break;
+      }
+      case "stats": {
+        const daysIdx = args.indexOf("--days");
+        const daysArg = daysIdx !== -1 ? Number(args[daysIdx + 1]) : void 0;
+        const jsonArg = args.includes("--json");
+        const clearArg = args.includes("--clear");
+        await new StatsCommand(this.projectRoot).run({ days: daysArg, json: jsonArg, clear: clearArg });
+        break;
+      }
+      case "doctor": {
+        const jsonArg = args.includes("--json");
+        const quietArg = args.includes("--quiet");
+        const fixArg = args.includes("--fix");
+        const dryRunArg = args.includes("--dry-run");
+        const yesArg = args.includes("--yes") || args.includes("-y");
+        await new DoctorCommand(this.projectRoot).run({
+          json: jsonArg,
+          quiet: quietArg,
+          fix: fixArg,
+          dryRun: dryRunArg,
+          yes: yesArg
+        });
+        break;
+      }
+      case "install": {
+        const languages = [];
+        const flagValues = {};
+        for (let i = 1; i < args.length; i++) {
+          const a = args[i];
+          if (a === "--yes" || a === "-y") flagValues["yes"] = true;
+          else if (a === "--global" || a === "-g") flagValues["global"] = true;
+          else if (a === "--dry-run") flagValues["dryRun"] = true;
+          else if (a === "--force") flagValues["force"] = true;
+          else if (a === "--pm") {
+            const next = args[++i];
+            if (!next) {
+              console.error("[ctxo] --pm requires a value");
+              process.exit(1);
+              return;
+            }
+            flagValues["pm"] = next;
+          } else if (a === "--version") {
+            const next = args[++i];
+            if (!next) {
+              console.error("[ctxo] --version requires a value");
+              process.exit(1);
+              return;
+            }
+            flagValues["version"] = next;
+          } else if (a.startsWith("--")) {
+            console.error(`[ctxo] Unknown install flag: ${a}`);
+            process.exit(1);
+            return;
+          } else {
+            languages.push(a);
+          }
+        }
+        await new InstallCommand(this.projectRoot).run({
+          languages,
+          yes: flagValues["yes"] === true,
+          global: flagValues["global"] === true,
+          dryRun: flagValues["dryRun"] === true,
+          force: flagValues["force"] === true,
+          pm: typeof flagValues["pm"] === "string" ? flagValues["pm"] : void 0,
+          version: typeof flagValues["version"] === "string" ? flagValues["version"] : void 0
+        });
+        break;
+      }
+      case "visualize": {
+        const outputIdx = args.indexOf("--output");
+        const outputArg = outputIdx !== -1 ? args[outputIdx + 1] : void 0;
+        const maxNodesIdx = args.indexOf("--max-nodes");
+        const maxNodesArg = maxNodesIdx !== -1 ? Number(args[maxNodesIdx + 1]) : void 0;
+        const noBrowser = args.includes("--no-browser");
+        if (maxNodesIdx !== -1 && (!maxNodesArg || isNaN(maxNodesArg) || maxNodesArg < 1)) {
+          console.error("[ctxo] --max-nodes requires a positive integer");
+          process.exit(1);
+          return;
+        }
+        await new VisualizeCommand(this.projectRoot).run({ output: outputArg, maxNodes: maxNodesArg, noBrowser });
+        break;
+      }
+      default:
+        console.error(`[ctxo] Unknown command: "${command}". Run "ctxo --help" for usage.`);
+        process.exit(1);
+        return;
+    }
+  }
+  printHelp() {
+    const v = getVersion();
+    console.error(`
+ctxo v${v} \u2014 MCP server for dependency-aware codebase context
+
+Usage:
+  ctxo                      Start MCP server (stdio transport)
+  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
+  ctxo status               Show index manifest
+  ctxo init                 Interactive setup (tools, rules, hooks)
+  ctxo init --rules         Regenerate AI tool rules only
+  ctxo init --tools a,b -y  Non-interactive (claude-code,cursor,...)
+  ctxo init --dry-run       Preview what would be created
+  ctxo stats                Show usage statistics (--json, --days N, --clear)
+  ctxo doctor               Health check all subsystems (--json, --quiet)
+  ctxo visualize            Generate interactive dependency graph HTML
+  ctxo visualize --max-nodes N   Limit to top N symbols by PageRank
+  ctxo visualize --output PATH   Write HTML to custom path
+  ctxo visualize --no-browser    Skip auto-opening browser
+  ctxo install [<lang>...]  Install language plugins (detects if omitted)
+  ctxo install python -y    Batch install, no prompt
+  ctxo install ts --global  Install globally
+  ctxo install py --dry-run Show command without running
+  ctxo --version                 Print core version
+  ctxo --version --verbose       Print core + plugins + runtime
+  ctxo --version --json          Machine-readable version payload
+  ctxo version                   Subcommand \u2014 verbose by default
+  ctxo --help               Show this help message
+`.trim());
+  }
+};
+export {
+  CliRouter,
+  getVersion,
+  locateGitRoot
+};
+//# sourceMappingURL=cli-router-RA4EBMVV.js.map