opencode-deja 0.21.7 → 0.22.1

package/README.md

@@ -3,13 +3,13 @@
 English | [中文](https://github.com/vshulcz/deja-vu/blob/main/extensions/opencode/docs/zh.md)
 
 opencode remembers its own sessions. This plugin answers the other question:
-what you did in the thirty-seven other coding agents on this machine — Claude Code,
+what you did in the forty other coding agents on this machine — Claude Code,
 Codex, Cursor, Gemini and Zed among them — including the months before you
 installed anything.
 
 It runs [deja](https://github.com/vshulcz/deja-vu), a local Go binary that
 indexes the transcripts those agents already wrote to disk. No LLM, no
-embeddings, no network path unless you ask for one.
+embeddings, no network path besides a daily release check, which DEJA_OFFLINE=1 turns off.
 
 ## Install
 
@@ -92,7 +92,7 @@ On 2.x:
 In order: `bin` from the options, `DEJA_BIN`, a `deja` on `PATH`, the usual
 install locations (`~/.local/bin`, `/usr/local/bin`, `/opt/homebrew/bin`), and
 only then the copy npm installed with this package. Your own `deja update` or
-`brew upgrade deja` wins over whatever version this package shipped with.
+`brew upgrade deja-vu` wins over whatever version this package shipped with.
 
 Without deja anywhere, the tools say so instead of reporting an empty history,
 and the hooks stay quiet.

package/index.js

@@ -1,7 +1,7 @@
 // opencode-deja — the sessions you already have, inside opencode.
 //
 // opencode remembers its own sessions. This plugin answers the other question:
-// what you did in Claude Code, Codex, Cursor, Gemini and thirty-four more agents on
+// what you did in Claude Code, Codex, Cursor, Gemini and thirty-seven more agents on
 // 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.
@@ -23,9 +23,9 @@ import {
   configPaths,
   contextText,
   contributions,
-  lastUserText,
   mcpWired,
   TOOL_SPECS,
+  userTurns,
   zodTools,
 } from "./lib.js"
 
@@ -172,6 +172,12 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   // 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()
+  // The per-prompt recall each user message was given, by message.
+  const recalled = new Map()
+  const remember = (key, extra) => {
+    recalled.set(key, extra)
+    if (recalled.size > 1000) recalled.delete(recalled.keys().next().value)
+  }
   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
@@ -206,7 +212,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
   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, and before changing code, config, a dependency or a schedule. Match on the most specific token available: an exact error string, function name, file path or flag.",
+        "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, and before the first edit in a task and before calling a change done or ready to merge. 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." },
@@ -348,22 +354,34 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
       // the recovery packet would count as delivered to a turn that never saw it.
       const owner = (output?.messages || []).find((m) => m?.info?.sessionID)?.info?.sessionID
       if (owner && compacting.has(owner)) return
-      const { parts, prompt, sessionID } = lastUserText(output?.messages)
-      // 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 || ""
-      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
+      const users = userTurns(output?.messages)
+      const last = users[users.length - 1]
+      if (!last) return
+      // Asked once per message. opencode builds every model call afresh from
+      // its store, so text added to a message here lasts one call: once the
+      // agent ran a tool the recall was gone, and deja, having shown it, would
+      // not send it again (#4786).
+      if (!recalled.has(last.key)) {
+        // 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).
+        // 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 || last.sessionID || ""
+        if (key) live.add(key)
+        const raw = await ask(["hook-prompt"], JSON.stringify({ prompt: last.prompt, session_id: key, parent_session_id: await parentOf(key), cwd }))
+        remember(last.key, last.prompt && raw ? JSON.parse(raw)?.hookSpecificOutput?.additionalContext || "" : "")
+      }
+      // Every message gets back what it was given, in every call, the way
+      // Claude Code keeps a prompt hook's text in its transcript.
+      for (const u of users) {
+        const extra = recalled.get(u.key)
+        const tail = u.parts[u.parts.length - 1]
+        if (extra && tail && !tail.text.endsWith(extra)) tail.text += "\n\n" + extra
+      }
     } catch {
       // memory is optional: never break the session over it
     }

package/lib.js

@@ -22,19 +22,21 @@ export function contextText(raw) {
   }
 }
 
