@kisev/memomatic 1.0.0-dev.46.gfbe1e4c6992e

package/dist/entries.js

@@ -0,0 +1,102 @@
+const TRAILING_ANNOTATION = /\s*<!--\s*([a-z-]+):\s*([^<]*?)\s*-->\s*$/;
+export function parseEntryLine(line) {
+    let value = line.trimEnd();
+    if (!value.startsWith("- "))
+        return null;
+    const annotations = {};
+    for (let index = 0; index < 8; index += 1) {
+        const match = TRAILING_ANNOTATION.exec(value);
+        if (!match)
+            break;
+        const name = match[1];
+        const raw = match[2];
+        let consumed = true;
+        if (name === "key" || name === "project" || name === "observed") {
+            if (name === "observed")
+                annotations.observed = raw;
+            else if (name === "project")
+                annotations.project = raw;
+            else
+                annotations.key = raw;
+        }
+        else if (name === "status") {
+            if (raw === "active" || raw === "superseded")
+                annotations.status = raw;
+            else
+                consumed = false;
+        }
+        else if (name === "origin") {
+            if (raw === "user" || raw === "agent")
+                annotations.origin = raw;
+            else
+                consumed = false;
+        }
+        else if (name === "importance") {
+            const parsed = Number.parseInt(raw, 10);
+            if (Number.isFinite(parsed) && parsed >= 1 && parsed <= 10)
+                annotations.importance = parsed;
+            else
+                consumed = false;
+        }
+        else if (name === "trigger") {
+            annotations.trigger = raw
+                .split(/[;,]\s*/)
+                .map((item) => item.trim())
+                .filter(Boolean);
+            if (!annotations.trigger.length)
+                consumed = false;
+        }
+        else if (name === "pinned") {
+            if (raw === "true")
+                annotations.pinned = true;
+            else
+                consumed = false;
+        }
+        else
+            consumed = false;
+        if (!consumed)
+            break;
+        value = value.slice(0, match.index).trimEnd();
+    }
+    return { text: value, annotations };
+}
+export function serializeAnnotations(annotations) {
+    const parts = [];
+    if (annotations.key)
+        parts.push(`key: ${annotations.key}`);
+    if (annotations.status)
+        parts.push(`status: ${annotations.status}`);
+    if (annotations.origin)
+        parts.push(`origin: ${annotations.origin}`);
+    if (annotations.observed)
+        parts.push(`observed: ${annotations.observed}`);
+    if (annotations.project)
+        parts.push(`project: ${annotations.project}`);
+    if (annotations.importance !== undefined)
+        parts.push(`importance: ${annotations.importance}`);
+    if (annotations.trigger?.length)
+        parts.push(`trigger: ${annotations.trigger.join("; ")}`);
+    if (annotations.pinned)
+        parts.push("pinned: true");
+    return parts.map((part) => `<!-- ${part} -->`).join(" ");
+}
+export function entryLine(text, annotations) {
+    const suffix = serializeAnnotations(annotations);
+    return `- ${text}${suffix ? ` ${suffix}` : ""}`;
+}
+export function entryKey(entry) {
+    if (entry.annotations.key)
+        return entry.annotations.key;
+    return null;
+}
+export function entryImportance(entry) {
+    return entry.annotations.importance ?? 5;
+}
+export function entryObservedAt(entry) {
+    if (entry.annotations.observed) {
+        const parsed = Date.parse(entry.annotations.observed);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return Number.NaN;
+}

package/dist/executor.d.ts

@@ -0,0 +1,22 @@
+export type ModelExecutor = {
+    name: string;
+    complete(request: {
+        system: string;
+        prompt: string;
+    }): Promise<string>;
+};
+export declare function extractJson(response: string): unknown;
+export declare class OpenCodeExecutor implements ModelExecutor {
+    private readonly options;
+    readonly name = "opencode";
+    constructor(options: {
+        model: string | null;
+        variant: string | null;
+        binary?: string;
+    });
+    complete(request: {
+        system: string;
+        prompt: string;
+    }): Promise<string>;
+    private spawnOnce;
+}

package/dist/executor.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+export function extractJson(response) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(response);
+    const candidates = [fenced?.[1], response].filter(Boolean);
+    for (const candidate of candidates) {
+        const start = candidate.indexOf("{");
+        const end = candidate.lastIndexOf("}");
+        if (start === -1 || end <= start)
+            continue;
+        try {
+            return JSON.parse(candidate.slice(start, end + 1));
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("model response contains no JSON object");
+}
+export class OpenCodeExecutor {
+    options;
+    name = "opencode";
+    constructor(options) {
+        this.options = options;
+    }
+    async complete(request) {
+        const args = ["run", "--agent", "build"];
+        if (this.options.model)
+            args.push("--model", this.options.model);
+        if (this.options.variant)
+            args.push("--variant", this.options.variant);
+        args.push("--message", `[memomatic-internal] ${request.system}\n\n${request.prompt}`);
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const output = await this.spawnOnce(args);
+            try {
+                const parsed = extractJson(output);
+                return JSON.stringify(parsed);
+            }
+            catch {
+                if (attempt === 1)
+                    throw new Error("opencode run returned no parsable JSON twice");
+            }
+        }
+        throw new Error("unreachable");
+    }
+    spawnOnce(args) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(this.options.binary ?? "opencode", args, {
+                env: process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout.on("data", (chunk) => {
+                stdout += chunk.toString("utf8");
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString("utf8");
+            });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve(stdout);
+                else
+                    reject(new Error(`opencode run exited ${code}: ${stderr.slice(0, 400)}`));
+            });
+        });
+    }
+}

