opencode-fractal-memory 0.2.0

package/commands/memory-total-tokens.md

@@ -0,0 +1,10 @@
+---
+description: Show complete token analysis (memory + conversation)
+---
+Show me a complete token analysis including:
+- Memory system tokens (L0, L1, L2+ summaries)
+- Conversation tokens (input, output, reasoning, cache)
+- Total tokens and percentage of context limit
+- Recommendations for compression if needed
+
+Use memory_total_tokens with include_messages=false for summary, or include_messages=true for detailed message breakdown.

package/commands/memory-verify.md

@@ -0,0 +1,4 @@
+---
+description: Verify node correctness to boost confidence
+---
+Confirm that the information in a memory node is correct. This increases the node's confidence score by 0.2 and records the verification timestamp. Use memory_verify with the node's id or label. Verified nodes rank higher in semantic search results.

package/commands/memory-version.md

@@ -0,0 +1,9 @@
+---
+title: memory-version
+description: Show the installed version of the Fractal Memory plugin
+usage: /memory-version
+examples:
+  - memory-version
+tags:
+  - version
+  - info

package/dist/cache.js

@@ -0,0 +1,39 @@
+const workingMemoryCache = new Map();
+let CACHE_MAX_SIZE = 8;
+let CACHE_TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+export function getWorkingCache(sessionId) {
+    const cache = workingMemoryCache.get(sessionId) || [];
+    const now = Date.now();
+    // Filter expired entries
+    return cache.filter(n => now - n.cachedAt < CACHE_TTL_MS);
+}
+export function addToWorkingCache(sessionId, node) {
+    let cache = workingMemoryCache.get(sessionId) || [];
+    // Remove if already exists
+    cache = cache.filter(n => n.id !== node.id);
+    // Add to front (most recent)
+    cache.unshift({
+        id: node.id,
+        label: node.label ?? node.id.slice(0, 8),
+        content: node.content,
+        importance: node.importance ?? 0.5,
+        cachedAt: Date.now()
+    });
+    // Trim to max size
+    if (cache.length > CACHE_MAX_SIZE) {
+        cache = cache.slice(0, CACHE_MAX_SIZE);
+    }
+    workingMemoryCache.set(sessionId, cache);
+}
+export function invalidateWorkingCache(sessionId, nodeId) {
+    if (!nodeId) {
+        workingMemoryCache.delete(sessionId);
+        return;
+    }
+    const cache = workingMemoryCache.get(sessionId) || [];
+    workingMemoryCache.set(sessionId, cache.filter(n => n.id !== nodeId));
+}
+export function setCacheConfig(maxSize, ttlHours) {
+    CACHE_MAX_SIZE = maxSize;
+    CACHE_TTL_MS = ttlHours * 60 * 60 * 1000;
+}

package/dist/config.js

