@gobing-ai/spur 0.4.2 → 0.4.3

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

@@ -11,9 +11,31 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { getEnvVar, getEnvVars } from '../../lib/env';
+import { loadInlineApp, resolveAppEntry } from '../../lib/inline-run-app';
 
-import { logger } from './logger';
+// ─── In-script logger ────────────────────────────────────────────────────────
+
+// The former `logger.ts` helper exposed a file channel nothing ever implemented, so the used part
+// — a console toggle the tests need — lives here instead of a one-caller module (task 1173, plan P7).
+let consoleEnabled = true;
+
+/** Silence or restore this script's console output (test hook). */
+export function enableLogger(consoleOn: boolean): void {
+    consoleEnabled = consoleOn;
+}
+
+function logAt(stream: 'log' | 'warn' | 'error', message: string): void {
+    if (!consoleEnabled) return;
+    console[stream](message);
+}
+
+const logger = {
+    info: (message: string): void => logAt('log', message),
+    warn: (message: string): void => logAt('warn', message),
+    error: (message: string): void => logAt('error', message),
+};
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -287,113 +309,85 @@ export async function getCcusageData(date: string): Promise<CcusageData | null>
 
 // ─── Spur History Health Integration ──────────────────────────────────────────
 
+/** The day's raw history health read back across the generated inline app entry (task 1178 R3). */
+interface HistoryHealthReading {
+    toolCalls: number;
+    toolErrors: number;
+    errorRatePct: number;
+    loops: Array<{
+        toolName: string;
+        argsDigest: string;
+        repeats: number;
+        sessionId: string;
+        firstSeq: number;
+        lastSeq: number;
+        startedAt: string | null;
+    }>;
+}
+
+/** The generated inline app entry's history-health export. */
+interface InlineHistoryApp {
+    readHistoryHealth(input: { date: string; dbPath: string }): Promise<HistoryHealthReading | null>;
+}
+
+/**
+ * Compose the daily report's health summary from the app reading. `wastedTokens` stays an
+ * explicit `repeats * 250` estimate; remediation proposals stay plain text (task 1178 R3).
+ */
+function composeHistoryHealth(reading: HistoryHealthReading): HistoryHealthSummary {
+    const loops: HistoryLoopFinding[] = reading.loops.map((row) => ({
+        toolName: row.toolName,
+        argsDigest: row.argsDigest || 'repeated execution',
+        repeats: row.repeats,
+        sessionId: row.sessionId,
+        fromSeq: row.firstSeq,
+        toSeq: row.lastSeq,
+        wastedTokens: row.repeats * 250,
+    }));
+
+    const remediationProposals: Array<{ key: string; title: string; command: string }> = [];
+    for (const lp of loops.slice(0, 5)) {
+        const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
+        const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
+        const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
+        remediationProposals.push({ key, title, command });
+    }
+    if (reading.toolCalls > 0 && reading.errorRatePct > 10) {
+        remediationProposals.push({
+            key: 'reliability:tooling:high-error-rate',
+            title: `Investigate high tool error rate (${reading.errorRatePct.toFixed(1)}%)`,
+            command: `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`,
+        });
+    }
+
+    return {
+        toolCalls: reading.toolCalls,
+        toolErrors: reading.toolErrors,
+        errorRatePct: reading.errorRatePct,
+        loops,
+        redundantCalls: loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0),
+        wastedTokens: loops.reduce((acc, l) => acc + l.wastedTokens, 0),
+        remediationProposals,
+    };
+}
+
+/**
+ * Read the day's history health through the app owner (task 1178 R3): this adapter opens no
+ * SQLite and carries no SQL. A missing database file or required table returns `null`
+ * (unavailable); an existing empty table returns a measured-zero summary, never `n/a`.
+ */
 export async function getSpurHistoryHealth(
     date: string,
     dbPath = '.spur/spur.db',
 ): Promise<HistoryHealthSummary | null> {
     try {
         const resolvedPath = resolve(process.cwd(), dbPath);
-        if (!existsSync(resolvedPath)) {
-            return null;
-        }
-
-        const { Database } = await import('bun:sqlite');
-        const db = new Database(resolvedPath, { readonly: true });
-
-        try {
-            // 1. Query execution loop findings
-            const loopTable = db
-                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-                .get('history_board_loop_findings');
-
-            let loops: HistoryLoopFinding[] = [];
-            if (loopTable) {
-                const rows = db
-                    .query<
-                        {
-                            tool_name: string;
-                            args_digest: string;
-                            repeats: number;
-                            session_id: string;
-                            first_seq: number;
-                            last_seq: number;
-                            started_at: string | null;
-                        },
-                        [string]
-                    >(
-                        `SELECT tool_name, args_digest, repeats, session_id, first_seq, last_seq, started_at
-                         FROM history_board_loop_findings
-                         WHERE started_at IS NULL OR started_at LIKE ?
-                         ORDER BY repeats DESC
-                         LIMIT 20`,
-                    )
-                    .all(`${date}%`);
-
-                loops = rows.map((r) => ({
-                    toolName: r.tool_name,
-                    argsDigest: r.args_digest || 'repeated execution',
-                    repeats: r.repeats,
-                    sessionId: r.session_id,
-                    fromSeq: r.first_seq,
-                    toSeq: r.last_seq,
-                    wastedTokens: r.repeats * 250,
-                }));
-            }
-
-            // 2. Query tool calls and errors
-            let toolCalls = 0;
-            let toolErrors = 0;
-            const toolTable = db
-                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-                .get('history_board_tool_5m');
-
-            if (toolTable) {
-                const stats = db
-                    .query<{ calls: number | null; errors: number | null }, [string]>(
-                        `SELECT SUM(calls) AS calls, SUM(errors) AS errors
-                         FROM history_board_tool_5m
-                         WHERE bucket_start LIKE ?`,
-                    )
-                    .get(`${date}%`);
-
-                toolCalls = stats?.calls ?? 0;
-                toolErrors = stats?.errors ?? 0;
-            }
-
-            const redundantCalls = loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0);
-            const wastedTokens = loops.reduce((acc, l) => acc + l.wastedTokens, 0);
-            const errorRatePct = toolCalls > 0 ? (toolErrors / toolCalls) * 100 : 0;
-
-            // 3. Generate auto-healing remediation proposals
-            const remediationProposals: Array<{ key: string; title: string; command: string }> = [];
-
-            for (const lp of loops.slice(0, 5)) {
-                const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, '_');
-                const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
-                const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
-                const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
-                remediationProposals.push({ key, title, command });
-            }
-
-            if (toolCalls > 0 && errorRatePct > 10) {
-                const key = 'reliability:tooling:high-error-rate';
-                const title = `Investigate high tool error rate (${errorRatePct.toFixed(1)}%)`;
-                const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
-                remediationProposals.push({ key, title, command });
-            }
-
-            return {
-                toolCalls,
-                toolErrors,
-                errorRatePct,
-                loops,
-                redundantCalls,
-                wastedTokens,
-                remediationProposals,
-            };
-        } finally {
-            db.close();
-        }
+        const { app } = await loadInlineApp<InlineHistoryApp>(getEnvVar('SPUR_BIN') ?? '', resolveAppEntry, [
+            'readHistoryHealth',
+        ]);
+        const reading = await app.readHistoryHealth({ date, dbPath: resolvedPath });
+        return reading === null ? null : composeHistoryHealth(reading);
     } catch {
         return null;
     }
