@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/design-verify.js

@@ -1,311 +0,0 @@
-/**
- * design-verify command — Kick off a blind design-by-execution verification
- * run for a PR.
- *
- * haystack design-verify <pr>
- *
- * Unlike `haystack review` (finding-oriented analysis of the diff), design
- * verification executes the change: it infers intent from the diff alone,
- * designs pre-registered behavioral test cases, runs control-before, before,
- * and after in isolated sandboxes, and reports evidence-backed anomaly
- * candidates outside the registered intent.
- *
- * The command waits by default and returns an agent-facing behavioral result.
- * --no-wait preserves the asynchronous trigger-only path.
- */
-import chalk from 'chalk';
-import { loadToken } from '../utils/auth.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-import { getDesignVerifierHistory, getDesignVerifierUniverseAction, startDesignVerifierUniverseAction, triggerDesignVerifier, waitForDesignVerifier, waitForDesignVerifierUniverseAction, } from '../utils/design-verifier-api.js';
-import { buildDesignVerifierAgentReport, designVerifierStageLabel, formatDesignVerifierAgentReport, } from '../utils/design-verifier-result.js';
-import { formatDesignVerifierHistory } from '../utils/design-verifier-history.js';
-function emit(json, payload, human) {
-    if (json) {
-        console.log(JSON.stringify(payload));
-    }
-    else {
-        human();
-    }
-}
-function parseExecArgv(source) {
-    let value;
-    try {
-        value = JSON.parse(source);
-    }
-    catch (error) {
-        throw new Error(`--exec-json is not valid JSON: ${error.message}`);
-    }
-    if (!Array.isArray(value) || value.length === 0 ||
-        value.some(argument => typeof argument !== 'string')) {
-        throw new Error('--exec-json must be a non-empty JSON array of string arguments');
-    }
-    return value;
-}
-function terminalSafe(value) {
-    // Preserve ordinary whitespace while removing C0/C1 controls, including
-    // ESC/OSC introducers. JSON output retains the server-returned strings.
-    let safe = '';
-    for (const character of value) {
-        const codePoint = character.codePointAt(0) ?? 0;
-        const ordinaryWhitespace = codePoint === 9 || codePoint === 10 || codePoint === 13;
-        if ((codePoint < 32 && !ordinaryWhitespace) ||
-            (codePoint >= 127 && codePoint <= 159))
-            continue;
-        safe += character;
-    }
-    return safe;
-}
-function printUniverseAction(action) {
-    const result = action.result;
-    if (action.status === 'queued' || action.status === 'running') {
-        console.log(chalk.dim(`${action.caseId}/${action.universe} ${action.action} is ${action.status}; action ${action.actionId}`));
-        return;
-    }
-    if (action.status === 'failed') {
-        console.error(chalk.red(`Universe ${action.action} failed: ${action.error || 'unknown error'}`));
-        return;
-    }
-    if (!result) {
-        console.error(chalk.red(`Universe ${action.action} completed without a result.`));
-        return;
-    }
-    console.log(chalk.dim(`${action.caseId}/${action.universe} ${action.action} (${result.durationMs}ms, exit ${result.exitCode ?? 'unknown'})`));
-    if (result.stdout) {
-        const stdout = terminalSafe(result.stdout);
-        process.stdout.write(stdout.endsWith('\n') ? stdout : `${stdout}\n`);
-    }
-    if (result.stderr) {
-        const stderr = terminalSafe(result.stderr);
-        process.stderr.write(stderr.endsWith('\n') ? stderr : `${stderr}\n`);
-    }
-    if (result.stdoutOmittedBytes || result.stderrOmittedBytes) {
-        console.error(chalk.dim(`Output truncated: ${result.stdoutOmittedBytes} stdout bytes, ${result.stderrOmittedBytes} stderr bytes omitted.`));
-    }
-}
-async function runUniverseOperation(pr, prLabel, options, token, pollIntervalSeconds, timeoutSeconds) {
-    const requested = Boolean(options.action || options.case || options.universe ||
-        options.replay || options.execJson || options.cwd || options.commandTimeout);
-    if (!requested)
-        return false;
-    if (!options.run)
-        throw new Error('universe exploration requires --run <run-id>');
-    let actionId = options.action;
-    if (actionId) {
-        if (options.case || options.universe || options.replay || options.execJson ||
-            options.cwd || options.commandTimeout) {
-            throw new Error('--action cannot be combined with a new universe command');
-        }
-        if (options.wait === false) {
-            const loaded = await getDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, actionId, token);
-            if (loaded.status !== 'ok')
-                throw new Error(loaded.message);
-            emit(options.json, { ok: true, pr: prLabel, ...loaded.action }, () => printUniverseAction(loaded.action));
-            return true;
-        }
-    }
-    else {
-        if (!options.case || !/^case-\d{5}$/.test(options.case)) {
-            throw new Error('a canonical --case case-00000 is required');
-        }
-        if (!options.universe || !['control-before', 'before', 'after'].includes(options.universe)) {
-            throw new Error('--universe must be control-before, before, or after');
-        }
-        if (Boolean(options.replay) === Boolean(options.execJson)) {
-            throw new Error('choose exactly one of --replay or --exec-json');
-        }
-        if (options.replay && (options.cwd || options.commandTimeout)) {
-            throw new Error('--cwd and --command-timeout apply only to --exec-json');
-        }
-        const commandTimeoutMs = options.commandTimeout === undefined
-            ? undefined
-            : Number(options.commandTimeout) * 1000;
-        if (commandTimeoutMs !== undefined &&
-            !(Number.isInteger(commandTimeoutMs) && commandTimeoutMs >= 1_000 && commandTimeoutMs <= 300_000)) {
-            throw new Error('--command-timeout must be between 1 and 300 seconds');
-        }
-        const started = await startDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, token, {
-            caseId: options.case,
-            universe: options.universe,
-            action: options.replay ? 'replay' : 'exec',
-            ...(options.execJson ? { argv: parseExecArgv(options.execJson) } : {}),
-            ...(options.cwd ? { cwd: options.cwd } : {}),
-            ...(commandTimeoutMs === undefined ? {} : { timeoutMs: commandTimeoutMs }),
-        });
-        if (started.status !== 'ok')
-            throw new Error(started.message);
-        actionId = started.action.actionId;
-        if (options.wait === false) {
-            emit(options.json, { ok: true, pr: prLabel, ...started.action }, () => {
-                console.log(chalk.green('✓ Universe action queued'));
-                console.log(chalk.dim(`  Action: ${actionId}`));
-                console.log(chalk.dim(`  Resume: haystack design-verify ${prLabel} --run ${options.run} --action ${actionId}`));
-            });
-            return true;
-        }
-    }
-    const waited = await waitForDesignVerifierUniverseAction(pr.owner, pr.repo, pr.prNumber, options.run, actionId, token, { intervalMs: pollIntervalSeconds * 1000, timeoutMs: timeoutSeconds * 1000 });
-    if (waited.status === 'timeout') {
-        throw new Error(`Timed out waiting; resume with: haystack design-verify ${prLabel} --run ${options.run} --action ${actionId}`);
-    }
-    if (waited.status === 'error')
-        throw new Error(waited.message);
-    emit(options.json, {
-        ok: waited.action.status === 'completed' && waited.action.result?.exitCode === 0,
-        pr: prLabel,
-        ...waited.action,
-    }, () => printUniverseAction(waited.action));
-    process.exitCode = waited.action.status === 'failed'
-        ? 2
-        : waited.action.result?.exitCode === 0 ? 0 : 1;
-    return true;
-}
-export async function designVerifyCommand(identifier, options) {
-    let pr;
-    try {
-        pr = parsePrRef(identifier, 'design-verify');
-    }
-    catch (err) {
-        emit(options.json, { ok: false, error: err.message }, () => {
-            console.error(chalk.red(err.message));
-        });
-        process.exitCode = 1;
-        return;
-    }
-    const prLabel = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
-    let token = null;
-    try {
-        token = await loadToken({ owner: pr.owner, repo: pr.repo });
-    }
-    catch (err) {
-        emit(options.json, { ok: false, pr: prLabel, error: `Could not load Haystack credentials: ${err.message}` }, () => {
-            console.error(chalk.red(`Could not load Haystack credentials: ${err.message}`));
-        });
-        process.exitCode = 1;
-        return;
-    }
-    if (!token) {
-        emit(options.json, { ok: false, pr: prLabel, error: 'Authentication required. Run `haystack login` first.' }, () => {
-            console.error(chalk.red('Design verification requires authentication. Run `haystack login` first.'));
-        });
-        process.exitCode = 1;
-        return;
-    }
-    if (options.history || options.limit !== undefined) {
-        try {
-            if (!options.history)
-                throw new Error('--limit requires --history');
-            if (options.run || options.case || options.universe || options.replay || options.execJson ||
-                options.cwd || options.commandTimeout || options.action || options.wait === false) {
-                throw new Error('--history cannot be combined with run or universe operations');
-            }
-            const limit = Number(options.limit ?? '20');
-            if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
-                throw new Error('--limit must be between 1 and 100');
-            }
-            const loaded = await getDesignVerifierHistory(pr.owner, pr.repo, token, limit);
-            if (loaded.status !== 'ok')
-                throw new Error(loaded.message);
-            emit(options.json, { ...loaded.history }, () => console.log(formatDesignVerifierHistory(loaded.history)));
-        }
-        catch (error) {
-            emit(options.json, { ok: false, error: error.message }, () => {
-                console.error(chalk.red(error.message));
-            });
-            process.exitCode = 2;
-        }
-        return;
-    }
-    const pollIntervalSeconds = Number(options.pollInterval || '3');
-    const timeoutSeconds = Number(options.timeout || '7200');
-    if (!(Number.isFinite(pollIntervalSeconds) && pollIntervalSeconds >= 1 && pollIntervalSeconds <= 60)) {
-        emit(options.json, { ok: false, error: '--poll-interval must be between 1 and 60 seconds' }, () => {
-            console.error(chalk.red('--poll-interval must be between 1 and 60 seconds'));
-        });
-        process.exitCode = 2;
-        return;
-    }
-    if (!(Number.isFinite(timeoutSeconds) && timeoutSeconds >= 1 && timeoutSeconds <= 7200)) {
-        emit(options.json, { ok: false, error: '--timeout must be between 1 and 7200 seconds' }, () => {
-            console.error(chalk.red('--timeout must be between 1 and 7200 seconds'));
-        });
-        process.exitCode = 2;
-        return;
-    }
-    try {
-        if (await runUniverseOperation(pr, prLabel, options, token, pollIntervalSeconds, timeoutSeconds))
-            return;
-    }
-    catch (error) {
-        emit(options.json, { ok: false, pr: prLabel, error: error.message }, () => {
-            console.error(chalk.red(error.message));
-        });
-        process.exitCode = 2;
-        return;
-    }
-    if (!options.json) {
-        console.log(chalk.dim(options.run
-            ? `\nResuming design verification ${options.run}...`
-            : `\nStarting design verification for ${prLabel}...`));
-    }
-    const result = options.run
-        ? { status: 'duplicate', runId: options.run }
-        : await triggerDesignVerifier(pr.owner, pr.repo, pr.prNumber, token);
-    switch (result.status) {
-        case 'started':
-        case 'queued':
-        case 'duplicate':
-            if (options.wait === false) {
-                emit(options.json, { ok: true, pr: prLabel, runId: result.runId, outcome: result.status }, () => {
-                    const suffix = result.status === 'queued'
-                        ? ' (at capacity — queued; it will start as a slot frees up)'
-                        : '';
-                    console.log(chalk.green(`✓ Design verification ${result.status}${suffix}`));
-                    console.log(chalk.dim(`  Run: ${result.runId}`));
-                    console.log(chalk.dim(`  Resume: haystack design-verify ${prLabel} --run ${result.runId}`));
-                });
-                return;
-            }
-            break;
-        default:
-            emit(options.json, { ok: false, pr: prLabel, error: result.message, kind: result.status }, () => {
-                console.error(chalk.red(`✗ ${result.message}`));
-            });
-            process.exitCode = 1;
-            return;
-    }
-    let lastProgress = '';
-    const waited = await waitForDesignVerifier(pr.owner, pr.repo, pr.prNumber, result.runId, token, {
-        intervalMs: pollIntervalSeconds * 1000,
-        timeoutMs: timeoutSeconds * 1000,
-        onProgress: (run) => {
-            if (options.json)
-                return;
-            const label = designVerifierStageLabel(run.stage);
-            if (label === lastProgress)
-                return;
-            lastProgress = label;
-            console.error(chalk.dim(`  ${label}...`));
-        },
-    });
-    if (waited.status === 'timeout') {
-        const message = `Timed out waiting; the run continues. Resume with: haystack design-verify ${prLabel} --run ${result.runId}`;
-        emit(options.json, { ok: false, status: 'pending', runId: result.runId, error: message }, () => {
-            console.error(chalk.yellow(message));
-        });
-        process.exitCode = 2;
-        return;
-    }
-    if (waited.status === 'error') {
-        emit(options.json, { ok: false, status: 'failed', runId: result.runId, error: waited.message }, () => {
-            console.error(chalk.red(`Verification status failed: ${waited.message}`));
-        });
-        process.exitCode = 2;
-        return;
-    }
-    const report = buildDesignVerifierAgentReport(waited.run);
-    if (options.json)
-        console.log(JSON.stringify(report));
-    else
-        console.log(`\n${formatDesignVerifierAgentReport(report)}`);
-    process.exitCode = report.exitCode;
-}

