@jwilger/pi-development-system 0.8.3 → 0.8.4

package/package.json

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

package/skills/delivery-discipline/SKILL.md

@@ -22,6 +22,14 @@ the issue time. Sessions outliving their grant is a security defect, so the
 check now uses expiry; clock-skew tolerance is deliberately not added.
 ```
 
+```text
+refactor(billing): extract invoice totals into a pure function
+
+Totals were computed inline in three handlers, so each fix had to land three
+times. Behaviour is unchanged (tests untouched); the next commit adds the
+rounding rule on top of this seam.
+```
+
 - Do not write a body that only restates the diff. The diff already says what;
   the body is the only place the reason survives.
 - Do not add `Co-Authored-By`, "Generated with" or any AI trailer. This is
@@ -41,8 +49,10 @@ check now uses expiry; clock-skew tolerance is deliberately not added.
 
 Do not start unrelated work while trunk CI is red. Fix it first; a red build
 hides every later failure. A push to a red trunk is a hard stop unless the
-commit is a `fix` and Jev reads its diff as only repairing the failing run (it needs
-the failing log and Jev online; otherwise the push is a hard stop). If `gh`
+commit is `fix(ci): …` (or another `fix`), touches only what the failing log names, and
+stays small (an unpushed diff over 8000 characters is never exempt); Jev must read it as
+only repairing the failing run, which needs the failing log and Jev online. Otherwise the
+push is a hard stop. If `gh`
 is missing or unauthenticated, CI reads as unknown and the push is allowed:
 check CI by other means before relying on it.
 

package/src/core/commit-command.ts

@@ -72,7 +72,8 @@ function parseArg(args: readonly string[], i: number): Parsed | undefined {
   return undefined;
 }
 
-const OPAQUE_VALUE = /\$\(|`|^\$\{?\w+\}?$/;
+/** A value that is itself a substitution or variable (not prose that mentions backticks). */
+const OPAQUE_VALUE = /^\s*(?:\$\(|`)|^\$\{?\w+\}?$/;
 
 function record(options: Options, parsed: Parsed): void {
   if (parsed.kind === "file") options.file = parsed.value;

package/src/core/push-command.ts

@@ -5,6 +5,10 @@ export type PushTarget = {
   /** Destination branch names named by refspecs; empty means "the current branch's default". */
   readonly branches: readonly string[];
   readonly allBranches: boolean;
+  /** The refspecs name `HEAD`, so the current branch is pushed too. */
+  readonly usesHead: boolean;
+  /** `--tags` with no refspec: only tags are pushed, no branch. */
+  readonly tagsOnly: boolean;
   /** Where the push runs when `cd`/`git -C` moved it away from the session's directory. */
   readonly dir?: string | undefined;
 };
@@ -12,17 +16,26 @@ export type PushTarget = {
 const VALUE_OPTIONS = new Set(["--repo", "-o", "--push-option", "--receive-pack", "--exec"]);
 const isDynamic = (refspec: string): boolean => /[$`*?[]/.test(refspec);
 
+/** A dry run pushes nothing. */
+const isDryRun = (args: readonly string[]): boolean =>
+  args.some((a) => a === "--dry-run" || a === "-n" || /^-[a-zA-Z]*n[a-zA-Z]*$/.test(a));
+
 const destination = (refspec: string): string => {
   const dst = refspec.includes(":") ? refspec.slice(refspec.lastIndexOf(":") + 1) : refspec;
   return dst.replace(/^\+/, "").replace(/^(?:refs\/)?heads\//, "");
 };
 
-type ParsedArgs = { positional: string[]; all: boolean; repo: string | undefined };
+type ParsedArgs = {
+  positional: string[];
+  all: boolean;
+  tags: boolean;
+  repo: string | undefined;
+};
 
 const VALUE_PREFIX = "--repo=";
 
 function positionalArgs(args: readonly string[]): ParsedArgs {
-  const parsed: ParsedArgs = { positional: [], all: false, repo: undefined };
+  const parsed: ParsedArgs = { positional: [], all: false, tags: false, repo: undefined };
   let valueFor: "repo" | "skip" | undefined;
   for (const a of args) {
     if (valueFor === "repo") parsed.repo = a;
@@ -31,13 +44,14 @@ function positionalArgs(args: readonly string[]): ParsedArgs {
     else if (a.startsWith(VALUE_PREFIX)) parsed.repo = a.slice(VALUE_PREFIX.length);
     else if (VALUE_OPTIONS.has(a)) valueFor = "skip";
     else if (a === "--all" || a === "--mirror") parsed.all = true;
+    else if (a === "--tags") parsed.tags = true;
     else if (!a.startsWith("-")) parsed.positional.push(a);
   }
   return parsed;
 }
 
 const toTarget = (args: readonly string[], dir: string | undefined): PushTarget => {
-  const { positional, all, repo } = positionalArgs(args);
+  const { positional, all, tags, repo } = positionalArgs(args);
   // With --repo, every positional argument is a refspec.
   const [remote, ...refspecs] = repo === undefined ? positional : [repo, ...positional];
   const destinations = refspecs.map(destination);
@@ -46,6 +60,8 @@ const toTarget = (args: readonly string[], dir: string | undefined): PushTarget
     remote,
     branches: destinations.filter(named),
     allBranches: all || destinations.some(isDynamic),
+    usesHead: destinations.includes("HEAD"),
+    tagsOnly: tags && refspecs.length === 0 && !all,
     ...(dir === undefined ? {} : { dir }),
   };
 };
@@ -54,11 +70,21 @@ const toTarget = (args: readonly string[], dir: string | undefined): PushTarget
 export function pushTargets(command: string): PushTarget[] {
   const resolution = resolveGit(command);
   const targets = resolution.invocations.flatMap((g) =>
-    g.sub === "push" ? [toTarget(g.args, g.dir)] : [],
+    g.sub === "push" && !isDryRun(g.args) ? [toTarget(g.args, g.dir)] : [],
   );
   // git run through something opaque (xargs, `$CMD`): a push cannot be ruled out, so assume the worst.
   const opaquePush = resolution.opaque && /\bpush\b/.test(command);
   return opaquePush
-    ? [...targets, { remote: undefined, branches: [], allBranches: true }]
+    ? [
+        ...targets,
+        {
+          remote: undefined,
+          branches: [],
+          allBranches: true,
+          usesHead: false,
+          tagsOnly: false,
+          dir: undefined,
+        },
+      ]
     : targets;
 }

package/src/gates/commit-guard.ts

@@ -61,15 +61,21 @@ function messageNeeds(message: string): Need[] {
     : [{ gate: RATIONALE, why: "the message has no body explaining why the change was made" }];
 }
 
-/** What is about to be committed, as far as the working tree shows (staged and unstaged tracked changes). */
+/** `-a`/`--all`, or a `git add` in the same command, widen the commit beyond what is staged. */
+const stagesEverything = (command: string): boolean =>
+  /(?:^|\s)(?:-[a-zA-Z]*a[a-zA-Z]*|--all|--include)(?:\s|$)|\bgit\s+add\b/.test(command);
+
+/** What is about to be committed: the staged changes, or every tracked change when the commit stages them itself. */
 async function pendingDiff(
   exec: Exec,
   cwd: string,
+  command: string,
 ): Promise<{ stat: string; diff: string } | undefined> {
   try {
+    const base = stagesEverything(command) ? ["diff", "HEAD"] : ["diff", "--cached"];
     const [stat, diff] = await Promise.all([
-      exec("git", ["diff", "HEAD", "--stat"], { cwd, timeout: 10_000 }),
-      exec("git", ["diff", "HEAD"], { cwd, timeout: 10_000 }),
+      exec("git", [...base, "--stat"], { cwd, timeout: 10_000 }),
+      exec("git", base, { cwd, timeout: 10_000 }),
     ]);
     if (stat.code !== 0 || diff.code !== 0 || diff.stdout.trim() === "") return undefined;
     return { stat: stat.stdout, diff: diff.stdout };
@@ -83,8 +89,9 @@ async function jevNeeds(
   ctx: ExtensionContext,
   message: string,
   bodyPresent: boolean,
+  command: string,
 ): Promise<Need[]> {
-  const pending = await pendingDiff(deps.exec, ctx.cwd);
+  const pending = await pendingDiff(deps.exec, ctx.cwd, command);
   if (pending === undefined) return [];
   const judged = await judgeCommit(deps.jev(ctx), {
     message,
@@ -131,10 +138,11 @@ async function needsOf(
   deps: CommitGuardDeps,
   ctx: ExtensionContext,
   message: string,
+  command: string,
 ): Promise<Need[]> {
   const needs = messageNeeds(message);
   const bodyPresent = !needs.some((n) => n.why.startsWith("the message has no body"));
-  const viaJev = await jevNeeds(deps, ctx, message, bodyPresent);
+  const viaJev = await jevNeeds(deps, ctx, message, bodyPresent, command);
   return [...needs, ...viaJev.filter((n) => !needs.some((m) => m.gate === n.gate))];
 }
 
@@ -160,7 +168,7 @@ export function registerCommitGuard(deps: CommitGuardDeps): void {
       });
     }
     for (const message of known) {
-      for (const need of await needsOf(deps, ctx, message)) {
+      for (const need of await needsOf(deps, ctx, message, command)) {
         if (!all.some((n) => n.gate === need.gate)) all.push(need);
       }
     }

package/src/gates/push-guard.ts

@@ -55,7 +55,8 @@ async function pushesTrunk(
   for (const t of targets) {
     if (t.allBranches || t.branches.includes(trunk)) return true;
     const where = t.dir === undefined ? cwd : resolve(cwd, t.dir);
-    if (t.branches.length === 0) {
+    if (t.tagsOnly) continue;
+    if (t.branches.length === 0 || t.usesHead) {
       // No refspec: the current branch decides. When it cannot be read, assume it is the trunk.
       const branch = await currentBranch(exec, where);
       if (branch === undefined || branch === trunk) return true;

package/src/state/ci-watch.ts

@@ -23,7 +23,11 @@ export async function watchCi(options: WatchOptions): Promise<CiState> {
       branch: options.branch,
       cwd: options.cwd,
     });
-    const stale = options.expectSha !== undefined && trunk.headSha !== options.expectSha;
+    // `gh` missing or no runs at all (no sha) is unknown, not a run that has yet to appear.
+    const stale =
+      options.expectSha !== undefined &&
+      trunk.headSha !== undefined &&
+      trunk.headSha !== options.expectSha;
     const status = stale ? "pending" : trunk.status;
     last = trunk.headSha === undefined ? { status } : { status, sha: trunk.headSha };
     options.onObserved(last);