opencode-deja 0.21.4 → 0.21.5

package/README.md

@@ -20,6 +20,14 @@ embeddings, no network path unless you ask for one.
 }
 ```
 
+That is opencode 1.x. On 2.x the list is `plugins`:
+
+```json
+{
+  "plugins": ["opencode-deja"]
+}
+```
+
 opencode installs the package on start. The deja binary comes with it, but a
 deja you installed yourself always wins — see [Which binary](#which-binary).
 
@@ -45,7 +53,8 @@ Six tools the model can call:
 And recall nobody has to ask for:
 
 - the project's recent sessions are pushed onto the system prompt once per
-  session, with a one-time toast so you know memory arrived;
+  session, with a one-time toast so you know memory arrived (1.x only: a
+  2.x server plugin has no channel to the TUI);
 - each prompt gets a relevance pass of its own — silent when nothing matches;
 - a spawned agent gets recall in its own instructions, since it never sees the
   system prompt or a user prompt;
@@ -63,6 +72,14 @@ And recall nobody has to ask for:
 }
 ```
 
+On 2.x:
+
+```json
+{
+  "plugins": [{ "package": "opencode-deja", "options": { "autoRecall": false, "tools": true } }]
+}
+```
+
 - `autoRecall` (default `true`) — the hooks above. Turn off to keep only
   the tools.
 - `tools` (default `true`) — the six tools. They are skipped on their own when

package/index.js

@@ -5,6 +5,9 @@
 // this machine, including months before deja existed. The index is deja's; this
 // file is the seam: six tools the model can call, plus recall that arrives
 // without being asked for.
+//
+// This is the 1.x plugin. opencode 2.x loads server.js, which runs this same
+// function and wires its hooks to 2.x's seams.
 
 import { createRequire } from "node:module"
 import { execFile } from "node:child_process"
@@ -22,6 +25,8 @@ import {
   contributions,
   lastUserText,
   mcpWired,
+  TOOL_SPECS,
+  zodTools,
 } from "./lib.js"
 
 const require = createRequire(import.meta.url)
@@ -99,6 +104,9 @@ async function run(bin, args, input, cwd, timeout = 20000) {
       maxBuffer: 8 * 1024 * 1024,
     })
     if (input !== undefined) {
+      // deja can exit before it reads stdin; unhandled, the EPIPE that
+      // follows would take opencode down. The generated plugin does the same.
+      child.child.stdin.on("error", () => {})
       child.child.stdin.end(input)
     }
     const { stdout } = await child
@@ -158,6 +166,27 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   // again. Counted, so a store that really is empty is still only asked a few
   // times.
   const empties = new Map()
+  // Every session the per-prompt hook stamped live. opencode never says a
+  // session ended, so without ending them here the stamp sat out its whole
+  // window and the next session's MCP recall left a finished one out (#4546).
+  const live = new Set()
+  const endSession = (id) => ask(["hook-session-end"], JSON.stringify({ session_id: id }), 5000)
+  // The session that spawned each one, asked of opencode once. A task
+  // sub-agent's digest and recall led with its parent, which is live and
+  // asking through it (#4548).
+  const parents = new Map()
+  const parentOf = async (id) => {
+    if (!id) return ""
+    if (!parents.has(id)) {
+      let parent = ""
+      try {
+        const res = await client?.session?.get?.({ path: { id } })
+        parent = res?.data?.parentID || ""
+      } catch {}
+      parents.set(id, parent)
+    }
+    return parents.get(id)
+  }
 
   const hooks = {}
 
@@ -169,74 +198,80 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   // copy `deja install` keeps current; this package fills the gaps.
   const adds = contributions(installerWiring(), config)
 
