@jwilger/pi-development-system 0.3.5 → 0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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-weakening.ts

@@ -1,5 +1,5 @@
 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 };
 
@@ -151,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 }];

package/src/gates/test-guard.ts

@@ -70,6 +70,35 @@ const RISKY_ADDITION = /\/\*|<!--|=begin\b|"""|'''|\breturn\b|\bthrow\b|\bexit\b
 
 const GLOB = /[*?[\]{]/;
 
+const NO_SIGNALS: WeakeningSignals = { addsSkip: false, emptied: false, commentedOut: false };
+
+/** Adding lines never weakens a test unless an added line itself disables something. */
+const isHarmlessAddition = (before: string, after: string, signals: WeakeningSignals): boolean =>
+  !signals.addsSkip &&
+  !signals.commentedOut &&
+  isPureAddition(before, after) &&
+  !addedLines(before, after).some((line) => RISKY_ADDITION.test(line));
+
+/** Jev's reading of a change, or `undefined` when it sees nothing to act on. */
+function jevVerdict(
+  judged: { weakens: number; motive: string },
+  deterministicSignal: boolean,
+): Verdict | undefined {
+  const weakening = judged.weakens >= WEAKENS_THRESHOLD;
+  if ((weakening || deterministicSignal) && judged.motive === "gate-gaming") {
+    return {
+      kind: "hard-stop",
+      why: "Jev reads this change as weakening a check to get a green result",
+    };
+  }
+  return weakening
+    ? {
+        kind: "require-departure",
+        why: `Jev reads this change as weakening the tests (motive: ${judged.motive})`,
+      }
+    : undefined;
+}
+
 /**
  * Soft gate `tests.weaken`: deleting, skipping, emptying or loosening tests needs a recorded
  * departure; a change Jev reads as gaming a failing gate escalates to a hard stop.
@@ -90,10 +119,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),
@@ -103,41 +135,16 @@ export function registerTestGuard(deps: TestGuardDeps): void {
   const judge = async (change: Change, ctx: ExtensionContext): Promise<Verdict> => {
     const deleted = change.after === undefined && change.rewritten === undefined;
     const after = change.after ?? change.rewritten ?? "";
-    const signals = deleted
-      ? { 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 &&
-      !signals.commentedOut &&
-      isPureAddition(change.before, after) &&
-      !addedLines(change.before, after).some((line) => RISKY_ADDITION.test(line))
-    ) {
-      return { kind: "allow" };
-    }
+    const signals = deleted ? NO_SIGNALS : weakeningSignals(change.before, after);
+    if (!deleted && isHarmlessAddition(change.before, after, signals)) return { kind: "allow" };
     const deterministic = describeSignals(deleted, signals);
     const judged = await judgeTestChange(deps.jev(ctx), {
       path: change.path,
       before: change.before,
       after: after === "" ? undefined : redactSecrets(after),
     });
-    if (judged.ok) {
-      const { weakens, motive } = judged.value;
-      const weakening = weakens >= WEAKENS_THRESHOLD || deterministic !== undefined;
-      if (weakening && motive === "gate-gaming") {
-        return {
-          kind: "hard-stop",
-          why: "Jev reads this change as weakening a check to get a green result",
-        };
-      }
-      if (weakens >= WEAKENS_THRESHOLD) {
-        return {
-          kind: "require-departure",
-          why: `Jev reads this change as weakening the tests (motive: ${motive})`,
-        };
-      }
-    }
+    const fromJev = judged.ok ? jevVerdict(judged.value, deterministic !== undefined) : undefined;
+    if (fromJev !== undefined) return fromJev;
     return deterministic !== undefined
       ? { kind: "require-departure", why: `this change ${deterministic}` }
       : { kind: "allow" };