gitnexus 1.6.12-rc.31 → 1.6.12-rc.33

package/dist/cli/embeddings-sync.js

@@ -7,7 +7,8 @@ import { getStoragePaths, loadMeta, saveMeta } from '../storage/repo-manager.js'
 import { closeLbug, executeQuery, executeWithReusedStatement, fetchExistingEmbeddingHashes, initLbug, } from '../core/lbug/lbug-adapter.js';
 import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js';
 import { resolveEmbeddingIdentity } from '../core/embeddings/embedding-identity.js';
-import { checkpointKind, decideEmbeddingResume, mintInterruptedCheckpoint, mintPartialCheckpoint, mintUnverifiedCountCheckpoint, } from '../core/embedding-checkpoint.js';
+import { decideEmbeddingResume, mintInterruptedCheckpoint, mintPartialCheckpoint, mintUnverifiedCountCheckpoint, } from '../core/embedding-checkpoint.js';
+import { EMBEDDING_DIMS, embeddingDimsMismatch } from '../core/lbug/schema.js';
 import { measurePersistedEmbeddingCount, persistedEmbeddingCountOrUndefined, } from '../core/embedding-count.js';
 /** Add missing embeddings directly to a healthy index, checkpointing periodically. */
 export const embeddingsSyncCommand = async (inputPath) => {
@@ -45,10 +46,16 @@ export const embeddingsSyncCommand = async (inputPath) => {
             const identityDiffers = checkpoint.provider !== identity.provider ||
                 checkpoint.model !== identity.model ||
                 checkpoint.dimensions !== identity.dimensions;
-            // `abandon` on a non-interrupted foreign identity drops the pending set
-            // only. Existing rows stay; sync would then embed the holes under the new
-            // identity and mix vector spaces. Fail closed — rebuild via analyze.
-            if (identityDiffers && checkpointKind(checkpoint) !== 'unverified-count') {
+            // `abandon` on a foreign identity drops the pending set only. Existing
+            // rows stay; sync would then embed the holes under the new identity and
+            // mix vector spaces. Fail closed — rebuild via analyze.
+            //
+            // Every kind is gated, `unverified-count` included. Exempting it looked
+            // safe because that kind only records "the count could not be read", but
+            // `decideEmbeddingResume` returns `abandon` for it BEFORE comparing
+            // identity, so the exemption was the only thing standing between a
+            // foreign identity and a silently mixed table.
+            if (identityDiffers) {
                 throw new Error(`Cannot sync embeddings: the index checkpoint was written by ${checkpoint.model} ` +
                     `(${checkpoint.provider}) at ${checkpoint.dimensions} dimensions, but this run ` +
                     `resolves ${identity.model} (${identity.provider}) at ${identity.dimensions}. ` +
@@ -60,19 +67,34 @@ export const embeddingsSyncCommand = async (inputPath) => {
                 resumedFrom = decision.resumedFrom;
             }
         }
+        // The vector column is FLOAT[N] fixed when the index was built, and the
+        // pipeline deletes each batch's stale rows immediately before inserting the
+        // replacements — so a width change here deletes rows it cannot re-insert.
+        // `analyze` forces a full rebuild on the same mismatch; only a rebuild can
+        // retype the column, so this writer refuses instead. An absent recorded
+        // width is not a mismatch (see `embeddingDimsMismatch`).
+        if (embeddingDimsMismatch(meta.embeddingDims, EMBEDDING_DIMS)) {
+            throw new Error(`Cannot sync embeddings: this index stores FLOAT[${meta.embeddingDims}] vectors, ` +
+                `but this run embeds at ${EMBEDDING_DIMS} dimensions. ` +
+                'Run `gitnexus analyze --embeddings --force` to rebuild the column at the new width.');
+        }
         await initLbug(lbugPath);
         try {
             const existing = await fetchExistingEmbeddingHashes(executeQuery);
             let lastPercent = -1;
             const countEmbeddings = async () => persistedEmbeddingCountOrUndefined(await measurePersistedEmbeddingCount(executeQuery));
-            const saveCheckpoint = async (checkpoint, pendingNodeIds, embeddings) => {
+            // One write path for every meta update this command makes. The re-read
+            // happens immediately before each save so a concurrent writer's fields
+            // survive. #2790 traced two production drifts to hand-copied writers of
+            // these exact fields, so this file keeps one copy instead of three.
+            const persistMeta = async (patch) => {
                 const latest = (await loadMeta(metaDir)) ?? meta;
-                await saveMeta(metaDir, {
-                    ...latest,
-                    ...(embeddings === undefined ? {} : { stats: { ...latest.stats, embeddings } }),
-                    embeddingCheckpoint: mintInterruptedCheckpoint(identity, checkpoint, pendingNodeIds),
-                });
+                await saveMeta(metaDir, { ...latest, ...patch(latest) });
             };
+            const saveCheckpoint = async (checkpoint, pendingNodeIds, embeddings) => persistMeta((latest) => ({
+                ...(embeddings === undefined ? {} : { stats: { ...latest.stats, embeddings } }),
+                embeddingCheckpoint: mintInterruptedCheckpoint(identity, checkpoint, pendingNodeIds),
+            }));
             cliInfo(`Embedding ${repoPath}`);
             cliInfo(`Checkpointed nodes already present: ${existing?.size ?? 0}`);
             const result = await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
@@ -91,13 +113,11 @@ export const embeddingsSyncCommand = async (inputPath) => {
                 },
             });
             const embeddings = await countEmbeddings();
-            const latest = (await loadMeta(metaDir)) ?? meta;
             if (embeddings === undefined) {
                 // Keep last-known stats.embeddings. An interrupted window marker would
                 // fail the identity gate on the next run even though this run finished;
                 // unverified-count is the recovery kind that forces a recount (#2790).
-                await saveMeta(metaDir, {
-                    ...latest,
+                await persistMeta(() => ({
                     embeddingCheckpoint: result.failedNodeIds.length
                         ? mintPartialCheckpoint(identity, result, resumedFrom)
                         : mintUnverifiedCountCheckpoint(identity, {
@@ -105,16 +125,15 @@ export const embeddingsSyncCommand = async (inputPath) => {
                             totalNodes: result.nodesProcessed,
                             chunksProcessed: result.chunksProcessed,
                         }),
-                });
+                }));
                 throw new Error('Could not verify persisted embedding count.');
             }
-            await saveMeta(metaDir, {
-                ...latest,
+            await persistMeta((latest) => ({
                 stats: { ...latest.stats, embeddings },
                 embeddingCheckpoint: result.failedNodeIds.length
                     ? mintPartialCheckpoint(identity, result, resumedFrom)
                     : undefined,
-            });
+            }));
             cliInfo(`Embeddings ready: ${embeddings}`);
         }
         finally {

package/dist/core/embeddings/http-client.js

@@ -11,6 +11,7 @@
  * via `AbortSignal.timeout` on the underlying fetch.
  */
 import { chunk } from '../../lib/utils.js';
+import { parseTruthyEnv } from '../ingestion/utils/env.js';
 import { CircuitOpenError, ResilientFetchExhaustedError, isTerminalNetworkError, resilientFetch, } from '../../_shared/index.js';
 const DEFAULT_HTTP_TIMEOUT_MS = 180_000;
 const MAX_HTTP_TIMEOUT_MS = 300_000;
@@ -157,7 +158,12 @@ const readConfig = () => {
         retryCapMs: parsePositiveIntegerEnv('GITNEXUS_EMBEDDING_RETRY_CAP_MS', HTTP_RETRY_CAP_MS, 300_000),
         minIntervalMs: parseNonNegativeIntegerEnv('GITNEXUS_EMBEDDING_MIN_INTERVAL_MS', 0, 300_000),
         timeoutMs: parsePositiveIntegerEnv(HTTP_TIMEOUT_ENV, DEFAULT_HTTP_TIMEOUT_MS, MAX_HTTP_TIMEOUT_MS),
-        retryTimeouts: parseNonNegativeIntegerEnv('GITNEXUS_EMBEDDING_RETRY_TIMEOUTS', 0, 1) === 1,
+        // A boolean toggle, so it takes the repo's truthy convention (`1`/`true`/
+        // `yes`) and falls back to the documented default on anything else. The
+        // integer parser this used throws on a non-digit, which turned the
+        // conventional `=true` into a hard failure of every embedding call rather
+        // than either enabling the flag or leaving it off.
+        retryTimeouts: parseTruthyEnv(process.env.GITNEXUS_EMBEDDING_RETRY_TIMEOUTS),
         requestDimensions,
     };
 };

package/dist/mcp/local/local-backend.d.ts

@@ -497,6 +497,23 @@ export declare class LocalBackend {
      *   - `remoteUrl`: the canonical origin URL recorded at index time.
      */
     listRepos(): Promise<RepoListing[]>;
+    /**
+     * Lightweight registry count for schema-introspection callers that only
+     * need to know "one repo or many?" without paying the full staleness fan-out
+     * cost that listRepos() incurs. Uses the same validated registry
+     * `refreshRepos` / `selectToolRepository` see (`validate: true` prunes
+     * entries whose metadata is provably gone) so tools/list cannot advertise a
+     * multi-repo schema for ENOENT ghosts. No git processes are spawned.
+     */
+    countRepos(): Promise<number>;
+    /**
+     * In-memory validated registry size after the last `refreshRepos` / init /
+     * `selectToolRepository` refresh. `countRepos()` does not populate this map.
+     * Schema introspection uses this after a refreshed cwd probe so cardinality
+     * and the probe share one snapshot — without putting `refreshRepos()` (and
+     * its kuzu cleanup) on the 0–1 `countRepos` path.
+     */
+    cachedRepoCount(): number;
     /**
      * Paginated view over {@link listRepos} for the `list_repos` MCP tool (#2119).
      *

package/dist/mcp/local/local-backend.js

@@ -1841,6 +1841,28 @@ export class LocalBackend {
             };
         });
     }
+    /**
+     * Lightweight registry count for schema-introspection callers that only
+     * need to know "one repo or many?" without paying the full staleness fan-out
+     * cost that listRepos() incurs. Uses the same validated registry
+     * `refreshRepos` / `selectToolRepository` see (`validate: true` prunes
+     * entries whose metadata is provably gone) so tools/list cannot advertise a
+     * multi-repo schema for ENOENT ghosts. No git processes are spawned.
+     */
+    async countRepos() {
+        const entries = await listRegisteredRepos({ validate: true });
+        return entries.length;
+    }
+    /**
+     * In-memory validated registry size after the last `refreshRepos` / init /
+     * `selectToolRepository` refresh. `countRepos()` does not populate this map.
+     * Schema introspection uses this after a refreshed cwd probe so cardinality
+     * and the probe share one snapshot — without putting `refreshRepos()` (and
+     * its kuzu cleanup) on the 0–1 `countRepos` path.
+     */
+    cachedRepoCount() {
+        return this.repos.size;
+    }
     /**
      * Paginated view over {@link listRepos} for the `list_repos` MCP tool (#2119).
      *

package/dist/mcp/repository-policy.js

@@ -148,26 +148,28 @@ export class McpRepositoryPolicy {
                 mutatingRequiresRepo: requiresRepo,
             };
         }
-        // One fresh listing supplies both schema decisions. Besides keeping the
-        // advertised contract internally consistent, this avoids doing two full
-        // per-repo staleness fan-outs for every tools/list request.
-        const visibleRepos = await this.listAllowedRepos(backend);
-        if (visibleRepos.length <= 1) {
+        // Validated registry cardinality only — no listRepos() staleness git.
+        // The 0–1 arm stays a cheap countRepos() (no refreshRepos / kuzu cleanup).
+        const repoCount = await backend.countRepos();
+        if (repoCount <= 1) {
             return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
         }
         try {
-            // listAllowedRepos() refreshed this backend immediately above. Resolve
-            // against that exact cache snapshot instead of racing another registry
-            // read; only read-only schemas may advertise the cwd-derived default.
+            // countRepos() does not refresh the backend; this cwd probe must.
             await backend.selectToolRepository(undefined, undefined, {
                 allowCwdDefault: true,
-                refreshRegistry: false,
+                refreshRegistry: true,
             });
-            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: true };
         }
         catch {
             return { readOnlyRequiresRepo: true, mutatingRequiresRepo: true };
         }
+        // The probe just refreshed. If that snapshot is now a singleton, match the
+        // <=1 arm rather than advertising a split mutating-only schema.
+        if (backend.cachedRepoCount() <= 1) {
+            return { readOnlyRequiresRepo: false, mutatingRequiresRepo: false };
+        }
+        return { readOnlyRequiresRepo: false, mutatingRequiresRepo: true };
     }
     async listReposPage(backend, params) {
         const { limit, offset } = parseListReposPagination(params, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.31",
+  "version": "1.6.12-rc.33",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",