pi-task-tracker 0.1.2 → 0.1.3

package/README.md

@@ -13,7 +13,7 @@ Task workflow tracking for the [pi coding agent](https://www.npmjs.com/package/@
 
 - **Hashline-aware** — records edits made through `pi-hashline-edit-pro`'s `replace`/`insert` tools, not just the native `edit` tool (most setups that replace native edit would otherwise go completely untracked).
 - **Shell-aware** — captures files created/modified by `bash` **and** `powershell` tool calls via before/after `git status` diffing.
-- **Nested-repo aware** — changes inside a sub-repository (a `.git` below your session root) are committed *there* — the innermost repo wins — and never pollute the outer repo.
+- **Nested-repo aware** — changes inside a sub-repository (a `.git` below your session root) are committed *there* — the innermost repo wins — and never pollute the outer repo. The outer task commit records anchors (`Nested: <repo>@<sha>`), so `/rollback` restores nested repos to their exact matching commit.
 - **Subagent-safe** — `.pi-subagents/` session artifacts are never recorded, listed, or committed.
 - **~zero per-turn cost** — one incremental `git add` of touched files per task; no full-worktree scans, no background snapshot daemons.
 

package/index.ts

@@ -151,23 +151,35 @@ function gitCommitTask(
 
   const subject = task ? task.slice(0, 72) : "chore: workflow auto-commit";
   const visible = (f: string) => !isSubagentPath(f);
-  for (const [root, files] of groups) {
+  // Inner repos commit first, the session repo last, so the outer commit can
+  // carry anchors ("Nested: <rel>@<sha>") pointing at the exact nested-repo
+  // commits of this task - /rollback uses them for precise restoration.
+  const innerCommits: string[] = [];
+  const orderedRoots = [...groups.keys()].filter((r) => r !== cwd);
+  orderedRoots.push(cwd);
+  for (const root of orderedRoots) {
+    const files = groups.get(root)!;
     ensureGitIdentity(root);
     for (const f of files) {
       gitOk(["add", "--", f], root);
     }
-    // skip when nothing ended up staged in this repo
-    if (!git(["diff", "--cached", "--name-only"], root)) continue;
+    const staged = git(["diff", "--cached", "--name-only"], root);
+    if (!staged && !(root === cwd && innerCommits.length > 0)) continue;
     const parts: string[] = [];
     if (root === cwd) {
       if (created.some(visible)) parts.push(`Created: ${created.filter(visible).join(", ")}`);
       if (edited.some(visible)) parts.push(`Edited: ${edited.filter(visible).join(", ")}`);
+      for (const ic of innerCommits) parts.push(`Nested: ${ic}`);
     }
     const args = ["commit", "-m", subject];
     if (parts.length > 0) args.push("-m", parts.join("\n"));
-    gitOk(args, root);
+    if (!staged) args.push("--allow-empty");
+    if (gitOk(args, root) && root !== cwd) {
+      const rel = path.relative(cwd, root).replace(/\\/g, "/");
+      innerCommits.push(`${rel}@${git(["rev-parse", "--short", "HEAD"], root)}`);
+    }
+  }
   }
-}
 
 // Best-effort: bring an existing TODO up to the standard format (ensure header).
 function normalizeTodo(todoPath: string): void {
@@ -212,6 +224,60 @@ function normalizeReadme(readmePath: string, name: string): void {
   } catch {}
 }
 
+// ---- Rollback helpers ----
+// Compute the worktree actions needed to bring `root`'s tracked files back to
+// `sha`: restores (M/D paths) and removes (A paths). Subagent data excluded.
+function repoDiffActions(root: string, sha: string): { restores: string[]; removes: string[] } {
+  const diff = git(["diff", "--name-status", "--no-renames", `${sha}..HEAD`], root);
+  const restores: string[] = [];
+  const removes: string[] = [];
+  for (const line of diff.split("\n")) {
+    const tab = line.indexOf("\t");
+    if (tab === -1) continue;
+    const status = line.slice(0, tab).trim()[0];
+    const file = line.slice(tab + 1).trim();
+    if (!file || file.includes("->")) continue;
+    if (isSubagentPath(file)) continue;
+    if (status === "A") removes.push(file);
+    else if (status === "M" || status === "D") restores.push(file);
+  }
+  return { restores, removes };
+}
+
+// Apply actions computed by repoDiffActions (worktree only; chunked for
+// Windows command-length limits).
+function applyRepoRollback(root: string, sha: string, actions: { restores: string[]; removes: string[] }): void {
+  for (let i = 0; i < actions.restores.length; i += 50) {
+    gitOk(["restore", "--source=" + sha, "--worktree", "--", ...actions.restores.slice(i, i + 50)], root);
+  }
+  for (const f of actions.removes) {
+    try {
+      fs.rmSync(path.join(root, f), { force: true });
+    } catch {}
+  }
+}
+
+// Find the commit in a nested repo matching the rolled-back task. One task
+// produces commits with the SAME subject in every repo it touched, so match
+// by subject AND occurrence ordinal (task names may repeat over time):
+// outerIndexNewer = how many commits with this subject are newer than the
+// outer target; pick the same ordinal (newest-first) in the nested history.
+function findInnerTarget(root: string, subject: string, outerDateISO: string): string | null {
+  const log = git(["log", "--max-count=200", "--format=%H|%cI|%s"], root);
+  if (!log) return null;
+  const outerDate = Date.parse(outerDateISO);
+  if (Number.isNaN(outerDate)) return null;
+  let best: { sha: string; t: number } | null = null;
+  for (const line of log.split("\n")) {
+    if (!line) continue;
+    const [sha, date, ...rest] = line.split("|");
+    if (rest.join("|") !== subject) continue;
+    const t = Date.parse(date);
+    if (Number.isNaN(t) || t > outerDate) continue;
+    if (!best || t > best.t) best = { sha, t };
+  }
+  return best ? best.sha : null;
+}
 // ---- Session helpers ----
 // Flatten an AgentMessage's content to plain text (string or content blocks).
 function messageText(m: { content?: unknown }): string {
@@ -529,40 +595,53 @@ export default function (pi: ExtensionAPI) {
       const target = entries.find((e) => e.label === chosen);
       if (!target) return;
 
-      // 2. what changed between target and HEAD (rename pairs split into A+D)
-      const diff = git(["diff", "--name-status", "--no-renames", `${target.sha}..HEAD`], cwd);
-      const restores: string[] = [];
-      const removes: string[] = [];
-      for (const line of diff.split("\n")) {
-        const tab = line.indexOf("\t");
-        if (tab === -1) continue;
-        const status = line.slice(0, tab).trim()[0];
-        const file = line.slice(tab + 1).trim();
-        if (!file || file.includes("->")) continue;
-        // never touch subagent session data
-        if (isSubagentPath(file)) continue;
-        if (status === "A") removes.push(file);
-        else if (status === "M" || status === "D") restores.push(file);
+      // 2. what changed between target and HEAD in the session repo (rename
+      // pairs split into A+D), plus every nested repo touched this session:
+      // one task commits the same subject in each repo it touched, so nested
+      // repos roll back to their own matching commit (time-aligned).
+      const actions = repoDiffActions(cwd, target.sha);
+      const innerRollbacks: { root: string; sha: string; name: string; restores: number; removes: number }[] = [];
+      const innerApply: { root: string; sha: string; actions: { restores: string[]; removes: string[] } }[] = [];
+      if (nestedRoots.size > 0) {
+        // exact anchors recorded in the outer commit body: Nested: <rel>@<sha>
+        const body = git(["show", "-s", "--format=%B", target.sha], cwd);
+        const anchored = new Map<string, string>();
+        for (const line of body.split("\n")) {
+          const m = /^Nested: (.+)@([0-9a-f]{7,40})$/.exec(line.trim());
+          if (m) anchored.set(m[1], m[2]);
+        }
+        const subject = target.subject || git(["show", "-s", "--format=%s", target.sha], cwd);
+        const outerDate = git(["show", "-s", "--format=%cI", target.sha], cwd);
+        for (const root of nestedRoots) {
+          const rel = path.relative(cwd, root).replace(/\\/g, "/");
+          const innerSha = anchored.get(rel) || findInnerTarget(root, subject, outerDate);
+          if (!innerSha) continue;
+          const a = repoDiffActions(root, innerSha);
+          if (a.restores.length > 0 || a.removes.length > 0) {
+            innerRollbacks.push({ root, sha: innerSha, name: path.basename(root), restores: a.restores.length, removes: a.removes.length });
+            innerApply.push({ root, sha: innerSha, actions: a });
+          }
+        }
       }
-      if (restores.length === 0 && removes.length === 0) {
+      const totalRestores = actions.restores.length + innerRollbacks.reduce((n, r) => n + r.restores, 0);
+      const totalRemoves = actions.removes.length + innerRollbacks.reduce((n, r) => n + r.removes, 0);
+      if (totalRestores === 0 && totalRemoves === 0) {
         ctx.ui.notify("No tracked file changes since the target commit - nothing to roll back", "info");
         return;
       }
 
-      // 3. confirm — warn about uncommitted changes that would be overwritten
+      // 3. confirm - warn about uncommitted changes that would be overwritten
       const dirty = git(["status", "--porcelain"], cwd).split("\n").filter(Boolean).length;
-      const summary = `Restore ${restores.length} file(s) and remove ${removes.length} file(s), back to ${target.sha}${dirty > 0 ? ` (WARNING: ${dirty} uncommitted change(s) in the worktree - affected paths will be overwritten)` : " (clean worktree)"}`;
+      const scope = [`main repo: restore ${actions.restores.length}, remove ${actions.removes.length}`];
+      for (const r of innerRollbacks) scope.push(`${r.name}: restore ${r.restores}, remove ${r.removes}`);
+      const summary = `Back to ${target.sha} - ${scope.join('; ')}${dirty > 0 ? ` (WARNING: ${dirty} uncommitted change(s) - affected paths will be overwritten)` : ' (clean worktree)'}`;
       const ok = await ctx.ui.select(`${summary}. Proceed? (worktree only, nothing is committed)`, ["Cancel", "Roll back"]);
       if (ok !== "Roll back") return;
 
-      // 4. apply (worktree only; chunked for Windows command-length limits)
-      for (let i = 0; i < restores.length; i += 50) {
-        gitOk(["restore", "--source=" + target.sha, "--worktree", "--", ...restores.slice(i, i + 50)], cwd);
-      }
-      for (const f of removes) {
-        try {
-          fs.rmSync(path.join(cwd, f), { force: true });
-        } catch {}
+      // 4. apply everywhere (worktree only)
+      applyRepoRollback(cwd, target.sha, actions);
+      for (const r of innerApply) {
+        applyRepoRollback(r.root, r.sha, r.actions);
       }
 
       // 5. drop accumulated file records — they no longer reflect the worktree

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-task-tracker",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Task workflow tracking for the pi coding agent: TODO/README maintenance, per-task git auto-commits as checkpoints, and an interactive /rollback. Hashline-aware, nested-repo aware, subagent-artifact-safe.",
   "keywords": [
     "pi-package",