opencode-codex-memory 0.1.9 → 0.2.1

package/dist/tools/memory.js

@@ -1,7 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { safeResolveMemoryPath } from "../src/path-guard.js";
-import { memoryRoot } from "../src/paths.js";
+import { safeResolveMemoryPath, assertMemoryRootSafe } from "../src/path-guard.js";
 import { tool } from "@opencode-ai/plugin";
 const MAX_READ_BYTES = 256 * 1024;
 export const memory_read = tool({
@@ -27,19 +26,10 @@ export const memory_read = tool({
                     metadata: { kind: "directory", entries },
                 };
             }
-            const fd = fs.openSync(fullPath, "r");
-            let text;
-            let byteTruncated;
-            try {
-                const size = Math.min(stat.size, MAX_READ_BYTES);
-                const buf = Buffer.alloc(size);
-                fs.readSync(fd, buf, 0, size, 0);
-                text = buf.toString("utf8");
-                byteTruncated = stat.size > MAX_READ_BYTES;
-            }
-            finally {
-                fs.closeSync(fd);
-            }
+            // Read the whole file and apply the line window FIRST; the byte cap
+            // applies to the WINDOWED output. Capping the raw read used to make
+            // lines beyond the first 256 KiB unreachable regardless of line_offset.
+            const text = fs.readFileSync(fullPath, "utf8");
             // Line windowing mirrors codex memories/read: 1-indexed offset, bounded
             // line count, and the start line reported so file:line citations work.
             const startLine = args.line_offset ?? 1;
@@ -54,12 +44,18 @@ export const memory_read = tool({
                 lines = lines.slice(0, args.max_lines);
                 lineTruncated = true;
             }
-            const body = lines.join("\n");
+            let body = lines.join("\n");
+            let byteTruncated = false;
+            if (Buffer.byteLength(body, "utf8") > MAX_READ_BYTES) {
+                byteTruncated = true;
+                // Byte-accurate cut; drop a possibly split trailing multibyte char.
+                body = Buffer.from(body, "utf8").subarray(0, MAX_READ_BYTES).toString("utf8").replace(/\uFFFD+$/, "");
+            }
             const notes = [];
             if (lineTruncated)
                 notes.push(`[stopped after ${args.max_lines} lines; file has ${totalLines}]`);
             if (byteTruncated)
-                notes.push(`[truncated: ${stat.size - MAX_READ_BYTES} bytes omitted]`);
+                notes.push(`[output truncated at ${MAX_READ_BYTES} bytes; use line_offset to page]`);
             const header = startLine > 1 ? `[starting at line ${startLine}]\n` : "";
             return {
                 output: header + body + (notes.length ? "\n\n" + notes.join("\n") : ""),
@@ -152,22 +148,22 @@ function parseDateArg(value, endOfDay) {
 }
 // Walks every non-hidden, non-symlink file (codex searches all files, not an
 // extension allowlist), in sorted order for deterministic results.
-function collectSearchFiles(root) {
+function collectSearchFiles(start, prefix) {
     const files = [];
-    const walk = (dir, prefix) => {
+    const walk = (dir, rel) => {
         const entries = visibleEntries(dir).sort((a, b) => a.name.localeCompare(b.name));
         for (const { name, isDir } of entries) {
             const abs = path.join(dir, name);
-            const rel = prefix ? `${prefix}/${name}` : name;
+            const relPath = rel ? `${rel}/${name}` : name;
             if (isDir) {
-                walk(abs, rel);
+                walk(abs, relPath);
             }
             else {
-                files.push({ rel, abs, ts: fileTimestamp(name) });
+                files.push({ rel: relPath, abs, ts: fileTimestamp(name) });
             }
         }
     };
-    walk(root, "");
+    walk(start, prefix);
     return files;
 }
 function firstContentLine(content) {
@@ -182,26 +178,118 @@ function firstContentLine(content) {
     }
     return "(empty)";
 }
+// --- search engine, ported from codex ext/memories/src/local/search.rs ---
+const SEARCH_MAX_RESULTS = 200; // codex MAX_SEARCH_RESULTS (= default)
+// codex SearchComparison::prepare: lowercase when case-insensitive; when
+// normalized, keep ONLY alphanumeric characters (Unicode) so "blue-green",
+// "blue green" and "bluegreen" compare equal.
+function prepareComparable(value, caseSensitive, normalized) {
+    let v = caseSensitive ? value : value.toLowerCase();
+    if (normalized)
+        v = v.replace(/[^\p{L}\p{N}]/gu, "");
+    return v;
+}
+/**
+ * Per-file matching, all three codex modes. Window mode extends from every
+ * line matching at least one query until all queries are covered (bounded by
+ * lineCount), then drops windows that strictly contain another window so only
+ * minimal windows are reported.
+ */
+function searchFileContent(file, lines, queries, preparedQueries, mode, lineCount, contextLines, caseSensitive, normalized, out) {
+    const lineFlags = lines.map((line) => {
+        const prepared = prepareComparable(line, caseSensitive, normalized);
+        return preparedQueries.map((q) => prepared.includes(q));
+    });
+    const matchedQueries = (flags) => queries.filter((_, i) => flags[i]);
+    const push = (start, end, flags) => {
+        const contentStart = Math.max(0, start - contextLines);
+        const contentEnd = Math.min(lines.length, end + contextLines + 1);
+        out.push({
+            path: file.rel,
+            match_line_number: start + 1,
+            content_start_line_number: contentStart + 1,
+            content: lines.slice(contentStart, contentEnd).join("\n"),
+            matched_queries: matchedQueries(flags),
+        });
+    };
+    if (mode === "any" || mode === "all_on_same_line") {
+        for (let i = 0; i < lines.length; i++) {
+            const flags = lineFlags[i];
+            const hit = mode === "any" ? flags.some(Boolean) : flags.every(Boolean);
+            if (hit)
+                push(i, i, flags);
+        }
+        return;
+    }
+    // all_within_lines
+    const windows = [];
+    for (let start = 0; start < lines.length; start++) {
+        if (!lineFlags[start].some(Boolean))
+            continue;
+        const lastAllowed = Math.min(start + lineCount - 1, lines.length - 1);
+        const flags = new Array(preparedQueries.length).fill(false);
+        for (let end = start; end <= lastAllowed; end++) {
+            for (let q = 0; q < flags.length; q++)
+                flags[q] = flags[q] || lineFlags[end][q];
+            if (flags.every(Boolean)) {
+                windows.push({ start, end, flags });
+                break;
+            }
+        }
+    }
+    for (let i = 0; i < windows.length; i++) {
+        const w = windows[i];
+        const containsAnother = windows.some((o, j) => i !== j && w.start <= o.start && w.end >= o.end && (w.start !== o.start || w.end !== o.end));
+        if (containsAnother)
+            continue;
+        push(w.start, w.end, w.flags);
+    }
+}
+function renderMatch(m) {
+    const header = `${m.path}:${m.match_line_number}`;
+    if (!m.content.includes("\n") && m.content_start_line_number === m.match_line_number) {
+        return `${header}: ${m.content}`;
+    }
+    return `${header} (content from line ${m.content_start_line_number}):\n${m.content}`;
+}
 export const memory_search = tool({
-    description: "Search across the persistent memory workspace (MEMORY.md, rollout_summaries/*, skills/*). " +
-        "Returns matching lines with file paths. Optional since/until restrict the search to " +
-        "time-anchored files (rollout summaries, ad-hoc notes) from that period — useful to recall " +
-        "what the user was working on around a given time. With since/until and no query, returns a " +
-        "chronological listing of that period's sessions/notes.",
+    description: "Search the persistent memory workspace (MEMORY.md, rollout_summaries/*, skills/*) for substring " +
+        "matches. Supports multiple queries with match_mode: 'any' (a line matching any query), " +
+        "'all_on_same_line' (a line containing every query), or 'all_within_lines' (all queries within a " +
+        "window of line_count lines). Optional path scoping, context lines, and cursor pagination. " +
+        "Optional since/until restrict the search to time-anchored files (rollout summaries, ad-hoc " +
+        "notes) from that period — useful to recall what the user was working on around a given time. " +
+        "With since/until and no queries, returns a chronological listing of that period's sessions/notes.",
     args: {
-        query: tool.schema.string().min(1).optional().describe("Search query (substring match). Optional when since/until is set."),
+        queries: tool.schema.array(tool.schema.string()).optional().describe("Search substrings (at least one, non-empty after trim). Optional only when since/until is set."),
+        match_mode: tool.schema.enum(["any", "all_on_same_line", "all_within_lines"]).default("any").describe("How multiple queries combine (default any)."),
+        line_count: tool.schema.number().int().min(1).optional().describe("Window size in lines for all_within_lines (required for that mode)."),
+        path: tool.schema.string().optional().describe("Restrict the search to a file or directory relative to the memory root."),
+        cursor: tool.schema.string().optional().describe("Pagination cursor from a previous response's next_cursor."),
+        context_lines: tool.schema.number().int().min(0).default(0).describe("Extra lines of context around each match."),
         case_sensitive: tool.schema.boolean().default(true).describe("Case-sensitive matching (default true, like codex memories/search)."),
+        normalized: tool.schema.boolean().default(false).describe("Compare only alphanumeric characters, ignoring separators (blue-green == bluegreen); combine with case_sensitive=false to also ignore case."),
         since: tool.schema.string().optional().describe("Only time-anchored files at/after this time (YYYY-MM-DD or ISO datetime)."),
         until: tool.schema.string().optional().describe("Only time-anchored files at/before this time (YYYY-MM-DD or ISO datetime; whole day for date-only)."),
-        limit: tool.schema.number().int().min(1).max(200).default(200).describe("Max matches to return (default/max 200, like codex)."),
+        max_results: tool.schema.number().int().min(1).max(SEARCH_MAX_RESULTS).default(SEARCH_MAX_RESULTS).describe("Max matches per page (default/max 200, like codex)."),
     },
     async execute(args, ctx) {
         try {
-            const root = memoryRoot();
+            // Walks from the root directly (no per-path resolution), so the root
+            // symlink check must run here explicitly.
+            const root = assertMemoryRootSafe();
             if (!fs.existsSync(root))
                 return { output: "Memory workspace is empty." };
-            if (!args.query && !args.since && !args.until) {
-                return { output: "memory_search error: provide a query and/or since/until." };
+            const queries = (args.queries ?? []).map((q) => q.trim());
+            if (args.queries && (queries.length === 0 || queries.some((q) => q.length === 0))) {
+                return { output: "memory_search error: queries must be non-empty strings." };
+            }
+            if (queries.length === 0 && !args.since && !args.until) {
+                return { output: "memory_search error: provide queries and/or since/until." };
+            }
+            const mode = (args.match_mode ?? "any");
+            if (mode === "all_within_lines" && !(typeof args.line_count === "number" && args.line_count >= 1)) {
+                return { output: "memory_search error: all_within_lines requires line_count >= 1." };
             }
             const since = args.since ? parseDateArg(args.since, false) : null;
             if (args.since && since === null)
@@ -209,7 +297,23 @@ export const memory_search = tool({
             const until = args.until ? parseDateArg(args.until, true) : null;
             if (args.until && until === null)
                 return { output: `memory_search error: could not parse until="${args.until}".` };
-            let files = collectSearchFiles(root);
+            // Path scoping: a file searches just that file, a directory is walked.
+            let files;
+            if (args.path) {
+                const start = safeResolveMemoryPath(args.path);
+                let st;
+                try {
+                    st = fs.statSync(start);
+                }
+                catch {
+                    return { output: `Not found: ${args.path}` };
+                }
+                const rel = args.path.replace(/\/+$/, "");
+                files = st.isFile() ? [{ rel, abs: start, ts: fileTimestamp(path.basename(start)) }] : collectSearchFiles(start, rel);
+            }
+            else {
+                files = collectSearchFiles(root, "");
+            }
             const timeFiltered = since !== null || until !== null;
             if (timeFiltered) {
                 // Time filters only apply to time-anchored files; MEMORY.md etc. carry
@@ -218,8 +322,8 @@ export const memory_search = tool({
                 files.sort((a, b) => (b.ts ?? 0) - (a.ts ?? 0));
             }
             const rangeLabel = timeFiltered ? ` in ${args.since ?? "..."}..${args.until ?? "..."}` : "";
-            if (!args.query) {
-                const listing = files.slice(0, args.limit).map((f) => {
+            if (queries.length === 0) {
+                const listing = files.slice(0, args.max_results).map((f) => {
                     let content = "";
                     try {
                         content = fs.readFileSync(f.abs, "utf8");
@@ -236,13 +340,14 @@ export const memory_search = tool({
                 };
             }
             const caseSensitive = args.case_sensitive ?? true;
-            const q = caseSensitive ? args.query : args.query.toLowerCase();
-            const matches = [];
-            // Files are walked in sorted order, so results are ordered by
-            // (path, line) like codex's search response.
+            const normalized = args.normalized ?? false;
+            const preparedQueries = queries.map((q) => prepareComparable(q, caseSensitive, normalized));
+            if (preparedQueries.some((q) => q.length === 0)) {
+                return { output: "memory_search error: a query is empty after normalization." };
+            }
+            // codex: collect ALL matches, sort by (path, line), then page by cursor.
+            const all = [];
             for (const f of files) {
-                if (matches.length >= args.limit)
-                    break;
                 let content;
                 try {
                     content = fs.readFileSync(f.abs, "utf8");
@@ -250,26 +355,42 @@ export const memory_search = tool({
                 catch {
                     continue;
                 }
-                for (const [i, line] of content.split(/\r?\n/).entries()) {
-                    if (matches.length >= args.limit)
-                        break;
-                    const haystack = caseSensitive ? line : line.toLowerCase();
-                    if (haystack.includes(q)) {
-                        matches.push({ file: f.rel, line: i + 1, text: line.slice(0, 240) });
-                    }
+                if (content.includes("\u0000"))
+                    continue; // binary, like codex's InvalidData skip
+                searchFileContent(f, content.split(/\r?\n/), queries, preparedQueries, mode, args.line_count ?? 1, args.context_lines ?? 0, caseSensitive, normalized, all);
+            }
+            all.sort((a, b) => a.path.localeCompare(b.path) || a.match_line_number - b.match_line_number);
+            let startIndex = 0;
+            if (args.cursor !== undefined) {
+                startIndex = Number.parseInt(args.cursor, 10);
+                if (!Number.isInteger(startIndex) || startIndex < 0 || String(startIndex) !== args.cursor.trim()) {
+                    return { output: `memory_search error: invalid cursor "${args.cursor}" (must be a non-negative integer).` };
+                }
+                if (startIndex > all.length) {
+                    return { output: `memory_search error: cursor ${startIndex} exceeds result count ${all.length}.` };
                 }
             }
-            if (matches.length === 0)
-                return { output: `No matches for "${args.query}"${rangeLabel}.` };
-            const out = matches
-                .map((m) => `${m.file}:${m.line}: ${m.text}`)
-                .join("\n");
-            // codex signals a capped result set (truncated/next_cursor); without an
-            // indicator the model cannot tell "exactly N" from "stopped at N".
-            const capped = matches.length >= args.limit;
+            const endIndex = Math.min(startIndex + (args.max_results ?? SEARCH_MAX_RESULTS), all.length);
+            const pageMatches = all.slice(startIndex, endIndex);
+            const nextCursor = endIndex < all.length ? String(endIndex) : null;
+            const truncated = nextCursor !== null;
+            const label = queries.map((q) => `"${q}"`).join(", ");
+            if (all.length === 0)
+                return { output: `No matches for ${label}${rangeLabel}.` };
             return {
-                output: `${matches.length} match(es) for "${args.query}"${rangeLabel}${capped ? " (result limit reached; more may exist)" : ""}:\n${out}`,
-                metadata: { count: matches.length, query: args.query, since: args.since, until: args.until, truncated: capped },
+                output: `${pageMatches.length} of ${all.length} match(es) for ${label}${rangeLabel}` +
+                    `${truncated ? ` (more available; pass cursor=${nextCursor})` : ""}:\n` +
+                    pageMatches.map(renderMatch).join("\n"),
+                metadata: {
+                    queries,
+                    match_mode: mode === "all_within_lines" ? { type: mode, line_count: args.line_count } : { type: mode },
+                    path: args.path,
+                    matches: pageMatches,
+                    next_cursor: nextCursor,
+                    truncated,
+                    since: args.since,
+                    until: args.until,
+                },
             };
         }
         catch (err) {
@@ -287,7 +408,8 @@ export const memory_add_note = tool({
     },
     async execute(args, ctx) {
         try {
-            const root = memoryRoot();
+            // Writes under the root without per-path resolution; check the root.
+            const root = assertMemoryRootSafe();
             const notesDir = path.join(root, NOTES_DIR);
             fs.mkdirSync(notesDir, { recursive: true });
             const ts = new Date().toISOString();

package/opencode.json

@@ -20,7 +20,7 @@
     },
     "memorize-extract": {
       "mode": "subagent",
-      "prompt": "You are a memory extraction agent. Read the session transcript and extract raw_memory, rollout_summary, and rollout_slug as JSON. Exclude AGENTS.md/instruction content. Redact secrets.",
+      "prompt": "You are a memory extraction agent. The session transcript is provided inline in the prompt. Extract raw_memory, rollout_summary, and rollout_slug as JSON. Exclude AGENTS.md/instruction content. Redact secrets.",
       "permission": {
         "*": "deny",
         "bash": "deny",
@@ -28,11 +28,11 @@
         "websearch": "deny",
         "task": "deny",
         "todowrite": "deny",
-        "read": "allow",
+        "read": "deny",
         "write": "deny",
         "edit": "deny",
-        "glob": "allow",
-        "grep": "allow"
+        "glob": "deny",
+        "grep": "deny"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codex-memory",
-  "version": "0.1.9",
+  "version": "0.2.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",
@@ -45,7 +45,7 @@
   ],
   "license": "Apache-2.0",
   "dependencies": {
-    "@opencode-ai/plugin": "^1.17.13",
+    "@opencode-ai/plugin": "^1.18.0",
     "diff": "^9.0.0",
     "isomorphic-git": "^1.38.6"
   },