@haystackeditor/cli 0.15.26 → 0.15.28

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

@@ -0,0 +1,31 @@
+/**
+ * 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 { type DesignVerifierUniverseRole } from '../utils/design-verifier-api.js';
+export interface DesignVerifyOptions {
+    json?: boolean;
+    wait?: boolean;
+    run?: string;
+    pollInterval?: string;
+    timeout?: string;
+    case?: string;
+    universe?: DesignVerifierUniverseRole;
+    replay?: boolean;
+    execJson?: string;
+    cwd?: string;
+    commandTimeout?: string;
+    action?: string;
+}
+export declare function designVerifyCommand(identifier: string, options: DesignVerifyOptions): Promise<void>;

package/dist/commands/design-verify.js

@@ -0,0 +1,285 @@
+/**
+ * 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 { getDesignVerifierUniverseAction, startDesignVerifierUniverseAction, triggerDesignVerifier, waitForDesignVerifier, waitForDesignVerifierUniverseAction, } 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();
+    }
+}
+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;
+    }
+    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/hooks.d.ts

@@ -2,16 +2,12 @@
  * haystack hooks - Install and manage git hooks for AI agent quality checks
  *
  * Installs:
- *   - Entire CLI binary (session tracking, powered by https://entire.dev)
  *   - Pre-commit hook (agent detection, truncation checking, LLM rules review)
- *   - Git hooks for session logging (commit-msg, post-commit, pre-push, prepare-commit-msg)
+ *   - Git hooks for Haystack quality checks and workflow guidance
  */
 interface HooksInstallOptions {
-    version?: string;
     force?: boolean;
-    skipEntire?: boolean;
 }
 export declare function hooksInstall(options: HooksInstallOptions): Promise<void>;
 export declare function hooksStatus(): Promise<void>;
-export declare function hooksUpdate(): Promise<void>;
 export {};

package/dist/commands/hooks.js

@@ -2,15 +2,14 @@
  * haystack hooks - Install and manage git hooks for AI agent quality checks
  *
  * Installs:
