@nxuss/lemma 1.25.0 → 1.26.1

package/dist/cjs/subconscious/TheBrainV2.js

@@ -27,6 +27,7 @@ exports.tokenize = tokenize;
 exports.termFrequencies = termFrequencies;
 exports.bm25Score = bm25Score;
 exports.jaccardSimilarity = jaccardSimilarity;
+exports.extractRepoPathsFromText = extractRepoPathsFromText;
 exports.resolveFreshnessNode = resolveFreshnessNode;
 exports.buildClaimIndex = buildClaimIndex;
 exports.findBlastRadius = findBlastRadius;
@@ -815,6 +816,51 @@ function jaccardSimilarity(setA, setB) {
     return intersection / (setA.size + setB.size - intersection);
 }
 // ─── Freshness (file-hash invalidation) ───────────────────────────────────────
+/**
+ * Real repository files named in a memory's body — the raw material for turning an
+ * untracked entry into a verifiable one. Only paths that actually exist under the project
+ * root count: an anchor must stay portable, so references that resolve outside the repo
+ * (or into node_modules / generated output) are ignored, and `file:line` suffixes are
+ * stripped (`src/foo.ts:123` anchors to `src/foo.ts`). False positives self-filter by
+ * existence — a stray "auth.ts" in prose that no such file backs just never resolves.
+ */
+function extractRepoPathsFromText(text, opts = {}) {
+    const root = opts.root ?? process.cwd();
+    const max = opts.max ?? 10;
+    const found = [];
+    const seen = new Set();
+    // A dot-extension filename, optionally prefixed by ./ or a relative path. The character
+    // class excludes ':' so `src/foo.ts:123` captures `src/foo.ts` only (the line reference
+    // would otherwise defeat the extension anchor). Anchored to start-of-text or one of the
+    // delimiters one actually finds around a path in prose: whitespace, quotes, backticks,
+    // colons, and opening brackets.
+    const tokenRe = /(?:^|[\s"'`=([,:—-])((?:\.\/)?[A-Za-z0-9_][A-Za-z0-9_./-]*\.(?:ts|tsx|js|jsx|mjs|cjs|json|jsonc|yaml|yml|md|toml|txt|env|css|scss|html|py|go|rs|rb|sh|sql|graphql|vue|svelte|java|kt|swift|c|cpp|h|cs|php))(?::\d+)?/g;
+    for (const m of text.matchAll(tokenRe)) {
+        const raw = m[1];
+        if (seen.has(raw))
+            continue;
+        seen.add(raw);
+        const abs = path_1.default.resolve(root, raw);
+        const rel = path_1.default.relative(root, abs);
+        if (rel.startsWith('..') || path_1.default.isAbsolute(rel))
+            continue; // outside the repo
+        if (/(?:^|\/)(?:node_modules|\.git|\.next|coverage|dist)(?:\/|$)/.test(rel))
+            continue;
+        let st;
+        try {
+            st = fs_1.default.statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (!st.isFile())
+            continue;
+        found.push(rel);
+        if (found.length >= max)
+            break;
+    }
+    return found;
+}
 function hashFilesForFreshness(filePaths) {
     const hashes = {};
     for (const p of filePaths) {
@@ -1846,6 +1892,7 @@ class TheBrainV2 {
             const { fresh, staleFiles, unverifiedFiles, cosmeticChanges } = checkEntryFreshness(r.entry, resolver, resolveNode, 0, new Set(), semanticDiff);
             const claims = r.entry.claims?.map((c) => checkClaimFreshness(c, resolver, semanticDiff));
             const unverified = unverifiedFiles.length > 0;
+            const untracked = trackedArtifactCount(r.entry) === 0;
             return {
                 id: r.entry.id,
                 query: r.entry.query,
@@ -1854,6 +1901,7 @@ class TheBrainV2 {
                 provider: r.entry.provider,
                 timestamp: r.entry.timestamp,
                 fresh,
+                ...(untracked ? { untracked: true } : {}),
                 ...(r.entry.hits ? { hits: r.entry.hits } : {}),
                 ...(r.entry.tokensSaved ? { tokensSaved: r.entry.tokensSaved } : {}),
                 ...(r.whyShown.length > 0 ? { whyShown: r.whyShown } : {}),
@@ -1870,11 +1918,15 @@ class TheBrainV2 {
         if (countStats) {
             if (results.length > 0) {
                 this.sessionHits++;
-                // Increment hit counter on top result (LRU-style freshness)
-                const topEntry = this.entries.get(results[0].id);
-                if (topEntry) {
-                    topEntry.hits++;
-                    this.scheduleSave();
+                // An untracked result is a hint about something that was never validated against
+                // code — counting it as a reuse would inflate the ROI/eviction ledger.
+                if (!results[0].untracked) {
+                    // Increment hit counter on top result (LRU-style freshness)
+                    const topEntry = this.entries.get(results[0].id);
+                    if (topEntry) {
+                        topEntry.hits++;
+                        this.scheduleSave();
+                    }
                 }
             }
             else {
@@ -1933,10 +1985,13 @@ class TheBrainV2 {
         if (options.countStats !== false) {
             if (results.length > 0) {
                 this.sessionHits++;
-                const topEntry = this.entries.get(results[0].id);
-                if (topEntry) {
-                    topEntry.hits++;
-                    this.scheduleSave();
+                // Same untracked gate as search(): never credit a hint with no evidence behind it.
+                if (!results[0].untracked) {
+                    const topEntry = this.entries.get(results[0].id);
+                    if (topEntry) {
+                        topEntry.hits++;
+                        this.scheduleSave();
+                    }
                 }
             }
             else {
@@ -2806,7 +2861,18 @@ class TheBrainV2 {
                 revalidated.stale.push({ id: v.id, query: queryOf(v.id), staleFiles: v.staleFiles || [], action: 'refresh_memory after checking it is still true' });
             }
             else if (v.status === 'untracked') {
-                revalidated.untracked.push({ id: v.id, query: queryOf(v.id), action: 'update_memory with filePaths/symbols so it becomes verifiable' });
+                const entry = this.entries.get(v.id);
+                const candidates = entry
+                    ? extractRepoPathsFromText(`${entry.query}\n${entry.response}`, { max: 10 })
+                    : [];
+                revalidated.untracked.push({
+                    id: v.id,
+                    query: queryOf(v.id),
+                    action: candidates.length > 0
+                        ? 'refresh_memory with the discovered filePaths (auto-anchor)'
+                        : 'update_memory with filePaths/symbols so it becomes verifiable',
+                    anchorCandidates: candidates.length > 0 ? candidates : undefined,
+                });
             }
             else if (v.status === 'unverified') {
                 revalidated.unverified.push({ id: v.id, query: queryOf(v.id), action: 'check the tracked paths exist on this machine, then refresh_memory' });