opencode-fractal-memory 0.2.0

package/dist/storage/navigation.js

@@ -0,0 +1,98 @@
+export async function getNodeDepth(getNode, node, depthCache, visited = new Set()) {
+    if (!node.parentIds || node.parentIds.length === 0)
+        return 0;
+    if (visited.has(node.id))
+        return 0;
+    const cached = depthCache.get(node.id);
+    if (cached !== undefined)
+        return cached;
+    visited.add(node.id);
+    let maxParentDepth = 0;
+    for (const parentId of node.parentIds) {
+        try {
+            const parent = await getNode(parentId);
+            const parentDepth = await getNodeDepth(getNode, parent, depthCache, visited);
+            maxParentDepth = Math.max(maxParentDepth, parentDepth);
+        }
+        catch {
+            // Parent not found, skip
+        }
+    }
+    const depth = 1 + maxParentDepth;
+    depthCache.set(node.id, depth);
+    return depth;
+}
+export async function retrieveFractal(getNode, id, maxDepth = 10) {
+    const node = await getNode(id);
+    const path = [];
+    const visited = new Set();
+    let currentNode = node;
+    let depth = 0;
+    while (currentNode && depth < maxDepth) {
+        path.push(currentNode);
+        if (!currentNode.parentIds || currentNode.parentIds.length === 0)
+            break;
+        if (visited.has(currentNode.id))
+            break;
+        visited.add(currentNode.id);
+        const parentId = currentNode.parentIds[0];
+        if (!parentId)
+            break;
+        try {
+            currentNode = await getNode(parentId);
+            depth++;
+        }
+        catch {
+            break;
+        }
+    }
+    return {
+        node,
+        path,
+        depth,
+        relevanceScore: node.importance,
+    };
+}
+export async function getFractalStats(listNodes, getNode, scope) {
+    const depthCache = new Map();
+    const allNodes = await listNodes(scope);
+    const nodesPerLevel = { 0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+    let hasEmbeddings = 0;
+    const scopes = { global: 0, project: 0 };
+    const parentCounts = [];
+    let maxDepth = 0;
+    for (const node of allNodes) {
+        nodesPerLevel[node.level]++;
+        scopes[node.scope]++;
+        if (node.embedding)
+            hasEmbeddings++;
+        if (node.parentIds && node.parentIds.length > 0) {
+            parentCounts.push(node.parentIds.length);
+            const parentDepth = await getNodeDepth(getNode, node, depthCache);
+            maxDepth = Math.max(maxDepth, parentDepth);
+        }
+    }
+    const totalNodes = allNodes.length;
+    const compressionRatios = {};
+    for (let level = 0; level < 5; level++) {
+        const current = nodesPerLevel[level];
+        const next = nodesPerLevel[(level + 1)];
+        compressionRatios[level] = next > 0 && current > 0 ? current / next : 0;
+    }
+    const fractalDimension = totalNodes > 1 && maxDepth > 0
+        ? Math.log(totalNodes) / Math.log(1 + maxDepth)
+        : 0;
+    const avgChildren = parentCounts.length > 0
+        ? parentCounts.reduce((a, b) => a + b, 0) / parentCounts.length
+        : 0;
+    return {
+        totalNodes,
+        nodesPerLevel,
+        compressionRatios,
+        fractalDimension: Math.round(fractalDimension * 100) / 100,
+        avgChildrenPerNode: Math.round(avgChildren * 100) / 100,
+        treeDepth: maxDepth,
+        hasEmbeddings,
+        scopes,
+    };
+}

package/dist/storage/queries/base.js

@@ -0,0 +1,44 @@
+export function blobToEmbedding(blob) {
+    if (!blob)
+        return null;
+    const floats = new Float32Array(blob.buffer, blob.byteOffset, blob.length / 4);
+    return Array.from(floats);
+}
+export function embeddingToBlob(embedding) {
+    const floatArray = new Float32Array(embedding);
+    return Buffer.from(floatArray.buffer);
+}
+export function rowToNode(row) {
+    let embedding = null;
+    if (row.embedding_blob) {
+        embedding = blobToEmbedding(row.embedding_blob);
+    }
+    else if (row.embedding) {
+        embedding = JSON.parse(row.embedding);
+    }
+    return {
+        id: row.id,
+        scope: row.scope,
+        label: row.label || undefined,
+        content: row.content,
+        summary: row.summary,
+        level: row.level,
+        parentIds: row.parent_ids ? JSON.parse(row.parent_ids) : null,
+        embedding,
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+        importance: row.importance,
+        accessCount: row.access_count,
+        lastAccessed: row.last_accessed ? new Date(row.last_accessed) : null,
+        type: row.type,
+        metadata: row.metadata ? JSON.parse(row.metadata) : null,
+        sticky: Boolean(row.sticky),
+        ttlDays: row.ttl_days ?? null,
+        expiresAt: row.expires_at ? new Date(row.expires_at) : null,
+        confidence: row.confidence ?? 0.5,
+        lastVerified: row.last_verified ? new Date(row.last_verified) : null,
+        usefulnessScore: row.usefulness_score ?? 0,
+        timesUsed: row.times_used ?? 0,
+        timesHelpful: row.times_helpful ?? 0,
+    };
+}

package/dist/storage/queries/links.js

@@ -0,0 +1,32 @@
+export async function queryStoreLinks(db, sourceId, content, getNodeByLabel) {
+    const { extractLinks } = await import("../utils");
+    const links = extractLinks(content);
+    db.run("DELETE FROM memory_links WHERE source_id = ?", [sourceId]);
+    for (const label of links) {
+        let targetId = null;
+        try {
+            const target = await getNodeByLabel(db, "global", label);
+            if (!target) {
+                const targetProject = await getNodeByLabel(db, "project", label);
+                targetId = targetProject?.id ?? null;
+            }
+            else {
+                targetId = target.id;
+            }
+        }
+        catch { /* Target doesn't exist yet */ }
+        db.run("INSERT OR REPLACE INTO memory_links (source_id, target_label, target_id) VALUES (?, ?, ?)", [sourceId, label, targetId]);
+    }
+}
+export function queryUpdateLinksForNewNode(db, label, nodeId) {
+    db.run("UPDATE memory_links SET target_id = ? WHERE target_label = ? AND target_id IS NULL", [nodeId, label]);
+}
+export function queryGetLinks(db, sourceId) {
+    return db.query("SELECT target_label, target_id FROM memory_links WHERE source_id = ?").all(sourceId);
+}
+export function queryDeleteLinks(db, sourceId) {
+    db.run("DELETE FROM memory_links WHERE source_id = ?", [sourceId]);
+}
+export function queryDeleteLinksForTarget(db, targetId) {
+    db.run("DELETE FROM memory_links WHERE target_id = ?", [targetId]);
+}

package/dist/storage/queries/nodes.js

@@ -0,0 +1,189 @@
+import { randomUUID } from "node:crypto";
+import { embeddingToBlob, rowToNode } from "./base";
+import { getHNSWIndex } from "../../hnsw-index";
+function validateLabel(label) {
+    const trimmed = label.trim();
+    if (!/^[a-z0-9][a-z0-9-_:]{1,60}$/i.test(trimmed)) {
+        throw new Error(`Invalid label "${label}". Use letters/numbers/dash/underscore/colon (2-61 chars).`);
+    }
+    return trimmed;
+}
+export async function queryListNodes(db, scope, level, limit = 50, offset = 0, includeExpired = false) {
+    let query = "SELECT * FROM memory_nodes";
+    const params = [];
+    const conditions = [];
+    conditions.push("scope = ?");
+    params.push(scope);
+    if (level !== undefined) {
+        conditions.push("level = ?");
+        params.push(level);
+    }
+    if (!includeExpired) {
+        conditions.push("(expires_at IS NULL OR expires_at > ?)");
+        params.push(Date.now());
+    }
+    if (conditions.length > 0) {
+        query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY importance DESC, created_at DESC";
+    query += " LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const rows = db.query(query).all(...params);
+    return rows.map(rowToNode);
+}
+export async function queryGetNode(db, id) {
+    const row = db.query("SELECT * FROM memory_nodes WHERE id = ?").get(id);
+    if (!row)
+        return null;
+    return rowToNode(row);
+}
+export async function queryGetNodeByLabel(db, scope, label, includeExpired = false) {
+    const safeLabel = validateLabel(label);
+    const sql = includeExpired
+        ? "SELECT id FROM memory_nodes WHERE label = ? AND scope = ?"
+        : "SELECT id FROM memory_nodes WHERE label = ? AND scope = ? AND (expires_at IS NULL OR expires_at > ?)";
+    const params = includeExpired ? [safeLabel, scope] : [safeLabel, scope, Date.now()];
+    const row = db.query(sql).get(...params);
+    return row;
+}
+export async function queryGetNodeByLabelFull(db, scope, label, includeExpired = false) {
+    const safeLabel = validateLabel(label);
+    const sql = includeExpired
+        ? "SELECT * FROM memory_nodes WHERE label = ? AND scope = ?"
+        : "SELECT * FROM memory_nodes WHERE label = ? AND scope = ? AND (expires_at IS NULL OR expires_at > ?)";
+    const params = includeExpired ? [safeLabel, scope] : [safeLabel, scope, Date.now()];
+    const row = db.query(sql).get(...params);
+    if (!row) {
+        throw new Error(`Memory node not found: ${scope}:${safeLabel}`);
+    }
+    db.run("UPDATE memory_nodes SET access_count = access_count + 1, last_accessed = ? WHERE id = ?", [Date.now(), row.id]);
+    return { ...rowToNode(row), accessCount: row.access_count + 1 };
+}
+export async function queryGetNodeByPrefix(db, prefix) {
+    const rows = db.query("SELECT * FROM memory_nodes WHERE id LIKE ?").all(`${prefix}%`);
+    if (rows.length === 1) {
+        const row = rows[0];
+        db.run("UPDATE memory_nodes SET access_count = access_count + 1, last_accessed = ? WHERE id = ?", [Date.now(), row.id]);
+        return rowToNode(row);
+    }
+    if (rows.length > 1) {
+        throw new Error(`Ambiguous ID prefix "${prefix}" matches ${rows.length} nodes. Use full ID.`);
+    }
+    return null;
+}
+export async function queryCreateNode(db, node, storeLinks, updateLinksForNewNode, updateBM25Index) {
+    const now = Date.now();
+    const id = randomUUID();
+    const sticky = node.type === "skill" ? 1 : (node.sticky ? 1 : 0);
+    const ttlDays = node.ttlDays ?? null;
+    const expiresAt = ttlDays ? now + ttlDays * 86400000 : null;
+    const confidence = node.confidence ?? 0.5;
+    const usefulnessScore = node.usefulnessScore ?? 0;
+    const timesUsed = node.timesUsed ?? 0;
+    const timesHelpful = node.timesHelpful ?? 0;
+    db.run("INSERT INTO memory_nodes (id, scope, label, content, summary, level, parent_ids, embedding, embedding_blob, created_at, updated_at, importance, access_count, last_accessed, type, metadata, sticky, ttl_days, expires_at, confidence, usefulness_score, times_used, times_helpful) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+        id,
+        node.scope,
+        node.label ?? "",
+        node.content,
+        node.summary ?? null,
+        node.level ?? 0,
+        node.parentIds ? JSON.stringify(node.parentIds) : null,
+        node.embedding ? JSON.stringify(node.embedding) : null,
+        node.embedding ? embeddingToBlob(node.embedding) : null,
+        now,
+        now,
+        node.importance ?? 0.5,
+        0,
+        null,
+        node.type ?? null,
+        node.metadata ? JSON.stringify(node.metadata) : null,
+        sticky,
+        ttlDays,
+        expiresAt,
+        confidence,
+        usefulnessScore,
+        timesUsed,
+        timesHelpful,
+    ]);
+    // Store links
+    await storeLinks(node.scope, id, node.content);
+    if (node.label) {
+        await updateLinksForNewNode(node.scope, node.label, id);
+    }
+    updateBM25Index(db, id, node.content, node.label, node.scope);
+    // HNSW add is outside transaction (in-memory)
+    if (node.embedding) {
+        const hnsw = getHNSWIndex();
+        await hnsw.addNode(node.scope, id, node.embedding);
+    }
+    return {
+        id,
+        scope: node.scope,
+        label: node.label,
+        content: node.content,
+        summary: node.summary ?? null,
+        level: node.level ?? 0,
+        parentIds: node.parentIds ?? null,
+        embedding: node.embedding ?? null,
+        createdAt: new Date(now),
+        updatedAt: new Date(now),
+        importance: node.importance ?? 0.5,
+        accessCount: 0,
+        lastAccessed: null,
+        type: node.type ?? null,
+        metadata: node.metadata ?? null,
+        sticky: Boolean(sticky),
+        ttlDays,
+        expiresAt: expiresAt ? new Date(expiresAt) : null,
+        confidence: node.confidence ?? 0.5,
+        lastVerified: null,
+        usefulnessScore: node.usefulnessScore ?? 0,
+        timesUsed: node.timesUsed ?? 0,
+        timesHelpful: node.timesHelpful ?? 0,
+    };
+}
+const UPDATE_FIELDS = {
+    content: (v) => [["content = ?", v]],
+    summary: (v) => [["summary = ?", v]],
+    level: (v) => [["level = ?", v]],
+    parentIds: (v) => [["parent_ids = ?", v ? JSON.stringify(v) : null]],
+    importance: (v) => [["importance = ?", v]],
+    type: (v) => [["type = ?", v]],
+    metadata: (v) => [["metadata = ?", v ? JSON.stringify(v) : null]],
+    embedding: (v) => [
+        ["embedding = ?", v ? JSON.stringify(v) : null],
+        ["embedding_blob = ?", v ? embeddingToBlob(v) : null],
+    ],
+    sticky: (v) => [["sticky = ?", v ? 1 : 0]],
+    ttlDays: (v) => {
+        const now = Date.now();
+        return [
+            ["ttl_days = ?", v],
+            ["expires_at = ?", v ? now + v * 86400000 : null],
+        ];
+    },
+    confidence: (v) => [["confidence = ?", v]],
+    usefulnessScore: (v) => [["usefulness_score = ?", v]],
+    timesHelpful: (v) => [["times_helpful = ?", v]],
+};
+export async function queryUpdateNode(db, id, updates) {
+    const setClauses = ["updated_at = ?"];
+    const params = [Date.now()];
+    for (const [key, value] of Object.entries(updates)) {
+        if (value === undefined)
+            continue;
+        const field = UPDATE_FIELDS[key];
+        if (!field)
+            continue;
+        for (const [clause, param] of field(value)) {
+            setClauses.push(clause);
+            params.push(param);
+        }
+    }
+    params.push(id);
+    db.run(`UPDATE memory_nodes SET ${setClauses.join(", ")} WHERE id = ?`, params);
+}
+export async function queryDeleteNode(db, id) {
+    db.run("DELETE FROM memory_nodes WHERE id = ?", [id]);
+}

package/dist/storage/queries/search-helpers.js

@@ -0,0 +1,239 @@
+import { tokenize } from "../utils";
+import { estimateTokens } from "../../embeddings";
+const CHUNK_SIZE_TOKENS = 500;
+const OVERLAP_TOKENS = 50;
+export function cosineSimilarity(a, b) {
+    if (!a || !b || a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i] ?? 0;
+        const bi = b[i] ?? 0;
+        dotProduct += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export function updateBM25Index(db, nodeId, content, label, scope) {
+    const tokens = tokenize(content + ' ' + (label ?? ''));
+    const termFreq = new Map();
+    for (const token of tokens) {
+        termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+    }
+    db.run("DELETE FROM bm25_index WHERE node_id = ?", [nodeId]);
+    db.run("DELETE FROM bm25_doc_stats WHERE node_id = ?", [nodeId]);
+    db.run("INSERT INTO bm25_doc_stats (node_id, token_count, scope) VALUES (?, ?, ?)", [nodeId, tokens.length, scope]);
+    for (const [term, freq] of termFreq) {
+        db.run("INSERT INTO bm25_index (term, node_id, frequency, scope) VALUES (?, ?, ?, ?)", [term, nodeId, freq, scope]);
+    }
+}
+export function removeBM25Index(db, nodeId) {
+    db.run("DELETE FROM bm25_index WHERE node_id = ?", [nodeId]);
+    db.run("DELETE FROM bm25_doc_stats WHERE node_id = ?", [nodeId]);
+}
+export function calculateDynamicBm25Weight(queryLength, baseWeight) {
+    if (queryLength === 0)
+        return baseWeight;
+    const decay = Math.max(0.3, 0.6 - 0.002 * queryLength);
+    return Math.min(baseWeight, decay);
+}
+export function computeRecencyScore(lastAccessed) {
+    if (!lastAccessed)
+        return 0;
+    const hoursSinceAccess = (Date.now() - lastAccessed.getTime()) / (1000 * 60 * 60);
+    return Math.exp(-hoursSinceAccess / 24);
+}
+export function chunkContent(content, nodeId) {
+    const tokens = content.split(/\s+/);
+    const chunks = [];
+    const step = CHUNK_SIZE_TOKENS - OVERLAP_TOKENS;
+    for (let i = 0; i < tokens.length; i += step) {
+        const chunkTokens = tokens.slice(i, i + CHUNK_SIZE_TOKENS);
+        if (chunkTokens.length < 20) {
+            if (chunks.length > 0)
+                break;
+        }
+        chunks.push({
+            id: `${nodeId}:chunk:${chunks.length}`,
+            nodeId,
+            content: chunkTokens.join(' '),
+            startToken: i,
+            endToken: Math.min(i + CHUNK_SIZE_TOKENS, tokens.length),
+        });
+    }
+    return chunks;
+}
+export function isLargeNode(content) {
+    return estimateTokens(content) > CHUNK_SIZE_TOKENS;
+}
+export function rerankResults(query, nodes, topK = 10) {
+    if (nodes.length <= topK) {
+        return nodes.map(n => ({ node: n, originalScore: n.importance ?? 0, rerankScore: 1, finalScore: n.importance ?? 0 }));
+    }
+    const queryTerms = new Set(query.toLowerCase().split(/\s+/).filter(t => t.length > 2));
+    const results = [];
+    for (const node of nodes) {
+        const contentLower = node.content.toLowerCase();
+        const labelLower = (node.label ?? '').toLowerCase();
+        let keywordScore = 0;
+        const contentTerms = new Set(contentLower.split(/\s+/).filter(t => t.length > 2));
+        for (const term of queryTerms) {
+            if (contentTerms.has(term))
+                keywordScore += 1;
+            if (labelLower.includes(term))
+                keywordScore += 0.5;
+        }
+        keywordScore = Math.min(1, keywordScore / Math.max(1, queryTerms.size));
+        const firstLine = contentLower.split('\n')[0] ?? '';
+        const positionScore = firstLine.includes(query.toLowerCase()) ? 0.3 : 0;
+        const termDensity = keywordScore * 100 / Math.max(1, estimateTokens(node.content) / 10);
+        const densityScore = Math.min(0.4, termDensity * 0.1);
+        const rerankScore = keywordScore * 0.4 + positionScore + densityScore;
+        const finalScore = (node.importance ?? 0) * 0.7 + rerankScore * 0.3;
+        results.push({ node, originalScore: node.importance ?? 0, rerankScore, finalScore });
+    }
+    return results
+        .sort((a, b) => b.finalScore - a.finalScore)
+        .slice(0, topK);
+}
+const BM25_K1 = 1.2;
+const BM25_B = 0.75;
+export function computeBM25TermScore(params) {
+    const { termFrequency, documentFrequency, documentLength, averageDocumentLength, totalDocuments } = params;
+    if (documentFrequency === 0 || totalDocuments === 0)
+        return 0;
+    const idf = Math.log(totalDocuments / documentFrequency);
+    const tf = termFrequency;
+    const dl = documentLength;
+    const avgdl = averageDocumentLength;
+    return idf * (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * (dl / avgdl)));
+}
+export function computeBM25Scores(input) {
+    const { queryTerms, nodes } = input;
+    const scores = new Map();
+    if (queryTerms.length === 0 || nodes.length === 0)
+        return scores;
+    const nodeTokens = new Map();
+    let totalLength = 0;
+    for (const node of nodes) {
+        const tokens = tokenize(node.content + ' ' + (node.label ?? ''));
+        nodeTokens.set(node.id, { tokens, length: tokens.length });
+        totalLength += tokens.length;
+    }
+    const avgdl = totalLength / nodes.length;
+    for (const node of nodes) {
+        const { tokens, length } = nodeTokens.get(node.id);
+        let nodeScore = 0;
+        for (const term of queryTerms) {
+            const tf = tokens.filter(t => t === term).length;
+            if (tf === 0)
+                continue;
+            const df = nodes.filter(n => {
+                const nt = nodeTokens.get(n.id);
+                return nt && nt.tokens.includes(term);
+            }).length;
+            const score = computeBM25TermScore({
+                termFrequency: tf,
+                documentFrequency: df,
+                documentLength: length,
+                averageDocumentLength: avgdl,
+                totalDocuments: nodes.length,
+            });
+            nodeScore += score;
+        }
+        scores.set(node.id, nodeScore);
+    }
+    const maxScore = Math.max(...Array.from(scores.values()), 1);
+    for (const [id, score] of scores) {
+        scores.set(id, score / maxScore);
+    }
+    return scores;
+}
+export function computeBM25ScoresSQL(db, scope, queryTerms, nodeIds) {
+    const scores = new Map();
+    if (queryTerms.length === 0 || nodeIds.length === 0)
+        return scores;
+    const totalDocs = db.query("SELECT COUNT(*) as count FROM bm25_doc_stats WHERE scope = ?").get(scope)?.count ?? 0;
+    if (totalDocs === 0)
+        return scores;
+    const avgdl = db.query("SELECT AVG(token_count) as avg FROM bm25_doc_stats WHERE scope = ?").get(scope)?.avg ?? 0;
+    for (const nodeId of nodeIds) {
+        let nodeScore = 0;
+        for (const term of queryTerms) {
+            const tfRow = db.query("SELECT frequency FROM bm25_index WHERE term = ? AND node_id = ?").get(term, nodeId);
+            if (!tfRow)
+                continue;
+            const df = db.query("SELECT COUNT(DISTINCT node_id) as df FROM bm25_index WHERE term = ? AND scope = ?").get(term, scope)?.df ?? 0;
+            if (df === 0)
+                continue;
+            const docLength = db.query("SELECT token_count FROM bm25_doc_stats WHERE node_id = ?").get(nodeId)?.token_count ?? avgdl;
+            nodeScore += computeBM25TermScore({
+                termFrequency: tfRow.frequency,
+                documentFrequency: df,
+                documentLength: docLength,
+                averageDocumentLength: avgdl,
+                totalDocuments: totalDocs,
+            });
+        }
+        scores.set(nodeId, nodeScore);
+    }
+    const maxScore = Math.max(...Array.from(scores.values()), 1);
+    for (const [id, score] of scores) {
+        scores.set(id, score / maxScore);
+    }
+    return scores;
+}
+export function buildScoredNodes(query, nodesWithEmbeddings, weights, options) {
+    const scoredNodes = [];
+    for (const { node, embedding, hnswScore } of nodesWithEmbeddings) {
+        const level = node.level;
+        if (options?.minLevel !== undefined && level < options.minLevel)
+            continue;
+        if (options?.maxLevel !== undefined && level > options.maxLevel)
+            continue;
+        if (options?.minUsefulness !== undefined && (node.usefulnessScore ?? 0) < options.minUsefulness)
+            continue;
+        const baseScore = hnswScore !== undefined
+            ? (cosineSimilarity(query, embedding) + hnswScore) / 2
+            : cosineSimilarity(query, embedding);
+        const levelWeight = weights[level] ?? 1;
+        const confidence = node.confidence ?? 0.5;
+        const confidenceWeight = 0.5 + 0.5 * confidence;
+        scoredNodes.push({
+            ...node,
+            importance: baseScore * levelWeight * confidenceWeight * (1 + (node.usefulnessScore ?? 0) * 0.1),
+        });
+    }
+    return scoredNodes;
+}
+export function computeFinalScores(scoredNodes, options) {
+    const bm25Weight = options?.bm25Weight ?? 0.4;
+    const queryText = options?.queryText ?? "";
+    const queryLength = queryText ? tokenize(queryText).length : 0;
+    const dynamicBm25Weight = calculateDynamicBm25Weight(queryLength, bm25Weight);
+    const bm25Scores = options?.bm25Scores ?? (bm25Weight > 0 && queryText
+        ? computeBM25Scores({ queryTerms: tokenize(queryText), nodes: scoredNodes })
+        : new Map());
+    const finalNodes = [];
+    for (const node of scoredNodes) {
+        const bm25Score = bm25Scores.get(node.id) ?? 0;
+        const recencyScore = computeRecencyScore(node.lastAccessed);
+        let finalScore;
+        if (bm25Weight > 0 && queryText) {
+            const semanticWeight = 1 - dynamicBm25Weight;
+            finalScore = ((node.importance ?? 0) * semanticWeight + bm25Score * dynamicBm25Weight);
+        }
+        else {
+            finalScore = node.importance ?? 0;
+        }
+        finalScore = finalScore * (1 + recencyScore * 0.2);
+        finalNodes.push({
+            ...node,
+            importance: finalScore,
+        });
+    }
+    return finalNodes;
+}

package/dist/storage/scoring.js

@@ -0,0 +1,36 @@
+import { withRetry } from "./utils";
+import { memLog } from "../logging";
+export async function runScoreDecay(getDb, decayDays) {
+    const now = Date.now();
+    const cutoffMs = now - decayDays * 24 * 60 * 60 * 1000;
+    const msPerDay = 24 * 60 * 60 * 1000;
+    let total = 0;
+    for (const scope of ["global", "project"]) {
+        const db = await getDb(scope);
+        const result = await withRetry(() => {
+            return db.run(`UPDATE memory_nodes SET
+           usefulness_score = MAX(0, usefulness_score - MIN(1.0, (? - COALESCE(last_accessed, updated_at)) / ?) * 0.5),
+           updated_at = ?
+         WHERE COALESCE(last_accessed, updated_at) < ? AND usefulness_score > 0 AND (type IS NULL OR type != 'skill')`, [now, decayDays * msPerDay, now, cutoffMs]);
+        });
+        total += Number(result.changes ?? 0);
+    }
+    if (total > 0) {
+        memLog("info", "score-decay", `Decayed ${total} nodes via SQL`);
+    }
+    return total;
+}
+export function calculateNodeConfidence(node) {
+    if (node.type === "skill")
+        return node.confidence;
+    const age = Date.now() - node.updatedAt.getTime();
+    const ageInDays = age / (24 * 60 * 60 * 1000);
+    const baseConfidence = node.confidence;
+    const decayFactor = Math.exp(-ageInDays / 365);
+    const ageConfidence = baseConfidence * decayFactor;
+    const verifiedBonus = node.lastVerified
+        ? Math.max(0, 0.1 - (Date.now() - node.lastVerified.getTime()) / (24 * 60 * 60 * 1000 * 30))
+        : 0;
+    const finalConfidence = Math.max(0, Math.min(1, ageConfidence + verifiedBonus));
+    return Math.round(finalConfidence * 100) / 100;
+}