@jwilger/pi-development-system 0.3.1 → 0.3.3

package/package.json

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

package/src/core/redact.ts

@@ -6,5 +6,13 @@ export function redactSecrets(text: string): string {
     .replace(/\b(\w*(?:TOKEN|KEY|SECRET|PASSWORD)\w*)=("[^"]*"|'[^']*'|\S+)/gi, "$1=[redacted]")
     .replace(/\b(Authorization:\s*)\w+\s+[^\s'"]+/gi, "$1[redacted]")
     .replace(/\bBearer\s+[^\s'"]+/g, "Bearer [redacted]")
+    .replace(
+      /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g,
+      "[redacted private key]",
+    )
+    .replace(
+      /\b(\w*(?:token|key|secret|password|passwd)\w*["']?\s*[:=]\s*)(["'])[^"'\n]+\2/gi,
+      "$1$2[redacted]$2",
+    )
     .replace(/\bsk-[A-Za-z0-9_-]{16,}/g, "[redacted]");
 }

package/src/core/test-paths.ts

@@ -1,7 +1,15 @@
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
 export type TestPathProfile = { readonly testGlobs?: readonly string[] };
 
+const TEST_DIR = /(^|\/)(test|tests|__tests__|spec|specs|e2e)(\/|$)/;
+const TEST_DIR_ITSELF = /(^|\/)(test|tests|__tests__|spec|specs|e2e)\/?$/;
+const SOURCE_EXT =
+  /\.(?:[cm]?[jt]sx?|py|rb|rs|go|java|kt|kts|scala|cs|ex|exs|php|swift|c|cc|cpp|h|hpp|sh|lua|clj|hs|ml)$/;
+const GLOBBY = /[*?[\]{]/;
+
 const PATTERNS: readonly RegExp[] = [
-  /(^|\/)(test|tests|__tests__|spec|specs|e2e)(\/|$)/,
   /\.(test|spec|cy)\.[cm]?[jt]sx?$/,
   /_test\.(go|rb|py|exs?|rs)$/,
   /(^|\/)test_[^/]+\.py$/,
@@ -23,5 +31,24 @@ function globToRegExp(glob: string): RegExp {
 export function isTestPath(path: string, profile?: TestPathProfile): boolean {
   const normalized = path.replace(/^\.\//, "");
   if (PATTERNS.some((p) => p.test(normalized))) return true;
+  // Inside a test directory only source files (or globs that may expand to them) are tests;
+  // logs, caches, snapshots and docs are not. The directory itself is, so `rm -rf tests` is caught.
+  if (TEST_DIR.test(normalized)) {
+    return (
+      TEST_DIR_ITSELF.test(normalized) || SOURCE_EXT.test(normalized) || GLOBBY.test(normalized)
+    );
+  }
   return (profile?.testGlobs ?? []).some((g) => globToRegExp(g).test(normalized));
 }
+
+/**
+ * Repo-relative form of a path exactly as pi would resolve it: a leading `@` is dropped, `~` expands
+ * to the home directory and `file://` URLs are decoded, so guards see the file that is really touched.
+ */
+export function normalizeRepoPath(cwd: string, input: string, home: string): string {
+  let path = input.startsWith("@") ? input.slice(1) : input;
+  if (path === "~") path = home;
+  else if (path.startsWith("~/")) path = join(home, path.slice(2));
+  else if (/^file:\/\//.test(path)) path = fileURLToPath(path);
+  return isAbsolute(path) ? relative(cwd, path) : relative(cwd, resolve(cwd, path)) || ".";
+}

package/src/core/test-weakening.ts

@@ -1,13 +1,17 @@
 import { posix } from "node:path";
 import { parse } from "shell-quote";
 
-export type WeakeningSignals = { addsSkip: boolean; emptied: boolean };
+export type WeakeningSignals = { addsSkip: boolean; emptied: boolean; commentedOut: boolean };
 
 const SKIP_MARKERS: readonly RegExp[] = [
-  /\b(?:it|test|describe|context)\.(?:skip|todo)\b/,
+  /\b(?:it|test|describe|context)\.(?:skip|only)\b/,
+  /\.skip\(/,
+  /\bskip:\s*true\b/,
+  /\bskipTest\(/,
+  /\bf(?:it|describe)\(/,
   /\bx(?:it|describe|test)\(/,
   /#\[ignore\b/,
-  /@pytest\.mark\.skip|@unittest\.skip|\bpytest\.skip\(/,
+  /@pytest\.mark\.(?:skip|skipif|xfail)|@unittest\.skip|\bpytest\.skip\(/,
   /\bt\.Skip(?:Now|f)?\(/,
   /@Disabled\b|@Ignore\b/,
   /\bprocess\.exit\(/,
@@ -16,11 +20,57 @@ const SKIP_MARKERS: readonly RegExp[] = [
 const countSkips = (text: string): number =>
   SKIP_MARKERS.reduce((n, re) => n + (text.match(new RegExp(re.source, "g"))?.length ?? 0), 0);
 
+/** Lines that are neither blank, inside a C-style block comment, nor a line comment. */
+function codeLineCount(text: string): number {
+  let inBlock = false;
+  let count = 0;
+  for (const raw of text.split("\n")) {
+    let line = raw.trim();
+    let code = false;
+    while (line !== "") {
+      if (inBlock) {
+        const end = line.indexOf("*/");
+        if (end < 0) break;
+        inBlock = false;
+        line = line.slice(end + 2).trim();
+      } else if (line.startsWith("//") || line.startsWith("#")) {
+        break;
+      } else if (line.startsWith("/*")) {
+        inBlock = true;
+        line = line.slice(2);
+      } else {
+        code = true;
+        const start = line.indexOf("/*");
+        if (start < 0) break;
+        inBlock = true;
+        line = line.slice(start + 2);
+      }
+    }
+    if (code) count++;
+  }
+  return count;
+}
+
+const LINE_COMMENT = /^(?:\/\/+|#+|--|;+)\s?(.*)$/;
+
+/** True when a line that was live code before survives only as a line comment after. */
+function lineCommentedOut(before: string, after: string): boolean {
+  const live = new Set(after.split("\n").map((l) => l.trim()));
+  const beforeLines = new Set(before.split("\n").map((l) => l.trim()));
+  return after.split("\n").some((raw) => {
+    const rest = LINE_COMMENT.exec(raw.trim())?.[1]?.trim();
+    return rest !== undefined && rest.length > 3 && beforeLines.has(rest) && !live.has(rest);
+  });
+}
+
 /** Deterministic weakening signals between two versions of a test file. */
 export function weakeningSignals(before: string, after: string): WeakeningSignals {
   return {
     addsSkip: countSkips(after) > countSkips(before),
     emptied: before.trim() !== "" && after.trim() === "",
+    commentedOut:
+      lineCommentedOut(before, after) ||
+      (codeLineCount(after) < codeLineCount(before) && isPureAddition(before, after)),
   };
 }
 
@@ -47,12 +97,49 @@ export function isPureAddition(before: string, after: string): boolean {
   return true;
 }
 
+/** Lines of `after` not matched by a line of `before` (multiset difference, order preserved). */
+export function addedLines(before: string, after: string): string[] {
+  const remaining = new Map<string, number>();
+  for (const line of before.split("\n")) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+  return after.split("\n").filter((line) => {
+    const left = remaining.get(line) ?? 0;
+    if (left === 0) return true;
+    remaining.set(line, left - 1);
+    return false;
+  });
+}
+
 type Segment = { words: string[]; truncates: string[] };
 type Token = { kind: "word"; value: string } | { kind: "op"; op: string };
 
+/** Turns unquoted newlines into `;` (and joins backslash continuations) so shell-quote sees every command. */
+function splitLines(command: string): string {
+  let out = "";
+  let quote: "'" | '"' | undefined;
+  for (let i = 0; i < command.length; i++) {
+    const c = command.charAt(i);
+    if (quote === undefined && c === "\\" && command.charAt(i + 1) === "\n") {
+      out += " ";
+      i++;
+    } else if (quote === undefined && c === "\\") {
+      out += c + command.charAt(i + 1);
+      i++;
+    } else if (quote === undefined && (c === "'" || c === '"')) {
+      quote = c;
+      out += c;
+    } else if (quote === c) {
+      quote = undefined;
+      out += c;
+    } else if (quote === undefined && c === "\n") {
+      out += ";";
+    } else out += c;
+  }
+  return out;
+}
+
 /** Boundary decode of shell-quote's output into domain tokens; globs count as words. */
 function tokenize(command: string): Token[] {
-  return parse(command).flatMap((entry): Token[] => {
+  return parse(splitLines(command)).flatMap((entry): Token[] => {
     if (typeof entry === "string") return [{ kind: "word", value: entry }];
     if ("pattern" in entry) return [{ kind: "word", value: entry.pattern }];
     if ("op" in entry) return [{ kind: "op", op: entry.op }];
@@ -60,8 +147,8 @@ function tokenize(command: string): Token[] {
   });
 }
 
-const TRUNCATING = new Set([">", ">|"]);
-const NON_TRUNCATING_REDIRECTS = new Set([">>", "<", ">&", "<&"]);
+const TRUNCATING = new Set([">", ">|", "&>"]);
+const NON_TRUNCATING_REDIRECTS = new Set([">>", "&>>", "<", ">&", "<&"]);
 
 /** Splits a shell line into simple commands; `>` targets are kept apart from arguments. */
 function segments(command: string): Segment[] {
@@ -104,24 +191,32 @@ const KNOWN = new Set([
   "sed",
   "tee",
   "cp",
+  "dd",
   "cd",
+  "eval",
 ]);
 
 const base = (word: string): string => word.slice(word.lastIndexOf("/") + 1);
 const operands = (words: readonly string[]): string[] => words.filter((w) => !w.startsWith("-"));
 
-/** Strips env assignments and wrappers so the real command is first. */
+const KEYWORDS = new Set(["then", "do", "else", "elif", "if", "while", "until", "{", "!"]);
+
+/** Strips env assignments, shell keywords and wrappers so the real command is first. */
 function realCommand(words: readonly string[]): string[] {
   let rest = [...words];
   for (;;) {
-    while (rest[0] !== undefined && /^\w+=/.test(rest[0])) rest = rest.slice(1);
     const head = rest[0];
-    if (head === undefined || !WRAPPERS.has(base(head))) return rest;
-    const next = rest.findIndex((w, i) => i > 0 && KNOWN.has(base(w)) && !WRAPPERS.has(base(w)));
-    const nextWrapper = rest.findIndex((w, i) => i > 0 && WRAPPERS.has(base(w)));
-    if (nextWrapper > 0 && (next < 0 || nextWrapper < next)) rest = rest.slice(nextWrapper);
-    else if (next > 0) return rest.slice(next);
-    else return [];
+    if (head === undefined) return rest;
+    if (/^\w+=/.test(head) || KEYWORDS.has(head)) rest = rest.slice(1);
+    else if (base(head) === "timeout") {
+      const at = rest.findIndex((w, i) => i > 0 && /^\d+[smhd]?$/.test(w));
+      rest = at < 0 ? [] : rest.slice(at + 1);
+    } else if (WRAPPERS.has(base(head))) {
+      const next = rest.findIndex((w, i) => i > 0 && KNOWN.has(base(w)) && !WRAPPERS.has(base(w)));
+      const nextWrapper = rest.findIndex((w, i) => i > 0 && WRAPPERS.has(base(w)));
+      if (nextWrapper > 0 && (next < 0 || nextWrapper < next)) rest = rest.slice(nextWrapper);
+      else return next > 0 ? rest.slice(next) : [];
+    } else return rest;
   }
 }
 
@@ -144,6 +239,12 @@ function findTargets(args: readonly string[]): string[] {
 
 const removers = (args: readonly string[]): string[] => operands(args);
 
+export type MutationKind = "remove" | "overwrite";
+export type Mutation = { readonly path: string; readonly kind: MutationKind };
+
+/** Commands whose targets cease to exist (or are emptied); every other target is rewritten in place. */
+const REMOVING = new Set(["rm", "unlink", "trash", "rmdir", "mv", "truncate", "find", "git"]);
+
 const gitTargets = (args: readonly string[]): string[] => {
   let i = 0;
   while (args[i]?.startsWith("-")) i += args[i] === "-C" || args[i] === "-c" ? 2 : 1;
@@ -151,11 +252,18 @@ const gitTargets = (args: readonly string[]): string[] => {
   return sub === "rm" || sub === "mv" ? operands(args.slice(i + 1)) : [];
 };
 
-const sedTargets = (args: readonly string[]): string[] =>
-  args.some((a) => /^-[A-Za-z]*i|^--in-place/.test(a)) ? operands(args) : [];
+const sedTargets = (args: readonly string[]): string[] => {
+  if (!args.some((a) => /^-[A-Za-z]*i|^--in-place/.test(a))) return [];
+  // Without -e/-f the first operand is the script, not a file.
+  const scripted = args.some((a) => /^-[A-Za-z]*[ef]$|^--(?:expression|file)/.test(a));
+  return scripted ? operands(args) : operands(args).slice(1);
+};
+
+/** The destination operand is overwritten, whatever the source is. */
+const cpTargets = (args: readonly string[]): string[] => operands(args).slice(-1);
 
-const cpTargets = (args: readonly string[]): string[] =>
-  args.includes("/dev/null") ? operands(args).slice(-1) : [];
+const ddTargets = (args: readonly string[]): string[] =>
+  args.flatMap((a) => (a.startsWith("of=") ? [a.slice(3)] : []));
 
 const truncateTargets = (args: readonly string[]): string[] =>
   operands(args).filter((a) => !/^[+\-<>/%]?\d+$/.test(a));
@@ -171,27 +279,39 @@ const TARGETS: Readonly<Record<string, (args: readonly string[]) => string[]>> =
   find: findTargets,
   sed: sedTargets,
   cp: cpTargets,
+  dd: ddTargets,
   git: gitTargets,
 };
 
-function commandTargets(words: readonly string[]): string[] {
+function commandTargets(words: readonly string[]): Mutation[] {
   const [head, ...args] = words;
   if (head === undefined) return [];
-  const targets = Object.hasOwn(TARGETS, base(head)) ? TARGETS[base(head)] : undefined;
-  return targets === undefined ? [] : targets(args);
+  const name = base(head);
+  const targets = Object.hasOwn(TARGETS, name) ? TARGETS[name] : undefined;
+  const kind: MutationKind = REMOVING.has(name) ? "remove" : "overwrite";
+  return targets === undefined ? [] : targets(args).map((path) => ({ path, kind }));
 }
 
 const joinCwd = (cwd: string, path: string): string =>
   cwd === "" || path.startsWith("/") ? path : posix.join(cwd, path);
 
-function collect(command: string, startCwd: string, depth: number): string[] {
-  const found: string[] = [];
+/** With these (or nothing) as the command, a `>` redirect empties its target. */
+const PRODUCES_NOTHING = new Set(["", ":", "true", "false"]);
+
+function collect(command: string, startCwd: string, depth: number): Mutation[] {
+  const found: Mutation[] = [];
   let cwd = startCwd;
   for (const seg of segments(command)) {
     const words = realCommand(seg.words);
     const head = words[0] === undefined ? "" : base(words[0]);
-    if (head === "cd" && words[1] !== undefined) {
-      cwd = joinCwd(cwd, words[1]);
+    if (head === "cd") {
+      const target = operands(words.slice(1))[0] ?? "~";
+      // A computed directory cannot be resolved statically; keep the current one.
+      if (!/[$`]/.test(target)) cwd = joinCwd(cwd, target);
+      continue;
+    }
+    if (head === "eval" && depth < 3) {
+      found.push(...collect(words.slice(1).join(" "), cwd, depth + 1));
       continue;
     }
     if (SHELLS.has(head) && depth < 3) {
@@ -200,8 +320,14 @@ function collect(command: string, startCwd: string, depth: number): string[] {
       if (script !== undefined) found.push(...collect(script, cwd, depth + 1));
       continue;
     }
-    found.push(...commandTargets(words).map((p) => joinCwd(cwd, p)));
-    found.push(...seg.truncates.flatMap((p) => (p === "/dev/null" ? [] : [joinCwd(cwd, p)])));
+    found.push(...commandTargets(words).map((m) => ({ ...m, path: joinCwd(cwd, m.path) })));
+    found.push(
+      ...seg.truncates.flatMap((p): Mutation[] =>
+        p === "/dev/null"
+          ? []
+          : [{ path: joinCwd(cwd, p), kind: PRODUCES_NOTHING.has(head) ? "remove" : "overwrite" }],
+      ),
+    );
   }
   return found;
 }
@@ -211,6 +337,10 @@ function collect(command: string, startCwd: string, depth: number): string[] {
  * `git rm|mv`, `find -delete`, truncate, `sed -i`, tee and `>` redirects; sees through wrappers,
  * `bash -c`, `cd` and glob arguments.
  */
-export function bashMutatedPaths(command: string): string[] {
+export function bashMutations(command: string): Mutation[] {
   return collect(command, "", 0);
 }
+
+export function bashMutatedPaths(command: string): string[] {
+  return bashMutations(command).map((m) => m.path);
+}

package/src/gates/test-guard.ts

@@ -1,16 +1,20 @@
-import { readFileSync } from "node:fs";
-import { isAbsolute, join, relative } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import {
   type ExtensionAPI,
   type ExtensionContext,
   isToolCallEventType,
   type ToolCallEvent,
 } from "@earendil-works/pi-coding-agent";
-import { isTestPath } from "../core/test-paths.ts";
+import { redactSecrets } from "../core/redact.ts";
+import { isTestPath, normalizeRepoPath } from "../core/test-paths.ts";
 import {
+  addedLines,
   applyEdits,
-  bashMutatedPaths,
+  bashMutations,
   isPureAddition,
+  type WeakeningSignals,
   weakeningSignals,
 } from "../core/test-weakening.ts";
 import { type GateId, isParseError, parseGateId } from "../core/types.ts";
@@ -27,7 +31,13 @@ export type TestGuardDeps = {
   now?: () => Date;
 };
 
-type Change = { path: string; before: string; after: string | undefined };
+type Change = {
+  path: string;
+  before: string;
+  /** `undefined` means the file is gone; an `overwrite` carries the shell command instead. */
+  after: string | undefined;
+  rewritten?: string;
+};
 
 type Verdict =
   | { kind: "allow" }
@@ -36,13 +46,11 @@ type Verdict =
 
 const GATE_ID = "tests.weaken";
 
-const describeSignals = (
-  deleted: boolean,
-  signals: { addsSkip: boolean; emptied: boolean },
-): string | undefined => {
+const describeSignals = (deleted: boolean, signals: WeakeningSignals): string | undefined => {
   if (deleted) return "deletes the test file";
   if (signals.addsSkip) return "skips tests";
   if (signals.emptied) return "empties the test file";
+  if (signals.commentedOut) return "comments out test code";
   return undefined;
 };
 
@@ -54,8 +62,12 @@ const readIfExists = (file: string): string | undefined => {
   }
 };
 
-const repoPath = (cwd: string, path: string): string =>
-  isAbsolute(path) ? relative(cwd, path) : path;
+const repoPath = (cwd: string, path: string): string => normalizeRepoPath(cwd, path, homedir());
+
+/** Added lines that can disable tests without matching a skip marker (block comments, early exits). */
+const RISKY_ADDITION = /\/\*|<!--|=begin\b|"""|'''|\breturn\b|\bthrow\b|\bexit\b|\bpanic\(/;
+
+const GLOB = /[*?[\]{]/;
 
 /**
  * Soft gate `tests.weaken`: deleting, skipping, emptying or loosening tests needs a recorded
@@ -88,19 +100,26 @@ export function registerTestGuard(deps: TestGuardDeps): void {
   };
 
   const judge = async (change: Change, ctx: ExtensionContext): Promise<Verdict> => {
-    const deleted = change.after === undefined;
+    const deleted = change.after === undefined && change.rewritten === undefined;
+    const after = change.after ?? change.rewritten ?? "";
     const signals = deleted
-      ? { addsSkip: false, emptied: false }
-      : weakeningSignals(change.before, change.after ?? "");
+      ? { addsSkip: false, emptied: false, commentedOut: false }
+      : weakeningSignals(change.before, after);
     // Adding lines never weakens a test unless the added line itself is a skip marker.
-    if (!deleted && !signals.addsSkip && isPureAddition(change.before, change.after ?? "")) {
+    if (
+      !deleted &&
+      !signals.addsSkip &&
+      !signals.commentedOut &&
+      isPureAddition(change.before, after) &&
+      !addedLines(change.before, after).some((line) => RISKY_ADDITION.test(line))
+    ) {
       return { kind: "allow" };
     }
     const deterministic = describeSignals(deleted, signals);
     const judged = await judgeTestChange(deps.jev(ctx), {
       path: change.path,
       before: change.before,
-      ...(change.after !== undefined ? { after: change.after } : {}),
+      ...(after !== "" ? { after: redactSecrets(after) } : {}),
     });
     if (judged.ok) {
       const { weakens, motive } = judged.value;
@@ -125,10 +144,22 @@ export function registerTestGuard(deps: TestGuardDeps): void {
 
   const collectChanges = (event: ToolCallEvent, ctx: ExtensionContext): Change[] => {
     if (isToolCallEventType("bash", event)) {
-      return bashMutatedPaths(event.input.command).flatMap((raw) => {
+      const { command } = event.input;
+      return bashMutations(command).flatMap(({ path: raw, kind }) => {
         const path = repoPath(ctx.cwd, raw);
-        return isTestPath(path)
-          ? [{ path, before: readIfExists(join(ctx.cwd, path)) ?? "", after: undefined }]
+        // Missing plain paths have nothing to weaken; globs and directories may still hide tests.
+        const touched = GLOB.test(path) || existsSync(join(ctx.cwd, path));
+        return isTestPath(path) && touched
+          ? [
+              {
+                path,
+                before: readIfExists(join(ctx.cwd, path)) ?? "",
+                after: undefined,
+                ...(kind === "overwrite"
+                  ? { rewritten: `(rewritten by shell command) ${command}` }
+                  : {}),
+              },
+            ]
           : [];
       });
     }