@brainforge/core 3.1.12 → 3.1.13

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { EventEmitter } from 'events';
 type ProjectType = 'student' | 'junior' | 'solo' | 'personal' | 'pro';
 type StudentLevel = 'beginner' | 'intermediate' | 'advanced' | 'professional';
 type Language = 'typescript' | 'javascript' | 'python' | 'java' | 'go' | 'php' | 'rust' | 'csharp' | 'ruby';
-type PhaseStatus = 'pending' | 'active' | 'completed' | 'blocked' | 'draft' | 'discussed' | 'planned' | 'checked' | 'executing' | 'executed' | 'verified' | 'failed' | 'fixed' | 'shipped';
+type PhaseStatus = 'pending' | 'active' | 'completed' | 'blocked' | 'draft' | 'discussed' | 'planned' | 'checked' | 'executing' | 'executed' | 'verified' | 'failed' | 'fixed' | 'shipped' | 'needs-manual-verification';
 type TaskStatus = 'todo' | 'in-progress' | 'done' | 'skipped';
 type TaskPriority = 'low' | 'medium' | 'high' | 'critical';
 type TaskType = 'backend' | 'frontend' | 'database' | 'devops' | 'security' | 'test' | 'docs' | 'general';
@@ -750,6 +750,14 @@ interface BugEntry {
     taskId?: string;
     description?: string;
 }
+interface CommandResult {
+    command: string;
+    status: 'passed' | 'failed';
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    duration: number;
+}
 interface VerifyResult {
     phaseId: string;
     phaseName: string;
@@ -758,11 +766,13 @@ interface VerifyResult {
     passed: number;
     bugs: BugEntry[];
     blocked: boolean;
+    commandResults?: CommandResult[];
 }
 declare class VerificationEngine {
     detectAvailableCommands(cwd: string): Promise<string[]>;
+    runCommands(commands: string[], cwd: string): Promise<CommandResult[]>;
     buildVerifyPrompt(phase: Phase, stack?: StackInfo, detectedCommands?: string[]): string;
-    buildVerifyMd(phase: Phase, bugs?: BugEntry[]): string;
+    buildVerifyMd(phase: Phase, commandResults?: CommandResult[], bugs?: BugEntry[]): string;
     buildBugsMd(bugs: BugEntry[]): string;
 }
 

package/dist/index.js

@@ -604,16 +604,20 @@ Identify:
 Ensure every acceptance criterion is covered.`,
   fix_phase: `You are BrainForge AI. Generate a fix plan for phase "{{phase.name}}".
 
-Bugs/Failures: {{failures}}
-Original Plan: {{plan}}
+# Verification Results
+{{failures}}
 
-Analyze:
-- Root cause hypotheses
-- Files to inspect
-- Proposed correction steps
-- Commands to re-run
+# Original Plan Context
+{{plan}}
 
-Produce a FIX_PLAN.md.`,
+# Analysis Requirements
+1. Identify the failed commands and their error outputs.
+2. Formulate root cause hypotheses for each failure.
+3. List specific files to inspect and potential logical bugs.
+4. Propose step-by-step correction instructions for an AI agent.
+5. Identify the exact verification commands to re-run after fixes.
+
+Produce a FIX_PLAN.md that is honest: it guides the fix, it doesn't pretend to have fixed it automatically.`,
   ship_phase: `You are BrainForge AI. Generate a final ship report for phase "{{phase.name}}".
 
 Completed Tasks: {{tasks}}
@@ -7362,6 +7366,9 @@ ${cmd}
 // src/workflow/verification-engine.ts
 import fs23 from "fs/promises";
 import path25 from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
 var VerificationEngine = class {
   async detectAvailableCommands(cwd) {
     const commands = [];
@@ -7370,10 +7377,15 @@ var VerificationEngine = class {
       const raw = await fs23.readFile(pkgPath, "utf-8");
       const pkg = JSON.parse(raw);
       const scripts = pkg.scripts || {};
-      if (scripts.build) commands.push("npm run build");
-      if (scripts.test) commands.push("npm test");
-      if (scripts.lint) commands.push("npm run lint");
-      if (scripts.typecheck) commands.push("npm run typecheck");
+      const hasYarn = await fs23.access(path25.join(cwd, "yarn.lock")).then(() => true).catch(() => false);
+      const hasPnpm = await fs23.access(path25.join(cwd, "pnpm-lock.yaml")).then(() => true).catch(() => false);
+      const hasBun = await fs23.access(path25.join(cwd, "bun.lockb")).then(() => true).catch(() => false);
+      const manager = hasBun ? "bun" : hasPnpm ? "pnpm" : hasYarn ? "yarn" : "npm";
+      const run = manager === "npm" || manager === "bun" ? `${manager} run` : manager;
+      if (scripts.build) commands.push(`${run} build`);
+      if (scripts.test) commands.push(`${manager} test`);
+      if (scripts.lint) commands.push(`${run} lint`);
+      if (scripts.typecheck) commands.push(`${run} typecheck`);
     } catch {
     }
     try {
@@ -7393,11 +7405,48 @@ var VerificationEngine = class {
     }
     try {
       await fs23.access(path25.join(cwd, "build.gradle"));
-      commands.push("gradle test");
+      commands.push("./gradlew test");
+    } catch {
+    }
+    try {
+      await fs23.access(path25.join(cwd, "go.mod"));
+      commands.push("go test ./...");
+    } catch {
+    }
+    try {
+      await fs23.access(path25.join(cwd, "Cargo.toml"));
+      commands.push("cargo test");
     } catch {
     }
     return commands;
   }
+  async runCommands(commands, cwd) {
+    const results = [];
+    for (const command of commands) {
+      const start = Date.now();
+      try {
+        const { stdout, stderr } = await execAsync2(command, { cwd });
+        results.push({
+          command,
+          status: "passed",
+          exitCode: 0,
+          stdout,
+          stderr,
+          duration: Date.now() - start
+        });
+      } catch (err) {
+        results.push({
+          command,
+          status: "failed",
+          exitCode: err.code || 1,
+          stdout: err.stdout || "",
+          stderr: err.stderr || err.message,
+          duration: Date.now() - start
+        });
+      }
+    }
+    return results;
+  }
   buildVerifyPrompt(phase, stack, detectedCommands = []) {
     const allCriteria = [];
     for (const t of phase.tasks) {
@@ -7447,23 +7496,53 @@ ${cmd}
     lines.push("*Generated by BrainForge AI \u2014 paste into your AI tool to verify the phase.*");
     return lines.join("\n");
   }
-  buildVerifyMd(phase, bugs = []) {
+  buildVerifyMd(phase, commandResults = [], bugs = []) {
     const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-    const criticalBugs = bugs.filter((b) => b.severity === "critical");
-    const blocked = criticalBugs.length > 0;
+    let status = "passed";
+    if (commandResults.length === 0) {
+      status = "manual-required";
+    } else if (commandResults.some((r) => r.status === "failed") || bugs.some((b) => b.severity === "critical")) {
+      status = "failed";
+    }
+    const passedCount = commandResults.filter((r) => r.status === "passed").length;
+    const totalDuration = commandResults.reduce((acc, r) => acc + r.duration, 0);
     const lines = [
-      `# Verification Report \u2014 ${phase.name}`,
-      `> Generated: ${now} UTC`,
-      `> Status: ${blocked ? "\u{1F534} BLOCKED" : bugs.length > 0 ? "\u{1F7E1} ISSUES FOUND" : "\u{1F7E2} VERIFIED"}`,
+      `# Verify Report: ${phase.name}`,
+      "",
+      "## Summary",
+      "",
+      `- **Status:** ${status.toUpperCase()}`,
+      `- **Date:** ${now} UTC`,
+      `- **Duration:** ${(totalDuration / 1e3).toFixed(2)}s`,
+      `- **Commands run:** ${commandResults.length}`,
+      `- **Commands passed:** ${passedCount}`,
+      `- **Commands failed:** ${commandResults.length - passedCount}`,
       "",
-      "## Tasks"
+      "## Commands",
+      ""
     ];
