wolverine-ai 1.0.0

package/src/agent/goal-loop.js

@@ -0,0 +1,140 @@
+const chalk = require("chalk");
+const { verifyFix } = require("../core/verifier");
+
+/**
+ * Goal Loop — claw-code run_turn_loop pattern.
+ *
+ * Instead of: try fast → try agent → give up
+ * Now:        set goal → attempt → verify → learn → retry with new context
+ *
+ * The loop:
+ *   1. Set goal (e.g. "server starts without error X")
+ *   2. Check brain for past attempts on this goal
+ *   3. Attempt a fix (strategy chosen by iteration)
+ *   4. Verify: did we meet the goal?
+ *   5. Yes → record success, exit
+ *   6. No  → record failure, research if needed, loop with new context
+ *
+ * Each iteration gets smarter because failures feed into the next attempt's context.
+ */
+
+class GoalLoop {
+  constructor(options = {}) {
+    this.maxIterations = options.maxIterations || 3;
+    this.researcher = options.researcher;
+    this.logger = options.logger;
+    this.onAttempt = options.onAttempt; // async (iteration, context) => { healed, explanation }
+    this.onVerify = options.onVerify;   // async () => { verified, status }
+    this.goal = options.goal || "Fix the error";
+
+    this._attempts = [];
+  }
+
+  /**
+   * Run the goal loop. Returns the final result.
+   */
+  async run({ errorMessage, filePath, cwd }) {
+    console.log(chalk.magenta(`\n  🎯 Goal: ${this.goal}`));
+    console.log(chalk.gray(`     Max iterations: ${this.maxIterations}\n`));
+
+    if (this.logger) {
+      this.logger.info("goal.start", `Goal: ${this.goal}`, { maxIterations: this.maxIterations, error: errorMessage?.slice(0, 100) });
+    }
+
+    for (let i = 0; i < this.maxIterations; i++) {
+      const iteration = i + 1;
+      console.log(chalk.blue(`  ── Iteration ${iteration}/${this.maxIterations} ──`));
+
+      // Build context from past attempts
+      let context = "";
+      if (this.researcher) {
+        context = await this.researcher.buildFixContext(errorMessage);
+      }
+      if (this._attempts.length > 0) {
+        context += "\n\n## This Session's Attempts";
+        for (const a of this._attempts) {
+          context += `\nAttempt ${a.iteration}: ${a.success ? "SUCCESS" : "FAILED"} — ${a.explanation}`;
+        }
+      }
+
+      // Attempt the fix
+      let attempt;
+      try {
+        attempt = await this.onAttempt(iteration, context);
+      } catch (err) {
+        attempt = { healed: false, explanation: `Error: ${err.message}` };
+      }
+
+      this._attempts.push({
+        iteration,
+        success: attempt.healed,
+        explanation: attempt.explanation || "No explanation",
+      });
+
+      if (attempt.healed) {
+        // Goal met!
+        console.log(chalk.green(`  ✅ Goal achieved on iteration ${iteration}`));
+
+        if (this.researcher) {
+          await this.researcher.recordAttempt({
+            errorMessage, filePath,
+            success: true,
+            explanation: attempt.explanation,
+          }).catch(() => {});
+        }
+
+        if (this.logger) {
+          this.logger.info("goal.success", `Goal achieved: ${this.goal}`, { iteration, explanation: attempt.explanation });
+        }
+
+        return {
+          success: true,
+          iteration,
+          explanation: attempt.explanation,
+          attempts: this._attempts,
+          ...attempt,
+        };
+      }
+
+      // Record failure
+      console.log(chalk.yellow(`  ↩️ Iteration ${iteration} failed: ${attempt.explanation?.slice(0, 80)}`));
+
+      if (this.researcher) {
+        await this.researcher.recordAttempt({
+          errorMessage, filePath,
+          success: false,
+          explanation: attempt.explanation,
+        }).catch(() => {});
+
+        // Deep research after 2nd failure — bring in RESEARCH_MODEL
+        if (iteration >= 2) {
+          console.log(chalk.magenta(`  🔬 Triggering deep research after ${iteration} failures...`));
+          const research = await this.researcher.research(errorMessage, context);
+          if (research) {
+            console.log(chalk.gray(`  🔬 Research insight: ${research.slice(0, 100)}`));
+          }
+        }
+      }
+
+      if (this.logger) {
+        this.logger.warn("goal.attempt_failed", `Iteration ${iteration} failed`, { iteration, explanation: attempt.explanation });
+      }
+    }
+
+    // All iterations exhausted
+    console.log(chalk.red(`  🛑 Goal not achieved after ${this.maxIterations} iterations`));
+
+    if (this.logger) {
+      this.logger.error("goal.failed", `Goal failed: ${this.goal}`, { attempts: this._attempts.length });
+    }
+
+    return {
+      success: false,
+      iteration: this.maxIterations,
+      explanation: `Failed after ${this.maxIterations} iterations`,
+      attempts: this._attempts,
+    };
+  }
+}
+
+module.exports = { GoalLoop };

