@jwilger/pi-development-system 0.45.2 → 0.46.1

package/package.json

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

package/src/core/model-advice.ts

@@ -47,7 +47,7 @@ const direct = (matrix: ModelMatrix, tier: Tier): string[] =>
  * frontier but lives in strong). Undefined when it is in none of them.
  */
 export function tierOf(matrix: ModelMatrix, model: string): Tier | undefined {
-  return [...TIERS].reverse().find((tier) => matches(direct(matrix, tier), model));
+  return TIERS.findLast((tier) => matches(direct(matrix, tier), model));
 }
 
 /** The best tier that lists the model at all: what a slot resolving to it is asking for. */

package/src/core/redact.ts

@@ -1,7 +1,7 @@
 /** Removes credentials from text before it is written to committed logs or session entries (R11). */
 export function redactSecrets(text: string): string {
   return text
-    .replace(/(\w+:\/\/)[^\s/@]+@/g, "$1[redacted]@")
+    .replace(/(?<!\w)(\w+:\/\/)[^\s/@]+@/g, "$1[redacted]@")
     .replace(/\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{16,}/g, "[redacted]")
     .replace(/\b(\w*(?:TOKEN|KEY|SECRET|PASSWORD)\w*)=("[^"]*"|'[^']*'|\S+)/gi, "$1=[redacted]")
     .replace(/\b(Authorization:\s*)\w+\s+[^\s'"]+/gi, "$1[redacted]")

package/src/core/review-flow.ts

@@ -144,8 +144,11 @@ export function adoptSeverity(
   };
 }
 
-const where = (f: Finding): string =>
-  f.path === undefined ? "" : ` \`${f.path}${f.line === undefined ? "" : `:${f.line}`}\``;
+const where = (f: Finding): string => {
+  if (f.path === undefined) return "";
+  const line = f.line === undefined ? "" : `:${f.line}`;
+  return ` \`${f.path}${line}\``;
+};
 
 /**
  * Nits are never stored. Each is reported back so the coordinator fixes it now or drops it

package/src/core/review-packet.ts

@@ -10,11 +10,7 @@ export type ReviewPacket = {
   readonly verdict: "no-blocking" | "blocking";
 };
 
-const SEP = "[—–-]";
-const HEADER = new RegExp(
-  `^##\\s+Review\\s+${SEP}\\s+(.+?)\\s+${SEP}\\s+round\\s+(\\S+)\\s+${SEP}\\s+lenses:\\s*(.*)$`,
-  "m",
-);
+const HEADER = /^##\s+Review\s+[—–-]\s+(.+?)\s+[—–-]\s+round\s+(\S+)\s+[—–-]\s+lenses:\s*(.*)$/m;
 // Reviewers add text after the location (`fn`, a second location); the first backticked one is the finding's.
 const FINDING = /^-\s*\[([^\]]+)\]\s+(\S+)\s+(?:`([^`]+)`[^—–]*?\s+)?[—–-]\s+(.+)$/;
 // An indented line under a finding is its detail (trigger, fix), unless it is itself a finding.
@@ -24,8 +20,11 @@ const isDetail = (line: string): boolean =>
 // `until` ends a section; by default any heading does. Findings ends only at a known section so a stray
 // heading inside it (### Nits) makes its lines errors instead of silently cutting the findings off.
 const section = (text: string, name: string, until = /^###?\s/m): string | undefined => {
-  const match = new RegExp(`^###\\s+${name}\\s*$`, "im").exec(text);
-  if (match === null) return undefined;
+  const wanted = name.toLowerCase();
+  const match = [...text.matchAll(/^###\s+(.+?)\s*$/gim)].find(
+    (m) => m[1]?.toLowerCase() === wanted,
+  );
+  if (match === undefined) return undefined;
   const rest = text.slice(match.index + match[0].length);
   const next = until.exec(rest);
   return next === null ? rest : rest.slice(0, next.index);
@@ -94,8 +93,7 @@ export function parseReviewPacket(text: string): ReviewPacket | ParseError {
   }
   const lines = findingsText
     .split("\n")
-    .filter((l) => !isDetail(l))
-    .map((l) => l.trim())
+    .flatMap((l) => (isDetail(l) ? [] : [l.trim()]))
     .filter((l) => l !== "" && !/^(?:-\s*)?[([]?(?:none|no findings?)[)\]]?\.?$/i.test(l));
   for (const [i, line] of lines.entries()) {
     const finding = parseFinding(line, lenses, i + 1);

package/src/core/test-runner.ts

@@ -2,7 +2,7 @@ import { basename, isAssignment, segments, splitLines, WRAPPERS } from "./git-in
 import { redactSecrets } from "./redact.ts";
 
 const PACKAGE_MANAGERS = new Set(["npm", "pnpm", "yarn", "bun"]);
-const DIRECT_RUNNERS = new Set(["vitest", "jest", "pytest", "mocha", "ava", "tap"]);
+const DIRECT_RUNNERS = new Set(["vitest", "jest", "pytest", "mocha", "ava"]);
 const EXEC_PREFIX = new Set(["npx", "bunx", "pnpx"]);
 const SUMMARY_LINES = 3;
 const SUMMARY_MAX = 300;
@@ -59,6 +59,7 @@ export type ResultLike = {
 };
 
 /** A pipe or sequence makes the shell report the last command's status, not the runner's. */
+const NO_TEST_SCRIPT = /Missing script: "?test/;
 const MASKS_STATUS = /[|;\n]/;
 const FAILURE_MARKERS =
   /^(?:# |ℹ )fail [1-9]|test result: FAILED|\b[1-9]\d* (?:failed|failing)\b|^FAILED\b|^FAIL\b|\bnot ok\b/m;
@@ -68,6 +69,8 @@ const isRecord = (v: unknown): v is Record<string, unknown> =>
 
 /** Exit code of a bash tool result: structured `exit_code`, else pi's status line, else error/not. */
 export function exitCodeOf(result: ResultLike): number {
+  // `npm test` in a package without a test script exits 1 but ran no tests, so it is not a RED.
+  if (NO_TEST_SCRIPT.test(result.text)) return 0;
   const reported = reportedExit(result);
   if (reported !== 0) return reported;
   // `npm test | tail` exits 0 whatever the tests did, even in the structured status; trust the output.

package/src/gates/commit-guard.ts

@@ -174,7 +174,7 @@ const stagedThenEdited = (
   // re-staged from the work tree, which was reviewed. Message text is one argument and never equals a path.
   const named = upto
     .filter((i) => (i.sub === "commit" || i.sub === "add") && !isDryRun(i) && inThisDir(i, cwd))
-    .flatMap((i) => i.args.filter((a) => !a.startsWith("-")).map(cleanPath));
+    .flatMap((i) => i.args.flatMap((a) => (a.startsWith("-") ? [] : [cleanPath(a)])));
   const covered = (name: string) => named.some((n) => name === n || name.startsWith(`${n}/`));
   return names.staged.filter(
     (name) => names.unstaged.includes(name) && !covered(name) && !DECISION_LOG.test(name),

package/src/state/config.ts

@@ -31,7 +31,6 @@ export type DevsysConfig = {
   readonly profiles: { readonly override: readonly string[] };
   readonly models: ModelMatrix;
   readonly routing: Readonly<Record<string, Route>>;
-  readonly jev: { readonly timeoutMs: number; readonly confidenceFloor: number };
   readonly verifier: { readonly maxPerSession: number };
   readonly cadence: { readonly pushMinutes: number };
   readonly eventModel: { readonly provider: string };
@@ -170,12 +169,20 @@ function route(raw: unknown, key: string): Result<Route, ConfigError> {
     : ok({ slot, thinkingLevel });
 }
 
+const ROUTING_KEY = /^(?:trivial|routine|complex|expert|\*)\/(?:low|medium|high|\*)$/;
+
 function routing(root: Table): Result<Readonly<Record<string, Route>>, ConfigError> {
   const raw = root.routing;
   if (raw === undefined) return ok(DEFAULT_ROUTING);
   if (!isTable(raw)) return fail("routing must be a table", "routing");
   const result: Record<string, Route> = {};
   for (const [pattern, value] of Object.entries(raw)) {
+    if (!ROUTING_KEY.test(pattern)) {
+      return fail(
+        `routing.${pattern}: key must be <difficulty>/<risk>, each a level or *`,
+        `routing.${pattern}`,
+      );
+    }
     const parsed = route(value, `routing.${pattern}`);
     if (!parsed.ok) return parsed;
     result[pattern] = parsed.value;
@@ -201,7 +208,6 @@ const TOP_LEVEL = [
   "profiles",
   "models",
   "routing",
-  "jev",
   "verifier",
   "cadence",
   "event_model",
@@ -237,27 +243,20 @@ function deliveryAndReview(
 
 function limits(
   root: Table,
-): Result<Pick<DevsysConfig, "jev" | "verifier" | "cadence" | "eventModel">, ConfigError> {
-  const j = section(root, "jev", ["timeout_ms", "confidence_floor"]);
+): Result<Pick<DevsysConfig, "verifier" | "cadence" | "eventModel">, ConfigError> {
   const v = section(root, "verifier", ["max_per_session"]);
   const c = section(root, "cadence", ["push_minutes"]);
   const e = section(root, "event_model", ["provider"]);
-  if (!j.ok) return j;
   if (!v.ok) return v;
   if (!c.ok) return c;
   if (!e.ok) return e;
-  const timeout = number(j.value, "jev", "timeout_ms", 4000, POSITIVE);
-  const floor = number(j.value, "jev", "confidence_floor", 0.6, { min: 0, max: 1, integer: false });
   const max = number(v.value, "verifier", "max_per_session", 6, POSITIVE);
   const push = number(c.value, "cadence", "push_minutes", 60, POSITIVE);
   const provider = text(e.value, "event_model", "provider", "builtin");
-  if (!timeout.ok) return timeout;
-  if (!floor.ok) return floor;
   if (!max.ok) return max;
   if (!push.ok) return push;
   if (!provider.ok) return provider;
   return ok({
-    jev: { timeoutMs: timeout.value, confidenceFloor: floor.value },
     verifier: { maxPerSession: max.value },
     cadence: { pushMinutes: push.value },
     eventModel: { provider: provider.value },