opencode-fractal-memory 0.2.0

package/dist/hooks/predictive-rating.js

@@ -0,0 +1,87 @@
+import { memLog } from "../logging";
+export async function predictiveRateToolCall(store, input, output, config) {
+    const success = output.metadata?.error ? false : true;
+    let nodeId;
+    const tool = input.tool;
+    const args = input.args ?? {};
+    if (tool === "memory_get" && (args.id || args.label)) {
+        nodeId = args.id;
+        if (!nodeId && args.label) {
+            try {
+                const node = await store.getNodeByLabel(args.scope ?? "project", args.label);
+                nodeId = node.id;
+            }
+            catch { /* Not found, skip rating */
+                return;
+            }
+        }
+    }
+    else if (tool === "memory_fetch" && args.label) {
+        try {
+            const node = await store.getNodeByLabel("global", args.label);
+            nodeId = node.id;
+        }
+        catch {
+            try {
+                const node = await store.getNodeByLabel("project", args.label);
+                nodeId = node.id;
+            }
+            catch { /* Not found in project, skip */
+                return;
+            }
+        }
+    }
+    else if (tool === "memory_rate" && (args.id || args.label)) {
+        nodeId = args.id;
+        if (!nodeId && args.label) {
+            try {
+                const node = await store.getNodeByLabel(args.scope ?? "project", args.label);
+                nodeId = node.id;
+            }
+            catch { /* Not found, skip rating */
+                return;
+            }
+        }
+    }
+    if (!nodeId)
+        return;
+    try {
+        const node = await store.getNode(nodeId);
+        if (!node)
+            return;
+        const currentScore = node.usefulnessScore ?? 0;
+        const currentHelpful = node.timesHelpful ?? 0;
+        if (tool === "memory_rate") {
+            if (args.helpful === true) {
+                const newScore = Math.min(5, currentScore + config.positiveBoost);
+                await store.updateNode(nodeId, {
+                    usefulnessScore: newScore,
+                    timesHelpful: currentHelpful + 1,
+                });
+                memLog("debug", "predictive-rating", `Boosted ${nodeId.slice(0, 8)} to ${newScore}`);
+            }
+            else if (success && args.helpful === false) {
+                const newScore = Math.max(0, currentScore - config.negativePenalty);
+                await store.updateNode(nodeId, { usefulnessScore: newScore });
+                memLog("debug", "predictive-rating", `Penalized ${nodeId.slice(0, 8)} to ${newScore}`);
+            }
+        }
+        else if (success) {
+            const newScore = Math.min(5, currentScore + config.positiveBoost);
+            await store.updateNode(nodeId, { usefulnessScore: newScore });
+            memLog("debug", "predictive-rating", `Access boost ${nodeId.slice(0, 8)} to ${newScore}`);
+        }
+        else {
+            const newScore = Math.max(0, currentScore - config.negativePenalty);
+            await store.updateNode(nodeId, { usefulnessScore: newScore });
+            memLog("debug", "predictive-rating", `Failure penalty ${nodeId.slice(0, 8)} to ${newScore}`);
+        }
+    }
+    catch (err) {
+        memLog("warn", "predictive-rating", "Rating update failed", { error: String(err) });
+    }
+}
+export async function applyScoreDecay(store, config) {
+    const decayed = await store.runScoreDecay(config.decayDays);
+    return `Predictive rating: decayed ${decayed} nodes`;
+}

package/dist/journal.js