package/src/agent/research-agent.js

@@ -0,0 +1,120 @@
+const chalk = require("chalk");
+const { aiCall } = require("../core/ai-client");
+const { getModel } = require("../core/models");
+
+/**
+ * Research Agent — deep research + learning from experience.
+ *
+ * Uses RESEARCH_MODEL for deep analysis of errors and solutions.
+ * Stores everything in the brain so wolverine gets smarter over time.
+ *
+ * Loop prevention:
+ * - Before fixing, checks brain for past attempts on the same error
+ * - If past fix failed, provides that context so agent tries something different
+ * - Stores both successes AND failures
+ */
+
+class ResearchAgent {
+  constructor(options = {}) {
+    this.brain = options.brain;
+    this.logger = options.logger;
+    this.redactor = options.redactor;
+  }
+
+  /**
+   * Check if we've seen this error before. Returns past attempts.
+   */
+  async checkHistory(errorMessage) {
+    if (!this.brain || !this.brain._initialized) return null;
+
+    const fixes = await this.brain.recall(errorMessage, { topK: 3, namespace: "fixes" });
+    const errors = await this.brain.recall(errorMessage, { topK: 3, namespace: "errors" });
+    const learnings = await this.brain.recall(errorMessage, { topK: 2, namespace: "learnings" });
+
+    const total = fixes.length + errors.length + learnings.length;
+    if (total === 0) return null;
+
+    console.log(chalk.gray(`  🔍 Research: ${fixes.length} past fixes, ${errors.length} past errors, ${learnings.length} learnings`));
+
+    return {
+      hasPastAttempts: true,
+      fixes: fixes.map(r => r.text),
+      errors: errors.map(r => r.text),
+      learnings: learnings.map(r => r.text),
+    };
+  }
+
+  /**
+   * Record a fix attempt (success or failure).
+   */
+  async recordAttempt({ errorMessage, filePath, fix, success, explanation }) {
+    if (!this.brain || !this.brain._initialized) return;
+
+    const safeError = this.redactor ? this.redactor.redact(errorMessage) : errorMessage;
+    const safeExplanation = this.redactor ? this.redactor.redact(explanation || fix || "") : (explanation || fix || "");
+
+    const namespace = success ? "fixes" : "errors";
+    const prefix = success ? "FIXED" : "FAILED";
+    const text = `${prefix}: ${safeError} in ${filePath}. ${success ? "Solution" : "Attempted"}: ${safeExplanation}`;
+
+    await this.brain.remember(namespace, text, { type: success ? "fix-success" : "fix-failure", file: filePath });
+    console.log(chalk.gray(`  🧠 ${success ? "✅" : "❌"} Recorded ${prefix.toLowerCase()} for ${safeError.slice(0, 50)}`));
+  }
+
+  /**
+   * Deep research using RESEARCH_MODEL. Called when normal fixes fail.
+   * Stores findings in brain for future reference.
+   */
+  async research(errorMessage, context) {
+    const safeError = this.redactor ? this.redactor.redact(errorMessage) : errorMessage;
+
+    console.log(chalk.magenta(`  🔬 Deep research (${getModel("research")})...`));
+
+    try {
+      const result = await aiCall({
+        model: getModel("research"),
+        systemPrompt: "You are a Node.js debugging researcher. Given an error and context of failed fix attempts, research the root cause deeply and provide a specific, actionable solution. Include exact code changes. If the previous fix attempts failed, explain WHY they failed and what to do differently.",
+        userPrompt: `Error: ${safeError}\n\n${context || "No previous attempts."}`,
+        maxTokens: 1024,
+        category: "research",
+      });
+
+      const findings = result.content || "";
+
+      // Store research in brain
+      if (this.brain && this.brain._initialized && findings.length > 20) {
+        await this.brain.remember("learnings", `Research for "${safeError.slice(0, 60)}": ${findings.slice(0, 500)}`, { type: "deep-research" });
+        this.brain.store.save();
+      }
+
+      const tokens = (result.usage?.prompt_tokens || result.usage?.input_tokens || 0)
+        + (result.usage?.completion_tokens || result.usage?.output_tokens || 0);
+      console.log(chalk.magenta(`  🔬 Research complete (${tokens} tokens)`));
+
+      return findings;
+    } catch (err) {
+      console.log(chalk.yellow(`  Research failed: ${err.message}`));
+      return null;
+    }
+  }
+
+  /**
+   * Build full context for the agent — past attempts + research.
+   */
+  async buildFixContext(errorMessage) {
+    const parts = [];
+
+    const history = await this.checkHistory(errorMessage);
+    if (history && history.hasPastAttempts) {
+      parts.push("## Past Attempts (from brain)");
+      if (history.fixes.length > 0) parts.push("Successful fixes for similar errors:\n" + history.fixes.join("\n"));
+      if (history.errors.length > 0) parts.push("Failed attempts (DO NOT repeat these):\n" + history.errors.join("\n"));
+      if (history.learnings.length > 0) parts.push("Research findings:\n" + history.learnings.join("\n"));
+      parts.push("\nIMPORTANT: Use a DIFFERENT approach from any failed attempts listed above.");
+    }
+
+    return parts.join("\n");
+  }
+}
+
+module.exports = { ResearchAgent };

