@haystackeditor/cli 0.8.1 → 0.9.0

package/dist/commands/submit.js

@@ -0,0 +1,428 @@
+/**
+ * Submit command - Create a PR from current changes
+ *
+ * Runs pre-PR triage (code review, rules, intent drift) via parallel sub-agents,
+ * then pushes the current branch and creates a PR.
+ *
+ * PRs are routed based on flags:
+ *   - Default: auto-merge queue (analysis runs, auto-merged if approved)
+ *   - --review: human review required
+ *   - --force: skip triage checks
+ */
+import chalk from 'chalk';
+import fs from 'fs';
+import { findGitRoot, getCurrentBranch, getDefaultBranch, hasUncommittedChanges, parseRemoteUrl, pushBranch, getLastCommitMessage, getCommitMessagesSinceBase, } from '../utils/git.js';
+import { createPullRequest, findExistingPR, requireGitHubAuth, requestReviewers, } from '../utils/github-api.js';
+import { runTriage } from '../triage/runner.js';
+import { checkAnalysisReady, fetchAnalysisResults } from '../utils/analysis-api.js';
+import { savePendingSubmit, updatePendingSubmit } from '../utils/pending-state.js';
+import { isAutoMergeEnabled } from './config.js';
+import { ensureHaystackLabels, addLabelsToIssue, } from '../utils/github-api.js';
+// ============================================================================
+// Helpers
+// ============================================================================
+function buildPRBody(commitMessages) {
+    const body = commitMessages || 'Submitted via `haystack submit`.';
+    return `${body}
+
+---
+*Created via [Haystack CLI](https://haystackeditor.com)*`;
+}
+// ============================================================================
+// Triage output
+// ============================================================================
+function severityIcon(severity) {
+    switch (severity) {
+        case 'error': return chalk.red('✗');
+        case 'warning': return chalk.yellow('!');
+        case 'info': return chalk.blue('i');
+        default: return chalk.dim('-');
+    }
+}
+function severityColor(severity) {
+    switch (severity) {
+        case 'error': return chalk.red;
+        case 'warning': return chalk.yellow;
+        case 'info': return chalk.blue;
+        default: return chalk.dim;
+    }
+}
+function checkerDisplayName(checker) {
+    switch (checker) {
+        case 'code-review': return 'Code Review';
+        case 'rules-validator': return 'Rules Validator';
+        case 'intent-drift': return 'Intent Drift';
+        default: return checker;
+    }
+}
+function isCodexNetworkDisabledTriageError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.includes('CODEX_SANDBOX_NETWORK_DISABLED=1');
+}
+function printTriageSummary(result) {
+    console.log(chalk.bold('\n' + '━'.repeat(50)));
+    console.log(chalk.bold('  Pre-PR Triage Results'));
+    console.log(chalk.bold('━'.repeat(50) + '\n'));
+    // Per-checker summaries
+    for (const checkerResult of result.results) {
+        const icon = checkerResult.passed ? chalk.green('✓') : chalk.red('✗');
+        const name = checkerDisplayName(checkerResult.checker);
+        console.log(`  ${icon} ${chalk.bold(name)}: ${checkerResult.summary}`);
+        // List issues
+        if (checkerResult.issues.length > 0) {
+            for (const issue of checkerResult.issues) {
+                const location = issue.line
+                    ? `${issue.file}:${issue.line}`
+                    : issue.file;
+                const ruleTag = issue.rule ? chalk.dim(` [${issue.rule}]`) : '';
+                const patternTag = issue.pattern ? chalk.dim(` (${issue.pattern})`) : '';
+                console.log(`    ${severityIcon(issue.severity)} ${chalk.dim(location)} ${severityColor(issue.severity)(issue.message)}${ruleTag}${patternTag}`);
+            }
+            console.log('');
+        }
+    }
+    // Errors from sub-agent failures
+    if (result.errors.length > 0) {
+        console.log(chalk.yellow('  Checker errors:'));
+        for (const err of result.errors) {
+            console.log(chalk.yellow(`    ! ${err}`));
+        }
+        console.log('');
+    }
+    // Total summary
+    const totalIssues = result.results.reduce((sum, r) => sum + r.issues.length, 0);
+    const errorCount = result.results.reduce((sum, r) => sum + r.issues.filter((i) => i.severity === 'error').length, 0);
+    const warningCount = result.results.reduce((sum, r) => sum + r.issues.filter((i) => i.severity === 'warning').length, 0);
+    const duration = (result.duration / 1000).toFixed(1);
+    if (result.passed) {
+        console.log(chalk.green(`  All checks passed (${duration}s)\n`));
+    }
+    else {
+        const parts = [];
+        if (errorCount > 0)
+            parts.push(chalk.red(`${errorCount} error(s)`));
+        if (warningCount > 0)
+            parts.push(chalk.yellow(`${warningCount} warning(s)`));
+        console.log(`  ${parts.join(', ')} found across ${totalIssues} issue(s) (${duration}s)\n`);
+    }
+    // Results saved location
+    console.log(chalk.dim('  Results saved to .haystack/triage/\n'));
+}
+// ============================================================================
+// Main command
+// ============================================================================
+export async function submitCommand(options) {
+    console.log(chalk.bold.cyan('\nHaystack Submit\n'));
+    // -------------------------------------------------------------------------
+    // Step 1: Validate environment
+    // -------------------------------------------------------------------------
+    console.log(chalk.dim('Checking environment...'));
+    // Validate mutually exclusive options
+    if (options.body && options.bodyFile) {
+        console.error(chalk.red('\nCannot use both --body and --body-file. Pick one.\n'));
+        process.exit(1);
+    }
+    // Check git repo
+    const gitRoot = findGitRoot();
+    if (!gitRoot) {
+        console.error(chalk.red('\nNot a git repository.\n'));
+        process.exit(1);
+    }
+    // Check authentication
+    let githubToken;
+    try {
+        githubToken = await requireGitHubAuth();
+        console.log(chalk.green('✓ Authenticated'));
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    // Get remote info
+    let remoteInfo;
+    try {
+        remoteInfo = parseRemoteUrl('origin');
+        console.log(chalk.green(`✓ Repository: ${remoteInfo.owner}/${remoteInfo.repo}`));
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    // Check for uncommitted changes
+    if (hasUncommittedChanges()) {
+        console.log(chalk.yellow('⚠ You have uncommitted changes. They will not be included in the PR.'));
+    }
+    // Get current branch info
+    const currentBranch = getCurrentBranch();
+    const baseBranch = options.base || getDefaultBranch();
+    console.log(chalk.dim(`  Current branch: ${currentBranch}`));
+    console.log(chalk.dim(`  Base branch: ${baseBranch}`));
+    // -------------------------------------------------------------------------
+    // Step 2: Pre-PR Triage
+    // -------------------------------------------------------------------------
+    if (!options.force) {
+        console.log(chalk.dim('\nRunning pre-PR triage checks...'));
+        try {
+            const triageResult = await runTriage(gitRoot, baseBranch);
+            printTriageSummary(triageResult);
+            const triageInfraFailure = triageResult.results.length === 0 && triageResult.errors.length > 0;
+            if (triageInfraFailure) {
+                console.log(chalk.yellow('\n⚠ Triage unavailable (sub-agents failed to run). Continuing with submit.\n'));
+            }
+            if (!triageResult.passed) {
+                if (triageInfraFailure) {
+                    // Infrastructure failure should not block submission.
+                    // We already warned above and continue.
+                }
+                else {
+                    console.log(chalk.red('\nTriage failed. Fix the issues above or re-run with --force.\n'));
+                    process.exit(1);
+                }
+            }
+        }
+        catch (err) {
+            // Triage failure should not block submission
+            if (isCodexNetworkDisabledTriageError(err)) {
+                console.log(chalk.yellow('\n⚠ Triage skipped in Codex app shell.'));
+                console.log(chalk.dim('  Nested Codex sub-agents cannot access model endpoints from this shell.'));
+                console.log(chalk.dim('  Submit will continue normally.'));
+                console.log(chalk.dim('  For full triage, run `haystack submit` from a regular terminal.\n'));
+            }
+            else {
+                console.log(chalk.yellow(`\n⚠ Triage skipped: ${err.message}`));
+            }
+        }
+    }
+    else {
+        console.log(chalk.dim('\nSkipping triage (--force)'));
+    }
+    // -------------------------------------------------------------------------
+    // Step 3: Check if on main/master
+    // -------------------------------------------------------------------------
+    if (currentBranch === 'main' || currentBranch === 'master') {
+        console.error(chalk.red(`\nRefusing to submit from ${currentBranch}. Create a feature branch first.\n`));
+        process.exit(1);
+    }
+    // -------------------------------------------------------------------------
+    // Step 4: Push to remote
+    // -------------------------------------------------------------------------
+    console.log(chalk.dim('\nPushing to origin...'));
+    try {
+        pushBranch('origin', currentBranch);
+        console.log(chalk.green('✓ Branch pushed'));
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    // -------------------------------------------------------------------------
+    // Step 5: Create or find PR
+    // -------------------------------------------------------------------------
+    console.log(chalk.dim('\nCreating pull request...'));
+    // Check if PR already exists
+    const existingPR = await findExistingPR(remoteInfo.owner, remoteInfo.repo, currentBranch);
+    let prNumber;
+    let prUrl;
+    if (existingPR) {
+        console.log(chalk.yellow(`PR already exists: #${existingPR.number}`));
+        prNumber = existingPR.number;
+        prUrl = existingPR.html_url;
+    }
+    else {
+        // Generate PR title and body
+        const prTitle = options.title || getLastCommitMessage();
+        let bodyContent;
+        if (options.bodyFile) {
+            try {
+                bodyContent = options.bodyFile === '-'
+                    ? fs.readFileSync(0, 'utf-8')
+                    : fs.readFileSync(options.bodyFile, 'utf-8');
+            }
+            catch (err) {
+                console.error(chalk.red(`\nFailed to read body file: ${err.message}\n`));
+                process.exit(1);
+            }
+        }
+        else {
+            bodyContent = options.body || getCommitMessagesSinceBase(baseBranch);
+        }
+        const prBody = buildPRBody(bodyContent);
+        try {
+            const pr = await createPullRequest({
+                owner: remoteInfo.owner,
+                repo: remoteInfo.repo,
+                title: prTitle,
+                head: currentBranch,
+                base: baseBranch,
+                body: prBody,
+                draft: options.draft,
+            });
+            prNumber = pr.number;
+            prUrl = pr.html_url;
+            console.log(chalk.green(`✓ Pull request created: #${prNumber}`));
+        }
+        catch (err) {
+            console.error(chalk.red(`\n${err.message}\n`));
+            process.exit(1);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 6: Apply auto-merge label if enabled
+    // -------------------------------------------------------------------------
+    let autoMergeEnabled = false;
+    try {
+        autoMergeEnabled = await isAutoMergeEnabled();
+    }
+    catch {
+        // Preference check failure should not block submission
+    }
+    if (autoMergeEnabled) {
+        try {
+            await ensureHaystackLabels(remoteInfo.owner, remoteInfo.repo, ['haystack:auto-merge']);
+            await addLabelsToIssue(remoteInfo.owner, remoteInfo.repo, prNumber, ['haystack:auto-merge']);
+            console.log(chalk.green('✓ Auto-merge enabled for this PR'));
+        }
+        catch (err) {
+            console.log(chalk.yellow(`⚠ Could not set auto-merge label: ${err.message}`));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 7: Request review if --review
+    // -------------------------------------------------------------------------
+    if (options.review) {
+        try {
+            await ensureHaystackLabels(remoteInfo.owner, remoteInfo.repo, ['haystack:needs-review']);
+            await addLabelsToIssue(remoteInfo.owner, remoteInfo.repo, prNumber, ['haystack:needs-review']);
+            if (typeof options.review === 'string') {
+                // Specific reviewer requested
+                await requestReviewers(remoteInfo.owner, remoteInfo.repo, prNumber, [options.review]);
+                console.log(chalk.green(`✓ Review requested from ${options.review}`));
+            }
+            else {
+                // No reviewer specified — goes to needs-assignment queue
+                console.log(chalk.green('✓ Marked for review (needs assignment)'));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`⚠ Could not request review: ${err.message}`));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 8: Success!
+    // -------------------------------------------------------------------------
+    console.log(chalk.green('\n' + '━'.repeat(50)));
+    console.log(chalk.bold.green('\nPull Request Created!\n'));
+    console.log(`  ${chalk.dim('URL:')}    ${chalk.cyan(prUrl)}`);
+    console.log(`  ${chalk.dim('Title:')}  ${options.title || getLastCommitMessage()}`);
+    console.log(`  ${chalk.dim('Branch:')} ${currentBranch} → ${baseBranch}`);
+    if (autoMergeEnabled) {
+        console.log(`  ${chalk.dim('Merge:')}  ${chalk.green('Auto-merge if safe')}`);
+    }
+    if (options.review) {
+        const reviewer = typeof options.review === 'string' ? options.review : 'needs assignment';
+        console.log(`  ${chalk.dim('Review:')} ${chalk.yellow(reviewer)}`);
+    }
+    console.log('');
+    // -------------------------------------------------------------------------
+    // Step 9: Wait for Haystack analysis (triggered via GitHub App webhook)
+    // -------------------------------------------------------------------------
+    console.log(chalk.dim('Haystack analysis triggered via GitHub App webhook.'));
+    // Save pending state (so check-pending works even if we disconnect)
+    const pendingState = {
+        version: 1,
+        prNumber,
+        prUrl,
+        owner: remoteInfo.owner,
+        repo: remoteInfo.repo,
+        branch: currentBranch,
+        baseBranch,
+        submittedAt: new Date().toISOString(),
+        status: 'polling',
+    };
+    savePendingSubmit(pendingState, gitRoot);
+    // If --no-wait or non-interactive, exit here
+    if (options.wait === false || !process.stdin.isTTY) {
+        console.log(chalk.dim('\nAnalysis running in background.'));
+        console.log(chalk.dim('Check results later with: ') + chalk.cyan('haystack check-pending\n'));
+        return;
+    }
+    // Wait for analysis inline by polling the result endpoint
+    console.log(chalk.dim('\nWaiting for analysis...\n'));
+    // Handle Ctrl+C gracefully
+    let interrupted = false;
+    const sigintHandler = () => {
+        interrupted = true;
+        console.log(chalk.dim('\n\nAnalysis still running. Check later with:'));
+        console.log(chalk.cyan('  haystack check-pending\n'));
+        process.exit(0);
+    };
+    process.on('SIGINT', sigintHandler);
+    const POLL_INTERVAL = 5_000;
+    const POLL_TIMEOUT = 10 * 60 * 1000; // 10 minutes
+    const deadline = Date.now() + POLL_TIMEOUT;
+    let consecutiveErrors = 0;
+    const MAX_CONSECUTIVE_ERRORS = 5;
+    while (Date.now() < deadline && !interrupted) {
+        const result = await checkAnalysisReady(remoteInfo.owner, remoteInfo.repo, prNumber, githubToken);
+        if (result.status === 'ready') {
+            consecutiveErrors = 0;
+            // Fetch results
+            try {
+                const verdict = await fetchAnalysisResults(remoteInfo.owner, remoteInfo.repo, prNumber, githubToken);
+                updatePendingSubmit({
+                    status: 'completed',
+                    analysisResult: verdict,
+                    resolvedAt: new Date().toISOString(),
+                }, gitRoot);
+                // Print verdict
+                console.log(chalk.bold('\n' + '━'.repeat(50)));
+                console.log(chalk.bold('  Haystack Analysis Results'));
+                console.log(chalk.bold('━'.repeat(50) + '\n'));
+                if (verdict.state === 'good-to-merge') {
+                    if (verdict.autoMerged) {
+                        console.log(chalk.green.bold('  ✓ Auto-merged\n'));
+                        console.log(chalk.dim('  No issues found. PR was automatically merged.'));
+                    }
+                    else {
+                        console.log(chalk.green.bold('  ✓ Good to merge\n'));
+                        console.log(chalk.dim(`  ${verdict.summary}`));
+                    }
+                }
+                else {
+                    console.log(chalk.yellow.bold('  ⚠ Needs your input\n'));
+                    console.log(chalk.dim(`  ${verdict.summary}\n`));
+                    for (const issue of verdict.issues) {
+                        const icon = issue.severity === 'error' ? chalk.red('✗') : chalk.yellow('!');
+                        const loc = issue.line ? `${issue.file}:${issue.line}` : issue.file;
+                        console.log(`  ${icon} ${chalk.dim(loc)} ${issue.message}`);
+                    }
+                }
+                console.log(`\n  ${chalk.dim('Review:')} ${chalk.cyan(verdict.reviewUrl)}\n`);
+            }
+            catch {
+                console.log(chalk.yellow('⚠ Analysis complete but could not fetch results.'));
+                console.log(chalk.dim('  Check results at: ') + chalk.cyan(prUrl) + '\n');
+            }
+            break;
+        }
+        if (result.status === 'error') {
+            consecutiveErrors++;
+            if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                console.log(chalk.red(`\n  Analysis check failed: ${result.message}`));
+                updatePendingSubmit({ status: 'failed', resolvedAt: new Date().toISOString() }, gitRoot);
+                break;
+            }
+        }
+        else {
+            consecutiveErrors = 0;
+        }
+        process.stdout.write(`\r  ${chalk.dim('Status:')} Waiting for analysis...${'  '.repeat(10)}`);
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+    }
+    // Clean up SIGINT handler
+    process.removeListener('SIGINT', sigintHandler);
+    if (Date.now() >= deadline && !interrupted) {
+        console.log(chalk.yellow('\n\n  Timed out waiting for analysis.'));
+        console.log(chalk.dim('  Check results later with: ') + chalk.cyan('haystack check-pending\n'));
+    }
+}

package/dist/commands/triage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * triage command — View Haystack analysis results for any PR.
+ *
+ * Fetches the full rating synthesis (same data shown on the Haystack feed)
+ * and displays verdict, findings, verified bugs, and agent fix prompts.
+ *
+ * Accepts a PR identifier in several formats:
+ *   haystack triage 123                  # Uses current repo's owner/repo
+ *   haystack triage owner/repo#123       # Fully qualified
+ *   haystack triage https://github.com/owner/repo/pull/123
+ */
+export interface TriageOptions {
+    json?: boolean;
+    wait?: boolean;
+}
+export declare function triageCommand(identifier: string, options: TriageOptions): Promise<void>;