@@ -0,0 +1,120 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { z } from "zod";
+import { memLog } from "./logging";
+const AutoRetrieveSchema = z.object({
+    enabled: z.boolean().default(false),
+    candidateCount: z.number().positive().int().default(30),
+    maxInjectNodes: z.number().positive().int().default(5),
+    maxInjectPlaybooks: z.number().positive().int().default(3),
+});
+const OllamaSchema = z.object({
+    enabled: z.boolean().default(false),
+    baseUrl: z.string().default("http://localhost:11434"),
+    model: z.string().default("qwen2.5-coder:1.5b"),
+    mode: z.enum(["binary", "score"]).default("binary"),
+});
+const LlmCompressionSchema = z.object({
+    enabled: z.boolean().default(false),
+    model: z.string().optional(),
+    maxSummaryTokens: z.number().positive().int().default(500),
+});
+const AutoDistillSchema = z.object({
+    enabled: z.boolean().default(false),
+    minLessons: z.number().positive().int().default(3),
+    useLlm: z.boolean().default(false),
+});
+const AutoDiscoverSchema = z.object({
+    enabled: z.boolean().default(false),
+    minSequenceLength: z.number().positive().int().default(3),
+    minRepeatCount: z.number().positive().int().default(2),
+    maxInjectPlaybooks: z.number().positive().int().default(3),
+});
+const PredictiveRatingSchema = z.object({
+    enabled: z.boolean().default(false),
+    decayDays: z.number().positive().default(7),
+    confidenceThreshold: z.number().min(0).max(1).default(0.3),
+    positiveBoost: z.number().min(0).max(1).default(0.1),
+    negativePenalty: z.number().min(0).max(1).default(0.05),
+});
+const DEFAULT_CONFIG = {
+    maxInjectionTokens: 8000,
+    coreInjectionTokens: 2000,
+    cacheSize: 8,
+    cacheTTLHours: 2,
+    autoCompressThreshold: 0.7,
+    highContextThreshold: 0.6,
+    criticalContextThreshold: 0.8,
+    enableMiddleTermCapture: true,
+    defaultTtlDays: 0,
+    autoFileSummarization: {
+        enabled: false,
+    },
+    autoRetrieve: {
+        enabled: false,
+        candidateCount: 30,
+        maxInjectNodes: 5,
+        maxInjectPlaybooks: 3,
+    },
+    ollama: {
+        enabled: false,
+        baseUrl: "http://localhost:11434",
+        model: "qwen2.5-coder:1.5b",
+        mode: "binary",
+    },
+    llmCompression: {
+        enabled: false,
+        maxSummaryTokens: 500,
+    },
+    autoDistill: {
+        enabled: false,
+        minLessons: 3,
+        useLlm: false,
+    },
+    predictiveRating: {
+        enabled: false,
+        decayDays: 7,
+        confidenceThreshold: 0.3,
+        positiveBoost: 0.1,
+        negativePenalty: 0.05,
+    },
+    autoDiscover: {
+        enabled: false,
+        minSequenceLength: 3,
+        minRepeatCount: 2,
+        maxInjectPlaybooks: 3,
+    },
+};
+const MemConfigSchema = z.object({
+    maxInjectionTokens: z.number().positive().int().default(8000),
+    coreInjectionTokens: z.number().positive().int().default(2000),
+    cacheSize: z.number().positive().int().default(8),
+    cacheTTLHours: z.number().positive().default(2),
+    autoCompressThreshold: z.number().min(0).max(1).default(0.7),
+    highContextThreshold: z.number().min(0).max(1).default(0.6),
+    criticalContextThreshold: z.number().min(0).max(1).default(0.8),
+    enableMiddleTermCapture: z.boolean().default(true),
+    defaultTtlDays: z.number().int().min(0).default(0),
+    autoFileSummarization: z.object({
+        enabled: z.boolean().default(false),
+    }).optional(),
+    autoRetrieve: AutoRetrieveSchema.optional(),
+    ollama: OllamaSchema.optional(),
+    llmCompression: LlmCompressionSchema.optional(),
+    autoDistill: AutoDistillSchema.optional(),
+    predictiveRating: PredictiveRatingSchema.optional(),
+    autoDiscover: AutoDiscoverSchema.optional(),
+}).default(DEFAULT_CONFIG);
+export async function loadMemConfig(_projectRoot) {
+    const configPath = path.join(os.homedir(), ".config", "opencode", "opencode-mem.json");
+    try {
+        const raw = await fs.promises.readFile(configPath, "utf-8");
+        const parsed = MemConfigSchema.parse(JSON.parse(raw));
+        return parsed;
+    }
+    catch (err) {
+        memLog("warn", "config", "Failed to load config, using defaults", { error: String(err), configPath });
+        return DEFAULT_CONFIG;
+    }
+}

package/dist/embeddings.js

