@jwilger/pi-development-system 0.22.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/src/core/exec.ts

@@ -11,6 +11,8 @@ export const TIMEOUT_CODE = 124;
 /**
  * pi reports a killed command as `code: 0, killed: true`, so a timed-out `git diff` would look like an
  * empty diff. A guard must never read that as "nothing changed": make the kill a failure.
+ * Limit: a process killed from outside (e.g. the OOM killer) also reads as `code: 0` with `killed` unset;
+ * pi's API does not expose that, so it cannot be detected here.
  */
 export const timeoutAsFailure = (result: {
   code: number;

package/src/gates/commit-guard.ts

@@ -137,40 +137,80 @@ async function reviewNeeds(
   if (gap !== undefined) return [{ gate: REVIEW, why: gap }];
   // The review saw the work tree; a plain `git commit` records the index. A file staged and then edited
   // again would commit the older, unreviewed content.
-  const stale = stagedThenEdited(await changedNames(deps.exec, ctx.cwd), command);
+  const names = await changedNames(deps.exec, ctx.cwd);
+  if (names === undefined) {
+    return [
+      {
+        gate: REVIEW,
+        why: "cannot read which files are staged or edited, so the staged content cannot be compared with the reviewed work tree",
+      },
+    ];
+  }
+  const stale = stagedThenEdited(names, command, ctx.cwd);
   return stale.length === 0
     ? []
     : [
         {
           gate: REVIEW,
-          why: `the staged content of ${stale.join(", ")} differs from the work tree that was reviewed (edited after \`git add\`); stage it again`,
+          why: `the staged content of ${stale.join(", ")} differs from the work tree that was reviewed (edited after \`git add\`, or only partly staged); stage it again, or depart if committing in parts is deliberate`,
         },
       ];
 }
 
+type Invocations = ReturnType<typeof resolveGit>["invocations"];
+
 /** Files staged and also changed since staging; empty when the commit stages everything itself. */
 const stagedThenEdited = (
-  names: { staged: readonly string[]; unstaged: readonly string[] } | undefined,
+  names: { staged: readonly string[]; unstaged: readonly string[] },
   command: string,
-): string[] =>
-  names === undefined || stagesAllTracked(command)
-    ? []
-    : // A path named in the command is committed (or re-staged) from the work tree, which was reviewed.
-      names.staged.filter((name) => names.unstaged.includes(name) && !command.includes(name));
+  cwd: string,
+): string[] => {
+  // Only what runs before or at the first commit can change what that commit records.
+  const all = resolveGit(command).invocations;
+  const firstCommit = all.findIndex((i) => i.sub === "commit");
+  const upto = firstCommit === -1 ? all : all.slice(0, firstCommit + 1);
+  if (stagesAllTracked(upto, cwd)) return [];
+  // A path (or a directory holding it) that is an argument of the commit or add itself is committed or
+  // re-staged from the work tree, which was reviewed. Message text is one argument and never equals a path.
+  const named = upto
+    .filter((i) => (i.sub === "commit" || i.sub === "add") && !isDryRun(i) && inThisDir(i, cwd))
+    .flatMap((i) => i.args.filter((a) => !a.startsWith("-")).map(cleanPath));
+  const covered = (name: string) => named.some((n) => name === n || name.startsWith(`${n}/`));
+  return names.staged.filter((name) => names.unstaged.includes(name) && !covered(name));
+};
+
+const cleanPath = (arg: string): string => arg.replace(/^(\.\/)+/, "").replace(/\/+$/, "");
+const isDryRun = (i: Invocations[number]): boolean =>
+  i.sub === "add" && i.args.some((a) => a === "-n" || a === "--dry-run");
+/** The invocation runs in the session's directory (no `cd`/`-C`, or one that leads back to it). */
+const inThisDir = (i: Invocations[number], cwd: string): boolean =>
+  i.dir === undefined || resolve(cwd, i.dir) === resolve(cwd);
 
 const STAGE_ALL = new Set(["-A", "--all", "-u", "--update", "."]);
+const BOOLEAN_SHORT = /[enqsvz]/;
 
-/** The command re-stages every tracked change itself: `commit -a`, or `git add -A|-u|.`. Read from parsed invocations, not message text. */
-function stagesAllTracked(command: string): boolean {
-  return resolveGit(command).invocations.some(
-    (i) =>
-      (i.sub === "commit" &&
-        i.args.some(
-          (a) =>
-            a === "--all" || a === "--include" || (/^-[a-zA-Z]{1,4}$/.test(a) && a.includes("a")),
-        )) ||
-      (i.sub === "add" && i.args.some((a) => STAGE_ALL.has(a))),
-  );
+/** `-a` inside a short-flag cluster such as `-sa`; a value-taking letter ends the cluster (`-mtab`, `-uall`). */
+function clusterHasA(arg: string): boolean {
+  if (!/^-[a-zA-Z]+$/.test(arg)) return false;
+  for (const ch of arg.slice(1)) {
+    if (ch === "a") return true;
+    if (!BOOLEAN_SHORT.test(ch)) return false;
+  }
+  return false;
+}
+
+/**
+ * The command re-stages every tracked change of this repository before it commits: `commit -a`, or
+ * `git add -A|-u|.` with no pathspec, in this directory. Read from parsed invocations, not message text.
+ */
+function stagesAllTracked(invocations: Invocations, cwd: string): boolean {
+  return invocations.some((i) => {
+    if (!inThisDir(i, cwd) || isDryRun(i)) return false;
+    if (i.sub === "commit") return i.args.some((a) => a === "--all" || clusterHasA(a));
+    if (i.sub !== "add") return false;
+    const paths = i.args.filter((a) => !a.startsWith("-"));
+    return i.args.some((a) => STAGE_ALL.has(a)) && paths.every((a) => a === ".");
+  });
 }
 
 async function changedNames(