@vatzzza/botintern 1.0.0

package/lib/loop.js

@@ -0,0 +1,174 @@
+import { fix, fixBuild, generateYaml, fixTestFailures } from "./ai.js";
+import { applyFileUpdates, parseAiResponse } from "./aiFileParser.js";
+import { getCriticalSourceCode, getProjectStructure } from "./fileTreeParser.js";
+import { runTests } from "./runTests.js";
+import fs from "fs";
+import chalk from "chalk";
+import exec from "child_process";
+import path from "path";
+import { extractErrorFile } from "../utils/errorExtractor.js";
+import ora from "ora";
+
+async function loop(page, prompt = "", iteration = 1, maxIterations = 5) {
+    const cwd = process.cwd();
+
+    // Check iteration limit
+    if (iteration > maxIterations) {
+        console.log(chalk.yellow(`⚠️  Maximum iterations (${maxIterations}) reached. Stopping loop.`));
+        console.log(chalk.dim('💡 Consider reviewing the test cases or code manually.'));
+        process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n🔄 Loop Iteration ${iteration}/${maxIterations}`));
+
+    const fileTree = getProjectStructure(cwd);
+    const sourceCode = getCriticalSourceCode(cwd);
+
+    const yamlPath = `${cwd}/vibe.yaml`;
+    let currentYaml = "";
+    if (fs.existsSync(yamlPath)) {
+        currentYaml = fs.readFileSync(yamlPath, 'utf-8');
+    }
+
+    // Generate YAML if prompt is provided (only on first iteration)
+    let spinner = null;
+    if (prompt && iteration === 1) {
+        spinner = ora(chalk.yellow('👀 Generating yaml test cases...')).start();
+        try {
+            const yaml = await generateYaml([fileTree, sourceCode, currentYaml, prompt]);
+            fs.writeFileSync(yamlPath, yaml);
+            spinner.succeed(chalk.green('✨ YAML generated successfully.'));
+            spinner = null;
+        } catch (err) {
+            spinner.fail(chalk.red('❌ YAML generation failed.'));
+            console.log(chalk.red(`Error: ${err.message}`));
+            process.exit(1);
+        }
+    }
+
+    // Run build process with proper promise handling
+    spinner = ora(chalk.yellow('🔨 Building project...')).start();
+
+    const buildResult = await new Promise((resolve) => {
+        exec.exec("npm run build", async function (error, stdout, stderr) {
+            if (error) {
+                spinner.fail(chalk.red('Build Failed! Errors detected.'));
+                console.log('');
+                console.log(chalk.dim('--- Error Logs ---'));
+                console.log(stdout);
+                console.log(stderr);
+
+                const combinedLogs = stdout + "\n" + stderr;
+                let brokenFilePath = extractErrorFile(combinedLogs);
+
+                if (!brokenFilePath) {
+                    console.log(chalk.yellow("⚠️  Could not find file in logs. Defaulting to 'app/page.tsx'"));
+                    brokenFilePath = "app/page.tsx";
+                } else {
+                    console.log(chalk.blue(`🎯 Targeted Broken File: ${brokenFilePath}`));
+                }
+
+                try {
+                    const absolutePath = path.resolve(process.cwd(), brokenFilePath);
+
+                    if (fs.existsSync(absolutePath)) {
+                        spinner = ora(chalk.cyan('🤖 AI fixing the code...')).start();
+                        const pageContent = fs.readFileSync(absolutePath, "utf-8");
+                        const packageContent = fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8");
+
+                        const finalCode = await fixBuild([combinedLogs, pageContent, packageContent]);
+                        fs.writeFileSync(absolutePath, finalCode);
+                        spinner.succeed(chalk.green('✨ Code fixed and saved.'));
+                        spinner = null;
+                        resolve({ success: false, fixed: true });
+                    } else {
+                        console.log(chalk.red(`❌ The file ${brokenFilePath} does not exist.`));
+                        resolve({ success: false, fixed: false });
+                    }
+                } catch (err) {
+                    console.log(chalk.red(`Error fixing files: ${err.message}`));
+                    resolve({ success: false, fixed: false });
+                }
+            } else {
+                spinner.succeed(chalk.green('✅ Build Passed!'));
+                spinner = null;
+                resolve({ success: true });
+            }
+        });
+    });
+
+    // If build failed and couldn't be fixed, exit
+    if (!buildResult.success && !buildResult.fixed) {
+        console.log(chalk.red('❌ Build failed and could not be automatically fixed.'));
+        process.exit(1);
+    }
+
+    // If build was just fixed, retry the loop
+    if (buildResult.fixed) {
+        console.log(chalk.blue('🔄 Retrying with fixed code...'));
+        return loop(page, "", iteration + 1, maxIterations);
+    }
+
+    // Run tests
+    spinner = ora(chalk.yellow('🧪 Running tests...')).start();
+    const testResult = await runTests(page);
+    spinner.stop();
+    spinner = null;
+
+    if (testResult.success) {
+        console.log(chalk.green.bold('\n✨ All tests passed! Loop completed successfully.'));
+        process.exit(0);
+    } else {
+        console.log(chalk.yellow(`\n⚠️  Tests failed. Attempting to fix... (${testResult.failures?.length || 0} failures)`));
+
+        // Gather comprehensive context for AI to fix test failures
+        const yamlPath = `${cwd}/vibe.yaml`;
+        const yamlContent = fs.existsSync(yamlPath) ? fs.readFileSync(yamlPath, 'utf-8') : '';
+        const packageJsonPath = path.join(cwd, 'package.json');
+        const packageJSON = fs.existsSync(packageJsonPath) ? fs.readFileSync(packageJsonPath, 'utf-8') : '{}';
+
+        try {
+            spinner = ora(chalk.cyan('🔧 Generating test-driven fixes...')).start();
+
+            // Call AI with comprehensive context
+            const aiResponse = await fixTestFailures([
+                testResult.failures,
+                yamlContent,
+                sourceCode,
+                fileTree,
+                packageJSON
+            ]);
+
+            spinner.succeed(chalk.green('✅ Fix suggestions generated'));
+
+            // Parse and apply the fixes
+            spinner = ora(chalk.blue('📝 Parsing AI response...')).start();
+            const updates = parseAiResponse(aiResponse);
+
+            if (!updates || updates.length === 0) {
+                spinner.fail(chalk.red('❌ No valid file updates found in AI response'));
+                spinner = null;
+                console.log(chalk.yellow('💡 The AI may have misunderstood. Retrying...'));
+                return loop(page, "", iteration + 1, maxIterations);
+            }
+
+            spinner.succeed(chalk.green(`✅ Found ${updates.length} file(s) to update`));
+            spinner = null;
+
+            // Apply the file updates
+            applyFileUpdates(updates);
+            console.log(chalk.green('✨ Fixes applied successfully!'));
+
+            // Retry the loop with fixed code
+            console.log(chalk.blue('🔄 Retrying tests with fixed code...'));
+            return loop(page, "", iteration + 1, maxIterations);
+
+        } catch (err) {
+            console.log(chalk.red(`❌ Error during test-driven fix: ${err.message}`));
+            console.log(chalk.yellow('💡 Retrying anyway...'));
+            return loop(page, "", iteration + 1, maxIterations);
+        }
+    }
+}
+
+export { loop };

package/lib/registerAndFetchKey.js

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+
+// Store API key in user's home directory
+const CONFIG_DIR = path.join(os.homedir(), '.botintern');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+/**
+ * Save API key to global config
+ */
+export function saveApiKey(apiKey) {
+    try {
+        // Create config directory if it doesn't exist
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+
+        // Save API key to config file
+        const config = {
+            geminiApiKey: apiKey,
+            updatedAt: new Date().toISOString()
+        };
+
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+        return true;
+    } catch (error) {
+        console.error(chalk.red(`Failed to save API key: ${error.message}`));
+        return false;
+    }
+}
+
+/**
+ * Get API key from global config or environment
+ */
+export function getApiKey() {
+    // First, try to get from global config
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+            if (config.geminiApiKey) {
+                return config.geminiApiKey;
+            }
+        }
+    } catch (error) {
+        // Silently fail and try environment variable
+    }
+
+    // Fallback to environment variable
+    return process.env.GEMINI_API_KEY || process.env.API_KEY;
+}
+
+/**
+ * Check if API key is configured
+ */
+export function hasApiKey() {
+    return !!getApiKey();
+}
+
+/**
+ * Remove saved API key
+ */
+export function removeApiKey() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            fs.unlinkSync(CONFIG_FILE);
+            return true;
+        }
+        return false;
+    } catch (error) {
+        console.error(chalk.red(`Failed to remove API key: ${error.message}`));
+        return false;
+    }
+}

package/lib/runPlaywright.js

@@ -0,0 +1,39 @@
+import { execSync } from 'child_process';
+import { chromium } from 'playwright';
+import chalk from 'chalk';
+
+async function runPlaywright() {
+    try {
+        // Attempt to launch
+        const browser = await chromium.launch({
+            headless: true,        // Config: Run invisible
+            slowMo: 50,            // Config: Slow down by 50ms so actions are reliable
+            args: ['--no-sandbox'],
+        });
+
+        const context = await browser.newContext({
+            viewport: { width: 1280, height: 720 }, // Config: Standard Screen size
+            userAgent: 'BotIntern-Vibe-Check/1.0',  // Config: Custom User Agent
+            // recordVideo: { dir: 'test-assets/videos/' } // Config: Free Video Recording!
+        });
+        const page = await context.newPage();
+        return { browser, context, page };
+    } catch (e) {
+        // Check if the error is "Executable not found"
+        if (e.message.includes('Executable doesn\'t exist') || e.message.includes('not found')) {
+            console.log(chalk.yellow('📦 First-time setup: Downloading Browsers... (This happens only once)'));
+
+            // AUTO-INSTALL: The Magic Command
+            execSync('npx playwright install chromium', { stdio: 'inherit' });
+
+            console.log(chalk.green('✅ Setup complete. Resuming...'));
+            return await runPlaywright();
+        }
+        throw e; // Rethrow real errors
+    }
+}
+
+
+export { runPlaywright };
+
+