@jwilger/pi-development-system 0.3.3 → 0.3.5

package/package.json

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

package/src/core/test-paths.ts

@@ -3,8 +3,8 @@ 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 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 = /[*?[\]{]/;
@@ -16,15 +16,23 @@ const PATTERNS: readonly RegExp[] = [
   /_spec\.rb$/,
 ];
 
-const SPECIALS = /[.+^$(){}|[\]\\]/g;
-
-function globToRegExp(glob: string): RegExp {
-  const escaped = glob
-    .replace(SPECIALS, "\\$&")
-    .replace(/\*\*/g, "@@GLOBSTAR@@")
-    .replace(/\*/g, "[^/]*")
-    .replace(/@@GLOBSTAR@@/g, ".*");
-  return new RegExp(`^${escaped}$`);
+/** Glob match without building a RegExp: `**` spans directories, `*` stays within a segment. */
+function matchGlob(glob: string, path: string): boolean {
+  if (glob === "") return path === "";
+  if (glob.startsWith("**")) {
+    const rest = glob.slice(2);
+    for (let i = 0; i <= path.length; i++) if (matchGlob(rest, path.slice(i))) return true;
+    return false;
+  }
+  if (glob.startsWith("*")) {
+    const rest = glob.slice(1);
+    for (let i = 0; i <= path.length; i++) {
+      if (matchGlob(rest, path.slice(i))) return true;
+      if (path[i] === "/" || i === path.length) return false;
+    }
+    return false;
+  }
+  return path !== "" && path[0] === glob[0] && matchGlob(glob.slice(1), path.slice(1));
 }
 
 /** Whether a repo-relative path is a test file (conventions, plus profile-supplied globs). */
@@ -34,11 +42,11 @@ export function isTestPath(path: string, profile?: TestPathProfile): boolean {
   // 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)
-    );
+    if (TEST_DIR_ITSELF.test(normalized) || SOURCE_EXT.test(normalized)) return true;
+    // A glob may expand to tests, unless it ends in a literal non-source extension (*.log, *.snap).
+    return GLOBBY.test(normalized) && !/\.[A-Za-z0-9]+$/.test(normalized);
   }
-  return (profile?.testGlobs ?? []).some((g) => globToRegExp(g).test(normalized));
+  return (profile?.testGlobs ?? []).some((g) => matchGlob(g, normalized));
 }
 
 /**

package/src/core/test-weakening.ts

@@ -4,21 +4,20 @@ import { parse } from "shell-quote";
 export type WeakeningSignals = { addsSkip: boolean; emptied: boolean; commentedOut: boolean };
 
 const SKIP_MARKERS: readonly RegExp[] = [
-  /\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|skipif|xfail)|@unittest\.skip|\bpytest\.skip\(/,
-  /\bt\.Skip(?:Now|f)?\(/,
-  /@Disabled\b|@Ignore\b/,
-  /\bprocess\.exit\(/,
+  /\b(?:it|test|describe|context)\.(?:skip|only)\b/g,
+  /\b(?:this|t|self|ctx)\.skip\(/g,
+  /\bskip:\s*true\b/g,
+  /\bskipTest\(/g,
+  /(?<![.\w])f(?:it|describe)\(/g,
+  /(?<![.\w])x(?:it|describe|test)\(/g,
+  /#\[ignore\b/g,
+  /@pytest\.mark\.(?:skip|skipif|xfail)|@unittest\.skip|\bpytest\.skip\(/g,
+  /\bt\.Skip(?:Now|f)?\(/g,
+  /@Disabled\b|@Ignore\b/g,
 ];
 
 const countSkips = (text: string): number =>
-  SKIP_MARKERS.reduce((n, re) => n + (text.match(new RegExp(re.source, "g"))?.length ?? 0), 0);
+  SKIP_MARKERS.reduce((n, re) => n + [...text.matchAll(re)].length, 0);
 
 /** Lines that are neither blank, inside a C-style block comment, nor a line comment. */
 function codeLineCount(text: string): number {
@@ -39,11 +38,9 @@ function codeLineCount(text: string): number {
         inBlock = true;
         line = line.slice(2);
       } else {
+        // A `/*` after code is more likely inside a string than a comment opener.
         code = true;
-        const start = line.indexOf("/*");
-        if (start < 0) break;
-        inBlock = true;
-        line = line.slice(start + 2);
+        break;
       }
     }
     if (code) count++;
@@ -74,15 +71,30 @@ export function weakeningSignals(before: string, after: string): WeakeningSignal
   };
 }
 
