@haystackeditor/cli 0.7.2 → 0.8.1

package/dist/commands/init.js

@@ -3,7 +3,6 @@
  *
  * Creates .haystack.json with auto-detected settings.
  */
-import inquirer from 'inquirer';
 import chalk from 'chalk';
 import * as path from 'path';
 import { detectProject } from '../utils/detect.js';
@@ -11,27 +10,11 @@ import { saveConfig, configExists } from '../utils/config.js';
 import { createSkillFile, createClaudeCommand } from '../utils/skill.js';
 import { validateConfigSecurity, formatSecurityReport } from '../utils/secrets.js';
 export async function initCommand(options) {
-    // Auto-use defaults when not in interactive terminal (e.g., when run by AI agents)
-    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
-    if (!isInteractive && !options.yes) {
-        console.log(chalk.dim('Non-interactive mode detected. Using --yes defaults.\n'));
-        options.yes = true;
-    }
-    console.log(chalk.cyan('\n🌾 Haystack Setup Wizard\n'));
+    console.log(chalk.cyan('\n🌾 Haystack Setup\n'));
     // Check if config already exists
-    if (await configExists()) {
-        const { overwrite } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'overwrite',
-                message: '.haystack.json already exists. Overwrite?',
-                default: false,
-            },
-        ]);
-        if (!overwrite) {
-            console.log(chalk.yellow('Setup cancelled.'));
-            return;
-        }
+    if (await configExists() && !options.force) {
+        console.log(chalk.yellow('.haystack.json already exists. Use --force to overwrite.\n'));
+        return;
     }
     // Detect project
     console.log(chalk.dim('Detecting project configuration...\n'));
@@ -45,107 +28,31 @@ export async function initCommand(options) {
     if (detected.isMonorepo) {
         console.log(`  Monorepo: ${chalk.bold(detected.monorepoTool || 'yes')}`);
         if (detected.services?.length) {
-            console.log(`  Services: ${chalk.bold(detected.services.map((s) => s.name).join(', '))}`);
+            console.log(`  Services: ${chalk.bold(detected.services.length)} packages detected`);
         }
     }
     console.log('');
-    // If --yes flag, use all defaults
-    if (options.yes) {
-        const config = buildConfigFromDetection(detected);
-        const configPath = await saveConfig(config);
-        console.log(chalk.green(`✓ Created ${configPath}`));
-        // Create skill file for agent discovery
-        const skillPath = await createSkillFile();
-        console.log(chalk.green(`✓ Created ${skillPath}`));
-        // Create Claude Code slash command
-        const commandPath = await createClaudeCommand();
-        console.log(chalk.green(`✓ Created ${commandPath} (use /haystack in Claude Code)\n`));
-        // Security validation
-        await runSecurityCheck(configPath);
-        // Print the prompt for the AI agent to follow
-        console.log(chalk.cyan('━'.repeat(70)));
-        console.log(chalk.cyan.bold('\n📋 NEXT STEP: Add verification flows\n'));
-        console.log(chalk.white('The config has dev server settings. Now add flows to tell Haystack'));
-        console.log(chalk.white('what to verify when PRs are opened.\n'));
-        console.log(chalk.yellow.bold('Give this prompt to your AI coding agent:\n'));
-        console.log(chalk.cyan('━'.repeat(70)));
-        console.log(`
-${chalk.white('Add Haystack verification flows to .haystack.json')}
-
-${chalk.bold('STEP 1: Understand the app')}
-- Read src/App.tsx and the main components
-- Write 2 sentences: What does this app do? What's the core feature?
-
-${chalk.bold('STEP 2: Identify what PRs would touch')}
-- List the 5 most important UI areas that PRs change
-- These need the most thorough flows
-
-${chalk.bold('STEP 3: Add flows')}
-- Read .agents/skills/haystack.md for the flow format
-- Add flows for the 5 core areas first, then secondary pages
-
-${chalk.bold('STEP 4: Validate')}
-- Confirm the core feature from Step 1 has flows
-- Verify selectors are specific (not generic like "#root")
-`);
-        console.log(chalk.cyan('━'.repeat(70)));
-        return;
-    }
-    // Interactive prompts
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'name',
-            message: 'Project name:',
-            default: path.basename(process.cwd()),
-        },
-        {
-            type: 'confirm',
-            name: 'isMonorepo',
-            message: 'Is this a monorepo with multiple services?',
-            default: detected.isMonorepo,
-        },
-    ]);
-    let config;
-    if (answers.isMonorepo) {
-        config = await configureMonorepo(detected, answers.name);
-    }
-    else {
-        config = await configureSingleService(detected, answers.name);
-    }
-    // Verification commands
-    const { commands } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'commands',
-            message: 'Verification commands (comma-separated):',
-            default: `${detected.packageManager} build, ${detected.packageManager} lint, ${detected.packageManager} tsc --noEmit`,
-        },
-    ]);
-    config.verification = {
-        commands: commands
-            .split(',')
-            .map((cmd) => cmd.trim())
-            .filter(Boolean)
-            .map((cmd) => {
-            const name = cmd.split(' ').pop() || cmd;
-            return { name, run: cmd };
-        }),
-    };
-    // Save config
+    // Build config from detection (no interactive prompts)
+    const config = buildConfigFromDetection(detected);
     const configPath = await saveConfig(config);
     console.log(chalk.green(`✓ Created ${configPath}`));
     // Create skill file for agent discovery
     const skillPath = await createSkillFile();
