@jwilger/pi-development-system 0.8.2 → 0.8.3

package/package.json

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

package/src/core/commit-command.ts

@@ -1,3 +1,4 @@
+import { splitLines } from "./git-intent.ts";
 import { resolveGit } from "./git-invocations.ts";
 
 export type CommitExtraction =
@@ -7,20 +8,21 @@ export type CommitExtraction =
   | { readonly kind: "unknown"; readonly trailers: readonly string[] };
 
 const HEREDOC =
-  /<<-?[ \t]*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[^\n]*\n([\s\S]*?)\n[ \t]*\2[ \t]*(?:\n|$)/g;
-
-/** Heredoc bodies are data: take them out so their quotes cannot confuse line splitting. */
-function stripHeredocs(command: string): { rest: string; bodies: Heredoc[] } {
-  const bodies: Heredoc[] = [];
+  /<<-?[ \t]*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1([^\n]*)\n([\s\S]*?)\n[ \t]*\2[ \t]*(?:\n|$)/g;
+
+/**
+ * Heredoc bodies are data: take them out so their quotes cannot confuse line splitting. The rest of
+ * the opening line stays (`| git commit -F -`) with a `#HD<n>` marker naming the removed body.
+ */
+function stripHeredocs(command: string): { rest: string; bodies: string[] } {
+  const bodies: string[] = [];
   const rest = command.replace(HEREDOC, (...m: unknown[]) => {
-    bodies.push({ body: String(m[3]), at: Number(m[m.length - 2]) });
-    return "\n";
+    bodies.push(String(m[4]).trim());
+    return `${String(m[3])} #HD${bodies.length - 1}\n`;
   });
   return { rest, bodies };
 }
 
-type Heredoc = { readonly body: string; readonly at: number };
-
 type Options = {
   messages: string[];
   trailers: string[];
@@ -35,10 +37,11 @@ type Parsed = {
   readonly next: number;
 };
 
-const LONG: ReadonlyArray<readonly [string, Parsed["kind"]]> = [
-  ["--message", "message"],
-  ["--file", "file"],
-  ["--trailer", "trailer"],
+/** Option, kind and the shortest prefix git still resolves uniquely (`--fi` would be `--fixup`). */
+const LONG: ReadonlyArray<readonly [string, Parsed["kind"], number]> = [
+  ["--message", "message", 4],
+  ["--file", "file", 5],
+  ["--trailer", "trailer", 4],
 ];
 
 /** The option a `--name`/`--na=value` spelling means; git accepts any unambiguous prefix (3+ chars). */
@@ -46,11 +49,9 @@ function longOption(arg: string): { kind: Parsed["kind"]; inline: string | undef
   if (!arg.startsWith("--")) return undefined;
   const eq = arg.indexOf("=");
   const name = eq < 0 ? arg : arg.slice(0, eq);
-  if (name.length < 5) return undefined;
-  const hit = LONG.find(([long]) => long.startsWith(name));
-  return hit === undefined
-    ? undefined
-    : { kind: hit[1], inline: eq < 0 ? undefined : arg.slice(eq + 1) };
+  const hit = LONG.find(([long, , min]) => name.length >= min && long.startsWith(name));
+  if (hit === undefined) return undefined;
+  return { kind: hit[1], inline: eq < 0 ? undefined : arg.slice(eq + 1) };
 }
 
 /** Reads the message/file/trailer option starting at args[i], in any of its spellings. */
@@ -71,17 +72,21 @@ function parseArg(args: readonly string[], i: number): Parsed | undefined {
   return undefined;
 }
 
+const OPAQUE_VALUE = /\$\(|`|^\$\{?\w+\}?$/;
+
+function record(options: Options, parsed: Parsed): void {
+  if (parsed.kind === "file") options.file = parsed.value;
+  else if (parsed.kind === "trailer") options.trailers.push(parsed.value ?? "");
+  else if (parsed.value === undefined || OPAQUE_VALUE.test(parsed.value)) options.opaque = true;
+  else options.messages.push(parsed.value);
+}
+
 function readOptions(args: readonly string[]): Options {
   const options: Options = { messages: [], trailers: [], file: undefined, opaque: false };
-  let i = 0;
-  while (i < args.length) {
+  for (let i = 0; i < args.length; ) {
     const parsed = parseArg(args, i);
+    if (parsed !== undefined) record(options, parsed);
     i = parsed?.next ?? i + 1;
-    if (parsed === undefined) continue;
-    if (parsed.kind === "file") options.file = parsed.value;
-    else if (parsed.kind === "trailer") options.trailers.push(parsed.value ?? "");
-    else if (parsed.value === undefined || /\$\(|`/.test(parsed.value)) options.opaque = true;
-    else options.messages.push(parsed.value);
   }
   return options;
 }
@@ -92,18 +97,22 @@ const unknown = (trailers: readonly string[] = []): CommitExtraction => ({
 });
 
 const STDIN_PATHS = new Set(["-", "/dev/stdin", "/proc/self/fd/0"]);
+const MARKER = /#HD(\d+)/g;
 
-/** The heredoc that is this commit's input: the first one written after the word `commit`. */
-const heredocFor = (command: string, bodies: readonly Heredoc[]): string | undefined => {
-  const from = command.search(/\bcommit\b/);
-  return bodies.find((h) => h.at >= from)?.body.trim();
+/** Body of the first heredoc opened on this line or later (its stdin, or the `$(cat <<EOF)` message). */
+const heredocFrom = (lines: readonly string[], line: number, bodies: readonly string[]) => {
+  for (const text of lines.slice(line)) {
+    const hit = [...text.matchAll(MARKER)][0];
+    if (hit !== undefined) return bodies[Number(hit[1])];
+  }
+  return undefined;
 };
 
 function extractOne(args: readonly string[], heredoc: string | undefined): CommitExtraction {
   const options = readOptions(args);
   if (options.file !== undefined && STDIN_PATHS.has(options.file)) {
     return heredoc === undefined
-      ? unknown(options.trailers)
+      ? { kind: "file", path: "-" }
       : { kind: "message", message: heredoc };
   }
   if (options.file !== undefined) return { kind: "file", path: options.file };
@@ -121,9 +130,10 @@ function extractOne(args: readonly string[], heredoc: string | undefined): Commi
 export function extractCommits(command: string): CommitExtraction[] {
   const { rest, bodies } = stripHeredocs(command);
   const resolution = resolveGit(rest);
-  const heredoc = heredocFor(command, bodies);
-  const commits = resolution.invocations.filter((g) => g.sub === "commit");
-  const found = commits.map((g) => extractOne(g.args, heredoc));
+  const lines = splitLines(rest);
+  const found = resolution.invocations.flatMap((g) =>
+    g.sub === "commit" ? [extractOne(g.args, heredocFrom(lines, g.line, bodies))] : [],
+  );
   const hidden = resolution.opaque && /\bcommit\b/.test(command);
   return hidden ? [...found, unknown()] : found;
 }

package/src/core/commit-message.ts

@@ -93,7 +93,8 @@ export function findForbiddenTrailers(
     });
 }
 
-const AI_TRAILER_ANYWHERE = /(?:co-authored-by|generated-by)\s*[:=]/gi;
+const AI_TRAILER_ANYWHERE =
+  /(?:co-authored-by|generated-by)\s*[:=]|signed-off-by\s*[:=][^\n]*\b(?:ai|claude|copilot|codex|gpt|chatgpt|openai|anthropic|gemini|llm)\b/gi;
 
 /** AI-attribution trailer keys anywhere in free text (command lines, quoted strings, printf bodies). */
 export function findForbiddenTrailerKeys(text: string): string[] {

package/src/core/git-invocations.ts

@@ -19,6 +19,8 @@ export type GitInvocation = {
   readonly args: readonly string[];
   /** Directory the command runs in, relative to the starting one (from `cd` and `git -C`), when it moved. */
   readonly dir?: string;
+  /** Index of the (newline-split) line of the top-level command this invocation sits on. */
+  readonly line: number;
 };
 
 export type GitResolution = {
@@ -27,7 +29,12 @@ export type GitResolution = {
   readonly opaque: boolean;
 };
 
-type Collector = { invocations: GitInvocation[]; opaque: boolean; dir: string | undefined };
+type Collector = {
+  invocations: GitInvocation[];
+  opaque: boolean;
+  dir: string | undefined;
+  line: number;
+};
 
 const firstCommand = (tokens: readonly string[]): number => {
   const at = tokens.findIndex((t) => !(isAssignment(t) || WRAPPERS.has(t) || KEYWORDS.has(t)));
@@ -53,7 +60,8 @@ function visitGit(rest: readonly string[], into: Collector): void {
   if (sub.startsWith("$")) into.opaque = true;
   else {
     const args = rest.slice(j + 1);
-    into.invocations.push(dir === undefined ? { sub, args } : { sub, args, dir });
+    const line = into.line;
+    into.invocations.push(dir === undefined ? { sub, args, line } : { sub, args, dir, line });
   }
 }
 
@@ -85,14 +93,17 @@ function visitSegment(tokens: readonly string[], into: Collector): void {
   else if (SHELLS.has(base) || base === "eval") visitScript(base, rest, into);
   else if (OPAQUE.has(base)) into.opaque = into.opaque || gitIndex(rest) >= 0;
   else if (base === "git") visitGit(rest, into);
-  else if (!DATA_ONLY.has(base) && gitIndex(rest) >= 0) {
-    // Wrapper with options (`sudo -E git …`, `timeout 5 git …`): resolve from the git token.
-    visitSegment(rest.slice(gitIndex(rest)), into);
-  }
+  else visitWrapped(base, rest, into);
+}
+
+/** Wrapper with options (`sudo -E git …`, `timeout 5 git …`): resolve from the git token. */
+function visitWrapped(base: string, rest: readonly string[], into: Collector): void {
+  const at = gitIndex(rest);
+  if (!DATA_ONLY.has(base) && at >= 0) visitSegment(rest.slice(at), into);
 }
 
 function merge(into: Collector, other: GitResolution): void {
-  into.invocations.push(...other.invocations);
+  into.invocations.push(...other.invocations.map((g) => ({ ...g, line: into.line })));
   if (other.opaque) into.opaque = true;
 }
 
@@ -101,9 +112,11 @@ function merge(into: Collector, other: GitResolution): void {
  * `timeout`, `if … then`), `bash -c`/`eval` scripts and `$(…)` substitutions. Heredoc bodies are data.
  */
 export function resolveGit(command: string): GitResolution {
-  const into: Collector = { invocations: [], opaque: false, dir: undefined };
+  const into: Collector = { invocations: [], opaque: false, dir: undefined, line: 0 };
   let heredocEnd: string | undefined;
-  for (const line of splitLines(command)) {
+  const lines = splitLines(command);
+  for (const [index, line] of lines.entries()) {
+    into.line = index;
     if (heredocEnd !== undefined) {
       if (line.trim() === heredocEnd) heredocEnd = undefined;
       continue;

package/src/gates/commit-guard.ts

@@ -152,6 +152,13 @@ export function registerCommitGuard(deps: CommitGuardDeps): void {
 
     const known = messages.flatMap((m) => (m === undefined ? [] : [m]));
     const all: Need[] = [];
+    // A -F file that cannot be read now (written by this same command, or stdin) cannot be checked.
+    if (extractions.some((e, i) => e.kind === "file" && messages[i] === undefined)) {
+      all.push({
+        gate: RATIONALE,
+        why: "the message file cannot be read before the commit runs, so its rationale cannot be checked; use -m or a heredoc",
+      });
+    }
     for (const message of known) {
       for (const need of await needsOf(deps, ctx, message)) {
         if (!all.some((n) => n.gate === need.gate)) all.push(need);

package/src/gates/push-guard.ts

@@ -32,6 +32,7 @@ const gate = (id: string): GateId => {
   if (isParseError(parsed)) throw new Error(parsed.message);
   return parsed;
 };
+const FIX_DIFF_LIMIT = 8000;
 const RED_TRUNK = gate("push.red-trunk");
 const DELIVERY_MODE = gate("push.delivery-mode");
 
@@ -54,7 +55,11 @@ 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 && (await currentBranch(exec, where)) === trunk) return true;
+    if (t.branches.length === 0) {
+      // 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;
+    }
   }
   return false;
 }
@@ -74,7 +79,10 @@ async function repairsRedTrunk(
   if (message.code !== 0 || !parsed.ok || parsed.value.type !== "fix") return false;
   const range = `${config.delivery.remote}/${config.delivery.trunk}..HEAD`;
   const diff = await deps.exec("git", ["diff", range], { cwd: ctx.cwd, timeout: 10_000 });
-  if (diff.code !== 0 || diff.stdout.trim() === "") return false;
+  // Jev only reads a bounded diff; a longer range could hide unrelated change past what it sees.
+  if (diff.code !== 0 || diff.stdout.trim() === "" || diff.stdout.length > FIX_DIFF_LIMIT) {
+    return false;
+  }
   const failingLog = await getFailureLog(deps.exec, ctx.cwd, runId);
   if (failingLog.trim() === "") return false; // nothing to compare the diff against: fail closed
   const judged = await judgeFixRelated(deps.jev(ctx), {