hippocamp 0.2.8 → 0.2.10

package/assets/github-actions/hippocamp-dream.yml

@@ -106,14 +106,14 @@ jobs:
               --target-chars "$HIPPOCAMP_DREAM_TARGET_CHARS" \
               > "/tmp/hippocamp-dream-${project}.json"
 
-            if git diff --quiet -- "projects/${project}/current_state.md" "projects/${project}/open_threads.md"; then
+            git add -- "projects/${project}/current_state.md" "projects/${project}/open_threads.md"
+            if git diff --cached --quiet; then
               echo "No Dream diff for ${project}"
               git checkout main
               git reset --hard origin/main
               continue
             fi
 
-            git add "projects/${project}/current_state.md" "projects/${project}/open_threads.md"
             git commit -m "Dream update ${project} memory"
             git push --force-with-lease origin "$branch"
 

package/assets/railway/run-dream.sh

@@ -113,12 +113,12 @@ while IFS= read -r project; do
     continue
   fi
 
-  if git diff --quiet -- "projects/${project}/current_state.md" "projects/${project}/open_threads.md"; then
+  git add -- "projects/${project}/current_state.md" "projects/${project}/open_threads.md"
+  if git diff --cached --quiet; then
     echo "No Dream diff for ${project}"
     continue
   fi
 
-  git add "projects/${project}/current_state.md" "projects/${project}/open_threads.md"
   git commit -m "Dream update ${project} memory"
 
   if git ls-remote --exit-code --heads origin "refs/heads/${branch}" >/dev/null 2>&1; then

package/docs/dream.md

@@ -17,6 +17,8 @@ Recent events use at most half of the evidence budget. The remaining budget supp
 
 Dream promotes clear decisions, explicit corrections, and reusable project lessons into `current_state.md`, with source references. It keeps remaining actions in `open_threads.md`, preserves unresolved blockers, and removes completed actions only when evidence supports it. A merged PR does not prove its deployment or follow-up work is done. Uncertain lessons remain in events for normal search.
 
+Projects with indexed events can start without curated summaries. Dream creates the two files, and the scheduled runners include these new files in the project's PR.
+
 Corrections apply across both files: a shipped feature should not remain an implementation task, while unverified deployment stays open. Extra compaction passes must keep source paths and timestamps for retained knowledge and aim below the size limit to leave room for length estimates. Dream writes the review comment itself; the model does not set review progress.
 
 The snapshot may grow within `--target-chars` when new evidence adds useful knowledge. If it exceeds the target, Dream compacts the complete result again. It never crops a wake-up file. After three passes, it fails without writing either file or advancing the event comment if the snapshot still does not fit. A project below the threshold with no new indexed evidence is skipped without a model call.

package/package.json

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

package/scripts/hippocamp-memory.cjs

@@ -510,12 +510,19 @@ async function syncMemory({ scope, projectRoot, paths, message }) {
   }
 
   if (!diffResult.stdout) {
-    return {
-      attempted: true,
-      skipped: true,
-      reason: "no_changes_to_commit",
-      repoRoot,
-    };
+    // Commits left behind by an earlier failed push still need to go up.
+    const aheadResult = await runGit(["rev-list", "--count", "@{u}..HEAD"], repoRoot);
+
+    if (!aheadResult.ok || aheadResult.stdout === "0") {
+      return {
+        attempted: true,
+        skipped: true,
+        reason: "no_changes_to_commit",
+        repoRoot,
+      };
+    }
+
+    return pushToUpstream(repoRoot, { attempted: true, committed: false, repoRoot });
   }
 
   const commitResult = await runGit(["commit", "-m", message, "--", ...repoRelativePaths], repoRoot);
@@ -524,16 +531,22 @@ async function syncMemory({ scope, projectRoot, paths, message }) {
     throw new Error(commitResult.stderr || "git commit failed.");
   }
 
+  return pushToUpstream(repoRoot, {
+    attempted: true,
+    committed: true,
+    repoRoot,
+    commitSummary: commitResult.stdout,
+  });
+}
+
+async function pushToUpstream(repoRoot, result) {
   const upstreamResult = await runGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], repoRoot);
 
   if (!upstreamResult.ok) {
     return {
-      attempted: true,
-      committed: true,
+      ...result,
       pushed: false,
       reason: "no_upstream",
-      repoRoot,
-      commitSummary: commitResult.stdout,
     };
   }
 
