@haystackeditor/cli 0.8.1 → 0.10.0

package/dist/commands/policy.js

@@ -0,0 +1,365 @@
+/**
+ * haystack policy - Manage review policies
+ *
+ * Commands:
+ *   list    - List all review policies
+ *   add     - Add a new policy interactively
+ *   remove  - Remove a policy by name
+ *   init    - Create initial review-policy.md
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import inquirer from 'inquirer';
+const POLICY_PATH = '.haystack/review-policy.md';
+// ============================================================================
+// Markdown Parsing
+// ============================================================================
+/**
+ * Parse review-policy.md content into ReviewPolicy objects and instructions
+ */
+function parsePolicyMarkdown(content) {
+    const policies = [];
+    const instructions = [];
+    // Split by H2 headings (## )
+    const sections = content.split(/^## /m).slice(1); // Skip content before first H2
+    for (const section of sections) {
+        const lines = section.trim().split('\n');
+        if (lines.length === 0)
+            continue;
+        // First line is the section name
+        const name = lines[0].trim();
+        if (!name)
+            continue;
+        // ## Instructions — collect bullet points as raw semantic directives
+        if (name.toLowerCase() === 'instructions') {
+            for (const line of lines.slice(1)) {
+                const trimmed = line.trim();
+                const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+                if (bulletMatch) {
+                    instructions.push(bulletMatch[1].trim());
+                }
+            }
+            continue;
+        }
+        let paths = [];
+        let severity = 'medium';
+        let reason = '';
+        // Parse bullet points
+        for (const line of lines.slice(1)) {
+            const trimmed = line.trim();
+            // Match **Paths**: `pattern1`, `pattern2`
+            const pathsMatch = trimmed.match(/^\*\*Paths?\*\*:\s*(.+)$/i);
+            if (pathsMatch) {
+                const pathString = pathsMatch[1];
+                const backtickPatterns = pathString.match(/`([^`]+)`/g);
+                if (backtickPatterns) {
+                    paths = backtickPatterns.map(p => p.replace(/`/g, '').trim());
+                }
+                else {
+                    paths = pathString.split(',').map(p => p.trim());
+                }
+                continue;
+            }
+            // Match **Severity**: critical|high|medium|low
+            const severityMatch = trimmed.match(/^\*\*Severity\*\*:\s*(critical|high|medium|low)/i);
+            if (severityMatch) {
+                severity = severityMatch[1].toLowerCase();
+                continue;
+            }
+            // Match **Reason**: ...
+            const reasonMatch = trimmed.match(/^\*\*Reason\*\*:\s*(.+)$/i);
+            if (reasonMatch) {
+                reason = reasonMatch[1].trim();
+                continue;
+            }
+        }
+        // Only add if we have at least paths and reason
+        if (paths.length > 0 && reason) {
+            policies.push({ name, paths, reason, severity });
+        }
+    }
+    return { policies, instructions };
+}
+/**
+ * Serialize ReviewPolicy objects and instructions back to markdown
+ */
+function serializePolicies(policies, instructions = []) {
+    const lines = ['# Review Policies', ''];
+    if (instructions.length > 0) {
+        lines.push('## Instructions', '');
+        for (const instruction of instructions) {
+            lines.push(`- ${instruction}`);
+        }
+        lines.push('');
+    }
+    for (const policy of policies) {
+        lines.push(`## ${policy.name}`);
+        lines.push(`- **Paths**: ${policy.paths.map(p => '`' + p + '`').join(', ')}`);
+        lines.push(`- **Severity**: ${policy.severity}`);
+        lines.push(`- **Reason**: ${policy.reason}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ============================================================================
+// Severity Colors
+// ============================================================================
+function severityColor(severity) {
+    switch (severity) {
+        case 'critical': return chalk.red;
+        case 'high': return chalk.yellow;
+        case 'medium': return chalk.blue;
+        case 'low': return chalk.dim;
+        default: return chalk.white;
+    }
+}
+// ============================================================================
+// Commands
+// ============================================================================
+/**
+ * List all review policies
+ */
+export async function listPolicies() {
+    const filePath = join(process.cwd(), POLICY_PATH);
+    if (!existsSync(filePath)) {
+        console.log(chalk.yellow('\nNo review-policy.md found.'));
+        console.log(chalk.dim('Run "haystack policy init" to create one.\n'));
+        return;
+    }
+    const content = readFileSync(filePath, 'utf-8');
+    const { policies, instructions } = parsePolicyMarkdown(content);
+    if (policies.length === 0 && instructions.length === 0) {
+        console.log(chalk.yellow('\nNo policies or instructions defined in review-policy.md'));
+        console.log(chalk.dim('Run "haystack policy add" to create one.\n'));
+        return;
+    }
+    if (instructions.length > 0) {
+        console.log(chalk.cyan('\n📝 Review Instructions\n'));
+        for (const instruction of instructions) {
+            console.log(`  ${chalk.dim('•')} ${instruction}`);
+        }
+        console.log('');
+    }
+    if (policies.length > 0) {
+        console.log(chalk.cyan('📋 Review Policies\n'));
+        for (const policy of policies) {
+            const color = severityColor(policy.severity);
+            console.log(`  ${chalk.bold(policy.name)}`);
+            console.log(`    Severity: ${color(policy.severity)}`);
+            console.log(`    Paths: ${chalk.dim(policy.paths.join(', '))}`);
+            console.log(`    Reason: ${policy.reason}`);
+            console.log('');
+        }
+    }
+}
+/**
+ * Add a new review policy interactively
+ */
+export async function addPolicy(nameArg) {
+    const filePath = join(process.cwd(), POLICY_PATH);
+    // Load existing policies and instructions
+    let policies = [];
+    let instructions = [];
+    if (existsSync(filePath)) {
+        const existingContent = readFileSync(filePath, 'utf-8');
+        const parsed = parsePolicyMarkdown(existingContent);
+        policies = parsed.policies;
+        instructions = parsed.instructions;
+    }
+    console.log(chalk.cyan('\n➕ Add Review Policy\n'));
+    // Prompt for policy details
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Policy name:',
+            default: nameArg,
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Name is required';
+                if (policies.some(p => p.name.toLowerCase() === input.toLowerCase())) {
+                    return 'A policy with this name already exists';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'paths',
+            message: 'File patterns (comma-separated globs):',
+            validate: (input) => input.trim() ? true : 'At least one path pattern is required',
+        },
+        {
+            type: 'list',
+            name: 'severity',
+            message: 'Severity:',
+            choices: [
+                { name: chalk.red('critical') + ' - Always requires human review', value: 'critical' },
+                { name: chalk.yellow('high') + ' - Usually requires review', value: 'high' },
+                { name: chalk.blue('medium') + ' - Should be reviewed', value: 'medium' },
+                { name: chalk.dim('low') + ' - Nice to review', value: 'low' },
+            ],
+            default: 'medium',
+        },
+        {
+            type: 'input',
+            name: 'reason',
+            message: 'Reason for requiring review:',
+            validate: (input) => input.trim() ? true : 'Reason is required',
+        },
+    ]);
+    // Parse paths from comma-separated input
+    const paths = answers.paths.split(',').map((p) => p.trim()).filter(Boolean);
+    const newPolicy = {
+        name: answers.name.trim(),
+        paths,
+        severity: answers.severity,
+        reason: answers.reason.trim(),
+    };
+    policies.push(newPolicy);
+    // Ensure directory exists
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    // Write updated file
+    writeFileSync(filePath, serializePolicies(policies, instructions));
+    console.log(chalk.green(`\n✓ Added policy "${newPolicy.name}"`));
+    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
+}
+/**
+ * Remove a policy by name
+ */
+export async function removePolicy(name) {
+    const filePath = join(process.cwd(), POLICY_PATH);
+    if (!existsSync(filePath)) {
+        console.log(chalk.red('\nNo review-policy.md found.\n'));
+        return;
+    }
+    const content = readFileSync(filePath, 'utf-8');
+    const parsed = parsePolicyMarkdown(content);
+    let policies = parsed.policies;
+    const instructions = parsed.instructions;
+    // Find policy (case-insensitive)
+    const index = policies.findIndex(p => p.name.toLowerCase() === name.toLowerCase());
+    if (index === -1) {
+        console.log(chalk.red(`\nPolicy "${name}" not found.\n`));
+        console.log(chalk.dim('Available policies:'));
+        for (const p of policies) {
+            console.log(chalk.dim(`  - ${p.name}`));
+        }
+        console.log('');
+        return;
+    }
+    const removed = policies[index];
+    // Confirm removal
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Remove policy "${removed.name}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk.dim('\nCancelled.\n'));
+        return;
+    }
+    // Remove and write
+    policies = policies.filter((_, i) => i !== index);
+    writeFileSync(filePath, serializePolicies(policies, instructions));
+    console.log(chalk.green(`\n✓ Removed policy "${removed.name}"`));
+    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
+}
+/**
+ * Add a review instruction
+ */
+export async function addInstruction(text) {
+    const filePath = join(process.cwd(), POLICY_PATH);
+    // Load existing
+    let policies = [];
+    let instructions = [];
+    if (existsSync(filePath)) {
+        const content = readFileSync(filePath, 'utf-8');
+        const parsed = parsePolicyMarkdown(content);
+        policies = parsed.policies;
+        instructions = parsed.instructions;
+    }
+    let instruction = text?.trim();
+    if (!instruction) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'instruction',
+                message: 'Review instruction:',
+                validate: (input) => input.trim() ? true : 'Instruction text is required',
+            },
+        ]);
+        instruction = answers.instruction.trim();
+    }
+    instructions.push(instruction);
+    // Ensure directory exists
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(filePath, serializePolicies(policies, instructions));
+    console.log(chalk.green(`\n✓ Added instruction: "${instruction}"`));
+    console.log(chalk.dim(`  Updated ${POLICY_PATH}\n`));
+}
+/**
+ * Create initial review-policy.md with example policies
+ */
+export async function initPolicies(options) {
+    const filePath = join(process.cwd(), POLICY_PATH);
+    if (existsSync(filePath) && !options.force) {
+        console.log(chalk.yellow('\nreview-policy.md already exists. Use --force to overwrite.\n'));
+        return;
+    }
+    // Default template policies
+    const defaultPolicies = [
+        {
+            name: 'Infrastructure changes',
+            paths: ['terraform/**', '*.tf', 'pulumi/**', 'cdk/**'],
+            severity: 'high',
+            reason: 'Infrastructure changes require manual review for security and cost implications',
+        },
+        {
+            name: 'Secret files',
+            paths: ['**/*.secret*', '**/*.env*', '**/credentials*', '**/*.pem', '**/*.key'],
+            severity: 'critical',
+            reason: 'Files potentially containing secrets require security review',
+        },
+        {
+            name: 'CI/CD pipelines',
+            paths: ['.github/workflows/**', '.gitlab-ci.yml', 'Jenkinsfile', '.circleci/**'],
+            severity: 'high',
+            reason: 'CI/CD changes can affect deployment security and reliability',
+        },
+        {
+            name: 'Weak test coverage',
+            paths: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.py', '**/*.go', '**/*.rs'],
+            severity: 'medium',
+            reason: 'Non-trivial logic changes without test coverage should be reviewed by a human to verify correctness',
+        },
+        {
+            name: 'Unverified agent changes',
+            paths: ['**/*'],
+            severity: 'medium',
+            reason: 'Agent-authored PRs without verification evidence (tests run, build checked, UI verified) should be reviewed by a human',
+        },
+    ];
+    // Ensure directory exists
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(filePath, serializePolicies(defaultPolicies));
+    console.log(chalk.green(`\n✓ Created ${POLICY_PATH}`));
+    console.log(chalk.dim('\nDefault policies added:'));
+    for (const p of defaultPolicies) {
+        console.log(chalk.dim(`  - ${p.name} (${p.severity})`));
+    }
+    console.log(chalk.dim('\nEdit the file or use "haystack policy add" / "haystack policy add-instruction" to customize.\n'));
+}

package/dist/commands/pr-status.d.ts

@@ -0,0 +1,16 @@
+/**
+ * pr-status command — Show the current Haystack status of a PR.
+ *
+ * Calls the classify-debug endpoint to determine which inbox bucket the PR
+ * is in (analyzing, auto-fixing, good-to-merge, issues, needs-assignment, etc.)
+ * and displays a human-readable summary.
+ *
+ * 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
+ */
+export interface PRStatusOptions {
+    json?: boolean;
+}
+export declare function prStatusCommand(identifier: string, options: PRStatusOptions): Promise<void>;

package/dist/commands/pr-status.js

@@ -0,0 +1,188 @@
+/**
+ * pr-status command — Show the current Haystack status of a PR.
+ *
+ * Calls the classify-debug endpoint to determine which inbox bucket the PR
+ * is in (analyzing, auto-fixing, good-to-merge, issues, needs-assignment, etc.)
+ * and displays a human-readable summary.
+ *
+ * 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 { loadToken } from './login.js';
+import { parseRemoteUrl } from '../utils/git.js';
+// ============================================================================
+// PR identifier parsing
+// ============================================================================
+function parsePRIdentifier(identifier) {
+    const urlMatch = identifier.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/);
+    if (urlMatch) {
+        return { owner: urlMatch[1], repo: urlMatch[2], prNumber: parseInt(urlMatch[3], 10) };
+    }
+    const qualifiedMatch = identifier.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+    if (qualifiedMatch) {
+        return { owner: qualifiedMatch[1], repo: qualifiedMatch[2], prNumber: parseInt(qualifiedMatch[3], 10) };
+    }
+    const numberMatch = identifier.match(/^#?(\d+)$/);
+    if (numberMatch) {
+        const prNumber = parseInt(numberMatch[1], 10);
+        try {
+            const remote = parseRemoteUrl('origin');
+            return { owner: remote.owner, repo: remote.repo, prNumber };
+        }
+        catch {
+            throw new Error(`Cannot determine repository for PR #${prNumber}.\n` +
+                `Use the full format: haystack pr-status owner/repo#${prNumber}`);
+        }
+    }
+    throw new Error(`Invalid PR identifier: "${identifier}"\n\n` +
+        `Accepted formats:\n` +
+        `  haystack pr-status 123\n` +
+        `  haystack pr-status owner/repo#123\n` +
+        `  haystack pr-status https://github.com/owner/repo/pull/123`);
+}
+// ============================================================================
+// Display helpers
+// ============================================================================
+const BUCKET_DISPLAY = {
+    'analyzing': { label: 'Analyzing', color: chalk.blue, icon: '...' },
+    'auto-fixing': { label: 'Auto-fixing', color: chalk.blue, icon: '>>>' },
+    'good-to-merge': { label: 'Good to Merge', color: chalk.green, icon: '[+]' },
+    'failed-when-merging': { label: 'Failed When Merging', color: chalk.red, icon: '[!]' },
+    'issues': { label: 'Issues Found', color: chalk.yellow, icon: '[?]' },
+    'needs-assignment': { label: 'Needs Reviewer Assignment', color: chalk.yellow, icon: '[?]' },
+    'needs-shepherding': { label: 'Needs Manual Merge', color: chalk.yellow, icon: '[!]' },
+    'needs-fixing': { label: 'Agent Fixing CI', color: chalk.blue, icon: '>>>' },
+    'awaiting-review': { label: 'Awaiting Review', color: chalk.cyan, icon: '[-]' },
+    'review-requested': { label: 'Review Requested', color: chalk.cyan, icon: '[-]' },
+    'snoozed': { label: 'Snoozed', color: chalk.dim, icon: '[-]' },
+};
+function formatBucket(bucket) {
+    if (!bucket)
+        return chalk.dim('Not classified (PR may be closed, or not yet analyzed)');
+    const info = BUCKET_DISPLAY[bucket];
+    if (!info)
+        return chalk.dim(bucket);
+    return `${info.icon} ${info.color(info.label)}`;
+}
+function formatAnalysisStatus(status) {
+    switch (status) {
+        case 'ready': return chalk.green('Ready');
+        case 'in_queue': return chalk.blue('In queue');
+        case 'pending': return chalk.dim('Pending');
+        case 'error': return chalk.red('Error');
+        default: return chalk.dim(status ?? 'unknown');
+    }
+}
+function formatVerdict(verdict) {
+    switch (verdict) {
+        case 'clean': return chalk.green('Clean');
+        case 'has-issues': return chalk.yellow('Has issues');
+        case 'needs-review': return chalk.cyan('Needs review');
+        default: return chalk.dim(verdict ?? 'n/a');
+    }
+}
+// ============================================================================
+// API call
+// ============================================================================
+const HAYSTACK_API = 'https://haystackeditor.com';
+async function fetchClassification(owner, repo, prNumber, token) {
+    const prId = `${owner}/${repo}#${prNumber}`;
+    const response = await fetch(`${HAYSTACK_API}/auth/classify-debug?pr=${encodeURIComponent(prId)}`, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'User-Agent': 'Haystack-CLI',
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Authentication failed. Run `haystack login` to re-authenticate.');
+        }
+        if (response.status === 403) {
+            throw new Error('Access denied — you may not have permission to this repository.');
+        }
+        const body = await response.text().catch(() => '');
+        throw new Error(`API error (${response.status}): ${body}`);
+    }
+    return response.json();
+}
+// ============================================================================
+// Command
+// ============================================================================
+export async function prStatusCommand(identifier, options) {
+    let pr;
+    try {
+        pr = parsePRIdentifier(identifier);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    const token = await loadToken();
+    if (!token) {
+        console.error(chalk.red('\nNot logged in. Run `haystack login` first.\n'));
+        process.exit(1);
+    }
+    const prLabel = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
+    if (!options.json) {
+        console.log(chalk.dim(`\nFetching status for ${prLabel}...\n`));
+    }
+    let data;
+    try {
+        data = await fetchClassification(pr.owner, pr.repo, pr.prNumber, token);
+    }
+    catch (err) {
+        console.error(chalk.red(`\n${err.message}\n`));
+        process.exit(1);
+    }
+    // JSON mode — pure JSON to stdout, nothing else
+    if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    // Human-readable output
+    console.log(`  ${chalk.bold('PR')}:        ${data.prId}`);
+    console.log(`  ${chalk.bold('Status')}:    ${formatBucket(data.bucket)}`);
+    console.log(`  ${chalk.bold('Analysis')}:  ${formatAnalysisStatus(data.inputs.analysisStatus)}`);
+    if (data.inputs.analysisVerdict) {
+        console.log(`  ${chalk.bold('Verdict')}:   ${formatVerdict(data.inputs.analysisVerdict)}`);
+    }
+    if (data.inputs.haystackRating != null) {
+        console.log(`  ${chalk.bold('Rating')}:    ${data.inputs.haystackRating}/5`);
+    }
+    console.log(`  ${chalk.bold('Reason')}:    ${chalk.dim(data.reason)}`);
+    // Extra context
+    if (!data.inputs.isOpen) {
+        console.log(chalk.dim(`\n  PR is closed or merged.`));
+    }
+    if (!data.inputs.isAuthor) {
+        console.log(chalk.dim(`\n  You are not the author (author: ${data.inputs.author}).`));
+    }
+    // Labels of interest
+    const haystackLabels = (data.inputs.labels || []).filter(l => l.startsWith('haystack:'));
+    if (haystackLabels.length > 0) {
+        console.log(`  ${chalk.bold('Labels')}:    ${haystackLabels.join(', ')}`);
+    }
+    // User overrides
+    const overrides = [];
+    if (data.inputs.dismissed)
+        overrides.push('dismissed');
+    if (data.inputs.dismissedAgentAlerts)
+        overrides.push('agent alerts dismissed');
+    if (data.inputs.dismissedNeedsAssignment)
+        overrides.push('needs-assignment dismissed');
+    if (data.inputs.manuallyGoodToMerge)
+        overrides.push('manually marked good-to-merge');
+    if (data.inputs.snoozed)
+        overrides.push('snoozed');
+    if (overrides.length > 0) {
+        console.log(`  ${chalk.bold('Overrides')}: ${overrides.join(', ')}`);
+    }
+    // Stale warning
+    if (data.staleWarning) {
+        console.log(chalk.yellow(`\n  Warning: ${data.staleWarning}`));
+    }
+    console.log('');
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * haystack setup - Interactive onboarding wizard
+ *
+ * CLI equivalent of the web onboarding wizard. Walks through:
+ * 1. Login check
+ * 2. Repository selection
+ * 3. Scan for coding rules
+ * 4. Scan for wait-for signals (CI checks, bot reviews)
+ * 5. Scan for review policies
+ * 6. Review discovered items (toggle on/off)
+ * 7. Confirm & write .haystack.json to selected repos
+ */
+export declare function setupCommand(): Promise<void>;