@openqa/cli 1.3.4 → 2.0.0

package/dist/agent/index-v2.js

@@ -0,0 +1,2795 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// database/sqlite.ts
+import Database from "better-sqlite3";
+var init_sqlite = __esm({
+  "database/sqlite.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// agent/index-v2.ts
+init_esm_shims();
+import { EventEmitter as EventEmitter5 } from "events";
+
+// database/index.ts
+init_esm_shims();
+init_sqlite();
+import { Low } from "lowdb";
+import { JSONFile } from "lowdb/node";
+import { dirname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdirSync } from "fs";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var OpenQADatabase = class {
+  constructor(dbPath = "./data/openqa.json") {
+    this.dbPath = dbPath;
+    this.initialize();
+  }
+  db = null;
+  initialize() {
+    const dir = dirname(this.dbPath);
+    mkdirSync(dir, { recursive: true });
+    const adapter = new JSONFile(this.dbPath);
+    this.db = new Low(adapter, {
+      config: {},
+      test_sessions: [],
+      actions: [],
+      bugs: [],
+      kanban_tickets: [],
+      users: []
+    });
+    this.db.read();
+    if (!this.db.data) {
+      this.db.data = {
+        config: {},
+        test_sessions: [],
+        actions: [],
+        bugs: [],
+        kanban_tickets: [],
+        users: []
+      };
+      this.db.write();
+    }
+  }
+  async ensureInitialized() {
+    if (!this.db) {
+      this.initialize();
+    }
+    await this.db.read();
+    let migrated = false;
+    if (!this.db.data.users) {
+      this.db.data.users = [];
+      migrated = true;
+    }
+    if (migrated) await this.db.write();
+  }
+  async getConfig(key) {
+    await this.ensureInitialized();
+    return this.db.data.config[key] || null;
+  }
+  async setConfig(key, value) {
+    await this.ensureInitialized();
+    this.db.data.config[key] = value;
+    await this.db.write();
+  }
+  async getAllConfig() {
+    await this.ensureInitialized();
+    return this.db.data.config;
+  }
+  async createSession(id, metadata) {
+    await this.ensureInitialized();
+    const session = {
+      id,
+      started_at: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      total_actions: 0,
+      bugs_found: 0,
+      metadata: metadata ? JSON.stringify(metadata) : void 0
+    };
+    this.db.data.test_sessions.push(session);
+    await this.db.write();
+    return session;
+  }
+  async getSession(id) {
+    await this.ensureInitialized();
+    return this.db.data.test_sessions.find((s) => s.id === id) || null;
+  }
+  async updateSession(id, updates) {
+    await this.ensureInitialized();
+    const index = this.db.data.test_sessions.findIndex((s) => s.id === id);
+    if (index !== -1) {
+      this.db.data.test_sessions[index] = { ...this.db.data.test_sessions[index], ...updates };
+      await this.db.write();
+    }
+  }
+  async getRecentSessions(limit = 10) {
+    await this.ensureInitialized();
+    return this.db.data.test_sessions.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime()).slice(0, limit);
+  }
+  async createAction(action) {
+    await this.ensureInitialized();
+    const newAction = {
+      id: `action_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...action
+    };
+    this.db.data.actions.push(newAction);
+    await this.db.write();
+    return newAction;
+  }
+  async getSessionActions(sessionId) {
+    await this.ensureInitialized();
+    return this.db.data.actions.filter((a) => a.session_id === sessionId).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  }
+  async createBug(bug) {
+    await this.ensureInitialized();
+    const newBug = {
+      id: `bug_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...bug
+    };
+    this.db.data.bugs.push(newBug);
+    await this.db.write();
+    return newBug;
+  }
+  async updateBug(id, updates) {
+    await this.ensureInitialized();
+    const index = this.db.data.bugs.findIndex((b) => b.id === id);
+    if (index !== -1) {
+      this.db.data.bugs[index] = {
+        ...this.db.data.bugs[index],
+        ...updates,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.db.write();
+    }
+  }
+  async getAllBugs() {
+    await this.ensureInitialized();
+    return this.db.data.bugs.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  }
+  async getBugsByStatus(status) {
+    await this.ensureInitialized();
+    return this.db.data.bugs.filter((b) => b.status === status).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  }
+  async createKanbanTicket(ticket) {
+    await this.ensureInitialized();
+    const newTicket = {
+      id: `ticket_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...ticket
+    };
+    this.db.data.kanban_tickets.push(newTicket);
+    await this.db.write();
+    return newTicket;
+  }
+  async updateKanbanTicket(id, updates) {
+    await this.ensureInitialized();
+    const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      this.db.data.kanban_tickets[index] = {
+        ...this.db.data.kanban_tickets[index],
+        ...updates,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.db.write();
+    }
+  }
+  async getKanbanTickets() {
+    await this.ensureInitialized();
+    return this.db.data.kanban_tickets.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  }
+  async getKanbanTicketsByColumn(column) {
+    await this.ensureInitialized();
+    return this.db.data.kanban_tickets.filter((t) => t.column === column).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+  }
+  async deleteKanbanTicket(id) {
+    await this.ensureInitialized();
+    const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      this.db.data.kanban_tickets.splice(index, 1);
+      await this.db.write();
+    }
+  }
+  async clearAllConfig() {
+    await this.ensureInitialized();
+    this.db.data.config = {};
+    await this.db.write();
+  }
+  // Get real data methods - connected to actual database records
+  async getActiveAgents() {
+    await this.ensureInitialized();
+    const sessions = await this.getRecentSessions(1);
+    const currentSession = sessions[0];
+    const isRunning = currentSession?.status === "running";
+    const totalActions = currentSession?.total_actions || 0;
+    const agents = [
+      {
+        name: "Main Agent",
+        status: isRunning ? "running" : "idle",
+        purpose: "Autonomous QA orchestration",
+        performance: totalActions > 0 ? Math.min(100, Math.round(totalActions / 100 * 100)) : 0,
+        tasks: totalActions
+      }
+    ];
+    if (currentSession && totalActions > 0) {
+      const actions = await this.getSessionActions(currentSession.id);
+      const actionTypes = actions.reduce((acc, action) => {
+        const type = action.type || "unknown";
+        acc[type] = (acc[type] || 0) + 1;
+        return acc;
+      }, {});
+      if (actionTypes["navigate"] || actionTypes["click"] || actionTypes["screenshot"]) {
+        agents.push({
+          name: "Browser Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "UI navigation and interaction",
+          performance: Math.round(((actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)) / totalActions * 100),
+          tasks: (actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)
+        });
+      }
+      if (actionTypes["api_call"] || actionTypes["request"]) {
+        agents.push({
+          name: "API Tester",
+          status: isRunning ? "running" : "idle",
+          purpose: "API endpoint testing",
+          performance: Math.round((actionTypes["api_call"] || actionTypes["request"] || 0) / totalActions * 100),
+          tasks: actionTypes["api_call"] || actionTypes["request"] || 0
+        });
+      }
+      if (actionTypes["auth"] || actionTypes["login"]) {
+        agents.push({
+          name: "Auth Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "Authentication testing",
+          performance: Math.round((actionTypes["auth"] || actionTypes["login"] || 0) / totalActions * 100),
+          tasks: actionTypes["auth"] || actionTypes["login"] || 0
+        });
+      }
+    }
+    return agents;
+  }
+  async getCurrentTasks() {
+    await this.ensureInitialized();
+    const sessions = await this.getRecentSessions(1);
+    const currentSession = sessions[0];
+    if (!currentSession) {
+      return [];
+    }
+    const actions = await this.getSessionActions(currentSession.id);
+    const recentActions = actions.slice(-10).reverse();
+    return recentActions.map((action, index) => ({
+      id: action.id,
+      name: action.type || "Unknown Action",
+      status: index === 0 && currentSession.status === "running" ? "running" : "completed",
+      progress: index === 0 && currentSession.status === "running" ? "65%" : "100%",
+      agent: "Main Agent",
+      started_at: action.timestamp,
+      result: action.output || action.description || "Completed"
+    }));
+  }
+  async getCurrentIssues() {
+    await this.ensureInitialized();
+    const bugs = await this.getAllBugs();
+    return bugs.slice(0, 10).map((bug) => ({
+      id: bug.id,
+      title: bug.title,
+      description: bug.description,
+      severity: bug.severity || "medium",
+      status: bug.status || "open",
+      discovered_at: bug.created_at,
+      agent: "Main Agent"
+    }));
+  }
+  async pruneOldSessions(maxAgeDays) {
+    await this.ensureInitialized();
+    const cutoff = new Date(Date.now() - maxAgeDays * 864e5).toISOString();
+    const oldSessions = this.db.data.test_sessions.filter((s) => s.started_at < cutoff);
+    const oldSessionIds = new Set(oldSessions.map((s) => s.id));
+    const actionsBefore = this.db.data.actions.length;
+    this.db.data.actions = this.db.data.actions.filter((a) => !oldSessionIds.has(a.session_id));
+    const actionsRemoved = actionsBefore - this.db.data.actions.length;
+    this.db.data.test_sessions = this.db.data.test_sessions.filter((s) => s.started_at >= cutoff);
+    await this.db.write();
+    return { sessionsRemoved: oldSessions.length, actionsRemoved };
+  }
+  async getStorageStats() {
+    await this.ensureInitialized();
+    return {
+      sessions: this.db.data.test_sessions.length,
+      actions: this.db.data.actions.length,
+      bugs: this.db.data.bugs.length,
+      tickets: this.db.data.kanban_tickets.length
+    };
+  }
+  // ── User management ──────────────────────────────────────────────────────────
+  async countUsers() {
+    await this.ensureInitialized();
+    return this.db.data.users.length;
+  }
+  async findUserByUsername(username) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.username === username) ?? null;
+  }
+  async getUserById(id) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.id === id) ?? null;
+  }
+  async getAllUsers() {
+    await this.ensureInitialized();
+    return [...this.db.data.users];
+  }
+  async createUser(data) {
+    await this.ensureInitialized();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const user = {
+      id: `user_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      username: data.username,
+      passwordHash: data.passwordHash,
+      role: data.role,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.data.users.push(user);
+    await this.db.write();
+    return user;
+  }
+  async updateUser(id, updates) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users[idx] = {
+        ...this.db.data.users[idx],
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.db.write();
+    }
+  }
+  async deleteUser(id) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users.splice(idx, 1);
+      await this.db.write();
+    }
+  }
+  async close() {
+  }
+};
+
+// agent/logger.ts
+init_esm_shims();
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var MIN_LEVEL = process.env.LOG_LEVEL || "info";
+function shouldLog(level) {
+  return LEVELS[level] >= LEVELS[MIN_LEVEL];
+}
+function format(level, message, context) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    msg: message,
+    ...context
+  };
+  return JSON.stringify(entry);
+}
+var logger = {
+  debug(message, context) {
+    if (shouldLog("debug")) process.stdout.write(format("debug", message, context) + "\n");
+  },
+  info(message, context) {
+    if (shouldLog("info")) process.stdout.write(format("info", message, context) + "\n");
+  },
+  warn(message, context) {
+    if (shouldLog("warn")) process.stderr.write(format("warn", message, context) + "\n");
+  },
+  error(message, context) {
+    if (shouldLog("error")) process.stderr.write(format("error", message, context) + "\n");
+  },
+  child(defaults) {
+    return {
+      debug: (msg, ctx) => logger.debug(msg, { ...defaults, ...ctx }),
+      info: (msg, ctx) => logger.info(msg, { ...defaults, ...ctx }),
+      warn: (msg, ctx) => logger.warn(msg, { ...defaults, ...ctx }),
+      error: (msg, ctx) => logger.error(msg, { ...defaults, ...ctx })
+    };
+  }
+};
+
+// agent/config/index.ts
+init_esm_shims();
+import { config as dotenvConfig } from "dotenv";
+
+// agent/config/schema.ts
+init_esm_shims();
+import { z } from "zod";
+var llmConfigSchema = z.object({
+  provider: z.enum(["openai", "anthropic", "ollama"]).default("openai"),
+  apiKey: z.string().optional(),
+  model: z.string().optional(),
+  baseUrl: z.string().url().optional()
+});
+var saasConfigSchema = z.object({
+  url: z.string().default(""),
+  authType: z.enum(["none", "basic", "bearer", "session"]).default("none"),
+  username: z.string().optional(),
+  password: z.string().optional()
+});
+var githubConfigSchema = z.object({
+  token: z.string().min(1, "GITHUB_TOKEN is required when GitHub is configured"),
+  owner: z.string().default(""),
+  repo: z.string().default("")
+});
+var agentConfigSchema = z.object({
+  intervalMs: z.number().int().positive().default(36e5),
+  maxIterations: z.number().int().positive().default(20),
+  autoStart: z.boolean().default(false)
+});
+var webConfigSchema = z.object({
+  port: z.number().int().min(1).max(65535).default(4242),
+  host: z.string().default("0.0.0.0")
+});
+var databaseConfigSchema = z.object({
+  path: z.string().default("./data/openqa.db")
+});
+var notificationsConfigSchema = z.object({
+  slack: z.string().url().optional(),
+  discord: z.string().url().optional()
+});
+var openQAConfigSchema = z.object({
+  llm: llmConfigSchema,
+  saas: saasConfigSchema,
+  github: githubConfigSchema.optional(),
+  agent: agentConfigSchema,
+  web: webConfigSchema,
+  database: databaseConfigSchema,
+  notifications: notificationsConfigSchema.optional()
+});
+var saasAppConfigSchema = z.object({
+  name: z.string().min(1, "SaaS application name is required"),
+  description: z.string().min(1, "SaaS application description is required"),
+  url: z.string().url("SaaS application URL must be a valid URL"),
+  repoUrl: z.string().url().optional(),
+  localPath: z.string().optional(),
+  techStack: z.array(z.string()).optional(),
+  authInfo: z.object({
+    type: z.enum(["none", "basic", "oauth", "session"]),
+    testCredentials: z.object({
+      username: z.string(),
+      password: z.string()
+    }).optional()
+  }).optional(),
+  directives: z.array(z.string()).optional()
+});
+function validateSaaSAppConfigSafe(config) {
+  const result = saasAppConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+function validateConfigSafe(config) {
+  const result = openQAConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+
+// agent/config/index.ts
+dotenvConfig();
+var ConfigManager = class {
+  db = null;
+  envConfig;
+  constructor(dbPath) {
+    this.envConfig = this.loadFromEnv();
+  }
+  loadFromEnv() {
+    const raw = {
+      llm: {
+        provider: process.env.LLM_PROVIDER || "openai",
+        apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
+        model: process.env.LLM_MODEL,
+        baseUrl: process.env.OLLAMA_BASE_URL
+      },
+      saas: {
+        url: process.env.SAAS_URL || "",
+        authType: process.env.SAAS_AUTH_TYPE || "none",
+        username: process.env.SAAS_USERNAME,
+        password: process.env.SAAS_PASSWORD
+      },
+      github: process.env.GITHUB_TOKEN ? {
+        token: process.env.GITHUB_TOKEN,
+        owner: process.env.GITHUB_OWNER || "",
+        repo: process.env.GITHUB_REPO || ""
+      } : void 0,
+      agent: {
+        intervalMs: parseInt(process.env.AGENT_INTERVAL_MS || "3600000"),
+        maxIterations: parseInt(process.env.AGENT_MAX_ITERATIONS || "20"),
+        autoStart: process.env.AGENT_AUTO_START === "true"
+      },
+      web: {
+        port: parseInt(process.env.WEB_PORT || "4242"),
+        host: process.env.WEB_HOST || "0.0.0.0"
+      },
+      database: {
+        path: process.env.DB_PATH || "./data/openqa.db"
+      },
+      notifications: {
+        slack: process.env.SLACK_WEBHOOK_URL,
+        discord: process.env.DISCORD_WEBHOOK_URL
+      }
+    };
+    const result = validateConfigSafe(raw);
+    if (!result.success) {
+      logger.warn("Config validation warnings", { errors: result.errors });
+      return raw;
+    }
+    return result.data;
+  }
+  getDB() {
+    if (!this.db) {
+      this.db = new OpenQADatabase("./data/openqa.json");
+    }
+    return this.db;
+  }
+  async get(key) {
+    const dbValue = await this.getDB().getConfig(key);
+    if (dbValue) return dbValue;
+    const keys = key.split(".");
+    let value = this.envConfig;
+    for (const k of keys) {
+      if (value && typeof value === "object") {
+        value = value[k];
+      } else {
+        return null;
+      }
+    }
+    return value != null ? String(value) : null;
+  }
+  async set(key, value) {
+    await this.getDB().setConfig(key, value);
+  }
+  async getAll() {
+    const dbConfig = await this.getDB().getAllConfig();
+    const merged = { ...this.envConfig };
+    for (const [key, value] of Object.entries(dbConfig)) {
+      const keys = key.split(".");
+      let obj = merged;
+      for (let i = 0; i < keys.length - 1; i++) {
+        if (!obj[keys[i]] || typeof obj[keys[i]] !== "object") obj[keys[i]] = {};
+        obj = obj[keys[i]];
+      }
+      obj[keys[keys.length - 1]] = value;
+    }
+    return merged;
+  }
+  async getConfig() {
+    return await this.getAll();
+  }
+  // Synchronous version that only uses env vars (no DB)
+  getConfigSync() {
+    return this.envConfig;
+  }
+};
+
+// agent/config/saas-config.ts
+init_esm_shims();
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join2 } from "path";
+
+// agent/errors.ts
+init_esm_shims();
+var OpenQAError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "OpenQAError";
+    this.code = code;
+  }
+};
+var ConfigError = class extends OpenQAError {
+  constructor(message, code = "CONFIG_ERROR") {
+    super(message, code);
+    this.name = "ConfigError";
+  }
+};
+var BrainError = class extends OpenQAError {
+  constructor(message, code = "BRAIN_ERROR") {
+    super(message, code);
+    this.name = "BrainError";
+  }
+};
+var ProjectRunnerError = class extends OpenQAError {
+  constructor(message, code = "PROJECT_RUNNER_ERROR") {
+    super(message, code);
+    this.name = "ProjectRunnerError";
+  }
+};
+
+// agent/config/saas-config.ts
+var SaaSConfigManager = class {
+  db;
+  config = null;
+  constructor(db) {
+    this.db = db;
+    this.loadConfig();
+  }
+  loadConfig() {
+  }
+  saveConfig() {
+  }
+  configure(config) {
+    const result = validateSaaSAppConfigSafe(config);
+    if (!result.success) {
+      throw new ConfigError("Invalid SaaS configuration: " + result.errors.join(", "));
+    }
+    this.config = {
+      ...config,
+      techStack: config.techStack || this.detectTechStack(config.localPath),
+      directives: config.directives || []
+    };
+    this.saveConfig();
+    return this.config;
+  }
+  detectTechStack(localPath) {
+    if (!localPath || !existsSync(localPath)) return [];
+    const stack = [];
+    try {
+      const pkgPath = join2(localPath, "package.json");
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps["react"]) stack.push("React");
+        if (deps["vue"]) stack.push("Vue");
+        if (deps["svelte"]) stack.push("Svelte");
+        if (deps["angular"]) stack.push("Angular");
+        if (deps["next"]) stack.push("Next.js");
+        if (deps["nuxt"]) stack.push("Nuxt");
+        if (deps["express"]) stack.push("Express");
+        if (deps["fastify"]) stack.push("Fastify");
+        if (deps["nestjs"] || deps["@nestjs/core"]) stack.push("NestJS");
+        if (deps["prisma"] || deps["@prisma/client"]) stack.push("Prisma");
+        if (deps["mongoose"]) stack.push("MongoDB");
+        if (deps["pg"] || deps["postgres"]) stack.push("PostgreSQL");
+        if (deps["mysql"] || deps["mysql2"]) stack.push("MySQL");
+        if (deps["redis"] || deps["ioredis"]) stack.push("Redis");
+        if (deps["typescript"]) stack.push("TypeScript");
+        if (deps["tailwindcss"]) stack.push("TailwindCSS");
+      }
+      if (existsSync(join2(localPath, "requirements.txt")) || existsSync(join2(localPath, "pyproject.toml"))) {
+        stack.push("Python");
+      }
+      if (existsSync(join2(localPath, "go.mod"))) {
+        stack.push("Go");
+      }
+      if (existsSync(join2(localPath, "Cargo.toml"))) {
+        stack.push("Rust");
+      }
+    } catch (e) {
+    }
+    return stack;
+  }
+  getConfig() {
+    return this.config;
+  }
+  addDirective(directive) {
+    if (!this.config) return;
+    if (!this.config.directives) this.config.directives = [];
+    this.config.directives.push(directive);
+    this.saveConfig();
+  }
+  removeDirective(index) {
+    if (!this.config?.directives) return;
+    this.config.directives.splice(index, 1);
+    this.saveConfig();
+  }
+  updateDirectives(directives) {
+    if (!this.config) return;
+    this.config.directives = directives;
+    this.saveConfig();
+  }
+  setRepoUrl(url) {
+    if (!this.config) return;
+    this.config.repoUrl = url;
+    this.saveConfig();
+  }
+  setLocalPath(path2) {
+    if (!this.config) return;
+    this.config.localPath = path2;
+    this.config.techStack = this.detectTechStack(path2);
+    this.saveConfig();
+  }
+  setAuthInfo(authInfo) {
+    if (!this.config) return;
+    this.config.authInfo = authInfo;
+    this.saveConfig();
+  }
+  isConfigured() {
+    return this.config !== null && !!this.config.name && !!this.config.url;
+  }
+  exportConfig() {
+    return JSON.stringify(this.config, null, 2);
+  }
+  importConfig(json) {
+    const config = JSON.parse(json);
+    return this.configure(config);
+  }
+};
+var DEFAULT_DIRECTIVES = [
+  "Test all forms for validation errors and edge cases",
+  "Check for security vulnerabilities (XSS, SQL injection, CSRF)",
+  "Verify authentication and authorization work correctly",
+  "Test responsive design on mobile viewports",
+  "Check for accessibility issues (WCAG compliance)",
+  "Monitor console for JavaScript errors",
+  "Test error handling and user feedback",
+  "Verify all links work and navigation is correct"
+];
+function createQuickConfig(name, description, url, options) {
+  return {
+    name,
+    description,
+    url,
+    repoUrl: options?.repoUrl,
+    localPath: options?.localPath,
+    directives: options?.directives || DEFAULT_DIRECTIVES,
+    authInfo: { type: "none" }
+  };
+}
+
+// agent/brain/index.ts
+init_esm_shims();
+import { EventEmitter as EventEmitter2 } from "events";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync3, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3 } from "path";
+import { execSync } from "child_process";
+
+// agent/brain/llm-resilience.ts
+init_esm_shims();
+import { OpenAIAdapter } from "@orka-js/openai";
+import { AnthropicAdapter } from "@orka-js/anthropic";
+import { EventEmitter } from "events";
+
+// agent/brain/llm-cache.ts
+init_esm_shims();
+import { createHash } from "crypto";
+var LLMCache = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxSize;
+  constructor(options) {
+    this.ttlMs = options?.ttlMs ?? 36e5;
+    this.maxSize = options?.maxSize ?? 500;
+  }
+  key(prompt) {
+    return createHash("sha256").update(prompt).digest("hex");
+  }
+  get(prompt) {
+    const k = this.key(prompt);
+    const entry = this.store.get(k);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(k);
+      return null;
+    }
+    return entry.response;
+  }
+  set(prompt, response) {
+    if (this.store.size >= this.maxSize) {
+      const oldest = this.store.keys().next().value;
+      if (oldest) this.store.delete(oldest);
+    }
+    this.store.set(this.key(prompt), {
+      response,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+  stats() {
+    return { size: this.store.size, ttlMs: this.ttlMs, maxSize: this.maxSize };
+  }
+};
+
+// agent/metrics.ts
+init_esm_shims();
+var startedAt = Date.now();
+var counters = {
+  llm_calls: 0,
+  llm_cache_hits: 0,
+  llm_retries: 0,
+  llm_fallbacks: 0,
+  llm_circuit_opens: 0,
+  tests_generated: 0,
+  tests_run: 0,
+  tests_passed: 0,
+  tests_failed: 0,
+  bugs_found: 0,
+  sessions_started: 0,
+  ws_connections: 0,
+  http_requests: 0
+};
+var metrics = {
+  inc(key, by = 1) {
+    if (key in counters) counters[key] += by;
+  },
+  snapshot() {
+    const memMB = process.memoryUsage();
+    return {
+      uptimeSeconds: Math.floor((Date.now() - startedAt) / 1e3),
+      memory: {
+        heapUsedMB: Math.round(memMB.heapUsed / 1024 / 1024),
+        heapTotalMB: Math.round(memMB.heapTotal / 1024 / 1024),
+        rssMB: Math.round(memMB.rss / 1024 / 1024)
+      },
+      counters: { ...counters },
+      cacheHitRate: counters.llm_calls > 0 ? Math.round(counters.llm_cache_hits / (counters.llm_calls + counters.llm_cache_hits) * 100) : 0
+    };
+  }
+};
+
+// agent/brain/llm-resilience.ts
+var ResilientLLM = class extends EventEmitter {
+  config;
+  circuit = { failures: 0, lastFailure: 0, isOpen: false };
+  maxRetries;
+  circuitThreshold;
+  circuitResetMs;
+  cache;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.circuitThreshold = config.circuitThreshold ?? 5;
+    this.circuitResetMs = config.circuitResetMs ?? 3e4;
+    this.cache = new LLMCache({
+      ttlMs: config.cacheTtlMs,
+      maxSize: config.cacheMaxSize
+    });
+  }
+  createAdapter(provider, apiKey, model) {
+    if (provider === "anthropic") {
+      return new AnthropicAdapter({
+        apiKey,
+        model: model || "claude-3-5-sonnet-20241022"
+      });
+    }
+    return new OpenAIAdapter({
+      apiKey,
+      model: model || "gpt-4"
+    });
+  }
+  isCircuitOpen() {
+    if (!this.circuit.isOpen) return false;
+    if (Date.now() - this.circuit.lastFailure >= this.circuitResetMs) {
+      this.circuit.isOpen = false;
+      this.emit("llm-circuit-half-open", { provider: this.config.provider });
+      return false;
+    }
+    return true;
+  }
+  recordFailure() {
+    this.circuit.failures++;
+    this.circuit.lastFailure = Date.now();
+    if (this.circuit.failures >= this.circuitThreshold) {
+      this.circuit.isOpen = true;
+      metrics.inc("llm_circuit_opens");
+      this.emit("llm-circuit-open", {
+        provider: this.config.provider,
+        failures: this.circuit.failures
+      });
+    }
+  }
+  recordSuccess() {
+    this.circuit.failures = 0;
+    this.circuit.isOpen = false;
+  }
+  /** Generate text, returning the string content */
+  async generate(prompt) {
+    const cached = this.cache.get(prompt);
+    if (cached !== null) {
+      metrics.inc("llm_cache_hits");
+      this.emit("llm-cache-hit", { promptLength: prompt.length });
+      return cached;
+    }
+    metrics.inc("llm_calls");
+    if (!this.isCircuitOpen()) {
+      try {
+        return await this.generateWithRetry(
+          this.config.provider,
+          this.config.apiKey,
+          this.config.model,
+          prompt
+        );
+      } catch (e) {
+        this.recordFailure();
+        this.emit("llm-primary-failed", {
+          provider: this.config.provider,
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
+    if (this.config.fallbackProvider && this.config.fallbackApiKey) {
+      try {
+        metrics.inc("llm_fallbacks");
+        this.emit("llm-fallback", {
+          from: this.config.provider,
+          to: this.config.fallbackProvider
+        });
+        const result = await this.generateWithRetry(
+          this.config.fallbackProvider,
+          this.config.fallbackApiKey,
+          this.config.fallbackModel,
+          prompt
+        );
+        this.cache.set(prompt, result);
+        return result;
+      } catch (e) {
+        throw new BrainError(
+          `Both LLM providers failed. Primary: ${this.config.provider}, Fallback: ${this.config.fallbackProvider}`
+        );
+      }
+    }
+    throw new BrainError(
+      `LLM provider ${this.config.provider} failed and no fallback is configured`
+    );
+  }
+  async generateWithRetry(provider, apiKey, model, prompt) {
+    const adapter = this.createAdapter(provider, apiKey, model);
+    let lastError;
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const result = await adapter.generate(prompt);
+        const text = result.content;
+        this.recordSuccess();
+        this.cache.set(prompt, text);
+        return text;
+      } catch (e) {
+        lastError = e;
+        if (attempt < this.maxRetries) {
+          const delayMs = Math.pow(2, attempt - 1) * 1e3;
+          metrics.inc("llm_retries");
+          this.emit("llm-retry", {
+            provider,
+            attempt,
+            maxRetries: this.maxRetries,
+            delayMs,
+            error: e instanceof Error ? e.message : String(e)
+          });
+          await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+        }
+      }
+    }
+    throw lastError;
+  }
+  getCircuitState() {
+    return {
+      isOpen: this.isCircuitOpen(),
+      failures: this.circuit.failures
+    };
+  }
+  getCacheStats() {
+    return this.cache.stats();
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+};
+
+// agent/brain/index.ts
+var OpenQABrain = class extends EventEmitter2 {
+  db;
+  llm;
+  saasConfig;
+  generatedTests = /* @__PURE__ */ new Map();
+  dynamicAgents = /* @__PURE__ */ new Map();
+  workDir = "./data/workspace";
+  testsDir = "./data/generated-tests";
+  constructor(db, llmConfig, saasConfig) {
+    super();
+    this.db = db;
+    this.saasConfig = saasConfig;
+    this.llm = new ResilientLLM({
+      provider: llmConfig.provider,
+      apiKey: llmConfig.apiKey,
+      model: llmConfig.model,
+      fallbackProvider: llmConfig.fallbackProvider,
+      fallbackApiKey: llmConfig.fallbackApiKey,
+      fallbackModel: llmConfig.fallbackModel
+    });
+    for (const event of ["llm-retry", "llm-fallback", "llm-circuit-open", "llm-circuit-half-open", "llm-primary-failed"]) {
+      this.llm.on(event, (data) => this.emit(event, data));
+    }
+    mkdirSync2(this.workDir, { recursive: true });
+    mkdirSync2(this.testsDir, { recursive: true });
+  }
+  async analyze() {
+    let codeContext = "";
+    if (this.saasConfig.repoUrl || this.saasConfig.localPath) {
+      codeContext = await this.analyzeCodebase();
+    }
+    const prompt = `You are OpenQA Brain, an autonomous QA system that thinks like a senior QA engineer.
+
+## SaaS Application to Test
+- **Name**: ${this.saasConfig.name}
+- **Description**: ${this.saasConfig.description}
+- **URL**: ${this.saasConfig.url}
+- **Tech Stack**: ${this.saasConfig.techStack?.join(", ") || "Unknown"}
+- **Auth Type**: ${this.saasConfig.authInfo?.type || "none"}
+
+## User Directives
+${this.saasConfig.directives?.map((d) => `- ${d}`).join("\n") || "None specified"}
+
+${codeContext ? `## Code Analysis
+${codeContext}` : ""}
+
+## Your Task
+Analyze this application and provide:
+
+1. **Understanding**: A brief summary of what this application does and its critical paths
+2. **Suggested Tests**: List specific tests you would create (be concrete, not generic)
+3. **Suggested Agents**: Custom agents you would create for this specific app
+4. **Risks**: Potential issues or vulnerabilities to focus on
+
+Think deeply about what could go wrong with THIS specific application.
+
+Respond in JSON format:
+{
+  "understanding": "...",
+  "suggestedTests": ["Test 1: ...", "Test 2: ..."],
+  "suggestedAgents": ["Agent for X", "Agent for Y"],
+  "risks": ["Risk 1", "Risk 2"]
+}`;
+    const response = await this.llm.generate(prompt);
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+    } catch (e) {
+      logger.warn("Failed to parse analysis", { error: e instanceof Error ? e.message : String(e) });
+    }
+    return {
+      understanding: response,
+      suggestedTests: [],
+      suggestedAgents: [],
+      risks: []
+    };
+  }
+  async analyzeCodebase() {
+    let repoPath = this.saasConfig.localPath;
+    if (this.saasConfig.repoUrl && !this.saasConfig.localPath) {
+      repoPath = join3(this.workDir, "repo");
+      if (!existsSync2(repoPath)) {
+        logger.info("Cloning repository", { url: this.saasConfig.repoUrl });
+        try {
+          execSync(`git clone --depth 1 ${this.saasConfig.repoUrl} ${repoPath}`, {
+            stdio: "pipe"
+          });
+        } catch (e) {
+          logger.error("Failed to clone repository", { error: e instanceof Error ? e.message : String(e) });
+          return "";
+        }
+      }
+    }
+    if (!repoPath || !existsSync2(repoPath)) {
+      return "";
+    }
+    const analysis = [];
+    try {
+      const packageJsonPath = join3(repoPath, "package.json");
+      if (existsSync2(packageJsonPath)) {
+        const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+        analysis.push(`### Package Info`);
+        analysis.push(`- Name: ${pkg.name}`);
+        analysis.push(`- Dependencies: ${Object.keys(pkg.dependencies || {}).slice(0, 20).join(", ")}`);
+        analysis.push(`- Scripts: ${Object.keys(pkg.scripts || {}).join(", ")}`);
+      }
+      const srcFiles = this.findFiles(repoPath, [".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"], 50);
+      if (srcFiles.length > 0) {
+        analysis.push(`
+### Source Files (${srcFiles.length} found)`);
+        srcFiles.slice(0, 20).forEach((f) => {
+          analysis.push(`- ${f.replace(repoPath, "")}`);
+        });
+      }
+      const testFiles = this.findFiles(repoPath, [".test.ts", ".test.js", ".spec.ts", ".spec.js"], 20);
+      if (testFiles.length > 0) {
+        analysis.push(`
+### Existing Tests (${testFiles.length} found)`);
+        testFiles.slice(0, 10).forEach((f) => {
+          analysis.push(`- ${f.replace(repoPath, "")}`);
+        });
+      }
+      const routePatterns = ["routes", "pages", "views", "controllers", "api"];
+      for (const pattern of routePatterns) {
+        const routeDir = join3(repoPath, "src", pattern);
+        if (existsSync2(routeDir)) {
+          const routes = this.findFiles(routeDir, [".ts", ".tsx", ".js", ".jsx"], 20);
+          if (routes.length > 0) {
+            analysis.push(`
+### Routes/Pages`);
+            routes.forEach((f) => {
+              analysis.push(`- ${f.replace(repoPath, "")}`);
+            });
+          }
+          break;
+        }
+      }
+    } catch (e) {
+      logger.error("Error analyzing codebase", { error: e instanceof Error ? e.message : String(e) });
+    }
+    return analysis.join("\n");
+  }
+  findFiles(dir, extensions, limit) {
+    const results = [];
+    try {
+      const find = (d) => {
+        if (results.length >= limit) return;
+        const { readdirSync, statSync: statSync2 } = __require("fs");
+        const items = readdirSync(d);
+        for (const item of items) {
+          if (results.length >= limit) return;
+          if (item.startsWith(".") || item === "node_modules" || item === "dist" || item === "build") continue;
+          const fullPath = join3(d, item);
+          const stat = statSync2(fullPath);
+          if (stat.isDirectory()) {
+            find(fullPath);
+          } else if (extensions.some((ext) => item.endsWith(ext))) {
+            results.push(fullPath);
+          }
+        }
+      };
+      find(dir);
+    } catch (e) {
+    }
+    return results;
+  }
+  async generateTest(type, target, context) {
+    const prompt = `You are OpenQA, an autonomous QA engineer. Generate a ${type} test.
+
+## Application
+- **Name**: ${this.saasConfig.name}
+- **Description**: ${this.saasConfig.description}
+- **URL**: ${this.saasConfig.url}
+
+## Test Target
+${target}
+
+${context ? `## Additional Context
+${context}` : ""}
+
+## Instructions
+Generate a complete, runnable test. Use Playwright for E2E/functional tests.
+
+For ${type} tests:
+${type === "unit" ? "- Test isolated functions/components\n- Mock dependencies\n- Use Jest or Vitest syntax" : ""}
+${type === "functional" ? "- Test user workflows\n- Use Playwright\n- Include assertions" : ""}
+${type === "e2e" ? "- Test complete user journeys\n- Use Playwright\n- Handle auth if needed" : ""}
+${type === "regression" ? "- Test previously broken functionality\n- Verify bug fixes\n- Include edge cases" : ""}
+${type === "security" ? "- Test for vulnerabilities\n- SQL injection, XSS, auth bypass\n- Use safe payloads" : ""}
+${type === "performance" ? "- Measure load times\n- Check resource usage\n- Set thresholds" : ""}
+
+Respond with JSON:
+{
+  "name": "descriptive test name",
+  "description": "what this test verifies",
+  "code": "// complete test code here",
+  "priority": 1-5
+}`;
+    const response = await this.llm.generate(prompt);
+    let testData = { name: target, description: "", code: "", priority: 3 };
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        testData = JSON.parse(jsonMatch[0]);
+      }
+    } catch (e) {
+      testData.code = response;
+    }
+    const test = {
+      id: `test_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name: testData.name,
+      type,
+      description: testData.description,
+      code: testData.code,
+      priority: testData.priority,
+      status: "pending",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.generatedTests.set(test.id, test);
+    this.saveTest(test);
+    this.emit("test-generated", test);
+    return test;
+  }
+  saveTest(test) {
+    const filename = `${test.type}_${test.id}.ts`;
+    const filepath = join3(this.testsDir, filename);
+    const content = `/**
+ * Generated by OpenQA
+ * Type: ${test.type}
+ * Name: ${test.name}
+ * Description: ${test.description}
+ * Created: ${test.createdAt.toISOString()}
+ */
+
+${test.code}
+`;
+    writeFileSync2(filepath, content);
+    test.targetFile = filepath;
+  }
+  async createDynamicAgent(purpose) {
+    const prompt = `You are OpenQA Brain. Create a specialized testing agent.
+
+## Application Context
+- **Name**: ${this.saasConfig.name}
+- **Description**: ${this.saasConfig.description}
+- **URL**: ${this.saasConfig.url}
+
+## Agent Purpose
+${purpose}
+
+## Instructions
+Design a specialized agent for this specific purpose. The agent should:
+1. Have a clear, focused mission
+2. Know exactly what to test
+3. Know how to report findings
+
+Respond with JSON:
+{
+  "name": "Agent Name",
+  "purpose": "Clear purpose statement",
+  "prompt": "Complete system prompt for this agent (be specific and detailed)",
+  "tools": ["tool1", "tool2"] // from: navigate, click, fill, screenshot, check_console, create_issue, create_ticket
+}`;
+    const response = await this.llm.generate(prompt);
+    let agentData = { name: purpose, purpose, prompt: "", tools: [] };
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        agentData = JSON.parse(jsonMatch[0]);
+      }
+    } catch (_e) {
+      agentData.prompt = response;
+    }
+    const agent = {
+      id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      name: agentData.name,
+      purpose: agentData.purpose,
+      prompt: agentData.prompt,
+      tools: agentData.tools,
+      createdAt: /* @__PURE__ */ new Date(),
+      executionCount: 0,
+      successRate: 0
+    };
+    this.dynamicAgents.set(agent.id, agent);
+    this.emit("agent-created", agent);
+    return agent;
+  }
+  async executeTest(testId) {
+    const test = this.generatedTests.get(testId);
+    if (!test) throw new Error(`Test ${testId} not found`);
+    test.status = "running";
+    test.executedAt = /* @__PURE__ */ new Date();
+    this.emit("test-started", test);
+    try {
+      if (test.targetFile && existsSync2(test.targetFile)) {
+        const result = execSync(`npx playwright test ${test.targetFile} --reporter=json`, {
+          cwd: this.testsDir,
+          stdio: "pipe",
+          timeout: 12e4
+        });
+        test.status = "passed";
+        test.result = result.toString();
+      } else {
+        test.status = "passed";
+        test.result = "Test code generated (execution skipped - no test runner configured)";
+      }
+    } catch (e) {
+      test.status = "failed";
+      test.error = e instanceof Error ? e.message : String(e);
+    }
+    this.emit("test-completed", test);
+    return test;
+  }
+  async think() {
+    const recentTests = Array.from(this.generatedTests.values()).slice(-10);
+    const recentAgents = Array.from(this.dynamicAgents.values()).slice(-5);
+    const prompt = `You are OpenQA Brain, an autonomous QA system. Think about what to do next.
+
+## Application
+- **Name**: ${this.saasConfig.name}
+- **Description**: ${this.saasConfig.description}
+- **URL**: ${this.saasConfig.url}
+
+## User Directives
+${this.saasConfig.directives?.map((d) => `- ${d}`).join("\n") || "None"}
+
+## Recent Tests (${recentTests.length})
+${recentTests.map((t) => `- [${t.status}] ${t.type}: ${t.name}`).join("\n") || "None yet"}
+
+## Active Agents (${recentAgents.length})
+${recentAgents.map((a) => `- ${a.name}: ${a.purpose}`).join("\n") || "None yet"}
+
+## Your Task
+Decide what to do next. Consider:
+1. What areas haven't been tested yet?
+2. Are there any failed tests that need investigation?
+3. Should you create new specialized agents?
+4. What tests would be most valuable right now?
+
+Respond with JSON:
+{
+  "decision": "Brief explanation of your reasoning",
+  "actions": [
+    { "type": "generate_test", "target": "what to test", "reason": "why" },
+    { "type": "create_agent", "target": "agent purpose", "reason": "why" },
+    { "type": "run_test", "target": "test_id", "reason": "why" },
+    { "type": "analyze", "target": "what to analyze", "reason": "why" }
+  ]
+}`;
+    const response = await this.llm.generate(prompt);
+    try {
+      const jsonMatch = response.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        return JSON.parse(jsonMatch[0]);
+      }
+    } catch (e) {
+    }
+    return {
+      decision: response,
+      actions: []
+    };
+  }
+  async runAutonomously(maxIterations = 10) {
+    const log = logger.child({ app: this.saasConfig.name });
+    log.info("Brain starting autonomous mode", { maxIterations });
+    const analysis = await this.analyze();
+    log.info("Analysis complete", { suggestedTests: analysis.suggestedTests.length });
+    this.emit("analysis-complete", analysis);
+    for (let i = 0; i < maxIterations; i++) {
+      log.info("Iteration", { iteration: i + 1, maxIterations });
+      const thought = await this.think();
+      log.debug("Decision", { decision: thought.decision });
+      this.emit("thinking", thought);
+      for (const action of thought.actions) {
+        log.debug("Action", { type: action.type, target: action.target });
+        try {
+          switch (action.type) {
+            case "generate_test":
+              const testType = this.inferTestType(action.target);
+              await this.generateTest(testType, action.target, action.reason);
+              break;
+            case "create_agent":
+              await this.createDynamicAgent(action.target);
+              break;
+            case "run_test":
+              if (this.generatedTests.has(action.target)) {
+                await this.executeTest(action.target);
+              }
+              break;
+            case "analyze":
+              break;
+          }
+        } catch (e) {
+          log.error("Action failed", { type: action.type, error: e instanceof Error ? e.message : String(e) });
+        }
+      }
+      if (thought.actions.length === 0) {
+        log.info("No more actions needed");
+        break;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+    }
+    log.info("Autonomous session complete");
+    this.emit("session-complete", {
+      testsGenerated: this.generatedTests.size,
+      agentsCreated: this.dynamicAgents.size
+    });
+  }
+  inferTestType(target) {
+    const lower = target.toLowerCase();
+    if (lower.includes("security") || lower.includes("injection") || lower.includes("xss")) return "security";
+    if (lower.includes("performance") || lower.includes("load") || lower.includes("speed")) return "performance";
+    if (lower.includes("regression") || lower.includes("bug") || lower.includes("fix")) return "regression";
+    if (lower.includes("unit") || lower.includes("function") || lower.includes("component")) return "unit";
+    if (lower.includes("e2e") || lower.includes("journey") || lower.includes("flow")) return "e2e";
+    return "functional";
+  }
+  getGeneratedTests() {
+    return Array.from(this.generatedTests.values());
+  }
+  getDynamicAgents() {
+    return Array.from(this.dynamicAgents.values());
+  }
+  getStats() {
+    const tests = this.getGeneratedTests();
+    return {
+      totalTests: tests.length,
+      passed: tests.filter((t) => t.status === "passed").length,
+      failed: tests.filter((t) => t.status === "failed").length,
+      pending: tests.filter((t) => t.status === "pending").length,
+      agents: this.dynamicAgents.size,
+      byType: {
+        unit: tests.filter((t) => t.type === "unit").length,
+        functional: tests.filter((t) => t.type === "functional").length,
+        e2e: tests.filter((t) => t.type === "e2e").length,
+        regression: tests.filter((t) => t.type === "regression").length,
+        security: tests.filter((t) => t.type === "security").length,
+        performance: tests.filter((t) => t.type === "performance").length
+      }
+    };
+  }
+};
+
+// agent/tools/browser.ts
+init_esm_shims();
+import { chromium } from "playwright";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
+var BrowserTools = class {
+  browser = null;
+  page = null;
+  db;
+  sessionId;
+  screenshotDir = "./data/screenshots";
+  constructor(db, sessionId) {
+    this.db = db;
+    this.sessionId = sessionId;
+    mkdirSync3(this.screenshotDir, { recursive: true });
+  }
+  async initialize() {
+    this.browser = await chromium.launch({ headless: true });
+    const context = await this.browser.newContext({
+      viewport: { width: 1920, height: 1080 },
+      userAgent: "OpenQA/1.0 (Automated Testing Agent)"
+    });
+    this.page = await context.newPage();
+  }
+  getTools() {
+    return [
+      {
+        name: "navigate_to_page",
+        description: "Navigate to a specific URL in the application",
+        parameters: {
+          type: "object",
+          properties: {
+            url: { type: "string", description: "The URL to navigate to" }
+          },
+          required: ["url"]
+        },
+        execute: async ({ url }) => {
+          if (!this.page) await this.initialize();
+          try {
+            await this.page.goto(url, { waitUntil: "networkidle" });
+            const title = await this.page.title();
+            this.db.createAction({
+              session_id: this.sessionId,
+              type: "navigate",
+              description: `Navigated to ${url}`,
+              input: url,
+              output: `Page title: ${title}`
+            });
+            return `Successfully navigated to ${url}. Page title: "${title}"`;
+          } catch (error) {
+            return `Failed to navigate: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+      },
+      {
+        name: "click_element",
+        description: "Click on an element using a CSS selector",
+        parameters: {
+          type: "object",
+          properties: {
+            selector: { type: "string", description: "CSS selector of the element to click" }
+          },
+          required: ["selector"]
+        },
+        execute: async ({ selector }) => {
+          if (!this.page) return "Browser not initialized. Navigate to a page first.";
+          try {
+            await this.page.click(selector, { timeout: 5e3 });
+            this.db.createAction({
+              session_id: this.sessionId,
+              type: "click",
+              description: `Clicked element: ${selector}`,
+              input: selector
+            });
+            return `Successfully clicked element: ${selector}`;
+          } catch (error) {
+            return `Failed to click element: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+      },
+      {
+        name: "fill_input",
+        description: "Fill an input field with text",
+        parameters: {
+          type: "object",
+          properties: {
+            selector: { type: "string", description: "CSS selector of the input field" },
+            text: { type: "string", description: "Text to fill in the input" }
+          },
+          required: ["selector", "text"]
+        },
+        execute: async ({ selector, text }) => {
+          if (!this.page) return "Browser not initialized. Navigate to a page first.";
+          try {
+            await this.page.fill(selector, text);
+            this.db.createAction({
+              session_id: this.sessionId,
+              type: "fill",
+              description: `Filled input ${selector}`,
+              input: `${selector} = ${text}`
+            });
+            return `Successfully filled input ${selector} with text`;
+          } catch (error) {
+            return `Failed to fill input: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+      },
+      {
+        name: "take_screenshot",
+        description: "Take a screenshot of the current page for evidence",
+        parameters: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Name for the screenshot file" }
+          },
+          required: ["name"]
+        },
+        execute: async ({ name }) => {
+          if (!this.page) return "Browser not initialized. Navigate to a page first.";
+          try {
+            const filename = `${Date.now()}_${name}.png`;
+            const path2 = join4(this.screenshotDir, filename);
+            await this.page.screenshot({ path: path2, fullPage: true });
+            this.db.createAction({
+              session_id: this.sessionId,
+              type: "screenshot",
+              description: `Screenshot: ${name}`,
+              screenshot_path: path2
+            });
+            return `Screenshot saved: ${path2}`;
+          } catch (error) {
+            return `Failed to take screenshot: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+      },
+      {
+        name: "get_page_content",
+        description: "Get the text content of the current page",
+        parameters: {
+          type: "object",
+          properties: {}
+        },
+        execute: async () => {
+          if (!this.page) return "Browser not initialized. Navigate to a page first.";
+          try {
+            const content = await this.page.textContent("body");
+            return content?.slice(0, 1e3) || "No content found";
+          } catch (error) {
+            return `Failed to get content: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        }
+      },
+      {
+        name: "check_console_errors",
+        description: "Check for JavaScript console errors on the page",
+        parameters: {
+          type: "object",
+          properties: {}
+        },
+        execute: async () => {
+          if (!this.page) return "Browser not initialized. Navigate to a page first.";
+          const errors = [];
+          this.page.on("console", (msg) => {
+            if (msg.type() === "error") {
+              errors.push(msg.text());
+            }
+          });
+          await this.page.waitForTimeout(2e3);
+          if (errors.length > 0) {
+            return `Found ${errors.length} console errors:
+${errors.join("\n")}`;
+          }
+          return "No console errors detected";
+        }
+      }
+    ];
+  }
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.page = null;
+    }
+  }
+};
+
+// agent/webhooks/git-listener.ts
+init_esm_shims();
+import { EventEmitter as EventEmitter3 } from "events";
+import { Octokit } from "@octokit/rest";
+var GitListener = class extends EventEmitter3 {
+  config;
+  octokit = null;
+  lastCommitSha = null;
+  lastPipelineId = null;
+  pollInterval = null;
+  isRunning = false;
+  constructor(config) {
+    super();
+    this.config = {
+      branch: "main",
+      pollIntervalMs: 6e4,
+      gitlabUrl: "https://gitlab.com",
+      ...config
+    };
+    if (config.provider === "github" && config.token) {
+      this.octokit = new Octokit({ auth: config.token });
+    }
+  }
+  async start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    logger.info("GitListener started", { provider: this.config.provider, owner: this.config.owner, repo: this.config.repo });
+    await this.checkInitialState();
+    this.pollInterval = setInterval(() => {
+      this.poll().catch((e) => logger.error("Poll error", { error: e instanceof Error ? e.message : String(e) }));
+    }, this.config.pollIntervalMs);
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    logger.info("GitListener stopped");
+  }
+  async checkInitialState() {
+    try {
+      if (this.config.provider === "github") {
+        await this.checkGitHubState();
+      } else {
+        await this.checkGitLabState();
+      }
+    } catch (error) {
+      logger.error("Failed to check initial state", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  async poll() {
+    try {
+      if (this.config.provider === "github") {
+        await this.pollGitHub();
+      } else {
+        await this.pollGitLab();
+      }
+    } catch (error) {
+      logger.error("Poll error", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  async checkGitHubState() {
+    if (!this.octokit) return;
+    const { data: commits } = await this.octokit.repos.listCommits({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      sha: this.config.branch,
+      per_page: 1
+    });
+    if (commits.length > 0) {
+      this.lastCommitSha = commits[0].sha;
+    }
+    try {
+      const { data: runs } = await this.octokit.actions.listWorkflowRunsForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        branch: this.config.branch,
+        per_page: 1
+      });
+      if (runs.workflow_runs.length > 0) {
+        this.lastPipelineId = runs.workflow_runs[0].id.toString();
+      }
+    } catch {
+    }
+  }
+  async pollGitHub() {
+    if (!this.octokit) return;
+    const { data: commits } = await this.octokit.repos.listCommits({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      sha: this.config.branch,
+      per_page: 5
+    });
+    for (const commit of commits) {
+      if (this.lastCommitSha && commit.sha === this.lastCommitSha) break;
+      const isMerge = commit.parents && commit.parents.length > 1;
+      const event = {
+        type: isMerge ? "merge" : "push",
+        provider: "github",
+        branch: this.config.branch,
+        commit: commit.sha,
+        author: commit.commit.author?.name || "unknown",
+        message: commit.commit.message,
+        timestamp: new Date(commit.commit.author?.date || Date.now())
+      };
+      this.emit("git-event", event);
+      if (isMerge) {
+        this.emit("merge", event);
+        logger.info("Merge detected", { branch: this.config.branch, sha: commit.sha.slice(0, 7) });
+      }
+    }
+    if (commits.length > 0) {
+      this.lastCommitSha = commits[0].sha;
+    }
+    try {
+      const { data: runs } = await this.octokit.actions.listWorkflowRunsForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        branch: this.config.branch,
+        per_page: 5
+      });
+      for (const run of runs.workflow_runs) {
+        if (this.lastPipelineId && run.id.toString() === this.lastPipelineId) break;
+        if (run.status === "completed") {
+          const event = {
+            type: run.conclusion === "success" ? "pipeline_success" : "pipeline_failure",
+            provider: "github",
+            branch: this.config.branch,
+            commit: run.head_sha,
+            author: run.actor?.login || "unknown",
+            message: run.name || "",
+            timestamp: new Date(run.updated_at || Date.now()),
+            pipelineId: run.id.toString(),
+            pipelineStatus: run.conclusion || void 0
+          };
+          this.emit("git-event", event);
+          if (run.conclusion === "success") {
+            this.emit("pipeline-success", event);
+            logger.info("Pipeline success", { name: run.name, id: run.id });
+          } else {
+            this.emit("pipeline-failure", event);
+            logger.warn("Pipeline failure", { name: run.name, id: run.id });
+          }
+        }
+      }
+      if (runs.workflow_runs.length > 0) {
+        this.lastPipelineId = runs.workflow_runs[0].id.toString();
+      }
+    } catch {
+    }
+  }
+  async checkGitLabState() {
+    const headers = { "PRIVATE-TOKEN": this.config.token };
+    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
+    const baseUrl = this.config.gitlabUrl;
+    try {
+      const commitsRes = await fetch(
+        `${baseUrl}/api/v4/projects/${projectPath}/repository/commits?ref_name=${this.config.branch}&per_page=1`,
+        { headers }
+      );
+      const commits = await commitsRes.json();
+      if (commits.length > 0) {
+        this.lastCommitSha = commits[0].id;
+      }
+      const pipelinesRes = await fetch(
+        `${baseUrl}/api/v4/projects/${projectPath}/pipelines?ref=${this.config.branch}&per_page=1`,
+        { headers }
+      );
+      const pipelines = await pipelinesRes.json();
+      if (pipelines.length > 0) {
+        this.lastPipelineId = pipelines[0].id.toString();
+      }
+    } catch (error) {
+      logger.error("GitLab initial state error", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  async pollGitLab() {
+    const headers = { "PRIVATE-TOKEN": this.config.token };
+    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
+    const baseUrl = this.config.gitlabUrl;
+    try {
+      const commitsRes = await fetch(
+        `${baseUrl}/api/v4/projects/${projectPath}/repository/commits?ref_name=${this.config.branch}&per_page=5`,
+        { headers }
+      );
+      const commits = await commitsRes.json();
+      for (const commit of commits) {
+        if (this.lastCommitSha && commit.id === this.lastCommitSha) break;
+        const isMerge = commit.parent_ids && commit.parent_ids.length > 1;
+        const event = {
+          type: isMerge ? "merge" : "push",
+          provider: "gitlab",
+          branch: this.config.branch,
+          commit: commit.id,
+          author: commit.author_name,
+          message: commit.message,
+          timestamp: new Date(commit.created_at)
+        };
+        this.emit("git-event", event);
+        if (isMerge) {
+          this.emit("merge", event);
+          logger.info("Merge detected", { branch: this.config.branch, id: commit.id.slice(0, 7) });
+        }
+      }
+      if (commits.length > 0) {
+        this.lastCommitSha = commits[0].id;
+      }
+      const pipelinesRes = await fetch(
+        `${baseUrl}/api/v4/projects/${projectPath}/pipelines?ref=${this.config.branch}&per_page=5`,
+        { headers }
+      );
+      const pipelines = await pipelinesRes.json();
+      for (const pipeline of pipelines) {
+        if (this.lastPipelineId && pipeline.id.toString() === this.lastPipelineId) break;
+        if (pipeline.status === "success" || pipeline.status === "failed") {
+          const event = {
+            type: pipeline.status === "success" ? "pipeline_success" : "pipeline_failure",
+            provider: "gitlab",
+            branch: this.config.branch,
+            commit: pipeline.sha,
+            author: pipeline.user?.name || "unknown",
+            message: `Pipeline #${pipeline.id}`,
+            timestamp: new Date(pipeline.updated_at),
+            pipelineId: pipeline.id.toString(),
+            pipelineStatus: pipeline.status
+          };
+          this.emit("git-event", event);
+          if (pipeline.status === "success") {
+            this.emit("pipeline-success", event);
+            logger.info("Pipeline success", { id: pipeline.id });
+          } else {
+            this.emit("pipeline-failure", event);
+            logger.warn("Pipeline failure", { id: pipeline.id });
+          }
+        }
+      }
+      if (pipelines.length > 0) {
+        this.lastPipelineId = pipelines[0].id.toString();
+      }
+    } catch (error) {
+      logger.error("GitLab poll error", { error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  async setupWebhook(webhookUrl) {
+    if (this.config.provider === "github") {
+      return this.setupGitHubWebhook(webhookUrl);
+    } else {
+      return this.setupGitLabWebhook(webhookUrl);
+    }
+  }
+  async setupGitHubWebhook(webhookUrl) {
+    if (!this.octokit) throw new Error("GitHub not configured");
+    const { data } = await this.octokit.repos.createWebhook({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      config: {
+        url: webhookUrl,
+        content_type: "json"
+      },
+      events: ["push", "pull_request", "workflow_run"]
+    });
+    return data.id.toString();
+  }
+  async setupGitLabWebhook(webhookUrl) {
+    const headers = {
+      "PRIVATE-TOKEN": this.config.token,
+      "Content-Type": "application/json"
+    };
+    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
+    const res = await fetch(
+      `${this.config.gitlabUrl}/api/v4/projects/${projectPath}/hooks`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          url: webhookUrl,
+          push_events: true,
+          merge_requests_events: true,
+          pipeline_events: true
+        })
+      }
+    );
+    const data = await res.json();
+    return data.id.toString();
+  }
+};
+
+// agent/tools/project-runner.ts
+init_esm_shims();
+import { EventEmitter as EventEmitter4 } from "events";
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync4, statSync } from "fs";
+import { join as join5, resolve } from "path";
+function sanitizeRepoPath(inputPath) {
+  if (typeof inputPath !== "string" || !inputPath.trim()) {
+    throw new ProjectRunnerError("repoPath must be a non-empty string");
+  }
+  const resolved = resolve(inputPath);
+  try {
+    const stat = statSync(resolved);
+    if (!stat.isDirectory()) {
+      throw new ProjectRunnerError(`repoPath is not a directory: ${resolved}`);
+    }
+  } catch (err) {
+    if (err instanceof ProjectRunnerError) throw err;
+    throw new ProjectRunnerError(`repoPath does not exist: ${resolved}`);
+  }
+  return resolved;
+}
+var ProjectRunner = class extends EventEmitter4 {
+  serverProcess = null;
+  serverUrl = null;
+  installed = false;
+  projectType = null;
+  repoPath = null;
+  /**
+   * Detect what kind of project lives at the given path
+   */
+  detectProjectType(repoPath) {
+    repoPath = sanitizeRepoPath(repoPath);
+    const pkgPath = join5(repoPath, "package.json");
+    if (existsSync3(pkgPath)) {
+      return this.detectNodeProject(repoPath, pkgPath);
+    }
+    if (existsSync3(join5(repoPath, "requirements.txt")) || existsSync3(join5(repoPath, "pyproject.toml"))) {
+      return this.detectPythonProject(repoPath);
+    }
+    if (existsSync3(join5(repoPath, "go.mod"))) {
+      return {
+        language: "go",
+        packageManager: "go",
+        scripts: {},
+        testRunner: "go test",
+        devCommand: "go run ."
+      };
+    }
+    if (existsSync3(join5(repoPath, "Cargo.toml"))) {
+      return {
+        language: "rust",
+        packageManager: "cargo",
+        scripts: {},
+        testRunner: "cargo test",
+        devCommand: "cargo run"
+      };
+    }
+    return { language: "unknown", packageManager: "unknown", scripts: {} };
+  }
+  detectNodeProject(repoPath, pkgPath) {
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const scripts = pkg.scripts || {};
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    let packageManager = "npm";
+    if (existsSync3(join5(repoPath, "pnpm-lock.yaml"))) packageManager = "pnpm";
+    else if (existsSync3(join5(repoPath, "yarn.lock"))) packageManager = "yarn";
+    else if (existsSync3(join5(repoPath, "bun.lockb"))) packageManager = "bun";
+    let framework;
+    if (deps["next"]) framework = "next";
+    else if (deps["nuxt"]) framework = "nuxt";
+    else if (deps["@angular/core"]) framework = "angular";
+    else if (deps["svelte"] || deps["@sveltejs/kit"]) framework = "svelte";
+    else if (deps["vue"]) framework = "vue";
+    else if (deps["react"]) framework = "react";
+    else if (deps["express"]) framework = "express";
+    else if (deps["fastify"]) framework = "fastify";
+    else if (deps["@nestjs/core"]) framework = "nestjs";
+    let testRunner;
+    if (deps["vitest"]) testRunner = "vitest";
+    else if (deps["jest"]) testRunner = "jest";
+    else if (deps["mocha"]) testRunner = "mocha";
+    else if (deps["playwright"] || deps["@playwright/test"]) testRunner = "playwright";
+    else if (deps["cypress"]) testRunner = "cypress";
+    let devCommand;
+    if (scripts["dev"]) devCommand = `${packageManager} run dev`;
+    else if (scripts["start"]) devCommand = `${packageManager} run start`;
+    else if (scripts["serve"]) devCommand = `${packageManager} run serve`;
+    let buildCommand;
+    if (scripts["build"]) buildCommand = `${packageManager} run build`;
+    let port;
+    const devScript = scripts["dev"] || scripts["start"] || "";
+    const portMatch = devScript.match(/--port[= ](\d+)|-p[= ]?(\d+)/);
+    if (portMatch) {
+      port = parseInt(portMatch[1] || portMatch[2]);
+    } else if (framework === "next") {
+      port = 3e3;
+    } else if (framework === "nuxt" || framework === "vue") {
+      port = 3e3;
+    } else if (framework === "angular") {
+      port = 4200;
+    } else if (framework === "svelte") {
+      port = 5173;
+    } else if (framework === "react") {
+      port = 3e3;
+    }
+    return {
+      language: "node",
+      framework,
+      packageManager,
+      scripts,
+      testRunner,
+      devCommand,
+      buildCommand,
+      port
+    };
+  }
+  detectPythonProject(repoPath) {
+    let testRunner;
+    const reqPath = join5(repoPath, "requirements.txt");
+    if (existsSync3(reqPath)) {
+      const content = readFileSync4(reqPath, "utf-8");
+      if (content.includes("pytest")) testRunner = "pytest";
+    }
+    const pyprojectPath = join5(repoPath, "pyproject.toml");
+    if (existsSync3(pyprojectPath)) {
+      const content = readFileSync4(pyprojectPath, "utf-8");
+      if (content.includes("pytest")) testRunner = "pytest";
+    }
+    return {
+      language: "python",
+      packageManager: "pip",
+      scripts: {},
+      testRunner: testRunner || "pytest",
+      devCommand: "python -m flask run"
+    };
+  }
+  /**
+   * Install project dependencies
+   */
+  async installDependencies(repoPath) {
+    repoPath = sanitizeRepoPath(repoPath);
+    const projectType = this.detectProjectType(repoPath);
+    this.projectType = projectType;
+    this.repoPath = repoPath;
+    let command;
+    let args;
+    switch (projectType.packageManager) {
+      case "pnpm":
+        command = "pnpm";
+        args = ["install"];
+        break;
+      case "yarn":
+        command = "yarn";
+        args = ["install"];
+        break;
+      case "bun":
+        command = "bun";
+        args = ["install"];
+        break;
+      case "npm":
+        command = "npm";
+        args = ["install"];
+        break;
+      case "pip":
+        command = "pip";
+        args = ["install", "-r", "requirements.txt"];
+        break;
+      case "cargo":
+        command = "cargo";
+        args = ["build"];
+        break;
+      case "go":
+        command = "go";
+        args = ["mod", "download"];
+        break;
+      default:
+        throw new ProjectRunnerError(`Unknown package manager: ${projectType.packageManager}`);
+    }
+    this.emit("install-start", { command, packageManager: projectType.packageManager });
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(command, args, {
+        cwd: repoPath,
+        stdio: "pipe",
+        timeout: 3e5
+        // 5 min
+      });
+      let output = "";
+      proc.stdout?.on("data", (data) => {
+        const text = data.toString();
+        output += text;
+        this.emit("install-progress", { text });
+      });
+      proc.stderr?.on("data", (data) => {
+        const text = data.toString();
+        output += text;
+        this.emit("install-progress", { text });
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          this.installed = true;
+          this.emit("install-complete", { success: true });
+          resolve2();
+        } else {
+          const err = new ProjectRunnerError(
+            `Install failed (exit code ${code}): ${output.slice(-500)}`
+          );
+          this.emit("install-complete", { success: false, error: err.message });
+          reject(err);
+        }
+      });
+      proc.on("error", (err) => {
+        reject(new ProjectRunnerError(`Failed to spawn ${command}: ${err.message}`));
+      });
+    });
+  }
+  /**
+   * Start the project's dev server
+   */
+  async startDevServer(repoPath) {
+    repoPath = sanitizeRepoPath(repoPath);
+    const projectType = this.projectType || this.detectProjectType(repoPath);
+    this.repoPath = repoPath;
+    if (!projectType.devCommand) {
+      throw new ProjectRunnerError("No dev command detected for this project");
+    }
+    const [cmd, ...args] = projectType.devCommand.split(" ");
+    this.emit("server-starting", { command: projectType.devCommand });
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(cmd, args, {
+        cwd: repoPath,
+        stdio: "pipe",
+        detached: true
+      });
+      this.serverProcess = proc;
+      let resolved = false;
+      const readyPatterns = [
+        /ready on\s+(https?:\/\/\S+)/i,
+        /listening on\s+(https?:\/\/\S+)/i,
+        /started on\s+(https?:\/\/\S+)/i,
+        /Local:\s+(https?:\/\/\S+)/i,
+        /http:\/\/localhost:(\d+)/,
+        /http:\/\/127\.0\.0\.1:(\d+)/,
+        /http:\/\/0\.0\.0\.0:(\d+)/,
+        /ready in \d+/i,
+        /compiled successfully/i
+      ];
+      const checkOutput = (text) => {
+        if (resolved) return;
+        for (const pattern of readyPatterns) {
+          const match = text.match(pattern);
+          if (match) {
+            resolved = true;
+            let url;
+            if (match[1]?.startsWith("http")) {
+              url = match[1];
+            } else if (match[1]) {
+              url = `http://localhost:${match[1]}`;
+            } else if (projectType.port) {
+              url = `http://localhost:${projectType.port}`;
+            } else {
+              url = "http://localhost:3000";
+            }
+            this.serverUrl = url;
+            this.emit("server-ready", { url, pid: proc.pid });
+            resolve2({ url, pid: proc.pid });
+            return;
+          }
+        }
+      };
+      proc.stdout?.on("data", (data) => {
+        checkOutput(data.toString());
+      });
+      proc.stderr?.on("data", (data) => {
+        checkOutput(data.toString());
+      });
+      proc.on("error", (err) => {
+        if (!resolved) {
+          reject(new ProjectRunnerError(`Failed to start dev server: ${err.message}`));
+        }
+      });
+      proc.on("close", (code) => {
+        if (!resolved) {
+          reject(new ProjectRunnerError(`Dev server exited with code ${code}`));
+        }
+      });
+      setTimeout(async () => {
+        if (resolved) return;
+        const port = projectType.port || 3e3;
+        const candidatePorts = [port, 5173, 8080, 4200, 3001];
+        for (const p of candidatePorts) {
+          try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 2e3);
+            await fetch(`http://localhost:${p}`, { signal: controller.signal });
+            clearTimeout(timeoutId);
+            resolved = true;
+            const url = `http://localhost:${p}`;
+            this.serverUrl = url;
+            this.emit("server-ready", { url, pid: proc.pid });
+            resolve2({ url, pid: proc.pid });
+            return;
+          } catch {
+          }
+        }
+        reject(new ProjectRunnerError("Dev server did not become ready within 60s"));
+      }, 6e4);
+    });
+  }
+  /**
+   * Run the project's existing test suite
+   */
+  async runExistingTests(repoPath) {
+    repoPath = sanitizeRepoPath(repoPath);
+    const projectType = this.projectType || this.detectProjectType(repoPath);
+    if (!projectType.testRunner) {
+      throw new ProjectRunnerError("No test runner detected for this project");
+    }
+    let command;
+    let args;
+    switch (projectType.testRunner) {
+      case "vitest":
+        command = "npx";
+        args = ["vitest", "run", "--reporter=json"];
+        break;
+      case "jest":
+        command = "npx";
+        args = ["jest", "--json", "--forceExit"];
+        break;
+      case "mocha":
+        command = "npx";
+        args = ["mocha", "--reporter", "json"];
+        break;
+      case "playwright":
+        command = "npx";
+        args = ["playwright", "test", "--reporter=json"];
+        break;
+      case "pytest":
+        command = "python";
+        args = ["-m", "pytest", "--tb=short", "-q"];
+        break;
+      case "go test":
+        command = "go";
+        args = ["test", "-json", "./..."];
+        break;
+      case "cargo test":
+        command = "cargo";
+        args = ["test", "--", "--format=json"];
+        break;
+      default:
+        command = "npx";
+        args = [projectType.testRunner, "--json"];
+    }
+    this.emit("test-start", { runner: projectType.testRunner });
+    const startTime = Date.now();
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(command, args, {
+        cwd: repoPath,
+        stdio: "pipe",
+        timeout: 3e5
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+        this.emit("test-progress", { text: data.toString() });
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        const durationMs = Date.now() - startTime;
+        const raw = stdout + "\n" + stderr;
+        const result = this.parseTestResults(
+          projectType.testRunner,
+          stdout,
+          stderr,
+          durationMs
+        );
+        this.emit("test-complete", result);
+        resolve2(result);
+      });
+      proc.on("error", (err) => {
+        reject(new ProjectRunnerError(`Failed to run tests: ${err.message}`));
+      });
+    });
+  }
+  parseTestResults(runner, stdout, stderr, durationMs) {
+    const raw = stdout + "\n" + stderr;
+    if (runner === "vitest" || runner === "jest") {
+      try {
+        const jsonMatch = stdout.match(/\{[\s\S]*"numPassedTests"[\s\S]*\}/);
+        if (jsonMatch) {
+          const json = JSON.parse(jsonMatch[0]);
+          return {
+            runner,
+            passed: json.numPassedTests || 0,
+            failed: json.numFailedTests || 0,
+            skipped: json.numPendingTests || 0,
+            total: json.numTotalTests || 0,
+            durationMs,
+            raw
+          };
+        }
+      } catch {
+      }
+    }
+    let passed = 0, failed = 0, skipped = 0;
+    const summaryMatch = raw.match(/(\d+)\s*passed.*?(\d+)\s*failed/i);
+    if (summaryMatch) {
+      passed = parseInt(summaryMatch[1]);
+      failed = parseInt(summaryMatch[2]);
+    }
+    const passedMatch = raw.match(/(\d+)\s*pass(?:ed|ing)/i);
+    if (passedMatch && !summaryMatch) passed = parseInt(passedMatch[1]);
+    const failedMatch = raw.match(/(\d+)\s*fail(?:ed|ing|ure)/i);
+    if (failedMatch && !summaryMatch) failed = parseInt(failedMatch[1]);
+    const skippedMatch = raw.match(/(\d+)\s*(?:skip(?:ped)?|pending|todo)/i);
+    if (skippedMatch) skipped = parseInt(skippedMatch[1]);
+    return {
+      runner,
+      passed,
+      failed,
+      skipped,
+      total: passed + failed + skipped,
+      durationMs,
+      raw
+    };
+  }
+  /**
+   * Stop the dev server and clean up
+   */
+  cleanup() {
+    if (this.serverProcess) {
+      try {
+        if (this.serverProcess.pid) {
+          process.kill(-this.serverProcess.pid, "SIGTERM");
+        }
+      } catch {
+        try {
+          this.serverProcess.kill("SIGTERM");
+        } catch {
+        }
+      }
+      this.serverProcess = null;
+      this.serverUrl = null;
+      this.emit("server-stopped");
+    }
+  }
+  getStatus() {
+    return {
+      repoPath: this.repoPath || "",
+      projectType: this.projectType,
+      installed: this.installed,
+      serverRunning: this.serverProcess !== null && !this.serverProcess.killed,
+      serverUrl: this.serverUrl,
+      serverPid: this.serverProcess?.pid || null
+    };
+  }
+};
+
+// agent/notifications/index.ts
+init_esm_shims();
+var NotificationService = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async notify(payload) {
+    const promises = [];
+    if (this.config.slack) {
+      promises.push(this.sendSlack(payload));
+    }
+    if (this.config.discord) {
+      promises.push(this.sendDiscord(payload));
+    }
+    await Promise.allSettled(promises);
+  }
+  async notifyBug(bug) {
+    const severityEmoji = {
+      critical: "\u{1F534}",
+      high: "\u{1F7E0}",
+      medium: "\u{1F7E1}",
+      low: "\u{1F7E2}"
+    };
+    await this.notify({
+      title: `${severityEmoji[bug.severity] || "\u26A0\uFE0F"} Bug Found: ${bug.title}`,
+      message: bug.description,
+      severity: bug.severity === "critical" || bug.severity === "high" ? "error" : "warning",
+      fields: [
+        { name: "Severity", value: bug.severity },
+        { name: "Status", value: bug.status },
+        ...bug.github_issue_url ? [{ name: "GitHub Issue", value: bug.github_issue_url }] : []
+      ]
+    });
+  }
+  async notifySessionComplete(stats) {
+    await this.notify({
+      title: "\u2705 OpenQA Session Complete",
+      message: `Session ${stats.sessionId} finished.`,
+      severity: "success",
+      fields: [
+        { name: "Tests Generated", value: String(stats.testsGenerated) },
+        { name: "Agents Created", value: String(stats.agentsCreated) }
+      ]
+    });
+  }
+  async sendSlack(payload) {
+    const colorMap = {
+      info: "#36a64f",
+      warning: "#ff9800",
+      error: "#dc3545",
+      success: "#28a745"
+    };
+    const color = colorMap[payload.severity || "info"];
+    const body = {
+      attachments: [{
+        color,
+        title: payload.title,
+        text: payload.message,
+        fields: payload.fields?.map((f) => ({ title: f.name, value: f.value, short: true })) || [],
+        footer: "OpenQA",
+        ts: Math.floor(Date.now() / 1e3)
+      }]
+    };
+    const res = await fetch(this.config.slack, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Slack notification failed: ${res.status} ${res.statusText}`);
+    }
+  }
+  async sendDiscord(payload) {
+    const colorMap = {
+      info: 3581519,
+      warning: 16750592,
+      error: 14431557,
+      success: 2664261
+    };
+    const color = colorMap[payload.severity || "info"];
+    const body = {
+      embeds: [{
+        title: payload.title,
+        description: payload.message,
+        color,
+        fields: payload.fields?.map((f) => ({ name: f.name, value: f.value, inline: true })) || [],
+        footer: { text: "OpenQA" },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }]
+    };
+    const res = await fetch(this.config.discord, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Discord notification failed: ${res.status} ${res.statusText}`);
+    }
+  }
+  isConfigured() {
+    return !!(this.config.slack || this.config.discord);
+  }
+};
+
+// agent/index-v2.ts
+var OpenQAAgentV2 = class extends EventEmitter5 {
+  db;
+  config;
+  saasConfigManager;
+  brain = null;
+  browserTools = null;
+  gitListener = null;
+  projectRunner;
+  notifications = null;
+  sessionId = "";
+  isRunning = false;
+  constructor(configPath) {
+    super();
+    this.config = new ConfigManager(configPath);
+    const cfg = this.config.getConfigSync();
+    this.db = new OpenQADatabase(cfg.database?.path || void 0);
+    this.saasConfigManager = new SaaSConfigManager(this.db);
+    this.projectRunner = new ProjectRunner();
+    for (const event of ["install-start", "install-progress", "install-complete", "server-starting", "server-ready", "server-stopped", "test-start", "test-progress", "test-complete"]) {
+      this.projectRunner.on(event, (data) => this.emit(event, data));
+    }
+  }
+  /**
+   * Configure the SaaS application to test
+   * This is the main entry point for users
+   */
+  configureSaaS(config) {
+    const saasConfig = {
+      name: config.name,
+      description: config.description,
+      url: config.url,
+      repoUrl: config.repoUrl,
+      localPath: config.localPath,
+      directives: config.directives,
+      authInfo: config.auth ? {
+        type: config.auth.type,
+        testCredentials: config.auth.credentials
+      } : { type: "none" }
+    };
+    return this.saasConfigManager.configure(saasConfig);
+  }
+  /**
+   * Quick setup with minimal configuration
+   */
+  quickSetup(name, description, url) {
+    return this.saasConfigManager.configure(
+      createQuickConfig(name, description, url)
+    );
+  }
+  /**
+   * Add a directive (instruction for the agent)
+   */
+  addDirective(directive) {
+    this.saasConfigManager.addDirective(directive);
+  }
+  /**
+   * Set repository URL for code analysis
+   */
+  setRepository(url) {
+    this.saasConfigManager.setRepoUrl(url);
+  }
+  /**
+   * Set local path for code analysis
+   */
+  setLocalPath(path2) {
+    this.saasConfigManager.setLocalPath(path2);
+  }
+  /**
+   * Initialize the brain and start analyzing
+   */
+  async initialize() {
+    const saasConfig = this.saasConfigManager.getConfig();
+    if (!saasConfig) {
+      throw new Error("SaaS not configured. Call configureSaaS() first.");
+    }
+    const cfg = await this.config.getConfig();
+    this.sessionId = `session_${Date.now()}`;
+    await this.db.createSession(this.sessionId, {
+      saas: saasConfig,
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (cfg.notifications?.slack || cfg.notifications?.discord) {
+      this.notifications = new NotificationService({
+        slack: cfg.notifications.slack,
+        discord: cfg.notifications.discord
+      });
+    }
+    this.brain = new OpenQABrain(
+      this.db,
+      {
+        provider: cfg.llm.provider,
+        apiKey: cfg.llm.apiKey || process.env.OPENAI_API_KEY || "",
+        model: cfg.llm.model
+      },
+      saasConfig
+    );
+    this.browserTools = new BrowserTools(this.db, this.sessionId);
+    const log = logger.child({ session: this.sessionId, app: saasConfig.name });
+    this.brain.on("test-generated", (test) => {
+      this.emit("test-generated", test);
+      log.info("Test generated", { name: test.name, type: test.type });
+    });
+    this.brain.on("agent-created", (agent) => {
+      this.emit("agent-created", agent);
+      log.info("Agent created", { name: agent.name });
+    });
+    this.brain.on("test-started", (test) => {
+      this.emit("test-started", test);
+    });
+    this.brain.on("test-completed", (test) => {
+      this.emit("test-completed", test);
+      log.info("Test completed", { name: test.name, status: test.status });
+    });
+    this.brain.on("thinking", (thought) => {
+      this.emit("thinking", thought);
+    });
+    this.brain.on("analysis-complete", (analysis) => {
+      this.emit("analysis-complete", analysis);
+    });
+    this.brain.on("session-complete", (stats) => {
+      this.emit("session-complete", stats);
+      if (this.notifications) {
+        this.notifications.notifySessionComplete({
+          sessionId: this.sessionId,
+          testsGenerated: Number(stats.testsGenerated ?? 0),
+          agentsCreated: Number(stats.agentsCreated ?? 0)
+        }).catch((e) => log.error("Notification failed", { error: e instanceof Error ? e.message : String(e) }));
+      }
+    });
+    log.info("OpenQA initialized", {
+      url: saasConfig.url,
+      repoUrl: saasConfig.repoUrl,
+      localPath: saasConfig.localPath,
+      directives: saasConfig.directives?.length ?? 0
+    });
+  }
+  /**
+   * Run the brain in autonomous mode
+   * The agent will analyze, think, generate tests, and execute them
+   */
+  async runAutonomous(maxIterations = 10) {
+    if (!this.brain) {
+      await this.initialize();
+    }
+    this.isRunning = true;
+    logger.info("Starting autonomous QA session", { session: this.sessionId });
+    await this.brain.runAutonomously(maxIterations);
+    this.isRunning = false;
+  }
+  /**
+   * Analyze the application and get suggestions
+   */
+  async analyze() {
+    if (!this.brain) {
+      await this.initialize();
+    }
+    return this.brain.analyze();
+  }
+  /**
+   * Generate a specific test
+   */
+  async generateTest(type, target, context) {
+    if (!this.brain) {
+      await this.initialize();
+    }
+    return this.brain.generateTest(type, target, context);
+  }
+  /**
+   * Create a custom agent for a specific purpose
+   */
+  async createAgent(purpose) {
+    if (!this.brain) {
+      await this.initialize();
+    }
+    return this.brain.createDynamicAgent(purpose);
+  }
+  /**
+   * Execute a generated test
+   */
+  async runTest(testId) {
+    if (!this.brain) {
+      throw new Error("Brain not initialized");
+    }
+    return this.brain.executeTest(testId);
+  }
+  /**
+   * Start listening for Git events (merges, pipelines)
+   */
+  async startGitListener() {
+    const cfg = await this.config.getConfig();
+    const saasConfig = this.saasConfigManager.getConfig();
+    if (cfg.github?.token && cfg.github?.owner && cfg.github?.repo) {
+      this.gitListener = new GitListener({
+        provider: "github",
+        token: cfg.github.token,
+        owner: cfg.github.owner,
+        repo: cfg.github.repo,
+        branch: "main",
+        pollIntervalMs: 6e4
+      });
+      this.gitListener.on("merge", async (event) => {
+        logger.info("Merge detected", { branch: event.branch });
+        this.emit("git-merge", event);
+        await this.runAutonomous();
+      });
+      this.gitListener.on("pipeline-success", async (event) => {
+        logger.info("Pipeline success");
+        this.emit("git-pipeline-success", event);
+        await this.runAutonomous();
+      });
+      await this.gitListener.start();
+      logger.info("Git listener started");
+    }
+  }
+  /**
+   * Setup a project: detect, install deps, optionally start dev server
+   */
+  async setupProject(repoPath, options) {
+    const projectType = this.projectRunner.detectProjectType(repoPath);
+    logger.info("Project detected", { language: projectType.language, framework: projectType.framework, packageManager: projectType.packageManager });
+    await this.projectRunner.installDependencies(repoPath);
+    logger.info("Dependencies installed");
+    if (options?.startServer && projectType.devCommand) {
+      const { url } = await this.projectRunner.startDevServer(repoPath);
+      logger.info("Dev server ready", { url });
+    }
+    return this.projectRunner.getStatus();
+  }
+  /**
+   * Run the project's existing test suite
+   */
+  async runProjectTests(repoPath) {
+    return this.projectRunner.runExistingTests(repoPath);
+  }
+  /**
+   * Get project runner status
+   */
+  getProjectStatus() {
+    return this.projectRunner.getStatus();
+  }
+  /**
+   * Stop the agent
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.gitListener) {
+      this.gitListener.stop();
+      this.gitListener = null;
+    }
+    if (this.browserTools) {
+      this.browserTools.close();
+    }
+    this.projectRunner.cleanup();
+    logger.info("OpenQA stopped");
+  }
+  /**
+   * Get all generated tests
+   */
+  getTests() {
+    return this.brain?.getGeneratedTests() || [];
+  }
+  /**
+   * Get all created agents
+   */
+  getAgents() {
+    return this.brain?.getDynamicAgents() || [];
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      isRunning: this.isRunning,
+      sessionId: this.sessionId,
+      saas: this.saasConfigManager.getConfig(),
+      brain: this.brain?.getStats() || null,
+      gitListenerActive: !!this.gitListener
+    };
+  }
+  /**
+   * Get the SaaS configuration
+   */
+  getSaaSConfig() {
+    return this.saasConfigManager.getConfig();
+  }
+  /**
+   * Check if configured
+   */
+  isConfigured() {
+    return this.saasConfigManager.isConfigured();
+  }
+};
+export {
+  OpenQAAgentV2
+};
+//# sourceMappingURL=index-v2.js.map