opencode-fractal-memory 0.2.0

package/dist/storage/compress-ops.js

@@ -0,0 +1,129 @@
+import { rowToNode } from "./queries/base";
+import { generateEmbedding } from "../embeddings";
+import { CompressionHelper, COMPRESSION_LEVELS } from "./compression";
+export async function getCompressionCandidates(getDb, scope, level, maxAgeMs, force) {
+    const config = COMPRESSION_LEVELS[level];
+    if (!config)
+        return [];
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    const candidates = [];
+    for (const s of scopes) {
+        const db = await getDb(s);
+        if (force) {
+            const rows = db.query("SELECT * FROM memory_nodes WHERE scope = ? AND level = ? AND length(content) > 100 AND (sticky IS NULL OR sticky = 0) ORDER BY importance DESC").all(s, level);
+            candidates.push(...rows.map(rowToNode));
+        }
+        else {
+            const threshold = maxAgeMs ?? config.maxAgeMs;
+            const cutoffTime = Date.now() - threshold;
+            const rows = db.query("SELECT * FROM memory_nodes WHERE scope = ? AND level = ? AND updated_at < ? AND length(content) > 100 AND (sticky IS NULL OR sticky = 0) ORDER BY importance DESC").all(s, level, cutoffTime);
+            candidates.push(...rows.map(rowToNode));
+        }
+    }
+    return candidates;
+}
+export async function runCompression(deps, scope, force, client) {
+    let compressed = 0;
+    let created = 0;
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    for (const s of scopes) {
+        for (const level of [0, 1, 2, 3]) {
+            const config = COMPRESSION_LEVELS[level];
+            if (!config)
+                continue;
+            const candidates = await deps.getCompressionCandidates(s, level, undefined, force);
+            const clusters = CompressionHelper.findRelatedNodes(candidates, 0.3);
+            for (const cluster of clusters) {
+                const useLlm = !!client;
+                const summary = useLlm
+                    ? await CompressionHelper.generateLLMSummary(cluster, client, 500)
+                    : CompressionHelper.generateStructuredSummary(cluster);
+                let summaryEmbedding = null;
+                try {
+                    summaryEmbedding = await generateEmbedding(summary);
+                }
+                catch {
+                    // Embedding generation failed, continue without it
+                }
+                const summaryNode = await deps.createNode({
+                    scope: s,
+                    label: `summary-l${config.nextLevel}-group-${Date.now()}`,
+                    content: summary,
+                    summary: `Fractal summary of ${cluster.length} related nodes`,
+                    level: config.nextLevel,
+                    parentIds: cluster.map((node) => node.id),
+                    embedding: summaryEmbedding,
+                    importance: Math.max(...cluster.map((n) => n.importance)) * 0.9,
+                    type: "summary",
+                    metadata: null,
+                });
+                for (const node of cluster) {
+                    await deps.updateNode(node.id, {
+                        summary: `Group compressed into ${summaryNode.id.slice(0, 8)}`,
+                    });
+                }
+                compressed += cluster.length;
+                created++;
+            }
+        }
+    }
+    return { compressed, created };
+}
+export async function runPatternExtraction(deps, scope, minSourceCount = 2) {
+    let created = 0;
+    let sources = 0;
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    for (const s of scopes) {
+        const nodes = await deps.listNodes(s, 0);
+        const eligibleNodes = nodes.filter((n) => n.content.length > 50 &&
+            !n.sticky &&
+            n.type !== "summary");
+        if (eligibleNodes.length < 2)
+            continue;
+        const patterns = CompressionHelper.extractPatterns(eligibleNodes);
+        const sourceNodeIds = eligibleNodes.map((n) => n.id);
+        sources = sourceNodeIds.length;
+        const totalPatternCount = patterns.decisions.size +
+            patterns.preferences.size +
+            patterns.conventions.size +
+            patterns.tools.size +
+            patterns.files.size;
+        if (totalPatternCount === 0)
+            continue;
+        const summary = CompressionHelper.generatePatternSummary(patterns, sourceNodeIds);
+        let summaryEmbedding = null;
+        try {
+            summaryEmbedding = await generateEmbedding(summary);
+        }
+        catch {
+            // Embedding generation failed, continue without it
+        }
+        const summaryNode = await deps.createNode({
+            scope: s,
+            label: `patterns-${Date.now()}`,
+            content: summary,
+            summary: `Cross-layer patterns extracted from ${sourceNodeIds.length} nodes`,
+            level: 1,
+            parentIds: sourceNodeIds,
+            embedding: summaryEmbedding,
+            importance: 0.7,
+            type: "summary",
+            metadata: {
+                patternTypes: [
+                    patterns.decisions.size > 0 ? "decisions" : null,
+                    patterns.preferences.size > 0 ? "preferences" : null,
+                    patterns.conventions.size > 0 ? "conventions" : null,
+                    patterns.tools.size > 0 ? "tools" : null,
+                    patterns.files.size > 0 ? "files" : null,
+                ].filter(Boolean),
+            },
+        });
+        for (const node of eligibleNodes) {
+            await deps.updateNode(node.id, {
+                summary: `Pattern extraction: ${summaryNode.id.slice(0, 8)}`,
+            });
+        }
+        created++;
+    }
+    return { created, sources };
+}