@@ -0,0 +1,125 @@
+import { InferenceSession, Tensor } from "onnxruntime-web";
+import { Tokenizer } from "@huggingface/tokenizers";
+import { readFile } from "node:fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+const MODELS_DIR = join(homedir(), ".config", "opencode", "models", "Xenova", "all-MiniLM-L6-v2");
+const MODEL_PATH = join(MODELS_DIR, "onnx", "model_quantized.onnx");
+const TOKENIZER_JSON_PATH = join(MODELS_DIR, "tokenizer.json");
+const TOKENIZER_CONFIG_PATH = join(MODELS_DIR, "tokenizer_config.json");
+let session;
+let tokenizer;
+async function getSession() {
+    if (!session) {
+        session = await InferenceSession.create(MODEL_PATH, {
+            executionProviders: ["wasm"],
+        });
+    }
+    return session;
+}
+async function loadTokenizer() {
+    if (!tokenizer) {
+        const [tokenizerJsonRaw, tokenizerConfigRaw] = await Promise.all([
+            readFile(TOKENIZER_JSON_PATH, "utf-8"),
+            readFile(TOKENIZER_CONFIG_PATH, "utf-8"),
+        ]);
+        const tokenizerJson = JSON.parse(tokenizerJsonRaw);
+        const tokenizerConfig = JSON.parse(tokenizerConfigRaw);
+        tokenizer = new Tokenizer(tokenizerJson, tokenizerConfig);
+    }
+    return tokenizer;
+}
+// Synchronous version for internal use (tokenizer must be loaded first)
+function getTokenizerSync() {
+    if (!tokenizer) {
+        throw new Error("Tokenizer not loaded. Call loadTokenizer() first.");
+    }
+    return tokenizer;
+}
+export async function generateEmbedding(text) {
+    const [session, tok] = await Promise.all([
+        getSession(),
+        loadTokenizer()
+    ]);
+    const encoded = tok.encode(text);
+    const ids = encoded.ids;
+    const attentionMask = encoded.attention_mask;
+    const seqLen = Math.min(ids.length, 256);
+    const inputIds = new BigInt64Array(seqLen);
+    const mask = new BigInt64Array(seqLen);
+    for (let i = 0; i < seqLen; i++) {
+        inputIds[i] = BigInt(ids[i]);
+        mask[i] = BigInt(attentionMask[i]);
+    }
+    const feeds = {
+        input_ids: new Tensor("int64", inputIds, [1, seqLen]),
+        attention_mask: new Tensor("int64", mask, [1, seqLen]),
+        token_type_ids: new Tensor("int64", new BigInt64Array(seqLen), [1, seqLen]),
+    };
+    const results = await session.run(feeds);
+    const output = results["last_hidden_state"];
+    if (!output)
+        throw new Error("No output from model");
+    const lastHiddenState = output.data;
+    const hiddenSize = 384;
+    let count = 0;
+    for (let i = 0; i < seqLen; i++) {
+        if (mask[i] === BigInt(1))
+            count++;
+    }
+    const pooled = new Array(hiddenSize).fill(0);
+    for (let i = 0; i < seqLen; i++) {
+        if (mask[i] === BigInt(1)) {
+            for (let j = 0; j < hiddenSize; j++) {
+                pooled[j] = (pooled[j] ?? 0) + (lastHiddenState[i * hiddenSize + j] ?? 0);
+            }
+        }
+    }
+    if (count > 0) {
+        for (let j = 0; j < hiddenSize; j++) {
+            pooled[j] = (pooled[j] ?? 0) / count;
+        }
+    }
+    let norm = 0;
+    for (const v of pooled) {
+        norm += v * v;
+    }
+    norm = Math.sqrt(norm);
+    const normalized = [];
+    if (norm > 0) {
+        for (const v of pooled) {
+            normalized.push(v / norm);
+        }
+    }
+    return normalized;
+}
+export function estimateTokens(text) {
+    // If the tokenizer hasn't been loaded (e.g., in unit tests), fall back to a simple word‑count heuristic.
+    if (!tokenizer) {
+        // Approximate token count as 1.5 tokens per whitespace‑separated word.
+        const words = text.trim().split(/\s+/).filter(Boolean).length;
+        return Math.max(1, Math.ceil(words * 1.5));
+    }
+    const tok = getTokenizerSync();
+    const encoded = tok.encode(text);
+    return encoded.ids.length;
+}
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Embedding dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dotProduct += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    return dotProduct / denominator;
+}

package/dist/ensure-models.js

