@haystackeditor/cli 0.8.0 → 0.9.0

package/dist/tools/fixtures.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Fixture definition for loading.
+ * This is constructed from HaystackConfig's verification.fixtures Record.
+ */
+export interface Fixture {
+    /** URL pattern to intercept (e.g., "/api/users/*") */
+    pattern: string;
+    /** Source to load data from (file://, https://, s3://, r2://, script://, or passthrough) */
+    source: string;
+    /** Optional headers for remote sources */
+    headers?: Record<string, string>;
+    /** Optional cookies for remote sources (for login-required endpoints) */
+    cookies?: string;
+}
+export interface FixtureData {
+    pattern: string;
+    data: unknown;
+    source: string;
+}
+export interface FixtureLoaderOptions {
+    /** Base directory for relative file paths */
+    baseDir: string;
+    /** Environment variables for token substitution */
+    env: Record<string, string>;
+}
+/**
+ * Load fixture data from various sources
+ */
+export declare function loadFixture(fixture: Fixture, options: FixtureLoaderOptions): Promise<FixtureData>;
+/**
+ * Load all fixtures from config
+ */
+export declare function loadAllFixtures(fixtures: Fixture[], options: FixtureLoaderOptions): Promise<FixtureData[]>;
+/**
+ * Generate a mock fixture based on a pattern
+ * Useful for scaffolding fixture files
+ */
+export declare function generateMockFixture(pattern: string): unknown;

package/dist/tools/fixtures.js