@@ -0,0 +1,279 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import yaml from "js-yaml";
+import { z } from "zod";
+import { cosineSimilarity, generateEmbedding } from "./embeddings";
+import { atomicWriteFile, buildFrontmatterDocument, splitFrontmatter } from "./frontmatter";
+const TagSchema = z.looseObject({
+    name: z.string().min(1),
+    description: z.string().min(1),
+});
+const ConfigSchema = z.looseObject({
+    journal: z
+        .looseObject({
+        enabled: z.boolean().optional(),
+        tags: z.array(TagSchema).optional(),
+    })
+        .optional(),
+    management: z
+        .looseObject({
+        enabled: z.boolean().optional(),
+        port: z.number().optional(),
+    })
+        .optional(),
+});
+export async function loadConfig(configDir) {
+    const dir = configDir ?? path.join(os.homedir(), ".config", "opencode");
+    const configPath = path.join(dir, "agent-memory.json");
+    try {
+        const raw = await fs.readFile(configPath, "utf-8");
+        const parsed = ConfigSchema.safeParse(JSON.parse(raw));
+        if (!parsed.success)
+            return {};
+        return parsed.data;
+    }
+    catch {
+        return {};
+    }
+}
+const EntryFrontmatterSchema = z.looseObject({
+    title: z.string().min(1),
+    project: z.string().optional(),
+    model: z.string().optional(),
+    provider: z.string().optional(),
+    agent: z.string().optional(),
+    session_id: z.string().optional(),
+    created: z.string().optional(),
+    tags: z.array(z.string().min(1)).optional(),
+});
+function entryFilename(date) {
+    const pad = (n, len = 2) => String(n).padStart(len, "0");
+    return [
+        `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}`,
+        "-",
+        `${pad(date.getUTCHours())}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}`,
+        "-",
+        `${pad(date.getUTCMilliseconds(), 3)}`,
+        ".md",
+    ].join("");
+}
+function embeddingPath(entryPath) {
+    return entryPath.replace(/\.md$/, ".embedding");
+}
+async function readEntryFile(filePath) {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const { frontmatterText, body } = splitFrontmatter(raw);
+    if (!frontmatterText) {
+        throw new Error(`Journal entry missing frontmatter: ${filePath}`);
+    }
+    const loaded = yaml.load(frontmatterText);
+    const parsed = EntryFrontmatterSchema.safeParse(loaded);
+    if (!parsed.success) {
+        throw new Error(`Invalid journal frontmatter in ${filePath}: ${parsed.error.message}`);
+    }
+    const fm = parsed.data;
+    const id = path.basename(filePath, ".md");
+    return {
+        id,
+        title: fm.title,
+        project: fm.project ?? "",
+        model: fm.model ?? "",
+        provider: fm.provider ?? "",
+        agent: fm.agent ?? "",
+        sessionId: fm.session_id ?? "",
+        created: fm.created ? new Date(fm.created) : new Date(),
+        tags: fm.tags ?? [],
+        body: body.trim(),
+        filePath,
+    };
+}
+async function loadEmbedding(entryPath) {
+    const ePath = embeddingPath(entryPath);
+    try {
+        const raw = await fs.readFile(ePath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
+function validateId(id) {
+    const trimmed = id.trim();
+    if (!SAFE_ID.test(trimmed)) {
+        throw new Error(`Invalid journal entry ID: "${id}"`);
+    }
+    return trimmed;
+}
+export function createJournalStore(configDir) {
+    const journalDir = path.join(configDir ?? path.join(os.homedir(), ".config", "opencode"), "journal");
+    return {
+        async write(entry) {
+            await fs.mkdir(journalDir, { recursive: true });
+            const created = new Date();
+            const filename = entryFilename(created);
+            const filePath = path.join(journalDir, filename);
+            const frontmatter = {
+                title: entry.title,
+                created: created.toISOString(),
+            };
+            if (entry.project)
+                frontmatter.project = entry.project;
+            if (entry.model)
+                frontmatter.model = entry.model;
+            if (entry.provider)
+                frontmatter.provider = entry.provider;
+            if (entry.agent)
+                frontmatter.agent = entry.agent;
+            if (entry.sessionId)
+                frontmatter.session_id = entry.sessionId;
+            if (entry.tags && entry.tags.length > 0)
+                frontmatter.tags = entry.tags;
+            const content = buildFrontmatterDocument(frontmatter, entry.body);
+            await atomicWriteFile(filePath, content);
+            // Generate and save embedding for semantic search
+            const searchableText = `${entry.title}\n${entry.body}`;
+            try {
+                const embedding = await generateEmbedding(searchableText);
+                await fs.writeFile(embeddingPath(filePath), JSON.stringify(embedding), "utf-8");
+            }
+            catch {
+                // Embedding generation can fail (e.g. model download issue).
+                // The entry is still saved; text search remains available.
+            }
+            return {
+                id: path.basename(filePath, ".md"),
+                title: entry.title,
+                project: entry.project ?? "",
+                model: entry.model ?? "",
+                provider: entry.provider ?? "",
+                agent: entry.agent ?? "",
+                sessionId: entry.sessionId ?? "",
+                created,
+                tags: entry.tags ?? [],
+                body: entry.body,
+                filePath,
+            };
+        },
+        async read(id) {
+            const safeId = validateId(id);
+            const filePath = path.join(journalDir, `${safeId}.md`);
+            try {
+                await fs.access(filePath);
+            }
+            catch {
+                throw new Error(`Journal entry not found: ${safeId}`);
+            }
+            return readEntryFile(filePath);
+        },
+        async search(query) {
+            const limit = Math.min(Math.max(query.limit ?? 20, 1), 50);
+            const offset = Math.max(query.offset ?? 0, 0);
+            let entries = [];
+            // Read all entry files
+            let files;
+            try {
+                const dirEntries = await fs.readdir(journalDir, {
+                    withFileTypes: true,
+                });
+                files = dirEntries
+                    .filter((e) => e.isFile() && e.name.endsWith(".md"))
+                    .map((e) => e.name)
+                    .sort()
+                    .reverse(); // Newest first
+            }
+            catch {
+                return { entries: [], total: 0, allTags: [] };
+            }
+            // If a text query is provided, try semantic search first
+            let queryEmbedding;
+            if (query.text) {
+                try {
+                    queryEmbedding = await generateEmbedding(query.text);
+                }
+                catch {
+                    // Fall back to text search if embedding fails
+                }
+            }
+            // Collect all tags across every entry (before filtering)
+            const tagSet = new Set();
+            for (const file of files) {
+                const filePath = path.join(journalDir, file);
+                let entry;
+                try {
+                    entry = await readEntryFile(filePath);
+                }
+                catch {
+                    continue;
+                }
+                // Collect tags before applying filters
+                for (const tag of entry.tags) {
+                    tagSet.add(tag);
+                }
+                // Apply metadata filters (AND logic)
+                if (query.project && entry.project !== query.project) {
+                    continue;
+                }
+                if (query.tags && query.tags.length > 0) {
+                    const entryTagNames = entry.tags.map((t) => t.toLowerCase());
+                    const allTagsMatch = query.tags.every((t) => entryTagNames.includes(t.toLowerCase()));
+                    if (!allTagsMatch)
+                        continue;
+                }
+                // Score the entry
+                let score = 0;
+                if (query.text) {
+                    if (queryEmbedding) {
+                        // Semantic search
+                        const entryEmbedding = await loadEmbedding(filePath);
+                        if (entryEmbedding) {
+                            score = cosineSimilarity(queryEmbedding, entryEmbedding);
+                        }
+                        else {
+                            // No embedding stored; fall back to text match
+                            const haystack = `${entry.title}\n${entry.body}`.toLowerCase();
+                            score = haystack.includes(query.text.toLowerCase()) ? 0.5 : 0;
+                        }
+                    }
+                    else {
+                        // Text search fallback
+                        const haystack = `${entry.title}\n${entry.body}`.toLowerCase();
+                        score = haystack.includes(query.text.toLowerCase()) ? 1 : 0;
+                    }
+                    if (score <= 0)
+                        continue;
+                }
+                else {
+                    // No text query - chronological order (score by recency)
+                    score = entry.created.getTime();
+                }
+                entries.push({ entry, score });
+            }
+            const total = entries.length;
+            // Sort by score descending
+            entries.sort((a, b) => b.score - a.score);
+            // Apply offset + limit
+            entries = entries.slice(offset, offset + limit);
+            return {
+                entries: entries.map((e) => e.entry),
+                total,
+                allTags: Array.from(tagSet).sort(),
+            };
+        },
+    };
+}
+export function buildJournalSystemNote(tags) {
+    const tagSection = tags && tags.length > 0
+        ? `\n\nSuggested tags:\n${tags.map((t) => `- ${t.name}: ${t.description}`).join("\n")}`
+        : "";
+    return `<journal_instructions>
+You have access to a private journal. Use it to record thoughts, discoveries, and decisions as you work.
+Tags are free-form strings — use them to classify entries however makes sense.${tagSection}
+
+Before starting complex tasks, search the journal for relevant past context.
+Journal entries are append-only: you write new entries but never edit old ones.
+Use journal_search to find past entries semantically, and journal_read to read a specific entry.
+The journal is global across all projects but each entry records which project it was written from.
+</journal_instructions>`;
+}

package/dist/logging.js

@@ -0,0 +1,147 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const LOG_FILE = path.join(os.homedir(), ".config", "opencode", "memory-plugin.log");
+const CONTEXT_DUMP_FILE = path.join(os.homedir(), ".config", "opencode", "context_dump.log");
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+let currentSessionId = null;
+let logLevel = "info";
+// Categories to always skip (OpenCode core noise)
+const SKIP_CATEGORIES = ["event"];
+export function setSessionId(sessionId) {
+    currentSessionId = sessionId;
+}
+export function setLogLevel(level) {
+    logLevel = level;
+}
+function shouldLog(level, category) {
+    if (SKIP_CATEGORIES.includes(category || ""))
+        return false;
+    const levels = { debug: 0, info: 1, warn: 2, error: 3 };
+    return levels[level] >= levels[logLevel];
+}
+function writeLog(line) {
+    try {
+        try {
+            const stat = fs.statSync(LOG_FILE);
+            if (stat.size > MAX_LOG_SIZE) {
+                fs.renameSync(LOG_FILE, LOG_FILE + ".old");
+            }
+        }
+        catch { /* file doesn't exist yet */ }
+        fs.appendFileSync(LOG_FILE, line + "\n");
+    }
+    catch { /* silent fail */ }
+}
+export function memLog(level, category, msg, data) {
+    if (!shouldLog(level, category))
+        return;
+    const ts = new Date().toISOString().slice(0, 19).replace("T", " ");
+    const session = currentSessionId ? `[${currentSessionId.slice(0, 8)}]` : "";
+    const line = `[${ts}] [${level.padEnd(5)}] [${category}]${session} ${msg}` +
+        (Object.keys(data || {}).length > 0 ? ` ${JSON.stringify(data)}` : "");
+    writeLog(line);
+}
+export function memLogSimple(msg, data) {
+    memLog("info", "general", msg, data);
+}
+// Performance timing wrapper
+const perfTimers = new Map();
+export function perfStart(label) {
+    perfTimers.set(label, Date.now());
+}
+export function perfEnd(label, category = "perf") {
+    const start = perfTimers.get(label);
+    if (!start)
+        return null;
+    const duration = Date.now() - start;
+    memLog("debug", category, `${label} completed`, { durationMs: duration, label });
+    perfTimers.delete(label);
+    return duration;
+}
+export function perfNow() {
+    return Date.now();
+}
+export function memLogInjection(action, data) {
+    switch (action) {
+        case "start":
+            memLog("info", "injection", "Memory injection started", {
+                query: data.query?.slice(0, 100),
+                mode: data.mode,
+                nodeCount: data.nodes,
+                estimatedTokens: data.tokens,
+            });
+            break;
+        case "complete":
+            const durationStr = data.durationMs ? ` (${data.durationMs}ms)` : "";
+            memLog("info", "injection", `Injected ${data.selectedIds?.length || 0} nodes${durationStr}`, {
+                nodes: data.nodes,
+                tokens: data.tokens,
+                mode: data.mode,
+                durationMs: data.durationMs,
+                selectedCount: data.selectedIds?.length,
+            });
+            break;
+        case "skip":
+            memLog("info", "injection", `Skipped: ${data.reason}`, {
+                reason: data.reason,
+                query: data.query?.slice(0, 100),
+            });
+            break;
+    }
+}
+export function memLogToolCall(tool, data) {
+    memLog("debug", "tool", `Tool call: ${tool}`, {
+        success: data.success,
+        durationMs: data.durationMs,
+        error: data.error,
+    });
+}
+export function memLogSession(action, data) {
+    const level = action === "error" ? "warn" : "info";
+    memLog(level, "session", `Session ${action}`, {
+        sessionId: data.sessionId,
+        error: data.error,
+    });
+}
+export function memLogAutoCompress(action, data) {
+    switch (action) {
+        case "triggered":
+            memLog("info", "compress", "Auto-compress triggered", data);
+            break;
+        case "skipped":
+            memLog("debug", "compress", "Auto-compress skipped", data);
+            break;
+        case "complete":
+            memLog("info", "compress", "Auto-compress complete", data);
+            break;
+        case "failed":
+            memLog("error", "compress", "Auto-compress failed", { error: data.error });
+            break;
+    }
+}
+export function memLogAgentTool(tool, data) {
+    // Only log tools that matter (not debug/internal)
+    const importantTools = ["read", "edit", "write", "bash", "grep", "glob", "task", "memory_search", "memory_set", "memory_get", "memory_list"];
+    const isImportant = importantTools.includes(tool) || tool.startsWith("memory_");
+    if (isImportant) {
+        const durationStr = data.durationMs ? ` (${data.durationMs}ms)` : "";
+        const successStr = data.success === false ? " FAILED" : "";
+        const lengthStr = data.outputLength ? ` [${data.outputLength} chars]` : "";
+        memLog("info", "agent_tool", `${tool}${successStr}${lengthStr}${durationStr}`, {
+            sessionId: data.sessionId?.slice(0, 8),
+            success: data.success,
+            outputLength: data.outputLength,
+            durationMs: data.durationMs,
+        });
+    }
+}
+export function writeContextDump(systemBlocks) {
+    try {
+        const ts = new Date().toISOString();
+        const header = `\n\n========== CONTEXT DUMP: ${ts} ==========\n\n`;
+        const content = header + systemBlocks.map((s, i) => `--- BLOCK ${i} ---\n${s}\n`).join("\n");
+        fs.appendFileSync(CONTEXT_DUMP_FILE, content);
+    }
+    catch { /* silent fail */ }
+}