package/dist/gates.d.ts

@@ -0,0 +1,22 @@
+import type { MemomaticSettings } from "./settings.js";
+import type { IndexedEntry, MemoryStore } from "./store.js";
+export type PromotionCandidate = {
+    entry: IndexedEntry;
+    score: number;
+    signals: {
+        relevance: number;
+        frequency: number;
+        diversity: number;
+        recency: number;
+        consolidation: number;
+        richness: number;
+    };
+    eligible: boolean;
+    reason: string | null;
+};
+export declare function scoreCandidate(entry: IndexedEntry, usage: {
+    useful: number;
+    queries: string[];
+    days: string[];
+}, settings: MemomaticSettings, relevance: number, now?: number): PromotionCandidate;
+export declare function promotionCandidates(store: MemoryStore, settings: MemomaticSettings, relevanceByStableId: Map<string, number>, now?: number): PromotionCandidate[];

package/dist/gates.js

@@ -0,0 +1,52 @@
+export function scoreCandidate(entry, usage, settings, relevance, now = Date.now()) {
+    const signals = {
+        relevance: Math.max(0, Math.min(1, relevance)),
+        frequency: Math.min(1, usage.useful / 10),
+        diversity: Math.min(1, usage.queries.length / 5),
+        recency: entry.observedAt
+            ? Math.pow(0.5, Math.max(0, now - entry.observedAt) / 86_400_000 / settings.search.halfLifeDays)
+            : 0.5,
+        consolidation: Math.min(1, usage.useful / Math.max(1, settings.dream.minUseful)),
+        richness: Math.min(1, entry.text.length / 400),
+    };
+    const score = 0.3 * signals.relevance +
+        0.24 * signals.frequency +
+        0.15 * signals.diversity +
+        0.15 * signals.recency +
+        0.1 * signals.consolidation +
+        0.06 * signals.richness;
+    let eligible = true;
+    let reason = null;
+    if (entry.kind !== "episodic") {
+        eligible = false;
+        reason = "not episodic";
+    }
+    else if (entry.origin === null) {
+        eligible = false;
+        reason = "unknown origin";
+    }
+    else if (usage.useful < settings.dream.minUseful) {
+        eligible = false;
+        reason = `useful ${usage.useful} < ${settings.dream.minUseful}`;
+    }
+    else if (usage.queries.length < settings.dream.minUniqueQueries) {
+        eligible = false;
+        reason = `queries ${usage.queries.length} < ${settings.dream.minUniqueQueries}`;
+    }
+    else if (score < settings.dream.minScore) {
+        eligible = false;
+        reason = `score ${score.toFixed(3)} < ${settings.dream.minScore}`;
+    }
+    return { entry, score, signals, eligible, reason };
+}
+export function promotionCandidates(store, settings, relevanceByStableId, now = Date.now()) {
+    const candidates = [];
+    for (const entry of store.allEntries()) {
+        const usage = store.usageFor(entry.stableId);
+        candidates.push(scoreCandidate(entry, usage, settings, relevanceByStableId.get(entry.stableId) ?? 0, now));
+    }
+    return candidates
+        .filter((candidate) => candidate.eligible)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, settings.dream.maxCandidates);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { writeCorpusFile } from "./corpus.js";
+export { entryLine, parseEntryLine } from "./entries.js";
+export { forgetEntry, getEntry, openMemomatic, searchMemory, writeEntry } from "./service.js";
+export type { MemomaticContext } from "./service.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { writeCorpusFile } from "./corpus.js";
+export { entryLine, parseEntryLine } from "./entries.js";
+export { forgetEntry, getEntry, openMemomatic, searchMemory, writeEntry } from "./service.js";

