bangonit 0.3.0 → 0.3.1

package/bin/bangonit.js

@@ -267,6 +267,16 @@ function createPrompter() {
     };
 }
 // --- init command ---
+// Common timezone offsets from UTC (standard time)
+const TIMEZONE_OFFSETS = {
+    "us/eastern": -5, "us/central": -6, "us/mountain": -7, "us/pacific": -8,
+    "europe/london": 0, "europe/berlin": 1, "europe/paris": 1,
+    "asia/tokyo": 9, "asia/shanghai": 8, "asia/kolkata": 5,
+    "australia/sydney": 11,
+};
+function localHourToUtc(localHour, utcOffset) {
+    return ((localHour - utcOffset) % 24 + 24) % 24;
+}
 async function initProject() {
     const p = createPrompter();
     console.log(`\n  ${c.bold}${c.magenta}Bang On It! init${c.reset}\n`);
@@ -282,7 +292,7 @@ async function initProject() {
         s3Region = await p.ask("S3 region", "us-east-1");
         s3Prefix = await p.ask("S3 prefix", "bangonit");
     }
-    p.close();
+    // --- Config file ---
     let toml = `testplans = "${testplans}"\n`;
     toml += `recordings_dir = "${recordingsDir}"\n`;
     if (apiKey) {
@@ -304,58 +314,148 @@ async function initProject() {
     }
     const bangDir = path.join(process.cwd(), ".bangonit");
     fs.mkdirSync(bangDir, { recursive: true });
-    const outPath = path.join(bangDir, "config.toml");
-    fs.writeFileSync(outPath, toml);
-    console.log(`\n  ${c.green}Created${c.reset} .bangonit/config.toml\n`);
-    const testDir = path.join(process.cwd(), testplans);
-    if (!fs.existsSync(testDir)) {
-        fs.mkdirSync(testDir, { recursive: true });
-        console.log(`  ${c.green}Created${c.reset} ${testplans}/\n`);
-    }
-}
-// --- init-ci command ---
-async function initCi() {
-    const p = createPrompter();
-    console.log(`\n  ${c.bold}${c.magenta}Bang On It! CI Setup${c.reset}\n`);
-    const baseImage = await p.ask("GitHub Actions runner", "ubuntu-latest");
-    const nodeVersion = await p.ask("Node.js version", "20");
-    const setupCommand = await p.ask("Setup command (install deps, build, etc.)", "npm install && npm run build");
-    const startCommand = await p.ask("Command to start your web server", "npm start &");
-    const waitUrl = await p.ask("URL to wait for before testing", "http://localhost:3000");
-    const testDir = await p.ask("Test plan directory", "testplans");
-    const triggerInput = await p.askChoice("Trigger on", ["pr", "push", "both"], "both");
-    const timeout = await p.ask("Test timeout in seconds", "300");
-    p.close();
-    const trigger = triggerInput === "pr" ? "pull_request" :
-        triggerInput === "push" ? "push" :
-            "both";
-    let triggerYaml;
-    if (trigger === "both") {
-        triggerYaml = `on:
-  push:
-    branches: [main, master]
-  pull_request:`;
-    }
-    else if (trigger === "pull_request") {
-        triggerYaml = `on:
-  pull_request:`;
-    }
-    else {
-        triggerYaml = `on:
-  push:
-    branches: [main, master]`;
-    }
-    const workflow = `name: Bang On It! Tests
+    const configOutPath = path.join(bangDir, "config.toml");
+    fs.writeFileSync(configOutPath, toml);
+    console.log(`\n  ${c.green}Created${c.reset} .bangonit/config.toml`);
+    // --- Test plan directories ---
+    const testplanBase = path.join(process.cwd(), testplans);
+    const dirs = ["smoke", "acceptance", "regression"];
+    for (const dir of dirs) {
+        const dirPath = path.join(testplanBase, dir);
+        fs.mkdirSync(dirPath, { recursive: true });
+        const gitkeep = path.join(dirPath, ".gitkeep");
+        if (!fs.existsSync(gitkeep))
+            fs.writeFileSync(gitkeep, "");
+        console.log(`  ${c.green}Created${c.reset} ${testplans}/${dir}/`);
+    }
+    // Write example smoke test
+    const smokeExample = path.join(testplanBase, "smoke", "homepage.md");
+    if (!fs.existsSync(smokeExample)) {
+        fs.writeFileSync(smokeExample, `---
+name: Homepage loads
+---
 
-${triggerYaml}
+## Steps
+1. Navigate to http://localhost:3000
+2. Verify the page loads with a heading
+3. Verify there are no console errors
+`);
+        console.log(`  ${c.green}Created${c.reset} ${testplans}/smoke/homepage.md`);
+    }
+    // --- Claude Code skills ---
+    const claudeSkillsDir = path.join(process.cwd(), ".claude", "skills");
+    const testSkillDir = path.join(claudeSkillsDir, "test");
+    fs.mkdirSync(testSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(testSkillDir, "SKILL.md"), `---
+name: test
+description: Run Bang On It! E2E tests locally. Pass test plan files or a filter as $ARGUMENTS (e.g. "testplans/smoke/" or "-t login"). With no arguments, runs all test plans.
+tools: Bash, Read
+---
 
-jobs:
-  test:
-    runs-on: ${baseImage}
-    timeout-minutes: ${Math.ceil(parseInt(timeout) / 60) + 5}
-    env:
-      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+# Run E2E Tests
+
+Run Bang On It! end-to-end tests locally.
+
+**Arguments:** $ARGUMENTS
+
+## Instructions
 
+1. If $ARGUMENTS is empty, run all test plans:
+   \`\`\`bash
+   boi run --record
+   \`\`\`
+
+2. If $ARGUMENTS contains file paths or directories, run those:
+   \`\`\`bash
+   boi run $ARGUMENTS --record
+   \`\`\`
+
+3. If $ARGUMENTS contains a filter (e.g. "login", "checkout"), run with filter:
+   \`\`\`bash
+   boi run -t $ARGUMENTS --record
+   \`\`\`
+
+4. Wait for tests to complete. Report results and recording paths.
+
+5. If tests fail, read the test plan file and the output to diagnose the failure. Suggest whether the test plan needs updating or there's a real bug.
+`);
+    console.log(`  ${c.green}Created${c.reset} .claude/skills/test/SKILL.md`);
+    const createTestSkillDir = path.join(claudeSkillsDir, "create-test");
+    fs.mkdirSync(createTestSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(createTestSkillDir, "SKILL.md"), `---
+name: create-test
+description: Create new Bang On It! test plan(s). Pass a description of what to test as $ARGUMENTS, or omit to auto-generate from git changes.
+tools: Bash, Read, Write, Glob, Grep
+---
+
+# Create Test Plan
+
+Create new Bang On It! test plan files.
+
+**What to test:** $ARGUMENTS
+
+## Instructions
+
+### Step 0: Determine what to test
+
+- If $ARGUMENTS is provided, use it as the description of what to test.
+- If $ARGUMENTS is empty, auto-discover from git changes:
+  1. Run \`git log master..HEAD --oneline\` and \`git diff master...HEAD --stat\` to see what changed on this branch.
+  2. If no branch divergence, run \`git diff HEAD --stat\` and \`git diff HEAD\` for uncommitted changes.
+  3. If still nothing, run \`git log -1 --format="%H %s"\` and \`git show HEAD --stat\` for the latest commit.
+  4. Analyze the changes and create test plan(s) covering them. Bug fixes get regression tests, new features get acceptance tests.
+  5. Skip changes that are already covered by existing test plans, pure refactors, docs, CI, or dependency updates.
+
+### Step 1: Determine which directory the test belongs in
+   - \`${testplans}/smoke/\` — Quick sanity checks (app loads, critical path works). Keep smoke tests minimal — they run on every commit so they must be fast. Only add here if it tests truly fundamental functionality. Prefer acceptance/ for most tests.
+   - \`${testplans}/acceptance/\` — Core user journeys and happy paths. This is the default for most new tests.
+   - \`${testplans}/regression/\` — Bug fixes and edge cases. Use when the description references a bug or issue.
+
+2. Read existing test plans in that directory to understand conventions:
+   \`\`\`bash
+   ls ${testplans}/smoke/ ${testplans}/acceptance/ ${testplans}/regression/
+   \`\`\`
+
+3. Read the codebase to understand what UI elements and flows are involved. Look at routes, components, and pages relevant to the test.
+
+4. Create the test plan file:
+   - Filename: kebab-case, e.g. \`password-reset.md\`
+   - Use this format:
+
+   \`\`\`markdown
+   ---
+   name: Descriptive test name
+   retries: 1
+   ---
+
+   ## Steps
+   1. Navigate to the relevant page
+   2. Perform the action being tested
+   3. Verify the expected outcome
+   \`\`\`
+
+5. Keep steps concise and actionable. Write from the user's perspective — describe what to click, type, and verify. Don't reference CSS selectors or implementation details.
+
+6. Output the path to the created file.
+`);
+    console.log(`  ${c.green}Created${c.reset} .claude/skills/create-test/SKILL.md`);
+    // --- CI setup ---
+    console.log("");
+    const setupCi = await p.askChoice("Set up GitHub Actions CI?", ["y", "n"], "y");
+    if (setupCi === "y") {
+        console.log("");
+        const baseImage = await p.ask("GitHub Actions runner", "ubuntu-latest");
+        const nodeVersion = await p.ask("Node.js version", "20");
+        const setupCommand = await p.ask("Setup command", "npm install && npm run build");
+        const startCommand = await p.ask("Command to start your web server", "npm start &");
+        const waitUrl = await p.ask("URL to wait for before testing", "http://localhost:3000");
+        const timeout = await p.ask("Test timeout in seconds", "300");
+        const tzNames = Object.keys(TIMEZONE_OFFSETS).join(", ");
+        const tz = await p.ask(`Timezone for full run (${tzNames})`, "us/eastern");
+        const utcOffset = TIMEZONE_OFFSETS[tz.toLowerCase()] ?? -5;
+        const fullUtcHour = localHourToUtc(18, utcOffset);
+        const timeoutMinutes = Math.ceil(parseInt(timeout) / 60) + 5;
+        const stepsYaml = `
     steps:
       - uses: actions/checkout@v4
 
@@ -378,12 +478,25 @@ jobs:
         run: npx wait-on ${waitUrl} --timeout 30000
 
       - name: Install bangonit
-        run: npm install -g bangonit
+        run: npm install -g bangonit`;
+        const smokeWorkflow = `name: "Bang On It! Smoke Tests"
 
-      - name: Run tests
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  smoke:
+    runs-on: ${baseImage}
+    timeout-minutes: ${timeoutMinutes}
+    env:
+      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+${stepsYaml}
+
+      - name: Run smoke tests
         run: |
-          xvfb-run --auto-servernum boi run ${testDir}/*.md \\
-            --headless --exit \\
+          xvfb-run --auto-servernum boi run ${testplans}/smoke/ \\
             --timeout ${timeout} \\
             --output bangonit-output.json --record
 
@@ -391,19 +504,57 @@ jobs:
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: bangonit-results
+          name: bangonit-smoke-results
           path: |
             bangonit-output.json
             recordings/
           if-no-files-found: ignore
 `;
-    const outDir = path.join(process.cwd(), ".github", "workflows");
-    fs.mkdirSync(outDir, { recursive: true });
-    const outPath = path.join(outDir, "bangonit.yml");
-    fs.writeFileSync(outPath, workflow);
-    console.log(`\n  ${c.green}Created${c.reset} ${path.relative(process.cwd(), outPath)}\n`);
-    console.log(`  ${c.yellow}Required GitHub secrets:${c.reset}`);
-    console.log(`  ${c.dim}  ANTHROPIC_API_KEY    ${c.reset}— your Anthropic API key`);
+        const fullWorkflow = `name: "Bang On It! Full Tests"
+
+on:
+  schedule:
+    - cron: '0 ${fullUtcHour} * * *'
+  workflow_dispatch:
+
+jobs:
+  full:
+    runs-on: ${baseImage}
+    timeout-minutes: ${timeoutMinutes * 3}
+    env:
+      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+${stepsYaml}
+
+      - name: Run all tests
+        run: |
+          xvfb-run --auto-servernum boi run \\
+            --timeout ${timeout} \\
+            --output bangonit-output.json --record
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: bangonit-full-results
+          path: |
+            bangonit-output.json
+            recordings/
+          if-no-files-found: ignore
+`;
+        const outDir = path.join(process.cwd(), ".github", "workflows");
+        fs.mkdirSync(outDir, { recursive: true });
+        const smokePath = path.join(outDir, "bangonit-smoke.yml");
+        fs.writeFileSync(smokePath, smokeWorkflow);
+        console.log(`\n  ${c.green}Created${c.reset} ${path.relative(process.cwd(), smokePath)}`);
+        const fullPath = path.join(outDir, "bangonit-full.yml");
+        fs.writeFileSync(fullPath, fullWorkflow);
+        console.log(`  ${c.green}Created${c.reset} ${path.relative(process.cwd(), fullPath)}`);
+        console.log(`\n  ${c.yellow}Required GitHub secret:${c.reset}`);
+        console.log(`  ${c.dim}  ANTHROPIC_API_KEY${c.reset} — your Anthropic API key`);
+        console.log(`\n  ${c.dim}Smoke tests run on every push/PR.${c.reset}`);
+        console.log(`  ${c.dim}Full tests run all test plans daily at 6pm ${tz} (${fullUtcHour}:00 UTC).${c.reset}`);
+    }
+    p.close();
     console.log("");
 }
 async function run(argv, config) {
@@ -418,6 +569,13 @@ async function run(argv, config) {
     const recordingsDir = config.recordings_dir
         ? path.resolve(process.cwd(), config.recordings_dir)
         : path.join(process.cwd(), "recordings");
+    // Validate test plan files exist before launching anything
+    for (const file of argv.files) {
+        const absPath = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
+        if (!fs.existsSync(absPath)) {
+            die(`Test plan file not found: ${file}`);
+        }
+    }
     // Discover test plans if no files/plan/auto specified
     const files = [...argv.files];
     if (files.length === 0 && !argv.plan && !argv.auto && config.testplans) {
@@ -433,30 +591,31 @@ async function run(argv, config) {
     else if (files.length === 0 && !argv.plan && !argv.auto && argv.filter) {
         die(`--filter requires a testplans directory configured in .bangonit/config.toml`);
     }
-    // Build args to forward to Electron
-    const electronArgs = [...files];
-    if (argv.plan)
-        electronArgs.push("--plan", argv.plan);
-    if (argv.auto)
-        electronArgs.push("--auto");
-    if (argv.prompt)
-        electronArgs.push("--prompt", argv.prompt);
-    if (argv.record)
-        electronArgs.push("--record", "--recordings-dir", recordingsDir);
-    if (argv.headless)
-        electronArgs.push("--headless");
-    if (argv.exit)
-        electronArgs.push("--exit");
-    if (argv.json)
-        electronArgs.push("--json");
-    if (argv.console)
-        electronArgs.push("--console");
-    if (argv.output)
-        electronArgs.push("--output", argv.output);
-    if (argv.concurrency != null)
-        electronArgs.push("--concurrency", String(argv.concurrency));
-    if (argv.timeout != null)
-        electronArgs.push("--timeout", String(argv.timeout));
+    // Hint when launching interactive UI with no config
+    if (files.length === 0 && !argv.plan && !argv.auto) {
+        if (!config.testplans) {
+            console.log(`${c.dim}No test plans specified. Launching interactive UI.${c.reset}`);
+            console.log(`${c.dim}Tip: Run ${c.reset}boi init${c.dim} to set up a config file, or pass test plan files directly.${c.reset}\n`);
+        }
+    }
+    // Build structured args for Electron (passed via BANGONIT_ARGS env var)
+    const electronArgs = {
+        testPlanFiles: files,
+        headless: argv.headless,
+        exit: argv.exit,
+        json: argv.json,
+        console: argv.console,
+        record: argv.record,
+        retries: argv.retries ?? 0,
+        auto: argv.auto,
+        output: argv.output || null,
+        plan: argv.plan || null,
+        prompt: argv.prompt || null,
+        concurrency: argv.concurrency ?? 1,
+        timeout: argv.timeout ?? 0,
+        cwd: process.cwd(),
+        recordingsDir: argv.record ? recordingsDir : null,
+    };
     const PORT = await getFreePort();
     fs.mkdirSync(LOGS_DIR, { recursive: true });
     const nextDir = path.join(WEBAPP_DIR, ".next");
@@ -479,7 +638,15 @@ async function run(argv, config) {
     const webappLog = fs.createWriteStream(path.join(LOGS_DIR, "webapp.log"));
     webappProc.stdout.pipe(webappLog);
     webappProc.stderr.pipe(webappLog);
+    let webappCrashed = false;
+    webappProc.on("exit", (code) => {
+        if (!webappCrashed && code !== null && code !== 0) {
+            webappCrashed = true;
+            die(`Webapp server crashed (exit code ${code}). Check logs/webapp.log for details.`);
+        }
+    });
     const cleanup = () => {
+        webappCrashed = true; // suppress crash message during normal shutdown
         try {
             webappProc.kill();
         }
@@ -512,15 +679,11 @@ async function run(argv, config) {
             die("Error: electron not found. Run `npm install` in app/desktopapp.");
         }
     }
-    const finalArgs = [
-        ".",
-        ...electronArgs,
-        "--cwd", process.cwd(),
-    ];
-    const electronProc = (0, child_process_1.spawn)(electronPath, finalArgs, {
+    const electronProc = (0, child_process_1.spawn)(electronPath, ["."], {
         cwd: DESKTOP_DIR,
         env: {
             ...process.env,
+            BANGONIT_ARGS: JSON.stringify(electronArgs),
             WEBAPP_URL: `http://localhost:${PORT}/app`,
             NODE_ENV: process.env.NODE_ENV || "production",
         },
@@ -560,8 +723,7 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .scriptName("boi")
     .usage("Usage: $0 <command> [options]")
-    .command("init", "Create a .bangonit/config.toml config file", {}, () => { initProject(); })
-    .command("init-ci", "Generate a GitHub Actions workflow", {}, () => { initCi(); })
+    .command("init", "Set up Bang On It! (config, test plans, and optionally CI)", {}, () => { initProject(); })
     .command(["run [files..]", "$0"], "Run test plans (or launch interactive UI)", (y) => y
     .positional("files", { type: "string", array: true, default: [], describe: "Test plan files" })
     .option("filter", { alias: "t", type: "string", describe: "Filter test plans by name substring" })
@@ -570,6 +732,7 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
     .option("auto", { type: "boolean", default: false, describe: "Auto-generate test plan from git state" })
     .option("prompt", { type: "string", describe: "Additional instructions appended to test plan" })
     .option("record", { type: "boolean", default: false, describe: "Record session replay" })
+    .option("retries", { type: "number", describe: "Retry failed tests N times (overrides test plan frontmatter)" })
     .option("headless", { type: "boolean", default: ciDefaults.headless ?? false, describe: "Run without showing the browser window" })
     .option("exit", { type: "boolean", default: ciDefaults.exit ?? false, describe: "Exit immediately after tests complete" })
     .option("json", { type: "boolean", default: false, describe: "Stream NDJSON events to stdout" })
@@ -585,6 +748,7 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
         auto: argv.auto,
         prompt: argv.prompt,
         record: argv.record,
+        retries: argv.retries,
         headless: argv.headless,
         exit: argv.exit,
         json: argv.json,
@@ -599,8 +763,7 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
     .example("$0 run --auto", "Auto-discover from git state")
     .example("$0 run -t checkout", "Run test plans matching 'checkout'")
     .example("$0 run", "Launch interactive UI")
-    .example("$0 init", "Create .bangonit/config.toml")
-    .example("$0 init-ci", "Set up GitHub Actions")
+    .example("$0 init", "Set up config, test plans, and CI")
     .strict()
     .help()
     .alias("h", "help")