@haystackeditor/cli 0.15.31 → 0.16.0

package/dist/commands/verify.js

@@ -1,152 +1,64 @@
-import { readFile } from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-import { resolve } from 'node:path';
-import chalk from 'chalk';
-import { setVerifyToken, verifyAuthHeaders } from './verify-core.js';
-const DEFAULT_CONTROL_PLANE = 'http://127.0.0.1:3000';
-export const VERIFY_SPECIMENS = new Set(['all', 'posthog-js-478', 'analytics-js-255']);
-export function parseStartRunResponse(raw) {
-    let parsed;
+import { execFileSync } from 'node:child_process';
+import { parseHostedRepository, verifyHostedStartCommand } from './verify-hosted.js';
+function git(args, message) {
     try {
-        parsed = JSON.parse(raw);
+        return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
     }
     catch {
-        throw new Error('Verifier returned an invalid JSON response.');
+        throw new Error(message);
     }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('Verifier returned an invalid response object.');
-    }
-    const response = parsed;
-    const requiredString = (field) => {
-        const value = response[field];
-        if (typeof value !== 'string' || value.trim() === '') {
-            throw new Error(`Verifier response is missing a valid ${field}.`);
-        }
-        return value;
-    };
-    return {
-        runId: requiredString('runId'),
-        status: requiredString('status'),
-        resultsUrl: requiredString('resultsUrl'),
-    };
 }
-export function verifierErrorReason(raw, contentType) {
-    if (!contentType?.toLowerCase().includes('application/json'))
-        return raw;
-    let parsed;
+function originRepository() {
+    const remote = git(['remote', 'get-url', 'origin'], 'Could not read origin; pass --repo owner/repo.');
+    let path;
     try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        return `malformed JSON error response (${error instanceof Error ? error.message : String(error)}); raw body: ${raw}`;
-    }
-    if (parsed
-        && typeof parsed === 'object'
-        && !Array.isArray(parsed)
-        && typeof parsed.error === 'string'
-        && parsed.error.trim() !== '') {
-        return parsed.error;
-    }
-    return `JSON error response omitted a string error; raw body: ${raw}`;
-}
-function openResults(url) {
-    const platform = process.platform;
-    const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
-    const args = platform === 'win32' ? ['/c', 'start', '', url] : [url];
-    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
-    child.unref();
-}
-async function readIntentTranscript(path) {
-    if (!path)
-        return undefined;
-    const absolutePath = resolve(path);
-    try {
-        return await readFile(absolutePath, 'utf8');
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Could not read intent transcript at ${absolutePath}: ${message}`);
-    }
-}
-export async function startVerificationRun(specimenArg, options) {
-    const specimen = specimenArg || 'all';
-    if (!VERIFY_SPECIMENS.has(specimen)) {
-        throw new Error(`Unknown or unreproduced specimen "${specimen}". Choose all, posthog-js-478, or analytics-js-255.`);
+        path = remote.includes('://')
+            ? new URL(remote).pathname.replace(/^\//, '')
+            : remote.match(/^[^@/]+@[^:]+:(.+)$/)?.[1] ?? '';
+        return parseHostedRepository(path.replace(/\.git$/, '')).fullName;
     }
-    setVerifyToken(options.token);
-    const server = (options.server || process.env.HAYSTACK_VERIFY_SERVER || DEFAULT_CONTROL_PLANE)
-        .replace(/\/+$/, '');
-    const intentTranscript = await readIntentTranscript(options.intentTranscript);
-    let response;
-    try {
-        response = await fetch(`${server}/api/cloud-verifier/runs`, {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', ...verifyAuthHeaders() },
-            body: JSON.stringify({
-                specimen,
-                repoPath: options.repo ? resolve(options.repo) : undefined,
-                baseRef: options.base,
-                headRef: options.head,
-                intentTranscript,
-                planSourceRunId: options.planSourceRunId,
-            }),
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Could not reach the Haystack verifier at ${server}. Start the demo control plane with \`pnpm dev\` and retry. ${message}`);
-    }
-    const raw = await response.text();
-    if (response.status === 401) {
-        throw new Error(`Control plane at ${server} requires a token (HTTP 401). Pass --token or set HAYSTACK_VERIFY_TOKEN.`);
-    }
-    if (!response.ok) {
-        const reason = verifierErrorReason(raw, response.headers.get('content-type'));
-        throw new Error(`Verifier rejected the run (${response.status}): ${reason}`);
+    catch {
+        throw new Error('Could not determine owner/repo from origin; pass --repo owner/repo.');
     }
-    return parseStartRunResponse(raw);
 }
