@haystackeditor/cli 0.10.1 → 0.10.3

package/dist/tools/setup.d.ts

@@ -1,43 +0,0 @@
-import { HaystackConfig } from '../types.js';
-import { ProjectDetection, DetectedService } from './detect.js';
-/**
- * Interactive setup flow for .haystack.json
- *
- * The MCP tool will return questions one at a time.
- * The agent asks the user, collects answers, and calls back
- * until the config is complete.
- */
-export interface SetupQuestion {
-    id: string;
-    question: string;
-    type: 'text' | 'select' | 'multiselect' | 'confirm';
-    options?: string[];
-    default?: string;
-    hint?: string;
-}
-export interface SetupState {
-    step: 'project_name' | 'is_monorepo' | 'services_list' | 'service_details' | 'dev_command' | 'dev_port' | 'dev_ready_pattern' | 'verification_commands' | 'auth_needs_signin' | 'auth_strategy' | 'auth_env' | 'auth_token_type' | 'auth_token_name' | 'auth_token_secret' | 'db_needs_database' | 'db_strategy' | 'db_env' | 'db_seed_command' | 'complete';
-    answers: Record<string, unknown>;
-    config: Partial<HaystackConfig>;
-    /** For monorepo setup: which service we're configuring */
-    currentServiceIndex?: number;
-    /** For monorepo setup: list of services to configure */
-    serviceNames?: string[];
-    /** Auto-detected project info */
-    detection?: ProjectDetection;
-    /** Auto-detected services (for smart defaults) */
-    detectedServices?: DetectedService[];
-}
-export declare function createInitialState(rootDir?: string): SetupState;
-/**
- * Get a default value based on auto-detection.
- */
-export declare function getDetectedDefault(state: SetupState, questionId: string): string | undefined;
-export declare function getNextQuestion(state: SetupState): SetupQuestion | null;
-export declare function advanceStep(state: SetupState): SetupState;
-/**
- * Build the final .haystack.json config from collected answers.
- * This generates the schema that sandbox.py expects.
- */
-export declare function buildConfig(state: SetupState): HaystackConfig;
-export declare function configToJson(config: HaystackConfig): string;

package/dist/tools/setup.js

