@gobing-ai/spur 0.3.53 → 0.3.55

package/plugins/sp/scripts/daily-summary/daily-summary.ts

@@ -8,6 +8,7 @@
  * - User annotations (learnings, issues, pending)
  */
 
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { logger } from './logger';
@@ -149,26 +150,28 @@ Examples:
 
 // ─── Date Helpers ─────────────────────────────────────────────────────────────
 
+// ─── Date Helpers ─────────────────────────────────────────────────────────────
+
 /** Return today's date as YYYY-MM-DD in the system (git) timezone. */
 export function todayLocal(): string {
     // Spawn 'date' to get system timezone date, since JS runtime
     // may have a different TZ (e.g. bun test forces UTC).
-    const proc = Bun.spawnSync(['date', '+%Y-%m-%d']);
-    return proc.stdout.toString().trim();
+    const proc = spawnSync('date', ['+%Y-%m-%d'], { encoding: 'utf8' });
+    return (proc.stdout ?? '').trim();
 }
 
 /** Return yesterday's date as YYYY-MM-DD in the system (git) timezone. */
 export function yesterdayLocal(): string {
     // Use portable epoch math via date command
-    const epochProc = Bun.spawnSync(['date', '+%s']);
-    const epoch = parseInt(epochProc.stdout.toString().trim(), 10);
+    const epochProc = spawnSync('date', ['+%s'], { encoding: 'utf8' });
+    const epoch = parseInt((epochProc.stdout ?? '').trim(), 10);
     const yesterdayEpoch = epoch - 86400;
     // Try BSD -r first, then GNU -d @
-    let proc = Bun.spawnSync(['date', '-r', String(yesterdayEpoch), '+%Y-%m-%d']);
-    if (proc.exitCode !== 0) {
-        proc = Bun.spawnSync(['date', '-d', `@${yesterdayEpoch}`, '+%Y-%m-%d']);
+    let proc = spawnSync('date', ['-r', String(yesterdayEpoch), '+%Y-%m-%d'], { encoding: 'utf8' });
+    if ((proc.status ?? 1) !== 0) {
+        proc = spawnSync('date', ['-d', `@${yesterdayEpoch}`, '+%Y-%m-%d'], { encoding: 'utf8' });
     }
-    return proc.stdout.toString().trim();
+    return (proc.stdout ?? '').trim();
 }
 
 export function getDateRange(dateStr: string): { start: string; end: string } {
@@ -181,40 +184,72 @@ export function getDateRange(dateStr: string): { start: string; end: string } {
     return { start, end };
 }
 
+// ─── Subprocess Spawner ──────────────────────────────────────────────────────
+
+export interface ProcessSpawnResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+
+export type ProcessSpawner = (cmd: string, args: string[], env?: NodeJS.ProcessEnv) => Promise<ProcessSpawnResult>;
+
+export const defaultProcessSpawner: ProcessSpawner = (cmd, args, env) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const proc = spawn(cmd, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: env ?? process.env,
+            });
+            const stdoutChunks: Buffer[] = [];
+            const stderrChunks: Buffer[] = [];
+            proc.stdout.on('data', (chunk) => stdoutChunks.push(Buffer.from(chunk)));
+            proc.stderr.on('data', (chunk) => stderrChunks.push(Buffer.from(chunk)));
+            proc.on('close', (exitCode) => {
+                resolve({
+                    stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                    stderr: Buffer.concat(stderrChunks).toString('utf8'),
+                    exitCode: exitCode ?? 0,
+                });
+            });
+            proc.on('error', (err) => {
+                reject(err);
+            });
+        } catch (err) {
+            reject(err);
+        }
+    });
+};
+
+let processSpawner: ProcessSpawner = defaultProcessSpawner;
+
+export function setProcessSpawner(next?: ProcessSpawner): void {
+    processSpawner = next ?? defaultProcessSpawner;
+}
+
 // ─── Ccusage Integration ─────────────────────────────────────────────────────
 
 export async function getCcusageData(date: string): Promise<CcusageData | null> {
     try {
         // Check if ccusage is available
         const env = { ...process.env };
-        const ccusageCheck = Bun.spawn(['ccusage', '--version'], {
-            stdout: 'pipe',
-            stderr: 'pipe',
-            env,
-        });
-        await new Response(ccusageCheck.stdout).text();
-        await ccusageCheck.exited;
+        const ccusageCheck = await processSpawner('ccusage', ['--version'], env);
+        if (ccusageCheck.exitCode !== 0) {
+            return null;
+        }
 
         // Get daily data for the date
         const since = `${date}T00:00:00`;
         const until = `${date}T23:59:59`;
 
-        const proc = Bun.spawn(['ccusage', 'daily', '--since', since, '--until', until, '--json'], {
-            stdout: 'pipe',
-            stderr: 'pipe',
-            env,
-        });
-
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
+        const proc = await processSpawner('ccusage', ['daily', '--since', since, '--until', until, '--json'], env);
 
-        if (exitCode !== 0) {
-            const errorOutput = await new Response(proc.stderr).text();
-            logger.warn(`ccusage error: ${errorOutput}`);
+        if (proc.exitCode !== 0) {
+            logger.warn(`ccusage error: ${proc.stderr}`);
             return null;
         }
 
-        const data = JSON.parse(output) as CcusageData;
+        const data = JSON.parse(proc.stdout) as CcusageData;
         return data;
     } catch (error) {
         logger.warn(`Failed to get ccusage data: ${error}`);
@@ -228,21 +263,24 @@ export async function getGitCommits(date: string): Promise<GitCommit[]> {
     try {
         const { start, end } = getDateRange(date);
 
-        const proc = Bun.spawn(
-            ['git', 'log', '--since', start, '--until', end, '--pretty=format:%H|%ad|%s', '--date=iso', '--numstat'],
-            { stdout: 'pipe', stderr: 'pipe' },
-        );
-
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-
-        if (exitCode !== 0) {
+        const proc = await processSpawner('git', [
+            'log',
+            '--since',
+            start,
+            '--until',
+            end,
+            '--pretty=format:%H|%ad|%s',
+            '--date=iso',
+            '--numstat',
+        ]);
+
+        if (proc.exitCode !== 0) {
             logger.warn('Failed to get git commits');
             return [];
         }
 
         const commits: GitCommit[] = [];
-        const lines = output.trim().split('\n');
+        const lines = proc.stdout.trim().split('\n');
 
         let currentCommit: Partial<GitCommit> | null = null;
 

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.mjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
+var PIPELINE_TOKENS = [
+  "--next",
+  "dev-runall",
+  "dev-wrapall",
+  "dev-run",
+  "dev-wrap",
+  "dev-idea",
+  "runall",
+  "wrapall",
+  "run",
+  "wrap",
+  "idea"
+];
+var PIPELINE_DRIVING_REFUSE_MESSAGE = "⚠ pipeline-driving testee detected; pass --max-retry 0 (observe-only) or --max-retry N (fix mode, tree mutation acknowledged)";
+var MUTATING_FIX_REFUSE_MESSAGE = "⚠ mutating --fix mode detected (--fix all | --fix blockers-first); pass --max-retry 0 (observe-only for the driver; the testee still mutates the tree) or --max-retry N (fix mode, driver + testee both mutate)";
+var IMPLEMENT_HEAVY_ADVISORY_MESSAGE = "⚠ implement-heavy pipeline dogfood: prefer --max-retry 0 (observe-only) or step-split; operator --max-retry N overrides";
+var IMPLEMENT_HEAVY_TOKENS = [
+  "dev-runall",
+  "dev-wrapall",
+  "dev-run",
+  "dev-wrap",
+  "dev-idea",
+  "runall",
+  "wrapall",
+  "run",
+  "wrap",
+  "idea",
+  "implement"
+];
+function hasMutatingFixMode(step) {
+  return /(?<![\w-])--fix[=\s]+(all|blockers-first)(?![\w-])/i.test(step);
+}
+function tokenMatches(testee, token) {
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i");
+  return re.test(testee);
+}
+function detectPipelineDriving(testee) {
+  if (typeof testee !== "string" || testee.length === 0) {
+    return false;
+  }
+  return PIPELINE_TOKENS.some((token) => tokenMatches(testee, token));
+}
+function isImplementHeavyStep(step) {
+  if (typeof step !== "string" || step.length === 0)
+    return false;
+  const nonMutatingOnly = tokenMatches(step, "dev-verify") || tokenMatches(step, "dev-review") || tokenMatches(step, "dev-unit");
+  const hasMutating = IMPLEMENT_HEAVY_TOKENS.some((token) => tokenMatches(step, token)) || hasMutatingFixMode(step);
+  if (nonMutatingOnly && !hasMutating)
+    return false;
+  if (tokenMatches(step, "dev-refine") && !hasMutating && !tokenMatches(step, "--next")) {
+    return false;
+  }
+  if (tokenMatches(step, "dev-refine") && tokenMatches(step, "--next")) {
+    return true;
+  }
+  return hasMutating;
+}
+function detectImplementHeavy(testee, derivedSteps = []) {
+  if (isImplementHeavyStep(testee))
+    return true;
+  if (!detectPipelineDriving(testee))
+    return false;
+  return derivedSteps.some((step) => isImplementHeavyStep(step));
+}
+function evaluateDogfoodGate(testee, options = {}) {
+  const maxRetryPresent = options.maxRetryPresent === true;
+  const steps = options.steps ?? [];
+  const pipelineDriving = detectPipelineDriving(testee);
+  const mutatingFix = hasMutatingFixMode(testee);
+  const implementHeavy = detectImplementHeavy(testee, steps);
+  if (pipelineDriving && !maxRetryPresent) {
+    return {
+      pipelineDriving,
+      mutatingFix,
+      maxRetryPresent,
+      implementHeavy,
+      refuse: true,
+      advisory: false,
+      message: PIPELINE_DRIVING_REFUSE_MESSAGE,
+      exitCode: 2
+    };
+  }
+  if (mutatingFix && !maxRetryPresent) {
+    return {
+      pipelineDriving,
+      mutatingFix,
+      maxRetryPresent,
+      implementHeavy,
+      refuse: true,
+      advisory: false,
+      message: MUTATING_FIX_REFUSE_MESSAGE,
+      exitCode: 2
+    };
+  }
+  if (implementHeavy) {
+    return {
+      pipelineDriving,
+      mutatingFix,
+      maxRetryPresent,
+      implementHeavy,
+      refuse: false,
+      advisory: true,
+      message: IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
+      exitCode: 0
+    };
+  }
+  return {
+    pipelineDriving,
+    mutatingFix,
+    maxRetryPresent,
+    implementHeavy,
+    refuse: false,
+    advisory: false,
+    message: null,
+    exitCode: 0
+  };
+}
+function parseCliArgs(argv) {
+  let testee = null;
+  let maxRetryPresent = false;
+  let steps = [];
+  let json = false;
+  let help = false;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") {
+      help = true;
+    } else if (a === "--json") {
+      json = true;
+    } else if (a === "--max-retry-present") {
+      maxRetryPresent = true;
+    } else if (a === "--testee") {
+      testee = argv[++i] ?? null;
+    } else if (a === "--steps") {
+      const raw = argv[++i] ?? "";
+      steps = raw.length === 0 ? [] : raw.split("||").map((s) => s.trim()).filter(Boolean);
+    } else if (a === "--") {
+      testee = argv.slice(i + 1).join(" ");
+      break;
+    } else if (!a.startsWith("-") && testee === null) {
+      testee = a;
+    }
+  }
+  return { testee, maxRetryPresent, steps, json, help };
+}
+var CLI_USAGE = `Usage:
+  bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \\
+    --testee "<testee string>" [--max-retry-present] [--steps "s1||s2"] [--json]
+
+Exit codes:
+  0  proceed (stdout may carry implement-heavy advisory)
+  2  refuse — pipeline-driving OR mutating --fix mode without --max-retry
+  1  usage error
+
+Phase 1.0: run BEFORE deriving steps (omit --steps).
+Phase 1 W8: re-run AFTER step derivation with --steps "label1||label2".`;
+function runCli(argv) {
+  const { testee, maxRetryPresent, steps, json, help } = parseCliArgs(argv);
+  if (help) {
+    return { exitCode: 0, stdout: "", stderr: CLI_USAGE };
+  }
+  if (testee === null || testee.length === 0) {
+    return { exitCode: 1, stdout: "", stderr: CLI_USAGE };
+  }
+  const result = evaluateDogfoodGate(testee, { maxRetryPresent, steps });
+  if (json) {
+    return { exitCode: result.exitCode, stdout: `${JSON.stringify(result, null, 2)}
+`, stderr: "" };
+  }
+  if (result.message) {
+    return { exitCode: result.exitCode, stdout: `${result.message}
+`, stderr: "" };
+  }
+  return { exitCode: result.exitCode, stdout: "", stderr: "" };
+}
+{
+  const { exitCode, stdout, stderr } = runCli(process.argv.slice(2));
+  if (stdout)
+    process.stdout.write(stdout);
+  if (stderr)
+    process.stderr.write(`${stderr}
+`);
+  process.exit(exitCode);
+}
+export {
+  runCli,
+  parseCliArgs,
+  isImplementHeavyStep,
+  hasMutatingFixMode,
+  evaluateDogfoodGate,
+  detectPipelineDriving,
+  detectImplementHeavy,
+  PIPELINE_TOKENS,
+  PIPELINE_DRIVING_REFUSE_MESSAGE,
+  MUTATING_FIX_REFUSE_MESSAGE,
+  IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
+  CLI_USAGE
+};

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts

@@ -356,7 +356,7 @@ export function runCli(argv: string[]): { exitCode: number; stdout: string; stde
 }
 
 if (import.meta.main) {
-    const { exitCode, stdout, stderr } = runCli(Bun.argv.slice(2));
+    const { exitCode, stdout, stderr } = runCli(process.argv.slice(2));
     if (stdout) process.stdout.write(stdout);
     if (stderr) process.stderr.write(`${stderr}\n`);
     process.exit(exitCode);

package/plugins/sp/scripts/dogfood-testing/validate-report.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// plugins/sp/scripts/dogfood-testing/validate-report.ts
+import { readFileSync } from "node:fs";
+var REQUIRED_SECTIONS = [1, 2, 3, 4, 5, 6];
+var CANONICAL_PROTOCOL = "sp:dogfood-testing@1.2";
+function countSectionHeadings(markdown, section) {
+  const re = new RegExp(`^### ${section}\\.`, "gm");
+  return (markdown.match(re) ?? []).length;
+}
+function countLedgerDataRows(markdown) {
+  const heading = markdown.match(/^### 3\. Monitor Ledger\s*$/m);
+  if (!heading || heading.index === undefined)
+    return null;
+  const after = markdown.slice(heading.index + heading[0].length);
+  const nextHeading = after.search(/^### /m);
+  const body = nextHeading === -1 ? after : after.slice(0, nextHeading);
+  const rows = body.split(`
+`).filter((line) => line.trim().startsWith("|")).filter((line) => !/^\|[\s:|-]+\|?\s*$/.test(line.trim())).filter((line) => !/^\|\s*drift:/.test(line.trim()));
+  return Math.max(rows.length - 1, 0);
+}
+function declaredExecutedSteps(markdown) {
+  const match = markdown.match(/\*\*Steps:\*\*\s*\d+\s+derived,\s*(\d+)\s+executed/);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+function validateReport(markdown) {
+  const errors = [];
+  if (!markdown.includes("── Dogfood Summary ──"))
+    errors.push("missing_footer");
+  if (!markdown.includes("[Live:"))
+    errors.push("missing_live_path");
+  if (!markdown.includes("[Report:"))
+    errors.push("missing_report_path");
+  for (const section of REQUIRED_SECTIONS) {
+    const count = countSectionHeadings(markdown, section);
+    if (count === 0)
+      errors.push(`missing_section:${section}`);
+    if (count > 1)
+      errors.push(`duplicate_section:${section}`);
+  }
+  if (!markdown.includes("#### Fixed") || !markdown.includes("#### Unresolved")) {
+    errors.push("missing_issues_subheads");
+  }
+  const protocolMatch = markdown.match(/^protocol:\s*(\S+)\s*$/m);
+  if (!protocolMatch || protocolMatch[1] !== CANONICAL_PROTOCOL) {
+    errors.push("protocol_string");
+  }
+  const executed = declaredExecutedSteps(markdown);
+  if (executed === null) {
+    errors.push("missing_steps_declared");
+  } else {
+    const rows = countLedgerDataRows(markdown);
+    if (rows === null || rows !== executed) {
+      errors.push("ledger_cardinality");
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}
+function parseValidateCliArgs(argv) {
+  let file = null;
+  let json = false;
+  let help = false;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h")
+      help = true;
+    else if (a === "--json")
+      json = true;
+    else if (a === "--file")
+      file = argv[++i] ?? null;
+    else if (!a.startsWith("-") && file === null)
+      file = a;
+  }
+  return { file, json, help };
+}
+var VALIDATE_CLI_USAGE = `Usage:
+  bun plugins/sp/scripts/dogfood-testing/validate-report.ts --file <report.md> [--json]
+
+Exit codes:
+  0  report validates clean (complete-report shape)
+  2  validation failed (errors on stdout / --json)
+  1  usage error
+
+Phase 4 finalize MUST run this before status: complete (task 0278 R6).
+On exit 2: set status: aborted and list error codes under #### Unresolved.`;
+function runValidateCli(argv, readFile) {
+  const { file, json, help } = parseValidateCliArgs(argv);
+  if (help)
+    return { exitCode: 0, stdout: "", stderr: VALIDATE_CLI_USAGE };
+  if (file === null || file.length === 0) {
+    return { exitCode: 1, stdout: "", stderr: VALIDATE_CLI_USAGE };
+  }
+  let markdown;
+  try {
+    markdown = readFile(file);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { exitCode: 1, stdout: "", stderr: `Failed to read ${file}: ${msg}` };
+  }
+  const result = validateReport(markdown);
+  if (json) {
+    return {
+      exitCode: result.ok ? 0 : 2,
+      stdout: `${JSON.stringify(result, null, 2)}
+`,
+      stderr: ""
+    };
+  }
+  if (result.ok) {
+    return { exitCode: 0, stdout: `ok
+`, stderr: "" };
+  }
+  return {
+    exitCode: 2,
+    stdout: `${result.errors.join(`
+`)}
+`,
+    stderr: ""
+  };
+}
+function mainCli(argv = process.argv.slice(2)) {
+  const { exitCode, stdout, stderr } = runValidateCli(argv, (p) => readFileSync(p, "utf8"));
+  if (stdout)
+    process.stdout.write(stdout);
+  if (stderr)
+    process.stderr.write(`${stderr}
+`);
+  return exitCode;
+}
+{
+  process.exit(mainCli());
+}
+export {
+  validateReport,
+  runValidateCli,
+  parseValidateCliArgs,
+  mainCli,
+  VALIDATE_CLI_USAGE
+};

package/plugins/sp/scripts/dogfood-testing/validate-report.ts

@@ -156,7 +156,7 @@ export function runValidateCli(
 }
 
 /** CLI entry for Phase 4 self-validate (import.meta.main). */
-export function mainCli(argv: string[] = Bun.argv.slice(2)): number {
+export function mainCli(argv: string[] = process.argv.slice(2)): number {
     const { exitCode, stdout, stderr } = runValidateCli(argv, (p) => readFileSync(p, 'utf8'));
     if (stdout) process.stdout.write(stdout);
     if (stderr) process.stderr.write(`${stderr}\n`);