package/dist/ingest.d.ts

@@ -0,0 +1,16 @@
+export type IngestSession = {
+    id: string;
+    title: string;
+    directory: string;
+    timeCreated: number;
+    messages: Array<{
+        role: string;
+        text: string;
+    }>;
+};
+export declare function opencodeDatabasePath(): string;
+export declare function loadRecentSessions(databaseFile: string, afterTimeCreated: number, options?: {
+    maxSessions: number;
+    maxCharsPerSession: number;
+    before?: number;
+}): IngestSession[];

package/dist/ingest.js

@@ -0,0 +1,81 @@
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export function opencodeDatabasePath() {
+    const base = process.env.XDG_DATA_HOME
+        ? process.env.XDG_DATA_HOME
+        : join(homedir(), ".local", "share");
+    if (!isAbsolute(base))
+        throw new Error("XDG_DATA_HOME must be an absolute path");
+    return join(base, "opencode", "opencode.db");
+}
+export function loadRecentSessions(databaseFile, afterTimeCreated, options = {
+    maxSessions: 20,
+    maxCharsPerSession: 24_000,
+}) {
+    let db;
+    try {
+        db = new DatabaseSync(databaseFile, { readOnly: true });
+    }
+    catch {
+        return [];
+    }
+    try {
+        const before = options.before ?? Number.MAX_SAFE_INTEGER;
+        const sessions = db
+            .prepare(`SELECT id, title, directory, time_created FROM session
+        WHERE time_created > ? AND time_created < ? ORDER BY time_created ASC LIMIT ?;`)
+            .all(afterTimeCreated, before, options.maxSessions);
+        const result = [];
+        for (const session of sessions) {
+            const messages = [];
+            let budget = options.maxCharsPerSession;
+            let internal = false;
+            const rows = db
+                .prepare(`SELECT data FROM message WHERE session_id = ? ORDER BY time_created ASC;`)
+                .all(session.id);
+            for (const row of rows) {
+                if (budget <= 0)
+                    break;
+                let parsed;
+                try {
+                    parsed = JSON.parse(row.data);
+                }
+                catch {
+                    continue;
+                }
+                const texts = [];
+                for (const part of parsed.parts ?? []) {
+                    const value = part;
+                    if (value.type === "text" && typeof value.text === "string")
+                        texts.push(value.text);
+                }
+                const text = texts.join("\n").trim();
+                if (!text)
+                    continue;
+                if (text.includes("[memomatic-internal]"))
+                    internal = true;
+                if (budget - text.length < 0) {
+                    messages.push({ role: parsed.role ?? "unknown", text: text.slice(0, budget) });
+                    budget = 0;
+                    break;
+                }
+                budget -= text.length;
+                messages.push({ role: parsed.role ?? "unknown", text });
+            }
+            if (internal || !messages.length)
+                continue;
+            result.push({
+                id: session.id,
+                title: session.title,
+                directory: session.directory,
+                timeCreated: session.time_created,
+                messages,
+            });
+        }
+        return result;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/mcp.d.ts

@@ -0,0 +1,15 @@
+type JsonRpcRequest = {
+    jsonrpc?: string;
+    id?: unknown;
+    method?: string;
+    params?: Record<string, unknown>;
+};
+export declare function mcpResponse(id: unknown, result: unknown): string;
+export declare function mcpError(id: unknown, code: number, message: string): string;
+export declare function handleMcpRequest(request: JsonRpcRequest): Promise<string>;
+export declare function runMcpServer(input?: NodeJS.ReadStream & {
+    fd: 0;
+}, output?: NodeJS.WriteStream & {
+    fd: 1;
+}): Promise<void>;
+export {};

package/dist/mcp.js

@@ -0,0 +1,187 @@
+import { forgetEntry, getEntry, openMemomatic, searchMemory, writeEntry } from "./service.js";
+const PROTOCOL_VERSION = "2025-06-18";
+const TOOLS = [
+    {
+        description: "Search personal memory: durable decisions, discoveries, and session outcomes.",
+        inputSchema: {
+            additionalProperties: false,
+            properties: { query: { type: "string" } },
+            required: ["query"],
+            type: "object",
+        },
+        name: "memory_search",
+    },
+    {
+        description: "Read a memory file fully or one line. Fetching a line marks that entry as useful.",
+        inputSchema: {
+            additionalProperties: false,
+            properties: {
+                file: { description: "Path relative to the memomatic state root", type: "string" },
+                line: { type: "number" },
+            },
+            required: ["file"],
+            type: "object",
+        },
+        name: "memory_get",
+    },
+    {
+        description: "Save a memory entry. Use for standing decisions with rationale, discoveries, failed attempts with rejection reasons, session outcomes, and action-sensitive boundaries. Respect MEMORY_RULES.md; never-save topics are rejected.",
+        inputSchema: {
+            additionalProperties: false,
+            properties: {
+                importance: { maximum: 10, minimum: 1, type: "number" },
+                key: { type: "string" },
+                origin: { enum: ["user", "agent"], type: "string" },
+                pinned: { type: "boolean" },
+                project: { type: "string" },
+                target: { enum: ["episodic", "curated", "user"], type: "string" },
+                text: { type: "string" },
+                trigger: { items: { type: "string" }, type: "array" },
+            },
+            required: ["text"],
+            type: "object",
+        },
+        name: "memory_write",
+    },
+    {
+        description: "Remove one entry line from a memory file (explicit deletion only).",
+        inputSchema: {
+            additionalProperties: false,
+            properties: {
+                file: { description: "Path relative to the memomatic state root", type: "string" },
+                line: { type: "number" },
+            },
+            required: ["file", "line"],
+            type: "object",
+        },
+        name: "memory_forget",
+    },
+];
+async function callTool(name, args) {
+    const context = await openMemomatic();
+    try {
+        switch (name) {
+            case "memory_search": {
+                if (typeof args.query !== "string" || !args.query.trim())
+                    throw new Error("query is required");
+                const hits = await searchMemory(context, args.query);
+                return hits.map((hit) => ({
+                    file: hit.entry.file.replace(`${context.paths.stateRoot}/`, ""),
+                    kind: hit.entry.kind,
+                    line: hit.entry.line,
+                    score: Number(hit.score.toFixed(4)),
+                    snippet: hit.snippet,
+                }));
+            }
+            case "memory_get": {
+                if (typeof args.file !== "string" || !args.file)
+                    throw new Error("file is required");
+                const line = typeof args.line === "number" ? args.line : undefined;
+                const result = await getEntry(context, args.file, line);
+                return {
+                    content: result.content,
+                    file: result.file.replace(`${context.paths.stateRoot}/`, ""),
+                    line: result.line,
+                };
+            }
+            case "memory_write": {
+                if (typeof args.text !== "string" || !args.text.trim())
+                    throw new Error("text is required");
+                const file = await writeEntry(context, {
+                    importance: typeof args.importance === "number" ? args.importance : undefined,
+                    key: typeof args.key === "string" ? args.key : undefined,
+                    origin: args.origin === "user" ? "user" : "agent",
+                    pinned: args.pinned === true,
+                    project: typeof args.project === "string" ? args.project : undefined,
+                    target: args.target === "curated" || args.target === "user" ? args.target : "episodic",
+                    text: args.text,
+                    trigger: Array.isArray(args.trigger)
+                        ? args.trigger.filter((item) => typeof item === "string")
+                        : undefined,
+                });
+                return { file: file.replace(`${context.paths.stateRoot}/`, ""), saved: true };
+            }
+            case "memory_forget": {
+                if (typeof args.file !== "string" || typeof args.line !== "number")
+                    throw new Error("file and line are required");
+                const file = await forgetEntry(context, { file: args.file, line: args.line });
+                return { file: file.replace(`${context.paths.stateRoot}/`, ""), forgotten: true };
+            }
+            default:
+                throw new Error(`unknown tool: ${name}`);
+        }
+    }
+    finally {
+        context.store.close();
+    }
+}
+export function mcpResponse(id, result) {
+    return `${JSON.stringify({ id, jsonrpc: "2.0", result })}\n`;
+}
+export function mcpError(id, code, message) {
+    return `${JSON.stringify({ error: { code, message }, id, jsonrpc: "2.0" })}\n`;
+}
+export async function handleMcpRequest(request) {
+    const { id, method } = request;
+    if (method === "initialize")
+        return mcpResponse(id, {
+            capabilities: { tools: {} },
+            protocolVersion: PROTOCOL_VERSION,
+            serverInfo: { name: "memomatic", version: "0.1.0" },
+        });
+    if (method === "ping")
+        return mcpResponse(id, {});
+    if (method === "tools/list")
+        return mcpResponse(id, { tools: TOOLS });
+    if (method === "tools/call") {
+        const params = request.params ?? {};
+        const name = typeof params.name === "string" ? params.name : "";
+        const args = params.arguments && typeof params.arguments === "object"
+            ? params.arguments
+            : {};
+        try {
+            const content = await callTool(name, args);
+            return mcpResponse(id, {
+                content: [{ text: JSON.stringify(content), type: "text" }],
+            });
+        }
+        catch (error) {
+            return mcpResponse(id, {
+                content: [
+                    {
+                        text: JSON.stringify({ error: error.message }),
+                        type: "text",
+                    },
+                ],
+                isError: true,
+            });
+        }
+    }
+    if (method?.startsWith("notifications/"))
+        return "";
+    return mcpError(id, -32601, `method not found: ${method ?? "(none)"}`);
+}
+export async function runMcpServer(input = process.stdin, output = process.stdout) {
+    let buffer = "";
+    input.setEncoding("utf8");
+    for await (const chunk of input) {
+        buffer += chunk;
+        let newline = buffer.indexOf("\n");
+        while (newline !== -1) {
+            const frame = buffer.slice(0, newline).trim();
+            buffer = buffer.slice(newline + 1);
+            if (frame) {
+                try {
+                    const request = JSON.parse(frame);
+                    const response = await handleMcpRequest(request);
+                    if (response)
+                        output.write(response);
+                }
+                catch {
+                    output.write(mcpError(null, -32700, "parse error"));
+                }
+            }
+            newline = buffer.indexOf("\n");
+        }
+    }
+}

package/dist/paths.d.ts

@@ -0,0 +1,15 @@
+export type MemomaticPaths = {
+    stateRoot: string;
+    configRoot: string;
+    memoryFile: string;
+    userFile: string;
+    dreamsFile: string;
+    rulesFile: string;
+    settingsFile: string;
+    dailyDir: string;
+    archiveDir: string;
+    historyDir: string;
+    indexFile: string;
+};
+export declare function memomaticPaths(): MemomaticPaths;
+export declare function verifyMemomaticRoots(paths: MemomaticPaths): Promise<void>;

package/dist/paths.js

@@ -0,0 +1,47 @@
+import { lstat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve, sep } from "node:path";
+function safeXdg(name, fallback) {
+    const configured = process.env[name];
+    if (configured) {
+        if (!isAbsolute(configured) || configured.split(sep).includes(".."))
+            throw new Error(`${name} must be an absolute safe path`);
+        return resolve(configured);
+    }
+    const home = process.env.HOME ?? homedir();
+    if (!isAbsolute(home) || home.split(sep).includes(".."))
+        throw new Error("HOME must be an absolute safe path");
+    return join(resolve(home), fallback);
+}
+async function assertDirectory(path) {
+    try {
+        const info = await lstat(path);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error(`memomatic directory is unsafe: ${path}`);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+export function memomaticPaths() {
+    const stateRoot = join(safeXdg("XDG_STATE_HOME", ".local/state"), "memomatic");
+    const configRoot = join(safeXdg("XDG_CONFIG_HOME", ".config"), "memomatic");
+    return {
+        stateRoot,
+        configRoot,
+        memoryFile: join(stateRoot, "MEMORY.md"),
+        userFile: join(stateRoot, "USER.md"),
+        dreamsFile: join(stateRoot, "DREAMS.md"),
+        rulesFile: join(configRoot, "MEMORY_RULES.md"),
+        settingsFile: join(configRoot, "settings.json"),
+        dailyDir: join(stateRoot, "memory"),
+        archiveDir: join(stateRoot, "archive"),
+        historyDir: join(stateRoot, "history"),
+        indexFile: join(stateRoot, "index.sqlite"),
+    };
+}
+export async function verifyMemomaticRoots(paths) {
+    await assertDirectory(paths.stateRoot);
+    await assertDirectory(paths.configRoot);
+}

package/dist/rules.d.ts

@@ -0,0 +1,11 @@
+export type MemoryRules = {
+    neverSave: string[];
+    autoClean: {
+        olderThanDays: number;
+        scope: "episodic";
+    } | null;
+};
+export declare const emptyRules: () => MemoryRules;
+export declare function parseRules(markdown: string): MemoryRules;
+export declare function loadRules(rulesFile: string): Promise<MemoryRules>;
+export declare function isForbidden(text: string, rules: MemoryRules): boolean;