@zibby/cli 0.1.5

package/src/commands/init.js

@@ -0,0 +1,736 @@
+import { mkdir, writeFile, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const MEMORY_ENV_BLOCK = `
+# Test Memory (Dolt-backed — learns from every run)
+ZIBBY_MEMORY=1
+# ZIBBY_MEMORY_COMPACT_EVERY=1500  # Auto-compact every N runs (0 to disable)
+# ZIBBY_MEMORY_MAX_RUNS=3000       # Max runs per spec to keep
+# ZIBBY_MEMORY_MAX_AGE=1095        # Max age in days for stale data (~3 years)
+`;
+
+export async function initCommand(projectName, options) {
+  console.log(chalk.bold.cyan('\n🎭 Welcome to Zibby Test Automation!\n'));
+
+  const targetDir = projectName ? resolve(process.cwd(), projectName) : process.cwd();
+  const projectNameActual = projectName || 'zibby-tests';
+  const isNewProject = !!projectName;
+  
+  // If creating new project, check if directory exists
+  if (isNewProject && existsSync(targetDir)) {
+    console.log(chalk.red(`\n❌ Directory "${projectName}" already exists!\n`));
+    process.exit(1);
+  }
+  
+  // If in existing directory, check if already initialized (unless --force)
+  if (!isNewProject && existsSync(join(targetDir, '.zibby.config.js')) && !options.force) {
+    console.log(chalk.yellow('\n⚠️  Zibby is already initialized in this directory!\n'));
+    console.log(chalk.white('Config file found: .zibby.config.js'));
+    console.log(chalk.gray('Use --force or -f to reinitialize\n'));
+    process.exit(0);
+  }
+  
+  if (options.force && !isNewProject) {
+    console.log(chalk.cyan('\nReinitializing Zibby configuration...\n'));
+  }
+
+  // Build answers from CLI flags or prompt interactively
+  let answers;
+  
+  // Check if all options provided via CLI (non-interactive mode)
+  const hasAllFlags = options.agent && (options.headed || options.headless);
+  
+  if (hasAllFlags) {
+    // Non-interactive mode - use CLI flags
+    console.log(chalk.cyan('Setting up with provided options...\n'));
+    answers = {
+      agent: options.agent,
+      browserMode: options.headless ? 'headless' : 'headed',
+      apiKey: options.apiKey || null,
+      cloudSync: !!(options.cloudSync || options.apiKey),
+    };
+  } else {
+    // Interactive mode - prompt for missing options
+    const prompts = [];
+    
+    if (!options.agent) {
+      prompts.push({
+        type: 'select',
+        name: 'agent',
+        message: 'Which AI agent do you prefer?',
+        choices: [
+          { name: 'Cursor', value: 'cursor' },
+          { name: 'Claude (Anthropic)', value: 'claude' },
+        ],
+        default: 'cursor',
+      });
+    }
+    
+    if (!options.headed && !options.headless) {
+      prompts.push({
+        type: 'select',
+        name: 'browserMode',
+        message: 'Browser mode during live AI execution?',
+        choices: [
+          { name: 'Headed - Visible browser (recommended for development)', value: 'headed' },
+          { name: 'Headless - Hidden browser (for CI/CD)', value: 'headless' },
+        ],
+        default: 'headed',
+      });
+    }
+    
+    if (!options.apiKey) {
+      prompts.push({
+        type: 'input',
+        name: 'apiKey',
+        message: 'Enable cloud sync? Enter project ZIBBY_API_KEY (or press Enter to skip):',
+      });
+    }
+    
+    answers = prompts.length > 0 ? await inquirer.prompt(prompts) : {};
+    
+    // Merge with CLI options
+    answers.agent = options.agent || answers.agent;
+    answers.browserMode = options.headless ? 'headless' : (options.headed ? 'headed' : answers.browserMode);
+    answers.apiKey = options.apiKey || answers.apiKey;
+    answers.cloudSync = !!(options.cloudSync || options.apiKey || (answers.apiKey && answers.apiKey.trim()));
+  }
+
+  // Set Playwright as default (only option for now)
+  answers.mcp = 'playwright';
+
+  // Automatically setup MCP if Cursor agent selected
+  answers.setupMcp = (answers.agent === 'cursor');
+
+  const spinner = ora('Setting up Zibby...').start();
+
+  try {
+    // Create project directory if new project
+    if (isNewProject) {
+      await mkdir(targetDir, { recursive: true });
+    }
+
+    // Create folders
+    await mkdir(join(targetDir, 'test-specs/examples'), { recursive: true });
+    await mkdir(join(targetDir, 'tests'), { recursive: true });
+    await mkdir(join(targetDir, '.zibby/output'), { recursive: true });
+
+    if (options.mem) {
+      try {
+        const { initMemory, DoltDB } = await import('@zibby/memory');
+        if (DoltDB.isAvailable()) {
+          const { created } = initMemory(targetDir);
+          if (created) {
+            spinner.text = 'Initialized test memory database (Dolt)...';
+          }
+        } else {
+          spinner.text = 'Dolt not found — skipping memory database (brew install dolt)';
+        }
+      } catch (_e) {
+        // @zibby/memory not available — skip silently
+      }
+    }
+
+    spinner.text = 'Scaffolding workflow graph...';
+    
+    // Use Template Factory to get the right template
+    const { TemplateFactory } = await import('@zibby/core/templates');
+    const templateName = options.template || 'browser-test-automation'; // Default to browser-test-automation
+    
+    try {
+      const { graphPath, nodesPath, readmePath, resultHandlerPath } = TemplateFactory.getTemplateFiles(templateName);
+      const targetZibbyDir = join(targetDir, '.zibby');
+      
+      // Copy graph.js
+      const graphTemplate = await readFile(graphPath, 'utf-8');
+      await writeFile(join(targetZibbyDir, 'graph.js'), graphTemplate);
+      
+      // Copy result-handler.js (workflow-specific post-processing)
+      if (resultHandlerPath) {
+        const rhTemplate = await readFile(resultHandlerPath, 'utf-8');
+        await writeFile(join(targetZibbyDir, 'result-handler.js'), rhTemplate);
+      }
+      
+      // Copy README
+      const readmeTemplate = await readFile(readmePath, 'utf-8');
+      await writeFile(join(targetZibbyDir, 'README.md'), readmeTemplate);
+      
+      // Copy nodes directory
+      await mkdir(join(targetZibbyDir, 'nodes'), { recursive: true });
+      const { readdirSync } = await import('fs');
+      const nodeFiles = readdirSync(nodesPath);
+      for (const file of nodeFiles) {
+        const content = await readFile(join(nodesPath, file), 'utf-8');
+        await writeFile(join(targetZibbyDir, 'nodes', file), content);
+      }
+    } catch (error) {
+      spinner.fail(`Failed to scaffold template: ${error.message}`);
+      throw error;
+    }
+
+    spinner.text = 'Generating configuration files...';
+
+    // Always create Zibby config
+    const configContent = generateConfig(answers, options);
+    await writeFile(join(targetDir, '.zibby.config.js'), configContent);
+
+    // Always create .env.example
+    const envContent = generateEnvFile(answers, options);
+    await writeFile(join(targetDir, '.env.example'), envContent);
+    
+    // Create/update .env file if API key provided
+    if (answers.apiKey && answers.apiKey.trim()) {
+      await createOrUpdateEnvFile(targetDir, answers.apiKey.trim(), answers, options);
+    }
+
+    // Ensure ZIBBY_MEMORY=1 is in .env when --mem is used (even without API key)
+    if (options.mem) {
+      const envPath = join(targetDir, '.env');
+      if (existsSync(envPath)) {
+        const existingEnv = await readFile(envPath, 'utf-8');
+        if (!existingEnv.includes('ZIBBY_MEMORY=')) {
+          await writeFile(envPath, existingEnv + MEMORY_ENV_BLOCK);
+        }
+      } else {
+        await writeFile(envPath, generateEnvFile(answers, options));
+      }
+    }
+
+    // Only create package.json if new project
+    if (isNewProject) {
+      const packageJsonContent = generatePackageJson(projectNameActual, answers);
+      await writeFile(join(targetDir, 'package.json'), packageJsonContent);
+    }
+
+    // Create .gitignore if doesn't exist
+    if (!existsSync(join(targetDir, '.gitignore'))) {
+      const gitignoreContent = generateGitignore();
+      await writeFile(join(targetDir, '.gitignore'), gitignoreContent);
+    }
+
+    // Create playwright.config.js if doesn't exist
+    if (!existsSync(join(targetDir, 'playwright.config.js'))) {
+      const playwrightConfigContent = generatePlaywrightConfig('on'); // Default: video enabled
+      await writeFile(join(targetDir, 'playwright.config.js'), playwrightConfigContent);
+    }
+
+    // Create example spec if doesn't exist
+    if (!existsSync(join(targetDir, 'test-specs/examples/example-domain.txt'))) {
+      const exampleSpecContent = generateExampleSpec();
+      await writeFile(join(targetDir, 'test-specs/examples/example-domain.txt'), exampleSpecContent);
+    }
+
+    // Create README only for new projects
+    if (isNewProject) {
+      const readmeContent = generateReadme(projectNameActual, answers);
+      await writeFile(join(targetDir, 'README.md'), readmeContent);
+    }
+
+    spinner.succeed(isNewProject ? 'Project created!' : 'Zibby initialized!');
+
+    // Install dependencies for new projects
+    if (isNewProject && !options.skipInstall) {
+      const installSpinner = ora('Installing dependencies...').start();
+      
+      await new Promise((resolveFn, reject) => {
+        const npm = spawn('npm', ['install'], {
+          cwd: targetDir,
+          stdio: 'pipe',
+        });
+
+        npm.on('close', (code) => {
+          if (code === 0) {
+            installSpinner.succeed('Dependencies installed!');
+            resolveFn();
+          } else {
+            installSpinner.fail('Failed to install dependencies');
+            reject(new Error('npm install failed'));
+          }
+        });
+      });
+    } else if (!isNewProject) {
+      console.log(chalk.gray('\nMake sure @zibby/cli is installed in your package.json\n'));
+    }
+
+    // Always check and install Playwright browsers if missing (for both new and existing projects)
+    // This ensures browsers are available even when reinitializing
+    if (!options.skipInstall) {
+      const playwrightSpinner = ora('Installing Playwright browsers...').start();
+      
+      await new Promise((resolveFn) => {
+        const npx = spawn('npx', ['playwright', 'install', 'chromium'], {
+          cwd: targetDir,
+          stdio: 'pipe',
+        });
+
+        let output = '';
+        npx.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+        npx.stderr.on('data', (data) => {
+          output += data.toString();
+        });
+
+        npx.on('close', (code) => {
+          if (code === 0) {
+            // Check if it actually installed or was already installed
+            if (output.includes('already installed') || output.includes('up to date')) {
+              playwrightSpinner.succeed('Playwright browsers already installed');
+            } else {
+              playwrightSpinner.succeed('Playwright browsers installed!');
+            }
+            resolveFn();
+          } else {
+            playwrightSpinner.warn('Could not verify Playwright browsers');
+            console.log(chalk.yellow('\n⚠️  If tests fail, run: npx playwright install\n'));
+            resolveFn(); // Don't fail the whole init
+          }
+        });
+      });
+    }
+
+    // Setup cursor-agent MCP if requested
+    if (answers.agent === 'cursor' && answers.setupMcp) {
+      const mcpSpinner = ora('Setting up Playwright MCP...').start();
+      
+      try {
+        const { setupPlaywrightMcpCommand } = await import('./setup-scripts.js');
+        
+        // Use cloudSync from answers (prompt response or flag)
+        const cloudSync = answers.cloudSync || false;
+        
+        // Use browserMode from answers (default to headed)
+        const isHeaded = answers.browserMode !== 'headless';
+        
+        await setupPlaywrightMcpCommand({
+          headed: isHeaded,
+          cloudSync,
+          video: 'on',  // Default video recording enabled
+          viewport: { width: 1280, height: 720 }  // Default viewport size
+        });
+
+        let message = 'Playwright MCP configured';
+        if (isHeaded) message += ' (headed mode - visible browser)';
+        else message += ' (headless mode - hidden browser)';
+        if (cloudSync) message += ' + Zibby MCP (cloud sync)';
+
+        mcpSpinner.succeed(message);
+
+        if (cloudSync && answers.apiKey) {
+          console.log(chalk.gray('\n   ✓ ZIBBY_API_KEY saved to .env\n'));
+        } else if (cloudSync) {
+          console.log(chalk.gray('\n   Set ZIBBY_API_KEY in .env to enable uploads\n'));
+        }
+      } catch (error) {
+        // Error during MCP setup - check if MCP is already configured
+        mcpSpinner.fail('MCP setup script failed');
+        console.log(chalk.yellow('   Check if MCP is already configured:'));
+        console.log(chalk.gray('   • Open Cursor settings → Check "playwright-official" MCP'));
+        console.log(chalk.gray('   • Run: cursor-agent mcp list'));
+        console.log(chalk.gray(`   • Or run manually: zibby setup-playwright\n`));
+        console.log(chalk.gray(`   Error: ${error.message}\n`));
+      }
+    }
+
+    console.log(chalk.bold.green('\n🎉 All set!\n'));
+    console.log(chalk.cyan('Try running your first test:'));
+    if (isNewProject) {
+      console.log(chalk.white(`  cd ${projectName}`));
+    }
+    console.log(chalk.white('  zibby run test-specs/examples/example-domain.txt\n'));
+    
+    console.log(chalk.cyan('Next steps:'));
+    if (answers.agent === 'claude') {
+      let step = 1;
+      console.log(chalk.white(`  ${step++}. ${answers.apiKey ? 'Update' : 'Copy .env.example to .env and add'} ANTHROPIC_API_KEY`));
+      if (answers.cloudSync && !answers.apiKey) {
+        console.log(chalk.white(`  ${step++}. Add ZIBBY_API_KEY to .env for cloud sync`));
+      }
+      console.log(chalk.white(`  ${step++}. Write test specs in test-specs/`));
+      console.log(chalk.white(`  ${step++}. Run: npx zibby run <spec-file>\n`));
+    } else if (answers.agent === 'cursor') {
+      let step = 1;
+      if (answers.cloudSync && !answers.apiKey) {
+        console.log(chalk.white(`  ${step++}. Add ZIBBY_API_KEY to .env for cloud sync`));
+      }
+      console.log(chalk.white(`  ${step++}. Write test specs in test-specs/`));
+      console.log(chalk.white(`  ${step++}. Run: npx zibby run <spec-file>\n`));
+    }
+
+  } catch (error) {
+    spinner.fail('Failed to create project');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+function generateConfig(answers, _options = {}) {
+  // Import here to avoid circular deps - constants are pure values
+  const DEFAULT_CLAUDE_MODEL = 'auto';
+  return `export default {
+  // AI agent settings - specify 'claude' or 'cursor' block
+  agent: {${answers.agent === 'claude' ? `
+    // Claude API settings
+    claude: {
+      model: '${DEFAULT_CLAUDE_MODEL}',  // Options: 'auto', 'sonnet-4.6', 'opus-4.6', 'sonnet-4.5', 'opus-4.5'
+      maxTokens: 4096,
+    },
+    
+    // OR use Cursor Agent (comment out claude block above, uncomment this):
+    // cursor: {
+    //   model: 'auto',  // Options: 'auto', 'opus-4.5', 'opus-4.5-thinking', 'sonnet-4.5', 'sonnet-4.5-thinking', 'composer-1', 'gpt-5.2-codex', 'gpt-5.2', 'gemini-3-pro', 'gemini-3-flash'
+    // },` : `
+    // Cursor Agent settings
+    cursor: {
+      model: 'auto',  // Options: 'auto', 'opus-4.5', 'opus-4.5-thinking', 'sonnet-4.5', 'sonnet-4.5-thinking', 'composer-1', 'gpt-5.2-codex', 'gpt-5.2', 'gemini-3-pro', 'gemini-3-flash'
+    },
+    
+    // OR use Claude (comment out cursor block above, uncomment this):
+    // claude: {
+    //   model: '${DEFAULT_CLAUDE_MODEL}',  // Options: 'auto', 'sonnet-4.6', 'opus-4.6', 'sonnet-4.5', 'opus-4.5'
+    //   maxTokens: 4096,
+    // },`}
+    strictMode: false,  // Set to true if you need reliable structured output enforcement for production workflows (requires authentication)
+  },
+
+  // Advanced: Override models per node (optional)
+  // models: {
+  //   default: 'auto',               // Fallback for all nodes
+  //   execute_live: 'claude-opus-4', // Override specific node
+  // },
+
+  // Folder paths
+  paths: {
+    specs: 'test-specs',      // Where your .txt test specs are
+    generated: 'tests',       // Where generated .spec.js files go
+    output: '.zibby/output',  // Where workflow execution results are saved (default: .zibby/output)
+    // sessionPrefix: 'run',  // Optional: prefix for session folders (e.g., run_1772788458045)
+  },
+
+  // Context discovery - auto-discovers CONTEXT.md & AGENTS.md files (cascades from root → spec directory)
+  // Override filenames to search for different files
+  context: {
+    filenames: ['CONTEXT.md', 'AGENTS.md'],  // Auto-discover these files (walks up from spec directory)
+    discovery: {
+      env: \`env-\${process.env.ENV || 'local'}.js\`,  // Additional explicit files
+      // fixtures: 'fixtures.js',  // Add more as needed
+    }
+  },
+
+  // Video recording (affects playwright.config.js generation)
+  video: 'on',  // Options: 'off', 'on', 'retain-on-failure', 'on-first-retry'
+
+  // Browser viewport size for test execution
+  // Default: 1280x720 (works well on most screens)
+  // For larger displays: { width: 1920, height: 1080 }
+  // For mobile testing: { width: 375, height: 667 } (iPhone SE)
+  viewport: { width: 1280, height: 720 },
+
+  // Playwright artifacts (screenshots, traces, videos)
+  // Traces contain EXACT selectors for 100% accurate script generation
+  // Default: true (stored in test-results/playwright, separate from workflow output)
+  playwrightArtifacts: true,
+
+  // Cloud sync - auto-upload test results & videos (requires ZIBBY_API_KEY in .env)
+  cloudSync: ${answers.cloudSync || false}
+};
+`;
+}
+
+function generateEnvFile(answers, options = {}) {
+  let content = `# Zibby Test Automation - Environment Variables
+
+# AI Provider Keys
+${answers.agent === 'claude' ? '# Claude (Anthropic) - Direct API\nANTHROPIC_API_KEY=sk-ant-your_key_here\n' : '# ANTHROPIC_API_KEY=sk-ant-your_key_here\n'}
+${answers.agent === 'cursor' ? '# Cursor Agent (uses cursor-agent CLI)\n# No API key needed if cursor-agent is installed\n# Run: curl https://cursor.com/install -fsS | bash\n' : ''}
+
+# Zibby Cloud Sync (for uploading test results & videos)
+# Get your API key from: https://zibby.app/settings/tokens
+# ZIBBY_API_KEY=zby_your_api_key_here
+
+# Optional: Notifications
+# SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
+`;
+
+  if (options.mem) {
+    content += MEMORY_ENV_BLOCK;
+  }
+
+  return content;
+}
+
+async function createOrUpdateEnvFile(targetDir, apiKey, answers, options = {}) {
+  const envPath = join(targetDir, '.env');
+  let envContent;
+  
+  // Read existing .env if it exists
+  if (existsSync(envPath)) {
+    try {
+      envContent = await readFile(envPath, 'utf-8');
+      
+      // Update or add ZIBBY_API_KEY
+      if (envContent.includes('ZIBBY_API_KEY=')) {
+        envContent = envContent.replace(
+          /ZIBBY_API_KEY=.*/g,
+          `ZIBBY_API_KEY=${apiKey}`
+        );
+      } else {
+        envContent += `\n# Zibby Cloud Sync\nZIBBY_API_KEY=${apiKey}\n`;
+      }
+
+      if (options.mem && !envContent.includes('ZIBBY_MEMORY=')) {
+        envContent += MEMORY_ENV_BLOCK;
+      }
+    } catch (_error) {
+      envContent = generateEnvFileWithKey(answers, apiKey, options);
+    }
+  } else {
+    envContent = generateEnvFileWithKey(answers, apiKey, options);
+  }
+  
+  await writeFile(envPath, envContent);
+}
+
+function generateEnvFileWithKey(answers, apiKey, options = {}) {
+  let content = `# Zibby Test Automation - Environment Variables
+
+# AI Provider Keys
+${answers.agent === 'claude' ? 'ANTHROPIC_API_KEY=sk-ant-your_key_here\n' : '# ANTHROPIC_API_KEY=sk-ant-your_key_here\n'}
+
+# Zibby Cloud Sync
+ZIBBY_API_KEY=${apiKey}
+
+# Optional: Notifications
+# SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
+`;
+
+  if (options.mem) {
+    content += MEMORY_ENV_BLOCK;
+  }
+
+  return content;
+}
+
+function generatePackageJson(projectName, _answers) {
+  return JSON.stringify({
+    name: projectName,
+    version: '1.0.0',
+    type: 'module',
+    private: true,
+    scripts: {
+      'test:spec': 'zibby run',
+      'test': 'playwright test',
+      'test:headed': 'playwright test --headed'
+    },
+    dependencies: {
+      '@zibby/cli': '^0.1.0',
+      '@zibby/core': '^0.1.0'
+    },
+    devDependencies: {
+      '@playwright/test': '^1.49.0',
+      'dotenv': '^17.2.3'
+    }
+  }, null, 2);
+}
+
+function generateGitignore() {
+  return `# Dependencies
+node_modules/
+
+# Test artifacts
+.zibby/output/
+playwright-report/
+tests/
+*.webm
+*.mp4
+
+# Environment variables
+.env
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+
+# Zibby cache
+.zibby/cache/
+.zibby/tenancy.json
+
+# Zibby memory (Dolt DB synced separately via dolt remote, not git)
+.zibby/memory/
+.zibby/memory-context.md
+`;
+}
+
+function generatePlaywrightConfig(_videoOption = 'off', outputDir = null) {
+  const outputDirLine = outputDir ? `  outputDir: '${outputDir}',\n` : `  outputDir: 'test-results/playwright', // Keep Playwright artifacts separate from Zibby workflow output\n`;
+  
+  return `import { defineConfig} from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+${outputDirLine}  timeout: 30000,
+  retries: 0,
+  workers: 1,
+  
+  use: {
+    headless: process.env.PLAYWRIGHT_HEADLESS === '1' ? true : false,
+    viewport: { width: 1280, height: 720 },
+    screenshot: 'off',
+    video: 'off',
+  },
+
+  reporter: [
+    ['html'],
+    ['list']
+  ],
+});
+`;
+}
+
+function generateExampleSpec() {
+  return `Test Specification: Example Domain Navigation
+==============================================
+
+Application: Example Domain
+URL: https://example.com
+Feature: Basic navigation and link verification
+
+Test Objective:
+---------------
+Verify that the example.com website loads correctly, displays expected content,
+and navigational links function as intended.
+
+Test Steps:
+-----------
+1. Navigate to https://example.com
+2. Verify the page title contains "Example Domain"
+3. Verify the main heading is visible and contains "Example Domain"
+4. Locate and verify the "More information..." link is present
+5. Click the "More information..." link
+6. Verify navigation to IANA domain information page
+7. Verify the new page URL contains "iana.org"
+8. Verify the page loaded successfully (no errors)
+
+Expected Results:
+-----------------
+- Initial page loads within 3 seconds
+- "Example Domain" heading is clearly visible
+- "More information..." link is clickable and visible
+- Navigation to IANA page succeeds
+- No console errors or network failures
+- Page title updates after navigation
+
+Notes:
+------
+- Uses a stable, public domain (example.com) maintained by IANA
+- No authentication required
+- Suitable for CI/CD smoke testing
+`;
+}
+
+function generateReadme(projectName, answers) {
+  return `# ${projectName}
+
+AI-powered test automation with Zibby.
+
+## Setup
+
+1. Install dependencies:
+\`\`\`bash
+npm install
+\`\`\`
+
+2. Configure environment:
+\`\`\`bash
+cp .env.example .env
+# Edit .env and add your ${answers.agent === 'claude' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'}
+\`\`\`
+
+3. Run example test:
+\`\`\`bash
+npx zibby run test-specs/examples/example-domain.txt
+\`\`\`
+
+## Usage
+
+### Run Test Specs
+
+\`\`\`bash
+# Run a test spec (executes + generates + verifies)
+npx zibby run test-specs/auth/login.txt
+
+# Run in headless mode
+npx zibby run test-specs/auth/login.txt --headless
+\`\`\`
+
+### Write Test Specs
+
+Create test specifications in \`test-specs/\`:
+
+\`\`\`
+test-specs/
+  auth/
+    login.txt
+    logout.txt
+  dashboard/
+    overview.txt
+\`\`\`
+
+### Run Generated Tests
+
+\`\`\`bash
+# Run all generated tests
+npx playwright test
+
+# Run specific test
+npx playwright test tests/auth/login.spec.js
+
+# Run with UI
+npx playwright test --ui
+\`\`\`
+
+## Configuration
+
+Edit \`.zibby.config.js\` to customize:
+- Agent settings (model, temperature)
+- Browser settings (headless, viewport)
+- Cloud sync${answers.cloudSync ? ' (enabled)' : ' (disabled)'}
+- Self-healing behavior
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+├── .zibby/
+│   ├── graph.js           # Workflow definition
+│   ├── nodes/             # Custom nodes
+│   └── output/            # Workflow execution results (gitignored)
+│       └── sessions/      # Session artifacts & recordings
+├── .zibby.config.js       # Configuration
+├── .env                   # API keys (gitignored)
+├── test-specs/            # Test specifications (committed)
+│   └── examples/
+│       └── example-domain.txt
+└── tests/                 # Generated tests (gitignored)
+\`\`\`
+
+## Learn More
+
+- Documentation: https://docs.zibby.dev
+- Examples: https://github.com/zibby/examples
+`;
+}
+