-// lastUserText is what the person typed on this turn, which is what the
-// per-prompt recall is ranked against. Parts a plugin appended earlier are
-// part of the same message, so the text is joined and matched whole.
-export function lastUserText(messages) {
+// userTurns is every user message in a request, oldest first, each with a key
+// that stays the same from one request to the next: opencode's message id, or
+// where a shape carries none, the message's place among the user messages and
+// its text.
+export function userTurns(messages) {
   const list = Array.isArray(messages) ? messages : []
-  for (let i = list.length - 1; i >= 0; i--) {
-    if (list[i]?.info?.role !== "user") continue
-    const sessionID = list[i].info?.sessionID || ""
-    const parts = (list[i].parts || []).filter((p) => p?.type === "text" && p.text)
-    if (!parts.length) return { parts: [], prompt: "", sessionID }
-    return { parts, prompt: parts.map((p) => p.text).join("\n").trim(), sessionID }
+  const out = []
+  for (const m of list) {
+    if (m?.info?.role !== "user") continue
+    const sessionID = m.info?.sessionID || ""
+    const parts = (m.parts || []).filter((p) => p?.type === "text" && p.text)
+    const prompt = parts.map((p) => p.text).join("\n").trim()
+    out.push({ key: m.info?.id || sessionID + "#" + out.length + "#" + prompt, parts, prompt, sessionID })
   }
-  return { parts: [], prompt: "", sessionID: "" }
+  return out
 }
 
 // cliPluginPath is where `deja install opencode-auto` writes its own plugin.
@@ -195,13 +197,13 @@ export function turnEnded(event) {
   return ""
 }
 
-// v1Messages shows 2.x's request messages in the 1.x shape lastUserText reads.
+// v1Messages shows 2.x's request messages in the 1.x shape userTurns 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 || "" },
+    info: { id: m?.id, role: m?.role, sessionID: sessionID || "" },
     parts: Array.isArray(m?.content) ? m.content : [],
   }))
 }
@@ -220,6 +222,24 @@ export function resultText(result) {
   return typeof r.output === "string" ? r.output : ""
 }
 
+// v1Client is the slice of the 1.x client the plugin reads, over 2.x's ctx. A
+// 2.x server plugin has no channel to the TUI, so the toasts go nowhere. The
+// session lookup is what names a sub-agent's parent: without it the
+// sub-agent's digest and recall led with the parent that spawned it (#4548).
+// 1.x answers through client.session.get, 2.x through ctx.session.get, whose
+// SessionInfo carries parentID.
+export function v1Client(ctx) {
+  return {
+    tui: { showToast: async () => {} },
+    session: {
+      get: async ({ path } = {}) => {
+        if (!path?.id || typeof ctx?.session?.get !== "function") return { data: {} }
+        return { data: (await ctx.session.get({ sessionID: path.id })) || {} }
+      },
+    },
+  }
+}
+
 // 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) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-deja",
-  "version": "0.21.7",
-  "description": "deja-vu memory for opencode: the session history of thirty-seven other coding agents, searchable and recalled on every request — a local index, no LLM.",
+  "version": "0.22.1",
+  "description": "deja-vu memory for opencode: the session history of forty other coding agents, searchable and recalled on every request — a local index, no LLM.",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": ">=1.0.0",
-    "@vshulcz/deja-vu": "^0.21.7"
+    "@vshulcz/deja-vu": "^0.22.1"
   },
   "scripts": {
     "test": "node --test test/*.test.js"

package/server.js

@@ -15,14 +15,11 @@
 // 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 () => {} } }
+import { jsonSchema, resultText, TOOL_SPECS, turnEnded, v1Client, v1Messages, v1ToolName } from "./lib.js"
 
 async function setup(ctx) {
   const directory = ctx.location?.directory || process.cwd()
-  const hooks = await DejaPlugin({ client: noToast, directory }, ctx.options || {})
+  const hooks = await DejaPlugin({ client: v1Client(ctx), directory }, ctx.options || {})
 
   const specs = hooks[TOOL_SPECS]
   if (specs) {
@@ -66,8 +63,10 @@ async function setup(ctx) {
 
   const compacting = hooks["experimental.session.compacting"]
   if (compacting) {
-    await ctx.session.hook("compaction", async () => {
-      await compacting()
+    // The 1.x hook reads the session from its input; called with none, 2.x
+    // sent hook-precompact an empty id and nothing was read or forgotten.
+    await ctx.session.hook("compaction", async (event) => {
+      await compacting({ sessionID: event?.sessionID || "" })
     })
   }