@@ -0,0 +1,70 @@
+import { mkdir, writeFile, access, cp } from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "os";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const BASE = join(homedir(), ".config", "opencode", "models", "Xenova", "all-MiniLM-L6-v2");
+const ONNX_DIR = join(BASE, "onnx");
+const FILES = [
+    {
+        path: join(ONNX_DIR, "model_quantized.onnx"),
+        url: "https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/onnx/model_quantized.onnx",
+    },
+    {
+        path: join(BASE, "tokenizer.json"),
+        url: "https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/tokenizer.json",
+    },
+    {
+        path: join(BASE, "tokenizer_config.json"),
+        url: "https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main/tokenizer_config.json",
+    },
+];
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function download(url, dest) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    const buffer = await response.arrayBuffer();
+    await writeFile(dest, new Uint8Array(buffer));
+}
+export async function ensureModels() {
+    let needsDownload = false;
+    for (const f of FILES) {
+        if (!(await fileExists(f.path))) {
+            needsDownload = true;
+            break;
+        }
+    }
+    if (!needsDownload)
+        return;
+    await mkdir(ONNX_DIR, { recursive: true });
+    for (const f of FILES) {
+        const name = f.url.split("/").pop();
+        process.stdout.write(`Downloading ${name} ... `);
+        await download(f.url, f.path);
+        const stat = await import("node:fs/promises").then(m => m.stat(f.path));
+        const mb = (stat.size / 1024 / 1024).toFixed(1);
+        process.stdout.write(`${mb} MB\n`);
+    }
+}
+export async function ensureAgentFiles() {
+    const srcAgent = join(__dirname, "..", "agent");
+    const dstAgent = join(homedir(), ".config", "opencode", "agent");
+    await mkdir(dstAgent, { recursive: true });
+    await cp(srcAgent, dstAgent, { recursive: true, force: true });
+}
+export async function ensureCommandFiles() {
+    const srcCommands = join(__dirname, "..", "commands");
+    const dstCommands = join(homedir(), ".config", "opencode", "commands");
+    await mkdir(dstCommands, { recursive: true });
+    await cp(srcCommands, dstCommands, { recursive: true, force: true });
+}

package/dist/file-summary.js

