@haystackeditor/cli 0.8.0 → 0.9.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/skills.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Skills command - Copies Haystack skill files into the project
+ * for AI agent discovery (Claude Code, Codex CLI, Cursor)
+ */
+export declare function installSkills(options: {
+    cli?: string;
+}): Promise<void>;
+export declare function listSkills(): Promise<void>;

package/dist/commands/skills.js

@@ -0,0 +1,80 @@
+/**
+ * Skills command - Copies Haystack skill files into the project
+ * for AI agent discovery (Claude Code, Codex CLI, Cursor)
+ */
+import chalk from 'chalk';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Directory containing bundled skill files */
+function getSkillsSourceDir() {
+    // In dist/commands/skills.js → assets are at dist/assets/skills/
+    return join(__dirname, '..', 'assets', 'skills');
+}
+const SKILL_FILES = [
+    'setup-haystack.md',
+    'prepare-haystack.md',
+    'secrets.md',
+    'setup-external-sandbox.md',
+    'submit.md',
+];
+function installSkillFiles(targetDir) {
+    const sourceDir = getSkillsSourceDir();
+    if (!existsSync(sourceDir)) {
+        console.error(chalk.red(`Skills source directory not found: ${sourceDir}`));
+        return false;
+    }
+    // Ensure target directory exists
+    if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    let copied = 0;
+    for (const file of SKILL_FILES) {
+        const src = join(sourceDir, file);
+        if (existsSync(src)) {
+            const dest = join(targetDir, file);
+            writeFileSync(dest, readFileSync(src, 'utf-8'));
+            copied++;
+        }
+    }
+    return copied > 0;
+}
+export async function installSkills(options) {
+    console.log(chalk.cyan('\n📦 Installing Haystack skills...\n'));
+    const projectRoot = process.cwd();
+    // Install to .agents/skills/ for generic agent discovery
+    const agentsSkillsDir = join(projectRoot, '.agents', 'skills');
+    console.log(chalk.gray(`Copying skills to ${agentsSkillsDir}\n`));
+    const success = installSkillFiles(agentsSkillsDir);
+    if (!success) {
+        console.error(chalk.red('Failed to install skill files.'));
+        process.exit(1);
+    }
+    // Also create .claude/commands/ entry for Claude Code slash commands
+    const claudeCommandsDir = join(projectRoot, '.claude', 'commands');
+    if (!existsSync(claudeCommandsDir)) {
+        mkdirSync(claudeCommandsDir, { recursive: true });
+    }
+    const claudeCommandPath = join(claudeCommandsDir, 'setup-haystack.md');
+    writeFileSync(claudeCommandPath, '# Set Up Haystack Verification\n\nFollow .agents/skills/setup-haystack.md to set up Haystack verification for this repo.\n');
+    showSuccessMessage();
+}
+function showSuccessMessage() {
+    console.log(chalk.green('\n✅ Haystack skills installed!\n'));
+    console.log(chalk.white('Available skills:'));
+    console.log(chalk.cyan('  /setup-haystack         ') + chalk.gray('- Create .haystack.json with AI assistance'));
+    console.log(chalk.cyan('  /prepare-haystack       ') + chalk.gray('- Add aria-labels and data-testid attributes'));
+    console.log(chalk.cyan('  /setup-haystack-secrets ') + chalk.gray('- Configure API keys and secrets'));
+    console.log();
+    console.log(chalk.white('Run in your coding CLI:'));
+    console.log(chalk.cyan('  /setup-haystack'));
+    console.log();
+}
+export async function listSkills() {
+    console.log(chalk.white('\nAvailable Haystack skills:\n'));
+    console.log(chalk.cyan('  /setup-haystack         ') + chalk.gray('- Master setup - creates .haystack.json'));
+    console.log(chalk.cyan('  /prepare-haystack       ') + chalk.gray('- Add accessibility attributes'));
+    console.log(chalk.cyan('  /setup-haystack-secrets ') + chalk.gray('- Configure secrets for sandboxes'));
+    console.log();
+}

package/dist/commands/submit.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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
+ */
+export interface SubmitOptions {
+    title?: string;
+    body?: string;
+    bodyFile?: string;
+    base?: string;
+    draft?: boolean;
+    review?: string | true;
+    force?: boolean;
+    wait?: boolean;
+}
+export declare function submitCommand(options: SubmitOptions): Promise<void>;