@ninjaxtools/slopdex 0.18.0 → 0.19.0

package/dist/{chunk-N6D66ASM.js → chunk-HMKVMRLF.js}

@@ -1,13 +1,13 @@
 import {
   IndexDatabase
-} from "./chunk-6LHZCHEB.js";
+} from "./chunk-GBEJHETS.js";
 import {
   OpenAIDescriptionProvider,
   isDescriptionProviderName
 } from "./chunk-TSURHRFF.js";
 import {
   analysisSimilarity
-} from "./chunk-KQRS5P4U.js";
+} from "./chunk-5BO2LLXC.js";
 import {
   DEFAULT_PARALLELISM,
   assertPositiveInteger,
@@ -1012,8 +1012,10 @@ var CodeIndex = class {
   }
   /**
    * Whether a working-tree refresh changed nothing: same file set, same
-   * content, same language, still working-tree rows, no checkout to clear,
-   * and no recorded errors to retry. Skipping the write avoids a generation
+   * content, same language, and still working-tree rows, with no checkout to
+   * clear. Recorded indexing errors never force a refresh on their own; a
+   * file with errors is retried only when its content changes or via an
+   * explicit updateFiles upsert. Skipping the write avoids a generation
    * bump and, via foreign-key cascades, needlessly invalidating the
    * similarity cache for unchanged files. Description state must already be
    * quiescent: a refresh is what lazily clears stored descriptions after
@@ -1022,15 +1024,12 @@ var CodeIndex = class {
    */
   #isWorkingTreeClean(indexedFiles, prepared) {
     if (this.#database.getCheckpoint() !== null) return false;
-    if (this.#database.needsDiagnosticsScan()) return false;
-    if (this.#database.filesWithErrors().length > 0) return false;
     if (this.#database.descriptionsEnabled()) return false;
     if (indexedFiles.length !== prepared.length) return false;
     const status = this.status();
     if (status.descriptionCount > 0 || status.fileDescriptionCount > 0) return false;
     const indexedByPath = new Map(indexedFiles.map((file) => [file.path, file]));
     return prepared.every((file) => {
-      if (file.unavailable || file.errors.length > 0) return false;
       const indexed = indexedByPath.get(file.path);
       return !!indexed && indexed.sourceMode === "working-tree" && indexed.blobOid === file.blobOid && indexed.language === file.language && indexed.contentHash === file.contentHash;
     });
@@ -1045,8 +1044,7 @@ var CodeIndex = class {
     const overlayWorkingTree = target === head && options.includeWorkingTree !== false;
     const checkpoint = this.#database.getCheckpoint();
     const generation = this.#database.getGeneration();
-    const diagnosticsScan = this.#database.needsDiagnosticsScan();
-    const retryPaths = new Set(this.#database.filesWithErrors());
+    const tooLargePaths = new Set(this.#database.filesWithFileTooLargeErrors());
     let reconcileAll = checkpoint === null;
     if (checkpoint && !await this.#git.isAncestor(checkpoint, target)) {
       if (!options.rebuildOnDivergence) throw new GitDivergenceError(checkpoint, target);
@@ -1084,7 +1082,7 @@ var CodeIndex = class {
       const claimedRenameSources = /* @__PURE__ */ new Set();
       for (const entry of eligibleEntries) {
         const indexed = indexedByPath.get(entry.path);
-        if (indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size <= this.#maxFileSize && !diagnosticsScan && !retryPaths.has(entry.path)) continue;
+        if (indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize === tooLargePaths.has(entry.path)) continue;
         const matches = renameCandidates.filter((candidate) => candidate.blobOid === entry.oid && !claimedRenameSources.has(candidate.path));
         const previousPath = matches.length === 1 ? matches[0].path : void 0;
         if (previousPath) claimedRenameSources.add(previousPath);
@@ -1099,7 +1097,8 @@ var CodeIndex = class {
       for (const targetPath of eligibleTargetPaths) {
         const indexed = indexedByPath.get(targetPath);
         const entry = tree.get(targetPath);
-        if ((diagnosticsScan || retryPaths.has(targetPath) || entry.size > this.#maxFileSize || !indexed || indexed.sourceMode === "git" && indexed.blobOid !== entry.oid) && !upserts.has(targetPath)) {
+        const sizeStateFlipped = indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize !== tooLargePaths.has(targetPath);
+        if ((!indexed || indexed.sourceMode === "git" && indexed.blobOid !== entry.oid || sizeStateFlipped) && !upserts.has(targetPath)) {
           upserts.set(targetPath, { entry });
         }
       }
@@ -1137,7 +1136,7 @@ var CodeIndex = class {
     }
     for (const [filePath, { entry, previousPath }] of upserts) {
       const indexed = indexedByPath.get(filePath);
-      if (!previousPath && indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size <= this.#maxFileSize && !diagnosticsScan && !retryPaths.has(filePath)) upserts.delete(filePath);
+      if (!previousPath && indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize === tooLargePaths.has(filePath)) upserts.delete(filePath);
     }
     const workingPrepared = [];
     const workingDeletes = /* @__PURE__ */ new Set();
@@ -1224,7 +1223,7 @@ var CodeIndex = class {
       }
     }
     let embeddingsCreated = await this.#attachEmbeddings([...prepared, ...workingPrepared], options.signal);
-    const noChanges = !reconcileAll && !diagnosticsScan && checkpoint === target && prepared.length === 0 && deletes.size === 0 && workingPrepared.length === 0 && workingDeletes.size === 0;
+    const noChanges = !reconcileAll && checkpoint === target && prepared.length === 0 && deletes.size === 0 && workingPrepared.length === 0 && workingDeletes.size === 0;
     while (true) {
       const resolvedAgain = await this.#git.resolveCommit(options.target ?? "HEAD");
       if (resolvedAgain !== target) throw new CodeIndexError("Target Git ref changed while indexing; retry the update.");
@@ -1877,26 +1876,30 @@ ${callable.description}` : null,
     }
     const functionsById = new Map(this.allFunctions().map((callable) => [callable.id, callable]));
     const lean = /* @__PURE__ */ new Map();
+    let scanFloor = floor;
+    for (const state of states.values()) scanFloor = Math.min(scanFloor, state.floor);
     for (const dirtyId of dirty) {
       throwIfAborted(options.signal);
+      const prior = states.get(dirtyId);
+      const keepWidth = Math.max(width, prior?.cachedWidth ?? width);
       const full = this.similarToFunction(dirtyId, {
         ...includeDescriptions ? { includeDescriptions: true } : {},
         limit: triples.length - 1,
-        minSimilarity: floor
+        minSimilarity: scanFloor
       });
       const byTarget = /* @__PURE__ */ new Map();
       for (const match of full) byTarget.set(match.function.id, match);
       lean.set(dirtyId, byTarget);
       const triple = tripleById.get(dirtyId);
-      const top = full.slice(0, width);
+      const top = full.slice(0, keepWidth);
       this.#database.storeSimilarityNeighbors(dirtyId, mode, top, {
         codeEmbeddingId: triple.codeEmbeddingId,
         descriptionEmbeddingId: triple.descriptionEmbeddingId,
         fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-        cachedWidth: width,
+        cachedWidth: keepWidth,
         generation,
-        floor,
-        complete: full.length <= width
+        floor: scanFloor,
+        complete: full.length <= keepWidth
       });
       sourcesRefreshed += 1;
       pairsStored += top.length;
@@ -1906,32 +1909,33 @@ ${callable.description}` : null,
     for (const triple of triples) {
       throwIfAborted(options.signal);
       if (dirty.has(triple.functionId)) continue;
+      const prior = states.get(triple.functionId);
+      const keepFloor = Math.min(floor, prior?.floor ?? floor);
+      const keepWidth = Math.max(width, prior?.cachedWidth ?? width);
       const cached = this.#database.cachedSimilarityNeighbors(triple.functionId, mode);
-      const kept = cached.filter((match) => match.similarity >= floor && !dirty.has(match.function.id) && functionsById.has(match.function.id));
+      const kept = cached.filter((match) => match.similarity >= keepFloor && !dirty.has(match.function.id) && functionsById.has(match.function.id));
       const added = [];
       for (const [dirtyId, byTarget] of lean) {
         if (dirtyId === triple.functionId) continue;
         const match = byTarget.get(triple.functionId);
         const dirtyFunction = functionsById.get(dirtyId);
-        if (match && dirtyFunction) {
+        if (match && match.similarity >= keepFloor && dirtyFunction) {
           const { function: _function, ...scores } = match;
           added.push({ ...scores, function: dirtyFunction });
         }
       }
-      const plusOne = [...kept, ...added].sort((left, right) => right.similarity - left.similarity || left.function.id - right.function.id).slice(0, width + 1);
-      const merged = plusOne.slice(0, width);
-      const contributorsComplete = triples.every((candidate) => dirty.has(candidate.functionId) || states.get(candidate.functionId)?.complete === true);
-      const complete = plusOne.length <= width && contributorsComplete;
+      const plusOne = [...kept, ...added].sort((left, right) => right.similarity - left.similarity || left.function.id - right.function.id).slice(0, keepWidth + 1);
+      const merged = plusOne.slice(0, keepWidth);
+      const complete = plusOne.length <= keepWidth && (prior?.complete ?? false);
       const unchanged = merged.length === cached.length && merged.every((match, index) => match.function.id === cached[index].function.id && match.similarity === cached[index].similarity);
       if (unchanged) {
-        const narrowed = cached.some((match) => match.similarity < floor);
         this.#database.touchSimilarityCacheState(triple.functionId, mode, {
           codeEmbeddingId: triple.codeEmbeddingId,
           descriptionEmbeddingId: triple.descriptionEmbeddingId,
           fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: width,
+          cachedWidth: keepWidth,
           generation,
-          floor: narrowed ? floor : states.get(triple.functionId)?.floor ?? floor,
+          floor: keepFloor,
           storedCount: merged.length,
           complete
         });
@@ -1940,9 +1944,9 @@ ${callable.description}` : null,
           codeEmbeddingId: triple.codeEmbeddingId,
           descriptionEmbeddingId: triple.descriptionEmbeddingId,
           fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: width,
+          cachedWidth: keepWidth,
           generation,
-          floor,
+          floor: keepFloor,
           complete
         });
         pairsStored += merged.length;
@@ -2214,4 +2218,4 @@ function groupBy(values, keyFor) {
 export {
   CodeIndex
 };
-//# sourceMappingURL=chunk-N6D66ASM.js.map
+//# sourceMappingURL=chunk-HMKVMRLF.js.map