-export async function verifyCommand(specimenArg, options) {
-    if (specimenArg === undefined && (options.repo !== undefined || options.base !== undefined || options.head !== undefined)) {
-        if (!options.repo || !options.base || !options.head) {
-            throw new Error('Repository verification requires --repo owner/repo, --base <ref>, and --head <ref>.');
+export function resolveVerifyRepository(options) {
+    const repo = options.repo ?? originRepository();
+    let head = options.head;
+    if (head === undefined) {
+        head = git(['rev-parse', '--verify', 'HEAD^{commit}'], 'Could not read HEAD; run inside a git checkout or pass --head.');
+        // The fleet fetches from the GitHub origin, so only origin's branches
+        // prove the commit is reachable there; another remote does not.
+        const originBranches = git(['for-each-ref', '--format=%(refname)', '--contains', head, 'refs/remotes/origin/'], 'Could not check origin branches for HEAD.');
+        if (!originBranches)
+            throw new Error('Push HEAD to origin before running haystack verify.');
+    }
+    let base = options.base;
+    if (base === undefined) {
+        let defaultBranch = 'origin/main';
+        try {
+            defaultBranch = git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], 'Could not read origin/HEAD.');
         }
-        if (options.intentTranscript !== undefined) {
-            throw new Error('Repository verification accepts optional --intent-file JSON with problem, goal, and intended_outcomes.');
+        catch {
+            // Repositories without origin/HEAD use origin/main.
         }
-        const { verifyHostedStartCommand } = await import('./verify-hosted.js');
-        await verifyHostedStartCommand(options.repo, {
-            provider: 'haystack',
-            base: options.base,
-            head: options.head,
-            intentFile: options.intentFile,
-            idempotencyKey: options.idempotencyKey,
-            account: options.account,
-            wait: options.wait,
-            interval: options.interval,
-            timeout: options.timeout,
-            json: options.json,
-        });
-        return;
-    }
-    if (!options.json) {
-        console.error(chalk.dim('Preparing the cloud verification run…'));
-    }
-    const started = await startVerificationRun(specimenArg, options);
-    if (options.json) {
-        process.stdout.write(`${JSON.stringify({
-            schema_version: '1.0.0',
-            run_id: started.runId,
-            status: started.status,
-            results_url: started.resultsUrl,
-        }, null, 2)}\n`);
-    }
-    else {
-        console.log('');
-        console.log(`${chalk.green('✓')} Verification started: ${chalk.bold(started.runId)}`);
-        console.log(`  ${chalk.dim('Results:')} ${chalk.cyan(started.resultsUrl)}`);
-    }
-    if (options.open !== false) {
-        openResults(started.resultsUrl);
+        // The base belongs to the head being verified, which may be an explicit
+        // --head rather than the working tree.
+        base = git(['merge-base', head, defaultBranch], `Could not find the merge base of ${head} with ${defaultBranch}; fetch origin or pass --base.`);
     }
+    return { repo, base, head };
+}
+export async function verifyCommand(options) {
+    const { repo, base, head } = resolveVerifyRepository(options);
+    await verifyHostedStartCommand(repo, {
+        provider: 'haystack',
+        base,
+        head,
+        intentFile: options.intentFile,
+        idempotencyKey: options.idempotencyKey,
+        account: options.account,
+        wait: options.wait,
+        interval: options.interval,
+        timeout: options.timeout,
+        json: options.json,
+    });
 }