@jwilger/pi-development-system 0.10.0 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "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. Docs, config, test and generated files are exempt by path, so the gate never asks. For
+any other exemption below, *name* it 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

@@ -31,7 +31,7 @@ const KINDS: readonly Kind[] = [
   {
     marker: "#![allow(",
     pattern: /#!\[allow\(/,
-    inline: () => undefined,
+    inline: (line) => lastGroup(/reason\s*=\s*"([^"]*)"/, line),
   },
   {
     marker: "#[expect(",
@@ -66,7 +66,8 @@ const KINDS: readonly Kind[] = [
   },
 ];
 
-const COMMENT_LINE = /^\s*(?:\/\/+|\/\*+|\*|#+)\s*(.*?)(?:\s*\*\/)?\s*$/;
+// `#` opens a comment in shell/Python, but `#[` / `#!` start Rust attributes and shebangs.
+const COMMENT_LINE = /^\s*(?:\/\/+|\/\*+|\*|#+(?![[!]))\s*(.*?)(?:\s*\*\/)?\s*$/;
 
 const isSuppressionLine = (line: string): boolean => KINDS.some((k) => k.pattern.test(line));
 
@@ -85,8 +86,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

@@ -8,9 +8,11 @@ const SOURCE_EXT =
 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 TOOL_CONFIG = /(?:^|\/)[\w.-]+\.config\.[cm]?[jt]s$|(?:^|\/)\.[\w-]+rc\.[cm]?[jt]s$/;
 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$)/;
 
@@ -20,12 +22,14 @@ const basename = (path: string): string => path.slice(path.lastIndexOf("/") + 1)
 export function classifyPath(input: string, profile?: TestPathProfile): PathClass {
   const path = input.replace(/^\.\//, "");
   const name = basename(path);
+  if (path.startsWith("../") || path.startsWith("/")) return "other"; // outside the repo
   if (GENERATED_DIR.test(path) || GENERATED_FILE.test(path)) return "generated";
   if (isTestPath(path, profile) && SOURCE_EXT.test(path)) return "test";
   if (DOCS_EXT.test(name) || DOCS_NAME.test(name) || /^docs\//.test(path)) return "docs";
   if (
     CONFIG_EXT.test(name) ||
     CONFIG_NAME.test(name) ||
+    TOOL_CONFIG.test(path) ||
     name.startsWith(".") ||
     /^\.github\//.test(path)
   ) {

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

@@ -1,4 +1,6 @@
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { resolve } from "node:path";
 import { type ExtensionAPI, isToolCallEventType } from "@earendil-works/pi-coding-agent";
 import { classifyPath } from "../core/path-class.ts";
 import { normalizeRepoPath } from "../core/test-paths.ts";
@@ -10,6 +12,28 @@ 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)\]/g;
+
+const countInlineTests = (text: string): number => text.match(INLINE_TEST)?.length ?? 0;
+
+const existing = (cwd: string, path: string): string => {
+  try {
+    return readFileSync(resolve(cwd, path), "utf8");
+  } catch {
+    return "";
+  }
+};
+
+/** Does this edit add test code? A whole-file write counts only markers beyond those already on disk. */
+const addsInlineTest = (
+  input: { content: string } | { edits: ReadonlyArray<{ newText: string }> },
+  before: () => string,
+): boolean =>
+  "content" in input
+    ? countInlineTests(input.content) > countInlineTests(before())
+    : countInlineTests(input.edits.map((e) => e.newText).join("\n")) > 0;
+
 /** 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 +58,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 (addsInlineTest(event.input, () => existing(ctx.cwd, path))) 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,