@haystackeditor/cli 0.8.1 → 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

@@ -1,6 +1,6 @@
 /**
- * Skills command - Registers the haystack-verify MCP server with coding CLIs
- * Supports: Claude Code, Codex CLI, Cursor, and manual setup
+ * 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;

package/dist/commands/skills.js

@@ -1,200 +1,73 @@
 /**
- * Skills command - Registers the haystack-verify MCP server with coding CLIs
- * Supports: Claude Code, Codex CLI, Cursor, and manual setup
+ * Skills command - Copies Haystack skill files into the project
+ * for AI agent discovery (Claude Code, Codex CLI, Cursor)
  */
-import { execSync } from 'child_process';
 import chalk from 'chalk';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-const CLI_CONFIGS = {
-    claude: {
-        name: 'claude',
-        displayName: 'Claude Code',
-        checkCommand: 'which claude',
-        installCommand: 'claude mcp add haystack-verify -- npx @haystackeditor/verify',
-    },
-    codex: {
-        name: 'codex',
-        displayName: 'Codex CLI',
-        checkCommand: 'which codex',
-        installCommand: 'codex mcp add haystack-verify -- npx @haystackeditor/verify',
-    },
-    cursor: {
-        name: 'cursor',
-        displayName: 'Cursor',
-        checkCommand: '', // Cursor is always "available" - we check config file
-        installCommand: '', // We modify config directly
-        configPath: join(homedir(), '.cursor', 'mcp.json'),
-    },
-    manual: {
-        name: 'manual',
-        displayName: 'Manual Setup',
-        checkCommand: '',
-        installCommand: '',
-    },
-};
-function detectAvailableCLIs() {
-    const available = [];
-    // Check Claude Code
-    try {
-        execSync('which claude', { stdio: 'ignore' });
-        available.push('claude');
-    }
-    catch { }
-    // Check Codex CLI
-    try {
-        execSync('which codex', { stdio: 'ignore' });
-        available.push('codex');
-    }
-    catch { }
-    // Check Cursor (config-based)
-    const cursorConfigDir = join(homedir(), '.cursor');
-    if (existsSync(cursorConfigDir)) {
-        available.push('cursor');
-    }
-    return available;
-}
-function installForClaude() {
-    const config = CLI_CONFIGS.claude;
-    console.log(chalk.gray(`Running: ${config.installCommand}\n`));
-    try {
-        execSync(config.installCommand, { stdio: 'inherit' });
-        return true;
-    }
-    catch {
-        return false;
-    }
+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');
 }
-function installForCodex() {
-    const config = CLI_CONFIGS.codex;
-    console.log(chalk.gray(`Running: ${config.installCommand}\n`));
-    try {
-        execSync(config.installCommand, { stdio: 'inherit' });
-        return true;
-    }
-    catch {
+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;
     }
-}
-function installForCursor() {
-    const configPath = CLI_CONFIGS.cursor.configPath;
-    const configDir = join(homedir(), '.cursor');
-    console.log(chalk.gray(`Updating: ${configPath}\n`));
-    try {
-        // Ensure directory exists
-        if (!existsSync(configDir)) {
-            mkdirSync(configDir, { recursive: true });
-        }
-        // Read or create config
-        let config = {};
-        if (existsSync(configPath)) {
-            const content = readFileSync(configPath, 'utf-8');
-            config = JSON.parse(content);
+    // 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++;
         }
-        // Add haystack-verify server
-        config.mcpServers = config.mcpServers || {};
-        config.mcpServers['haystack-verify'] = {
-            command: 'npx',
-            args: ['@haystackeditor/verify'],
-        };
-        // Write config
-        writeFileSync(configPath, JSON.stringify(config, null, 2));
-        return true;
-    }
-    catch (error) {
-        console.error(chalk.red(`Failed to update Cursor config: ${error}`));
-        return false;
     }
-}
-function showManualInstructions() {
-    console.log(chalk.white('\n📋 Manual Setup Instructions\n'));
-    console.log(chalk.cyan('Claude Code:'));
-    console.log(chalk.gray('  claude mcp add haystack-verify -- npx @haystackeditor/verify\n'));
-    console.log(chalk.cyan('Codex CLI:'));
-    console.log(chalk.gray('  codex mcp add haystack-verify -- npx @haystackeditor/verify\n'));
-    console.log(chalk.cyan('Cursor:'));
-    console.log(chalk.gray('  Add to ~/.cursor/mcp.json:'));
-    console.log(chalk.gray(`  {
-    "mcpServers": {
-      "haystack-verify": {
-        "command": "npx",
-        "args": ["@haystackeditor/verify"]
-      }
-    }
-  }\n`));
-    console.log(chalk.cyan('VS Code + Continue:'));
-    console.log(chalk.gray('  Add to .continue/config.json or settings\n'));
+    return copied > 0;
 }
 export async function installSkills(options) {
     console.log(chalk.cyan('\n📦 Installing Haystack skills...\n'));
-    // If CLI specified, use it directly
-    if (options.cli) {
-        const cli = options.cli.toLowerCase();
-        if (cli === 'manual') {
-            showManualInstructions();
-            return;
-        }
-        if (!['claude', 'codex', 'cursor'].includes(cli)) {
-            console.log(chalk.red(`Unknown CLI: ${options.cli}`));
-            console.log(chalk.gray('Supported: claude, codex, cursor, manual'));
-            process.exit(1);
-        }
-        const success = await installForCLI(cli);
-        if (success) {
-            showSuccessMessage(cli);
-        }
-        return;
-    }
-    // Auto-detect available CLIs
-    const available = detectAvailableCLIs();
-    if (available.length === 0) {
-        console.log(chalk.yellow('No supported coding CLI detected.\n'));
-        showManualInstructions();
-        return;
-    }
-    if (available.length === 1) {
-        // Only one CLI available, use it
-        const cli = available[0];
-        console.log(chalk.gray(`Detected: ${CLI_CONFIGS[cli].displayName}\n`));
-        const success = await installForCLI(cli);
-        if (success) {
-            showSuccessMessage(cli);
-        }
-        return;
-    }
-    // Multiple CLIs available - install for all
-    console.log(chalk.gray(`Detected: ${available.map(c => CLI_CONFIGS[c].displayName).join(', ')}\n`));
-    for (const cli of available) {
-        console.log(chalk.white(`\nInstalling for ${CLI_CONFIGS[cli].displayName}...`));
-        await installForCLI(cli);
-    }
-    console.log(chalk.green('\n✅ Haystack skills installed!\n'));
-    console.log(chalk.white('Run one of these in your coding CLI:'));
-    console.log(chalk.cyan('  /setup-haystack'));
-    console.log();
-}
-async function installForCLI(cli) {
-    switch (cli) {
-        case 'claude':
-            return installForClaude();
-        case 'codex':
-            return installForCodex();
-        case 'cursor':
-            return installForCursor();
-        default:
-            return false;
-    }
+    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(cli) {
-    const config = CLI_CONFIGS[cli];
+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(`Open ${config.displayName} and run:`));
+    console.log(chalk.white('Run in your coding CLI:'));
     console.log(chalk.cyan('  /setup-haystack'));
     console.log();
 }
@@ -204,12 +77,4 @@ export async function listSkills() {
     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();
-    const available = detectAvailableCLIs();
-    if (available.length > 0) {
-        console.log(chalk.gray('Detected CLIs: ') + chalk.white(available.map(c => CLI_CONFIGS[c].displayName).join(', ')));
-    }
-    else {
-        console.log(chalk.gray('No coding CLI detected. Run: ') + chalk.white('haystack skills install --cli manual'));
-    }
-    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>;