open-memex 0.6.2 → 0.7.0-alpha.11

package/dist/doctor.js

@@ -7,17 +7,25 @@ import os from "node:os";
 import path from "node:path";
 import { spawn, execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { loadConfig, configSource, DEFAULT_CONFIG } from "./config.js";
-import { paths } from "./paths.js";
+import { loadConfig, configSource, DEFAULT_CONFIG, stripJsonComments } from "./config.js";
+import { paths, homeOverride } from "./paths.js";
 import { resolveCwdScope } from "./scope.js";
 import { db, backendName } from "./store/db.js";
 import { LEGACY_PACKAGE_NAME, opencodeGlobalConfigPath, userMcpConfigPath } from "./init.js";
+// D64: the MCP server exposes eleven tools; checking only the five the
+// opencode plugin carries let a half-registered server pass as healthy.
 const EXPECTED_TOOLS = [
     "memory_add",
     "memory_search",
     "memory_list",
     "memory_supersede",
     "memory_forget",
+    "memory_status",
+    "memory_submit",
+    "memory_propose",
+    "memory_promote",
+    "memory_resolve",
+    "memory_pr_status",
 ];
 function nodeCheck() {
     const [major, minor] = process.versions.node.split(".").map(Number);
@@ -54,7 +62,13 @@ function storageCheck() {
     try {
         const p = paths();
         fs.accessSync(p.memories, fs.constants.W_OK);
-        return { name: "storage", ok: true, detail: `${p.root} (writable)` };
+        // D62: when the root came from the legacy env var, say so (still ok —
+        // the fallback is supported, doctor just names the current one).
+        const via = homeOverride()?.via;
+        const note = via === "MY_O_MEMORY_HOME"
+            ? " (via legacy MY_O_MEMORY_HOME — OPEN_MEMEX_HOME is the current name)"
+            : "";
+        return { name: "storage", ok: true, detail: `${p.root} (writable)${note}` };
     }
     catch (err) {
         return { name: "storage", ok: false, detail: String(err) };
@@ -82,14 +96,17 @@ function lockingCheck() {
     }
 }
 /**
- * D59: patrol the opencode native-plugin entry. The D58 field failure was
- * silent — the entry was configured, the host never loaded it, and nothing
- * anywhere said why. Two death modes to catch:
- *   1. the entry's target file does not exist (package moved, nvm rolled
- *      to a new version dir, checkout deleted);
- *   2. the plugin's import closure runtime-imports @opencode-ai/plugin
- *      (or another host-only module the package does not depend on),
- *      which is unresolvable from a global install (D58 regression).
+ * D59/D60: patrol the opencode native-plugin entries. The D58 field failure
+ * was silent — the entry was configured, the host never loaded it, and
+ * nothing anywhere said why. Death modes to catch:
+ *   1. the entry's target does not exist (package moved, nvm rolled to a
+ *      new version dir, checkout deleted);
+ *   2. the plugin's import closure runtime-imports a host SDK package
+ *      (@opencode-ai/plugin on v1, @opencode/plugin on v2) — unresolvable
+ *      from a global install, the host silently skips the plugin (D58);
+ *   3. (D60) the config wires only the other host generation: an
+ *      opencode 2 host never reads the v1 `plugin` file entry (it demands
+ *      a directory under `plugins`), and opencode 1 cannot read `plugins`.
  * Read-only; only inspects the user-level opencode configs.
  */
 function opencodePluginCheck() {
@@ -97,8 +114,18 @@ function opencodePluginCheck() {
     try {
         const jsonPath = opencodeGlobalConfigPath();
         const candidates = [jsonPath, jsonPath.replace(/\.json$/, ".jsonc")];
-        const entries = [];
+        const v1Entries = [];
+        const v2Entries = [];
         let sawConfig = false;
+        const v2EntryPackage = (entry) => {
+            if (typeof entry === "string")
+                return entry;
+            if (entry !== null && typeof entry === "object" && "package" in entry) {
+                const p = entry.package;
+                return typeof p === "string" ? p : null;
+            }
+            return null;
+        };
         for (const f of candidates) {
             if (!fs.existsSync(f))
                 continue;
@@ -106,17 +133,24 @@ function opencodePluginCheck() {
             const text = fs.readFileSync(f, "utf8");
             try {
                 const doc = JSON.parse(text);
-                const list = Array.isArray(doc.plugin) ? doc.plugin : [];
-                for (const e of list) {
-                    if (typeof e === "string")
-                        entries.push(e);
+                if (Array.isArray(doc.plugin)) {
+                    for (const e of doc.plugin)
+                        if (typeof e === "string")
+                            v1Entries.push(e);
+                }
+                if (Array.isArray(doc.plugins)) {
+                    for (const e of doc.plugins) {
+                        const p = v2EntryPackage(e);
+                        if (p !== null)
+                            v2Entries.push(p);
+                    }
                 }
             }
             catch {
                 // JSONC (comments/trailing commas): fall back to scanning quoted
                 // strings for plugin entries.
                 for (const m of text.matchAll(/"(file:[^"]+|[^"]+\.(?:ts|js|mts|mjs))"/g)) {
-                    entries.push(m[1]);
+                    v1Entries.push(m[1]);
                 }
             }
         }
@@ -124,24 +158,71 @@ function opencodePluginCheck() {
             return { name, ok: true, detail: "no global opencode config found (skipped)" };
         }
         const problems = [];
-        const RUNTIME_SDK_IMPORT = /^\s*import\s+(?!type\b)[^;]*?["']@opencode-ai\/plugin(?:\/[^"']*)?["']/m;
-        const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode-ai\/plugin(?:\/[^"']*)?["']\s*\)/;
+        // Host SDK packages per generation; a runtime import of either from a
+        // globally installed plugin cannot resolve (D58).
+        const RUNTIME_SDK_IMPORT = /^\s*import\s+(?!type\b)[^;]*?["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']/m;
+        const RUNTIME_SDK_REQUIRE = /require\(\s*["']@opencode(?:-ai)?\/plugin(?:\/[^"']*)?["']\s*\)/;
+        const toPath = (entry) => {
+            try {
+                return entry.startsWith("file:") ? fileURLToPath(entry) : entry;
+            }
+            catch {
+                return null;
+            }
+        };
         // An entry is ours when its path names the package, or when the target
         // file carries the plugin's "[open-memex]" log marker (source checkouts
         // can live at any path).
-        const isOurEntry = (entry) => {
-            if (entry.includes("open-memex"))
-                return true;
+        const fileHasMarker = (target) => {
             try {
-                const target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-                if (!fs.existsSync(target))
-                    return false;
                 return fs.readFileSync(target, "utf8").slice(0, 65536).includes("[open-memex]");
             }
             catch {
                 return false;
             }
         };
+        /** Resolve an OpenCode 2 directory entry to its entry file, if any. */
+        const resolveV2EntryFile = (target) => {
+            try {
+                if (!fs.existsSync(target))
+                    return null;
+                if (fs.statSync(target).isFile())
+                    return target;
+                for (const idx of ["index.ts", "index.js", "index.mts", "index.mjs"]) {
+                    const p = path.join(target, idx);
+                    if (fs.existsSync(p))
+                        return p;
+                }
+                const pkgJson = path.join(target, "package.json");
+                if (fs.existsSync(pkgJson)) {
+                    const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+                    if (typeof pkg.main === "string") {
+                        const main = path.join(target, pkg.main);
+                        if (fs.existsSync(main))
+                            return main;
+                    }
+                }
+            }
+            catch {
+                return null;
+            }
+            return null;
+        };
+        const isOursV1 = (entry) => {
+            if (entry.includes("open-memex"))
+                return true;
+            const target = toPath(entry);
+            return target !== null && fs.existsSync(target) && fileHasMarker(target);
+        };
+        const isOursV2 = (entry) => {
+            if (entry.includes("open-memex"))
+                return true;
+            const target = toPath(entry);
+            if (target === null)
+                return false;
+            const file = resolveV2EntryFile(target);
+            return file !== null && fileHasMarker(file);
+        };
         const scanSdkImports = (entryFile) => {
             // Walk the entry's relative-import closure looking for host-SDK
             // runtime imports (type-only imports are erased and fine).
@@ -176,16 +257,14 @@ function opencodePluginCheck() {
             }
             return offenders;
         };
-        const ours = entries.filter(isOurEntry);
-        if (ours.length === 0) {
+        const oursV1 = v1Entries.filter(isOursV1);
+        const oursV2 = v2Entries.filter(isOursV2);
+        if (oursV1.length === 0 && oursV2.length === 0) {
             return { name, ok: true, detail: "no global plugin entry (per-project or MCP wiring is not checked)" };
         }
-        for (const entry of ours) {
-            let target;
-            try {
-                target = entry.startsWith("file:") ? fileURLToPath(entry) : entry;
-            }
-            catch {
+        for (const entry of oursV1) {
+            const target = toPath(entry);
+            if (target === null) {
                 problems.push(`entry "${entry}" is not a parseable file URL`);
                 continue;
             }
@@ -194,16 +273,62 @@ function opencodePluginCheck() {
                 continue;
             }
             for (const f of scanSdkImports(target)) {
-                problems.push(`${f} runtime-imports @opencode-ai/plugin — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
+                problems.push(`${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
+            }
+        }
+        for (const entry of oursV2) {
+            // A bare package name ("open-memex" via `opencode plugin add`) is
+            // resolved by the host's plugin manager; there is no local path to
+            // verify.
+            const isPackageName = !entry.startsWith("file:") &&
+                !entry.startsWith(".") &&
+                !path.isAbsolute(entry) &&
+                !/^[a-zA-Z]:[\\/]/.test(entry);
+            if (isPackageName)
+                continue;
+            const target = toPath(entry);
+            if (target === null || !fs.existsSync(target)) {
+                problems.push(`opencode 2 entry "${entry}" does not resolve to an existing path — run \`open-memex init --client opencode --global --force\` to re-point it`);
+                continue;
+            }
+            const entryFile = resolveV2EntryFile(target);
+            if (entryFile === null) {
+                problems.push(`opencode 2 entry "${entry}" has no loadable plugin file (looked for index.ts/index.js and package.json main)`);
+                continue;
+            }
+            for (const f of scanSdkImports(entryFile)) {
+                problems.push(`${f} runtime-imports a host SDK package — opencode silently skips plugins whose imports it cannot resolve from a global install (D58)`);
             }
         }
+        // D60: generation mismatch — the config wires only the generation the
+        // installed host cannot read. Best-effort: no binary, no opinion.
+        let hostMajor = null;
+        try {
+            const out = execFileSync("opencode", ["--version"], {
+                timeout: 3000,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            });
+            const m = out.match(/(\d+)\.(\d+)\.(\d+)/);
+            if (m)
+                hostMajor = Number(m[1]);
+        }
+        catch {
+            hostMajor = null;
+        }
+        if (hostMajor !== null && hostMajor >= 2 && oursV1.length > 0 && oursV2.length === 0) {
+            problems.push(`the installed opencode is v${hostMajor} but the config only has the opencode 1 "plugin" entry — v2 loads directories from "plugins" and will silently skip this plugin; run \`open-memex init --client opencode --global --force\` to add the v2 entry`);
+        }
+        else if (hostMajor === 1 && oursV2.length > 0 && oursV1.length === 0) {
+            problems.push(`the installed opencode is v1 but the config only has the opencode 2 "plugins" entry — v1 reads the "plugin" key and will not load this plugin; run \`open-memex init --client opencode --global --force\` to add the v1 entry`);
+        }
         if (problems.length > 0) {
             return { name, ok: false, detail: problems.join("; ") };
         }
         return {
             name,
             ok: true,
-            detail: `${ours.length} plugin ${ours.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
+            detail: `${oursV1.length + oursV2.length} plugin ${oursV1.length + oursV2.length === 1 ? "entry" : "entries"}: target exists, no host-SDK runtime imports`,
         };
     }
     catch (err) {
@@ -290,7 +415,8 @@ function mcpCheck() {
     });
 }
 /** Parse JSON tolerating line/block comments plus trailing commas
- * (VS Code's settings.json is JSONC). Health-check grade, not a full parser. */
+ * (VS Code's settings.json is JSONC). Uses config.ts's string-aware
+ * stripper — one parser, not two (P0 review, 2026-10-03). */
 function parseLenientJson(raw) {
     try {
         return JSON.parse(raw);
@@ -298,47 +424,7 @@ function parseLenientJson(raw) {
     catch {
         /* fall through to comment stripping */
     }
-    let out = "";
-    let i = 0;
-    let inStr = false;
-    let esc = false;
-    while (i < raw.length) {
-        const c = raw[i];
-        const n = raw[i + 1];
-        if (inStr) {
-            out += c;
-            if (esc)
-                esc = false;
-            else if (c === "\\")
-                esc = true;
-            else if (c === '"')
-                inStr = false;
-            i++;
-            continue;
-        }
-        if (c === '"') {
-            inStr = true;
-            out += c;
-            i++;
-            continue;
-        }
-        if (c === "/" && n === "/") {
-            while (i < raw.length && raw[i] !== "\n")
-                i++;
-            continue;
-        }
-        if (c === "/" && n === "*") {
-            i += 2;
-            while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/"))
-                i++;
-            i += 2;
-            continue;
-        }
-        out += c;
-        i++;
-    }
-    out = out.replace(/,\s*([}\]])/g, "$1");
-    return JSON.parse(out);
+    return JSON.parse(stripJsonComments(raw));
 }
 function vscodeSettingsPath() {
     const home = os.homedir();
@@ -448,13 +534,28 @@ export async function runDoctor() {
 function legacyCheck() {
     const name = "legacy my-o-memory";
     const found = [];
-    const envHome = process.env.MY_O_MEMORY_HOME;
+    // D62: the override may arrive via either env var name; check the value
+    // in effect, not just the legacy one.
+    const envHome = homeOverride()?.dir;
     if (envHome && envHome.includes(LEGACY_PACKAGE_NAME))
-        found.push(`MY_O_MEMORY_HOME points at a pre-rename dir (${envHome}) — unset it, then merge old data with \`open-memex migrate --to-v2\``);
+        found.push(`memory home points at a pre-rename dir (${envHome}) — unset it, then merge old data with \`open-memex migrate --to-v2\``);
     const root = paths().root;
     const legacyDir = path.join(path.dirname(root), LEGACY_PACKAGE_NAME);
     if (fs.existsSync(legacyDir) && fs.statSync(legacyDir).isDirectory())
         found.push(`legacy data dir ${legacyDir} — merge it with \`open-memex migrate --to-v2\``);
+    // D64: v1 stored personal memories under the scope dir "user"; v2 reads
+    // only "personal". Files left there are invisible to every read path —
+    // an upgrader silently sees an empty personal scope. Surface them here;
+    // the migration itself stays explicit (no silent moves).
+    try {
+        const userDir = path.join(root, "memories", "user");
+        if (fs.existsSync(userDir) &&
+            fs.readdirSync(userDir).some((f) => f.endsWith(".md")))
+            found.push("v1 personal memories under " + userDir + " are invisible to v2 reads — convert them with `open-memex migrate --to-v2` (it moves them to the personal scope; preview with --dry-run)");
+    }
+    catch {
+        /* unreadable — not this check's problem */
+    }
     for (const f of [opencodeGlobalConfigPath(), userMcpConfigPath("vscode"), userMcpConfigPath("cursor")]) {
         try {
             if (fs.existsSync(f) && fs.readFileSync(f, "utf8").includes(LEGACY_PACKAGE_NAME))

package/dist/export.js

@@ -117,10 +117,20 @@ export function importBundle(bundlePath, opts) {
         if (manifest.format !== EXPORT_FORMAT) {
             fail(`unsupported bundle format: ${manifest.format} (expected ${EXPORT_FORMAT})`);
         }
-        const result = { imported: 0, skippedIdentical: 0, skippedConflict: [] };
+        const result = { imported: 0, skippedIdentical: 0, skippedConflict: [], rejectedPaths: [] };
         const existingStmt = db().prepare(`SELECT content_hash FROM memories WHERE id = ?`);
+        // The manifest comes from whoever sent the bundle: entry.file must
+        // stay inside the staging dir (P0 review, 2026-10-03 — "../" entries
+        // otherwise read arbitrary .md files into the store). realpath also
+        // catches symlinks planted by the tarball.
+        const stageRoot = fs.realpathSync(stage);
         for (const entry of manifest.memories ?? []) {
-            const src = path.join(stage, entry.file);
+            const joined = path.resolve(path.join(stage, entry.file));
+            const src = fs.existsSync(joined) ? fs.realpathSync(joined) : joined;
+            if (!src.startsWith(stageRoot + path.sep)) {
+                result.rejectedPaths.push(entry.file);
+                continue;
+            }
             const mf = readMemoryFile(src);
             if (!mf)
                 continue;

package/dist/index.js

@@ -1,127 +1,35 @@
-import { loadConfig } from "./config.js";
-import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "./scope.js";
-import { db } from "./store/db.js";
-import { syncScope, upsertFromFile } from "./store/sync.js";
-import { scopeHasFiles } from "./store/migrate.js";
-import { writeMemoryFile, readMemoryFile, ulid, msToRfc3339, } from "./store/markdown.js";
-import { buildContextBlock } from "./retrieve/inject.js";
-import { detectKeywords } from "./capture/keywords.js";
-import { findDuplicates } from "./store/lifecycle.js";
-import { redact } from "./redact.js";
+import { PLUGIN_ID, bootstrapPlugin, captureFromText, injectOnce, } from "./plugin-core.js";
 import { makeTools } from "./tools/memory.js";
-const plugin = async ({ worktree, directory }) => {
-    const cfg = loadConfig();
+import { v2Plugin } from "./opencode-v2.js";
+/**
+ * One entrypoint, both opencode generations (D60):
+ * - OpenCode 2 structurally decodes the default export as `{ id, setup }`
+ *   and ignores `server` (see src/opencode-v2.ts).
+ * - OpenCode 1 (≥1.18.29) reads `server` off the same default export and
+ *   ignores `setup` — the function below is the v1 plugin exactly as it
+ *   behaved before dual support.
+ * Neither host runtime-imports an SDK package from this file: v1's SDK is
+ * type-only (D58), and v2's decode is structural.
+ */
+const server = async ({ worktree, directory }) => {
     const roots = worktree || directory || process.cwd();
-    const scope = resolveProjectScope(roots);
-    // Init DB and one-shot sync of markdown -> index on plugin load.
-    try {
-        db();
-        syncScope(scope.key);
-        syncScope(PERSONAL_SCOPE.key);
-        if (cfg.logLevel === "debug") {
-            console.log(`[open-memex] loaded. scope=${scope.key}`);
-        }
-        // If a git remote was added *after* memories were first captured, the
-        // scope key changes (cwd-hash -> origin-hash). Detect the legacy dir on
-        // disk and tell the user how to migrate. We do NOT auto-migrate: two
-        // different repos at the same cwd would collide.
-        const cwdScope = resolveCwdScope(roots);
-        if (cwdScope.key !== scope.key && scopeHasFiles(cwdScope.key)) {
-            console.warn(`[open-memex] found memories under legacy scope key "${cwdScope.key}". ` +
-                `Current project scope is "${scope.key}". ` +
-                `To move them: npm run cli -- migrate --from ${cwdScope.key}`);
-        }
-    }
-    catch (err) {
-        console.error("[open-memex] init failed:", err);
-    }
-    const tools = makeTools(() => scope, cfg);
-    const injectedSessions = new Set();
+    const state = bootstrapPlugin(roots);
+    const tools = makeTools(() => state.scope, state.cfg);
     return {
         tool: tools,
         async "chat.message"(_input, output) {
-            if (!cfg.keywordCaptureEnabled)
-                return;
             const parts = (output.parts ?? []);
             const text = parts
                 .map((p) => (p?.type === "text" ? p.text ?? "" : ""))
                 .filter(Boolean)
                 .join("\n");
-            if (!text)
-                return;
-            const hits = detectKeywords(text, cfg);
-            for (const h of hits) {
-                const { content, hadSecret, matchedPattern } = redact(h.content, cfg.redactPatterns);
-                // Secrets are masked (first 4 chars kept) and the capture proceeds;
-                // skip only when nothing usable remains.
-                if (content.length === 0)
-                    continue;
-                if (hadSecret && cfg.logLevel === "debug") {
-                    console.log(`[open-memex] keyword capture masked secret (${matchedPattern})`);
-                }
-                // Personal patterns ("remember for me" / "记住（个人）") force the personal scope.
-                const target = h.personal ? PERSONAL_SCOPE : scope;
-                // Dedup (§3.4): skip exact duplicates captured before.
-                if (findDuplicates(target.key, content).exact)
-                    continue;
-                const now = Date.now();
-                const rfc = msToRfc3339(now);
-                const fm = {
-                    id: ulid(),
-                    schema_version: 2,
-                    scope_key: target.key,
-                    scope: target.kind === "project" ? "project" : "personal",
-                    visibility: target.kind === "project" ? "internal" : "private",
-                    project_name: target.projectName,
-                    type: "fact",
-                    role: "knowledge",
-                    importance: "normal",
-                    status: "active",
-                    tags: ["keyword"],
-                    source: "keyword",
-                    created_at: rfc,
-                    updated_at: rfc,
-                    supersedes: null,
-                    superseded_by: null,
-                    review_state: "draft",
-                    proposed_by: null,
-                    approved_by: null,
-                    derived_from: null,
-                    review_note: null,
-                    review_history: [],
-                };
-                try {
-                    const { filePath } = writeMemoryFile(fm, content);
-                    const mf = readMemoryFile(filePath);
-                    if (mf)
-                        upsertFromFile(mf);
-                    // Capture feedback: always visible (not debug-only) — the user said
-                    // "记住…", they should see that it landed. The opencode plugin API
-                    // offers no toast channel, so the plugin log is the feedback surface.
-                    const preview = content.length > 60 ? content.slice(0, 60) + "…" : content;
-                    console.log(`[open-memex] remembered → ${target.kind} scope: "${preview}"`);
-                }
-                catch (err) {
-                    console.error("[open-memex] keyword capture failed:", err);
-                }
-            }
+            captureFromText(text, state);
         },
         async "experimental.chat.system.transform"(input, output) {
-            if (!cfg.injectOnFirstTurn)
-                return;
-            const sid = input.sessionID ?? "";
-            if (injectedSessions.has(sid))
-                return;
-            injectedSessions.add(sid);
-            try {
-                const block = buildContextBlock(scope, cfg);
-                if (block)
-                    output.system.push(block);
-            }
-            catch (err) {
-                console.error("[open-memex] context injection failed:", err);
-            }
+            injectOnce(input.sessionID ?? "", state, (block) => {
+                output.system.push(block);
+            });
         },
     };
 };
-export default plugin;
+export default { id: PLUGIN_ID, setup: v2Plugin.setup, server };