@@ -1,597 +0,0 @@
-import { detectProject } from './detect.js';
-const QUESTIONS = {
-    project_name: {
-        id: 'project_name',
-        question: "What's the name of your project?",
-        type: 'text',
-        hint: 'This is just for display purposes in Haystack',
-    },
-    is_monorepo: {
-        id: 'is_monorepo',
-        question: 'Is this a monorepo with multiple services?',
-        type: 'select',
-        options: [
-            'no - Single app/service (frontend only)',
-            'yes - Multiple services (frontend + backend workers, APIs, etc.)',
-        ],
-        hint: 'Monorepos can have different dev servers for each service',
-    },
-    services_list: {
-        id: 'services_list',
-        question: 'What services does your monorepo have? (comma-separated)',
-        type: 'text',
-        default: 'frontend, api',
-        hint: 'e.g., frontend, api-worker, auth-worker',
-    },
-    service_root: {
-        id: 'service_root',
-        question: 'What directory is this service in?',
-        type: 'text',
-        default: './',
-        hint: 'Relative to repo root, e.g., ./, infra/api-worker',
-    },
-    service_command: {
-        id: 'service_command',
-        question: 'What command starts this service?',
-        type: 'text',
-        default: 'pnpm dev',
-        hint: 'e.g., pnpm dev, pnpm wrangler dev --local',
-    },
-    service_port: {
-        id: 'service_port',
-        question: 'What port does this service run on?',
-        type: 'text',
-        hint: 'Leave blank for batch jobs that exit after running',
-    },
-    service_type: {
-        id: 'service_type',
-        question: 'What type of service is this?',
-        type: 'select',
-        options: [
-            'server - Long-running server (frontend, API, worker)',
-            'batch - Runs once and exits (analysis, build, migration)',
-        ],
-    },
-    service_depends_on: {
-        id: 'service_depends_on',
-        question: 'What other services does this depend on? (comma-separated, leave blank if none)',
-        type: 'text',
-        hint: 'e.g., api-worker, auth-worker. These will start before this service.',
-    },
-    dev_command: {
-        id: 'dev_command',
-        question: 'What command starts your dev server?',
-        type: 'text',
-        default: 'pnpm dev',
-        hint: 'e.g., npm run dev, pnpm dev, yarn start',
-    },
-    dev_port: {
-        id: 'dev_port',
-        question: 'What port does your dev server run on?',
-        type: 'text',
-        default: '3000',
-    },
-    dev_ready_pattern: {
-        id: 'dev_ready_pattern',
-        question: 'What text appears in the terminal when the server is ready?',
-        type: 'text',
-        default: 'Local:',
-        hint: 'e.g., "Local:", "ready in", "listening on"',
-    },
-    verification_commands: {
-        id: 'verification_commands',
-        question: 'What commands should run to verify changes? (comma-separated)',
-        type: 'text',
-        default: 'pnpm build, pnpm lint, pnpm tsc --noEmit',
-        hint: 'These run during sandbox creation. Results are cached.',
-    },
-    auth_needs_signin: {
-        id: 'auth_needs_signin',
-        question: 'Does your app need signed-in user flows for verification?',
-        type: 'select',
-        options: [
-            'no - App works without auth or has an auth bypass env var',
-            'yes - Some flows need authenticated state to test properly',
-        ],
-        hint: 'e.g., dashboards, user profiles, or admin features',
-    },
-    auth_strategy: {
-        id: 'auth_strategy',
-        question: 'How would you like to handle authentication in sandboxes?',
-        type: 'select',
-        options: [
-            'bypass - Use an env var to skip auth (recommended if your app supports it)',
-            'fixture - Mock auth endpoints with fixture data',
-            'token - Inject a pre-generated session token (cookie or localStorage)',
-            'test_account - Run full login flow with test credentials',
-        ],
-        hint: 'Bypass is simplest. Token injection works for most apps.',
-    },
-    auth_env: {
-        id: 'auth_env',
-        question: 'What env var bypasses auth?',
-        type: 'text',
-        default: 'SKIP_AUTH=true',
-        hint: 'Format: VAR_NAME=value (e.g., VITE_SKIP_AUTH=true, NEXT_PUBLIC_SKIP_AUTH=true)',
-    },
-    auth_token_type: {
-        id: 'auth_token_type',
-        question: 'Where should the auth token be stored?',
-        type: 'select',
-        options: [
-            'cookie - Session cookie (most common)',
-            'localStorage - Browser localStorage',
-            'sessionStorage - Browser sessionStorage',
-        ],
-    },
-    auth_token_name: {
-        id: 'auth_token_name',
-        question: "What's the name of the auth token/cookie?",
-        type: 'text',
-        default: 'session',
-        hint: 'e.g., session, auth_token, access_token, Authorization',
-    },
-    auth_token_secret: {
-        id: 'auth_token_secret',
-        question: "What secret name should store the token value?",
-        type: 'text',
-        default: 'AUTH_TOKEN',
-        hint: "You'll set the actual value with: haystack secrets set AUTH_TOKEN <your-token>",
-    },
-    db_needs_database: {
-        id: 'db_needs_database',
-        question: 'Does your app need a database for verification?',
-        type: 'select',
-        options: [
-            'no - API responses will be mocked with fixtures (recommended)',
-            'yes - Need real database queries to test properly',
-        ],
-        hint: 'Fixtures are simpler. Only use a database if you need write operations or complex queries.',
-    },
-    db_strategy: {
-        id: 'db_strategy',
-        question: 'How should the database be configured in sandboxes?',
-        type: 'select',
-        options: [
-            'memory - In-memory database (SQLite :memory:)',
-            'seed - File-based database with seed data',
-            'docker - Spin up database containers (Postgres, MySQL, Redis)',
-        ],
-        hint: 'Memory is simplest. Use Docker for production-like testing.',
-    },
-    db_env: {
-        id: 'db_env',
-        question: 'What environment variable sets the database connection?',
-        type: 'text',
-        default: 'DATABASE_URL=sqlite::memory:',
-        hint: 'Format: VAR=value. For SQLite: DATABASE_URL=sqlite::memory: or file:./test.db',
-    },
-    db_seed_command: {
-        id: 'db_seed_command',
-        question: 'What command seeds the database? (leave blank if none)',
-        type: 'text',
-        default: '',
-        hint: 'e.g., pnpm db:seed, pnpm prisma db seed, pnpm knex seed:run',
-    },
-};
-export function createInitialState(rootDir = process.cwd()) {
-    const detection = detectProject(rootDir);
-    return {
-        step: 'project_name',
-        answers: {},
-        config: {},
-        detection,
-        detectedServices: detection.services,
-    };
-}
-/**
- * Get a default value based on auto-detection.
- */
-export function getDetectedDefault(state, questionId) {
-    const detection = state.detection;
-    if (!detection)
-        return undefined;
-    switch (questionId) {
-        case 'project_name':
-            return detection.suggestions.projectName;
-        case 'is_monorepo':
-            return detection.isMonorepo
-                ? 'yes - Multiple services (frontend + backend workers, APIs, etc.)'
-                : 'no - Single app/service (frontend only)';
-        case 'dev_command':
-            return detection.suggestions.devCommand;
-        case 'dev_port':
-            return String(detection.suggestions.port);
-        case 'dev_ready_pattern':
-            return detection.suggestions.readyPattern;
-        case 'auth_env':
-            return detection.suggestions.authBypassEnv || '';
-        case 'services_list':
-            // Use detected services if available
-            if (detection.services.length > 0) {
-                return detection.services.map((s) => s.name).join(', ');
-            }
-            return undefined;
-        default:
-            // Handle service-specific questions
-            if (questionId.startsWith('service_')) {
-                const parts = questionId.split('_');
-                const serviceName = parts.slice(1, -1).join('_');
-                const field = parts[parts.length - 1];
-                const detectedService = state.detectedServices?.find((s) => s.name === serviceName);
-                if (detectedService) {
-                    switch (field) {
-                        case 'root':
-                            return detectedService.root;
-                        case 'command':
-                            return detectedService.framework?.devCommand || 'pnpm dev';
-                        case 'port':
-                            return detectedService.framework?.port?.toString();
-                        case 'type':
-                            return detectedService.type === 'batch'
-                                ? 'batch - Runs once and exits (analysis, build, migration)'
-                                : 'server - Long-running server (frontend, API, worker)';
-                        case 'depends_on':
-                            return detectedService.depends_on?.join(', ') || '';
-                    }
-                }
-            }
-            return undefined;
-    }
-}
-export function getNextQuestion(state) {
-    const applyDefault = (question) => {
-        const detectedDefault = getDetectedDefault(state, question.id);
-        if (detectedDefault) {
-            return { ...question, default: detectedDefault };
-        }
-        return question;
-    };
-    switch (state.step) {
-        case 'project_name':
-            return applyDefault(QUESTIONS.project_name);
-        case 'is_monorepo':
-            return applyDefault(QUESTIONS.is_monorepo);
-        case 'services_list':
-            return applyDefault(QUESTIONS.services_list);
-        case 'service_details': {
-            const serviceNames = state.serviceNames || [];
-            const idx = state.currentServiceIndex || 0;
-            const serviceName = serviceNames[idx];
-            if (!serviceName)
-                return null;
-            const serviceKey = `service_${serviceName}`;
-            if (!state.answers[`${serviceKey}_root`]) {
-                const question = {
-                    ...QUESTIONS.service_root,
-                    id: `${serviceKey}_root`,
-                    question: `[${serviceName}] ${QUESTIONS.service_root.question}`,
-                };
-                return applyDefault(question);
-            }
-            if (!state.answers[`${serviceKey}_command`]) {
-                const question = {
-                    ...QUESTIONS.service_command,
-                    id: `${serviceKey}_command`,
-                    question: `[${serviceName}] ${QUESTIONS.service_command.question}`,
-                };
-                return applyDefault(question);
-            }
-            if (!state.answers[`${serviceKey}_type`]) {
-                const question = {
-                    ...QUESTIONS.service_type,
-                    id: `${serviceKey}_type`,
-                    question: `[${serviceName}] ${QUESTIONS.service_type.question}`,
-                };
-                return applyDefault(question);
-            }
-            const serviceType = state.answers[`${serviceKey}_type`];
-            if (serviceType?.startsWith('server') && !state.answers[`${serviceKey}_port`]) {
-                const question = {
-                    ...QUESTIONS.service_port,
-                    id: `${serviceKey}_port`,
-                    question: `[${serviceName}] ${QUESTIONS.service_port.question}`,
-                };
-                return applyDefault(question);
-            }
-            // Ask about dependencies (only for frontend/main services that might proxy to others)
-            if (state.answers[`${serviceKey}_depends_on`] === undefined) {
-                const question = {
-                    ...QUESTIONS.service_depends_on,
-                    id: `${serviceKey}_depends_on`,
-                    question: `[${serviceName}] ${QUESTIONS.service_depends_on.question}`,
-                };
-                return applyDefault(question);
-            }
-            return null;
-        }
-        case 'dev_command':
-            return applyDefault(QUESTIONS.dev_command);
-        case 'dev_port':
-            return applyDefault(QUESTIONS.dev_port);
-        case 'dev_ready_pattern':
-            return applyDefault(QUESTIONS.dev_ready_pattern);
-        case 'verification_commands':
-            return applyDefault(QUESTIONS.verification_commands);
-        case 'auth_needs_signin':
-            return applyDefault(QUESTIONS.auth_needs_signin);
-        case 'auth_strategy':
-            return applyDefault(QUESTIONS.auth_strategy);
-        case 'auth_env':
-            return applyDefault(QUESTIONS.auth_env);
-        case 'auth_token_type':
-            return applyDefault(QUESTIONS.auth_token_type);
-        case 'auth_token_name':
-            return applyDefault(QUESTIONS.auth_token_name);
-        case 'auth_token_secret':
-            return applyDefault(QUESTIONS.auth_token_secret);
-        case 'db_needs_database':
-            return applyDefault(QUESTIONS.db_needs_database);
-        case 'db_strategy':
-            return applyDefault(QUESTIONS.db_strategy);
-        case 'db_env':
-            return applyDefault(QUESTIONS.db_env);
-        case 'db_seed_command':
-            return applyDefault(QUESTIONS.db_seed_command);
-        case 'complete':
-            return null;
-        default:
-            return null;
-    }
-}
-export function advanceStep(state) {
-    if (state.step === 'project_name') {
-        return { ...state, step: 'is_monorepo' };
-    }
-    if (state.step === 'is_monorepo') {
-        const isMonorepo = state.answers.is_monorepo?.startsWith('yes');
-        if (isMonorepo) {
-            return { ...state, step: 'services_list' };
-        }
-        else {
-            return { ...state, step: 'dev_command' };
-        }
-    }
-    if (state.step === 'services_list') {
-        const servicesStr = state.answers.services_list || 'frontend';
-        const serviceNames = servicesStr
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean);
-        return {
-            ...state,
-            step: 'service_details',
-            serviceNames,
-            currentServiceIndex: 0,
-        };
-    }
-    if (state.step === 'service_details') {
-        const serviceNames = state.serviceNames || [];
-        const currentIdx = state.currentServiceIndex || 0;
-        const currentService = serviceNames[currentIdx];
-        if (currentService) {
-            const serviceKey = `service_${currentService}`;
-            const hasRoot = state.answers[`${serviceKey}_root`];
-            const hasCommand = state.answers[`${serviceKey}_command`];
-            const hasType = state.answers[`${serviceKey}_type`];
-            const isServer = state.answers[`${serviceKey}_type`]?.startsWith('server');
-            const hasPort = state.answers[`${serviceKey}_port`];
-            const hasDependsOn = state.answers[`${serviceKey}_depends_on`] !== undefined;
-            if (!hasRoot || !hasCommand || !hasType || (isServer && !hasPort) || !hasDependsOn) {
-                return state;
-            }
-        }
-        if (currentIdx < serviceNames.length - 1) {
-            return {
-                ...state,
-                currentServiceIndex: currentIdx + 1,
-            };
-        }
-        else {
-            return { ...state, step: 'verification_commands' };
-        }
-    }
-    // Simple transitions
-    const simpleTransitions = {
-        dev_command: 'dev_port',
-        dev_port: 'dev_ready_pattern',
-        dev_ready_pattern: 'verification_commands',
-        verification_commands: 'auth_needs_signin',
-    };
-    if (state.step in simpleTransitions) {
-        return { ...state, step: simpleTransitions[state.step] };
-    }
-    // Auth flow branching
-    if (state.step === 'auth_needs_signin') {
-        const needsSignin = state.answers.auth_needs_signin?.startsWith('yes');
-        if (needsSignin) {
-            return { ...state, step: 'auth_strategy' };
-        }
-        else {
-            // Still ask about env var bypass in case they have one
-            return { ...state, step: 'auth_env' };
-        }
-    }
-    if (state.step === 'auth_strategy') {
-        const strategy = state.answers.auth_strategy?.split(' - ')[0];
-        if (strategy === 'bypass' || strategy === 'fixture') {
-            return { ...state, step: 'auth_env' };
-        }
-        else if (strategy === 'token') {
-            return { ...state, step: 'auth_token_type' };
-        }
-        else {
-            // test_account - for now, complete (can expand later)
-            return { ...state, step: 'complete' };
-        }
-    }
-    if (state.step === 'auth_env') {
-        return { ...state, step: 'db_needs_database' };
-    }
-    if (state.step === 'auth_token_type') {
-        return { ...state, step: 'auth_token_name' };
-    }
-    if (state.step === 'auth_token_name') {
-        return { ...state, step: 'auth_token_secret' };
-    }
-    if (state.step === 'auth_token_secret') {
-        return { ...state, step: 'db_needs_database' };
-    }
-    // Database flow branching
-    if (state.step === 'db_needs_database') {
-        const needsDb = state.answers.db_needs_database?.startsWith('yes');
-        if (needsDb) {
-            return { ...state, step: 'db_strategy' };
-        }
-        else {
-            return { ...state, step: 'complete' };
-        }
-    }
-    if (state.step === 'db_strategy') {
-        return { ...state, step: 'db_env' };
-    }
-    if (state.step === 'db_env') {
-        return { ...state, step: 'db_seed_command' };
-    }
-    if (state.step === 'db_seed_command') {
-        return { ...state, step: 'complete' };
-    }
-    return { ...state, step: 'complete' };
-}
-/**
- * Build the final .haystack.json config from collected answers.
- * This generates the schema that sandbox.py expects.
- */
-export function buildConfig(state) {
-    const answers = state.answers;
-    const isMonorepo = answers.is_monorepo?.startsWith('yes');
-    // Parse verification commands
-    const cmdString = answers.verification_commands || 'pnpm build, pnpm lint';
-    const commands = cmdString
-        .split(',')
-        .map((c) => c.trim())
-        .filter(Boolean)
-        .map((cmd) => {
-        // Generate a name from the command
-        const name = cmd
-            .replace(/^(npm run|pnpm|yarn|bun)\s+/, '')
-            .split(' ')[0]
-            .replace(/^--/, '');
-        return { name, run: cmd };
-    });
-    // Parse auth env var
-    const authEnv = answers.auth_env?.trim();
-    const devEnv = {};
-    if (authEnv && authEnv.includes('=')) {
-        const [key, ...valueParts] = authEnv.split('=');
-        devEnv[key] = valueParts.join('=');
-    }
-    let authConfig;
-    const needsSignin = answers.auth_needs_signin?.startsWith('yes');
-    const authStrategy = answers.auth_strategy?.split(' - ')[0] || 'bypass';
-    if (needsSignin || (authEnv && authEnv.includes('='))) {
-        authConfig = {
-            strategy: needsSignin ? authStrategy : 'bypass',
-        };
-        // Add env for bypass/fixture strategies
-        if (Object.keys(devEnv).length > 0) {
-            authConfig.env = devEnv;
-        }
-        // Add token config for token strategy
-        if (authStrategy === 'token') {
-            const tokenType = answers.auth_token_type?.split(' - ')[0] || 'cookie';
-            const tokenName = answers.auth_token_name || 'session';
-            const tokenSecret = answers.auth_token_secret || 'AUTH_TOKEN';
-            authConfig.token = {
-                type: tokenType,
-                name: tokenName,
-                secret: `$${tokenSecret}`, // Prefix with $ for secret reference
-            };
-        }
-    }
-    let databaseConfig;
-    const needsDb = answers.db_needs_database?.startsWith('yes');
-    if (needsDb) {
-        const dbStrategy = answers.db_strategy?.split(' - ')[0] || 'memory';
-        const dbEnvStr = answers.db_env?.trim();
-        const dbSeedCommand = answers.db_seed_command?.trim();
-        databaseConfig = {
-            strategy: dbStrategy,
-        };
-        // Parse database env var
-        if (dbEnvStr && dbEnvStr.includes('=')) {
-            const [key, ...valueParts] = dbEnvStr.split('=');
-            databaseConfig.env = { [key]: valueParts.join('=') };
-        }
-        // Add seed command if provided
-        if (dbSeedCommand) {
-            databaseConfig.seed_command = dbSeedCommand;
-        }
-    }
-    // Build services config for monorepo mode
-    if (isMonorepo && state.serviceNames) {
-        const services = {};
-        for (const serviceName of state.serviceNames) {
-            const serviceKey = `service_${serviceName}`;
-            const root = answers[`${serviceKey}_root`];
-            const command = answers[`${serviceKey}_command`];
-            const serviceType = answers[`${serviceKey}_type`]?.split(' - ')[0];
-            const port = answers[`${serviceKey}_port`];
-            const dependsOnStr = answers[`${serviceKey}_depends_on`];
-            const dependsOn = dependsOnStr
-                ? dependsOnStr
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean)
-                : undefined;
-            services[serviceName] = {
-                root: root === './' ? undefined : root,
-                command: command || 'pnpm dev',
-                type: serviceType === 'batch' ? 'batch' : undefined,
-                port: port ? parseInt(port, 10) : undefined,
-                ready_pattern: serviceType === 'server' ? 'ready|started|listening|Local:' : undefined,
-                env: Object.keys(devEnv).length > 0 ? devEnv : undefined,
-                depends_on: dependsOn?.length ? dependsOn : undefined,
-            };
-        }
-        const config = {
-            version: '1',
-            name: answers.project_name || 'my-app',
-            services,
-            verification: {
-                commands: commands.length > 0 ? commands : undefined,
-            },
-        };
-        if (authConfig) {
-            config.auth = authConfig;
-        }
-        if (databaseConfig) {
-            config.database = databaseConfig;
-        }
-        return config;
-    }
-    // Simple mode (single dev server)
-    const config = {
-        version: '1',
-        name: answers.project_name || 'my-app',
-        dev_server: {
-            command: answers.dev_command || 'pnpm dev',
-            port: parseInt(answers.dev_port || '3000', 10),
-            ready_pattern: answers.dev_ready_pattern || 'Local:',
-            env: Object.keys(devEnv).length > 0 ? devEnv : undefined,
-        },
-        verification: {
-            commands: commands.length > 0 ? commands : undefined,
-        },
-    };
-    if (authConfig) {
-        config.auth = authConfig;
-    }
-    if (databaseConfig) {
-        config.database = databaseConfig;
-    }
-    return config;
-}
-export function configToJson(config) {
-    return JSON.stringify(config, null, 2);
-}

package/dist/utils/skill.d.ts

@@ -1,10 +0,0 @@
-/**
- * Create the .agents/skills/haystack.md file for agent discovery
- * and .claude/commands/haystack.md for Claude Code slash command
- */
-export declare function createSkillFile(): Promise<string>;
-/**
- * Create the .claude/commands/ files for Claude Code slash commands
- * Users can invoke with /setup-haystack, /prepare-haystack, or /setup-haystack-secrets
- */
-export declare function createClaudeCommand(): Promise<string>;