package/src/agent/sub-agents.js

@@ -0,0 +1,176 @@
+const chalk = require("chalk");
+const { AgentEngine } = require("./agent-engine");
+const { getModel } = require("../core/models");
+
+/**
+ * Sub-Agent System — spawn specialized agents for divide-and-conquer.
+ *
+ * claw-code pattern:
+ * - Parent agent identifies sub-tasks
+ * - Each sub-agent gets: restricted tools, specific model, focused prompt
+ * - Sub-agents run in parallel (Promise.all)
+ * - Results aggregated back to parent
+ *
+ * Built-in agent types:
+ * - explore:  Read-only. Investigates codebase, finds relevant files.
+ * - plan:     Read-only. Analyzes problem, proposes a fix strategy.
+ * - fix:      Read+write. Applies a specific, targeted fix.
+ * - verify:   Read-only. Checks if a fix actually works.
+ * - research: Read-only. Searches brain + web for solutions.
+ * - security: Read-only. Audits code for vulnerabilities.
+ * - database: Read+write. Handles database-related fixes (uses SQL skill).
+ */
+
+// Tool restrictions per agent type (claw-code: allowed_tools_for_subagent)
+const AGENT_TOOL_SETS = {
+  explore: ["read_file", "glob_files", "grep_code", "git_log", "git_diff", "done"],
+  plan: ["read_file", "glob_files", "grep_code", "search_brain", "done"],
+  fix: ["read_file", "write_file", "edit_file", "glob_files", "grep_code", "done"],
+  verify: ["read_file", "glob_files", "grep_code", "bash_exec", "done"],
+  research: ["read_file", "grep_code", "web_fetch", "search_brain", "done"],
+  security: ["read_file", "glob_files", "grep_code", "done"],
+  database: ["read_file", "write_file", "edit_file", "glob_files", "grep_code", "bash_exec", "done"],
+};
+
+// Default model + budget per agent type
+const AGENT_CONFIGS = {
+  explore:  { model: "reasoning", maxTurns: 5,  maxTokens: 10000 },
+  plan:     { model: "reasoning", maxTurns: 3,  maxTokens: 8000 },
+  fix:      { model: "coding",   maxTurns: 5,  maxTokens: 15000 },
+  verify:   { model: "reasoning", maxTurns: 3,  maxTokens: 5000 },
+  research: { model: "research",  maxTurns: 3,  maxTokens: 10000 },
+  security: { model: "audit",     maxTurns: 3,  maxTokens: 8000 },
+  database: { model: "coding",   maxTurns: 5,  maxTokens: 15000 },
+};
+
+// System prompts per agent type
+const AGENT_PROMPTS = {
+  explore: "You are an Explorer agent. Your job is to investigate the codebase and find files relevant to the problem. Read files, search for patterns, check git history. Report what you found — do NOT make changes.",
+  plan: "You are a Planner agent. Your job is to analyze the problem and propose a fix strategy. Read the relevant files, understand the root cause, and describe step-by-step what needs to change. Do NOT make changes.",
+  fix: "You are a Fixer agent. You receive a specific fix plan. Execute it precisely — edit only the files mentioned, make only the changes described. Use edit_file for surgical changes.",
+  verify: "You are a Verifier agent. Check if a fix actually works. Read the modified files, look for issues, run tests if available. Report whether the fix is correct.",
+  research: "You are a Research agent. Search the brain for past fixes to similar errors, and search the web for solutions. Report your findings.",
+  security: "You are a Security agent. Audit the code for vulnerabilities: SQL injection, XSS, path traversal, hardcoded secrets, missing input validation. Report all findings.",
+  database: "You are a Database agent. Handle database-related issues: schema problems, query errors, connection failures, migration issues. You have access to the SQL skill.",
+};
+
+/**
+ * Spawn a single sub-agent.
+ *
+ * @param {string} type — agent type (explore, plan, fix, verify, research, security, database)
+ * @param {string} task — what this agent should do
+ * @param {object} options — { sandbox, logger, cwd, mcp, brainContext }
+ * @returns {{ success, summary, filesModified, turnCount, totalTokens, type }}
+ */
+async function spawnAgent(type, task, options = {}) {
+  const config = AGENT_CONFIGS[type] || AGENT_CONFIGS.explore;
+  const allowedTools = AGENT_TOOL_SETS[type] || AGENT_TOOL_SETS.explore;
+  const systemPrompt = AGENT_PROMPTS[type] || AGENT_PROMPTS.explore;
+
+  console.log(chalk.magenta(`  🤖 [${type}] Spawning sub-agent (${getModel(config.model)}, ${config.maxTurns} turns)`));
+
+  if (options.logger) {
+    options.logger.info("agent.spawn", `Sub-agent [${type}]: ${task.slice(0, 80)}`, {
+      type, model: getModel(config.model), maxTurns: config.maxTurns,
+    });
+  }
+
+  const agent = new AgentEngine({
+    sandbox: options.sandbox,
+    logger: options.logger,
+    cwd: options.cwd || process.cwd(),
+    mcp: options.mcp,
+    maxTurns: config.maxTurns,
+    maxTokens: config.maxTokens,
+  });
+
+  // Override the system prompt for this agent type
+  const result = await agent.run({
+    errorMessage: task,
+    stackTrace: "",
+    primaryFile: "N/A",
+    sourceCode: `// Sub-agent type: ${type}\n// ${systemPrompt}`,
+    brainContext: options.brainContext || "",
+  });
+
+  console.log(chalk.magenta(`  🤖 [${type}] ${result.success ? "✅" : "❌"} ${(result.summary || "").slice(0, 80)}`));
+
+  return {
+    ...result,
+    type,
+    model: getModel(config.model),
+  };
+}
+
+/**
+ * Spawn multiple sub-agents in parallel.
+ *
+ * @param {Array<{ type, task }>} agents — agents to spawn
+ * @param {object} options — shared options for all agents
+ * @returns {Array} — results from all agents
+ */
+async function spawnParallel(agents, options = {}) {
+  console.log(chalk.magenta(`\n  🤖 Spawning ${agents.length} sub-agents in parallel...`));
+
+  if (options.logger) {
+    options.logger.info("agent.spawn_parallel", `Spawning ${agents.length} sub-agents`, {
+      agents: agents.map(a => a.type),
+    });
+  }
+
+  const promises = agents.map(({ type, task }) =>
+    spawnAgent(type, task, options).catch(err => ({
+      success: false,
+      summary: `[${type}] Error: ${err.message}`,
+      filesModified: [],
+      turnCount: 0,
+      totalTokens: 0,
+      type,
+    }))
+  );
+
+  const results = await Promise.all(promises);
+
+  const totalTokens = results.reduce((sum, r) => sum + (r.totalTokens || 0), 0);
+  const successes = results.filter(r => r.success).length;
+
+  console.log(chalk.magenta(`  🤖 Parallel complete: ${successes}/${results.length} succeeded, ${totalTokens} tokens total`));
+
+  return results;
+}
+
+/**
+ * Common workflow: explore → plan → fix → verify
+ * Used by the goal loop for complex repairs.
+ */
+async function exploreAndFix(task, options = {}) {
+  // Step 1: Explore — find relevant files
+  const exploration = await spawnAgent("explore", `Investigate: ${task}`, options);
+
+  // Step 2: Plan — propose a fix using exploration results
+  const planTask = `Based on exploration:\n${exploration.summary}\n\nPlan a fix for: ${task}`;
+  const plan = await spawnAgent("plan", planTask, options);
+
+  // Step 3: Fix — execute the plan
+  const fixTask = `Execute this fix plan:\n${plan.summary}\n\nOriginal problem: ${task}`;
+  const fix = await spawnAgent("fix", fixTask, options);
+
+  return {
+    exploration,
+    plan,
+    fix,
+    success: fix.success,
+    summary: fix.summary,
+    filesModified: fix.filesModified || [],
+    totalTokens: (exploration.totalTokens || 0) + (plan.totalTokens || 0) + (fix.totalTokens || 0),
+  };
+}
+
+module.exports = {
+  spawnAgent,
+  spawnParallel,
+  exploreAndFix,
+  AGENT_TOOL_SETS,
+  AGENT_CONFIGS,
+  AGENT_PROMPTS,
+};