@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/verify.js

@@ -27,74 +27,23 @@ import chalk from 'chalk';
 import { withSchema } from '../schema.js';
 import { findGitRoot } from '../utils/hooks.js';
 import { resolveAuthContext } from '../utils/auth.js';
-import { classifyHttpError, readWithRetries, SERVICE_SILENCE_LIMIT_MS, ServiceSilentError, transientReadFailure, } from '../utils/haystack-api.js';
+import { classifyHttpError, readWithRetries, SERVICE_SILENCE_LIMIT_MS, ServiceSilentError, transientReadFailure, repoApiPath, } from '../utils/haystack-api.js';
 import { GATEWAY_TIMEOUT_MS, gatewayFetch } from './case-batch.js';
 import { CRAWL_BRIEF_MAX_FUNCTIONS, CRAWL_BRIEF_MAX_GROUPS, CRAWL_BRIEF_MAX_PRODUCTION_ROWS, CRAWL_BUDGET_MAX_MS, CRAWL_BUDGET_MIN_MS, CRAWL_MAX_FINDINGS, CRAWL_MAX_FINDING_STEPS, CRAWL_MAX_IDEAS, CRAWL_MAX_STAND_IN_LINES, CRAWL_MAX_STAND_IN_ROWS, CRAWL_MAX_TEXT_CHARS, CRAWL_WAIT_MAX_MS, CRAWL_POOLS, } from './crawl-contract.js';
 import { captureCheckout, crawlUnavailableText, EXPLICIT_WALL_MS, normalModeFailure, postPrecomputeCapture, } from './verify-precompute.js';
+import { SPOT_WORDS, TERMINAL, VERDICT_WORDS, VERDICTS, currentStep, errorWords, headline, plural, reportedStatus, results, verifyReport, } from './crawl-report.js';
 import { formatOnboarding, onboardingExitCode, readOnboardingStatus, reportOnboardingState, reviewNotes, standInGapNotes, waitForOnboarding, } from './verify-onboarding.js';
 import { formatCapture, readPreVerifyCapture } from './capture-brief.js';
-const CRAWLS_PATH = '/api/agent/cloud-verifier/crawls';
 /** A held read (waitAfter): the service's hold, then the time any read gets. */
 const HELD_READ_TIMEOUT_MS = CRAWL_WAIT_MAX_MS + GATEWAY_TIMEOUT_MS;
 const RUN_ID = /^cv_[0-9a-f]{48}$/;
 const REPOSITORY_COMPONENT = /^[A-Za-z0-9_.-]{1,100}$/;
 const STATUSES = ['queued', 'preparing', 'crawling', 'draining', 'completed', 'prepared', 'incomplete', 'cancelled'];
-const TERMINAL = new Set(['completed', 'prepared', 'incomplete', 'cancelled']);
 const STAGES = ['reconcile', 'source', 'worlds', 'blast', 'knobs', 'prepare', 'crawl', 'publish', 'cleanup'];
 const ERROR_CODES = ['source-mismatch', 'blast-unavailable', 'world-build-failed',
     'prepare-failed', 'crawl-failed', 'no-capacity', 'stalled', 'lease-lost', 'cancelled'];
-const VERDICTS = ['bug', 'cant-tell', 'being-judged', 'not-a-bug'];
 const SPOT_STAGES = ['resolved', 'loaded', 'exposed', 'activated', 'pressed', 'observed', 'confirmed', 'judged'];
 const REUSE = ['hit', 'miss', null];