@@ -544,12 +557,9 @@ async function syncMemory({ scope, projectRoot, paths, message }) {
 
     if (!pullResult.ok) {
       return {
-        attempted: true,
-        committed: true,
+        ...result,
         pushed: false,
         reason: "pull_rebase_failed",
-        repoRoot,
-        commitSummary: commitResult.stdout,
         pushError: pushResult.stderr,
         pullError: pullResult.stderr,
       };
@@ -559,23 +569,17 @@ async function syncMemory({ scope, projectRoot, paths, message }) {
 
     if (!pushResult.ok) {
       return {
-        attempted: true,
-        committed: true,
+        ...result,
         pushed: false,
         reason: "push_failed",
-        repoRoot,
-        commitSummary: commitResult.stdout,
         pushError: pushResult.stderr,
       };
     }
   }
 
   return {
-    attempted: true,
-    committed: true,
+    ...result,
     pushed: true,
-    repoRoot,
-    commitSummary: commitResult.stdout,
     pushSummary: pushResult.stdout || pushResult.stderr,
   };
 }

package/test/dream-runner.test.cjs

@@ -0,0 +1,86 @@
+const assert = require("node:assert/strict");
+const { execFile } = require("node:child_process");
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const { promisify } = require("node:util");
+const test = require("node:test");
+const memory = require("../scripts/hippocamp-memory.cjs");
+
+const exec = promisify(execFile);
+
+test("Dream runner publishes first summaries and skips an unchanged repeat", async (t) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-runner-test-"));
+  const seed = path.join(root, "seed");
+  const remote = path.join(root, "remote.git");
+  const bin = path.join(root, "bin");
+  const calls = path.join(root, "prs");
+  const preload = path.join(root, "model.cjs");
+  const previousRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  t.after(async () => {
+    if (previousRoot === undefined) delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    else process.env.HIPPOCAMP_GLOBAL_ROOT = previousRoot;
+    await fs.rm(root, { recursive: true, force: true });
+  });
+  await fs.mkdir(seed);
+  await fs.mkdir(bin);
+  process.env.HIPPOCAMP_GLOBAL_ROOT = seed;
+  await memory.appendEvent({ projectRoot: "/tmp/new-project", scope: "project", sync: false, title: "Confirmed decision", keywords: ["constraint"], content: "Keep production access read-only." });
+  const env = {
+    ...process.env,
+    PATH: `${bin}${path.delimiter}${process.env.PATH}`,
+    GIT_CONFIG_GLOBAL: path.join(root, "gitconfig"),
+    GIT_CONFIG_NOSYSTEM: "1",
+    GITHUB_TOKEN: "fixture",
+    LAGOON_REPOSITORY: "fixture/lagoon",
+    MANIFEST_API_KEY: "fixture",
+    MANIFEST_BASE_URL: "https://model.invalid",
+    HIPPOCAMP_DREAM_AUTO_MERGE: "false",
+    NODE_OPTIONS: `--require=${preload}`,
+    FIXTURE_REMOTE: remote,
+    FIXTURE_CALLS: calls,
+  };
+  await fs.writeFile(env.GIT_CONFIG_GLOBAL, "[user]\nname = Fixture\nemail = fixture@localhost\n");
+  await fs.writeFile(preload, `
+    global.fetch = async () => {
+      const fs = require("node:fs");
+      const path = require("node:path");
+      fs.writeFileSync(path.join(process.env.HIPPOCAMP_GLOBAL_ROOT, "unrelated.md"), "Do not publish this file");
+      return { ok: true, status: 200, text: async () => JSON.stringify({ output_text: JSON.stringify({
+        current_state_md: "# Current State\\n\\n- Keep production access read-only.",
+        open_threads_md: "# Open Threads\\n\\n- Verify deployment."
+      }) }) };
+    };
+  `);
+  await fs.writeFile(path.join(bin, "gh"), `#!${process.execPath}
+    const fs = require("node:fs");
+    const { execFileSync } = require("node:child_process");
+    const args = process.argv.slice(2);
+    if (args[0] === "auth") process.exit(0);
+    if (args[0] === "repo" && args[1] === "clone") {
+      execFileSync("git", ["clone", process.env.FIXTURE_REMOTE, args[3]], { stdio: "inherit" });
+    } else if (args[0] === "pr" && args[1] === "list") {
+      if (fs.existsSync(process.env.FIXTURE_CALLS)) console.log("1");
+    } else if (args[0] === "pr" && args[1] === "create") {
+      fs.appendFileSync(process.env.FIXTURE_CALLS, "created\\n");
+    } else {
+      throw new Error("Unexpected gh operation: " + args.join(" "));
+    }
+  `, { mode: 0o755 });
+  const git = (args, cwd = seed) => exec("git", args, { cwd, env });
+  await git(["init", "-b", "main"]);
+  await git(["add", "."]);
+  await git(["commit", "-m", "Seed indexed evidence without curated files"]);
+  const before = (await git(["rev-parse", "HEAD"])).stdout.trim();
+  await git(["clone", "--bare", seed, remote]);
+  const runner = path.resolve(__dirname, "../assets/railway/run-dream.sh");
+  await exec("bash", [runner], { env });
+  const changed = (await git(["diff", "--name-only", before, "refs/heads/dream/new-project"], remote)).stdout.trim().split("\n");
+  assert.deepEqual(changed, ["projects/new-project/current_state.md", "projects/new-project/open_threads.md"]);
+  assert.match((await git(["show", "dream/new-project:projects/new-project/current_state.md"], remote)).stdout, /hippocamp-dream-through:/);
+  assert.equal(await fs.readFile(calls, "utf8"), "created\n");
+  // Simulate accepting the reviewed PR, then repeat against the same evidence.
+  await git(["update-ref", "refs/heads/main", "refs/heads/dream/new-project"], remote);
+  await exec("bash", [runner], { env });
+  assert.equal(await fs.readFile(calls, "utf8"), "created\n");
+});

