vibecheck-ai 2.0.2 → 5.0.0

package/bin/runners/runAIAgent.js

@@ -0,0 +1,229 @@
+/**
+ * vibecheck ai-test - AI Agent for autonomous app testing
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+};
+
+function parseArgs(args) {
+  const opts = {
+    help: false,
+    url: null,
+    maxSteps: 20,
+    headed: false,
+    verbose: false,
+    json: false,
+    scenario: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        opts.help = true;
+        break;
+      case "--url":
+      case "-u":
+        opts.url = args[++i];
+        break;
+      case "--max-steps":
+        opts.maxSteps = parseInt(args[++i]);
+        break;
+      case "--headed":
+        opts.headed = true;
+        break;
+      case "--verbose":
+      case "-v":
+        opts.verbose = true;
+        break;
+      case "--json":
+        opts.json = true;
+        break;
+      case "--scenario":
+      case "-s":
+        opts.scenario = args[++i];
+        break;
+    }
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}vibecheck ai-test${c.reset} - AI Agent for autonomous app testing
+
+${c.bold}USAGE${c.reset}
+  vibecheck ai-test --url <url> [options]
+
+${c.bold}OPTIONS${c.reset}
+  --help, -h          Show this help
+  --url, -u <url>     Target URL (required)
+  --max-steps <n>     Maximum exploration steps (default: 20)
+  --headed            Run browser in headed mode
+  --verbose, -v       Show detailed output
+  --json              Output results as JSON
+  --scenario, -s <s>  Test scenario (login, checkout, signup)
+
+${c.bold}SCENARIOS${c.reset}
+  login     Test login flow
+  checkout  Test checkout/payment flow
+  signup    Test user registration
+  explore   General exploration (default)
+
+${c.bold}EXAMPLES${c.reset}
+  vibecheck ai-test --url http://localhost:3000
+  vibecheck ai-test --url http://localhost:3000 --scenario login
+  vibecheck ai-test --url http://localhost:3000 --headed --verbose
+`);
+}
+
+async function runAIAgent(args) {
+  const opts = parseArgs(args);
+
+  if (opts.help) {
+    printHelp();
+    return 0;
+  }
+
+  if (!opts.url) {
+    console.log(`${c.red}✗${c.reset} --url is required\n`);
+    console.log(`${c.dim}Example: vibecheck ai-test --url http://localhost:3000${c.reset}\n`);
+    return 1;
+  }
+
+  console.log(`
+${c.bold}${c.magenta}🤖 AI AGENT TEST${c.reset}
+${c.dim}─────────────────────────────────────────${c.reset}
+  Target:    ${c.cyan}${opts.url}${c.reset}
+  Scenario:  ${opts.scenario || "explore"}
+  Max steps: ${opts.maxSteps}
+`);
+
+  // Check for Playwright
+  let playwright;
+  try {
+    playwright = require("playwright");
+  } catch (e) {
+    console.log(`${c.yellow}⚠${c.reset} Playwright not installed`);
+    console.log(`${c.dim}  Run: npm install -D playwright${c.reset}\n`);
+    return 1;
+  }
+
+  const findings = [];
+  const visited = new Set();
+  const actions = [];
+
+  try {
+    const browser = await playwright.chromium.launch({ headless: !opts.headed });
+    const context = await browser.newContext();
+    const page = await context.newPage();
+
+    // Track console errors
+    page.on("console", (msg) => {
+      if (msg.type() === "error") {
+        findings.push({
+          type: "console_error",
+          message: msg.text(),
+          url: page.url(),
+        });
+      }
+    });
+
+    // Track network errors
+    page.on("requestfailed", (request) => {
+      findings.push({
+        type: "network_error",
+        url: request.url(),
+        failure: request.failure()?.errorText,
+      });
+    });
+
+    console.log(`${c.cyan}▸${c.reset} Navigating to ${opts.url}...`);
+    await page.goto(opts.url, { waitUntil: "networkidle" });
+    visited.add(opts.url);
+    actions.push({ type: "navigate", url: opts.url });
+
+    // Simple exploration loop
+    for (let step = 0; step < opts.maxSteps; step++) {
+      if (opts.verbose) {
+        console.log(`${c.dim}  Step ${step + 1}/${opts.maxSteps}${c.reset}`);
+      }
+
+      // Find clickable elements
+      const buttons = await page.$$("button:visible, a:visible, [role='button']:visible");
+      
+      if (buttons.length === 0) break;
+
+      // Click a random button
+      const randomBtn = buttons[Math.floor(Math.random() * buttons.length)];
+      try {
+        const text = await randomBtn.textContent();
+        await randomBtn.click({ timeout: 3000 });
+        actions.push({ type: "click", text: text?.trim().slice(0, 50) });
+        
+        if (opts.verbose) {
+          console.log(`${c.green}✓${c.reset} Clicked: ${text?.trim().slice(0, 30)}`);
+        }
+        
+        await page.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => {});
+        
+        const currentUrl = page.url();
+        if (!visited.has(currentUrl)) {
+          visited.add(currentUrl);
+          if (opts.verbose) {
+            console.log(`${c.cyan}→${c.reset} New page: ${currentUrl}`);
+          }
+        }
+      } catch (e) {
+        // Element may have disappeared
+      }
+    }
+
+    await browser.close();
+
+    // Report
+    console.log(`
+${c.bold}─────────────────────────────────────────${c.reset}
+${c.bold}RESULTS${c.reset}
+  Pages visited: ${visited.size}
+  Actions taken: ${actions.length}
+  Issues found:  ${findings.length}
+`);
+
+    if (findings.length > 0) {
+      console.log(`${c.bold}Issues:${c.reset}`);
+      for (const f of findings.slice(0, 10)) {
+        console.log(`  ${c.red}✗${c.reset} [${f.type}] ${f.message || f.url}`);
+      }
+      if (findings.length > 10) {
+        console.log(`  ${c.dim}... and ${findings.length - 10} more${c.reset}`);
+      }
+      console.log();
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify({ visited: [...visited], actions, findings }, null, 2));
+    }
+
+    return findings.length > 0 ? 1 : 0;
+
+  } catch (error) {
+    console.error(`${c.red}✗${c.reset} AI Agent failed: ${error.message}`);
+    return 1;
+  }
+}
+
+module.exports = { runAIAgent };

package/bin/runners/runAgent.d.ts

@@ -0,0 +1,5 @@
+export interface AgentOptions {
+  action?: 'install' | 'status' | 'lock' | 'unlock';
+  projectRoot?: string;
+}
+export function runAgent(options?: AgentOptions): Promise<void>;

package/bin/runners/runAgent.js

@@ -0,0 +1,161 @@
+/**
+ * Agent Management Command Handler
+ * 
+ * Install/uninstall hooks, status checks.
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { loadPolicy } = require("./lib/agent-firewall/policy/loader");
+
+/**
+ * Run agent command
+ * @param {object} options - Command options
+ * @param {string} options.action - Action: 'install', 'status', 'lock', 'unlock'
+ * @param {string} options.projectRoot - Project root directory
+ */
+async function runAgent(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const action = options.action || "status";
+  
+  switch (action) {
+    case "install":
+      return installHooks(projectRoot);
+      
+    case "status":
+      return showAgentStatus(projectRoot);
+      
+    case "lock":
+      return lockRepo(projectRoot);
+      
+    case "unlock":
+      return unlockRepo(projectRoot);
+      
+    default:
+      throw new Error(`Unknown action: ${action}`);
+  }
+}
+
+/**
+ * Install IDE hooks
+ */
+function installHooks(projectRoot) {
+  // Create .vibecheck directory if it doesn't exist
+  const vibecheckDir = path.join(projectRoot, ".vibecheck");
+  if (!fs.existsSync(vibecheckDir)) {
+    fs.mkdirSync(vibecheckDir, { recursive: true });
+  }
+  
+  // Create hook marker file
+  const hookFile = path.join(vibecheckDir, "agent-firewall-enabled");
+  fs.writeFileSync(hookFile, JSON.stringify({
+    enabled: true,
+    installedAt: new Date().toISOString()
+  }, null, 2));
+  
+  return {
+    success: true,
+    message: "Agent Firewall hooks installed. Firewall will intercept AI code changes."
+  };
+}
+
+/**
+ * Show agent status
+ */
+function showAgentStatus(projectRoot) {
+  const hookFile = path.join(projectRoot, ".vibecheck", "agent-firewall-enabled");
+  const installed = fs.existsSync(hookFile);
+  
+  let policy;
+  try {
+    policy = loadPolicy(projectRoot);
+  } catch {
+    policy = { mode: "observe", profile: "default" };
+  }
+  
+  return {
+    installed,
+    mode: policy.mode,
+    profile: policy.profile,
+    locked: policy.mode === "enforce" && policy.profile === "repo-lock"
+  };
+}
+
+/**
+ * Lock repo (enable repo-lock mode)
+ */
+function lockRepo(projectRoot) {
+  const { loadPolicy, savePolicy, getDefaultPolicy } = require("./lib/agent-firewall/policy/loader");
+  
+  let policy;
+  try {
+    policy = loadPolicy(projectRoot);
+  } catch {
+    policy = getDefaultPolicy();
+  }
+  
+  policy.mode = "enforce";
+  policy.profile = "repo-lock";
+  
+  // Enable all hard rules
+  if (!policy.rules) {
+    policy.rules = {};
+  }
+  
+  const hardRules = [
+    "ghost_route",
+    "ghost_env",
+    "auth_drift",
+    "contract_drift",
+    "scope_explosion",
+    "unsafe_side_effect"
+  ];
+  
+  for (const rule of hardRules) {
+    if (!policy.rules[rule]) {
+      policy.rules[rule] = {};
+    }
+    policy.rules[rule].enabled = true;
+    policy.rules[rule].severity = "block";
+  }
+  
+  savePolicy(projectRoot, policy);
+  
+  return {
+    success: true,
+    message: "Repo Lock Mode enabled. All hard rules enforced."
+  };
+}
+
+/**
+ * Unlock repo (disable repo-lock mode)
+ */
+function unlockRepo(projectRoot) {
+  const { loadPolicy, savePolicy } = require("./lib/agent-firewall/policy/loader");
+  
+  let policy;
+  try {
+    policy = loadPolicy(projectRoot);
+  } catch {
+    return {
+      success: false,
+      message: "No policy found to unlock"
+    };
+  }
+  
+  policy.mode = "observe";
+  policy.profile = "balanced";
+  
+  savePolicy(projectRoot, policy);
+  
+  return {
+    success: true,
+    message: "Repo Lock Mode disabled. Firewall in observe mode."
+  };
+}
+
+module.exports = {
+  runAgent
+};