@@ -795,9 +789,11 @@ export async function buildDailySummary(options: CliOptions): Promise<DailySumma
         result.gitActivity = gitActivity;
     }
 
-    // Query Spur history health (loops, tool errors, and auto-healing proposals)
+    // Query Spur history health (loops, tool errors, and auto-healing proposals). A measured
+    // empty day is a real zero and keeps its "Clean" section; an unavailable database (missing
+    // file/table) stays absent — absence and zero never collapse (task 1178 R3).
     const historyHealth = await getSpurHistoryHealth(options.date);
-    if (historyHealth && (historyHealth.loops.length > 0 || historyHealth.toolCalls > 0)) {
+    if (historyHealth) {
         result.historyHealth = historyHealth;
         platforms.push('Spur History');
     }
@@ -806,6 +802,17 @@ export async function buildDailySummary(options: CliOptions): Promise<DailySumma
 }
 
 export async function main(): Promise<void> {
+    // The generated app entry read by getSpurHistoryHealth needs Bun (SQLite); the installed
+    // `.mjs` twin may be launched with plain node, so re-enter Bun before any app import.
+    // Without Bun on PATH, keep running under node: the history reader degrades to unavailable
+    // (n/a) instead of failing the whole report (task 1178 review P4).
+    if (!process.versions.bun) {
+        const child = spawnSync('bun', [fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
+            stdio: 'inherit',
+        });
+        if (!child.error) process.exit(child.status ?? 1);
+        console.error(`daily-summary: Bun not on PATH (${child.error.message}); history health unavailable`);
+    }
     const options = parseArgs();
 
     logger.info(`Generating daily summary for ${options.date}...`);

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

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
+// plugins/sp/lib/dogfood-pipeline.ts
 var PIPELINE_TOKENS = [
   "--next",
   "dev-runall",
@@ -125,6 +125,7 @@ function evaluateDogfoodGate(testee, options = {}) {
     exitCode: 0
   };
 }
+// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
 function parseCliArgs(argv) {
   let testee = null;
   let maxRetryPresent = false;

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

@@ -1,12 +1,10 @@
 /**
- * detect-pipeline-driving — @1.2 pipeline-driving testee detector (task 0277, W7).
+ * detect-pipeline-driving — live Phase 1.0 CLI gate over the @1.2 detector (task 0277 W7).
  *
- * Pure function over the raw testee string → boolean. Used by the dogfood driver
- * (Phase 1.0 refuse-ambiguous gate) and by unit tests so the matcher contract is
- * machine-checked rather than agent-interpreted.
- *
- * Also ships a **CLI gate** (import.meta.main) so Phase 1.0 is a live shell call,
- * not agent-only prose interpretation:
+ * The detector and its policy helpers are application-owned in
+ * `plugins/sp/lib/dogfood-pipeline.ts` (task 1173); this script keeps the shell entry the dogfood
+ * driver calls, with argv, usage, exit codes and refusal messages unchanged. Callers and tests may
+ * keep importing this path — every former export is re-exported.
  *
  *   bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \
  *     --testee "/sp:dev-run 0125 --auto --next" [--max-retry-present] \
@@ -16,267 +14,11 @@
  *   0 — proceed (may print implement-heavy advisory on stderr)
  *   2 — refuse: pipeline-driving without explicit --max-retry
  *   1 — usage / argument error
- *
- * Contract (0274 §3 dogfood-pipeline-detect, 0277 R1):
- *   - Word-boundary matchers with `-` treated as a word char (NOT a boundary).
- *     A token counts only when it is a distinct hyphen-word, not when it is a
- *     substring of a longer alphanumeric or hyphen run. This removes the
- *     leading-space dependency of the @1.1 prose detector.
- *   - Two token shapes, both with strict `[^\w-]` boundaries:
- *       (a) complete tokens — `--next`, `dev-run`, `dev-runall`, `dev-wrap`,
- *           `dev-wrapall`, `dev-idea` — matched as whole hyphen-words so the
- *           slash form `/sp:dev-run` matches on its `dev-run` tail whether or
- *           not it is preceded by a space, but `--next` does NOT match inside
- *           `--next-gen` (the trailing `-gen` breaks the boundary).
- *       (b) bare nouns — `run`, `runall`, `wrap`, `wrapall`, `idea` — matched
- *           only as standalone words, so `run` matches in
- *           `bun ... task run 0042` but NOT inside `runaway`/`prerun`, and
- *           `idea` does NOT match inside `idealist`/`ideal`.
- *   - Listing both shapes is what makes the detector leading-space invariant
- *     (the slash form is caught by its `dev-*` tail; the bare noun is caught
- *     when it appears as its own word) without letting `run` leak into every
- *     `-run-` identifier.
- *
- * Non-goals of detectPipelineDriving: decides ambiguity only. It does NOT decide
- * observe vs fix — any explicit `--max-retry` value proceeds regardless.
- * Implement-heavy advisory is a separate helper (detectImplementHeavy).
- */
-
-/**
- * Tokens whose presence makes a testee pipeline-driving. Ordered for stable
- * diagnostics. Two shapes per the contract above: complete `dev-*` / `--next`
- * tokens first, then bare nouns.
- */
-const PIPELINE_TOKENS = [
-    '--next',
-    'dev-runall',
-    'dev-wrapall',
-    'dev-refineall',
-    'dev-verifyall',
-    'dev-run',
-    'dev-wrap',
-    'dev-idea',
-    'refineall',
-    'verifyall',
-    'runall',
-    'wrapall',
-    'run',
-    'wrap',
-    'idea',
-] as const;
-
-/** Refuse message when pipeline-driving and `--max-retry` was not passed (exact string). */
-export const PIPELINE_DRIVING_REFUSE_MESSAGE =
-    '⚠ pipeline-driving testee detected; pass --max-retry 0 (observe-only) or --max-retry N (fix mode, tree mutation acknowledged)';
-
-/**
- * Refuse message when the testee carries a mutating `--fix` mode (`--fix all` /
- * `--fix blockers-first`) and `--max-retry` was not passed. A mutating fix mode
- * mutates the working tree independent of pipeline-driving (task 0293 R1/R2):
- * `--max-retry 0` bounds the **driver** only — the testee's own `--fix` pass
- * still mutates the tree — so the message must not imply otherwise.
- */
-export const 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)';
-
-/** Advisory when pipeline-driving + implement-heavy derived steps (exact string). */
-export const IMPLEMENT_HEAVY_ADVISORY_MESSAGE =
-    '⚠ implement-heavy pipeline dogfood: prefer --max-retry 0 (observe-only) or step-split; operator --max-retry N overrides';
-
-/**
- * Tokens that mark a derived step as implement-heavy (mutates product/code or
- * drives a mutating pipeline leg). Deliberately excludes verify/review/unit-only
- * surfaces even when they carry `--next`.
- */
-const IMPLEMENT_HEAVY_TOKENS = [
-    'dev-runall',
-    'dev-wrapall',
-    'dev-run',
-    'dev-wrap',
-    'dev-idea',
-    'runall',
-    'wrapall',
-    // bare `run` / `wrap` / `idea` — only when not clearly a non-mutating surface
-    'run',
-    'wrap',
-    'idea',
-    'implement',
-] as const;
-
-/**
- * A verify/review surface stops being non-mutating the moment it carries a
- * repair mode: `--fix all` / `--fix blockers-first` applies Edit/Write repairs
- * to the working tree (0280 dogfood, finding P2). `--fix none` stays
- * observational. Boundary-guarded so `--prefix all` / `--focus all` never match.
- * Exported so the Phase 1.0 gate and tests share one matcher (task 0293 R1/R4).
- */
-export function hasMutatingFixMode(step: string): boolean {
-    return /(?<![\w-])--fix[=\s]+(all|blockers-first)(?![\w-])/i.test(step);
-}
-
-/**
- * Match a token at a word boundary. A "word boundary" here is the position
- * between a non-`[\w-]` char (or string start) and the token, and between the
- * token and a non-`[\w-]` char (or string end). Treating `-` as a word char
- * is what makes `--next` reject `--next-gen` and `dev-run` reject `dev-runner`.
- */
-function tokenMatches(testee: string, token: string): boolean {
-    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    // (?<![\w-]) — not preceded by a word char or hyphen.
-    // (?![\w-])  — not followed by a word char or hyphen.
-    const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, 'i');
-    return re.test(testee);
-}
-
-/**
- * Returns whether the testee string is pipeline-driving (contains any of the
- * pipeline-driving tokens as a distinct hyphen-word). Machine-checked
- * counterpart of the prose list in SKILL.md §Pipeline-driving detection and
- * dev-dogfood.md.
- */
-export function detectPipelineDriving(testee: string): boolean {
-    if (typeof testee !== 'string' || testee.length === 0) {
-        return false;
-    }
-    return PIPELINE_TOKENS.some((token) => tokenMatches(testee, token));
-}
-
-/**
- * True when a single step label (or the whole testee) is implement-heavy —
- * it chains into real implementation / wrap / idea work, not verify-only.
- *
- * Non-mutating surfaces (`dev-verify`, `dev-review`, `dev-unit`, plain
- * `dev-refine` without a further run) are never implement-heavy even if
- * pipeline-driving via `--next` — UNLESS they carry a mutating repair mode
- * (`--fix all` / `--fix blockers-first`), which turns the verify/review leg
- * into a tree-mutating fix pass (0280 dogfood, finding P2).
- */
-export function isImplementHeavyStep(step: string): boolean {
-    if (typeof step !== 'string' || step.length === 0) return false;
-    // Explicit non-mutating surfaces win unless a mutating token co-occurs.
-    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;
-    // refine alone is planning, not implement-heavy; refine+run/--next chain is.
-    if (tokenMatches(step, 'dev-refine') && !hasMutating && !tokenMatches(step, '--next')) {
-        return false;
-    }
-    if (tokenMatches(step, 'dev-refine') && tokenMatches(step, '--next')) {
-        // refine --next chains into run → implement-heavy
-        return true;
-    }
-    return hasMutating;
-}
-
-/**
- * True when the testee is implement-heavy: it carries a pipeline-driving token,
- * a mutating `--fix` mode, OR at least one derived step (or the testee itself
- * when no steps given) is implement-heavy. Used for the W8 Phase 1 advisory
- * after step derivation.
- *
- * Task 0293 R3: a mutating `--fix` mode alone is implement-heavy even with no
- * pipeline token — the verify/review leg itself becomes a tree-mutating fix
- * pass.
- */
-export function detectImplementHeavy(testee: string, derivedSteps: string[] = []): boolean {
-    if (isImplementHeavyStep(testee)) return true;
-    if (!detectPipelineDriving(testee)) return false;
-    return derivedSteps.some((step) => isImplementHeavyStep(step));
-}
-
-export interface GateResult {
-    pipelineDriving: boolean;
-    mutatingFix: boolean;
-    maxRetryPresent: boolean;
-    implementHeavy: boolean;
-    refuse: boolean;
-    advisory: boolean;
-    message: string | null;
-    exitCode: 0 | 1 | 2;
-}
-
-/**
- * Phase 1.0 + W8 gate decision. Pure — no I/O. The CLI wrapper prints and exits.
- *
- * Refuse condition (task 0293 R1) is the union of two **independent** mutation
- * sources, each gated on `!maxRetryPresent`:
- *
- *   1. pipeline-driving testee (`--next`, `dev-run`, …) — refuses because the
- *      testee chains lifecycle legs whose cumulative blast radius the driver
- *      cannot pre-attribute.
- *   2. mutating `--fix` mode (`--fix all` / `--fix blockers-first`) — refuses
- *      because the testee itself applies Edit/Write repairs even with no
- *      pipeline token. `--max-retry 0` bounds the **driver** only; the testee
- *      still mutates (honesty note in MUTATING_FIX_REFUSE_MESSAGE).
- *
- * Pipeline-driving is reported first when both co-occur (its refuse message is
- * the superset — chain + tree mutation).
  */
-export function evaluateDogfoodGate(
-    testee: string,
-    options: { maxRetryPresent?: boolean; steps?: string[] } = {},
-): GateResult {
-    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,
-    };
-}
 
-export { PIPELINE_TOKENS };
+import { evaluateDogfoodGate } from '../../lib/dogfood-pipeline';
 
-// ── CLI entry (live Phase 1.0 gate) ──────────────────────────────────────────
+export * from '../../lib/dogfood-pipeline';
 
 export interface CliArgs {
     testee: string | null;

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

@@ -4,6 +4,8 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // plugins/sp/scripts/dogfood-testing/validate-report.ts
 import { readFileSync } from "node:fs";
+
+// plugins/sp/lib/dogfood-report.ts
 var REQUIRED_SECTIONS = [1, 2, 3, 4, 5, 6];
 var CANONICAL_PROTOCOL = "sp:dogfood-testing@1.2";
 function countSectionHeadings(markdown, section) {
@@ -188,6 +190,7 @@ function validateReport(markdown) {
   validateCostEvidence(markdown, errors);
   return { ok: errors.length === 0, errors };
 }
+// plugins/sp/scripts/dogfood-testing/validate-report.ts
 function parseValidateCliArgs(argv) {
   let file = null;
   let json = false;