-const STATUS_WORDS = {
-    queued: 'waiting for a machine',
-    preparing: 'getting ready',
-    crawling: 'exploring the app',
-    draining: 'finishing the last checks',
-    completed: 'finished',
-    prepared: 'built and ready to check',
-    incomplete: 'stopped before finishing',
-    cancelled: 'cancelled',
-};
-const STAGE_WORDS = {
-    reconcile: 'cleaning up after an earlier try',
-    source: 'rebuilding your change',
-    worlds: 'building and starting the app with and without your change',
-    blast: 'waiting for the analysis of what your change touches',
-    knobs: "reading the app's settings",
-    prepare: 'setting up starting points next to your change',
-    crawl: 'exploring the app',
-    publish: 'saving the results',
-    cleanup: 'shutting down the machines it used',
-};
-const ERROR_WORDS = {
-    'source-mismatch': 'your change could not be rebuilt exactly as it was captured',
-    'blast-unavailable': 'the analysis of what your change touches was not available',
-    'world-build-failed': 'the app did not build or start, with or without your change',
-    'prepare-failed': 'setting up starting points next to your change failed',
-    'crawl-failed': 'exploring the app failed',
-    'no-capacity': 'there was no room on the machines for it',
-    stalled: 'it stopped making progress',
-    'lease-lost': 'the machine running it stopped responding',
-    cancelled: 'it was cancelled',
-};
-const SPOT_WORDS = {
-    resolved: 'never reached',
-    loaded: 'loaded but never ran',
-    exposed: 'shown on screen',
-    activated: 'ran',
-    pressed: 'ran when its control was pressed',
-    observed: 'a difference seen',
-    confirmed: 'a difference seen and confirmed',
-    // The stage, not the verdict: a judged difference may be judged not a bug. The findings carry the verdicts.
-    judged: 'a difference seen, confirmed and judged',
-};
-const VERDICT_WORDS = {
-    bug: 'Bug',
-    'cant-tell': "Can't tell",
-    'being-judged': 'Still being judged',
-    'not-a-bug': 'Not a bug',
-};
 /** A response the CLI will not print: malformed, contradictory, or another revision's. */
 export class CrawlResponseError extends Error {
     constructor(message) {
@@ -363,16 +312,15 @@ async function responseBody(response) {
 function read(path, token, waitAfter) {
     return waitAfter === undefined
         ? gatewayFetch(path, token)
-        : gatewayFetch(`${path}&waitAfter=${encodeURIComponent(waitAfter)}`, token, { method: 'GET', timeoutMs: HELD_READ_TIMEOUT_MS });
+        : gatewayFetch(`${path}${path.includes('?') ? '&' : '?'}waitAfter=${encodeURIComponent(waitAfter)}`, token, { method: 'GET', timeoutMs: HELD_READ_TIMEOUT_MS });
 }
 /** The caller's newest crawl of this capture's revision, or null. Its change
  * title may differ from the capture's (sameChange). */
 async function readCrawl(identity, token, waitAfter) {
-    const path = `${CRAWLS_PATH}?repository=${encodeURIComponent(identity.repository)}`
-        + `&workCommit=${encodeURIComponent(identity.workCommit)}`;
+    const path = repoApiPath(identity.repository, `/checks?commit=${encodeURIComponent(identity.workCommit)}`);
     const response = await read(path, token, waitAfter);
     if (!response.ok)
-        throw await classifyHttpError(response, `Haystack API ${CRAWLS_PATH}`);
+        throw await classifyHttpError(response, `Haystack API ${path}`);
     const body = await responseBody(response);
     if (!isRecord(body) || !Object.hasOwn(body, 'crawl'))
         invalid('no crawl field');
@@ -382,9 +330,10 @@ async function readCrawl(identity, token, waitAfter) {
 async function readCrawlRun(runId, identity, token, waitAfter) {
     if (!RUN_ID.test(runId))
         invalid('an acknowledged run id');
-    const response = await read(`${CRAWLS_PATH}/${runId}?repository=${encodeURIComponent(identity.repository)}`, token, waitAfter);
+    const path = repoApiPath(identity.repository, `/checks/${runId}`);
+    const response = await read(path, token, waitAfter);
     if (!response.ok)
-        throw await classifyHttpError(response, `Haystack API ${CRAWLS_PATH}/${runId}`);
+        throw await classifyHttpError(response, `Haystack API ${path}`);
     const view = parseCrawlView(await responseBody(response), identity);
     if (view.runId !== runId || !sameChange(view, identity)) {
         throw new CrawlResponseError(`The crawl service returned another crawl for ${runId}; it is not shown.`);
@@ -397,52 +346,6 @@ function safe(value) {
     // eslint-disable-next-line no-control-regex -- replacing control characters is the point
     return value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ');
 }
-function plural(count, noun) {
-    return `${count} ${noun}${count === 1 ? '' : 's'}`;
-}
-function errorWords(error) {
-    return error.code === 'stalled'
-        ? `${ERROR_WORDS.stalled} while ${STAGE_WORDS[error.stage]}`
-        : ERROR_WORDS[error.code];
-}
-/** What a running crawl is doing now: its stage, except while it waits for a
- * machine or finishes its last checks, which its status says better. */
-function currentStep(view) {
-    return view.status === 'queued' || view.status === 'draining' ? STATUS_WORDS[view.status] : STAGE_WORDS[view.stage];
-}
-/** The crawl's results: its sealed manifest, else (amendment 9) its answer at the budget, which has the same findings and reach. */
-function results(view) {
-    return view.manifest ?? (view.answer?.status === 'answered' ? view.answer : null);
-}
-/** The status the command reports: a running crawl that has answered (amendment 9: its budget is up and its work is
- * done; only its shutdown remains) reads as completed. */
-function reportedStatus(view) {
-    return !TERMINAL.has(view.status) && view.answer?.status === 'answered' ? 'completed' : view.status;
-}
-function headline(view) {
-    const bugs = results(view)?.bugs ?? view.totals.bugs;
-    const found = bugs > 0 ? ` It found ${plural(bugs, 'bug')} before it stopped.` : '';
-    switch (reportedStatus(view)) {
-        case 'completed':
-            return bugs > 0 ? `Found ${plural(bugs, 'bug')} in your change.` : 'No bugs found in your change.';
-        case 'incomplete': {
-            const error = results(view)?.error ?? view.error;
-            return `The crawl could not finish: ${error ? errorWords(error) : 'no reason was recorded'}.${found}`;
-        }
-        case 'prepared':
-            // Amendment 12: the turn-end hook built and froze this change; `haystack verify` asks for the crawl itself.
-            return 'Your change is built and ready to check, but was not crawled yet. Run `haystack verify` to check it.';
-        case 'cancelled':
-            return `The crawl was cancelled.${found}`;
-        default: {
-            const so = bugs > 0 ? ` ${plural(bugs, 'bug')} found so far.` : '';
-            if (view.cancelRequested) {
-                return `Being cancelled: ${currentStep(view)}.${so}`;
-            }
-            return `Still running: ${currentStep(view)}.${so}`;
-        }
-    }
-}
 function spotLines(spot) {
     const how = spot.furthest === null ? 'never reached' : SPOT_WORDS[spot.furthest];
     const found = spot.findingIds.length === 0 ? ''
@@ -560,6 +463,7 @@ export function formatCrawl(view) {
  * 2 ended without finishing (incomplete, cancelled) or finished with cleanup
  * unproven (an answered crawl has not finished its cleanup, so it is not judged); bugs
  * found never change it. The command's own failures exit 1 elsewhere. */
+export { verifyReport };
 export function crawlExitCode(view) {
     const status = reportedStatus(view);
     if (!TERMINAL.has(status))
@@ -791,9 +695,9 @@ function checkedLine(change) {
 }
 /** Prints the onboarding (and nothing else) as the command's answer: `--json`
  * carries OnboardingStatusV1. A block exits 3: its ask says what to do. */
-function finishWithOnboarding(status, json, change) {
-    if (json)
-        process.stdout.write(`${JSON.stringify(withSchema('verify', { change, onboarding: status, crawl: null }), null, 2)}\n`);
+function finishWithOnboarding(status, options, change) {
+    if (options.json || options.raw)
+        printVerifyJson(options, change, status, null);
     else
         console.log(formatOnboarding(status));
     process.exitCode = onboardingExitCode(status);
@@ -997,7 +901,7 @@ export async function preVerifyCommand(options) {
     if (options.wait !== false && briefOf(view) === null && !TERMINAL.has(reportedStatus(view)))
         view = await waitForBrief(view, identity, auth.token);
     const brief = briefOf(view);
-    // CAPTURE-V1 rule 7b: the routes the change touches, with their share of captured sessions; null without capture set up.
+    // CAPTURE-V1 rule 7b: the routes the change touches, with their share of captured sessions, per app; null without capture set up.
     const captured = await readPreVerifyCapture(findGitRoot(), identity.repository, auth.token, [...new Set([...(brief?.functions.map(fn => fn.file) ?? []), ...change.files])], new Date());
     if (options.json)
         finish(onboarding, view, captured);
@@ -1014,13 +918,22 @@ export async function preVerifyCommand(options) {
                 : view.status === 'completed' ? 'It was checked before briefs existed and is not run again: change anything in the checkout and run `haystack pre-verify` again.'
                     : 'Run `haystack pre-verify` again to prepare it again.'));
     if (!options.json && captured !== null)
-        console.log(`\n${formatCapture(captured)}`);
+        for (const section of captured)
+            console.log(`\n${formatCapture(section)}`);
     if (brief === null && TERMINAL.has(reportedStatus(view)))
         process.exitCode = 2;
 }
+/** verify's one JSON document: the report (`--json`) or the service's whole record (`--raw`). */
+function printVerifyJson(options, change, onboarding, view) {
+    const document = options.raw
+        ? withSchema('verify-raw', { change, onboarding, crawl: view })
+        : withSchema('verify', { change, onboarding, crawl: view === null ? null : verifyReport(view) });
+    process.stdout.write(`${JSON.stringify(document, null, 2)}\n`);
+}
 export async function verifyCommand(options) {
+    const json = options.json || options.raw;
     // In --json mode stdout carries the one document; every other line goes to stderr.
-    const note = (line) => { if (options.json)
+    const note = (line) => { if (json)
         console.error(line);
     else
         console.log(line); };
@@ -1030,8 +943,8 @@ export async function verifyCommand(options) {
     const change = checkedChange(request.baseCommit, request.workCommit);
     if (!request.crawl) {
         note(`Nothing to verify: this checkout has no changes against ${request.baseCommit.slice(0, 12)}.`);
-        if (options.json)
-            process.stdout.write(`${JSON.stringify(withSchema('verify', { change, onboarding: null, crawl: null }), null, 2)}\n`);
+        if (json)
+            printVerifyJson(options, change, null, null);
         return;
     }
     note(checkedLine(change));
@@ -1065,7 +978,7 @@ export async function verifyCommand(options) {
                 reportOnboardingState(onboarding);
             }
             if (onboarding.state !== 'ready') {
-                finishWithOnboarding(onboarding, options.json, change);
+                finishWithOnboarding(onboarding, options, change);
                 return;
             }
             // Ready: the service admitted the waiting crawl when the record published; this
@@ -1075,8 +988,8 @@ export async function verifyCommand(options) {
             note(submitted.line);
         }
         if (submitted.runId === null) {
-            if (options.json)
-                process.stdout.write(`${JSON.stringify(withSchema('verify', { change, onboarding, crawl: null }), null, 2)}\n`);
+            if (json)
+                printVerifyJson(options, change, onboarding, null);
             process.exitCode = 1;
             return;
         }
@@ -1089,8 +1002,8 @@ export async function verifyCommand(options) {
     if (options.wait !== false && !TERMINAL.has(reportedStatus(view))) {
         view = await waitForCrawl(view, identity, auth.token);
     }
-    if (options.json)
-        process.stdout.write(`${JSON.stringify(withSchema('verify', { change, onboarding, crawl: view }), null, 2)}\n`);
+    if (json)
+        printVerifyJson(options, change, onboarding, view);
     else {
         console.log(formatCrawl(view));
         const notes = [...(onboarding?.dataAbsences ?? []), ...(onboarding?.versionChoices ?? []), ...(onboarding?.standIns ?? []),