@jwilger/pi-development-system 0.21.0 → 0.23.0

package/extensions/development-system.ts

@@ -3,6 +3,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { appendContextTail, renderContextTail } from "../src/context/context-tail.ts";
 import { renderStatus, renderStatusLine, STATUS_KEY } from "../src/context/status.ts";
 import { applyPromptSection } from "../src/context/system-prompt.ts";
+import { type Exec, timeoutAsFailure } from "../src/core/exec.ts";
 import { detectProfiles } from "../src/core/profile.ts";
 import { createApprovalStore } from "../src/gates/approvals.ts";
 import { registerCommitGuard } from "../src/gates/commit-guard.ts";
@@ -77,24 +78,26 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     return messages === undefined ? undefined : { messages };
   });
 
+  const exec: Exec = async (command, args, options) =>
+    timeoutAsFailure(await pi.exec(command, args, options));
   registerGitGuard({ pi, approvals, jev: (ctx) => jevHolder.forContext(ctx) });
   registerCommitGuard({
     pi,
     state,
     jev: (ctx) => jevHolder.forContext(ctx),
-    exec: (command, args, options) => pi.exec(command, args, options),
+    exec,
   });
   registerCiCommand({
     pi,
     state,
-    exec: (command, args, options) => pi.exec(command, args, options),
+    exec,
   });
   registerPushGuard({
     pi,
     state,
     approvals,
     jev: (ctx) => jevHolder.forContext(ctx),
-    exec: (command, args, options) => pi.exec(command, args, options),
+    exec,
   });
   registerTestGuard({ pi, state, approvals, jev: (ctx) => jevHolder.forContext(ctx) });
   registerTestEvidence({ pi, state });
@@ -107,8 +110,7 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
   const reviewDeps = {
     state,
     jev: (ctx: ExtensionContext) => jevHolder.forContext(ctx),
-    exec: (command: string, args: string[], options?: { cwd?: string; timeout?: number }) =>
-      pi.exec(command, args, options),
+    exec,
   } satisfies Parameters<typeof createReviewStartTool>[0];
   pi.registerTool(createReviewStartTool(reviewDeps));
   pi.registerTool(createReviewRecordTool(reviewDeps));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.21.0",
+  "version": "0.23.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

@@ -4,3 +4,26 @@ export type Exec = (
   args: string[],
   options?: { cwd?: string; timeout?: number },
 ) => Promise<{ code: number; stdout: string; stderr: string }>;
+
+/** Exit code reported for a command that was killed for running too long (as `timeout(1)` does). */
+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;
+  stdout: string;
+  stderr: string;
+  killed?: boolean;
+}): { code: number; stdout: string; stderr: string } =>
+  result.killed === true
+    ? {
+        code: TIMEOUT_CODE,
+        stdout: result.stdout,
+        stderr: `${result.stderr}\ntimed out`.trim(),
+      }
+    : { code: result.code, stdout: result.stdout, stderr: result.stderr };

package/src/core/review-flow.ts

@@ -56,6 +56,12 @@ export function reviewGap(state: DevsysState, slice: SliceRef, now: DiffNow): st
   }
 }
 
+const ESCAPES: Record<string, string> = { t: "\t", n: "\n", '"': '"', "\\": "\\" };
+
+/** Undo git's C-style quoting of a path (`\"`, `\\`, `\t`, `\n`; octal bytes were already turned off with quotePath=false). */
+const unquote = (path: string): string =>
+  path.replace(/\\([tn"\\])/g, (_m, c: string) => ESCAPES[c] ?? c);
+
 /** A unified diff cut into one text per file, keyed by the file's new path. */
 export function splitDiffByFile(diff: string): Record<string, string> {
   const out: Record<string, string> = {};
@@ -69,7 +75,7 @@ export function splitDiffByFile(diff: string): Record<string, string> {
     const header = /^diff --git "?a\/.*?"? "?b\/(.*?)"?$/.exec(line);
     if (header !== null) {
       flush();
-      path = header[1] ?? line;
+      path = unquote(header[1] ?? line);
       lines = [];
     }
     lines.push(line);

package/src/gates/commit-guard.ts

@@ -13,6 +13,7 @@ import {
   parseConventionalCommit,
 } from "../core/commit-message.ts";
 import type { Exec } from "../core/exec.ts";
+import { resolveGit } from "../core/git-invocations.ts";
 import { reviewGap } from "../core/review-flow.ts";
 import { type GateId, isParseError, parseGateId } from "../core/types.ts";
 import type { Jev } from "../jev/client.ts";
@@ -136,32 +137,84 @@ 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);
   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`,
         },
       ];
 }
 
 /** 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 || stagesEverything(command)
-    ? []
-    : names.staged.filter((name) => names.unstaged.includes(name));
+): string[] => {
+  const invocations = resolveGit(command).invocations;
+  if (stagesAllTracked(invocations)) return [];
+  // A path 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 = new Set(
+    invocations.filter((i) => i.sub === "commit" || i.sub === "add").flatMap((i) => i.args),
+  );
+  return names.staged.filter((name) => names.unstaged.includes(name) && !named.has(name));
+};
+
+const STAGE_ALL = new Set(["-A", "--all", "-u", "--update", "."]);
+const BOOLEAN_SHORT = /[enqsvz]/;
+
+/** `-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 the same directory, ahead of the commit. Read from parsed
+ * invocations, not message text.
+ */
+function stagesAllTracked(invocations: ReturnType<typeof resolveGit>["invocations"]): boolean {
+  const firstCommit = invocations.findIndex((i) => i.sub === "commit");
+  return invocations.some((i, index) => {
+    if (i.dir !== undefined) return false;
+    if (i.sub === "commit") return i.args.some((a) => a === "--all" || clusterHasA(a));
+    if (i.sub !== "add" || (firstCommit !== -1 && index > firstCommit)) 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(
   exec: Exec,
   cwd: string,
 ): Promise<{ staged: string[]; unstaged: string[] } | undefined> {
   try {
-    const base = ["-c", "core.quotePath=false", "diff", "--no-ext-diff", "--name-only", "-z"];
+    const base = [
+      "-c",
+      "core.quotePath=false",
+      "diff",
+      "--no-ext-diff",
+      "--name-only",
+      "-z",
+      "--ignore-submodules=dirty",
+    ];
     const [staged, unstaged] = await Promise.all([
       exec("git", [...base, "--cached"], { cwd, timeout: 10_000 }),
       exec("git", base, { cwd, timeout: 10_000 }),