-  if (adds.tools && tool) {
-    const schema = tool.schema
-    hooks.tool = {
-      deja_recall: tool({
-        description:
-          "Search this machine's own past AI coding sessions — every agent used on it, including months before deja was installed. Use before debugging an error or re-implementing anything that may already exist. Match on the most specific token available: an exact error string, function name, file path or flag.",
-        args: {
-          query: schema.string().describe("Specific tokens to match. Several words are ANDed."),
-          limit: schema.number().optional().describe("How many sessions to return. Default 5."),
-        },
-        async execute(args) {
-          const limit = String(clampLimit(args.limit))
-          return answer(await ask(argv("search", ["--json", "--limit", limit], args.query)))
-        },
-      }),
-      deja_session: tool({
-        description:
-          "A full digest of the single best-matching past session — what was tried, what was decided, what it cost. Use after deja_recall when the reasoning behind an earlier decision matters, not just that it happened.",
-        args: {
-          query: schema.string().describe("A query, or a session id prefix returned by deja_recall."),
-        },
-        async execute(args) {
-          return answer(await ask(argv("ctx", [], args.query)))
-        },
-      }),
-      deja_blame: tool({
-        description:
-          "The past sessions that discussed a file, so you know why it is shaped the way it is before editing, refactoring or deleting it. Session history, not git authorship.",
-        args: {
-          path: schema.string().describe("Path to the file, absolute or relative to the project."),
-        },
-        async execute(args) {
-          return answer(await ask(argv("blame", ["--json"], args.path)))
-        },
-      }),
-      deja_fix: tool({
-        description:
-          "What this machine ran after that same error before, in the sessions where the error did not come back. Paste the failing output verbatim rather than a paraphrase — the match is on the error's own words.",
-        args: {
-          error: schema.string().describe("The failing output, copied as it was printed."),
-        },
-        async execute(args) {
-          return answer(await ask(argv("fix", [], args.error)))
-        },
-      }),
-      deja_how: tool({
-        description:
-          "The real invocation this machine uses for a build, test, deploy or script, with the flags it actually ran, ordered by how many sessions ran it. A guessed command is plausible and fails on this setup.",
-        args: {
-          what: schema.string().describe("The thing to run: a tool, a task, a script name."),
-        },
-        async execute(args) {
-          return answer(await ask(argv("how", [], args.what)))
-        },
-      }),
-      deja_remember: tool({
-        description:
-          "Store one durable decision once it is settled, as a single self-contained fact that will make sense months later. Not transcripts, not a summary of the conversation, and not anything already obvious from the code.",
-        args: {
-          text: schema.string().describe("The decision, in one or two sentences, with the reason it was taken."),
-        },
-        async execute(args) {
-          const written = await ask(argv("remember", [], args.text))
-          if (!installed) return MISSING
-          return written || "deja did not record that."
-        },
-      }),
-    }
+  // The six tools, described once. opencode 1.x takes them through its zod
+  // helper and 2.x as JSON Schema (server.js), so the arguments are plain
+  // data and each side builds its own.
+  const specs = {
+    deja_recall: {
+      description:
+        "Search this machine's own past AI coding sessions — every agent used on it, including months before deja was installed. Use before debugging an error or re-implementing anything that may already exist. Match on the most specific token available: an exact error string, function name, file path or flag.",
+      args: {
+        query: { type: "string", description: "Specific tokens to match. Several words are ANDed." },
+        limit: { type: "number", optional: true, description: "How many sessions to return. Default 5." },
+      },
+      async execute(args) {
+        const limit = String(clampLimit(args.limit))
+        return answer(await ask(argv("search", ["--json", "--limit", limit], args.query)))
+      },
+    },
+    deja_session: {
+      description:
+        "A full digest of the single best-matching past session — what was tried, what was decided, what it cost. Use after deja_recall when the reasoning behind an earlier decision matters, not just that it happened.",
+      args: {
+        query: { type: "string", description: "A query, or a session id prefix returned by deja_recall." },
+      },
+      async execute(args) {
+        return answer(await ask(argv("ctx", [], args.query)))
+      },
+    },
+    deja_blame: {
+      description:
+        "The past sessions that discussed a file, so you know why it is shaped the way it is before editing, refactoring or deleting it. Session history, not git authorship.",
+      args: {
+        path: { type: "string", description: "Path to the file, absolute or relative to the project." },
+      },
+      async execute(args) {
+        return answer(await ask(argv("blame", ["--json"], args.path)))
+      },
+    },
+    deja_fix: {
+      description:
+        "What this machine ran after that same error before, in the sessions where the error did not come back. Paste the failing output verbatim rather than a paraphrase — the match is on the error's own words.",
+      args: {
+        error: { type: "string", description: "The failing output, copied as it was printed." },
+      },
+      async execute(args) {
+        return answer(await ask(argv("fix", [], args.error)))
+      },
+    },
+    deja_how: {
+      description:
+        "The real invocation this machine uses for a build, test, deploy or script, with the flags it actually ran, ordered by how many sessions ran it. A guessed command is plausible and fails on this setup.",
+      args: {
+        what: { type: "string", description: "The thing to run: a tool, a task, a script name." },
+      },
+      async execute(args) {
+        return answer(await ask(argv("how", [], args.what)))
+      },
+    },
+    deja_remember: {
+      description:
+        "Store one durable decision once it is settled, as a single self-contained fact that will make sense months later. Not transcripts, not a summary of the conversation, and not anything already obvious from the code.",
+      args: {
+        text: { type: "string", description: "The decision, in one or two sentences, with the reason it was taken." },
+      },
+      async execute(args) {
+        const written = await ask(argv("remember", [], args.text))
+        if (!installed) return MISSING
+        return written || "deja did not record that."
+      },
+    },
+  }
+
+  if (adds.tools) {
+    // Under a symbol, so 1.x, which reads its hooks by name, never sees it.
+    hooks[TOOL_SPECS] = specs
+    if (tool) hooks.tool = zodTools(tool, specs)
   }
 
   if (!adds.recall) return hooks
@@ -248,7 +283,12 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
     try {
       const key = input?.sessionID || "default"
       if (!digests.has(key)) {
-        const { context, receipt } = contextText(await ask(["hook-context"], undefined, 30000))
+        // The session id, as the plugin `deja install opencode-auto` writes
+        // sends it: without it deja hands the session its own work back and
+        // never reads the digest cached for it (#4273). The parent rides
+        // along so the digest leaves it out too.
+        const payload = { session_id: input?.sessionID || "", parent_session_id: await parentOf(input?.sessionID), cwd }
+        const { context, receipt } = contextText(await ask(["hook-context"], JSON.stringify(payload), 30000))
         digests.set(key, context)
         // The receipt is the only sign the user gets that memory arrived. Once
         // per session: repeating it every turn is wallpaper. The hook's own
@@ -296,13 +336,18 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   hooks["experimental.chat.messages.transform"] = async (input, output) => {
     try {
       const { parts, prompt, sessionID } = lastUserText(output?.messages)
-      if (!prompt) return
+      // A turn with no text, an image alone, still goes to hook-prompt: that
+      // call is what stamps the session live again after session.idle ended
+      // it, and without it the turn's MCP recall could return the session to
+      // itself (#4573). sessionID is empty when there is no user message.
+      if (!prompt && !sessionID) return
       // The session id lets recall skip what it already showed this session.
       // Without it every message re-injects the same block — measured on a real
       // store, half of all injections were a word-for-word repeat.
       const key = input?.sessionID || sessionID || ""
-      const raw = await ask(["hook-prompt"], JSON.stringify({ prompt, session_id: key, cwd }))
-      if (!raw) return
+      if (key) live.add(key)
+      const raw = await ask(["hook-prompt"], JSON.stringify({ prompt, session_id: key, parent_session_id: await parentOf(key), cwd }))
+      if (!prompt || !raw) return
       const extra = JSON.parse(raw)?.hookSpecificOutput?.additionalContext
       if (!extra) return
       parts[parts.length - 1].text += "\n\n" + extra
@@ -399,5 +444,27 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
     }
   }
 
+  // A turn is over when opencode publishes session.idle, and the next prompt
+  // stamps the session again before the model can ask anything, so the session
+  // is history to everyone else in between.
+  hooks.event = async ({ event }) => {
+    try {
+      const id = event?.type === "session.idle" ? event.properties?.sessionID : ""
+      if (!id) return
+      await endSession(id)
+      // Ended, so dispose does not spawn deja for it again on the way out.
+      live.delete(id)
+    } catch {
+      // memory is optional: never break the session over it
+    }
+  }
+
+  // `opencode run` exits without waiting for the event above, and it does wait
+  // for dispose: a one-shot run ends what it started here.
+  hooks.dispose = async () => {
+    for (const id of live) await endSession(id)
+    live.clear()
+  }
+
   return hooks
 }

package/lib.js

@@ -65,10 +65,13 @@ export function configPaths(env, home) {
 export function mcpWired(text) {
   try {
     const config = JSON.parse(stripJSONComments(String(text || "")))
-    const entry = config && config.mcp && config.mcp.deja
+    // 1.x keeps servers directly under `mcp`, 2.x under `mcp.servers`.
+    const mcp = (config && config.mcp) || {}
+    const entry = mcp.deja || (mcp.servers && mcp.servers.deja)
     // A server kept in the file but switched off offers nothing, so the
-    // tools here are not a second copy of it.
-    return Boolean(entry) && entry.enabled !== false
+    // tools here are not a second copy of it. 1.x switches it off with
+    // `enabled: false`, 2.x with `disabled: true`.
+    return Boolean(entry) && entry.enabled !== false && entry.disabled !== true
   } catch {
     return false
   }
@@ -145,3 +148,82 @@ export function clampLimit(value, fallback = 5) {
   if (!Number.isFinite(asked)) return fallback
   return Math.min(20, Math.max(1, Math.trunc(asked)))
 }
+
+// TOOL_SPECS is where the plugin leaves its tool list on the hooks it returns,
+// for the 2.x entry to register. A symbol, so 1.x never reads it as a hook.
+export const TOOL_SPECS = Symbol.for("opencode-deja.tools")
+
+// zodTools builds the 1.x tool table from the specs, through opencode's own
+// helper and the zod it re-exports.
+export function zodTools(tool, specs) {
+  const schema = tool.schema
+  const out = {}
+  for (const [name, spec] of Object.entries(specs)) {
+    const args = {}
+    for (const [key, arg] of Object.entries(spec.args)) {
+      let field = arg.type === "number" ? schema.number() : schema.string()
+      if (arg.optional) field = field.optional()
+      args[key] = field.describe(arg.description)
+    }
+    out[name] = tool({ description: spec.description, args, execute: spec.execute })
+  }
+  return out
+}
+
+// jsonSchema is a spec's arguments in the form 2.x takes a tool's input.
+export function jsonSchema(args) {
+  const properties = {}
+  const required = []
+  for (const [key, arg] of Object.entries(args)) {
+    properties[key] = { type: arg.type, description: arg.description }
+    if (!arg.optional) required.push(key)
+  }
+  return { type: "object", properties, required }
+}
+
+// turnEnded is the session whose turn a 2.x event says is over, or "". 2.0.22
+// ends a turn with session.execution.succeeded, .failed or .interrupted and
+// never publishes 1.x's session.idle, which its schema still carries (#4571).
+export function turnEnded(event) {
+  switch (event?.type) {
+    case "session.execution.succeeded":
+    case "session.execution.failed":
+    case "session.execution.interrupted":
+    case "session.idle":
+      return event.data?.sessionID || ""
+  }
+  return ""
+}
+
+// v1Messages shows 2.x's request messages in the 1.x shape lastUserText reads.
+// The parts are 2.x's own content objects, so text appended to one lands in
+// the request.
+export function v1Messages(messages, sessionID) {
+  const list = Array.isArray(messages) ? messages : []
+  return list.map((m) => ({
+    info: { role: m?.role, sessionID: sessionID || "" },
+    parts: Array.isArray(m?.content) ? m.content : [],
+  }))
+}
+
+// resultText is the text a finished 2.x tool call returned: `content` is a
+// string or a list of blocks, and a tool may leave only `output`.
+export function resultText(result) {
+  const r = result || {}
+  if (typeof r.content === "string") return r.content
+  if (Array.isArray(r.content)) {
+    return r.content
+      .filter((c) => c?.type === "text")
+      .map((c) => c.text)
+      .join("\n")
+  }
+  return typeof r.output === "string" ? r.output : ""
+}
+
+// v1ToolName is the 1.x name for a 2.x tool, where the two differ in a way the
+// hooks look at: the spawn tool and the shell.
+export function v1ToolName(name) {
+  if (name === "subagent") return "task"
+  if (name === "shell") return "bash"
+  return name
+}

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "opencode-deja",
-  "version": "0.21.4",
+  "version": "0.21.5",
   "description": "deja-vu memory for opencode: the session history of thirty-four other coding agents, searchable and recalled on every request — a local index, no LLM.",
   "type": "module",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
+    "./server": "./server.js",
     "./package.json": "./package.json"
   },
   "files": [
     "index.js",
+    "server.js",
     "lib.js",
     "README.md",
     "LICENSE"
@@ -50,7 +52,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": ">=1.0.0",
-    "@vshulcz/deja-vu": "^0.21.4"
+    "@vshulcz/deja-vu": "^0.21.5"
   },
   "scripts": {
     "test": "node --test test/*.test.js"

package/server.js

@@ -0,0 +1,122 @@
+// The entry opencode loads as `opencode-deja/server`.
+//
+// opencode 2.x imports only a default export and requires `{ id, setup }` (or
+// `effect`) on it; the named export in index.js fails its check with "Plugin
+// must export a default definition with an id and an effect or setup
+// function" (#4151). 1.x from 1.3.4 resolves the same `./server` subpath and
+// wants `{ server }` on the default export, so this object carries both. 1.x
+// before 1.3.4 never looks here and keeps loading index.js, which calls every
+// export as a plugin and would choke on an object.
+//
+// setup runs the 1.x plugin and wires its hooks to 2.x's seams, so both majors
+// run the same code: the session digest and the per-prompt recall go in on
+// `session` "context", the pre-compaction index on "compaction", the spawn and
+// after-tool lines on `tool` "execute.before" and "execute.after", the end of
+// a turn on `event` "subscribe" and dispose on the cleanup setup returns.
+
+import { DejaPlugin } from "./index.js"
+import { jsonSchema, resultText, TOOL_SPECS, turnEnded, v1Messages, v1ToolName } from "./lib.js"
+
+// A 2.x server plugin has no channel to the TUI, so the toasts go nowhere.
+const noToast = { tui: { showToast: async () => {} } }
+
+async function setup(ctx) {
+  const directory = ctx.location?.directory || process.cwd()
+  const hooks = await DejaPlugin({ client: noToast, directory }, ctx.options || {})
+
+  const specs = hooks[TOOL_SPECS]
+  if (specs) {
+    await ctx.tool.transform((tools) => {
+      for (const [name, spec] of Object.entries(specs)) {
+        tools.add({
+          name,
+          // Only a codemode: false tool is offered to the model directly; the
+          // rest sit behind the code-mode `execute` tool, as built-ins do not.
+          options: { codemode: false },
+          description: spec.description,
+          input: jsonSchema(spec.args),
+          execute: async (input) => ({ content: await spec.execute(input || {}) }),
+        })
+      }
+    })
+  }
+
+  const system = hooks["experimental.chat.system.transform"]
+  const prompt = hooks["experimental.chat.messages.transform"]
+  if (system || prompt) {
+    await ctx.session.hook("context", async (event) => {
+      try {
+        if (system) {
+          const out = { system: event.system.map((p) => p.text) }
+          await system({ sessionID: event.sessionID }, out)
+          if (event.system.length) {
+            if (out.system[0] !== event.system[0].text) event.system[0] = { ...event.system[0], text: out.system[0] }
+          } else if (out.system.length) {
+            event.system.push({ type: "text", text: out.system[0] })
+          }
+        }
+        if (prompt) {
+          await prompt({ sessionID: event.sessionID }, { messages: v1Messages(event.messages, event.sessionID) })
+        }
+      } catch {
+        // memory is optional: never break the session over it
+      }
+    })
+  }
+
+  const compacting = hooks["experimental.session.compacting"]
+  if (compacting) {
+    await ctx.session.hook("compaction", async () => {
+      await compacting()
+    })
+  }
+
+  const before = hooks["tool.execute.before"]
+  if (before) {
+    await ctx.tool.hook("execute.before", async (event) => {
+      const args = { ...(event.input || {}) }
+      await before({ tool: v1ToolName(event.tool), sessionID: event.sessionID }, { args })
+      if (args.prompt !== event.input?.prompt) event.input = args
+    })
+  }
+
+  const after = hooks["tool.execute.after"]
+  if (after) {
+    await ctx.tool.hook("execute.after", async (event) => {
+      if (event.status !== "completed") return
+      const text = resultText(event.result)
+      const output = { output: text }
+      await after({ tool: v1ToolName(event.tool), sessionID: event.sessionID, args: event.input || {} }, output)
+      if (output.output === text || !output.output.startsWith(text)) return
+      const extra = output.output.slice(text.length).trim()
+      const result = event.result || {}
+      const content = Array.isArray(result.content)
+        ? result.content
+        : typeof result.content === "string"
+          ? [{ type: "text", text: result.content }]
+          : text
+            ? [{ type: "text", text }]
+            : []
+      event.result = { ...result, content: [...content, { type: "text", text: extra }] }
+    })
+  }
+
+  // 2.x has no event hook or dispose in a plugin's table: the events come from
+  // ctx.event and the exit is the cleanup setup returns, which `opencode run`
+  // awaits. Without them a session stamped live was never ended (#4571).
+  const stop = new AbortController()
+  if (hooks.event && typeof ctx.event?.subscribe === "function") {
+    ;(async () => {
+      for await (const event of ctx.event.subscribe({ signal: stop.signal })) {
+        const id = turnEnded(event)
+        if (id) await hooks.event({ event: { type: "session.idle", properties: { sessionID: id } } })
+      }
+    })().catch(() => {})
+  }
+  return async () => {
+    stop.abort()
+    await hooks.dispose?.()
+  }
+}
+
+export default { id: "opencode-deja", setup, server: DejaPlugin }