-    console.log(chalk.green(`✓ Created ${skillPath}\n`));
-    // Show the generated config
-    console.log(chalk.dim('Generated configuration:'));
-    console.log(chalk.dim('─'.repeat(40)));
-    console.log(JSON.stringify(config, null, 2));
-    console.log(chalk.dim('─'.repeat(40)));
+    console.log(chalk.green(`✓ Created ${skillPath}`));
+    // Create Claude Code slash command
+    const commandPath = await createClaudeCommand();
+    console.log(chalk.green(`✓ Created ${commandPath}`));
     // Security validation
     await runSecurityCheck(configPath);
-    printNextSteps();
+    // Print next steps - direct to skill
+    console.log(chalk.cyan('\n━'.repeat(60)));
+    console.log(chalk.cyan.bold('\n📋 NEXT: Add verification flows\n'));
+    console.log(chalk.white('Base config created. Now an AI agent needs to add flows.\n'));
+    console.log(chalk.bold('Option 1: Claude Code'));
+    console.log(chalk.dim('  Run /setup-haystack in Claude Code\n'));
+    console.log(chalk.bold('Option 2: Other AI agents'));
+    console.log(chalk.dim('  Give your agent: "Read .agents/skills/setup-haystack.md and follow it"\n'));
+    console.log(chalk.cyan('━'.repeat(60) + '\n'));
 }
 /**
  * Run security check on config file
@@ -161,125 +68,6 @@ async function runSecurityCheck(configPath) {
         console.log(chalk.dim('\n' + formatSecurityReport(findings)));
     }
 }
-async function configureSingleService(detected, name) {
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'command',
-            message: 'Dev server command:',
-            default: detected.suggestedDevCommand,
-        },
-        {
-            type: 'number',
-            name: 'port',
-            message: 'Dev server port:',
-            default: detected.suggestedPort,
-        },
-        {
-            type: 'input',
-            name: 'readyPattern',
-            message: 'Ready pattern (stdout text when server is ready):',
-            default: detected.suggestedReadyPattern,
-        },
-        {
-            type: 'input',
-            name: 'authBypass',
-            message: 'Auth bypass env var (leave blank if no auth):',
-            default: detected.suggestedAuthBypass,
-        },
-    ]);
-    const env = {};
-    if (answers.authBypass) {
-        const [key, value] = answers.authBypass.split('=');
-        env[key] = value || 'true';
-    }
-    return {
-        version: '1',
-        name,
-        dev_server: {
-            command: answers.command,
-            port: answers.port,
-            ready_pattern: answers.readyPattern,
-            ...(Object.keys(env).length > 0 ? { env } : {}),
-        },
-    };
-}
-async function configureMonorepo(detected, name) {
-    // Get list of services
-    const detectedServices = detected.services || [];
-    const serviceNames = detectedServices.map((s) => s.name);
-    const { selectedServices } = await inquirer.prompt([
-        {
-            type: 'checkbox',
-            name: 'selectedServices',
-            message: 'Which services should the sandbox run?',
-            choices: serviceNames.length > 0 ? serviceNames : ['frontend', 'api'],
-            default: serviceNames,
-        },
-    ]);
-    // Ask about auth bypass
-    const { authBypass } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'authBypass',
-            message: 'Auth bypass env var (applied to all services):',
-            default: detected.suggestedAuthBypass,
-        },
-    ]);
-    const services = {};
-    for (const serviceName of selectedServices) {
-        const detectedService = detectedServices.find((s) => s.name === serviceName);
-        console.log(chalk.dim(`\nConfiguring ${serviceName}...`));
-        const answers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'root',
-                message: `  Directory:`,
-                default: detectedService?.root || './',
-            },
-            {
-                type: 'input',
-                name: 'command',
-                message: `  Command:`,
-                default: detectedService?.suggestedCommand || `${detected.packageManager} dev`,
-            },
-            {
-                type: 'list',
-                name: 'type',
-                message: `  Type:`,
-                choices: ['server', 'batch'],
-                default: detectedService?.type || 'server',
-            },
-            {
-                type: 'number',
-                name: 'port',
-                message: `  Port:`,
-                default: detectedService?.suggestedPort || 3000,
-                when: (ans) => ans.type === 'server',
-            },
-        ]);
-        const env = {};
-        if (authBypass) {
-            const [key, value] = authBypass.split('=');
-            env[key] = value || 'true';
-        }
-        // Check if this service has detected dependencies
-        const dependsOn = detectedService?.suggestedDependsOn?.filter((dep) => selectedServices.includes(dep));
-        services[serviceName] = {
-            ...(answers.root !== './' ? { root: answers.root } : {}),
-            command: answers.command,
-            ...(answers.type === 'server' ? { port: answers.port } : { type: 'batch' }),
-            ready_pattern: 'ready|started|listening|Local:',
-            ...(Object.keys(env).length > 0 ? { env } : {}),
-            ...(dependsOn?.length ? { depends_on: dependsOn } : {}),
-        };
-    }
-    return {
-        version: '1',
-        name,
-        services,
-    };
-}
 function buildConfigFromDetection(detected) {
     const env = {};
     if (detected.suggestedAuthBypass) {
@@ -328,10 +116,3 @@ function buildConfigFromDetection(detected) {
         },
     };
 }
-function printNextSteps() {
-    console.log(chalk.cyan('Next steps:'));
-    console.log(`  1. Review .haystack.json and adjust as needed`);
-    console.log(`  2. Add auth bypass env var if your app requires login`);
-    console.log(`  3. Add flows to describe key user journeys to verify`);
-    console.log(`  4. Commit: ${chalk.green('git add .haystack.json .agents/ && git commit -m "Add Haystack"')}\n`);
-}

package/dist/commands/secrets.d.ts

@@ -12,6 +12,21 @@ export declare function setSecret(key: string, value: string, options: {
     scope?: string;
     scopeId?: string;
 }): Promise<void>;
+/**
+ * Get a secret value (for programmatic use)
+ * Returns the value to stdout for piping to other commands.
+ * Use --quiet to suppress all output except the value.
+ */
+export declare function getSecret(key: string, options: {
+    quiet?: boolean;
+}): Promise<void>;
+/**
+ * Get multiple secrets needed by a repo's .haystack.json
+ * Returns JSON object with key-value pairs.
+ */
+export declare function getSecretsForRepo(keys: string[], options: {
+    json?: boolean;
+}): Promise<void>;
 /**
  * Delete a secret
  */

