pi-task-tracker 0.1.3 → 0.1.5

package/README.md

@@ -14,6 +14,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. The outer task commit records anchors (`Nested: <repo>@<sha>`), so `/rollback` restores nested repos to their exact matching commit.
+- **Pre-existing double tracking respected** — if a file is already tracked by both an outer repo and a nested repo, changes go to the nested repo (innermost wins), pi never untracks the outer copy, and `/rollback` never lets the outer repo restore its stale copy over the inner worktree.
+- **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,11 +164,14 @@ 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);
@@ -155,8 +179,8 @@ function gitCommitTask(
   // 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);
+  const orderedRoots = [...groups.keys()].filter((r) => r !== gitRoot);
+  orderedRoots.push(gitRoot);
   for (const root of orderedRoots) {
     const files = groups.get(root)!;
     ensureGitIdentity(root);
@@ -164,9 +188,9 @@ function gitCommitTask(
       gitOk(["add", "--", f], root);
     }
     const staged = git(["diff", "--cached", "--name-only"], root);
-    if (!staged && !(root === cwd && innerCommits.length > 0)) continue;
+    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}`);
@@ -174,12 +198,12 @@ function gitCommitTask(
     const args = ["commit", "-m", subject];
     if (parts.length > 0) args.push("-m", parts.join("\n"));
     if (!staged) args.push("--allow-empty");
-    if (gitOk(args, root) && root !== cwd) {
-      const rel = path.relative(cwd, root).replace(/\\/g, "/");
+    if (gitOk(args, root) && root !== gitRoot) {
+      const rel = path.relative(gitRoot, 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 {
@@ -227,7 +251,7 @@ function normalizeReadme(readmePath: string, name: string): void {
 // ---- 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[] } {
+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[] = [];
@@ -237,6 +261,12 @@ function repoDiffActions(root: string, sha: string): { restores: string[]; remov
     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;
+    // Pre-existing double-tracked files (tracked by both this repo and a
+    // nested repo) stay under the nested repo's authority: this repo's
+    // rollback must never restore/remove them over the inner worktree.
+    if (ownerRepoRoot(path.join(root, file), root) !== root) continue;
     if (isSubagentPath(file)) continue;
     if (status === "A") removes.push(file);
     else if (status === "M" || status === "D") restores.push(file);
@@ -325,6 +355,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[] = [];
@@ -338,18 +369,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") : "";
@@ -379,7 +414,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) => {
@@ -452,14 +487,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
@@ -551,7 +583,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;
@@ -571,13 +603,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;
@@ -599,21 +631,22 @@ export default function (pi: ExtensionAPI) {
       // 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 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], cwd);
+        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], cwd);
-        const outerDate = git(["show", "-s", "--format=%cI", target.sha], cwd);
+        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(cwd, root).replace(/\\/g, "/");
+          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);
@@ -631,15 +664,15 @@ export default function (pi: ExtensionAPI) {
       }
 
       // 3. confirm - warn about uncommitted changes that would be overwritten
-      const dirty = git(["status", "--porcelain"], cwd).split("\n").filter(Boolean).length;
-      const scope = [`main repo: restore ${actions.restores.length}, remove ${actions.removes.length}`];
+      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 everywhere (worktree only)
-      applyRepoRollback(cwd, target.sha, actions);
+      applyRepoRollback(gitRoot, target.sha, actions);
       for (const r of innerApply) {
         applyRepoRollback(r.root, r.sha, r.actions);
       }
@@ -656,7 +689,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.3",
+  "version": "0.1.5",
   "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",