hippocamp 0.2.4 → 0.2.5

package/README.md

@@ -8,9 +8,9 @@
 
 Agent memory you can `git log`.
 
-Hippocamp gives Claude Code, Codex, and Grok Build one shared memory: plain Markdown in a private Git repo you own. Every session starts by waking up from it, and every decision an agent records is a commit you can read, diff, and revert.
+Hippocamp gives all your coding agents, like Claude Code and Codex, one shared memory: plain Markdown in a private Git repo you own. Every session starts by waking up from it, and every decision an agent records is a commit you can read, diff, and revert.
 
-Open source (MIT). No account, no API key, no cloud service: it runs on your machine and works the moment it is installed. Your memory never leaves your computer except to a Git remote you choose. No database, no vector store, nothing to pay for.
+Open source (MIT). No account, no API key, no Hippocamp server: it runs on your machine and works the moment it is installed. Your memory lives in a private Git repo. No database, no vector store, nothing to pay for.
 
 ```bash
 npx hippocamp@latest install
@@ -22,10 +22,10 @@ This installs Hippocamp into every supported agent CLI it finds, creates `~/.lag
 
 Claude Code and Codex now ship their own memory. Use Hippocamp when you want:
 
-- **One memory for every agent.** Claude Code, Codex, and Grok read and write the same repo. Built-in memory stays inside one tool.
+- **One memory for every agent.** Claude Code, Codex, and your other agents read and write the same repo. Built-in memory stays inside one tool.
 - **History you can audit.** Every memory change is a Git commit with an author, a diff, and a timestamp. Roll back a bad memory like bad code.
 - **Files you own.** Markdown in your own private repo, readable without any UI, portable across machines through your normal Git credentials.
-- **Nothing to sign up for.** Open source, local, free. No account, no API key, no vendor that can change terms or shut down.
+- **Nothing to sign up for.** Open source and free, running on your machine. No account, no API key, no vendor that can change terms or shut down.
 - **Reviewed compaction.** Optional Dream mode summarizes memory offline and proposes the result as a pull request.
 
 ## Results
@@ -111,7 +111,7 @@ npx hippocamp@latest install-grok
 
 Upgrade with the same command: `npx hippocamp@latest upgrade`. Installers default to `~/.lagoon` as the memory repo; pass `--global-root /absolute/path/to/lagoon` to use another clone.
 
-Installed through npx, the agent starts the server with `npx -y --prefer-offline hippocamp@<version> mcp`, so it keeps working if npm cleans its cache. From a source checkout, `npm install` then `npm run install:claude` (or `install:codex`, `install:grok`) registers the checkout directly.
+Installed through npx, the installer copies the package to `~/.hippocamp/<version>/` and registers that copy, so the server starts without npx or network and keeps working if npm cleans its cache. From a source checkout, `npm install` then `npm run install:claude` (or `install:codex`, `install:grok`) registers the checkout directly.
 
 The Codex installer refreshes `~/.codex/AGENTS.md`. The Claude installer refreshes `~/.claude/CLAUDE.md`. The Grok installer refreshes `~/.grok/rules/hippocamp.md` and registers the MCP server with `HIPPOCAMP_AGENT=grok`.
 Managed instruction blocks tell the agent to call `wake_up` at the start of new top-level coding tasks before repo exploration or edits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippocamp",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "private": false,
   "description": "Local Git-backed memory for AI agents.",
   "license": "MIT",

package/scripts/hippocamp-mcp.cjs