package/test/sync-memory.test.cjs

@@ -63,3 +63,57 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
     /escapes the memory root/,
   );
 });
+
+test("sync pushes commits left behind by an earlier failed push", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-backlog-"));
+  const remote = path.join(tempRoot, "remote.git");
+  const lagoon = path.join(tempRoot, "lagoon");
+  const projectRoot = path.join(tempRoot, "project");
+  const git = (args, cwd = lagoon) => execFileSync("git", args, { cwd }).toString().trim();
+
+  const identity = { GIT_AUTHOR_NAME: "Test", GIT_AUTHOR_EMAIL: "test@example.com", GIT_COMMITTER_NAME: "Test", GIT_COMMITTER_EMAIL: "test@example.com" };
+  const saved = Object.fromEntries(Object.keys(identity).map((key) => [key, process.env[key]]));
+  Object.assign(process.env, identity);
+  t.after(() => {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  git(["init", "-q", "--bare", "-b", "main", remote], tempRoot);
+  git(["clone", "-q", remote, lagoon], tempRoot);
+  git(["commit", "-q", "--allow-empty", "-m", "init"]);
+  git(["push", "-q", "-u", "origin", "main"]);
+  process.env.HIPPOCAMP_GLOBAL_ROOT = lagoon;
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true, maxRetries: 5 });
+  });
+
+  // Simulate an unreachable remote for the first write.
+  git(["remote", "set-url", "origin", path.join(tempRoot, "missing.git")]);
+  const write = await memory.appendEvent({ content: "Use HTTPS.", keywords: ["sync"], projectRoot, scope: "project", title: "Remote" });
+  assert.equal(write.sync.committed, true);
+  assert.equal(write.sync.pushed, false);
+
+  git(["remote", "set-url", "origin", remote]);
+  const result = await memory.syncMemory({
+    scope: "project",
+    projectRoot,
+    paths: await memory.getDefaultSyncPaths("project", projectRoot),
+    message: "sync",
+  });
+
+  assert.equal(result.committed, false);
+  assert.equal(result.pushed, true);
+  assert.equal(git(["rev-parse", "main"], remote), git(["rev-parse", "HEAD"]));
+});