hippocamp 0.2.9 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippocamp",
-  "version": "0.2.9",
+  "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/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"]));
+});