-/** Applies `edits` to `content` (first occurrence each, in order); unmatched edits are ignored. */
+/** LF line endings and no trailing whitespace, so matching tolerates what pi's edit tool tolerates. */
+export const normalizeText = (text: string): string =>
+  text
+    .replace(/\r\n?/g, "\n")
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n");
+
+/**
+ * Applies `edits` to normalised `content` (first occurrence each, in order). `undefined` when an
+ * edit does not match, so callers can hand the change to a judge instead of assuming "no change".
+ */
 export function applyEdits(
   content: string,
   edits: ReadonlyArray<{ oldText: string; newText: string }>,
-): string {
-  return edits.reduce((text, e) => {
-    const at = text.indexOf(e.oldText);
-    return at < 0 ? text : text.slice(0, at) + e.newText + text.slice(at + e.oldText.length);
-  }, content);
+): string | undefined {
+  let text = normalizeText(content);
+  for (const e of edits) {
+    const old = normalizeText(e.oldText);
+    const at = old === "" ? -1 : text.indexOf(old);
+    if (at < 0) return undefined;
+    text = text.slice(0, at) + normalizeText(e.newText) + text.slice(at + old.length);
+  }
+  return text;
 }
 
 /** True when every line of `before` still appears (with multiplicity) in `after`. */
@@ -234,11 +246,18 @@ function findTargets(args: readonly string[]): string[] {
       ? [args[i + 1] ?? ""]
       : [],
   );
-  return [...starts, ...patterns];
+  // With name patterns the start directory is only where to look, not what is deleted.
+  return patterns.length > 0 ? patterns : starts;
 }
 
 const removers = (args: readonly string[]): string[] => operands(args);
 
+/** `mv src… dir/`: the trailing-slash destination is a directory receiving files, not a removal. */
+const moveSources = (args: readonly string[]): string[] => {
+  const ops = operands(args);
+  return ops.length > 1 && ops.at(-1)?.endsWith("/") ? ops.slice(0, -1) : ops;
+};
+
 export type MutationKind = "remove" | "overwrite";
 export type Mutation = { readonly path: string; readonly kind: MutationKind };
 
@@ -252,6 +271,9 @@ const gitTargets = (args: readonly string[]): string[] => {
   return sub === "rm" || sub === "mv" ? operands(args.slice(i + 1)) : [];
 };
 
+const teeTargets = (args: readonly string[]): string[] =>
+  args.some((a) => a === "-a" || a === "--append") ? [] : 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.
@@ -273,8 +295,8 @@ const TARGETS: Readonly<Record<string, (args: readonly string[]) => string[]>> =
   unlink: removers,
   trash: removers,
   rmdir: removers,
-  mv: removers,
-  tee: removers,
+  mv: moveSources,
+  tee: teeTargets,
   truncate: truncateTargets,
   find: findTargets,
   sed: sedTargets,
@@ -320,12 +342,11 @@ function collect(command: string, startCwd: string, depth: number): Mutation[] {
       if (script !== undefined) found.push(...collect(script, cwd, depth + 1));
       continue;
     }
+    const redirectKind: MutationKind = PRODUCES_NOTHING.has(head) ? "remove" : "overwrite";
     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" }],
+        p === "/dev/null" ? [] : [{ path: joinCwd(cwd, p), kind: redirectKind }],
       ),
     );
   }

package/src/gates/approvals.ts

@@ -67,7 +67,7 @@ export type HardStopRequest = {
   toolCallId: string;
   /** What goes wrong if the approved action is a mistake; defaults to the irreversible-git wording. */
   costIfWrong?: string;
-  now?: () => Date;
+  now?: (() => Date) | undefined;
 };
 
 export type HardStopOutcome =

package/src/gates/test-guard.ts

@@ -14,6 +14,7 @@ import {
   applyEdits,
   bashMutations,
   isPureAddition,
+  normalizeText,
   type WeakeningSignals,
   weakeningSignals,
 } from "../core/test-weakening.ts";
@@ -36,7 +37,7 @@ type Change = {
   before: string;
   /** `undefined` means the file is gone; an `overwrite` carries the shell command instead. */
   after: string | undefined;
-  rewritten?: string;
+  rewritten?: string | undefined;
 };
 
 type Verdict =