@@ -0,0 +1,143 @@
+export const SOURCE_FILE_EXTENSIONS = [
+    'ts', 'js', 'tsx', 'jsx', 'py', 'rs', 'go', 'java', 'c', 'cpp', 'h', 'hpp',
+    'cs', 'rb', 'php', 'swift', 'kt', 'scala', 'md', 'txt',
+];
+export function generateFileLabel(filePath) {
+    const fileName = filePath.split('/').pop() ?? filePath;
+    const maxFileNameLen = 30;
+    const truncatedName = fileName.length > maxFileNameLen ? fileName.slice(-maxFileNameLen) : fileName;
+    const pathHash = Math.abs(filePath.split('').reduce((a, c) => a + c.charCodeAt(0), 0) % 46656).toString(36);
+    return `file:${truncatedName}:${pathHash}`;
+}
+export function generateFileSummary(fileName, filePath, content, fileExt) {
+    const lines = content.split('\n');
+    const summary = [];
+    summary.push(`## File: ${fileName}`);
+    summary.push(`Path: ${filePath}`);
+    summary.push(`Lines: ${lines.length}`);
+    summary.push("");
+    if (['ts', 'js', 'tsx', 'jsx'].includes(fileExt)) {
+        const exports = [];
+        const imports = [];
+        const functions = [];
+        const classes = [];
+        const interfaces = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            const trimmed = line.trim();
+            const lineNum = i + 1;
+            const typeImportMatch = trimmed.match(/^import\s+type\s+\{[^}]*\}\s+from\s+['"]([^'"]+)['"]/);
+            if (typeImportMatch?.[1])
+                imports.push(typeImportMatch[1]);
+            const importMatch = trimmed.match(/^import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/);
+            if (importMatch?.[1])
+                imports.push(importMatch[1]);
+            const reExportMatch = trimmed.match(/^export\s+\{[^}]*\}\s+from\s+['"]([^'"]+)['"]/);
+            if (reExportMatch?.[1])
+                imports.push(reExportMatch[1]);
+            const exportMatch = trimmed.match(/^export\s+(?:const|let|var|function|class|interface|type)\s+(\w+)/);
+            if (exportMatch?.[1])
+                exports.push(exportMatch[1]);
+            const defaultExportMatch = trimmed.match(/^export\s+default\s+(\w+)/);
+            if (defaultExportMatch?.[1])
+                exports.push(defaultExportMatch[1] + ' (default)');
+            const funcMatch = trimmed.match(/^(?:export\s+)?function\s+(\w+)/);
+            if (funcMatch?.[1])
+                functions.push({ name: funcMatch[1], line: lineNum });
+            const constFuncMatch = trimmed.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?\(/);
+            if (constFuncMatch?.[1])
+                functions.push({ name: constFuncMatch[1], line: lineNum });
+            const classMatch = trimmed.match(/^(?:export\s+)?class\s+(\w+)/);
+            if (classMatch?.[1])
+                classes.push({ name: classMatch[1], line: lineNum });
+            const interfaceMatch = trimmed.match(/^(?:export\s+)?interface\s+(\w+)/);
+            if (interfaceMatch?.[1])
+                interfaces.push({ name: interfaceMatch[1], line: lineNum });
+            const typeMatch = trimmed.match(/^(?:export\s+)?type\s+(\w+)/);
+            if (typeMatch?.[1])
+                interfaces.push({ name: typeMatch[1] + ' (type)', line: lineNum });
+        }
+        if (imports.length > 0) {
+            summary.push("### Imports");
+            summary.push(imports.slice(0, 10).join(', '));
+            if (imports.length > 10)
+                summary.push(`... +${imports.length - 10} more`);
+            summary.push("");
+        }
+        if (interfaces.length > 0) {
+            summary.push("### Interfaces/Types");
+            summary.push(interfaces.map(i => `${i.name}:${i.line}`).join(', '));
+            summary.push("");
+        }
+        if (classes.length > 0) {
+            summary.push("### Classes");
+            summary.push(classes.map(c => `${c.name}:${c.line}`).join(', '));
+            summary.push("");
+        }
+        if (functions.length > 0) {
+            summary.push("### Functions");
+            summary.push(functions.map(f => `${f.name}:${f.line}`).join(', '));
+            summary.push("");
+        }
+        if (exports.length > 0) {
+            summary.push("### Exports");
+            summary.push(exports.join(', '));
+            summary.push("");
+        }
+    }
+    if (fileExt === 'py') {
+        const functions = [];
+        const classes = [];
+        const imports = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            const trimmed = line.trim();
+            const lineNum = i + 1;
+            const importMatch = trimmed.match(/^(?:from\s+(\S+)\s+)?import\s+(\S+)/);
+            if (importMatch?.[1] && importMatch[2])
+                imports.push(importMatch[1] + '.' + importMatch[2]);
+            if (importMatch?.[1] === undefined && importMatch?.[2])
+                imports.push(importMatch[2]);
+            const funcMatch = trimmed.match(/^(?:def\s+)(\w+)/);
+            if (funcMatch?.[1] && !trimmed.startsWith('#'))
+                functions.push({ name: funcMatch[1], line: lineNum });
+            const classMatch = trimmed.match(/^class\s+(\w+)/);
+            if (classMatch?.[1])
+                classes.push({ name: classMatch[1], line: lineNum });
+        }
+        if (imports.length > 0) {
+            summary.push("### Imports");
+            summary.push(imports.slice(0, 10).join(', '));
+            summary.push("");
+        }
+        if (classes.length > 0) {
+            summary.push("### Classes");
+            summary.push(classes.map(c => `${c.name}:${c.line}`).join(', '));
+            summary.push("");
+        }
+        if (functions.length > 0) {
+            summary.push("### Functions");
+            summary.push(functions.map(f => `${f.name}:${f.line}`).join(', '));
+            summary.push("");
+        }
+    }
+    if (fileExt === 'md') {
+        const headings = [];
+        for (const line of lines) {
+            const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+            if (headingMatch?.[1] && headingMatch[2])
+                headings.push({ text: headingMatch[2], level: headingMatch[1].length });
+        }
+        if (headings.length > 0) {
+            summary.push("### Structure");
+            summary.push(headings.map(h => '  '.repeat(h.level - 1) + h.text).join('\n'));
+            summary.push("");
+        }
+    }
+    const preview = lines.slice(0, 5).filter((l) => l.trim()).join('\n');
+    if (preview) {
+        summary.push("### Preview");
+        summary.push("```\n" + preview + "\n```");
+    }
+    return summary.join('\n');
+}

package/dist/frontmatter.js

@@ -0,0 +1,28 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import yaml from "js-yaml";
+export function splitFrontmatter(text) {
+    if (!text.startsWith("---\n")) {
+        return { frontmatterText: undefined, body: text };
+    }
+    const endIndex = text.indexOf("\n---\n", 4);
+    if (endIndex === -1) {
+        return { frontmatterText: undefined, body: text };
+    }
+    const frontmatterText = text.slice(4, endIndex);
+    const body = text.slice(endIndex + "\n---\n".length);
+    return { frontmatterText, body };
+}
+export function buildFrontmatterDocument(frontmatter, body) {
+    const frontmatterYaml = yaml.dump(frontmatter, {
+        lineWidth: 120,
+        noRefs: true,
+        sortKeys: true,
+    });
+    return `---\n${frontmatterYaml}---\n${body.trim()}\n`;
+}
+export async function atomicWriteFile(filePath, content) {
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.tmp`);
+    await fs.writeFile(tempPath, content, "utf-8");
+    await fs.rename(tempPath, filePath);
+}