@jwilger/pi-development-system 0.10.0 → 0.10.1

package/package.json

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

package/skills/tdd-canon/SKILL.md

@@ -39,8 +39,9 @@ This skill is how to work so that gate never fires.
 ## When RED is not required
 
 RED is for **adding or changing first-party production behaviour** when no existing
-failing test already proves the required change. These are exempt, and the exemption
-must be *named* in a recorded departure (scope `slice`; one departure covers the slice):
+failing test already proves the required change. These are exempt. Docs, config, test and generated files are
+exempt by path, so the gate never asks. For the rest, *name* the exemption in a
+recorded departure (scope `slice`; one departure covers the slice):
 
 - docs or metadata only
 - functionality removal (the proof is that nothing still depends on it)

package/src/core/lint-suppression.ts

@@ -85,8 +85,17 @@ function kindOf(line: string): Kind | undefined {
   return matched.find((k) => k.marker === "#![allow(") ?? matched[0];
 }
 
+/** A rustfmt-wrapped `#[allow(\n  lint,\n  reason = "...",\n)]`: the reason sits on a later line. */
+function wrappedReason(lines: readonly string[], index: number): boolean {
+  const attr = lines.slice(index, index + 8);
+  const end = attr.findIndex((l) => l.includes(")]"));
+  const text = (end < 0 ? attr : attr.slice(0, end + 1)).join(" ");
+  return long(lastGroup(/reason\s*=\s*"([^"]*)"/, text));
+}
+
 function reasonOf(kind: Kind, lines: readonly string[], index: number): boolean {
   const line = lines[index] ?? "";
+  if (/^\s*#!?\[(?:allow|expect)\(\s*$/.test(line) && wrappedReason(lines, index)) return true;
   const match = kind.pattern.exec(line);
   const after = match === null ? "" : line.slice(match.index + match[0].length);
   return (

package/src/core/path-class.ts

@@ -9,8 +9,9 @@ const DOCS_EXT = /\.(?:md|mdx|rst|txt|adoc)$/i;
 const DOCS_NAME = /^(?:LICENSE|LICENCE|CHANGELOG|NOTICE|AUTHORS|CONTRIBUTING)(?:\..*)?$/i;
 const CONFIG_EXT = /\.(?:json|jsonc|toml|ya?ml|ini|cfg|conf|env|properties)$/i;
 const CONFIG_NAME = /^(?:Dockerfile|Makefile|justfile|Rakefile|Gemfile|Procfile)$/i;
+// Build output directories only count at the repo root; `src/build/` is usually real source.
 const GENERATED_DIR =
-  /(?:^|\/)(?:node_modules|dist|target|build|coverage|__generated__|generated|\.next|vendor)\//;
+  /(?:^|\/)(?:node_modules|__generated__|\.next)\/|^(?:dist|target|build|coverage|vendor|generated)\//;
 const GENERATED_FILE =
   /(?:\.generated\.|\.gen\.|\.min\.[cm]?js$|\.pb\.go$|\.snap$|(?:^|\/)(?:package-lock\.json|Cargo\.lock|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$|\.lock$)/;
 

package/src/core/test-runner.ts

@@ -52,8 +52,15 @@ export type ResultLike = {
   readonly isError: boolean;
   readonly text: string;
   readonly structured?: unknown;
+  /** The command that ran; used to tell whether its exit status could have been masked. */
+  readonly command?: string;
 };
 
+/** A pipe or sequence makes the shell report the last command's status, not the runner's. */
+const MASKS_STATUS = /\||;/;
+const FAILURE_MARKERS =
+  /^# fail [1-9]|test result: FAILED|\b[1-9]\d* (?:failed|failing)\b|^FAILED\b|^FAIL\b|\bnot ok\b/m;
+
 const isRecord = (v: unknown): v is Record<string, unknown> =>
   typeof v === "object" && v !== null && !Array.isArray(v);
 
@@ -64,7 +71,10 @@ export function exitCodeOf(result: ResultLike): number {
   }
   const line = /Command exited with code (\d+)\s*$/.exec(result.text);
   if (line?.[1] !== undefined) return Number(line[1]);
-  return result.isError ? 1 : 0;
+  if (result.isError) return 1;
+  // `npm test | tail` exits 0 whatever the tests did; trust the output over the masked status.
+  const masked = result.command !== undefined && MASKS_STATUS.test(result.command);
+  return masked && FAILURE_MARKERS.test(result.text) ? 1 : 0;
 }
 
 /** The last few non-empty output lines, redacted and bounded: what the runner said at the end. */

package/src/gates/red-first-guard.ts

@@ -10,6 +10,13 @@ export type RedFirstGuardDeps = { pi: ExtensionAPI; state: SessionState };
 
 const GATE_ID = "tdd.red-first";
 
+/** Test code written inside a source file (Rust `#[cfg(test)]`/`#[test]`): that edit is the RED step itself. */
+const INLINE_TEST = /#\[(?:cfg\(test\)|test|tokio::test|rstest)\]/;
+
+const newText = (
+  input: { content: string } | { edits: ReadonlyArray<{ newText: string }> },
+): string => ("content" in input ? input.content : input.edits.map((e) => e.newText).join("\n"));
+
 /** Exemption classes a machine cannot see; the departure names which one applies (research 02). */
 const JUDGED_EXEMPTIONS =
   "functionality removal, documented third-party behaviour, a change already shown by a failing test, " +
@@ -34,6 +41,7 @@ export function registerRedFirstGuard(deps: RedFirstGuardDeps): void {
     if (lastTestRun !== undefined && lastTestRun.exitCode !== 0) return undefined;
     const path = normalizeRepoPath(ctx.cwd, event.input.path, homedir());
     if (classifyPath(path) !== "source") return undefined;
+    if (INLINE_TEST.test(newText(event.input))) return undefined;
     if (departure.hasOpen()) {
       departure.consume();
       return undefined;

package/src/state/test-evidence.ts

@@ -19,6 +19,7 @@ export function registerTestEvidence(deps: TestEvidenceDeps): void {
       isError: event.isError,
       text,
       structured: event.structuredContent,
+      command,
     });
     deps.state.update((s) => ({
       ...s,