-    for (const t of phase.tasks) {
-      const icon = t.status === "done" ? "\u2713" : "\u25CB";
-      lines.push(`- [${icon}] ${t.title}`);
+    for (const r of commandResults) {
+      lines.push(
+        `### \`${r.command}\``,
+        "",
+        `- **Status:** ${r.status === "passed" ? "\u{1F7E2} PASSED" : "\u{1F534} FAILED"}`,
+        `- **Exit code:** ${r.exitCode}`,
+        `- **Duration:** ${(r.duration / 1e3).toFixed(2)}s`,
+        "",
+        "#### stdout",
+        "```txt",
+        r.stdout || "(empty)",
+        "```",
+        "",
+        "#### stderr",
+        "```txt",
+        r.stderr || "(empty)",
+        "```",
+        ""
+      );
     }
     if (bugs.length > 0) {
-      lines.push("", "## Bugs Found");
+      lines.push("## Findings", "");
       for (const bug of bugs) {
         lines.push(`### ${bug.id}: ${bug.title}`);
         lines.push(`**Severity:** ${bug.severity}`);
@@ -7472,13 +7551,17 @@ ${cmd}
         lines.push("");
       }
     }
-    if (!blocked) {
-      lines.push("", "## Next step");
-      lines.push("Run `brg ship` to close this phase and update project memory.");
-    } else {
-      lines.push("", "## Next step");
-      lines.push("Fix critical bugs then re-run `brg verify` before shipping.");
-    }
+    lines.push(
+      "## Diagnosis",
+      "",
+      status === "passed" ? "* All automated checks passed. Ready to ship." : status === "manual-required" ? "* No automated commands detected. Manual verification is required." : "* Automated checks failed. Review stderr above for root causes.",
+      "* Files likely involved: " + (phase.tasks.flatMap((t) => t.files || []).join(", ") || "N/A"),
+      "",
+      "## Final decision",
+      "",
+      `Phase status changed to: **${status === "passed" ? "verified" : status === "failed" ? "failed" : "needs-manual-verification"}**`,
+      ""
+    );
     return lines.join("\n");
   }
   buildBugsMd(bugs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainforge/core",
-  "version": "3.1.12",
+  "version": "3.1.13",
   "description": "Core engine for BrainForge AI — state management, AST mapper, skills, and AI adapters",
   "type": "module",
   "license": "MIT",