open-memex 0.6.2 → 0.7.0-alpha.1

package/src/index.ts

@@ -1,133 +1,46 @@
 import type { Plugin } from "@opencode-ai/plugin";
-import { loadConfig } from "./config.ts";
-import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE, type Scope } from "./scope.ts";
-import { db } from "./store/db.ts";
-import { syncScope, upsertFromFile } from "./store/sync.ts";
-import { scopeHasFiles } from "./store/migrate.ts";
 import {
-  writeMemoryFile,
-  readMemoryFile,
-  ulid,
-  msToRfc3339,
-  type Frontmatter,
-} from "./store/markdown.ts";
-import { buildContextBlock } from "./retrieve/inject.ts";
-import { detectKeywords } from "./capture/keywords.ts";
-import { findDuplicates } from "./store/lifecycle.ts";
-import { redact } from "./redact.ts";
+  PLUGIN_ID,
+  bootstrapPlugin,
+  captureFromText,
+  injectOnce,
+} from "./plugin-core.ts";
 import { makeTools } from "./tools/memory.ts";
-
-const plugin: Plugin = async ({ worktree, directory }) => {
-  const cfg = loadConfig();
+import { v2Plugin } from "./opencode-v2.ts";
+
+/**
+ * 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: Plugin = async ({ worktree, directory }) => {
   const roots = worktree || directory || process.cwd();
-  const scope: 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<string>();
+  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 ?? []) as Array<{ type: string; text?: string }>;
       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: Frontmatter = {
-          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 };

package/src/init.ts

@@ -300,6 +300,16 @@ function opencodePluginUrl(): string {
   return pathToFileURL(path.join(pkgRoot, "src", "index.ts")).href;
 }
 
+/**
+ * D60: the same plugin directory, in the form OpenCode 2 wants. v2 rejects
+ * file entries in `plugins` ("configured plugin path must be a directory")
+ * and loads `<dir>/index.ts` instead.
+ */
+function opencodePluginDir(): string {
+  const pkgRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+  return path.join(pkgRoot, "src");
+}
+
 /**
  * D46: opencode's user-level config. opencode reads `~/.config/opencode/`
  * (`$XDG_CONFIG_HOME` when set) on every platform; a `plugin` entry there
@@ -330,6 +340,65 @@ export function mergePluginEntry(
   return "added";
 }
 
+/** The package path an OpenCode 2 `plugins` entry refers to, if any. */
+function v2EntryPackage(entry: unknown): string | null {
+  if (typeof entry === "string") return entry;
+  if (entry !== null && typeof entry === "object" && "package" in entry) {
+    const p = (entry as { package?: unknown }).package;
+    return typeof p === "string" ? p : null;
+  }
+  return null;
+}
+
+/**
+ * D60: pure merge of the open-memex directory into the `plugins` array
+ * (the OpenCode 2 spelling). An existing open-memex entry (any form)
+ * counts as present; with force, stale open-memex entries are replaced
+ * by `dir`. Same "added"/"kept" contract as mergePluginEntry.
+ */
+export function mergeV2PluginEntry(
+  doc: Record<string, unknown>,
+  dir: string,
+  force: boolean,
+): "added" | "kept" {
+  let plugins = doc["plugins"];
+  if (!Array.isArray(plugins)) {
+    plugins = [] as unknown[];
+    doc["plugins"] = plugins;
+  }
+  const list = plugins as unknown[];
+  const ours = (e: unknown) => (v2EntryPackage(e) ?? "").includes("open-memex");
+  if (!force && list.some(ours)) return "kept";
+  for (let i = list.length - 1; i >= 0; i--) {
+    const p = v2EntryPackage(list[i]);
+    if (p === dir) {
+      if (!force) return "kept";
+      list.splice(i, 1);
+    } else if (force && ours(list[i])) {
+      list.splice(i, 1);
+    }
+  }
+  list.push(dir);
+  return "added";
+}
+
+/**
+ * Pure removal of open-memex entries from the `plugins` array (OpenCode 2
+ * spelling — strings and `{package}` objects). Drops the key when empty.
+ */
+export function removeV2PluginEntry(
+  doc: Record<string, unknown>,
+  match: string,
+): "removed" | "absent" {
+  const plugins = doc["plugins"];
+  if (!Array.isArray(plugins)) return "absent";
+  const kept = (plugins as unknown[]).filter((p) => !(v2EntryPackage(p) ?? "").includes(match));
+  if (kept.length === plugins.length) return "absent";
+  if (kept.length === 0) delete doc["plugins"];
+  else doc["plugins"] = kept;
+  return "removed";
+}
+
 /**
  * D46: wire the native plugin at the opencode user level — the one-time
  * global setup. Merges into the existing config when it parses as JSON;
@@ -343,13 +412,15 @@ function writeOpencodeGlobalPlugin(force: boolean): string | null {
       .map((f) => path.join(dir, f))
       .find((f) => fs.existsSync(f)) ?? path.join(dir, "opencode.json");
   const url = opencodePluginUrl();
+  const pluginDir = opencodePluginDir();
   let doc: Record<string, unknown> = {};
   if (fs.existsSync(file)) {
     try {
       doc = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
     } catch {
       console.log(`  ! ${file} has comments or invalid JSON — left untouched, fix it manually.`);
-      console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] to it.`);
+      console.log(`    To enable open-memex everywhere, add "plugin": ["${url}"] (opencode 1)`);
+      console.log(`    and "plugins": ["${pluginDir}"] (opencode 2) to it.`);
       console.log(`    Also remove any "${LEGACY_PACKAGE_NAME}" entries from "plugin" (stale — package renamed).`);
       return null;
     }
@@ -358,8 +429,12 @@ function writeOpencodeGlobalPlugin(force: boolean): string | null {
   // alongside the new one — it writes to the OLD data dir, silently splitting
   // memories in two. Drop it wherever init touches the plugin list.
   const staleRemoved = removePluginEntry(doc, LEGACY_PACKAGE_NAME) === "removed";
+  removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
   const merged = mergePluginEntry(doc, url, force);
-  if (merged === "kept" && !staleRemoved) {
+  // D60: write both key generations — opencode 1 reads `plugin`, opencode 2
+  // reads `plugins`; each host ignores the other's key.
+  const mergedV2 = mergeV2PluginEntry(doc, pluginDir, force);
+  if (merged === "kept" && mergedV2 === "kept" && !staleRemoved) {
     console.log(`  = ${file} already loads the open-memex plugin — left as is (use --force to overwrite)`);
     return file;
   }
@@ -367,7 +442,7 @@ function writeOpencodeGlobalPlugin(force: boolean): string | null {
   fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
   if (staleRemoved)
     console.log(`  - ${file} (stale my-o-memory plugin entry removed — package renamed to open-memex)`);
-  if (merged === "added")
+  if (merged === "added" || mergedV2 === "added")
     console.log(`  + ${file} (native plugin — works in every project, no per-project init needed)`);
   return file;
 }
@@ -963,13 +1038,16 @@ function removeOpencodePluginFile(file: string): "removed" | "absent" | null {
   const doc = parseJsonConfig(fs.readFileSync(file, "utf8"));
   if (doc === null) {
     console.error(`  ! ${file} is not valid JSON — left untouched, fix it manually`);
-    console.error(`    Delete the open-memex URL from the "plugin" array.`);
+    console.error(`    Delete the open-memex URL from the "plugin" array and the open-memex path from "plugins".`);
     return null;
   }
   const res = removePluginEntry(doc, "open-memex");
+  // D60: the v2 `plugins` entry goes too (strings and {package} objects).
+  const resV2 = removeV2PluginEntry(doc, "open-memex");
   // F30: also sweep the pre-rename leftover — see removeServerEntryFile.
   const stale = removePluginEntry(doc, LEGACY_PACKAGE_NAME);
-  if (res === "removed" || stale === "removed") {
+  removeV2PluginEntry(doc, LEGACY_PACKAGE_NAME);
+  if (res === "removed" || resV2 === "removed" || stale === "removed") {
     fs.writeFileSync(file, JSON.stringify(doc, null, 2) + "\n");
     console.log(`  - ${file} (memory-plugin entries removed)`);
     return "removed";

package/src/opencode-v2.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+import {
+  PLUGIN_ID,
+  bootstrapPlugin,
+  captureFromText,
+  injectOnce,
+  type PluginState,
+} from "./plugin-core.ts";
+import { makeTools } from "./tools/memory.ts";
+
+/**
+ * OpenCode 2 adapter (D60). The v2 host structurally decodes the plugin's
+ * default export as `{ id, setup }` — `Plugin.define` is an identity
+ * wrapper, so a plain object with no runtime import of `@opencode/plugin`
+ * loads identically. Importing the SDK at runtime would repeat the D58
+ * failure (devDependency, unresolvable from a global install, silent
+ * skip); the context is duck-typed here from the 2.0.x surface instead.
+ *
+ * v1/v2 hook mapping used below:
+ *   tool map                          → ctx.tool.transform (JSON Schema in,
+ *                                       { content } out)
+ *   chat.message (keyword capture)    → ctx.session.hook("prompt") — fires
+ *                                       once per submitted prompt
+ *   experimental.chat.system.transform → ctx.session.hook("context") — runs
+ *                                       before each model request; the
+ *                                       system array is mutable
+ *
+ * Tool registration must opt out of code mode (`options.codemode: false`,
+ * verified on 2.0.1): by default the host exposes plugin tools only
+ * through an `execute` meta-tool that runs model-written JS, and a model
+ * that calls the tool by name instead gets "Unknown tool" — flaky,
+ * model-dependent behavior. With the opt-out the five tools are plain
+ * function calls, same as on v1 and MCP.
+ */
+
+interface V2ToolInfo {
+  name: string;
+  description: string;
+  input: unknown;
+  options?: { codemode?: boolean };
+  execute: (input: Record<string, unknown>) => Promise<{ content: string }>;
+}
+
+interface V2Registration {
+  dispose?: () => Promise<void>;
+}
+
+export interface V2PluginContext {
+  app?: { version?: string };
+  location?: { directory?: string; project?: { directory?: string } };
+  tool: {
+    transform: (cb: (editor: { add: (tool: V2ToolInfo) => void }) => void) => Promise<unknown>;
+  };
+  session: {
+    hook: (
+      name: "prompt" | "context",
+      cb: (event: never) => void | Promise<void>,
+    ) => Promise<V2Registration>;
+  };
+}
+
+interface V2PromptEvent {
+  sessionID: string;
+  prompt?: { text?: string };
+}
+
+interface V2ContextEvent {
+  sessionID: string;
+  system: unknown[];
+}
+
+/** Register the five memory tools on a v2 host. */
+async function registerTools(ctx: V2PluginContext, state: PluginState): Promise<void> {
+  const tools = makeTools(() => state.scope, state.cfg);
+  await ctx.tool.transform((editor) => {
+    for (const [name, t] of Object.entries(tools)) {
+      editor.add({
+        name,
+        description: t.description,
+        input: z.toJSONSchema(z.object(t.args)),
+        options: { codemode: false },
+        execute: async (input) => {
+          const r = await t.execute(input as never, undefined as never);
+          const content =
+            typeof r === "string" ? r : ((r as { output?: string }).output ?? JSON.stringify(r));
+          return { content };
+        },
+      });
+    }
+  });
+}
+
+export const v2Plugin = {
+  id: PLUGIN_ID,
+  async setup(ctx: V2PluginContext) {
+    const root = ctx.location?.directory ?? ctx.location?.project?.directory ?? process.cwd();
+    const state = bootstrapPlugin(root);
+    const registrations: V2Registration[] = [];
+
+    await registerTools(ctx, state);
+
+    registrations.push(
+      await ctx.session.hook("prompt", (ev: V2PromptEvent) => {
+        captureFromText(ev.prompt?.text ?? "", state);
+      }),
+    );
+    registrations.push(
+      await ctx.session.hook("context", (ev: V2ContextEvent) => {
+        injectOnce(ev.sessionID ?? "", state, (block) => {
+          ev.system.push({ type: "text", text: block });
+        });
+      }),
+    );
+
+    return () => {
+      for (const r of registrations) void r.dispose?.();
+    };
+  },
+};

package/src/plugin-core.ts

@@ -0,0 +1,152 @@
+import { loadConfig, type MyOMemoryConfig } from "./config.ts";
+import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE, type Scope } from "./scope.ts";
+import { db } from "./store/db.ts";
+import { syncScope, upsertFromFile } from "./store/sync.ts";
+import { scopeHasFiles } from "./store/migrate.ts";
+import {
+  writeMemoryFile,
+  readMemoryFile,
+  ulid,
+  msToRfc3339,
+  type Frontmatter,
+} from "./store/markdown.ts";
+import { buildContextBlock } from "./retrieve/inject.ts";
+import { detectKeywords } from "./capture/keywords.ts";
+import { findDuplicates } from "./store/lifecycle.ts";
+import { redact } from "./redact.ts";
+
+/**
+ * Host-agnostic plugin core (D60). Both opencode host generations adapt to
+ * this module: the v1 plugin (src/index.ts `server`) and the v2 plugin
+ * (src/opencode-v2.ts `setup`). Host-specific glue — tool registration and
+ * hook shapes — stays in the adapters; everything memory-shaped lives here.
+ */
+export const PLUGIN_ID = "open-memex";
+
+export interface PluginState {
+  cfg: MyOMemoryConfig;
+  scope: Scope;
+  /** Sessions that already received the one-time context injection. */
+  injectedSessions: Set<string>;
+}
+
+/**
+ * Resolve the project scope for a host working directory and bring the
+ * index up to date. Never throws: a broken store must not keep the host
+ * from starting — failures land in the host's log instead.
+ */
+export function bootstrapPlugin(root: string): PluginState {
+  const cfg = loadConfig();
+  const scope = resolveProjectScope(root);
+  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(root);
+    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);
+  }
+  return { cfg, scope, injectedSessions: new Set<string>() };
+}
+
+/**
+ * Keyword capture (§ capture): scan one user message for "remember …"
+ * triggers and save each hit. Shared by the v1 `chat.message` hook and
+ * the v2 session `prompt` hook — both hand us the message text.
+ */
+export function captureFromText(text: string, state: PluginState): void {
+  const { cfg, scope } = state;
+  if (!cfg.keywordCaptureEnabled || !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: Frontmatter = {
+      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);
+    }
+  }
+}
+
+/**
+ * First-turn context injection: exactly once per session. The host adapter
+ * supplies `push` (v1: output.system.push; v2: the session context hook's
+ * system array). Returns true when a block was pushed.
+ */
+export function injectOnce(
+  sessionID: string,
+  state: PluginState,
+  push: (block: string) => void,
+): boolean {
+  const { cfg, scope } = state;
+  if (!cfg.injectOnFirstTurn) return false;
+  if (state.injectedSessions.has(sessionID)) return false;
+  state.injectedSessions.add(sessionID);
+  try {
+    const block = buildContextBlock(scope, cfg);
+    if (block) {
+      push(block);
+      return true;
+    }
+  } catch (err) {
+    console.error("[open-memex] context injection failed:", err);
+  }
+  return false;
+}