@vshulcz/pi-deja 0.19.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladislav Shulcz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @vshulcz/pi-deja
+
+pi remembers its own sessions. This extension answers the other question: what
+was done in the twenty-two other coding agents on this machine — Claude Code,
+Codex, Cursor, Gemini, OpenClaw and Hermes among them — including the months
+before pi was installed.
+
+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, nothing leaves the machine.
+
+## Install
+
+```bash
+pi install npm:@vshulcz/pi-deja
+```
+
+The deja binary comes with the package; a deja you installed yourself
+(`brew install deja-vu`) always wins — see [Which binary](#which-binary).
+
+`deja install pi-auto` wires pi too, and is the shorter path if you have the
+CLI: it adds deja's MCP server and writes an extension of its own. When that
+extension is present this package stands down, so having both never injects
+twice.
+
+omp loads `pi.extensions` manifests and emits the same `before_agent_start`
+event, so `pi install`'s omp counterpart picks this package up as well.
+
+## What it does
+
+- **Session start**: a digest of what earlier sessions in this project decided
+  goes to the model before your first prompt; the receipt shows in the footer.
+- **Every prompt** (`before_agent_start`): the prompt is matched against the
+  index and, when a past session answers it, that session goes to the model
+  with the prompt. Silence is the common case.
+- **`/deja <query>`**: search the history by hand.
+
+## Which binary
+
+In order: `DEJA_BIN`, `deja` on `PATH`, the usual install locations, and last
+the copy bundled through `@vshulcz/deja-vu`.
+
+## Privacy
+
+deja reads session files where the agents wrote them and builds a local index
+under `~/.cache/deja` (or `DEJA_INDEX_DIR`). Keys and tokens are stripped as
+the index is built. Nothing is uploaded.
+
+Part of [deja-vu](https://github.com/vshulcz/deja-vu). MIT.

package/index.ts

@@ -0,0 +1,155 @@
+// deja-vu for pi: recall from the coding sessions already on this machine at
+// session start and on every prompt, and /deja to search them by hand.
+import { execFileSync } from "node:child_process";
+import { accessSync, constants, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { argv, contextText, installerExtensionPath, sessionKey } from "./lib.mjs";
+
+const require = createRequire(import.meta.url);
+
+const WINDOWS = process.platform === "win32";
+const PLATFORM = WINDOWS ? "windows" : process.platform;
+const ARCH = process.arch === "x64" ? "amd64" : process.arch;
+const EXE = WINDOWS ? "deja.exe" : "deja";
+
+// wellKnown lists the places a user's own install lands, for a pi started
+// from a launcher whose PATH never sourced a shell profile.
+function wellKnown(): string[] {
+  const home = homedir();
+  if (WINDOWS) {
+    const local = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    return [join(local, "deja", "bin", EXE), join(home, ".local", "bin", EXE)];
+  }
+  return [join(home, ".local", "bin", EXE), "/usr/local/bin/deja", "/opt/homebrew/bin/deja", "/usr/bin/deja"];
+}
+
+// resolveDeja: what the user pointed at, then the deja they installed and keep
+// current, and only last the copy npm brought with this package — pinning
+// them to our bundled copy would freeze their memory at whatever version this
+// package was released against.
+function resolveDeja(): string {
+  const candidates: string[] = [process.env.DEJA_BIN || "", EXE, ...wellKnown()];
+  try {
+    candidates.push(require.resolve(`@vshulcz/deja-vu-${PLATFORM}-${ARCH}/bin/${EXE}`));
+  } catch {}
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (candidate.includes("/") || candidate.includes("\\")) {
+      try {
+        accessSync(candidate, constants.X_OK);
+      } catch {
+        continue;
+      }
+    }
+    return candidate;
+  }
+  return EXE;
+}
+
+const DEJA = resolveDeja();
+
+// deja is asked for text, never for control flow: memory is optional
+// everywhere, and a throw here would end someone's turn.
+function run(args: string[], input: string, timeout = 10000): string {
+  try {
+    return execFileSync(DEJA, args, {
+      input,
+      encoding: "utf8",
+      timeout,
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export default function (pi: any) {
+  // `deja install pi-auto` writes an extension of its own; when it is there,
+  // it already does everything below, and two copies would inject the
+  // recall twice and register /deja twice.
+  try {
+    if (existsSync(installerExtensionPath(homedir()))) return;
+  } catch {}
+
+  let injected = false;
+  let toldBuilding = false;
+
+  // pi keeps a footer status line: while the first index builds, that is
+  // where the user can see it happening instead of wondering why recall is
+  // quiet. Cleared as soon as the build finishes.
+  const showBuild = (ctx: any) => {
+    const status = run(["warmup-status"], "");
+    if (status) {
+      ctx.ui.setStatus("deja", status);
+      return true;
+    }
+    ctx.ui.setStatus("deja", "");
+    return false;
+  };
+
+  pi.on("session_start", async (_event: any, ctx: any) => {
+    try {
+      showBuild(ctx);
+    } catch {
+      // memory is optional: never break the session over it
+    }
+  });
+
+  // pi surfaces registered commands in the prompt box, which is how someone
+  // who never read the docs finds this at all.
+  pi.registerCommand("deja", {
+    description: "Search your own past coding sessions",
+    handler: async (args: string, ctx: any) => {
+      const query = (args || "").trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /deja <what you are looking for>", "info");
+        return;
+      }
+      // The user is waiting on this one, so it may outlive the hook budget:
+      // a first search can rebuild the index.
+      const found = run(argv("search", [], query), "", 120000);
+      ctx.ui.notify(found || "Nothing in your history matches " + query, "info");
+    },
+  });
+
+  pi.on("before_agent_start", async (event: any, ctx: any) => {
+    try {
+      if (!injected) {
+        const { context: digest, receipt } = contextText(run(["hook-context"], ""));
+        if (digest) {
+          injected = true;
+          ctx.ui.setStatus("deja", "");
+          // The receipt is what tells the user memory arrived; without it the
+          // recall is invisible and reads as the model guessing.
+          if (receipt) ctx.ui.notify(receipt, "info");
+          // pi keeps the footer until it is cleared, so the session carries a
+          // quiet reminder that memory is on rather than a one-off toast.
+          const stats = run(["statusline"], "");
+          if (stats) ctx.ui.setStatus("deja", stats);
+          return { message: { customType: "deja-recall", content: digest, display: false } };
+        }
+        // Nothing to recall: either there is no history yet, or the first
+        // index is still building. Only the second is worth saying, once.
+        if (!toldBuilding && showBuild(ctx)) {
+          toldBuilding = true;
+          ctx.ui.notify(run(["warmup-status"], ""), "info");
+        }
+        return;
+      }
+      const key = sessionKey(event, ctx);
+      const raw = run(["hook-prompt"], JSON.stringify({ prompt: event.prompt || "", session_id: key }));
+      if (!raw) return;
+      const resp = JSON.parse(raw);
+      if (resp && resp.systemMessage) ctx.ui.notify(resp.systemMessage, "info");
+      const extra = resp && resp.hookSpecificOutput && resp.hookSpecificOutput.additionalContext;
+      if (!extra) return;
+      return { message: { customType: "deja-recall", content: extra, display: false } };
+    } catch {
+      // memory is optional: never break the session over it
+    }
+  });
+}

package/lib.mjs

@@ -0,0 +1,47 @@
+import { join } from "node:path"
+
+// The pure half of the extension: everything that reads deja's output or
+// decides what this package adds, with no process and no host, so it can be
+// tested without pi.
+
+// installerExtensionPath is where `deja install pi-auto` writes its own
+// extension. pi loads that file and this package side by side, and both
+// would inject recall and register /deja, so this package stands down when
+// the installer's copy is present. Mirrors PiConfigDir() in the installer,
+// which is ~/.pi/agent with no override — pi has none either.
+export function installerExtensionPath(home) {
+  return join(home || "", ".pi", "agent", "extensions", "deja.ts")
+}
+
+// contextText pulls the recall out of whatever hook-context printed. deja
+// answers in the Claude Code hook shape; older builds and `--plain` print
+// bare text, so both are accepted.
+export function contextText(raw) {
+  const text = String(raw || "").trim()
+  if (!text) return { context: "", receipt: "" }
+  try {
+    const parsed = JSON.parse(text)
+    return {
+      context: parsed?.hookSpecificOutput?.additionalContext || "",
+      receipt: parsed?.systemMessage || "",
+    }
+  } catch {
+    return { context: text, receipt: "" }
+  }
+}
+
+// argv builds the call for a query somebody typed. A query that starts with
+// a dash is read by deja as a flag and the call fails, which run() turns into
+// "nothing in the history" — a wrong answer where an error would at least be
+// visible. `--` ends the flags; sent only when the query needs it.
+export function argv(cmd, flags, text) {
+  const arg = String(text)
+  return arg.startsWith("-") ? [cmd, ...flags, "--", arg] : [cmd, ...flags, arg]
+}
+
+// sessionKey is what per-prompt recall dedups on: a hit shown once in a
+// session is not shown again. Without one it repeats itself every message.
+// Same order as the extension `deja install pi-auto` writes.
+export function sessionKey(event, ctx) {
+  return (event && (event.sessionId || event.session_id)) || (ctx && ctx.session && ctx.session.id) || ""
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vshulcz/pi-deja",
+  "version": "0.19.4",
+  "description": "deja-vu memory for pi: the coding sessions already on this machine — pi, Claude Code, Codex, Cursor and 19 more — recalled at session start and on every prompt, searchable with /deja. A local index, no LLM.",
+  "type": "module",
+  "files": [
+    "index.ts",
+    "lib.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vshulcz/deja-vu.git",
+    "directory": "extensions/pi"
+  },
+  "homepage": "https://vshulcz.github.io/deja-vu/guide/memory-for-pi.html",
+  "bugs": {
+    "url": "https://github.com/vshulcz/deja-vu/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "omp",
+    "memory",
+    "recall",
+    "session-history",
+    "agent"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@vshulcz/deja-vu": "^0.19.4"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/vshulcz/deja-vu/assets/listings/recall-card.png"
+  },
+  "omp": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
+}