ctxloom-pro 1.5.6 → 1.7.1

package/dist/{chunk-JULFFD7O.js → chunk-7S2ELKNU.js}

@@ -1,3 +1,7 @@
+import {
+  EMBEDDING_DIMENSION,
+  EMBEDDING_MODEL_ID
+} from "./chunk-6FGTNOCP.js";
 import {
   logger
 } from "./chunk-TYDMSHV7.js";
@@ -34,8 +38,12 @@ var VectorStore = class {
       fs.mkdirSync(dir, { recursive: true });
     }
     const lancedb = await import("@lancedb/lancedb");
+    const lanceModule = lancedb.default ?? lancedb;
+    const lance = lanceModule;
     const { makeArrowTable } = lancedb;
-    this.db = await lancedb.default.connect(this.dbPath);
+    this.db = await lance.connect(this.dbPath);
+    const markerPath = path.join(path.dirname(this.dbPath), "embedding-model.json");
+    this.assertModelCompatibility(markerPath);
     const existingTables = await this.db.tableNames();
     if (existingTables.includes("code_embeddings")) {
       this.table = await this.db.openTable("code_embeddings");
@@ -44,7 +52,7 @@ var VectorStore = class {
         {
           id: "__seed__",
           filePath: "__seed__",
-          vector: new Array(384).fill(0),
+          vector: new Array(EMBEDDING_DIMENSION).fill(0),
           content: ""
         }
       ]);
@@ -53,6 +61,47 @@ var VectorStore = class {
     }
     this.initialized = true;
   }