@@ -119,7 +120,7 @@ export function registerTestGuard(deps: TestGuardDeps): void {
     const judged = await judgeTestChange(deps.jev(ctx), {
       path: change.path,
       before: change.before,
-      ...(after !== "" ? { after: redactSecrets(after) } : {}),
+      after: after === "" ? undefined : redactSecrets(after),
     });
     if (judged.ok) {
       const { weakens, motive } = judged.value;
@@ -145,32 +146,33 @@ export function registerTestGuard(deps: TestGuardDeps): void {
   const collectChanges = (event: ToolCallEvent, ctx: ExtensionContext): Change[] => {
     if (isToolCallEventType("bash", event)) {
       const { command } = event.input;
-      return bashMutations(command).flatMap(({ path: raw, kind }) => {
+      return bashMutations(command).flatMap(({ path: raw, kind }): Change[] => {
         const path = repoPath(ctx.cwd, raw);
         // 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}` }
-                  : {}),
-              },
-            ]
-          : [];
+        if (!isTestPath(path) || !touched) return [];
+        const rewritten =
+          kind === "overwrite" ? `(rewritten by shell command) ${command}` : undefined;
+        return [
+          { path, before: readIfExists(join(ctx.cwd, path)) ?? "", after: undefined, rewritten },
+        ];
       });
     }
     if (!isToolCallEventType("write", event) && !isToolCallEventType("edit", event)) return [];
     const path = repoPath(ctx.cwd, event.input.path);
-    const before = isTestPath(path) ? readIfExists(join(ctx.cwd, path)) : undefined;
-    if (before === undefined) return [];
-    const after = isToolCallEventType("write", event)
-      ? event.input.content
-      : applyEdits(before, event.input.edits);
-    return [{ path, before, after }];
+    const raw = isTestPath(path) ? readIfExists(join(ctx.cwd, path)) : undefined;
+    if (raw === undefined) return [];
+    const before = normalizeText(raw);
+    if (isToolCallEventType("write", event)) {
+      return [{ path, before, after: normalizeText(event.input.content) }];
+    }
+    const after = applyEdits(before, event.input.edits);
+    if (after !== undefined) return [{ path, before, after }];
+    // The edit text does not match statically; let Jev read what the agent intends to write.
+    const intended = event.input.edits.map((e) => e.newText).join("\n");
+    return [
+      { path, before, after: undefined, rewritten: `(edit not matched statically) ${intended}` },
+    ];
   };
 
   const hardStop = async (
@@ -189,7 +191,7 @@ export function registerTestGuard(deps: TestGuardDeps): void {
       why,
       costIfWrong: "the tests verify less behaviour, so regressions can ship undetected",
       toolCallId: event.toolCallId,
-      ...(deps.now !== undefined ? { now: deps.now } : {}),
+      now: deps.now,
     });
     if (outcome.kind === "approved") return undefined;
     return {

package/src/jev/questions/test-change.ts

@@ -10,8 +10,8 @@ export type TestChangeMotive = "requirement-change" | "gate-gaming" | "refactor"
 export type TestChangeInput = {
   path: string;
   before?: string;
-  after?: string;
-  recentFailure?: string;
+  after?: string | undefined;
+  recentFailure?: string | undefined;
 };
 
 export const WEAKENS_QUESTION: ClassifierBoolQuestion = {
@@ -50,15 +50,38 @@ const isMotive = (value: string): value is TestChangeMotive => MOTIVES.some((m)
 export const motiveFromChoice = (choice: string, confidence: number): TestChangeMotive =>
   confidence >= MOTIVE_THRESHOLD && isMotive(choice) ? choice : "unclear";
 
+const CONTEXT_LINES = 40;
+const CLIP = 6000;
+
+/** The lines around what changed, so a large file's edit is not hidden behind its unchanged head. */
+export function changeWindow(before: string, after: string): { before: string; after: string } {
+  const b = before.split("\n");
+  const a = after.split("\n");
+  let head = 0;
+  while (head < b.length && head < a.length && b[head] === a[head]) head++;
+  let tail = 0;
+  while (tail < b.length - head && tail < a.length - head && b.at(-1 - tail) === a.at(-1 - tail)) {
+    tail++;
+  }
+  const from = Math.max(0, head - CONTEXT_LINES);
+  const slice = (lines: string[]): string =>
+    lines.slice(from, Math.min(lines.length, lines.length - tail + CONTEXT_LINES)).join("\n");
+  return { before: slice(b), after: slice(a) };
+}
+
 export async function judgeTestChange(
   jev: Jev,
   input: TestChangeInput,
 ): Promise<Result<{ weakens: number; motive: TestChangeMotive; confidence: number }, JevError>> {
-  const clip = (text: string | undefined): string => redactSecrets(text ?? "").slice(0, 6000);
+  const clip = (text: string | undefined): string => redactSecrets(text ?? "").slice(0, CLIP);
+  const windowed =
+    input.after === undefined
+      ? { before: input.before ?? "", after: "" }
+      : changeWindow(input.before ?? "", input.after);
   const state = {
     path: input.path,
-    before: clip(input.before),
-    after: input.after === undefined ? "" : clip(input.after),
+    before: clip(windowed.before),
+    after: input.after === undefined ? "" : clip(windowed.after),
     deleted: input.after === undefined,
     recentFailure: clip(input.recentFailure),
   };