- *   - Entire CLI binary (session tracking, powered by https://entire.dev)
  *   - Pre-commit hook (agent detection, truncation checking, LLM rules review)
- *   - Git hooks for session logging (commit-msg, post-commit, pre-push, prepare-commit-msg)
+ *   - Git hooks for Haystack quality checks and workflow guidance
  */
 import chalk from 'chalk';
 import { existsSync, accessSync, constants } from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
-import { findGitRoot, ENTIRE_DEFAULT_VERSION, ENTIRE_BIN_PATH, getInstalledEntireVersion, getLatestEntireVersion, downloadEntireBinary, copyHookFiles, installHookDeps, copyLlmRulesTemplate, createEntireConfig, updateGitignore, } from '../utils/hooks.js';
+import { findGitRoot, copyHookFiles, installHookDeps, copyLlmRulesTemplate, } from '../utils/hooks.js';
 export async function hooksInstall(options) {
     console.log(chalk.cyan('\nHaystack Hooks Setup\n'));
     // Step 1: Validate git repo
@@ -28,30 +27,7 @@ export async function hooksInstall(options) {
     if (existsSync(hooksDir) && options.force) {
         console.log(chalk.yellow('Overwriting existing hooks...'));
     }
-    // Step 3: Download Entire binary
-    if (!options.skipEntire) {
-        const version = options.version || ENTIRE_DEFAULT_VERSION;
-        const installedVersion = await getInstalledEntireVersion();
-        if (installedVersion === version) {
-            console.log(chalk.green(`✓ Entire CLI v${version} already installed`));
-        }
-        else {
-            console.log(chalk.dim(`Downloading Entire CLI v${version}...`));
-            try {
-                await downloadEntireBinary(version);
-                console.log(chalk.green(`✓ Entire CLI v${version} installed to ~/.haystack/bin/entire`));
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(chalk.red(`Failed to download Entire CLI: ${message}\n`));
-                process.exit(1);
-            }
-        }
-    }
-    else {
-        console.log(chalk.dim('Skipping Entire CLI download (--skip-entire)'));
-    }
-    // Step 4: Copy hook files
+    // Step 3: Copy hook files
     try {
         await copyHookFiles(hooksDir);
         console.log(chalk.green('✓ Hook scripts installed to hooks/'));
@@ -61,16 +37,16 @@ export async function hooksInstall(options) {
         console.error(chalk.red(`Failed to copy hook files: ${message}\n`));
         process.exit(1);
     }
-    // Step 5: Install hook dependencies
+    // Step 4: Install hook dependencies
     console.log(chalk.dim('Installing hook dependencies (tree-sitter)...'));
     try {
         await installHookDeps(hooksDir);
         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
+    // Step 5: Configure git hooks path
     try {
         execSync('git config core.hooksPath hooks', { cwd: gitRoot, stdio: 'pipe' });
         console.log(chalk.green('✓ Git configured to use hooks/ directory'));
@@ -80,15 +56,7 @@ export async function hooksInstall(options) {
         console.error(chalk.red(`Failed to set git hooks path: ${message}\n`));
         process.exit(1);
     }
-    // Step 7: Create .entire/ configuration
-    try {
-        await createEntireConfig(gitRoot);
-        console.log(chalk.green('✓ Created .entire/settings.json'));
-    }
-    catch {
-        console.log(chalk.yellow('⚠ Failed to create .entire/ configuration'));
-    }
-    // Step 8: Create LLM_RULES.md if needed
+    // Step 6: Create LLM_RULES.md if needed
     try {
         const created = await copyLlmRulesTemplate(gitRoot);
         if (created) {
@@ -101,29 +69,17 @@ export async function hooksInstall(options) {
     catch {
         console.log(chalk.yellow('⚠ Failed to create LLM_RULES.md'));
     }
-    // Step 9: Update .gitignore
-    try {
-        const updated = await updateGitignore(gitRoot);
-        if (updated) {
-            console.log(chalk.green('✓ Updated .gitignore'));
-        }
-    }
-    catch {
-        console.log(chalk.yellow('⚠ Failed to update .gitignore'));
-    }
     // Summary
     console.log(chalk.green('\n✓ Haystack hooks installed!\n'));
     console.log(chalk.dim('Hooks installed:'));
     console.log(chalk.dim('  pre-commit           Agent detection, truncation check, LLM rules review'));
-    console.log(chalk.dim('  commit-msg           Session tracking (powered by Entire)'));
-    console.log(chalk.dim('  post-commit          Session condensing (powered by Entire)'));
-    console.log(chalk.dim('  pre-push             Session log push (powered by Entire)'));
-    console.log(chalk.dim('  prepare-commit-msg   Commit preparation (powered by Entire)'));
+    console.log(chalk.dim('  commit-msg           Haystack commit checks'));
+    console.log(chalk.dim('  post-commit          Haystack post-commit checks'));
+    console.log(chalk.dim('  pre-push             Haystack workflow guidance'));
+    console.log(chalk.dim('  prepare-commit-msg   Haystack commit preparation'));
     console.log('');
     console.log(chalk.dim('Files to commit:'));
     console.log(chalk.dim('  hooks/               Hook scripts and TypeScript modules'));
-    console.log(chalk.dim('  .entire/settings.json'));
-    console.log(chalk.dim('  .entire/.gitignore'));
     console.log(chalk.dim('  LLM_RULES.md         Customize this for your project'));
     console.log('');
 }
@@ -181,7 +137,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', {
@@ -199,25 +155,6 @@ export async function hooksStatus() {
     catch {
         console.log(chalk.red('✗ Git core.hooksPath not set'));
     }
-    // Check Entire binary
-    const installedVersion = await getInstalledEntireVersion();
-    if (installedVersion) {
-        console.log(chalk.green(`✓ Entire CLI v${installedVersion}`));
-    }
-    else if (existsSync(ENTIRE_BIN_PATH)) {
-        console.log(chalk.yellow('⚠ Entire CLI binary exists but failed to run'));
-    }
-    else {
-        console.log(chalk.yellow('⚠ Entire CLI not installed (~/.haystack/bin/entire)'));
-    }
-    // Check .entire/settings.json
-    const settingsPath = path.join(gitRoot, '.entire', 'settings.json');
-    if (existsSync(settingsPath)) {
-        console.log(chalk.green('✓ .entire/settings.json'));
-    }
-    else {
-        console.log(chalk.yellow('⚠ .entire/settings.json not found'));
-    }
     // Check LLM_RULES.md
     const rulesPath = path.join(gitRoot, 'LLM_RULES.md');
     if (existsSync(rulesPath)) {
@@ -228,42 +165,3 @@ export async function hooksStatus() {
     }
     console.log('');
 }
-// ============================================================================
-// haystack hooks update
-// ============================================================================
-export async function hooksUpdate() {
-    console.log(chalk.cyan('\nUpdating Entire CLI...\n'));
-    // Check current version
-    const currentVersion = await getInstalledEntireVersion();
-    if (currentVersion) {
-        console.log(chalk.dim(`Current version: v${currentVersion}`));
-    }
-    else {
-        console.log(chalk.dim('Entire CLI not currently installed.'));
-    }
-    // Fetch latest version
-    let latestVersion;
-    try {
-        latestVersion = await getLatestEntireVersion();
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Failed to check for updates: ${message}\n`));
-        process.exit(1);
-    }
-    console.log(chalk.dim(`Latest version:  v${latestVersion}`));
-    if (currentVersion === latestVersion) {
-        console.log(chalk.green('\n✓ Already up to date.\n'));
-        return;
-    }
-    // Download and install
-    try {
-        await downloadEntireBinary(latestVersion);
-        console.log(chalk.green(`\n✓ Updated Entire CLI to v${latestVersion}\n`));
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Failed to update: ${message}\n`));
-        process.exit(1);
-    }
-}

package/dist/commands/install-session-hooks.d.ts

@@ -1,12 +1,12 @@
 /**
- * install-session-hooks — Wire up session-start hooks for coding CLIs.
+ * install-session-hooks — Wire up session-start and Stop hooks for coding CLIs.
  *
  * When a CLI session starts, `haystack triage --hook` runs automatically
  * and shows the user whether their last submitted PR is "Good to merge" or
  * "Needs input", with the Haystack rating and auto-fixer status.
  *
  * Supported CLIs:
- *   - Claude Code: Native SessionStart hook in .claude/settings.json
+ *   - Claude Code: Native SessionStart and Stop hooks in .claude/settings.json
  *   - Codex CLI:   AGENTS.md instructions (no native hook support)
  *   - Gemini CLI:  GEMINI.md instructions (no native hook support)
  */