@@ -0,0 +1,199 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Load fixture data from various sources
+ */
+export async function loadFixture(fixture, options) {
+    const { source, pattern, headers, cookies } = fixture;
+    // Substitute env vars in source, headers, and cookies
+    const resolvedSource = substituteEnvVars(source, options.env);
+    const resolvedHeaders = headers
+        ? Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, substituteEnvVars(v, options.env)]))
+        : undefined;
+    const resolvedCookies = cookies ? substituteEnvVars(cookies, options.env) : undefined;
+    let data;
+    if (source === 'passthrough') {
+        // Passthrough means don't intercept - return marker
+        return {
+            pattern,
+            data: { __passthrough: true },
+            source: 'passthrough',
+        };
+    }
+    if (source.startsWith('file://')) {
+        data = await loadFromFile(resolvedSource.slice(7), options.baseDir);
+    }
+    else if (source.startsWith('https://') || source.startsWith('http://')) {
+        data = await loadFromUrl(resolvedSource, resolvedHeaders, resolvedCookies);
+    }
+    else if (source.startsWith('s3://')) {
+        data = await loadFromS3(resolvedSource.slice(5));
+    }
+    else if (source.startsWith('r2://')) {
+        data = await loadFromR2(resolvedSource.slice(5));
+    }
+    else if (source.startsWith('script://')) {
+        data = await loadFromScript(resolvedSource.slice(9), options.baseDir);
+    }
+    else {
+        throw new Error(`Unknown fixture source type: ${source}`);
+    }
+    return { pattern, data, source: resolvedSource };
+}
+/**
+ * Load all fixtures from config
+ */
+export async function loadAllFixtures(fixtures, options) {
+    const results = [];
+    for (const fixture of fixtures) {
+        try {
+            const data = await loadFixture(fixture, options);
+            results.push(data);
+        }
+        catch (error) {
+            console.error(`Failed to load fixture for pattern ${fixture.pattern}:`, error);
+            throw error;
+        }
+    }
+    return results;
+}
+function substituteEnvVars(str, env) {
+    return str.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_, varName) => {
+        return env[varName] || process.env[varName] || '';
+    });
+}
+async function loadFromFile(filePath, baseDir) {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
+    const content = await fs.readFile(fullPath, 'utf-8');
+    return JSON.parse(content);
+}
+async function loadFromUrl(url, headers, cookies) {
+    // Build headers, including Cookie header if provided
+    const requestHeaders = { ...headers };
+    if (cookies) {
+        requestHeaders['Cookie'] = cookies;
+    }
+    const response = await fetch(url, {
+        headers: requestHeaders,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+async function loadFromS3(s3Path) {
+    // s3Path format: bucket/key
+    const [bucket, ...keyParts] = s3Path.split('/');
+    const key = keyParts.join('/');
+    // Use AWS SDK if available, otherwise fall back to presigned URL approach
+    try {
+        // Dynamic import to make SDK optional
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
+        const client = new S3Client({});
+        const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+        const response = await client.send(command);
+        const body = await response.Body?.transformToString();
+        if (!body)
+            throw new Error('Empty response from S3');
+        return JSON.parse(body);
+    }
+    catch (error) {
+        // If SDK not available, provide helpful error
+        if (error.code === 'MODULE_NOT_FOUND') {
+            throw new Error('S3 fixtures require @aws-sdk/client-s3. Install it with: pnpm add @aws-sdk/client-s3');
+        }
+        throw error;
+    }
+}
+async function loadFromR2(r2Path) {
+    // r2Path format: bucket/key
+    // R2 uses S3-compatible API, so we can use the same SDK
+    const [bucket, ...keyParts] = r2Path.split('/');
+    const key = keyParts.join('/');
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || process.env.CF_ACCOUNT_ID;
+    if (!accountId) {
+        throw new Error('R2 fixtures require CLOUDFLARE_ACCOUNT_ID or CF_ACCOUNT_ID env var');
+    }
+    try {
+        // Dynamic import to make SDK optional
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
+        const client = new S3Client({
+            region: 'auto',
+            endpoint: `https://${accountId}.r2.cloudflarestorage.com`,
+            credentials: {
+                accessKeyId: process.env.R2_ACCESS_KEY_ID || '',
+                secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || '',
+            },
+        });
+        const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+        const response = await client.send(command);
+        const body = await response.Body?.transformToString();
+        if (!body)
+            throw new Error('Empty response from R2');
+        return JSON.parse(body);
+    }
+    catch (error) {
+        if (error.code === 'MODULE_NOT_FOUND') {
+            throw new Error('R2 fixtures require @aws-sdk/client-s3. Install it with: pnpm add @aws-sdk/client-s3');
+        }
+        throw error;
+    }
+}
+async function loadFromScript(scriptPath, baseDir) {
+    const fullPath = path.isAbsolute(scriptPath)
+        ? scriptPath
+        : path.join(baseDir, scriptPath);
+    // Dynamic import the script - it should export a default function or 'generate' function
+    const module = await import(fullPath);
+    const generator = module.default || module.generate;
+    if (typeof generator !== 'function') {
+        throw new Error(`Script ${scriptPath} must export a default function or 'generate' function`);
+    }
+    return generator();
+}
+/**
+ * Generate a mock fixture based on a pattern
+ * Useful for scaffolding fixture files
+ */
+export function generateMockFixture(pattern) {
+    // Generate sensible mock data based on the pattern
+    if (pattern.includes('user')) {
+        return {
+            id: 1,
+            name: 'Test User',
+            email: 'test@example.com',
+            avatar: 'https://placekitten.com/100/100',
+        };
+    }
+    if (pattern.includes('dashboard') || pattern.includes('analytics')) {
+        return {
+            totalUsers: 1234,
+            activeUsers: 567,
+            revenue: 12345.67,
+            chartData: [
+                { date: '2024-01-01', value: 100 },
+                { date: '2024-01-02', value: 120 },
+                { date: '2024-01-03', value: 115 },
+            ],
+        };
+    }
+    if (pattern.includes('config') || pattern.includes('settings')) {
+        return {
+            theme: 'light',
+            language: 'en',
+            notifications: true,
+            features: {
+                darkMode: true,
+                betaFeatures: false,
+            },
+        };
+    }
+    // Default generic response
+    return {
+        success: true,
+        data: [],
+        message: `Mock data for ${pattern}`,
+    };
+}

package/dist/tools/setup.d.ts

@@ -0,0 +1,43 @@
+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;