+  /**
+   * Compare the active embedding model against the marker file written
+   * when the index was first built. Three cases:
+   *
+   *   1. Marker missing  → legacy index (pre-v1.7.0). Assume MiniLM
+   *      and write the marker so future runs are guarded.
+   *   2. Marker matches  → proceed silently.
+   *   3. Marker differs  → throw with a clear migration instruction.
+   *      We don't auto-wipe — silently dropping a user's index because
+   *      they set an env var is exactly the footgun the marker exists
+   *      to prevent.
+   */
+  assertModelCompatibility(markerPath) {
+    const active = { model: EMBEDDING_MODEL_ID, dim: EMBEDDING_DIMENSION };
+    let existing = null;
+    if (fs.existsSync(markerPath)) {
+      try {
+        existing = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+      } catch (err) {
+        logger.warn("Embedding-model marker is corrupt; treating as missing", {
+          path: markerPath,
+          detail: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    if (!existing) {
+      fs.writeFileSync(markerPath, JSON.stringify(active, null, 2));
+      return;
+    }
+    if (existing.model === active.model && existing.dim === active.dim) {
+      return;
+    }
+    throw new Error(
+      `Embedding-model mismatch: vector index at ${this.dbPath} was built with "${existing.model}" (${existing.dim}-dim) but the active model is "${active.model}" (${active.dim}-dim). Re-index required:
+
+    ctxloom vectors-cleanup --reset
+    ctxloom index
+
+Or revert CTXLOOM_EMBEDDING_MODEL to "${existing.model}" to keep the existing index.`
+    );
+  }
   /**
    * Release LanceDB resources (file descriptors held by the underlying
    * connection / table handles). Must be called at the end of long-lived
@@ -101,6 +150,48 @@ var VectorStore = class {
       await this.compact();
     }
   }
+  /**
+   * Batch upsert — one LanceDB transaction for N file records.
+   *
+   * Why this exists (v1.7.0 monorepo support): the per-file `upsert()`
+   * does 2 LanceDB transactions (delete + add). On a 50k-file repo
+   * that's 100k transactions, each writing a manifest + transaction
+   * file. Compaction reclaims them every 200 upserts, but during the
+   * indexing burst the FD churn is enormous (observed: ~10k FDs/sec
+   * peak on Next.js, hitting the 256-default macOS process limit).
+   *
+   * With BATCH_SIZE=50 callers (the streaming indexer), this drops to
+   * ~2k transactions across the same corpus — 50× fewer manifests
+   * written, ~5× faster wall time, and the FD ceiling stops mattering.
+   *
+   * Compaction semantics unchanged: `upsertsSinceCompact` increments by
+   * one per RECORD (not per batch), so the compact trigger fires at
+   * the same total-record cadence as the per-file path.
+   */
+  async upsertBatch(records) {
+    if (!this.table) throw new Error("VectorStore not initialized. Call init() first.");
+    if (records.length === 0) return;
+    const filter = records.map((r) => `filePath = '${sanitizeFilterPath(r.filePath)}'`).join(" OR ");
+    try {
+      await this.table.delete(filter);
+    } catch (err) {
+      logger.warn("Batch delete before upsert failed, continuing", {
+        detail: err instanceof Error ? err.message : String(err)
+      });
+    }
+    const rows = records.map((r) => ({
+      id: r.filePath,
+      filePath: r.filePath,
+      vector: r.embedding,
+      content: r.content.slice(0, 512)
+    }));
+    await this.table.add(rows);
+    this.upsertsSinceCompact += records.length;
+    if (this.upsertsSinceCompact >= this.compactEvery) {
+      this.upsertsSinceCompact = 0;
+      await this.compact();
+    }
+  }
   /**
    * Merge fragments and prune old LanceDB versions. Idempotent and safe to
    * call mid-flight; the Table API serializes writes internally. Called
@@ -131,6 +222,35 @@ var VectorStore = class {
       });
     }
   }
+  /**
+   * Retrieve the stored embedding for a known file. Returns null if the
+   * file isn't indexed. Used by blast-radius semantic-similarity search
+   * (v1.6.x) to find files semantically related to a seed without
+   * re-embedding the seed at query time.
+   */
+  async findEmbeddingByPath(filePath) {
+    if (!this.table) throw new Error("VectorStore not initialized. Call init() first.");
+    try {
+      const safe = sanitizeFilterPath(filePath);
+      const rows = await this.table.query().where(`filePath = '${safe}'`).limit(1).toArray();
+      const first = rows[0];
+      if (!first) return null;
+      const vec = first.vector;
+      if (vec === null || vec === void 0) return null;
+      if (Array.isArray(vec)) return vec;
+      if (vec instanceof Float32Array) return Array.from(vec);
+      if (typeof vec.length === "number") {
+        return Array.from(vec);
+      }
+      return null;
+    } catch (err) {
+      logger.warn("VectorStore.findEmbeddingByPath failed", {
+        detail: err instanceof Error ? err.message : String(err),
+        filePath
+      });
+      return null;
+    }
+  }
   /**
    * Search for the top-K most similar code records using vector search.
    */
@@ -187,4 +307,4 @@ var VectorStore = class {
 export {
   VectorStore
 };
-//# sourceMappingURL=chunk-JULFFD7O.js.map
+//# sourceMappingURL=chunk-7S2ELKNU.js.map

package/dist/{chunk-II2DPYRJ.js → chunk-YHLMQVBV.js}

@@ -15,6 +15,15 @@ var CTXLOOM_SERVER = {
   args: ["-y", "ctxloom"],
   env: {}
 };
+function tomlString(s) {
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\x00-\x1f\x7f]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+  return `"${escaped}"`;
+}
+function yamlEscape(s) {
+  if (/^[A-Za-z0-9_./-][A-Za-z0-9_./@-]*$/.test(s)) return s;
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
 var _serverEntry;
 function getServerEntry() {
   if (_serverEntry) return _serverEntry;
@@ -55,9 +64,16 @@ var MCP_CLIENTS = [
     id: "cursor",
     name: "Cursor",
     description: "Cursor AI code editor",
+    // Vendor docs (Cursor team, verified 2026-05) list TWO canonical paths:
+    //   - `<repo>/.cursor/mcp.json` (project-scoped — the documented default)
+    //   - `~/.cursor/mcp.json`       (user-scoped, applies to every project)
+    // The XDG-style paths in the old list were speculative; Cursor never
+    // shipped them. Project-root scope goes FIRST so a per-project install
+    // matches the canonical workflow before we touch the user-wide config.
     configPaths: [
-      path.join(xdgConfig(), "Cursor", "User", "globalStorage", "cursor-mcp", "mcp.json"),
+      path.join(process.cwd(), ".cursor", "mcp.json"),
       path.join(HOME, ".cursor", "mcp.json"),
+      path.join(xdgConfig(), "Cursor", "User", "globalStorage", "cursor-mcp", "mcp.json"),
       path.join(xdgConfig(), "Cursor", "mcp.json")
     ],
     cliBinaries: ["cursor"],
@@ -124,23 +140,41 @@ var MCP_CLIENTS = [
     serversPath: "mcpServers"
   },
   // ─── Continue.dev ───────────────────────────────────────
+  // v1.7.0 fix: current Continue (2026+) uses **per-server YAML files**
+  // at `.continue/mcpServers/<name>.yaml` (workspace-scoped), NOT the
+  // old `~/.continue/config.json` with embedded `experimental.mcpServers`.
+  // Writing to the old path silently fails on current Continue — the
+  // file is parsed but the section is ignored. Verified against
+  // docs.continue.dev/customize/deep-dives/mcp (2026-05).
+  //
+  // The customWriter renders the entire YAML file because each MCP
+  // server gets its own file; there's no merge step.
   {
     id: "continue",
     name: "Continue.dev",
     description: "Continue open-source AI code assistant",
+    // Workspace-scoped path FIRST (the canonical/correct path on
+    // current Continue). Legacy user-scoped paths kept as detection
+    // fallback so we still detect Continue's presence on machines
+    // that haven't migrated their config yet.
     configPaths: [
+      path.join(process.cwd(), ".continue", "mcpServers", "ctxloom.yaml"),
       path.join(HOME, ".continue", "config.json"),
       path.join(xdgConfig(), "continue", "config.json")
     ],
     cliBinaries: ["continue"],
     appBundles: [],
     usesMcpServersFormat: false,
-    serversPath: "experimental.mcpServers",
-    formatConfig: (entry) => ({
-      command: entry.command,
-      args: entry.args,
-      transport: "stdio"
-    })
+    serversPath: "mcpServers",
+    customWriter: (_targetPath, entry, _existingContent) => {
+      const envLines = entry.env && Object.keys(entry.env).length > 0 ? "\n    env:\n" + Object.entries(entry.env).map(([k, v]) => `      ${k}: ${yamlEscape(v)}`).join("\n") : "";
+      const argsLines = entry.args && entry.args.length > 0 ? "\n    args:\n" + entry.args.map((a) => `      - ${yamlEscape(a)}`).join("\n") : "\n    args: []";
+      return `# Generated by \`ctxloom setup\` \u2014 Continue MCP server registration.
+# Format: docs.continue.dev/customize/deep-dives/mcp
+mcpServers:
+  - name: ctxloom
+    command: ${yamlEscape(entry.command)}` + argsLines + envLines + "\n";
+    }
   },
   // ─── Aider ──────────────────────────────────────────────
   {
@@ -157,18 +191,83 @@ var MCP_CLIENTS = [
     serversPath: "mcpServers"
   },
   // ─── Codex CLI (OpenAI) ─────────────────────────────────
+  // v1.7.0 fix: current Codex (2026+) uses **TOML at config.toml**,
+  // NOT JSON at mcp.json. The schema key is `mcp_servers` (snake_case
+  // TOML), NOT `mcpServers`. Writing JSON to the old `.codex/mcp.json`
+  // path silently fails on current Codex — the file is never read.
+  // Verified against developers.openai.com/codex/config-reference
+  // (2026-05).
+  //
+  // config.toml is SHARED with other Codex settings (model selection,
+  // auth, sandbox prefs), so the writer reads existing content,
+  // appends/updates ONLY the `[mcp_servers.ctxloom]` block, and
+  // preserves everything else. We deliberately avoid pulling in a
+  // TOML parser library — the only mutation is a single named-table
+  // block, which append-or-replace by string match handles safely.
   {
     id: "codex",
     name: "Codex CLI",
     description: "OpenAI Codex CLI agent",
+    // Workspace path FIRST (canonical per Codex docs); user-scoped
+    // path second (preserves detection on machines with Codex
+    // installed but no project-local config yet).
     configPaths: [
+      path.join(process.cwd(), ".codex", "config.toml"),
+      path.join(HOME, ".codex", "config.toml"),
+      // Legacy detection only — won't be written to. Kept so users
+      // who created these in earlier ctxloom versions still get
+      // detected (they need to migrate, but at least we surface them).
       path.join(HOME, ".codex", "mcp.json"),
       path.join(xdgConfig(), "codex", "mcp.json")
     ],
     cliBinaries: ["codex"],
     appBundles: [],
-    usesMcpServersFormat: true,
-    serversPath: "mcpServers"
+    usesMcpServersFormat: false,
+    serversPath: "mcp_servers",
+    customInstalledCheck: (target) => {
+      try {
+        const content = fs.readFileSync(target, "utf-8");
+        return /^\s*\[mcp_servers\.ctxloom\]\s*$/m.test(content);
+      } catch {
+        return false;
+      }
+    },
+    customWriter: (_targetPath, entry, existingContent) => {
+      const lines = [
+        "# ctxloom \u2014 added by `ctxloom setup`. Safe to edit; the",
+        "# installer only ever modifies the [mcp_servers.ctxloom]",
+        "# block and never touches the rest of this file.",
+        "[mcp_servers.ctxloom]",
+        `command = ${tomlString(entry.command)}`,
+        `args = [${(entry.args ?? []).map(tomlString).join(", ")}]`
+      ];
+      if (entry.env && Object.keys(entry.env).length > 0) {
+        lines.push("");
+        lines.push("[mcp_servers.ctxloom.env]");
+        for (const [k, v] of Object.entries(entry.env)) {
+          lines.push(`${k} = ${tomlString(v)}`);
+        }
+      }
+      const newBlock = lines.join("\n") + "\n";
+      if (!existingContent) {
+        return newBlock;
+      }
+      const blockRegex = /(^|\n)(?:#[^\n]*\n)*\[mcp_servers\.ctxloom\][\s\S]*?(?=\n\[(?!mcp_servers\.ctxloom)|$)/;
+      if (blockRegex.test(existingContent)) {
+        return existingContent.replace(
+          blockRegex,
+          (_m, leading) => (leading === "\n" ? "\n" : "") + newBlock.trimEnd()
+        );
+      }
+      const sep = existingContent.endsWith("\n") ? "\n" : "\n\n";
+      return existingContent + sep + newBlock;
+    },
+    customRemove: (existingContent) => {
+      const blockWithLeadingComments = /(^|\n)(?:#[^\n]*\n)*\[mcp_servers\.ctxloom\][\s\S]*?(?=\n\[(?!mcp_servers\.ctxloom)|$)/;
+      const stripped = existingContent.replace(blockWithLeadingComments, (_m, leading) => leading);
+      if (stripped.trim() === "") return null;
+      return stripped;
+    }
   },
   // ─── Kimi ───────────────────────────────────────────────
   {
@@ -210,6 +309,77 @@ var MCP_CLIENTS = [
     appBundles: ["com.jetbrains.intellij"],
     usesMcpServersFormat: true,
     serversPath: "mcpServers"
+  },
+  // ─── Zed ────────────────────────────────────────────────
+  // Zed's MCP config lives under the main settings.json, NOT a
+  // dedicated mcp.json. Critical wrinkle: the key is `context_servers`,
+  // not the conventional `mcpServers` — silently ignored otherwise.
+  // Verified against zed.dev/docs/ai/mcp (2026-05).
+  {
+    id: "zed",
+    name: "Zed",
+    description: "Zed high-performance code editor",
+    configPaths: [
+      path.join(xdgConfig(), "zed", "settings.json"),
+      path.join(HOME, ".config", "zed", "settings.json")
+    ],
+    cliBinaries: ["zed"],
+    appBundles: ["dev.zed.Zed", "dev.zed.Zed-Preview"],
+    usesMcpServersFormat: true,
+    serversPath: "context_servers"
+  },
+  // ─── Gemini CLI ─────────────────────────────────────────
+  // Google's Gemini CLI tool. Workspace config wins over user config
+  // when both exist; we list the workspace path first so a project
+  // install lands where the user expects. Schema is standard
+  // `mcpServers` per google-gemini/gemini-cli docs/cli/settings.md.
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    description: "Google Gemini command-line AI agent",
+    configPaths: [
+      path.join(process.cwd(), ".gemini", "settings.json"),
+      path.join(HOME, ".gemini", "settings.json")
+    ],
+    cliBinaries: ["gemini"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── Kiro ───────────────────────────────────────────────
+  // Kiro IDE (kiro.dev). Both workspace + user configs are honored;
+  // workspace overrides user per Kiro's docs. Schema is standard
+  // `mcpServers`.
+  {
+    id: "kiro",
+    name: "Kiro",
+    description: "Kiro AI-first IDE",
+    configPaths: [
+      path.join(process.cwd(), ".kiro", "settings", "mcp.json"),
+      path.join(HOME, ".kiro", "settings", "mcp.json")
+    ],
+    cliBinaries: ["kiro"],
+    appBundles: ["dev.kiro.Kiro"],
+    usesMcpServersFormat: true,
+    serversPath: "mcpServers"
+  },
+  // ─── OpenCode ───────────────────────────────────────────
+  // Project-root configured. Critical wrinkle: the key is `mcp`
+  // (not `mcpServers`) — code-review-graph's PLATFORMS dict had
+  // this wrong; verified against opencode.ai/docs/mcp-servers.
+  // Supports both .json and .jsonc extensions.
+  {
+    id: "opencode",
+    name: "OpenCode",
+    description: "OpenCode agentic coding tool",
+    configPaths: [
+      path.join(process.cwd(), "opencode.json"),
+      path.join(process.cwd(), "opencode.jsonc")
+    ],
+    cliBinaries: ["opencode"],
+    appBundles: [],
+    usesMcpServersFormat: true,
+    serversPath: "mcp"
   }
 ];
 function detectInstalledClients() {
@@ -224,6 +394,12 @@ function detectInstalledClients() {
         detected = true;
         configPath = cp;
         configExists = true;
+        if (client.customWriter) {
+          if (cp === client.configPaths[0]) {
+            alreadyConfigured = client.customInstalledCheck ? client.customInstalledCheck(cp) : true;
+          }
+          break;
+        }
         try {
           const content = fs.readFileSync(cp, "utf-8");
           const config = JSON.parse(content);
@@ -314,6 +490,20 @@ function addCtxloomToConfig(detected) {
   if (alreadyConfigured) {
     return { success: true, message: `ctxloom is already configured in ${client.name}` };
   }
+  if (client.customWriter) {
+    const targetPath = client.configPaths[0];
+    const serverEntry2 = getServerEntry();
+    const existingContent = fs.existsSync(targetPath) ? fs.readFileSync(targetPath, "utf-8") : null;
+    const content = client.customWriter(targetPath, serverEntry2, existingContent);
+    const dir2 = path.dirname(targetPath);
+    if (!fs.existsSync(dir2)) fs.mkdirSync(dir2, { recursive: true });
+    try {
+      fs.writeFileSync(targetPath, content, "utf-8");
+      return { success: true, message: `Added ctxloom to ${client.name} (${targetPath})` };
+    } catch (err) {
+      return { success: false, message: `Failed to write config at ${targetPath}: ${err}` };
+    }
+  }
   let config;
   if (configExists) {
     try {
@@ -349,4 +539,4 @@ export {
   detectInstalledClients,
   addCtxloomToConfig
 };
-//# sourceMappingURL=chunk-II2DPYRJ.js.map
+//# sourceMappingURL=chunk-YHLMQVBV.js.map

package/dist/embedder-2JWDJUE2.js

@@ -0,0 +1,26 @@
+import {
+  EMBEDDING_DIMENSION,
+  EMBEDDING_MODEL_ID,
+  INDEXER_IGNORED_DIRS,
+  collectFiles,
+  collectFilesStream,
+  generateEmbedding,
+  generateEmbeddingBatch,
+  getActiveEmbeddingModel,
+  indexDirectory,
+  resolveEmbeddingModel
+} from "./chunk-6FGTNOCP.js";
+import "./chunk-TYDMSHV7.js";
+export {
+  EMBEDDING_DIMENSION,
+  EMBEDDING_MODEL_ID,
+  INDEXER_IGNORED_DIRS,
+  collectFiles,
+  collectFilesStream,
+  generateEmbedding,
+  generateEmbeddingBatch,
+  getActiveEmbeddingModel,
+  indexDirectory,
+  resolveEmbeddingModel
+};
+//# sourceMappingURL=embedder-2JWDJUE2.js.map

package/dist/index.js

@@ -47,18 +47,18 @@ import {
   validateDefaultRoot,
   wrapWithIndexingEnvelope,
   writeCODEOWNERS
-} from "./chunk-FPMNXF4D.js";
+} from "./chunk-6W4DFPP2.js";
 import {
   addCtxloomToConfig,
   detectInstalledClients
-} from "./chunk-II2DPYRJ.js";
+} from "./chunk-YHLMQVBV.js";
 import {
   VectorStore
-} from "./chunk-JULFFD7O.js";
+} from "./chunk-7S2ELKNU.js";
 import {
   generateEmbedding,
   indexDirectory
-} from "./chunk-WDX4PJGL.js";
+} from "./chunk-6FGTNOCP.js";
 import "./chunk-5I6CJITG.js";
 import {
   logger
@@ -1039,7 +1039,7 @@ try {
 } catch {
 }
 var args = process.argv.slice(2);
-var ctxloomVersion = "1.5.6".length > 0 ? "1.5.6" : "dev";
+var ctxloomVersion = "1.7.1".length > 0 ? "1.7.1" : "dev";
 if (args.includes("--version") || args.includes("-v")) {
   process.stdout.write(`ctxloom ${ctxloomVersion}
 `);
@@ -1112,7 +1112,7 @@ async function checkLicense() {
   if (command !== void 0 && LICENSE_GATE_BYPASS_COMMANDS.has(command)) return;
   const ciKey = process.env["CTXLOOM_LICENSE_KEY"];
   if (ciKey) {
-    const { ApiClient } = await import("./src-DL44T55H.js");
+    const { ApiClient } = await import("./src-FQQOURSD.js");
     const client = new ApiClient(process.env["CTXLOOM_API_BASE"]);
     try {
       const result = await client.validate(ciKey, "ci-ephemeral");
@@ -1490,7 +1490,7 @@ async function main() {
         }
         if (!skipHarness) {
           process.stdout.write("\n");
-          const { installHarness } = await import("./src-DL44T55H.js");
+          const { installHarness } = await import("./src-FQQOURSD.js");
           const h = installHarness({ cwd: initRoot, dryRun, force, extraHosts });
           const harnessFiles = [
             h.claudeMd,
@@ -1553,7 +1553,7 @@ async function main() {
         process.exit(1);
       }
       if (alias !== void 0) {
-        const { validateAlias } = await import("./src-DL44T55H.js");
+        const { validateAlias } = await import("./src-FQQOURSD.js");
         const v = validateAlias(alias);
         if (!v.ok) {
           console.error(`[ctxloom] Invalid alias: ${v.reason}`);
@@ -1912,7 +1912,7 @@ Suggested reviewers for ${files.length} file(s):`);
         process.stderr.write("[ctxloom] --limit must be a non-negative integer (0 for unlimited)\n");
         process.exit(2);
       }
-      const { loadRulesConfig, RulesChecker, formatText, formatJson, RulesConfigError } = await import("./src-DL44T55H.js");
+      const { loadRulesConfig, RulesChecker, formatText, formatJson, RulesConfigError } = await import("./src-FQQOURSD.js");
       let config;
       try {
         config = await loadRulesConfig(root);
@@ -1936,7 +1936,7 @@ Suggested reviewers for ${files.length} file(s):`);
       }
       let graph;
       if (useSnapshot) {
-        const { DependencyGraph: DG } = await import("./src-DL44T55H.js");
+        const { DependencyGraph: DG } = await import("./src-FQQOURSD.js");
         graph = new DG();
         const loaded = await graph.loadSnapshotOnly(root);
         if (!loaded) {
@@ -1945,7 +1945,7 @@ Suggested reviewers for ${files.length} file(s):`);
         }
       } else {
         process.stderr.write("[ctxloom] Building dependency graph...\n");
-        const { ASTParser: ASTParser2, DependencyGraph: DependencyGraph2 } = await import("./src-DL44T55H.js");
+        const { ASTParser: ASTParser2, DependencyGraph: DependencyGraph2 } = await import("./src-FQQOURSD.js");
         let parser;
         try {
           parser = new ASTParser2();

package/dist/setup/postinstall.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   detectInstalledClients
-} from "../chunk-II2DPYRJ.js";
+} from "../chunk-YHLMQVBV.js";
 
 // src/setup/postinstall.ts
 var C = {

package/dist/{src-DL44T55H.js → src-FQQOURSD.js}

@@ -65,6 +65,7 @@ import {
   computeBlockHmac,
   computeRiskBreakdown,
   computeRiskCaps,
+  computeSemanticSimilar,
   createProjectState,
   createToolRegistry,
   deactivateLicense,
@@ -131,16 +132,16 @@ import {
   wrapBlock,
   wrapWithIndexingEnvelope,
   writeCODEOWNERS
-} from "./chunk-FPMNXF4D.js";
+} from "./chunk-6W4DFPP2.js";
 import {
   VectorStore
-} from "./chunk-JULFFD7O.js";
+} from "./chunk-7S2ELKNU.js";
 import {
   EMBEDDING_DIMENSION,
   collectFiles,
   generateEmbedding,
   indexDirectory
-} from "./chunk-WDX4PJGL.js";
+} from "./chunk-6FGTNOCP.js";
 import {
   filenameForDate,
   readEvents,
@@ -223,6 +224,7 @@ export {
   computeBlockHmac,
   computeRiskBreakdown,
   computeRiskCaps,
+  computeSemanticSimilar,
   createProjectState,
   createToolRegistry,
   deactivateLicense,
@@ -298,4 +300,4 @@ export {
   wrapWithIndexingEnvelope,
   writeCODEOWNERS
 };
-//# sourceMappingURL=src-DL44T55H.js.map
+//# sourceMappingURL=src-FQQOURSD.js.map

package/dist/workers/indexerWorker.js

@@ -1,9 +1,9 @@
 import {
   VectorStore
-} from "../chunk-JULFFD7O.js";
+} from "../chunk-7S2ELKNU.js";
 import {
   generateEmbedding
-} from "../chunk-WDX4PJGL.js";
+} from "../chunk-6FGTNOCP.js";
 import "../chunk-TYDMSHV7.js";
 
 // packages/core/src/workers/indexerWorker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxloom-pro",
-  "version": "1.5.6",
+  "version": "1.7.1",
   "description": "ctxloom — The Universal Code Context Engine. A local-first MCP server providing intelligent code context via hybrid Vector + AST + Graph search with Skeletonization (92% token reduction).",
   "type": "module",
   "main": "dist/index.js",

package/dist/VectorStore-2LVECRTY.js

@@ -1,8 +0,0 @@
-import {
-  VectorStore
-} from "./chunk-JULFFD7O.js";
-import "./chunk-TYDMSHV7.js";
-export {
-  VectorStore
-};
-//# sourceMappingURL=VectorStore-2LVECRTY.js.map