pi-task-tracker 0.1.2 → 0.1.4

package/README.md

@@ -13,7 +13,8 @@ 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.
+- **Subdirectory start** — start pi in a subdirectory of an existing repo and no fresh `.git` is created there: all session changes (including TODO.md / README.md) are recorded in the enclosing repository, and `/rollback` restores the enclosing repo scoped to the session subtree.
 - **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

@@ -76,18 +76,36 @@ function isSubagentPath(rel: string): boolean {
 // repo by initGit). A .git found below cwd (nested/embedded repository) wins,
 // so changes made inside sub-repositories are attributed to the innermost
 // repo's history instead of polluting the outer one.
-function ownerRepoRoot(absPath: string, cwd: string): string {
+// Nearest enclosing git worktree root for an absolute path, searching upward
+// from the file's own directory and stopping at `stopAt` (the session's git
+// root). A .git found below stopAt (nested/embedded repository) wins, so
+// changes made inside sub-repositories are attributed to the innermost
+// repo's history instead of polluting the outer one.
+function ownerRepoRoot(absPath: string, stopAt: string): string {
   let dir = path.dirname(absPath);
   for (;;) {
     if (fs.existsSync(path.join(dir, ".git"))) return dir;
-    const rel = path.relative(dir, cwd);
-    if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return cwd;
+    const rel = path.relative(dir, stopAt);
+    if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return stopAt;
     const parent = path.dirname(dir);
-    if (parent === dir) return cwd;
+    if (parent === dir) return stopAt;
     dir = parent;
   }
 }
 
+// If `dir` itself has no .git, find the repository that contains it (walking
+// upward). Used when pi is started in a subdirectory of an existing repo:
+// that repo is reused instead of creating a fresh one in the subdirectory.
+function findEnclosingRepo(dir: string): string | null {
+  let d = dir;
+  for (;;) {
+    const parent = path.dirname(d);
+    if (parent === d) return null;
+    d = parent;
+    if (fs.existsSync(path.join(d, ".git"))) return d;
+  }
+}
+
 function ensureGitIdentity(cwd: string): void {
   // ensure local identity so commits never fail on a fresh machine
   if (!git(["config", "user.name"], cwd)) {
@@ -103,7 +121,7 @@ const GITIGNORE_SEED =
 
 function initGit(cwd: string): void {
   // 1. init repo if absent
-  if (!fs.existsSync(path.join(cwd, ".git"))) {
+    if (!fs.existsSync(path.join(cwd, ".git"))) {
     gitOk(["init"], cwd);
   }
   ensureGitIdentity(cwd);
@@ -125,7 +143,8 @@ function initGit(cwd: string): void {
 // repo wins) and never staged in the outer repo; subagent working data
 // (.pi-subagents/) is never committed at all.
 function gitCommitTask(
-  cwd: string,
+  sessionCwd: string,
+  gitRoot: string,
   task: string | null,
   created: string[],
   edited: string[]
@@ -133,9 +152,11 @@ function gitCommitTask(
   const groups = new Map<string, Set<string>>();
   const consider = (relPath: string) => {
     if (isSubagentPath(relPath)) return;
-    const abs = path.resolve(cwd, relPath);
-    if (path.relative(cwd, abs).startsWith("..") || path.isAbsolute(path.relative(cwd, abs))) return;
-    const root = ownerRepoRoot(abs, cwd);
+    const abs = path.resolve(sessionCwd, relPath);
+    const fromSession = path.relative(sessionCwd, abs);
+    if (fromSession.startsWith("..") || path.isAbsolute(fromSession)) return;
+    // innermost repo wins; the session repo is the enclosing one (gitRoot)
+    const root = ownerRepoRoot(abs, gitRoot);
     const rel = path.relative(root, abs).replace(/\\/g, "/");
     if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return;
     if (!groups.has(root)) groups.set(root, new Set());
@@ -143,29 +164,44 @@ function gitCommitTask(
   };
   for (const f of created) consider(f);
   for (const f of edited) consider(f);
-  if (!groups.has(cwd)) groups.set(cwd, new Set());
-  const rootFiles = groups.get(cwd)!;
-  rootFiles.add("TODO.md");
-  rootFiles.add("README.md");
-  rootFiles.add(".gitignore");
+  // workflow trackers ride along on the session repo's commit; they live in
+  // sessionCwd, which may be a subdirectory of gitRoot
+  if (!groups.has(gitRoot)) groups.set(gitRoot, new Set());
+  const rootFiles = groups.get(gitRoot)!;
+  const relOf = (f: string) => path.relative(gitRoot, path.join(sessionCwd, f)).replace(/\\/g, "/");
+  rootFiles.add(relOf("TODO.md"));
+  rootFiles.add(relOf("README.md"));
+  if (gitRoot === sessionCwd) rootFiles.add(".gitignore");
 
   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 !== gitRoot);
+  orderedRoots.push(gitRoot);
+  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 === gitRoot && innerCommits.length > 0)) continue;
     const parts: string[] = [];
-    if (root === cwd) {
+    if (root === gitRoot) {
       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 !== gitRoot) {
+      const rel = path.relative(gitRoot, root).replace(/\\/g, "/");
+      innerCommits.push(`${rel}@${git(["rev-parse", "--short", "HEAD"], root)}`);
+    }
   }
 }
 
@@ -212,6 +248,62 @@ 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, subtreeRel?: 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;
+    // when operating on a repo subdirectory, only touch paths inside it
+    if (subtreeRel !== undefined && !(file === subtreeRel || file.startsWith(subtreeRel + "/"))) 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 {
@@ -259,6 +351,7 @@ export default function (pi: ExtensionAPI) {
   let todoPath = "";
   let readmePath = "";
   let cwd = "";
+  let gitRoot = '';
   let config: TrackerConfig = readConfig();
   let currentTask: string | null = null;
   const createdFiles: string[] = [];
@@ -272,18 +365,22 @@ export default function (pi: ExtensionAPI) {
   const nestedRoots = new Set<string>();
   // learn the owning repo of a touched path and remember nested roots
   const watchRootFor = (absPath: string) => {
-    const root = ownerRepoRoot(absPath, cwd);
-    if (root !== cwd) nestedRoots.add(root);
+    const root = ownerRepoRoot(absPath, gitRoot);
+    if (root !== cwd && root !== gitRoot) nestedRoots.add(root);
   };
   const snapshotAll = (): Map<string, Map<string, string>> => {
     const m = new Map<string, Map<string, string>>();
-    m.set(cwd, gitStatusSet(cwd));
+    // git 2.5x 'status --porcelain' emits repo-root-relative paths; run it at the
+    // repo root so the keys are unambiguous, then rebase below.
+    m.set(cwd, gitStatusSet(gitRoot));
     for (const root of nestedRoots) m.set(root, gitStatusSet(root));
     return m;
   };
 
   pi.on("session_start", async (_event, ctx) => {
     cwd = ctx.cwd;
+    // reuse an enclosing repository instead of creating one in a subdirectory
+    gitRoot = fs.existsSync(path.join(cwd, ".git")) ? cwd : findEnclosingRepo(cwd) || cwd;
     config = readConfig();
     todoPath = config.todo ? path.join(cwd, "TODO.md") : "";
     readmePath = config.readme ? path.join(cwd, "README.md") : "";
@@ -313,7 +410,7 @@ export default function (pi: ExtensionAPI) {
     }
 
     // bootstrap git (safe on existing repos: only sets missing config/.gitignore)
-    if (config.autoCommit) initGit(cwd);
+    if (config.autoCommit && gitRoot === cwd) initGit(cwd);
   });
 
   pi.on("before_agent_start", async (event) => {
@@ -386,14 +483,11 @@ export default function (pi: ExtensionAPI) {
         if (p === "TODO.md" || p === "README.md") continue; // handled at commit time
         // Normalize to a cwd-relative path. Inner-repo entries come relative
         // to the inner root and need rebasing onto cwd.
-        let rel = p;
-        if (root !== cwd) {
-          rel = path.relative(cwd, path.join(root, p)).replace(/\\/g, "/");
-          if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
-        }
-        // Guard: never track paths outside cwd (git status emits "../" paths
-        // when cwd is a subdirectory of a parent repo), nor subagent data.
-        if (p === ".." || p.startsWith("../") || path.isAbsolute(p)) continue;
+        // Rebase the repo-root-relative status key onto sessionCwd; skip
+        // anything outside the session subtree.
+        const base = root === cwd ? gitRoot : root;
+        let rel = path.relative(cwd, path.join(base, p)).replace(/\\/g, "/");
+        if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) continue;
         if (isSubagentPath(rel)) continue; // subagent session data is never tracked
         if (prev === undefined) {
           // newly appeared in the working tree
@@ -485,7 +579,7 @@ export default function (pi: ExtensionAPI) {
 
     // commit a snapshot of this task's changes (fresh and existing repos alike)
     if (cwd && config.autoCommit) {
-      gitCommitTask(cwd, taskSnapshot, createdFiles, editedFiles);
+      gitCommitTask(cwd, gitRoot, taskSnapshot, createdFiles, editedFiles);
     }
 
     createdFiles.length = 0;
@@ -505,13 +599,13 @@ export default function (pi: ExtensionAPI) {
     description: "Roll the working tree back to a previous commit (worktree-only, nothing is committed; task commits are the checkpoints)",
     handler: async (_args, ctx) => {
       if (!cwd) return;
-      if (!fs.existsSync(path.join(cwd, ".git"))) {
+      if (!gitRoot || !fs.existsSync(path.join(gitRoot, ".git"))) {
         ctx?.ui.notify("Not a git repository - nothing to roll back", "warning");
         return;
       }
 
       // 1. list recent commits as rollback targets
-      const log = git(["log", "--max-count=30", "--date=format:%m-%d %H:%M", "--format=%h|%ad|%s"], cwd);
+      const log = git(["log", "--max-count=30", "--date=format:%m-%d %H:%M", "--format=%h|%ad|%s"], gitRoot);
       if (!log) {
         ctx?.ui.notify("No commits yet - nothing to roll back", "warning");
         return;
@@ -529,40 +623,54 @@ 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 relCwd = path.relative(gitRoot, cwd).replace(/\\/g, "/");
+      const actions = repoDiffActions(gitRoot, target.sha, relCwd === "" ? undefined : relCwd);
+      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], gitRoot);
+        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], gitRoot);
+        const outerDate = git(["show", "-s", "--format=%cI", target.sha], gitRoot);
+        for (const root of nestedRoots) {
+          const rel = path.relative(gitRoot, 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
-      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)"}`;
+      // 3. confirm - warn about uncommitted changes that would be overwritten
+      const dirty = git(["status", "--porcelain"], gitRoot).split("\n").filter(Boolean).length;
+      const scope = [`main repo${relCwd ? ` [./${relCwd}]` : ""}: 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(gitRoot, 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
@@ -577,7 +685,7 @@ export default function (pi: ExtensionAPI) {
       // in the session tree — /tree can navigate back at any time.
       let conversationNote = "";
       try {
-        const subject = git(["show", "-s", "--format=%s", target.sha], cwd);
+        const subject = git(["show", "-s", "--format=%s", target.sha], gitRoot);
         if (subject && ctx.sessionManager) {
           const norm = (t: string) => t.replace(/\s+/g, " ").trim();
           const branch = ctx.sessionManager.getBranch();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-task-tracker",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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",