@jwilger/pi-development-system 0.3.4 → 0.3.6

package/package.json

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

package/src/core/git-intent.ts

@@ -1,4 +1,4 @@
-import { parse } from "shell-quote";
+import { parseShell } from "./shell-parse.ts";
 
 export type GitIntent =
   | "history-rewrite"
@@ -58,7 +58,7 @@ const isRedirect = (op: string): boolean => /^[<>]/.test(op) && !op.endsWith("("
 /** Tokens of one line grouped into simple commands (operators separate segments). */
 function segments(line: string): string[][] {
   const result: string[][] = [[]];
-  for (const token of parse(line, (name) => `$${name}`)) {
+  for (const token of parseShell(line, (name) => `$${name}`)) {
     if (typeof token === "string") result[result.length - 1]?.push(token);
     else if ("pattern" in token) result[result.length - 1]?.push(token.pattern);
     else if ("op" in token && isRedirect(token.op)) continue;

package/src/core/shell-parse.ts

@@ -0,0 +1,21 @@
+import { type ParseEntry, parse } from "shell-quote";
+
+/**
+ * shell-quote throws on text that is valid shell or valid file content (a template literal inside a
+ * heredoc), and a guard must never crash the tool call. Retry with the `${` openers neutralised, then
+ * fall back to whitespace-split words so command classification still sees every token.
+ */
+export function parseShell(line: string, env?: (name: string) => string): ParseEntry[] {
+  const attempt = (text: string): ParseEntry[] | undefined => {
+    try {
+      return env === undefined ? parse(text) : parse(text, env);
+    } catch {
+      return undefined;
+    }
+  };
+  return (
+    attempt(line) ??
+    attempt(line.replaceAll("${", "$")) ??
+    line.split(/\s+/).filter((word) => word !== "")
+  );
+}

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

@@ -1,23 +1,23 @@
 import { posix } from "node:path";
-import { parse } from "shell-quote";
+import { parseShell } from "./shell-parse.ts";
 
 export type WeakeningSignals = { addsSkip: boolean; emptied: boolean; commentedOut: boolean };
 
 const SKIP_MARKERS: readonly RegExp[] = [
-  /\b(?:it|test|describe|context)\.(?:skip|only)\b/,
-  /\b(?:this|t|self|ctx)\.skip\(/,
-  /\bskip:\s*true\b/,
-  /\bskipTest\(/,
-  /(?<![.\w])f(?:it|describe)\(/,
-  /(?<![.\w])x(?:it|describe|test)\(/,
-  /#\[ignore\b/,
-  /@pytest\.mark\.(?:skip|skipif|xfail)|@unittest\.skip|\bpytest\.skip\(/,
-  /\bt\.Skip(?:Now|f)?\(/,
-  /@Disabled\b|@Ignore\b/,
+  /\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 {
@@ -71,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`. */
@@ -136,7 +151,7 @@ function splitLines(command: string): string {
 
 /** Boundary decode of shell-quote's output into domain tokens; globs count as words. */
 function tokenize(command: string): Token[] {
-  return parse(splitLines(command)).flatMap((entry): Token[] => {
+  return parseShell(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 }];
@@ -256,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.
@@ -278,7 +296,7 @@ const TARGETS: Readonly<Record<string, (args: readonly string[]) => string[]>> =
   trash: removers,
   rmdir: removers,
   mv: moveSources,
-  tee: removers,
+  tee: teeTargets,
   truncate: truncateTargets,
   find: findTargets,
   sed: sedTargets,

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 =
@@ -89,10 +90,13 @@ export function registerTestGuard(deps: TestGuardDeps): void {
 
   const consumeOpenDeparture = (): void => {
     const { openDepartures, activeSlice } = deps.state.get();
-    const used = openDepartures.find(
+    const applicable = openDepartures.filter(
       (d) => d.gate === gate && (d.scope.kind !== "slice" || d.scope.slice === activeSlice),
     );
-    if (used?.scope.kind !== "once") return;
+    // A broader departure covers the call without being spent; only a lone once-scoped one is used up.
+    if (applicable.some((d) => d.scope.kind !== "once")) return;
+    const used = applicable[0];
+    if (used === undefined) return;
     deps.state.update((s) => ({
       ...s,
       openDepartures: s.openDepartures.filter((d) => d.id !== used.id),
@@ -119,7 +123,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 +149,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 +194,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),
   };