opencode-deja 0.1.0 → 0.1.2

package/README.md

@@ -20,6 +20,12 @@ embeddings, nothing leaves the machine.
 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).
 
+`deja install --auto` wires opencode too, and is the shorter path if you have
+the CLI: it adds deja's MCP server and writes a plugin of its own. Having both
+is fine. This package reads what the installer left — the MCP entry in
+`opencode.json`, the plugin file in `plugins/deja.js` — and contributes only
+what is missing, so nothing is registered or recalled twice.
+
 ## What you get
 
 Six tools the model can call:
@@ -51,8 +57,9 @@ And recall nobody has to ask for:
 
 - `autoRecall` (default `true`) — the three hooks above. Turn off to keep only
   the tools.
-- `tools` (default `true`) — the six tools. Turn off if you already reach deja
-  through its MCP server and do not want them twice.
+- `tools` (default `true`) — the six tools. They are skipped on their own when
+  `deja install` already wired the MCP server; set this to `false` to drop them
+  when you reach deja some other way.
 - `bin` — path to a specific deja binary.
 
 ## Which binary

package/index.js

@@ -11,9 +11,17 @@ import { execFile } from "node:child_process"
 import { promisify } from "node:util"
 import { homedir } from "node:os"
 import { join } from "node:path"
-import { accessSync, constants } from "node:fs"
+import { accessSync, constants, existsSync, readFileSync } from "node:fs"
 
-import { clampLimit, contextText, lastUserText } from "./lib.js"
+import {
+  clampLimit,
+  cliPluginPath,
+  configPaths,
+  contextText,
+  contributions,
+  lastUserText,
+  mcpWired,
+} from "./lib.js"
 
 const require = createRequire(import.meta.url)
 const run_ = promisify(execFile)
@@ -99,6 +107,27 @@ const MISSING =
   "deja is not installed on this machine, so there is no history to search. " +
   "Install it with: curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh"
 
+// installerWiring reads what `deja install` left on disk for opencode: the MCP
+// server in the config, and the plugin file `--auto` writes. Both reads are
+// wrapped — a config we cannot read means "not wired", so the worst case is
+// this package doing the work twice rather than not at all.
+function installerWiring() {
+  const wiring = { mcp: false, recall: false }
+  try {
+    wiring.recall = existsSync(cliPluginPath(process.env, homedir()))
+  } catch {}
+  try {
+    for (const path of configPaths(process.env, homedir())) {
+      if (!existsSync(path)) continue
+      if (mcpWired(readFileSync(path, "utf8"))) {
+        wiring.mcp = true
+        break
+      }
+    }
+  } catch {}
+  return wiring
+}
+
 export const DejaPlugin = async ({ client, directory }, options = {}) => {
   const config = options || {}
   const bin = resolveDeja(typeof config.bin === "string" ? config.bin : "")
@@ -117,7 +146,15 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
 
   const hooks = {}
 
-  if (config.tools !== false && tool) {
+  // What `deja install` already wired for opencode is not repeated here. It
+  // writes an MCP server (the same six answers, under their own names) and,
+  // with --auto, a plugin file of its own that opencode loads beside this
+  // package — verified with `opencode debug config`, which resolves both into
+  // one plugin list. Whatever the installer wrote wins, because that is the
+  // 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({
@@ -187,7 +224,7 @@ export const DejaPlugin = async ({ client, directory }, options = {}) => {
     }
   }
 
-  if (config.autoRecall === false) return hooks
+  if (!adds.recall) return hooks
 
   // opencode has no session-start hook. The system prompt is assembled on
   // every request, so the session digest is fetched once and pushed there —

package/lib.js

@@ -1,3 +1,5 @@
+import { join } from "node:path"
+
 // The pure half of the plugin: everything that reads deja's output or
 // opencode's message shape, with no process and no host. Kept apart from
 // index.js because opencode loads every function a plugin module exports —
@@ -34,6 +36,88 @@ export function lastUserText(messages) {
   return { parts: [], prompt: "" }
 }
 
+// cliPluginPath is where `deja install opencode-auto` writes its own plugin.
+// opencode loads that file and this package side by side — both are entries in
+// the resolved `plugin` list — and both push recall onto the system prompt, so
+// whoever finds the other has to stand down. Mirrors opencodeConfigHome() in
+// the installer: XDG_CONFIG_HOME wins, else ~/.config.
+export function cliPluginPath(env, home) {
+  const base = (env && env.XDG_CONFIG_HOME) || join(home || "", ".config")
+  return join(base, "opencode", "plugins", "deja.js")
+}
+
+// configPaths are the two names opencode accepts for the global config, in the
+// order `deja install opencode` looks for them.
+export function configPaths(env, home) {
+  const base = (env && env.XDG_CONFIG_HOME) || join(home || "", ".config")
+  return [join(base, "opencode", "opencode.json"), join(base, "opencode", "opencode.jsonc")]
+}
+
+// mcpWired reports whether that config already runs deja as an MCP server,
+// which is what `deja install opencode` writes. The tools this package
+// registers do the same six things, so when the server is there they are a
+// second copy of it in the model's tool list.
+//
+// The file is JSONC — opencode ships it with comments — so comments come out
+// before the parse. A config this cannot read is treated as not wired: losing
+// the tools on a file we misread is worse than listing them twice.
+export function mcpWired(text) {
+  try {
+    const config = JSON.parse(stripJSONComments(String(text || "")))
+    return Boolean(config && config.mcp && config.mcp.deja)
+  } catch {
+    return false
+  }
+}
+
+// stripJSONComments removes // and /* */ outside strings. Small on purpose: it
+// only has to survive the file our own installer writes.
+export function stripJSONComments(text) {
+  let out = ""
+  let inString = false
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]
+    if (inString) {
+      out += c
+      if (c === "\\") {
+        out += text[++i] || ""
+      } else if (c === '"') {
+        inString = false
+      }
+      continue
+    }
+    if (c === '"') {
+      inString = true
+      out += c
+      continue
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++
+      out += "\n"
+      continue
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i += 2
+      while (i + 1 < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++
+      i++
+      continue
+    }
+    out += c
+  }
+  return out
+}
+
+// contributions decides what this package adds, given what `deja install`
+// already wired and what the user turned off in their config. It is the whole
+// rule in one place: fill the gaps, never repeat the installer.
+export function contributions(wiring, config = {}) {
+  const wired = wiring || {}
+  return {
+    tools: config.tools !== false && !wired.mcp,
+    recall: config.autoRecall !== false && !wired.recall,
+  }
+}
+
 // clampLimit keeps a model that asks for a hundred sessions from spending the
 // window on a tail nobody reads.
 export function clampLimit(value, fallback = 5) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-deja",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Brings the session history of nineteen other coding agents into opencode: recall, session digest and per-file history tools over a local index, plus automatic recall on every request.",
   "type": "module",
   "main": "index.js",