package/dist/commands/secrets.js

@@ -101,6 +101,89 @@ export async function setSecret(key, value, options) {
         process.exit(1);
     }
 }
+/**
+ * Get a secret value (for programmatic use)
+ * Returns the value to stdout for piping to other commands.
+ * Use --quiet to suppress all output except the value.
+ */
+export async function getSecret(key, options) {
+    const token = await requireAuth();
+    if (!key) {
+        console.error(chalk.red('\nUsage: haystack secrets get KEY\n'));
+        process.exit(1);
+    }
+    try {
+        const response = await apiRequest('GET', `/${encodeURIComponent(key)}`, token);
+        if (!response.ok) {
+            if (response.status === 401) {
+                if (!options.quiet) {
+                    console.error(chalk.red('Session expired. Run `haystack login` again.\n'));
+                }
+                process.exit(1);
+            }
+            if (response.status === 404) {
+                if (!options.quiet) {
+                    console.error(chalk.yellow(`\nSecret ${key} not found.\n`));
+                }
+                process.exit(1);
+            }
+            throw new Error(`Failed to get secret: ${response.status}`);
+        }
+        const data = await response.json();
+        // Output just the value (no newline if quiet, for piping)
+        if (options.quiet) {
+            process.stdout.write(data.value);
+        }
+        else {
+            console.log(data.value);
+        }
+    }
+    catch (error) {
+        if (!options.quiet) {
+            console.error(chalk.red(`\nError: ${error.message}\n`));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Get multiple secrets needed by a repo's .haystack.json
+ * Returns JSON object with key-value pairs.
+ */
+export async function getSecretsForRepo(keys, options) {
+    const token = await requireAuth();
+    if (keys.length === 0) {
+        console.error(chalk.red('\nUsage: haystack secrets get-for-repo KEY1 KEY2 ...\n'));
+        process.exit(1);
+    }
+    try {
+        const response = await apiRequest('POST', '/batch', token, { keys });
+        if (!response.ok) {
+            if (response.status === 401) {
+                console.error(chalk.red('Session expired. Run `haystack login` again.\n'));
+                process.exit(1);
+            }
+            throw new Error(`Failed to get secrets: ${response.status}`);
+        }
+        const data = await response.json();
+        if (options.json) {
+            console.log(JSON.stringify(data.secrets));
+        }
+        else {
+            if (data.missing.length > 0) {
+                console.log(chalk.yellow(`\nMissing secrets: ${data.missing.join(', ')}\n`));
+            }
+            console.log(chalk.bold('\nSecrets loaded:\n'));
+            for (const [k, v] of Object.entries(data.secrets)) {
+                console.log(`  ${chalk.cyan(k)}: ${chalk.dim('***' + v.slice(-4))}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`\nError: ${error.message}\n`));
+        process.exit(1);
+    }
+}
 /**
  * Delete a secret
  */

package/dist/commands/skills.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Skills command - Registers the haystack-verify MCP server with coding CLIs
+ * Supports: Claude Code, Codex CLI, Cursor, and manual setup
+ */
+export declare function installSkills(options: {
+    cli?: string;
+}): Promise<void>;
+export declare function listSkills(): Promise<void>;

package/dist/commands/skills.js

@@ -0,0 +1,215 @@
+/**
+ * Skills command - Registers the haystack-verify MCP server with coding CLIs
+ * Supports: Claude Code, Codex CLI, Cursor, and manual setup
+ */
+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;
+    }
+}
+function installForCodex() {
+    const config = CLI_CONFIGS.codex;
+    console.log(chalk.gray(`Running: ${config.installCommand}\n`));
+    try {
+        execSync(config.installCommand, { stdio: 'inherit' });
+        return true;
+    }
+    catch {
+        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);
+        }
+        // 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'));
+}
+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;
+    }
+}
+function showSuccessMessage(cli) {
+    const config = CLI_CONFIGS[cli];
+    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.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();
+    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();
+}