@haystackeditor/cli 0.15.25 → 0.15.27

package/dist/commands/design-verify.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 them against both sides
+ * of the PR in isolated sandboxes, and produces a mechanical verdict of
+ * unexpected behavior changes.
+ *
+ * The command waits by default and returns an agent-facing behavioral result.
+ * --no-wait preserves the asynchronous trigger-only path.
+ */
+export interface DesignVerifyOptions {
+    json?: boolean;
+    wait?: boolean;
+    run?: string;
+    pollInterval?: string;
+    timeout?: string;
+}
+export declare function designVerifyCommand(identifier: string, options: DesignVerifyOptions): Promise<void>;

package/dist/commands/design-verify.js

@@ -0,0 +1,142 @@
+/**
+ * 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 them against both sides
+ * of the PR in isolated sandboxes, and produces a mechanical verdict of
+ * unexpected behavior changes.
+ *
+ * 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 { triggerDesignVerifier, waitForDesignVerifier } from '../utils/design-verifier-api.js';
+import { buildDesignVerifierAgentReport, designVerifierStageLabel, formatDesignVerifierAgentReport, } from '../utils/design-verifier-result.js';
+function emit(json, payload, human) {
+    if (json) {
+        console.log(JSON.stringify(payload));
+    }
+    else {
+        human();
+    }
+}
+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;
+    }
+    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;
+    }
+    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/hooks.js

@@ -68,7 +68,7 @@ export async function hooksInstall(options) {
         console.log(chalk.green('✓ Hook dependencies installed'));
     }
     catch {
-        console.log(chalk.yellow('⚠ Failed to install hook dependencies. Run `npm install` in hooks/ manually.'));
+        console.log(chalk.yellow('⚠ Failed to install hook dependencies. Run `npm ci` in hooks/ manually.'));
     }
     // Step 6: Configure git hooks path
     try {
@@ -181,7 +181,7 @@ export async function hooksStatus() {
     const nodeModules = path.join(hooksDir, 'node_modules');
     console.log(existsSync(nodeModules)
         ? chalk.green('✓ Hook dependencies installed')
-        : chalk.yellow('⚠ Hook dependencies not installed (run npm install in hooks/)'));
+        : chalk.yellow('⚠ Hook dependencies not installed (run npm ci in hooks/)'));
     // Check git core.hooksPath
     try {
         const hooksPath = execSync('git config core.hooksPath', {

package/dist/commands/prepare-universe-review.d.ts

@@ -0,0 +1,115 @@
+export interface ReviewExclusion {
+    path: string;
+    rule_id: string;
+}
+export interface ReviewSymlinkIssue {
+    path: string;
+    target: string;
+    reason: 'absolute-target' | 'target-escapes-repository' | 'target-is-excluded' | 'target-is-not-retained-file' | 'target-cycle' | 'ambiguous-target' | 'unreadable-link';
+}
+export interface InlineTestCandidate {
+    path: string;
+}
+export interface SnapshotLimitBlocker {
+    kind: 'entry-count' | 'total-output-bytes';
+    path: string;
+    limit: number;
+    attempted: number;
+    reason: string;
+}
+export interface PrepareUniverseReviewResult {
+    status: 'ready-for-confinement' | 'blocked';
+    path: string;
+    process_confinement_required: true;
+    counts: {
+        tracked: number;
+        retained: number;
+        copied: number;
+        excluded: number;
+        submodules_omitted: number;
+        approved_inactive_submodules_omitted: number;
+        symlinks_materialized: number;
+        symlink_issues: number;
+        symlinks_omitted_target_not_retained: number;
+        omitted_unscannable: number;
+        missing_or_changed_type: number;
+        inline_test_candidates: number;
+        inline_scan_skipped: number;
+        binary_inline_scan_skipped: number;
+        oversized_text_inline_scan_blockers: number;
+        snapshot_limit_blockers: number;
+        copied_bytes: number;
+    };
+    exclusions: ReviewExclusion[];
+    submodules_omitted: string[];
+    approved_inactive_submodule_omissions: {
+        rule: {
+            id: string;
+            description: string;
+        };
+        paths: string[];
+    };
+    rules: Array<{
+        id: string;
+        description: string;
+    }>;
+    activated_conditional_rule_ids: string[];
+    inline_marker_rules: Array<{
+        id: string;
+        description: string;
+    }>;
+    symlink_issues: ReviewSymlinkIssue[];
+    omitted_symlinks: ReviewSymlinkIssue[];
+    omitted_unscannable: {
+        path: string;
+        reason: string;
+    }[];
+    missing_or_changed_type: Array<{
+        path: string;
+        reason: string;
+    }>;
+    inline_test_candidates: InlineTestCandidate[];
+    inline_scan_skipped: Array<{
+        path: string;
+        reason: string;
+    }>;
+    snapshot_limit_blockers: SnapshotLimitBlocker[];
+    receipt: {
+        detail: 'compact' | 'full';
+        sample_limit: number;
+        complete_blocking_details: true;
+        collections: {
+            exclusions: ReceiptCollectionSummary;
+            approved_inactive_submodule_omissions: ReceiptCollectionSummary;
+            binary_inline_scan_skips: ReceiptCollectionSummary;
+        };
+    };
+    manifest: {
+        path: string;
+        sha256: string;
+        entries: number;
+    };
+}
+export interface PrepareUniverseReviewOptions {
+    excludeInactiveSubmodules?: string[];
+    /** Omit files whose test content cannot be ruled out instead of blocking. */
+    omitUnscannableFiles?: boolean;
+    fullReceipt?: boolean;
+    limits?: {
+        maxSnapshotEntries?: number;
+        maxSnapshotOutputBytes?: number;
+    };
+}
+interface ReceiptCollectionSummary {
+    total: number;
+    returned: number;
+    truncated: number;
+}
+export declare function prepareUniverseReview(root: string, options?: PrepareUniverseReviewOptions): PrepareUniverseReviewResult;
+export declare function prepareUniverseReviewCommand(options: {
+    json?: boolean;
+    excludeInactiveSubmodule?: string[];
+    omitUnscannableFiles?: boolean;
+    fullReceipt?: boolean;
+}): Promise<void>;
+export {};