pi-supernova 0.3.2 → 0.4.0

package/src/context/evidence.js

@@ -33,9 +33,12 @@ const EVIDENCE_DEFAULTS = {
 };
 
 const IDENT = /[A-Za-z_$][\w$]*/g;
+
 // Verb forms only: "call sites" is a concept, "who calls X" is a usage question.
 const RELATION_WORDS = new Set(["calls", "caller", "callers", "uses", "usages", "used", "using", "imports", "imported", "depends", "references", "referenced", "invokes", "invoked"]);
+
 const HUB_FRACTION = 0.25;
+
 const HUB_MIN = 8;
 
 export { stem } from "./snap.js";
@@ -52,6 +55,7 @@ export function profileQuery(query) {
   const subjects = words.filter((w) => /[a-z][A-Z]|_/.test(w));
   const usage = words.some((w) => RELATION_WORDS.has(w.toLowerCase()));
   const relational = usage || subjects.length > 0;
+
   return {
     subjects: [...new Set(subjects)],
     keywords: tokens,
@@ -68,9 +72,11 @@ function spansOf(entry, filePath, maxSpanLines) {
   const lines = WorkspaceIndex.linesOf(entry);
   const base = { path: filePath, entry, lower: lines.lower, lines };
   const declared = WorkspaceIndex.spansOf(entry);
+
   if (declared.length === 0) {
     return [{ ...base, id: filePath + ":1", start: 1, end: Math.min(lines.raw.length, maxSpanLines), name: path.basename(filePath), kind: "file", sourceEnd: lines.raw.length }];
   }
+
   return declared.map((s, i) => ({ ...base, ...s, sourceEnd: s.end, id: filePath + ":" + s.start, end: Math.min(s.end, s.start + maxSpanLines - 1), index: i }));
 }
 
@@ -84,10 +90,12 @@ function buildGraph(spans) {
   const entityNames = new Set(spans.map((s) => s.name).filter((n) => n && n.length > 2));
   const spanEntities = new Map(); // span.id → Map(entity → w(d,e))
   const entitySpans = new Map();  // entity → Set(span.id)
+
   for (const span of spans) {
     const counts = new Map();
     let total = 0;
     const { idents } = span.lines;
+
     for (let li = span.start - 1; li < span.end; li++) {
       for (const word of idents[li]) {
         if (!entityNames.has(word)) continue;
@@ -95,17 +103,27 @@ function buildGraph(spans) {
         total += 1;
       }
     }
+
     const weights = new Map();
+
     for (const [e, c] of counts) {
       weights.set(e, c / total); // eq.4
+
       if (!entitySpans.has(e)) entitySpans.set(e, new Set());
       entitySpans.get(e).add(span.id);
     }
+
     spanEntities.set(span.id, weights);
   }
+
   // Entities present in a large share of spans (isString, path, …) carry no query signal; keep them out of propagation.
   const hubLimit = Math.max(HUB_MIN, Math.floor(spans.length * HUB_FRACTION));
-  const hubs = new Set([...entitySpans].filter(([, ids]) => ids.size > hubLimit).map(([e]) => e));
+  const hubs = new Set();
+
+  for (const [entity, ids] of entitySpans) {
+    if (ids.size > hubLimit) hubs.add(entity);
+  }
+
   return { entityNames, spanEntities, entitySpans, hubs, byId: new Map(spans.map((s) => [s.id, s])) };
 }
 
@@ -114,33 +132,43 @@ function buildGraph(spans) {
 function lexicalSim(a, b) {
   const ta = new Set(splitIdentifier(a));
   const tb = new Set(splitIdentifier(b));
+
   if (ta.size === 0 || tb.size === 0) return 0;
   let inter = 0;
+
   for (const t of ta) if (tb.has(t)) inter++;
+
   return inter / (ta.size + tb.size - inter);
 }
 
 function activateEntities(profile, graph) {
   const eta = new Map();
   const anchors = profile.subjects.length ? profile.subjects : profile.keywords;
+
   for (const anchor of anchors) {
     let best = null;
     let bestSim = 0;
+
     for (const e of graph.entityNames) {
       const sim = e.toLowerCase() === anchor.toLowerCase() ? 1 : lexicalSim(e, anchor);
+
       if (sim > bestSim) {
         bestSim = sim;
         best = e;
       }
     }
+
     if (best && bestSim >= 0.5) eta.set(best, Math.max(eta.get(best) || 0, bestSim)); // eq.8
   }
+
   return eta;
 }
 
 function querySim(profile, lowerLine) {
   let hits = 0;
+
   for (const t of profile.stems) if (lowerLine.includes(t)) hits++;
+
   return profile.stems.length ? hits / profile.stems.length : 0;
 }
 
@@ -155,10 +183,12 @@ function activateCooccurring(e, line, weight, spanId, graph, eta1) {
 
 function propagateFrom(e, act, graph, profile, eta1) {
   const eLower = e.toLowerCase();
+
   for (const spanId of graph.entitySpans.get(e) || []) {
     for (const line of spanLines(graph.byId.get(spanId))) {
       if (!line.includes(eLower)) continue;
       const sim = querySim(profile, line);
+
       if (sim > 0) activateCooccurring(e, line, act * sim, spanId, graph, eta1);
     }
   }
@@ -166,7 +196,9 @@ function propagateFrom(e, act, graph, profile, eta1) {
 
 function propagate(eta0, spans, graph, profile) {
   const eta1 = new Map(eta0);
+
   for (const [e, act] of eta0) propagateFrom(e, act, graph, profile, eta1);
+
   return eta1;
 }
 
@@ -176,13 +208,17 @@ function resetDistribution(spans, graph, eta, prior) {
   const n = spans.length;
   const reset = new Float64Array(n);
   let sum = 0;
+
   for (let i = 0; i < n; i++) {
     let r = prior[i];
+
     for (const [e, w] of graph.spanEntities.get(spans[i].id)) if (!graph.hubs.has(e)) r += (eta.get(e) || 0) * w;
     reset[i] = r;
     sum += r;
   }
+
   if (sum > 0) for (let i = 0; i < n; i++) reset[i] /= sum;
+
   return { reset, sum };
 }
 
@@ -192,60 +228,83 @@ function resetDistribution(spans, graph, eta, prior) {
  */
 function transitionStructure(spans, graph) {
   const n = spans.length;
-  const entities = [...graph.entitySpans].filter(([e, ids]) => ids.size >= 2 && !graph.hubs.has(e)).map(([e]) => e);
+  const entities = [];
+
+  for (const [entity, ids] of graph.entitySpans) {
+    if (ids.size >= 2 && !graph.hubs.has(entity)) entities.push(entity);
+  }
+
   const eIndex = new Map(entities.map((e, i) => [e, i]));
+
   const spanTerms = spans.map((s) => {
     const terms = [];
+
     for (const [e, w] of graph.spanEntities.get(s.id)) if (eIndex.has(e)) terms.push([eIndex.get(e), w]);
+
     return terms;
   });
+
   const entityMass = new Float64Array(entities.length);
+
   for (let i = 0; i < n; i++) for (const [ei, w] of spanTerms[i]) entityMass[ei] += w;
   const neighbours = spans.map((s, i) => [i - 1, i + 1].filter((j) => j >= 0 && j < n && spans[j].path === s.path));
   const outWeight = new Float64Array(n);
+
   for (let i = 0; i < n; i++) {
     let out = 0.5 * neighbours[i].length;
+
     for (const [ei, w] of spanTerms[i]) out += w * (entityMass[ei] - w);
     outWeight[i] = out;
   }
+
   return { spanTerms, entityCount: entities.length, neighbours, outWeight };
 }
 
 function pushStep(pi, next, acc, structure, gamma) {
   const { spanTerms, neighbours, outWeight } = structure;
   let dangling = 0;
+
   for (let i = 0; i < pi.length; i++) {
     if (outWeight[i] === 0) {
       dangling += pi[i];
       continue;
     }
+
     const flow = (gamma * pi[i]) / outWeight[i];
+
     for (const [ei, w] of spanTerms[i]) {
       acc[ei] += flow * w;
       next[i] -= flow * w * w; // remove the d → d self term
     }
+
     for (const j of neighbours[i]) next[j] += flow * 0.5;
   }
+
   return dangling;
 }
 
 function pageRank(spans, graph, eta, prior, { gamma, pprIterations }) {
   const n = spans.length;
   const { reset, sum } = resetDistribution(spans, graph, eta, prior);
+
   if (sum === 0) return reset;
   const structure = transitionStructure(spans, graph);
   const acc = new Float64Array(structure.entityCount);
   let pi = Float64Array.from(reset);
+
   for (let iter = 0; iter < pprIterations; iter++) {
     const next = new Float64Array(n);
     acc.fill(0);
     const dangling = pushStep(pi, next, acc, structure, gamma);
+
     for (let i = 0; i < n; i++) {
       for (const [ei, w] of structure.spanTerms[i]) next[i] += acc[ei] * w;
       next[i] += (1 - gamma) * reset[i] + gamma * dangling * reset[i]; // dangling mass follows the reset
     }
+
     pi = next;
   }
+
   return pi;
 }
 
@@ -255,7 +314,9 @@ function nameDefinitionScore(span, profile, usage) {
   if (usage) return 0; // eq.15 Rank_ϕ: a usage question is answered by callers, not the definer
   const nameTokens = splitIdentifier(span.name || "");
   let def = 0;
+
   for (const t of profile.stems) if (nameTokens.some((n) => n.startsWith(t))) def += 40;
+
   return def;
 }
 
@@ -265,20 +326,26 @@ function mentionScore(span, profile, usage, skipDeclaration) {
   let bestLine = span.start;
   let bestHits = 0;
   const lines = spanLines(span);
+
   for (let i = skipDeclaration ? 1 : 0; i < lines.length; i++) {
     let hits = 0;
+
     for (const t of profile.stems) if (lines[i].includes(t)) hits++;
+
     if (hits > bestHits) {
       bestHits = hits;
       bestLine = span.start + i;
     }
+
     mentions += hits * hits * perHit; // several query stems on one line is strong evidence
   }
+
   return { mentions, bestLine };
 }
 
 function hierarchicalScores(spans, fileScores, profile) {
   const usage = profile.answerType === "usage";
+
   return spans.map((span) => {
     const definesSubject = profile.subjects.includes(span.name);
     const def = nameDefinitionScore(span, profile, usage);
@@ -286,6 +353,7 @@ function hierarchicalScores(spans, fileScores, profile) {
     span.bestLine = bestLine;
     span.support = def + mentions; // span-level lexical evidence; file-level bonuses do not count
     const fileScore = Math.max(0, fileScores.get(span.path) || 0);
+
     return fileScore / 2 + def + Math.min(mentions, usage ? 200 : 120) + (span.isExport ? 10 : 0);
   });
 }
@@ -295,11 +363,15 @@ function hierarchicalScores(spans, fileScores, profile) {
 function normalize(scores) {
   let min = Infinity;
   let max = -Infinity;
+
   for (const s of scores) {
     if (s < min) min = s;
+
     if (s > max) max = s;
   }
+
   if (!(max > min)) return scores.map(() => 1);
+
   return scores.map((s) => (s - min) / (max - min));
 }
 
@@ -307,26 +379,36 @@ function normalize(scores) {
 
 function candidateFiles(files, profile, index, limit, overlayText) {
   const scored = [];
+
   for (const f of files) {
     const s = scorePathTopology(f, profile.keywords, profile.flags);
+
     if (s > 0) scored.push({ f, s });
   }
+
   scored.sort((a, b) => b.s - a.s);
   const chosen = new Set();
   const anchors = (profile.subjects.length ? profile.subjects : profile.keywords).map((a) => a.toLowerCase()).filter((a) => a.length > 2);
+
   const pendingHits = files.filter(file => {
     const pending = overlayText(file);
+
     return pending !== undefined && anchors.some(anchor => pending.toLowerCase().includes(anchor));
   });
+
   const hits = anchors.length ? [...new Set([...pendingHits, ...index.filesContaining(files, anchors, true)])] : [];
+
   for (const f of hits) {
     if (chosen.size >= limit) break;
+
     if (profile.flags.wantsTest || scorePathTopology(f, profile.keywords, profile.flags) > -50) chosen.add(f);
   }
+
   for (const { f } of scored) {
     if (chosen.size >= limit) break;
     chosen.add(f);
   }
+
   return { files: [...chosen], fileScores: new Map(scored.map(({ f, s }) => [f, s])) };
 }
 
@@ -335,13 +417,17 @@ function candidateFiles(files, profile, index, limit, overlayText) {
 function bridgesFor(i, spans, graph, fused, definers, chosen) {
   const byId = graph.byId;
   const bridges = [];
+
   for (const [e, w] of graph.spanEntities.get(spans[i].id)) {
     const defId = definers.get(e);
+
     if (!defId || graph.hubs.has(e) || chosen.has(defId) || defId === spans[i].id || w < 0.15) continue;
     const definer = byId.get(defId);
+
     if (definer.end - definer.start < 2) continue; // one-line helpers add no understanding
     bridges.push({ id: defId, w: w * fused[definer.index0] });
   }
+
   return bridges.sort((a, b) => b.w - a.w).slice(0, 2);
 }
 
@@ -349,35 +435,45 @@ function closure(main, spans, graph, fused, k) {
   spans.forEach((s, i) => (s.index0 = i));
   const chosen = new Map(main.map((i) => [spans[i].id, { i, why: "main" }]));
   const definers = new Map();
+
   for (const s of spans) if (s.name) definers.set(s.name, s.id);
   const neighboursOf = (i) => [i - 1, i + 1].filter((j) => j >= 0 && j < spans.length && spans[j].path === spans[i].path);
+
   for (const i of main) {
     // Ng: spans that define identifiers this span uses (relational bridges).
     for (const b of bridgesFor(i, spans, graph, fused, definers, chosen)) chosen.set(b.id, { i: graph.byId.get(b.id).index0, why: "bridge" });
+
     // Nh: in-file neighbours that still carry query signal.
     for (const j of neighboursOf(i)) {
       if (fused[j] > 0.2 && !chosen.has(spans[j].id)) chosen.set(spans[j].id, { i: j, why: "neighbor" });
     }
   }
+
   const supports = [...chosen.values()].filter((c) => c.why !== "main").sort((a, b) => fused[b.i] - fused[a.i]).slice(0, k);
+
   return [...main.map((i) => ({ i, why: "main" })), ...supports];
 }
 
 function render(spans, picks, fused, opts, root) {
   const out = [];
   let budget = opts.maxChars;
+
   for (const { i, why } of picks) {
     const span = spans[i];
     const lines = span.lines.raw.slice(span.start - 1, span.end);
     let text = lines.join("\n");
+
     if (text.length > budget) {
       const end = text.lastIndexOf("\n", budget);
+
       if (end < 0) {
         if (out.length) break;
         throw new Error("evidence source line exceeds maxChars; increase the budget or read the file directly");
       }
+
       text = text.slice(0, end);
     }
+
     const lastLine = span.start + text.split("\n").length - 1;
     const truncated = lastLine < span.sourceEnd;
     budget -= text.length;
@@ -391,8 +487,10 @@ function render(spans, picks, fused, opts, root) {
       why,
       text,
     });
+
     if (budget <= 0) break;
   }
+
   return out;
 }
 
@@ -403,23 +501,31 @@ function render(spans, picks, fused, opts, root) {
 export async function selectEvidence({ query, root, searchDir, index, overlayText = () => undefined, pendingPaths = [], options = {} }) {
   const opts = { ...EVIDENCE_DEFAULTS, ...options };
   const profile = profileQuery(query);
+
   if (profile.keywords.length === 0) throw new Error("evidence requires at least one searchable concept keyword");
   const searchRoot = path.resolve(searchDir || root);
+
   const staged = pendingPaths.filter(file => {
     const relative = path.relative(searchRoot, file);
+
     return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
   });
+
   const files = [...new Set([...await index.files(searchRoot), ...staged])];
+
   if (files.length === 0) throw new Error(`no files found to search in ${searchDir || root}`);
 
   const { files: chosenFiles, fileScores } = candidateFiles(files, profile, index, opts.maxCandidateFiles, overlayText);
   const spans = [];
+
   for (const f of chosenFiles) {
     const pending = overlayText(f);
     const entry = pending === undefined ? index.entry(f) : WorkspaceIndex.fromText(f, pending);
+
     if (!entry) continue;
     spans.push(...spansOf(entry, f, opts.maxSpanLines));
   }
+
   if (spans.length === 0) return { route: profile.route, spans: [] };
 
   const graph = buildGraph(spans);
@@ -434,16 +540,24 @@ export async function selectEvidence({ query, root, searchDir, index, overlayTex
 
   // eq.15 Filter: boundary/type hard constraints and lexical support; Rank_ϕ: answer-type compatibility.
   const usage = profile.answerType === "usage";
-  const admissible = spans.map((s, i) => i).filter((i) => {
-    const p = spans[i].path;
+
+  const admissible = spans.flatMap((span, i) => {
+    const p = span.path;
     const isDoc = /\.(md|mdx|rst|txt)$/i.test(p);
-    return spans[i].support > 0 && (profile.flags.wantsTest || !isTestPath(p)) && (profile.flags.wantsDoc || !isDoc);
+
+    return span.support > 0
+      && (profile.flags.wantsTest || !isTestPath(p))
+      && (profile.flags.wantsDoc || !isDoc)
+      ? [i] : [];
   });
+
   for (const i of admissible) {
     if (usage && profile.subjects.includes(spans[i].name)) fused[i] *= 0.5; // a usage question is answered by callers
   }
+
   const ranked = admissible.sort((a, b) => fused[b] - fused[a] || spans[a].path.localeCompare(spans[b].path) || spans[a].start - spans[b].start);
   const main = ranked.slice(0, opts.k);
   const picks = closure(main, spans, graph, fused, opts.k);
+
   return { route: profile.route, spans: render(spans, picks, fused, opts, root) };
 }

package/src/context/fuzzy.js

@@ -11,8 +11,11 @@
 //   - distance penalty from the current (last touched) file: −1 per directory hop, floor −20
 
 const AI_DECAY = Math.LN2 / 3;            // per day
+
 const AI_MAX_HISTORY_DAYS = 7;
+
 const MAX_TIMESTAMPS_PER_FILE = 128;
+
 const AI_MODIFICATION_THRESHOLDS = [[16, 30], [8, 300], [4, 900], [2, 3600], [1, 14400]]; // [boost, seconds]
 
 export class Frecency {
@@ -22,8 +25,10 @@ export class Frecency {
 
   record(filePath, at = Date.now() / 1000) {
     let list = this.access.get(filePath);
+
     if (!list) this.access.set(filePath, (list = []));
     list.push(at);
+
     if (list.length > MAX_TIMESTAMPS_PER_FILE) list.splice(0, list.length - MAX_TIMESTAMPS_PER_FILE);
   }
 
@@ -31,12 +36,15 @@ export class Frecency {
   score(filePath, mtimeSec, now = Date.now() / 1000) {
     let total = 0;
     const cutoff = now - AI_MAX_HISTORY_DAYS * 86400;
+
     for (const t of this.access.get(filePath) || []) {
       if (t < cutoff) continue;
       total += Math.exp(-AI_DECAY * ((now - t) / 86400));
     }
+
     if (mtimeSec) {
       const age = now - mtimeSec;
+
       for (const [boost, seconds] of AI_MODIFICATION_THRESHOLDS) {
         if (age <= seconds) {
           total += boost;
@@ -44,6 +52,7 @@ export class Frecency {
         }
       }
     }
+
     return total;
   }
 }
@@ -53,8 +62,10 @@ const SEPARATORS = new Set(["/", "\\", "_", "-", ".", " "]);
 function isBoundary(hay, i) {
   if (i === 0) return true;
   const prev = hay[i - 1];
+
   if (SEPARATORS.has(prev)) return true;
   const c = hay[i];
+
   return c >= "A" && c <= "Z" && !(prev >= "A" && prev <= "Z");
 }
 
@@ -67,18 +78,24 @@ function matchOnce(needle, hay, caseSensitive) {
   const nCmp = caseSensitive ? needle : needle.toLowerCase();
   let hi = 0;
   let firstAt = -1;
+
   for (let ni = 0; ni < nCmp.length; ni++) {
     hi = hayCmp.indexOf(nCmp[ni], hi);
+
     if (hi < 0) return null;
+
     if (firstAt < 0) firstAt = hi;
     hi++;
   }
+
   const end = hi;
   // Tighten: walk backwards from end to find the latest possible start.
   let start = end;
+
   for (let ni = nCmp.length - 1; ni >= 0; ni--) {
     start = hayCmp.lastIndexOf(nCmp[ni], start - 1);
   }
+
   return { score: scoreAlignment(needle, nCmp, hay, hayCmp, start), start, end };
 }
 
@@ -87,6 +104,7 @@ function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
   let score = 0;
   let prev = -2;
   let cursor = start;
+
   for (let ni = 0; ni < nCmp.length; ni++) {
     const at = hayCmp.indexOf(nCmp[ni], cursor);
     score += isBoundary(hay, at) ? 16 : 0;
@@ -96,22 +114,29 @@ function scoreAlignment(needle, nCmp, hay, hayCmp, start) {
     prev = at;
     cursor = at + 1;
   }
+
   return score;
 }
 
 /** Best match allowing up to maxTypos skipped needle characters. */
 export function fuzzyMatch(needle, hay, { maxTypos = 0, caseSensitive = false } = {}) {
   const direct = matchOnce(needle, hay, caseSensitive);
+
   if (direct) return { ...direct, typos: 0, exact: hay.toLowerCase() === needle.toLowerCase() };
+
   if (maxTypos <= 0 || needle.length < 3) return null;
   let best = null;
+
   for (let i = 0; i < needle.length; i++) {
     const shorter = needle.slice(0, i) + needle.slice(i + 1);
     const m = fuzzyMatch(shorter, hay, { maxTypos: maxTypos - 1, caseSensitive });
+
     if (!m) continue;
     const scored = { ...m, score: m.score - 12, typos: m.typos + 1, exact: false };
+
     if (!best || scored.score > best.score) best = scored;
   }
+
   return best;
 }
 
@@ -125,8 +150,10 @@ function distancePenalty(currentDir, candidateDir) {
   const a = currentDir.split("/").filter(Boolean);
   const b = candidateDir.split("/").filter(Boolean);
   let common = 0;
+
   while (common < a.length && common < b.length && a[common] === b[common]) common++;
   const depth = a.length - common;
+
   return Math.max(-20, -depth);
 }
 
@@ -136,20 +163,25 @@ function distancePenalty(currentDir, candidateDir) {
  */
 export function rankPaths(query, paths, ctx = {}) {
   const parts = query.trim().split(/\s+/).filter((p) => p.length >= 2);
+
   if (parts.length === 0) return [];
   const caseSensitive = smartCase(query);
   const maxTypos = ctx.maxTypos ?? (parts[0].length >= 6 ? 2 : parts[0].length >= 4 ? 1 : 0);
   const currentDir = ctx.currentFile ? ctx.currentFile.slice(0, ctx.currentFile.lastIndexOf("/") + 1) : "";
   const out = [];
+
   for (const rel of paths) {
     const matched = matchParts(parts, rel, maxTypos, caseSensitive);
+
     if (!matched) continue;
     const { base, first, exact } = matched;
     const filenameStart = rel.lastIndexOf("/") + 1;
     const boosts = filenameBonus(base, rel, filenameStart, first, parts[0]) + contextBoost(base, rel, ctx) + distancePenalty(currentDir, rel.slice(0, filenameStart));
     out.push({ path: rel, score: base + boosts, exact, typos: first.typos });
   }
+
   out.sort((a, b) => b.score - a.score || a.path.length - b.path.length || a.path.localeCompare(b.path));
+
   return out;
 }
 
@@ -158,19 +190,23 @@ function matchParts(parts, rel, maxTypos, caseSensitive) {
   let sum = 0;
   let first = null;
   let exact = true;
+
   for (let pi = 0; pi < parts.length; pi++) {
     const m = fuzzyMatch(parts[pi], rel, { maxTypos: pi === 0 ? maxTypos : Math.min(maxTypos, 1), caseSensitive });
+
     if (!m) return null;
     first ??= m;
     sum += m.score;
     exact = exact && m.exact;
   }
+
   return { base: Math.max(1, Math.round(sum / parts.length)), first, exact };
 }
 
 /** fff: exact filename +40% of base, any filename match +20%. */
 function filenameBonus(base, rel, filenameStart, first, needle) {
   if (first.start < filenameStart) return 0;
+
   return rel.slice(filenameStart).toLowerCase() === needle.toLowerCase() ? Math.floor((base * 2) / 5) : Math.floor(base / 5);
 }
 
@@ -178,5 +214,6 @@ function filenameBonus(base, rel, filenameStart, first, needle) {
 function contextBoost(base, rel, ctx) {
   const frecency = ctx.frecency ? ctx.frecency.score(rel, ctx.mtimeOf?.(rel)) : 0;
   const gitBoost = ctx.modified?.has(rel) ? Math.floor((base * 15) / 100) : 0;
+
   return Math.floor((base * frecency) / 100) + gitBoost;
 }