opencode-codex-memory 0.1.3 → 0.1.5

package/dist/src/capture.d.ts

@@ -0,0 +1,19 @@
+import { MemoryStore } from "./store.js";
+export interface SessionRow {
+    id: string;
+    updated_at: number;
+    directory: string | null;
+}
+export declare function listRecentSessions(limit?: number): SessionRow[];
+export interface TranscriptMessage {
+    type: string;
+    role?: string;
+    text?: string;
+}
+export declare function loadTranscript(sessionId: string): TranscriptMessage[];
+export interface EligibilityOptions {
+    maxAgeDays: number;
+    minIdleHours: number;
+    excludeSession?: string;
+}
+export declare function selectEligibleSessions(store: MemoryStore, opts: EligibilityOptions): SessionRow[];

package/dist/src/capture.js

@@ -0,0 +1,120 @@
+import { Database } from "bun:sqlite";
+import { opencodeDbPath } from "./paths.js";
+import { SCAN_LIMIT } from "./store.js";
+let opencodeDb = null;
+function openOpencodeDb() {
+    if (opencodeDb)
+        return opencodeDb;
+    const p = opencodeDbPath();
+    try {
+        opencodeDb = new Database(p, { readonly: true });
+    }
+    catch {
+        opencodeDb = null;
+    }
+    return opencodeDb;
+}
+export function listRecentSessions(limit = SCAN_LIMIT) {
+    const db = openOpencodeDb();
+    if (!db)
+        return [];
+    try {
+        // Top-level sessions only: task-tool children are summarized into their
+        // parent, and the plugin's own sub-sessions must never be memorized.
+        return db
+            .prepare(`SELECT id, time_updated AS updated_at, directory FROM session
+         WHERE parent_id IS NULL AND title NOT LIKE 'codex-memory-%'
+         ORDER BY time_updated DESC LIMIT ?`)
+            .all(limit);
+    }
+    catch {
+        return [];
+    }
+}
+export function loadTranscript(sessionId) {
+    const db = openOpencodeDb();
+    if (!db)
+        return [];
+    try {
+        const rows = db
+            .prepare(`SELECT p.data, m.data AS msg_data
+         FROM part p
+         JOIN message m ON p.message_id = m.id
+         WHERE p.session_id = ?
+         ORDER BY p.time_created ASC`)
+            .all(sessionId);
+        return rows.map((r) => {
+            let parsed = {};
+            try {
+                parsed = JSON.parse(r.data);
+            }
+            catch {
+            }
+            let role;
+            try {
+                const msg = JSON.parse(r.msg_data);
+                role = msg.role;
+            }
+            catch {
+            }
+            return {
+                type: parsed.type ?? "unknown",
+                role,
+                text: extractText(parsed),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function extractText(msg) {
+    if (!msg)
+        return undefined;
+    if (typeof msg.text === "string")
+        return msg.text;
+    if (msg.type === "tool") {
+        // Full tool payloads: codex serializes complete FunctionCall/Output items
+        // and relies solely on the global transcript truncation. Tool outputs are
+        // the extractor's strongest evidence — do not slice them per call.
+        const tool = msg.tool ?? "unknown";
+        const input = msg.state?.input ? JSON.stringify(msg.state.input) : "";
+        const output = typeof msg.state?.output === "string" ? msg.state.output : "";
+        return `[tool: ${tool}] ${input}${output ? "\n" + output : ""}`;
+    }
+    if (msg.type === "step-start" || msg.type === "step-finish")
+        return undefined;
+    if (Array.isArray(msg.parts)) {
+        return msg.parts
+            .filter((p) => p?.type === "text" && typeof p.text === "string")
+            .map((p) => p.text)
+            .join("\n");
+    }
+    if (Array.isArray(msg.content)) {
+        return msg.content
+            .filter((c) => typeof c === "string" || typeof c?.text === "string")
+            .map((c) => (typeof c === "string" ? c : c.text))
+            .join("\n");
+    }
+    return undefined;
+}
+export function selectEligibleSessions(store, opts) {
+    const now = Date.now();
+    const minUpdated = now - opts.maxAgeDays * 24 * 60 * 60 * 1000;
+    const maxUpdated = now - opts.minIdleHours * 60 * 60 * 1000;
+    const sessions = listRecentSessions();
+    return sessions.filter((s) => {
+        if (opts.excludeSession && s.id === opts.excludeSession)
+            return false;
+        if (s.updated_at < minUpdated)
+            return false;
+        if (s.updated_at > maxUpdated)
+            return false;
+        const mode = store.getMemoryMode(s.id);
+        if (mode === "disabled")
+            return false;
+        if (store.isPolluted(s.id))
+            return false;
+        return true;
+    });
+}

package/dist/src/citation.d.ts

@@ -0,0 +1,14 @@
+export interface MemoryCitationEntry {
+    path: string;
+    lineStart: number;
+    lineEnd: number;
+    note: string;
+}
+export interface ParsedCitation {
+    sessionIds: string[];
+    entries: MemoryCitationEntry[];
+    raw: string;
+}
+export declare function parseCitations(text: string): ParsedCitation[];
+export declare function extractCitedSessionIds(text: string): string[];
+export declare function stripCitations(text: string): string;

package/dist/src/citation.js

@@ -0,0 +1,81 @@
+const CITATION_BLOCK_RE = /<memory-citation>[\s\S]*?<\/memory-citation>/gi;
+function extractSection(block, name) {
+    const m = block.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`, "i"));
+    return m ? m[1] : null;
+}
+function parseEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    const noteSplit = trimmed.lastIndexOf("|note=[");
+    if (noteSplit === -1 || !trimmed.endsWith("]"))
+        return null;
+    const location = trimmed.slice(0, noteSplit);
+    const note = trimmed.slice(noteSplit + "|note=[".length, -1).trim();
+    const colon = location.lastIndexOf(":");
+    if (colon === -1)
+        return null;
+    const path = location.slice(0, colon).trim();
+    const range = location.slice(colon + 1);
+    const dash = range.indexOf("-");
+    if (dash === -1)
+        return null;
+    const lineStart = Number.parseInt(range.slice(0, dash).trim(), 10);
+    const lineEnd = Number.parseInt(range.slice(dash + 1).trim(), 10);
+    if (!path || Number.isNaN(lineStart) || Number.isNaN(lineEnd))
+        return null;
+    return { path, lineStart, lineEnd, note };
+}
+export function parseCitations(text) {
+    const results = [];
+    const re = new RegExp(CITATION_BLOCK_RE);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const raw = m[0];
+        const entries = [];
+        const sessionIds = [];
+        const seen = new Set();
+        const entriesBlock = extractSection(raw, "citation_entries");
+        if (entriesBlock) {
+            for (const line of entriesBlock.split(/\r?\n/)) {
+                const entry = parseEntry(line);
+                if (entry)
+                    entries.push(entry);
+            }
+        }
+        const idsBlock = extractSection(raw, "session_ids");
+        if (idsBlock) {
+            for (const line of idsBlock.split(/\r?\n/)) {
+                const id = line.trim();
+                if (id && !seen.has(id)) {
+                    seen.add(id);
+                    sessionIds.push(id);
+                }
+            }
+        }
+        else if (entriesBlock && entries.length === 0) {
+            // Legacy format: <citation_entries> held a comma-separated session-id list.
+            for (const id of entriesBlock.split(",").map((s) => s.trim()).filter(Boolean)) {
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    sessionIds.push(id);
+                }
+            }
+        }
+        if (entries.length > 0 || sessionIds.length > 0) {
+            results.push({ sessionIds, entries, raw });
+        }
+    }
+    return results;
+}
+export function extractCitedSessionIds(text) {
+    const seen = new Set();
+    for (const c of parseCitations(text)) {
+        for (const id of c.sessionIds)
+            seen.add(id);
+    }
+    return Array.from(seen);
+}
+export function stripCitations(text) {
+    return text.replace(CITATION_BLOCK_RE, "").replace(/[ \t]*\n{3,}/g, "\n\n").trimEnd();
+}

package/dist/src/db.d.ts

@@ -0,0 +1,3 @@
+import { Database } from "bun:sqlite";
+export declare function openDb(): Database;
+export declare function closeDb(): void;

package/dist/src/db.js

@@ -0,0 +1,78 @@
+import { Database } from "bun:sqlite";
+import { memoryDbPath } from "./paths.js";
+const SCHEMA_V1 = [
+    `CREATE TABLE IF NOT EXISTS memory_stage1_outputs (
+    session_id TEXT PRIMARY KEY,
+    source_updated_at INTEGER NOT NULL,
+    raw_memory TEXT NOT NULL,
+    rollout_summary TEXT NOT NULL,
+    rollout_slug TEXT,
+    cwd TEXT,
+    generated_at INTEGER NOT NULL,
+    usage_count INTEGER DEFAULT 0,
+    last_usage INTEGER,
+    selected_for_phase2 INTEGER NOT NULL DEFAULT 0,
+    selected_for_phase2_source_updated_at INTEGER
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_memory_stage1_source_updated_at
+    ON memory_stage1_outputs(source_updated_at DESC, session_id DESC)`,
+    `CREATE TABLE IF NOT EXISTS memory_jobs (
+    kind TEXT NOT NULL,
+    job_key TEXT NOT NULL,
+    status TEXT NOT NULL,
+    worker_id TEXT,
+    ownership_token TEXT,
+    started_at INTEGER,
+    finished_at INTEGER,
+    lease_until INTEGER,
+    retry_at INTEGER,
+    retry_remaining INTEGER NOT NULL,
+    last_error TEXT,
+    input_watermark INTEGER,
+    last_success_watermark INTEGER,
+    PRIMARY KEY (kind, job_key)
+  )`,
+    `CREATE INDEX IF NOT EXISTS idx_memory_jobs_kind_status_retry_lease
+    ON memory_jobs(kind, status, retry_at, lease_until)`,
+    `CREATE TABLE IF NOT EXISTS memory_session_meta (
+    session_id TEXT PRIMARY KEY,
+    memory_mode TEXT NOT NULL DEFAULT 'enabled',
+    polluted INTEGER NOT NULL DEFAULT 0,
+    updated_at INTEGER NOT NULL
+  )`,
+];
+let dbInstance = null;
+export function openDb() {
+    if (dbInstance)
+        return dbInstance;
+    const dbPath = memoryDbPath();
+    const db = new Database(dbPath, { create: true, readwrite: true, strict: false });
+    // Match codex's memories-DB open options (runtime.rs): WAL, NORMAL sync,
+    // 5s busy timeout for cross-process access, incremental auto-vacuum.
+    db.exec("PRAGMA journal_mode=WAL");
+    db.exec("PRAGMA synchronous=NORMAL");
+    db.exec("PRAGMA busy_timeout=5000");
+    db.exec("PRAGMA auto_vacuum=INCREMENTAL");
+    runMigrations(db);
+    dbInstance = db;
+    return db;
+}
+function runMigrations(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER NOT NULL,
+    applied_at INTEGER NOT NULL
+  )`);
+    const current = db.prepare("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    const currentVersion = current?.version ?? 0;
+    if (currentVersion >= 1)
+        return;
+    for (const stmt of SCHEMA_V1)
+        db.exec(stmt);
+    db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(1, Date.now());
+}
+export function closeDb() {
+    if (dbInstance) {
+        dbInstance.close();
+        dbInstance = null;
+    }
+}

package/dist/src/git-baseline.d.ts

@@ -0,0 +1,24 @@
+export declare const DIFF_ARTIFACT = "phase2_workspace_diff.md";
+export interface WorkspaceChange {
+    status: "A" | "M" | "D";
+    path: string;
+}
+export interface WorkspaceDiff {
+    changes: WorkspaceChange[];
+    unifiedDiff: string;
+}
+/**
+ * Mirrors codex prepare_memory_workspace: an existing baseline is preserved
+ * untouched so the phase-2 diff spans last-successful-run -> now — including
+ * manual user edits and newly added ad-hoc notes. Committing here would
+ * swallow those changes and consolidation would never see them. Only a root
+ * without any commit gets a fresh baseline.
+ */
+export declare function ensureBaseline(): Promise<boolean>;
+export declare function captureWorkspaceDiff(): Promise<WorkspaceDiff>;
+/**
+ * Mirrors codex reset_git_repository: delete .git and re-create a fresh
+ * single-commit baseline so deleted/redacted memory content is not retained
+ * in unreachable git objects (history is intentionally dropped).
+ */
+export declare function resetBaseline(): Promise<boolean>;

package/dist/src/git-baseline.js

@@ -0,0 +1,150 @@
+import fs from "fs";
+import path from "path";
+import { memoryRoot } from "./paths.js";
+import * as isogit from "isomorphic-git";
+import { createPatch } from "diff";
+const AUTHOR = { name: "opencode-codex-memory", email: "memory@opencode.local" };
+// Generated prompt artifact; removed before diffing and before baseline
+// commits (mirrors codex's remove_workspace_diff) so it never enters the
+// baseline history or shows up as memory content.
+export const DIFF_ARTIFACT = "phase2_workspace_diff.md";
+function removeDiffArtifact(dir) {
+    try {
+        fs.unlinkSync(path.join(dir, DIFF_ARTIFACT));
+    }
+    catch {
+    }
+}
+async function ensureInit(dir) {
+    const gitDir = path.join(dir, ".git");
+    if (!fs.existsSync(gitDir)) {
+        await isogit.init({ fs, dir });
+    }
+}
+// statusMatrix rows are [filepath, head, workdir, stage]; head !== workdir
+// means the working tree differs from HEAD (added, modified, or deleted).
+async function stageAll(dir) {
+    const matrix = await isogit.statusMatrix({ fs, dir });
+    let changes = 0;
+    for (const [filepath, head, workdir, stage] of matrix) {
+        if (head === 1 && workdir === 1 && stage === 1)
+            continue;
+        if (workdir === 0) {
+            // isogit.add throws on deleted files; they must be staged via remove
+            await isogit.remove({ fs, dir, filepath });
+        }
+        else {
+            await isogit.add({ fs, dir, filepath });
+        }
+        if (head !== workdir)
+            changes++;
+    }
+    return changes;
+}
+async function hasHeadCommit(dir) {
+    try {
+        await isogit.resolveRef({ fs, dir, ref: "HEAD" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function commitBaseline(dir) {
+    await stageAll(dir);
+    return isogit.commit({ fs, dir, message: "memory baseline", author: AUTHOR });
+}
+/**
+ * Mirrors codex prepare_memory_workspace: an existing baseline is preserved
+ * untouched so the phase-2 diff spans last-successful-run -> now — including
+ * manual user edits and newly added ad-hoc notes. Committing here would
+ * swallow those changes and consolidation would never see them. Only a root
+ * without any commit gets a fresh baseline.
+ */
+export async function ensureBaseline() {
+    try {
+        const dir = memoryRoot();
+        removeDiffArtifact(dir);
+        await ensureInit(dir);
+        if (!(await hasHeadCommit(dir))) {
+            await commitBaseline(dir);
+        }
+        return true;
+    }
+    catch (err) {
+        console.error("[opencode-codex-memory] ensureBaseline error:", err);
+        return false;
+    }
+}
+async function readBaselineText(dir, headOid, filepath) {
+    try {
+        const { blob } = await isogit.readBlob({ fs, dir, oid: headOid, filepath });
+        return new TextDecoder().decode(blob);
+    }
+    catch {
+        return "";
+    }
+}
+function readWorkdirText(dir, filepath) {
+    try {
+        return fs.readFileSync(path.join(dir, filepath), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export async function captureWorkspaceDiff() {
+    try {
+        const dir = memoryRoot();
+        await ensureInit(dir);
+        removeDiffArtifact(dir);
+        const matrix = await isogit.statusMatrix({ fs, dir });
+        const changedRows = matrix.filter(([filepath, head, workdir]) => head !== workdir && filepath !== DIFF_ARTIFACT);
+        const changes = changedRows.map(([filepath, head, workdir]) => {
+            if (head === 0)
+                return { status: "A", path: filepath };
+            if (workdir === 0)
+                return { status: "D", path: filepath };
+            return { status: "M", path: filepath };
+        });
+        let headOid = null;
+        try {
+            headOid = await isogit.resolveRef({ fs, dir, ref: "HEAD" });
+        }
+        catch {
+            // no commits yet — every file diffs against empty
+        }
+        const patches = [];
+        for (const [filepath, head, workdir] of changedRows) {
+            const oldText = head === 1 && headOid ? await readBaselineText(dir, headOid, filepath) : "";
+            const newText = workdir === 0 ? "" : readWorkdirText(dir, filepath);
+            // No per-file cap: codex renders every file's patch in full and relies
+            // on the global 4 MiB truncation in writeWorkspaceDiff.
+            patches.push(createPatch(filepath, oldText, newText));
+        }
+        return { changes, unifiedDiff: patches.join("\n") };
+    }
+    catch (err) {
+        console.error("[opencode-codex-memory] captureWorkspaceDiff error:", err);
+        return { changes: [], unifiedDiff: "" };
+    }
+}
+/**
+ * Mirrors codex reset_git_repository: delete .git and re-create a fresh
+ * single-commit baseline so deleted/redacted memory content is not retained
+ * in unreachable git objects (history is intentionally dropped).
+ */
+export async function resetBaseline() {
+    try {
+        const dir = memoryRoot();
+        removeDiffArtifact(dir);
+        fs.rmSync(path.join(dir, ".git"), { recursive: true, force: true });
+        await isogit.init({ fs, dir });
+        await commitBaseline(dir);
+        return true;
+    }
+    catch (err) {
+        console.error("[opencode-codex-memory] resetBaseline error:", err);
+        return false;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,163 @@
+import type { PluginInput, PluginOptions } from "@opencode-ai/plugin";
+export declare function takeNewCitations(partKey: string, ids: string[]): string[];
+declare const _default: {
+    id: string;
+    server(input: PluginInput, opts?: PluginOptions): Promise<{
+        tool: {
+            memory_read: {
+                description: string;
+                args: {
+                    path: import("zod").ZodString;
+                    line_offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    max_lines: import("zod").ZodOptional<import("zod").ZodNumber>;
+                };
+                execute(args: {
+                    path: string;
+                    line_offset?: number | undefined;
+                    max_lines?: number | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_search: {
+                description: string;
+                args: {
+                    query: import("zod").ZodOptional<import("zod").ZodString>;
+                    case_sensitive: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                    since: import("zod").ZodOptional<import("zod").ZodString>;
+                    until: import("zod").ZodOptional<import("zod").ZodString>;
+                    limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+                };
+                execute(args: {
+                    case_sensitive: boolean;
+                    limit: number;
+                    query?: string | undefined;
+                    since?: string | undefined;
+                    until?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_list: {
+                description: string;
+                args: {
+                    path: import("zod").ZodDefault<import("zod").ZodString>;
+                    max_results: import("zod").ZodDefault<import("zod").ZodNumber>;
+                };
+                execute(args: {
+                    path: string;
+                    max_results: number;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_add_note: {
+                description: string;
+                args: {
+                    note: import("zod").ZodString;
+                    title: import("zod").ZodOptional<import("zod").ZodString>;
+                };
+                execute(args: {
+                    note: string;
+                    title?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_reset: {
+                description: string;
+                args: {
+                    confirm: import("zod").ZodBoolean;
+                };
+                execute(args: {
+                    confirm: boolean;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_inspect: {
+                description: string;
+                args: {};
+                execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_mode: {
+                description: string;
+                args: {
+                    mode: import("zod").ZodEnum<{
+                        enabled: "enabled";
+                        disabled: "disabled";
+                        polluted: "polluted";
+                    }>;
+                    sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                };
+                execute(args: {
+                    mode: "enabled" | "disabled" | "polluted";
+                    sessionId?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+        } | {
+            memory_reset: {
+                description: string;
+                args: {
+                    confirm: import("zod").ZodBoolean;
+                };
+                execute(args: {
+                    confirm: boolean;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_inspect: {
+                description: string;
+                args: {};
+                execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_mode: {
+                description: string;
+                args: {
+                    mode: import("zod").ZodEnum<{
+                        enabled: "enabled";
+                        disabled: "disabled";
+                        polluted: "polluted";
+                    }>;
+                    sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+                };
+                execute(args: {
+                    mode: "enabled" | "disabled" | "polluted";
+                    sessionId?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            memory_read?: undefined;
+            memory_search?: undefined;
+            memory_list?: undefined;
+            memory_add_note?: undefined;
+        };
+        config(input: {
+            agent?: Record<string, unknown>;
+        }): Promise<void>;
+        "experimental.chat.system.transform"(input: {
+            sessionID?: string;
+            model: unknown;
+        }, output: {
+            system: string[];
+        }): Promise<void>;
+        "experimental.chat.messages.transform"(_input: unknown, output: {
+            messages: {
+                info: {
+                    role?: string;
+                };
+                parts: {
+                    type: string;
+                    text?: string;
+                }[];
+            }[];
+        }): Promise<void>;
+        event(input: {
+            event: {
+                type: string;
+                properties: unknown;
+            };
+        }): Promise<void>;
+        dispose(): Promise<void>;
+    }>;
+};
+export default _default;
+/**
+ * Registers the memorize / memorize-extract sub-agents through the config
+ * hook so installing the plugin requires no manual agent setup. Definitions
+ * are read from the plugin's bundled opencode.json (single source of truth
+ * with the dev checkout). A user-defined agent of the same name always wins —
+ * only missing entries are filled. opencode-specific packaging: codex ships
+ * its memory agents inside the binary.
+ */
+export declare function injectAgentDefinitions(config: {
+    agent?: Record<string, unknown>;
+}): void;