package/dist/storage/compression/formatters.js

@@ -0,0 +1,243 @@
+export const LEVEL_FORMATTERS = {
+    1: (nodes) => {
+        const lines = ["## Weekly Summary", ""];
+        const byDay = new Map();
+        for (const node of nodes) {
+            const day = node.createdAt.toISOString().split('T')[0];
+            if (!byDay.has(day))
+                byDay.set(day, []);
+            byDay.get(day).push(node);
+        }
+        for (const [day, dayNodes] of byDay) {
+            lines.push(`### ${day}`);
+            for (const n of dayNodes) {
+                lines.push(`- ${n.content.slice(0, 100)}...`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    },
+    2: (nodes) => {
+        const lines = ["## Monthly Themes", ""];
+        const themes = new Map();
+        for (const node of nodes) {
+            const theme = node.label ?? node.type ?? "general";
+            if (!themes.has(theme))
+                themes.set(theme, []);
+            themes.get(theme).push(node);
+        }
+        for (const [theme, themeNodes] of themes) {
+            lines.push(`### ${theme} (${themeNodes.length} items)`);
+            for (const n of themeNodes.slice(0, 5)) {
+                lines.push(`- ${n.content.slice(0, 80)}...`);
+            }
+            if (themeNodes.length > 5) {
+                lines.push(`  ... and ${themeNodes.length - 5} more`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    },
+    3: (nodes) => {
+        const lines = ["## Quarterly Report", "", "### Key Trends"];
+        const sorted = [...nodes].sort((a, b) => b.importance - a.importance);
+        for (const node of sorted.slice(0, 10)) {
+            lines.push(`- **${node.label ?? "Item"}**: ${node.content.slice(0, 100)}`);
+        }
+        lines.push("", "### Outcomes");
+        const highImportance = nodes.filter(n => n.importance > 0.7);
+        lines.push(`- ${highImportance.length} high-priority items identified`);
+        lines.push(`- ${nodes.length - highImportance.length} standard items`);
+        lines.push("");
+        lines.push(`_Summary of ${nodes.length} items_`);
+        return lines.join("\n");
+    },
+};
+export function generateSummary(node) {
+    if (LEVEL_FORMATTERS[node.level]) {
+        return LEVEL_FORMATTERS[node.level]([node]);
+    }
+    const content = node.content;
+    const lines = content.split('\n').filter(l => l.trim());
+    if (lines.length <= 5) {
+        return content;
+    }
+    const headingLines = lines.filter(l => l.startsWith('#') || l.startsWith('##'));
+    const bulletLines = lines.filter(l => l.startsWith('- ') || l.startsWith('* '));
+    const importantLines = lines.filter(l => l.length > 30 &&
+        !l.startsWith('#') &&
+        !l.startsWith('-'));
+    const summaryParts = [];
+    if (headingLines.length > 0) {
+        summaryParts.push(`Topics covered (${headingLines.length}):`);
+        summaryParts.push(...headingLines.slice(0, 5));
+        summaryParts.push('');
+    }
+    if (bulletLines.length > 0) {
+        summaryParts.push(`Key points (${bulletLines.length} items):`);
+        summaryParts.push(...bulletLines.slice(0, 8));
+        if (bulletLines.length > 8) {
+            summaryParts.push(`... and ${bulletLines.length - 8} more items`);
+        }
+    }
+    else if (importantLines.length > 0) {
+        summaryParts.push(`Key insights:`);
+        summaryParts.push(...importantLines.slice(0, 5));
+    }
+    if (summaryParts.length === 0) {
+        const firstFew = lines.slice(0, 3);
+        const lastFew = lines.slice(-2);
+        summaryParts.push(`Summary of ${lines.length} lines:`);
+        summaryParts.push(...firstFew);
+        summaryParts.push(`... (${lines.length - 5} more lines)`);
+        summaryParts.push(...lastFew);
+    }
+    return summaryParts.join('\n');
+}
+export function generateStructuredSummary(nodes) {
+    const allContent = nodes.map(n => n.content).join('\n\n');
+    const lines = allContent.split('\n').map(l => l.trim()).filter(l => l.length > 0);
+    const decisions = [];
+    const files = [];
+    const patterns = [];
+    const nextSteps = [];
+    const concepts = [];
+    const tools = [];
+    const filePattern = /\b[\w-]+\.(ts|js|tsx|jsx|py|md|json|yml|yaml|sql|sh)\b/gi;
+    const toolPattern = /\b(memory_\w+|journal_\w+|bash|git|npm|bun|tsc|test)\b/gi;
+    const decisionPatterns = [
+        /decides?:?\s*/i,
+        /chose\s+\w+/i,
+        /agreed\s+(to|that)/i,
+        /settled\s+on/i,
+        /opted\s+(for|in)/i,
+        /will\s+use/i,
+        /using\s+\w+\s+for/i,
+    ];
+    const nextPatterns = [
+        /^[-*]\s*(next|todo|will|should|need to|plan to)/i,
+        /next\s+step/i,
+        /pending/i,
+        /^#+\s*(next|todo|tasks?)/i,
+    ];
+    const conceptPatterns = [
+        /learned:?\s*/i,
+        /pattern:?\s*/i,
+        /convention:?\s*/i,
+        /architecture/i,
+        /design\s+decision/i,
+    ];
+    for (const line of lines) {
+        if (decisionPatterns.some(p => p.test(line)) && !decisionPatterns[5]?.test(line.slice(0, 20))) {
+            const clean = line.replace(/^[-*#\s]+/, '').slice(0, 120);
+            if (clean.length > 20 && !decisions.includes(clean)) {
+                decisions.push(clean);
+            }
+        }
+        if (nextPatterns.some(p => p.test(line))) {
+            const clean = line.replace(/^[-*#\s]+/, '').slice(0, 120);
+            if (clean.length > 10 && !nextSteps.includes(clean)) {
+                nextSteps.push(clean);
+            }
+        }
+        if (conceptPatterns.some(p => p.test(line))) {
+            const clean = line.replace(/^[-*#\s]+/, '').slice(0, 120);
+            if (clean.length > 10 && !patterns.includes(clean)) {
+                patterns.push(clean);
+            }
+        }
+        const fileMatches = line.match(filePattern);
+        if (fileMatches) {
+            for (const f of fileMatches) {
+                if (!files.includes(f)) {
+                    files.push(f);
+                }
+            }
+        }
+        const toolMatches = line.match(toolPattern);
+        if (toolMatches) {
+            for (const t of toolMatches) {
+                if (!tools.includes(t)) {
+                    tools.push(t);
+                }
+            }
+        }
+    }
+    for (const line of lines.slice(0, 20)) {
+        const headingMatch = line.match(/^#+\s+(.+)/);
+        if (headingMatch && !headingMatch[1].toLowerCase().includes('summary')) {
+            const concept = headingMatch[1].slice(0, 80);
+            if (!concepts.includes(concept)) {
+                concepts.push(concept);
+            }
+        }
+    }
+    const result = ['## Structured Summary', ''];
+    if (decisions.length > 0) {
+        result.push('### Decisions');
+        for (const d of decisions.slice(0, 5)) {
+            result.push(`- ${d}`);
+        }
+        if (decisions.length > 5) {
+            result.push(`- ... and ${decisions.length - 5} more`);
+        }
+        result.push('');
+    }
+    if (files.length > 0) {
+        result.push('### Files');
+        result.push(`_Modified or referenced: ${files.slice(0, 10).join(', ')}_`);
+        if (files.length > 10) {
+            result.push(`_... and ${files.length - 10} more_`);
+        }
+        result.push('');
+    }
+    if (tools.length > 0) {
+        result.push('### Tools');
+        result.push(`_${tools.slice(0, 8).join(', ')}_`);
+        result.push('');
+    }
+    if (patterns.length > 0) {
+        result.push('### Patterns & Conventions');
+        for (const p of patterns.slice(0, 5)) {
+            result.push(`- ${p}`);
+        }
+        result.push('');
+    }
+    if (concepts.length > 0) {
+        result.push('### Topics');
+        for (const c of concepts.slice(0, 6)) {
+            result.push(`- ${c}`);
+        }
+        result.push('');
+    }
+    if (nextSteps.length > 0) {
+        result.push('### Next Steps');
+        for (const n of nextSteps.slice(0, 5)) {
+            result.push(`- ${n}`);
+        }
+        if (nextSteps.length > 5) {
+            result.push(`- ... and ${nextSteps.length - 5} more`);
+        }
+        result.push('');
+    }
+    if (decisions.length === 0 && files.length === 0 && patterns.length === 0 && concepts.length === 0 && nextSteps.length === 0) {
+        const topics = [...new Set(lines.filter(l => l.startsWith('-') || l.startsWith('*')).map(l => l.replace(/^[-*]\s+/, '').slice(0, 60)))];
+        result.push('### Key Points');
+        for (const t of topics.slice(0, 8)) {
+            result.push(`- ${t}`);
+        }
+        result.push('');
+    }
+    result.push(`_Compressed from ${nodes.length} node(s)_`);
+    return result.join('\n');
+}
+export function generateLLMSummaryPrompt(node) {
+    return `Create a concise summary of the following memory content. Focus on the key points and essential information. Keep it under 200 words.
+
+Memory content:
+---
+${node.content}
+---
+
+Summary:`;
+}

package/dist/storage/compression/index.js

@@ -0,0 +1,107 @@
+import { cosineSimilarity } from "../queries/search-helpers";
+import { generateSummary, generateStructuredSummary, generateLLMSummaryPrompt, } from "./formatters";
+import { extractPatterns as ep, generatePatternSummary } from "./patterns";
+export { generateSummary, generateStructuredSummary, generateLLMSummaryPrompt } from "./formatters";
+export { extractPatterns, generatePatternSummary } from "./patterns";
+export const COMPRESSION_LEVELS = {
+    0: { maxAgeMs: 7 * 24 * 60 * 60 * 1000, nextLevel: 1, label: "Weekly", format: "events" },
+    1: { maxAgeMs: 30 * 24 * 60 * 60 * 1000, nextLevel: 2, label: "Monthly", format: "themes" },
+    2: { maxAgeMs: 90 * 24 * 60 * 60 * 1000, nextLevel: 3, label: "Quarterly", format: "trends" },
+    3: { maxAgeMs: 365 * 24 * 60 * 60 * 1000, nextLevel: 4, label: "Yearly", format: "milestones" },
+};
+export class CompressionHelper {
+    static async findCompressionCandidates(nodes, level, maxAgeMs, force) {
+        const config = COMPRESSION_LEVELS[level];
+        if (!config)
+            return [];
+        if (force) {
+            return nodes.filter(n => n.level === level && n.content.length > 100 && !n.sticky);
+        }
+        const threshold = maxAgeMs ?? config.maxAgeMs;
+        const cutoffTime = Date.now() - threshold;
+        return nodes.filter(n => n.level === level &&
+            n.updatedAt.getTime() < cutoffTime &&
+            n.content.length > 100 &&
+            !n.sticky);
+    }
+    static findRelatedNodes(nodes, threshold = 0.3) {
+        const visited = new Set();
+        const clusters = [];
+        for (let i = 0; i < nodes.length; i++) {
+            const nodeA = nodes[i];
+            if (visited.has(nodeA.id))
+                continue;
+            if (!nodeA.embedding)
+                continue;
+            const cluster = [nodeA];
+            visited.add(nodeA.id);
+            for (let j = i + 1; j < nodes.length; j++) {
+                const nodeB = nodes[j];
+                if (visited.has(nodeB.id))
+                    continue;
+                if (!nodeB.embedding)
+                    continue;
+                const similarity = cosineSimilarity(nodeA.embedding, nodeB.embedding);
+                if (similarity >= threshold) {
+                    cluster.push(nodeB);
+                    visited.add(nodeB.id);
+                }
+            }
+            if (cluster.length >= 2) {
+                clusters.push(cluster);
+            }
+        }
+        return clusters;
+    }
+    static generateSummary(node) {
+        return generateSummary(node);
+    }
+    static generateLLMSummaryPrompt(node) {
+        return generateLLMSummaryPrompt(node);
+    }
+    static generateStructuredSummary(nodes) {
+        return generateStructuredSummary(nodes);
+    }
+    static async generateLLMSummary(nodes, client, maxTokens = 500) {
+        const allContent = nodes.map(n => `---\nLabel: ${n.label ?? "unnamed"}\nLevel: ${n.level}\nImportance: ${n.importance}\n\n${n.content}`).join('\n\n');
+        const prompt = `Create a structured summary of the following ${nodes.length} related memory nodes. Extract the key information and organize it into sections.
+
+Extract:
+1. Key decisions or conclusions
+2. Files, libraries, or code patterns referenced
+3. Tools or commands used
+4. Design patterns or conventions discovered
+5. Next steps or pending items
+
+Nodes:
+${allContent}
+
+Structured summary:`;
+        try {
+            const sessionClient = client;
+            const result = await sessionClient.session?.prompt({
+                path: { id: 'compression' },
+                body: {
+                    noReply: true,
+                    parts: [{ type: 'text', text: prompt }],
+                },
+            });
+            if (result) {
+                const response = await result.text();
+                const trimmed = response.trim();
+                if (trimmed)
+                    return trimmed;
+            }
+        }
+        catch (e) {
+            // LLM failed, fall through to regex fallback
+        }
+        return generateStructuredSummary(nodes);
+    }
+    static extractPatterns(nodes) {
+        return ep(nodes);
+    }
+    static generatePatternSummary(patterns, sourceNodeIds) {
+        return generatePatternSummary(patterns, sourceNodeIds);
+    }
+}

package/dist/storage/compression/patterns.js

@@ -0,0 +1,138 @@
+export function extractPatterns(nodes) {
+    const files = new Map();
+    const tools = new Map();
+    const conventions = new Map();
+    const preferences = new Map();
+    const decisions = new Map();
+    const filePattern = /\b[\w-]+\.(ts|js|tsx|jsx|py|md|json|yml|yaml|sql|sh|css|html)\b/gi;
+    const toolPattern = /\b(memory_\w+|journal_\w+|git|npm|bun|tsc|test|make|cmake|pip|python|node)\b/gi;
+    const conventionPatterns = [
+        /convention:?\s*/i,
+        /standard:?\s*/i,
+        /best\s+practice/i,
+        /always\s+(use|run|follow)/i,
+        /never\s+(use|do)/i,
+        /rule:?\s*/i,
+    ];
+    const preferencePatterns = [
+        /user\s+(prefers?|likes?|wants?)/i,
+        /prefers?\s+\w+/i,
+        /likes?\s+\w+/i,
+        /uses?\s+\w+/i,
+        /favorite:?\s*/i,
+    ];
+    const decisionPatterns = [
+        /decided?\s+(to|on|that)/i,
+        /chose\s+\w+/i,
+        /agreed?\s+(to|that)/i,
+        /will\s+use/i,
+        /using\s+\w+\s+for/i,
+    ];
+    for (const node of nodes) {
+        const contentLines = node.content.split('\n');
+        for (const line of contentLines) {
+            const fileMatches = line.match(filePattern);
+            if (fileMatches) {
+                for (const f of fileMatches) {
+                    const existing = files.get(f) || [];
+                    if (!existing.includes(node.id)) {
+                        existing.push(node.id);
+                        files.set(f, existing);
+                    }
+                }
+            }
+            const toolMatches = line.match(toolPattern);
+            if (toolMatches) {
+                for (const t of toolMatches) {
+                    const existing = tools.get(t) || [];
+                    if (!existing.includes(node.id)) {
+                        existing.push(node.id);
+                        tools.set(t, existing);
+                    }
+                }
+            }
+            for (const pattern of conventionPatterns) {
+                if (pattern.test(line)) {
+                    const key = line.replace(/^[-*#\s]+/, '').slice(0, 80);
+                    const existing = conventions.get(key) || [];
+                    if (!existing.includes(node.id)) {
+                        existing.push(node.id);
+                        conventions.set(key, existing);
+                    }
+                    break;
+                }
+            }
+            for (const pattern of preferencePatterns) {
+                if (pattern.test(line)) {
+                    const key = line.replace(/^[-*#\s]+/, '').slice(0, 80);
+                    const existing = preferences.get(key) || [];
+                    if (!existing.includes(node.id)) {
+                        existing.push(node.id);
+                        preferences.set(key, existing);
+                    }
+                    break;
+                }
+            }
+            for (const pattern of decisionPatterns) {
+                if (pattern.test(line)) {
+                    const key = line.replace(/^[-*#\s]+/, '').slice(0, 80);
+                    const existing = decisions.get(key) || [];
+                    if (!existing.includes(node.id)) {
+                        existing.push(node.id);
+                        decisions.set(key, existing);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return { files, tools, conventions, preferences, decisions };
+}
+export function generatePatternSummary(patterns, sourceNodeIds) {
+    const result = ['## Cross-Layer Pattern Summary', ''];
+    if (patterns.decisions.size > 0) {
+        result.push('### Key Decisions');
+        for (const [decision, sources] of patterns.decisions) {
+            if (sources.length >= 1) {
+                result.push(`- ${decision}`);
+            }
+        }
+        result.push('');
+    }
+    if (patterns.preferences.size > 0) {
+        result.push('### User Preferences');
+        for (const [pref, sources] of patterns.preferences) {
+            if (sources.length >= 1) {
+                result.push(`- ${pref}`);
+            }
+        }
+        result.push('');
+    }
+    if (patterns.conventions.size > 0) {
+        result.push('### Conventions & Standards');
+        for (const [conv, sources] of patterns.conventions) {
+            if (sources.length >= 1) {
+                result.push(`- ${conv}`);
+            }
+        }
+        result.push('');
+    }
+    if (patterns.tools.size > 0) {
+        const toolCounts = Array.from(patterns.tools.entries())
+            .map(([tool, sources]) => ({ tool, count: sources.length }))
+            .sort((a, b) => b.count - a.count);
+        result.push('### Tools Used');
+        result.push(`_${toolCounts.slice(0, 10).map(t => `${t.tool} (${t.count}x)`).join(', ')}_`);
+        result.push('');
+    }
+    if (patterns.files.size > 0) {
+        const fileCounts = Array.from(patterns.files.entries())
+            .map(([file, sources]) => ({ file, count: sources.length }))
+            .sort((a, b) => b.count - a.count);
+        result.push('### Key Files');
+        result.push(`_${fileCounts.slice(0, 10).map(f => f.file).join(', ')}_`);
+        result.push('');
+    }
+    result.push(`_Extracted from ${sourceNodeIds.length} source nodes_`);
+    return result.join('\n');
+}

package/dist/storage/expiration.js

@@ -0,0 +1,66 @@
+import { rowToNode } from "./queries/base";
+import { withRetry } from "./utils";
+export async function getExpiredNodes(getDb, scope = "all") {
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    const expired = [];
+    const now = Date.now();
+    for (const s of scopes) {
+        const db = await getDb(s);
+        const rows = db.query("SELECT * FROM memory_nodes WHERE expires_at IS NOT NULL AND expires_at <= ? AND (type IS NULL OR type != 'skill')").all(now);
+        expired.push(...rows.map(rowToNode));
+    }
+    return expired;
+}
+export async function deleteExpiredNodes(getDb, scope = "all") {
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    let deleted = 0;
+    for (const s of scopes) {
+        const db = await getDb(s);
+        const result = db.run("DELETE FROM memory_nodes WHERE expires_at IS NOT NULL AND expires_at <= ? AND (type IS NULL OR type != 'skill')", [Date.now()]);
+        deleted += Number(result.changes);
+    }
+    return deleted;
+}
+export async function pruneNodes(deps, scope, options = {}) {
+    const { minAccessCount = 0, maxAgeDays = 90, minImportance = 0, excludeSticky = true, excludeCore = true, dryRun = true, } = options;
+    const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+    const cutoffTime = Date.now() - maxAgeMs;
+    const scopes = scope === "all" ? ["global", "project"] : [scope];
+    const prunable = [];
+    const coreLabels = new Set(["persona", "human", "current-state", "project"]);
+    for (const s of scopes) {
+        const nodes = await deps.listNodes(s);
+        for (const node of nodes) {
+            if (excludeSticky && node.sticky)
+                continue;
+            if (excludeCore && node.label && coreLabels.has(node.label))
+                continue;
+            if (node.importance >= 0.9)
+                continue;
+            const isLowAccess = node.accessCount <= minAccessCount;
+            const isStale = node.updatedAt.getTime() < cutoffTime;
+            const isLowImportance = node.importance < minImportance;
+            if ((isLowAccess || isStale) && isLowImportance) {
+                prunable.push(node);
+            }
+        }
+    }
+    let pruned = 0;
+    if (!dryRun && prunable.length > 0) {
+        const byScope = new Map();
+        for (const node of prunable) {
+            const list = byScope.get(node.scope);
+            if (list)
+                list.push(node.id);
+            else
+                byScope.set(node.scope, [node.id]);
+        }
+        for (const [s, ids] of byScope) {
+            const db = await deps.getDb(s);
+            const placeholders = ids.map(() => "?").join(",");
+            await withRetry(() => db.run(`DELETE FROM memory_nodes WHERE id IN (${placeholders})`, ids));
+            pruned += ids.length;
+        }
+    }
+    return { prunable, pruned };
+}

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { createSqliteMemoryStore } from "./sqlite";