opencode-codex-memory 0.2.1 → 0.3.1

package/README.md

@@ -104,6 +104,10 @@ echo 'I prefer TypeScript strict mode and 2-space indentation.' \
     └── extensions/ad_hoc/notes/    # things you explicitly asked it to remember
 ```
 
+The location follows opencode's own data directory — `$XDG_DATA_HOME/opencode`
+when that's set, otherwise `~/.local/share/opencode` (same resolution on macOS,
+Linux, and Windows).
+
 It's all plain files and a local SQLite database. Read them, edit them, delete
 them — it's yours. (The `memories/` folder also holds a few working files and
 an internal `.git/` the plugin uses for change tracking; `memory_reset` wipes
@@ -117,10 +121,10 @@ those too.)
   session transcripts and extracted memories before anything is written or sent
   to a model. Notes you explicitly dictate ("remember that ...") are stored as
   you said them.
-- **The learning agents are sandboxed** — the extraction agent has no tools at
-  all (the transcript is handed to it inline), and the consolidation agent gets
-  only file tools plus access to the memory folder. Shell, network, IDE, and
-  MCP tools are denied for both.
+- **The learning agents are sandboxed** — the extraction agent can't touch your
+  filesystem (the transcript is handed to it inline; it only emits its structured
+  result), and the consolidation agent gets only file tools plus access to the
+  memory folder. Shell, network, IDE, and MCP tools are denied for both.
 - **Reset is safe.** `memory_reset` refuses to run if the memory folder is a
   symlink, so it can't be tricked into deleting something else.
 - **Web/MCP sessions:** by default, sessions that used web search, fetch, or MCP

package/dist/opencode.json

@@ -32,7 +32,8 @@
         "write": "deny",
         "edit": "deny",
         "glob": "deny",
-        "grep": "deny"
+        "grep": "deny",
+        "StructuredOutput": "allow"
       }
     }
   }

package/dist/src/llm.d.ts

@@ -17,5 +17,14 @@ export declare function consolidateViaSubagent(memoryRoot: string, diffFileName:
 export declare function cleanupOldSubSessions(maxAgeMinutes?: number): Promise<void>;
 export declare function fillTemplate(tmpl: string, vars: Record<string, string>): string;
 export declare function buildConsolidationPrompt(memoryRoot: string, diffFileName: string): string;
-/** Parses the stage-1 JSON output. Returns null for the all-empty no-op response. */
+/**
+ * Validates a parsed stage-1 object into an ExtractionResult, or null for the
+ * all-empty no-op. Shared by the structured-output path (AssistantMessage.
+ * structured) and the text parser below.
+ */
+export declare function validateExtraction(obj: Partial<ExtractionResult>): ExtractionResult | null;
+/**
+ * Parses stage-1 JSON from assistant text. Fallback for when structured output
+ * is unavailable; the primary path reads AssistantMessage.structured directly.
+ */
 export declare function parseExtraction(raw: string): ExtractionResult | null;

package/dist/src/llm.js

@@ -63,7 +63,8 @@ function parseModelRef(ref) {
         return null;
     return { providerID: ref.slice(0, slash), modelID: ref.slice(slash + 1) };
 }
-async function promptSession(sessionId, prompt, agent, opts = {}) {
+/** Runs a sub-agent prompt and returns the raw response data (`{ info, parts }`). */
+async function runPrompt(sessionId, prompt, agent, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 300_000;
     const input = getPluginInput();
     if (!input)
@@ -71,10 +72,13 @@ async function promptSession(sessionId, prompt, agent, opts = {}) {
     const model = opts.model ? parseModelRef(opts.model) : null;
     const promptPromise = input.client.session.prompt({
         path: { id: sessionId },
+        // `format` lives in the server's PromptInput but not the generated SDK body
+        // type yet (same OpenAPI lag as session.list scope/roots), hence the cast.
         body: {
             agent,
             ...(opts.system ? { system: opts.system } : {}),
             ...(model ? { model } : {}),
+            ...(opts.format ? { format: opts.format } : {}),
             parts: [{ type: "text", text: prompt }],
         },
     });
@@ -88,12 +92,15 @@ async function promptSession(sessionId, prompt, agent, opts = {}) {
         ]);
         if (!res.data)
             throw new Error(`prompt failed: ${JSON.stringify(res.error ?? {})}`);
-        return extractAssistantText(res.data);
+        return res.data;
     }
     finally {
         clearTimeout(timer);
     }
 }
+async function promptSession(sessionId, prompt, agent, opts = {}) {
+    return extractAssistantText(await runPrompt(sessionId, prompt, agent, opts));
+}
 function extractAssistantText(body) {
     if (!body)
         return "";
@@ -116,6 +123,19 @@ function extractAssistantText(body) {
         return body.output;
     return JSON.stringify(body);
 }
+// JSON Schema for structured stage-1 output. Mirrors the deliverables in
+// stage_one_system.md (three required string fields; all-empty = no-op) and is
+// opencode's equivalent of codex's output_schema + output_schema_strict.
+const EXTRACTION_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        raw_memory: { type: "string" },
+        rollout_summary: { type: "string" },
+        rollout_slug: { type: "string" },
+    },
+    required: ["raw_memory", "rollout_summary", "rollout_slug"],
+};
 /** Returns null when the extractor reported a no-op (nothing worth remembering). */
 export async function extractViaSubagent(sessionId, transcript, opts = {}) {
     const agent = "memorize-extract";
@@ -124,15 +144,27 @@ export async function extractViaSubagent(sessionId, transcript, opts = {}) {
         const prompt = buildExtractionInput(sessionId, opts.cwd ?? "unknown", transcript);
         // extract_model option > opencode small_model > session default.
         const model = opts.model ?? (await getConfigModels()).smallModel;
-        const raw = await promptSession(subId, prompt, agent, {
+        const data = await runPrompt(subId, prompt, agent, {
             // Mirrors the stage-1 job lease (1h): codex has no per-request timeout,
             // and a near-600k-char transcript on a slow model can easily exceed a
             // short one — repeated timeouts would exhaust the job's retries.
             timeoutMs: 3600_000,
             system: readTemplate("stage_one_system.md"),
             model,
+            // opencode enforces json_schema output via a forced StructuredOutput tool
+            // call (toolChoice: required) — which is why memorize-extract must allow
+            // that one otherwise-denied tool.
+            format: { type: "json_schema", schema: EXTRACTION_SCHEMA },
         });
-        return parseExtraction(raw);
+        // The captured JSON lands on AssistantMessage.structured (schema
+        // v1/session.ts; absent from the generated SDK type, so read it untyped).
+        // Fall back to text parsing when structured output is unavailable (a host
+        // without the feature, or a model that emitted JSON as plain text).
+        const structured = data?.info?.structured;
+        if (structured && typeof structured === "object") {
+            return validateExtraction(structured);
+        }
+        return parseExtraction(extractAssistantText(data));
     }
     finally {
         void deleteSession(subId).catch(() => { });
@@ -257,16 +289,12 @@ export function buildConsolidationPrompt(memoryRoot, diffFileName) {
 function readTemplate(name) {
     return fs.readFileSync(path.join(import.meta.dirname, "templates", name), "utf8");
 }
-/** Parses the stage-1 JSON output. Returns null for the all-empty no-op response. */
-export function parseExtraction(raw) {
-    const cleaned = raw.replace(/^```(?:json)?/gim, "").replace(/```$/gim, "").trim();
-    const start = cleaned.indexOf("{");
-    const end = cleaned.lastIndexOf("}");
-    if (start === -1 || end === -1 || end <= start) {
-        throw new Error("extraction response contained no JSON object");
-    }
-    const json = cleaned.slice(start, end + 1);
-    const obj = JSON.parse(json);
+/**
+ * Validates a parsed stage-1 object into an ExtractionResult, or null for the
+ * all-empty no-op. Shared by the structured-output path (AssistantMessage.
+ * structured) and the text parser below.
+ */
+export function validateExtraction(obj) {
     if (typeof obj.raw_memory !== "string" || typeof obj.rollout_summary !== "string") {
         throw new Error("extraction response missing required fields");
     }
@@ -289,3 +317,16 @@ export function parseExtraction(raw) {
         rollout_slug: typeof obj.rollout_slug === "string" && obj.rollout_slug.trim() ? obj.rollout_slug : null,
     };
 }
+/**
+ * Parses stage-1 JSON from assistant text. Fallback for when structured output
+ * is unavailable; the primary path reads AssistantMessage.structured directly.
+ */
+export function parseExtraction(raw) {
+    const cleaned = raw.replace(/^```(?:json)?/gim, "").replace(/```$/gim, "").trim();
+    const start = cleaned.indexOf("{");
+    const end = cleaned.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) {
+        throw new Error("extraction response contained no JSON object");
+    }
+    return validateExtraction(JSON.parse(cleaned.slice(start, end + 1)));
+}

package/dist/src/paths.js

@@ -1,13 +1,31 @@
 import path from "path";
 import os from "os";
+import { xdgData } from "xdg-basedir";
 const MEMORY_DIR_NAME = "memories";
 const MEMORY_DB_NAME = "memory.db";
 const OVERRIDE_ENV = "OPENCODE_CODEX_MEMORY_TEST_ROOT";
+const OPENCODE_APP_DIR = "opencode";
+/**
+ * Memory lives under opencode's data dir, mirroring codex's
+ * `<codex_home>/memories` (codex-rs `find_codex_home` + `from_codex_home`) but
+ * with the opencode-specific home. opencode resolves its data dir as
+ * `path.join(xdgData, "opencode")` via the `xdg-basedir` lib
+ * (packages/core/src/global.ts), so we reuse the SAME lib to stay byte-identical
+ * across platforms and `XDG_DATA_HOME` overrides. opencode does not surface this
+ * directory through the plugin API (`/path` gives home/config/state/worktree/
+ * directory, not data), so it must be recomputed here.
+ *
+ * `OPENCODE_CODEX_MEMORY_TEST_ROOT` is our `CODEX_HOME` analog: an explicit
+ * override that wins outright (tests + the write-pipeline sandbox).
+ */
 function dataRoot() {
     const override = process.env[OVERRIDE_ENV];
     if (override)
         return override;
-    return path.join(os.homedir(), ".local", "share", "opencode");
+    // xdgData = XDG_DATA_HOME || ~/.local/share (identical on every platform).
+    // The `??` mirrors xdg-basedir's own guard for a missing home directory.
+    const base = xdgData ?? path.join(os.homedir(), ".local", "share");
+    return path.join(base, OPENCODE_APP_DIR);
 }
 export function memoryRoot() {
     return path.join(dataRoot(), MEMORY_DIR_NAME);

package/opencode.json

@@ -32,7 +32,8 @@
         "write": "deny",
         "edit": "deny",
         "glob": "deny",
-        "grep": "deny"
+        "grep": "deny",
+        "StructuredOutput": "allow"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Persistent memory plugin for opencode — ports codex's two-phase memory system (extraction → consolidation → injection → citation feedback)",
   "type": "module",
   "main": "./dist/src/index.js",
@@ -47,7 +47,8 @@
   "dependencies": {
     "@opencode-ai/plugin": "^1.18.0",
     "diff": "^9.0.0",
-    "isomorphic-git": "^1.38.6"
+    "isomorphic-git": "^1.38.6",
+    "xdg-basedir": "^5.1.0"
   },
   "devDependencies": {
     "typescript": "^5.5.0",