package/dist/commands/dismiss.js

@@ -1,159 +0,0 @@
-/**
- * dismiss & mark-reviewed commands — User overrides for PR findings.
- *
- * haystack dismiss <pr>        — Dismiss analysis findings for a PR
- * haystack mark-reviewed <pr>  — Mark human review as not needed for a PR
- *
- * Each posts a user override to the Haystack API so the PR moves toward
- * "Good to Merge" in the feed.
- *
- * Accepts a PR identifier in several formats:
- *   123                                    # Uses current repo's owner/repo
- *   owner/repo#123                         # Fully qualified
- *   https://github.com/owner/repo/pull/123 # GitHub URL
- */
-import chalk from 'chalk';
-import { emitActionPayload, failAction } from '../utils/action-output.js';
-import { resolveAuthContext } from '../utils/auth.js';
-import { classifyHttpError } from '../utils/haystack-api.js';
-import { githubRestBaseFor } from '../utils/github-api.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-// ============================================================================
-// GitHub API helpers
-// ============================================================================
-async function getPRHeadSha(owner, repo, prNumber, token) {
-    const response = await fetch(`${githubRestBaseFor(token)}/repos/${owner}/${repo}/pulls/${prNumber}`, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: 'application/vnd.github.v3+json',
-            'User-Agent': 'Haystack-CLI',
-        },
-    });
-    if (!response.ok) {
-        if (response.status === 404) {
-            throw new Error(`PR #${prNumber} not found in ${owner}/${repo}`);
-        }
-        throw await classifyHttpError(response, `Fetching PR #${prNumber}`);
-    }
-    const data = await response.json();
-    return data.head.sha;
-}
-// ============================================================================
-// User override API
-// ============================================================================
-const HAYSTACK_API = 'https://haystackeditor.com';
-async function postUserOverride(repoFullName, prNumber, commitSha, type, token) {
-    const response = await fetch(`${HAYSTACK_API}/api/user-override`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'Haystack-CLI',
-        },
-        body: JSON.stringify({ repoFullName, prNumber, commitSha, type }),
-    });
-    if (!response.ok) {
-        throw await classifyHttpError(response, 'User override');
-    }
-}
-async function deleteUserOverrides(repoFullName, prNumber, token) {
-    const response = await fetch(`${HAYSTACK_API}/api/user-override`, {
-        method: 'DELETE',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'Haystack-CLI',
-        },
-        body: JSON.stringify({ repoFullName, prNumber }),
-    });
-    if (!response.ok) {
-        throw await classifyHttpError(response, 'Clearing user overrides');
-    }
-}
-// ============================================================================
-// Pure payload functions (shared by the CLI commands and the MCP server —
-// they throw instead of exiting, and never write to stdout)
-// ============================================================================
-/** Post a user override and return the action payload. Throws on failure. */
-export async function performOverride(identifier, type, commandName) {
-    const pr = parsePrRef(identifier, commandName);
-    const authContext = await resolveAuthContext({ owner: pr.owner, repo: pr.repo });
-    const repoFullName = `${pr.owner}/${pr.repo}`;
-    const headSha = await getPRHeadSha(pr.owner, pr.repo, pr.prNumber, authContext.token);
-    await postUserOverride(repoFullName, pr.prNumber, headSha, type, authContext.token);
-    return {
-        action: type === 'findings-dismissed' ? 'dismiss' : 'mark_reviewed',
-        status: 'ok',
-        ref: `${repoFullName}#${pr.prNumber}`,
-        head_sha: headSha,
-        detail: type === 'findings-dismissed'
-            ? 'Findings dismissed; the PR moves to "Good to Merge". A new commit with net-new issues resurfaces it.'
-            : 'Human review marked as not needed; the PR moves to "Good to Merge". A new commit invalidates the override.',
-    };
-}
-/** Clear all overrides and return the action payload. Throws on failure. */
-export async function performUndismiss(identifier) {
-    const pr = parsePrRef(identifier, 'undismiss');
-    const authContext = await resolveAuthContext({ owner: pr.owner, repo: pr.repo });
-    const repoFullName = `${pr.owner}/${pr.repo}`;
-    await deleteUserOverrides(repoFullName, pr.prNumber, authContext.token);
-    return {
-        action: 'undismiss',
-        status: 'ok',
-        ref: `${repoFullName}#${pr.prNumber}`,
-        detail: 'All overrides cleared; the PR returns to its original feed bucket.',
-    };
-}
-async function runOverride(identifier, type, commandName, options) {
-    const action = type === 'findings-dismissed' ? 'dismiss' : 'mark_reviewed';
-    const actionLabel = type === 'findings-dismissed'
-        ? 'Dismissing findings'
-        : 'Marking review as not needed';
-    if (!options.json)
-        console.log(chalk.dim(`\n${actionLabel} for ${identifier}...`));
-    let payload;
-    try {
-        payload = await performOverride(identifier, type, commandName);
-    }
-    catch (err) {
-        failAction(options.json, action, null, err.message);
-        return; // unreachable — satisfies TS narrowing
-    }
-    if (options.json) {
-        emitActionPayload(payload);
-        return;
-    }
-    if (type === 'findings-dismissed') {
-        console.log(chalk.green(`\n  Findings dismissed for ${payload.ref}`));
-    }
-    else {
-        console.log(chalk.green(`\n  Review marked as not needed for ${payload.ref}`));
-    }
-    console.log(chalk.dim(`  Commit: ${payload.head_sha.slice(0, 7)}`));
-    console.log(chalk.dim('  The PR will move to "Good to Merge" in the feed.'));
-    console.log(chalk.dim('  If a new commit introduces net-new issues, the PR will resurface.\n'));
-}
-export async function dismissCommand(identifier, options = {}) {
-    await runOverride(identifier, 'findings-dismissed', 'dismiss', options);
-}
-export async function markReviewedCommand(identifier, options = {}) {
-    await runOverride(identifier, 'review-not-needed', 'mark-reviewed', options);
-}
-export async function undismissCommand(identifier, options = {}) {
-    if (!options.json)
-        console.log(chalk.dim(`\nClearing overrides for ${identifier}...`));
-    let payload;
-    try {
-        payload = await performUndismiss(identifier);
-    }
-    catch (err) {
-        failAction(options.json, 'undismiss', null, err.message);
-        return; // unreachable — satisfies TS narrowing
-    }
-    if (options.json) {
-        emitActionPayload(payload);
-        return;
-    }
-    console.log(chalk.green(`\n  Overrides cleared for ${payload.ref}`));
-    console.log(chalk.dim('  The PR will return to its original feed bucket.\n'));
-}