opencode-fractal-memory 0.2.0

package/dist/plugin/init.js

@@ -0,0 +1,109 @@
+import { createSqliteMemoryStore as createMemoryStore } from "../storage/sqlite";
+import { loadMemConfig } from "../config";
+import { generateEmbedding } from "../embeddings";
+import { ensureModels, ensureAgentFiles, ensureCommandFiles } from "../ensure-models";
+import { createAutoRetrieveHook } from "../hooks";
+import { loadConfig } from "../journal";
+import { createJournalStore } from "../journal";
+import { startManagementServer } from "../management-server";
+import { SEED_NODES } from "../seed-nodes";
+import * as tools from "../tools";
+import { memLog } from "../logging";
+import { setCacheConfig } from "../cache";
+import { setHighContextThreshold, setCriticalContextThreshold, setMaxInjectionTokens, setCoreInjectionTokens, setAutoCompressThreshold } from "./state";
+export async function initStorage(directory) {
+    const store = createMemoryStore(directory);
+    await store.ensureSeed();
+    await ensureModels();
+    await ensureAgentFiles().catch(() => { });
+    await ensureCommandFiles().catch(() => { });
+    return store;
+}
+export async function loadPluginConfig(directory) {
+    const memConfig = await loadMemConfig(directory);
+    memLog("info", "config", "[plugin] Config loaded", { directory, autoRetrieve: memConfig.autoRetrieve });
+    setHighContextThreshold(memConfig.highContextThreshold);
+    setCriticalContextThreshold(memConfig.criticalContextThreshold);
+    setMaxInjectionTokens(memConfig.maxInjectionTokens);
+    setCoreInjectionTokens(memConfig.coreInjectionTokens);
+    setAutoCompressThreshold(memConfig.autoCompressThreshold);
+    setCacheConfig(memConfig.cacheSize, memConfig.cacheTTLHours);
+    return memConfig;
+}
+export async function seedRuleNodes(store) {
+    for (const seed of SEED_NODES) {
+        try {
+            await store.getNodeByLabel("global", seed.label);
+        }
+        catch {
+            await store.createNode({
+                scope: "global",
+                label: seed.label,
+                content: seed.content,
+                summary: seed.summary ?? null,
+                type: (seed.type ?? "note"),
+                level: 0,
+                parentIds: null,
+                embedding: null,
+                importance: 1,
+                metadata: seed.metadata ?? null,
+            });
+        }
+    }
+}
+export async function backfillData(store) {
+    for (const scope of ["global", "project"]) {
+        await store.backfillLinks(scope);
+        await store.backfillBinaryEmbeddingsAndBM25(scope);
+    }
+    await store.rebuildHNSWIndex();
+}
+export function scheduleBackgroundEmbeddings(store) {
+    setTimeout(async () => {
+        try {
+            const nodes = await store.listNodes("all");
+            const withoutEmbeddings = nodes.filter(n => !n.embedding);
+            if (withoutEmbeddings.length === 0)
+                return;
+            for (const node of withoutEmbeddings) {
+                try {
+                    if (!node.content || node.content.trim().length < 10)
+                        continue;
+                    const embedding = await generateEmbedding(node.content);
+                    await store.updateNode(node.id, { embedding });
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+    }, 1000);
+}
+export async function setupJournal(directory) {
+    const config = await loadConfig();
+    if (!config.journal?.enabled)
+        return {};
+    const journalStore = createJournalStore();
+    return {
+        journal_write: tools.JournalWrite(journalStore, { directory, model: "", provider: "" }),
+        journal_read: tools.JournalRead(journalStore),
+        journal_search: tools.JournalSearch(journalStore),
+    };
+}
+export function startManagementIfEnabled(store, directory) {
+    const config = { enabled: true, port: 8787 };
+    loadConfig().then(c => {
+        const mgmtConfig = c.management;
+        if (mgmtConfig?.enabled === true) {
+            startManagementServer(store, directory, { enabled: true, port: mgmtConfig?.port ?? 8787 });
+        }
+    }).catch(() => { });
+}
+export function createAutoRetrieveIfEnabled(store, memConfig) {
+    return memConfig?.autoRetrieve?.enabled
+        ? createAutoRetrieveHook({
+            store,
+            config: memConfig,
+            log: (level, msg, data) => memLog(level, "auto-retrieve", msg, data),
+        })
+        : null;
+}

package/dist/plugin/state.js

@@ -0,0 +1,75 @@
+import { getWorkingCache } from "../cache";
+import { memLog } from "../logging";
+import { loadMemConfig } from "../config";
+export let CONTEXT_LIMIT = 128000;
+export let HIGH_CONTEXT_THRESHOLD = 0.6;
+export let CRITICAL_CONTEXT_THRESHOLD = 0.8;
+export let MAX_INJECTION_TOKENS = 8000;
+export let CORE_INJECTION_TOKENS = 2000;
+export let AUTO_COMPRESS_THRESHOLD = 0.7;
+export const AUTO_COMPRESS_COOLDOWN_MS = 5 * 60 * 60 * 1000;
+export let lastAutoCompress = 0;
+export let currentSessionId = null;
+export function setContextLimit(v) { CONTEXT_LIMIT = v; }
+export function setHighContextThreshold(v) { HIGH_CONTEXT_THRESHOLD = v; }
+export function setCriticalContextThreshold(v) { CRITICAL_CONTEXT_THRESHOLD = v; }
+export function setMaxInjectionTokens(v) { MAX_INJECTION_TOKENS = v; }
+export function setCoreInjectionTokens(v) { CORE_INJECTION_TOKENS = v; }
+export function setAutoCompressThreshold(v) { AUTO_COMPRESS_THRESHOLD = v; }
+export function setLastAutoCompress(v) { lastAutoCompress = v; }
+export function setCurrentSessionId(v) { currentSessionId = v; }
+export async function captureMiddleTermContext(store, sessionId) {
+    try {
+        const config = await loadMemConfig(process.cwd());
+        if (!config.enableMiddleTermCapture) {
+            memLog("debug", "middle-term", "Middle-term capture disabled in config");
+            return;
+        }
+        const sid = sessionId || currentSessionId || "unknown";
+        memLog("info", "middle-term", "Starting pre-compaction context capture", { sessionId: sid });
+        const workingCache = getWorkingCache(sid);
+        const allNodes = await store.listNodes("all");
+        const recentNodes = allNodes
+            .filter(n => n.importance >= 0.3)
+            .sort((a, b) => (b.lastAccessed?.getTime() ?? 0) - (a.lastAccessed?.getTime() ?? 0))
+            .slice(0, 20);
+        const snapshot = {
+            timestamp: new Date().toISOString(),
+            sessionId: sid,
+            type: "middle-term-context",
+            workingCache: workingCache.map((n) => ({
+                id: n.id,
+                label: n.label,
+                importance: n.importance,
+                cachedAt: n.cachedAt,
+            })),
+            recentNodes: recentNodes.slice(0, 10).map(n => ({
+                id: n.id,
+                label: n.label,
+                importance: n.importance,
+                level: n.level,
+            })),
+            contextTokens: workingCache.reduce((sum, n) => sum + (n.content ? n.content.length / 4 : 0), 0),
+        };
+        const label = `middle-term:${sid}:${Date.now()}`;
+        const content = JSON.stringify(snapshot, null, 2);
+        await store.createNode({
+            scope: "project",
+            label,
+            content,
+            level: 0,
+            sticky: true,
+            importance: 0.8,
+            type: "note",
+            metadata: { tags: ["middle-term", "pre-compaction", sid], customType: "middle-term" },
+        });
+        memLog("info", "middle-term", "Captured pre-compaction context", {
+            sessionId: sid,
+            nodeCount: workingCache.length,
+            label,
+        });
+    }
+    catch (err) {
+        memLog("warn", "middle-term", "Failed to capture context", { error: String(err) });
+    }
+}

package/dist/plugin/tools.js

@@ -0,0 +1,45 @@
+import * as tools from "../tools";
+import { MemoryPlaybookExecute } from "../tools/playbook";
+export function createToolMap(store, journalTools, client) {
+    return {
+        memory_list: tools.MemoryList(store),
+        memory_set: tools.MemorySet(store),
+        memory_rate: tools.MemoryRate(store),
+        memory_get: tools.MemoryGet(store),
+        memory_fetch: tools.MemoryFetch(store),
+        memory_replace: tools.MemoryReplace(store),
+        memory_delete: tools.MemoryDelete(store),
+        memory_verify: tools.MemoryVerify(store),
+        memory_prune: tools.MemoryPrune(store),
+        memory_compress: tools.MemoryCompress(store),
+        memory_extract_patterns: tools.MemoryExtractPatterns(store),
+        memory_summarize: tools.MemorySummarize(store),
+        memory_llm_compress: tools.MemoryLlmCompress(store, client),
+        memory_stats: tools.MemoryStats(store),
+        memory_drilldown: tools.MemoryDrilldown(store),
+        memory_search: tools.MemorySearch(store),
+        memory_drilldown_query: tools.MemoryDrilldownQuery(store),
+        memory_detect_topics: tools.MemoryDetectTopics(store),
+        memory_generate_embeddings: tools.MemoryGenerateEmbeddings(store),
+        memory_check_context: tools.MemoryCheckContext(store),
+        memory_injection_stats: tools.MemoryInjectionStats(store),
+        memory_injection_feedback: tools.MemoryInjectionFeedback(store),
+        memory_tool_stats: tools.MemoryToolStats(store),
+        memory_session_stats: tools.MemorySessionStats(store),
+        memory_total_tokens: tools.MemoryTotalTokens(store, client),
+        memory_reflect: tools.MemoryReflect(store, client),
+        memory_distill: tools.MemoryDistill(store, client),
+        memory_inject: tools.MemoryInject(store),
+        memory_injection_debug: tools.MemoryInjectionDebug(store),
+        memory_middle_term: tools.MemoryMiddleTerm(store),
+        memory_dashboard: tools.MemoryDashboard(store),
+        memory_cache_status: tools.MemoryCacheStatus(store),
+        memory_help: tools.MemoryHelp(store),
+        memory_version: tools.MemoryVersion(store),
+        memory_auto_test: tools.createMemoryAutoTest(store),
+        memory_playbook_execute: MemoryPlaybookExecute(store),
+        memory_skill_load: tools.MemorySkillLoad(store),
+        skill: tools.MemorySkillLoad(store),
+        ...journalTools,
+    };
+}

package/dist/plugin.js

@@ -0,0 +1,2 @@
+export { MemoryPlugin } from "./plugin/index";
+export { createMemoryStore } from "./memory";

package/dist/procedural/store.js

@@ -0,0 +1 @@
+export {};

package/dist/procedural/types.js

@@ -0,0 +1 @@
+export {};