@@ -64,7 +64,7 @@ async function main() {
 
   const server = new McpServer({
     name: "hippocamp",
-    version: "0.1.0",
+    version: require("../package.json").version,
   });
 
   server.registerTool(

package/scripts/install-common.cjs

@@ -1,22 +1,31 @@
 const fsSync = require("node:fs");
 const fs = require("node:fs/promises");
+const os = require("node:os");
 const path = require("node:path");
 const { execFile } = require("node:child_process");
 const { promisify } = require("node:util");
 
 const execFileAsync = promisify(execFile);
 
-// How an agent starts the MCP server. Run through npx, the package lives in npm's cache,
-// which npm may clean; a pinned npx command downloads it again instead of breaking.
-function mcpServerCommand(repoRoot) {
+// How an agent starts the MCP server. Run through npx, the package sits in npm's cache, which
+// npm may clean. Copy it with its dependencies to ~/.hippocamp/<version> and start it from
+// there: no npx or network at start, so it also works offline.
+function mcpServerCommand(repoRoot, home = os.homedir()) {
   if (!repoRoot.split(path.sep).includes("_npx")) {
     return [process.execPath, path.join(repoRoot, "scripts", "hippocamp-mcp.cjs")];
   }
 
   const { version } = require(path.join(repoRoot, "package.json"));
-  const npx = path.join(path.dirname(process.execPath), process.platform === "win32" ? "npx.cmd" : "npx");
+  const target = path.join(home, ".hippocamp", version, "node_modules");
 
-  return [fsSync.existsSync(npx) ? npx : path.basename(npx), "-y", "--prefer-offline", `hippocamp@${version}`, "mcp"];
+  // Copy into a staging folder first, so a failed copy never removes a working install.
+  const staging = `${target}.staging-${process.pid}`;
+  fsSync.rmSync(staging, { recursive: true, force: true });
+  fsSync.cpSync(path.dirname(repoRoot), staging, { recursive: true, dereference: true });
+  fsSync.rmSync(target, { recursive: true, force: true });
+  fsSync.renameSync(staging, target);
+
+  return [process.execPath, path.join(target, path.basename(repoRoot), "scripts", "hippocamp-mcp.cjs")];
 }
 
 async function git(args, cwd) {

package/test/install-common.test.cjs

@@ -36,13 +36,30 @@ async function tempDir(t, name) {
   return root;
 }
 
-test("mcpServerCommand pins npx installs and keeps source checkouts direct", async (t) => {
+test("mcpServerCommand copies npx installs to a stable folder and keeps source checkouts direct", async (t) => {
   const root = await tempDir(t, "npx");
-  const npxRoot = path.join(root, "_npx", "abc", "node_modules", "hippocamp");
-  await fs.mkdir(npxRoot, { recursive: true });
+  const modules = path.join(root, "_npx", "abc", "node_modules");
+  const npxRoot = path.join(modules, "hippocamp");
+  const home = path.join(root, "home");
+  await fs.mkdir(path.join(npxRoot, "scripts"), { recursive: true });
+  await fs.mkdir(path.join(modules, "minisearch"), { recursive: true });
   await fs.writeFile(path.join(npxRoot, "package.json"), '{ "version": "9.9.9" }');
+  await fs.writeFile(path.join(npxRoot, "scripts", "hippocamp-mcp.cjs"), "// server\n");
+  await fs.writeFile(path.join(modules, "minisearch", "index.js"), "// dependency\n");
+
+  const command = mcpServerCommand(npxRoot, home);
+  const stable = path.join(home, ".hippocamp", "9.9.9", "node_modules");
+
+  assert.deepEqual(command, [process.execPath, path.join(stable, "hippocamp", "scripts", "hippocamp-mcp.cjs")]);
+  await fs.stat(command[1]);
+  await fs.stat(path.join(stable, "minisearch", "index.js"));
+
+  // A reinstall of the same version replaces the copy: no stale files, no staging left behind.
+  await fs.writeFile(path.join(stable, "stale.js"), "// old\n");
+  mcpServerCommand(npxRoot, home);
+  await assert.rejects(fs.stat(path.join(stable, "stale.js")));
+  assert.deepEqual(await fs.readdir(path.join(home, ".hippocamp", "9.9.9")), ["node_modules"]);
 
-  assert.deepEqual(mcpServerCommand(npxRoot).slice(1), ["-y", "--prefer-offline", "hippocamp@9.9.9", "mcp"]);
   const source = path.join(root, "src", "hippocamp");
   assert.deepEqual(mcpServerCommand(source), [process.execPath, path.join(source, "scripts", "hippocamp-mcp.cjs")]);
 });