@brainforge/core 3.1.11 → 3.1.13

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { EventEmitter } from 'events';
 
 type ProjectType = 'student' | 'junior' | 'solo' | 'personal' | 'pro';
-type StudentLevel = 'beginner' | 'intermediate' | 'advanced';
+type StudentLevel = 'beginner' | 'intermediate' | 'advanced' | 'professional';
 type Language = 'typescript' | 'javascript' | 'python' | 'java' | 'go' | 'php' | 'rust' | 'csharp' | 'ruby';
-type PhaseStatus = 'pending' | 'active' | 'completed' | 'blocked';
+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';
@@ -130,7 +130,7 @@ interface BrainForgeConfig {
     };
     student: {
         enabled: boolean;
-        level: 'beginner' | 'intermediate' | 'advanced';
+        level: 'beginner' | 'intermediate' | 'advanced' | 'professional';
         professorMode: boolean;
     };
     safety: {
@@ -152,8 +152,12 @@ declare class StateManager {
     private statePath;
     private state;
     constructor(workingDir: string);
+    getPhaseDir(phaseId: string): string;
+    ensurePhaseDir(phaseId: string): Promise<void>;
+    writePhaseFile(phaseId: string, filename: string, content: string): Promise<void>;
+    readPhaseFile(phaseId: string, filename: string): Promise<string>;
     load(): Promise<BrainforgeState>;
-    save(): Promise<void>;
+    save(newState?: BrainforgeState): Promise<void>;
     init(project: ProjectConfig): Promise<BrainforgeState>;
     loadWorkspaceConfig(): Promise<BrainForgeConfig>;
     saveWorkspaceConfig(config: BrainForgeConfig): Promise<void>;
@@ -352,6 +356,7 @@ interface ScanReport {
     studentLevel: StudentLevel;
     totalFilesScanned: number;
     matches: PatternMatch[];
+    aiAnalysis?: string;
     summary: {
         errors: number;
         warnings: number;
@@ -361,7 +366,7 @@ interface ScanReport {
 declare class ProfessorScanner {
     private readonly workingDir;
     constructor(workingDir: string);
-    scan(language: Language, studentLevel: StudentLevel): Promise<ScanReport>;
+    scan(language: Language, studentLevel: StudentLevel, useAI?: boolean): Promise<ScanReport>;
     private findFiles;
     private walk;
     private writeReport;
@@ -745,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;
@@ -753,10 +766,13 @@ interface VerifyResult {
     passed: number;
     bugs: BugEntry[];
     blocked: boolean;
+    commandResults?: CommandResult[];
 }
 declare class VerificationEngine {
-    buildVerifyPrompt(phase: Phase, stack?: StackInfo): string;
-    buildVerifyMd(phase: Phase, bugs?: BugEntry[]): string;
+    detectAvailableCommands(cwd: string): Promise<string[]>;
+    runCommands(commands: string[], cwd: string): Promise<CommandResult[]>;
+    buildVerifyPrompt(phase: Phase, stack?: StackInfo, detectedCommands?: string[]): string;
+    buildVerifyMd(phase: Phase, commandResults?: CommandResult[], bugs?: BugEntry[]): string;
     buildBugsMd(bugs: BugEntry[]): string;
 }
 

package/dist/index.js

@@ -166,6 +166,7 @@ async function fileExists(p) {
 // src/state/manager.ts
 var STATE_DIR = ".brainforge";
 var STATE_FILE = "core.json";
+var PHASES_DIR = "phases";
 var StateManager = class {
   constructor(workingDir) {
     this.workingDir = workingDir;
@@ -174,12 +175,27 @@ var StateManager = class {
   workingDir;
   statePath;
   state = null;
+  getPhaseDir(phaseId) {
+    return path3.join(this.workingDir, STATE_DIR, PHASES_DIR, phaseId);
+  }
+  async ensurePhaseDir(phaseId) {
+    const dir = this.getPhaseDir(phaseId);
+    await fs3.mkdir(dir, { recursive: true });
+  }
+  async writePhaseFile(phaseId, filename, content) {
+    await this.ensurePhaseDir(phaseId);
+    await fs3.writeFile(path3.join(this.getPhaseDir(phaseId), filename), content, "utf-8");
+  }
+  async readPhaseFile(phaseId, filename) {
+    return fs3.readFile(path3.join(this.getPhaseDir(phaseId), filename), "utf-8");
+  }
   async load() {
     const raw = await fs3.readFile(this.statePath, "utf-8");
     this.state = JSON.parse(raw);
     return this.state;
   }
-  async save() {
+  async save(newState) {
+    if (newState) this.state = newState;
     if (!this.state) throw new Error("No state loaded \u2014 call init() or load() first.");
     this.state.metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     await fs3.mkdir(path3.dirname(this.statePath), { recursive: true });
@@ -267,7 +283,10 @@ var StateManager = class {
   }
   async writeProjectMd() {
     const s = this.state;
-    const phaseLines = s.phases.length ? s.phases.map((p) => `- [${p.status === "completed" ? "x" : " "}] **${p.name}** \u2014 ${p.description}`) : ["- No phases yet. Run `brainforge plan` to create one."];
+    const phaseLines = s.phases.length ? s.phases.map((p) => {
+      const active = p.id === s.activePhaseId ? " \u25C0 ACTIVE" : "";
+      return `- [${p.status === "shipped" || p.status === "completed" ? "x" : " "}] **${p.name}** \`${p.status}\`${active} \u2014 ${p.description}`;
+    }) : ["- No phases yet. Run `brg phase create` or `brg plan` to add one."];
     const content = [
       `# ${s.project.name}`,
       "",
@@ -279,6 +298,11 @@ var StateManager = class {
       "",
       ...phaseLines,
       "",
+      "## Quick Commands",
+      "- `brg next` \u2014 See what to do next",
+      "- `brg phase list` \u2014 List all phases",
+      "- `brg serve --open` \u2014 Open the live dashboard",
+      "",
       `---`,
       `*Generated by BrainForge AI v3 \u2014 ${s.metadata.updatedAt}*`
     ].join("\n");
@@ -291,20 +315,25 @@ var StateManager = class {
     const doneTasks = s.phases.reduce((n, p) => n + p.tasks.filter((t) => t.status === "done").length, 0);
     const phaseBlocks = s.phases.map((p) => {
       const done = p.tasks.filter((t) => t.status === "done").length;
-      return `### ${p.name} \`${p.status}\`
+      const statusIcon = p.status === "shipped" ? "\u{1F7E2}" : p.status === "failed" ? "\u{1F534}" : "\u{1F7E1}";
+      return `### ${statusIcon} ${p.name} \`${p.status}\`
 ${p.description}
-Tasks: ${done}/${p.tasks.length}`;
+Tasks: ${done}/${p.tasks.length}
+Artifacts: \`.brainforge/phases/${p.id}/\``;
     });
     const content = [
       "# Project State",
       "",
       `**Last Updated:** ${s.metadata.updatedAt}`,
-      `**Active Phase:** ${active ? active.name : "None"}`,
+      `**Active Phase:** ${active ? `"${active.name}" (${active.status})` : "None"}`,
       `**Progress:** ${doneTasks}/${totalTasks} tasks complete`,
       "",
-      "## Phases",
+      "## Phase Summary",
       "",
-      phaseBlocks.length ? phaseBlocks.join("\n\n") : "No phases yet."
+      phaseBlocks.length ? phaseBlocks.join("\n\n") : "No phases yet.",
+      "",
+      "---",
+      `*BrainForge AI Internal State*`
     ].join("\n");
     await fs3.writeFile(path3.join(this.workingDir, "STATE.md"), content, "utf-8");
   }
@@ -515,11 +544,106 @@ var BUILTIN_TEMPLATES = {
 
 Project: {{project.description}}
 Language: {{project.language}}{{#if project.framework}} / {{project.framework}}{{/if}}
-{{#if project.studentLevel}}Student Level: {{project.studentLevel}}{{/if}}
+{{#if project.studentLevel}}Level: {{project.studentLevel}}{{/if}}
 
 The developer wants to discuss: {{topic}}
 
 Provide structured, actionable guidance appropriate for their level. Be concise but thorough.`,
+  discuss_phase: `You are BrainForge AI. Help a {{project.type}} developer discuss phase "{{phase.name}}" for project "{{project.name}}".
+
+Phase Goal: {{phase.description}}
+Project Level: {{project.studentLevel}}
+
+Help the user clarify:
+- Technical constraints
+- Expected functionality
+- Affected files/modules
+- Risks and acceptance criteria
+- Expected code quality ({{project.studentLevel}})
+
+Ensure the discussion covers everything needed for a solid implementation plan.`,
+  plan_phase: `You are BrainForge AI. Generate an implementation plan for phase "{{phase.name}}" of "{{project.name}}".
+
+Phase Goal: {{phase.description}}
+Discussion Context: {{discussion}}
+Level: {{project.studentLevel}}
+
+Generate:
+1. A detailed PLAN.md overview
+2. A TASKS.json with small, atomic, verifiable tasks
+3. Files to create/modify
+4. Risk assessment per task
+
+The tasks MUST respect the {{project.studentLevel}} level:
+- beginner: simple code, few abstractions, pedagogic comments.
+- intermediate: clean architecture, services/controllers, basic validation.
+- professional: robust architecture, strict validation, full error handling, security.`,
+  check_plan: `You are BrainForge AI. Review the implementation plan for phase "{{phase.name}}".
+
+Plan: {{plan}}
+Level: {{project.studentLevel}}
+
+Check for:
+- Tasks too large or ambiguous
+- Missing acceptance criteria
+- Inconsistencies with the current codebase architecture
+- If the level ({{project.studentLevel}}) is respected
+- Missing test/verification commands
+
+Produce a PLAN_REVIEW.md report.`,
+  verify_phase: `You are BrainForge AI. Generate a verification checklist for phase "{{phase.name}}".
+
+Tasks: {{tasks}}
+Bugs Found: {{bugs}}
+
+Identify:
+- Automated tests to run (build, test, lint)
+- Manual verification steps
+- Edge cases to check
+
+Ensure every acceptance criterion is covered.`,
+  fix_phase: `You are BrainForge AI. Generate a fix plan for phase "{{phase.name}}".
+
+# Verification Results
+{{failures}}
+
+# Original Plan Context
+{{plan}}
+
+# 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}}
+Verification Status: {{status}}
+
+Summarize:
+- Key features implemented
+- Architecture decisions made
+- Remaining technical debt
+- Recommended next phase
+
+Produce a SHIP.md.`,
+  professor_review: `You are a Professor AI. Review these advanced patterns found in a {{level}} student's {{language}} project.
+
+Matches:
+{{#each matches}}
+- {{name}} in {{file}} (line {{line}}): "{{snippet}}"
+{{/each}}
+
+For each pattern:
+1. Explain it simply as if to a student.
+2. Provide a simpler alternative if applicable.
+3. Suggest 1-2 tricky questions a professor might ask about this.
+4. Provide the expected technical answer.
+
+Identify if the overall code level feels like beginner, intermediate, or professional based on these patterns.`,
   plan: `You are BrainForge AI. Analyze the following task for project "{{project.name}}":
 
 Task: {{task.title}}
@@ -1216,7 +1340,7 @@ var ProfessorScanner = class {
     this.workingDir = workingDir;
   }
   workingDir;
-  async scan(language, studentLevel) {
+  async scan(language, studentLevel, useAI = false) {
     const applicable = PATTERNS.filter(
       (p) => p.languages.includes(language) && p.flagForLevels.includes(studentLevel)
     );
@@ -1245,6 +1369,19 @@ var ProfessorScanner = class {
         pattern.regex.lastIndex = 0;
       }
     }
+    let aiAnalysis;
+    if (useAI && matches.length > 0) {
+      try {
+        const engine = new PromptEngine();
+        aiAnalysis = engine.render("professor_review", {
+          language,
+          level: studentLevel,
+          matches,
+          count: matches.length
+        });
+      } catch {
+      }
+    }
     const errors = matches.filter((m) => m.severity === "error").length;
     const warnings = matches.filter((m) => m.severity === "warn").length;
     const report = {
@@ -1253,6 +1390,7 @@ var ProfessorScanner = class {
       studentLevel,
       totalFilesScanned: files.length,
       matches,
+      aiAnalysis,
       summary: { errors, warnings, clean: matches.length === 0 }
     };
     await this.writeReport(report);
@@ -1294,7 +1432,10 @@ var ProfessorScanner = class {
     if (report.summary.clean) {
       lines.push("No advanced patterns detected. Your code matches your declared level.");
     } else {
-      lines.push("## Findings", "");
+      if (report.aiAnalysis) {
+        lines.push("## AI Analysis & Coaching", "", report.aiAnalysis, "");
+      }
+      lines.push("## Detailed Findings", "");
       for (const m of report.matches) {
         const icon = m.severity === "error" ? "[ERROR]" : "[WARN]";
         lines.push(
@@ -7223,9 +7364,90 @@ ${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 {
-  buildVerifyPrompt(phase, stack) {
-    const tasksWithCriteria = phase.tasks.filter((t) => t.acceptanceCriteria?.length);
+  async detectAvailableCommands(cwd) {
+    const commands = [];
+    try {
+      const pkgPath = path25.join(cwd, "package.json");
+      const raw = await fs23.readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const scripts = pkg.scripts || {};
+      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 {
+      await fs23.access(path25.join(cwd, "pytest.ini"));
+      commands.push("pytest");
+    } catch {
+      try {
+        await fs23.access(path25.join(cwd, "conftest.py"));
+        commands.push("pytest");
+      } catch {
+      }
+    }
+    try {
+      await fs23.access(path25.join(cwd, "pom.xml"));
+      commands.push("mvn test");
+    } catch {
+    }
+    try {
+      await fs23.access(path25.join(cwd, "build.gradle"));
+      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) {
       for (const c of t.acceptanceCriteria ?? []) {
@@ -7252,56 +7474,75 @@ var VerificationEngine = class {
     }
     lines.push("");
     lines.push("## Verification commands to run");
-    const cmds = phase.tasks.flatMap((t) => t.verificationCommands ?? []);
-    if (cmds.length > 0) {
-      for (const cmd of [...new Set(cmds)]) {
+    const taskCmds = phase.tasks.flatMap((t) => t.verificationCommands ?? []);
+    const uniqueCmds = [.../* @__PURE__ */ new Set([...detectedCommands, ...taskCmds])];
+    if (uniqueCmds.length > 0) {
+      for (const cmd of uniqueCmds) {
         lines.push(`\`\`\`bash
 ${cmd}
 \`\`\``);
       }
     } else {
-      lines.push("_(No verification commands defined \u2014 run your test suite manually.)_");
-      if (stack?.runtime === "node" || stack?.runtime === "bun") {
-        lines.push("```bash\nnpm test\n```");
-      }
+      lines.push("_(No verification commands detected \u2014 run your test suite manually.)_");
     }
     lines.push("");
     lines.push("## Instructions for your AI tool");
     lines.push("1. Run all verification commands. Report pass/fail for each.");
-    lines.push('2. For each checklist item, confirm it is truly done \u2014 not just "the code exists".');
-    lines.push("3. List any bugs found using the format below:");
-    lines.push("");
-    lines.push("```");
-    lines.push("BUG: [title]");
-    lines.push("Severity: critical | major | minor");
-    lines.push("Task: [task name]");
-    lines.push("Description: [what is wrong]");
-    lines.push("```");
-    lines.push("");
-    lines.push("4. If there are **critical** bugs, do NOT mark the phase as verified.");
-    lines.push('5. If all criteria pass, confirm with: "PHASE VERIFIED \u2713"');
+    lines.push("2. For each checklist item, confirm it is truly done.");
+    lines.push("3. List any bugs found with severity (critical | major | minor).");
+    lines.push("4. Produce a VERIFY.md with the results.");
     lines.push("");
     lines.push("---");
     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}`,
       "",
-      "## Tasks"
+      "## 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}`,
+      "",
+      "## 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}`);
@@ -7310,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) {
@@ -7724,12 +7969,12 @@ var AutoEngine = class {
 };
 
 // src/scanner/codebase-map.ts
-import fs27 from "fs/promises";
-import path30 from "path";
+import fs28 from "fs/promises";
+import path31 from "path";
 
 // src/scanner/stack-detector.ts
-import fs23 from "fs/promises";
-import path25 from "path";
+import fs24 from "fs/promises";
+import path26 from "path";
 var FRAMEWORK_MARKERS = {
   "next": ["next"],
   "nuxt": ["nuxt"],
@@ -7802,7 +8047,7 @@ async function detectStack(cwd) {
   let hasRuby = false;
   let runtime;
   try {
-    const raw = await fs23.readFile(path25.join(cwd, "package.json"), "utf-8");
+    const raw = await fs24.readFile(path26.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     Object.assign(allDeps, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
     if (pkg.engines?.["bun"]) runtime = "bun";
@@ -7921,7 +8166,7 @@ async function detectStack(cwd) {
 }
 async function fileExists4(cwd, ...parts) {
   try {
-    await fs23.access(path25.join(cwd, ...parts));
+    await fs24.access(path26.join(cwd, ...parts));
     return true;
   } catch {
     return false;
@@ -7929,8 +8174,8 @@ async function fileExists4(cwd, ...parts) {
 }
 
 // src/scanner/dependency-analyzer.ts
-import fs24 from "fs/promises";
-import path26 from "path";
+import fs25 from "fs/promises";
+import path27 from "path";
 async function analyzeDependencies(cwd) {
   const handlers = [
     () => parseNodePackage(cwd),
@@ -7947,7 +8192,7 @@ async function analyzeDependencies(cwd) {
 }
 async function parseNodePackage(cwd) {
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "package.json"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const runtime = Object.entries(pkg.dependencies ?? {}).map(([name, version]) => ({
       name,
@@ -7972,7 +8217,7 @@ async function parseNodePackage(cwd) {
 }
 async function parsePythonRequirements(cwd) {
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "pyproject.toml"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "pyproject.toml"), "utf-8");
     const deps = [];
     const depSection = raw.match(/\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/);
     if (depSection?.[1]) {
@@ -7990,7 +8235,7 @@ async function parsePythonRequirements(cwd) {
   } catch {
   }
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "requirements.txt"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "requirements.txt"), "utf-8");
     const deps = raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("-")).map((l) => {
       const m = l.match(/^([a-zA-Z0-9_.-]+)([>=<!].+)?$/);
       return m ? { name: m[1], version: m[2] ?? "*", dev: false } : null;
@@ -8004,7 +8249,7 @@ async function parsePythonRequirements(cwd) {
 }
 async function parseGoMod(cwd) {
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "go.mod"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "go.mod"), "utf-8");
     const deps = [];
     for (const line of raw.split("\n")) {
       const m = line.trim().match(/^([a-zA-Z0-9_./-]+)\s+(v[\d.]+.*)$/);
@@ -8017,7 +8262,7 @@ async function parseGoMod(cwd) {
 }
 async function parseCargoToml(cwd) {
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "Cargo.toml"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "Cargo.toml"), "utf-8");
     const deps = [];
     let inDeps = false;
     let inDevDeps = false;
@@ -8048,7 +8293,7 @@ async function parseCargoToml(cwd) {
 }
 async function parseComposerJson(cwd) {
   try {
-    const raw = await fs24.readFile(path26.join(cwd, "composer.json"), "utf-8");
+    const raw = await fs25.readFile(path27.join(cwd, "composer.json"), "utf-8");
     const pkg = JSON.parse(raw);
     const runtime = Object.entries(pkg.require ?? {}).filter(([name]) => name !== "php").map(([name, version]) => ({ name, version, dev: false }));
     const dev = Object.entries(pkg["require-dev"] ?? {}).map(([name, version]) => ({
@@ -8109,8 +8354,8 @@ function pickHighlights(deps) {
 }
 
 // src/scanner/convention-detector.ts
-import fs25 from "fs/promises";
-import path27 from "path";
+import fs26 from "fs/promises";
+import path28 from "path";
 async function detectConventions(cwd, files) {
   const srcFiles = files.filter((f) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f));
   const namingStyle = detectNamingStyle(srcFiles);
@@ -8135,7 +8380,7 @@ async function detectConventions(cwd, files) {
   };
 }
 function detectNamingStyle(files) {
-  const basenames = files.map((f) => path27.basename(f, path27.extname(f))).filter((b) => b.length > 2 && !/^index$|^main$|^app$/.test(b));
+  const basenames = files.map((f) => path28.basename(f, path28.extname(f))).filter((b) => b.length > 2 && !/^index$|^main$|^app$/.test(b));
   const counts = { camel: 0, snake: 0, kebab: 0, pascal: 0 };
   for (const b of basenames) {
     if (/^[A-Z][a-zA-Z0-9]*$/.test(b)) counts.pascal++;
@@ -8170,7 +8415,7 @@ function detectFolderPattern(files) {
 }
 async function detectModuleStyle(cwd) {
   try {
-    const raw = await fs25.readFile(path27.join(cwd, "package.json"), "utf-8");
+    const raw = await fs26.readFile(path28.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
     if (pkg.type === "module") return "esm";
     if (pkg.type === "commonjs") return "cjs";
@@ -8181,7 +8426,7 @@ async function detectModuleStyle(cwd) {
 }
 async function detectTsStrict(cwd) {
   try {
-    const raw = await fs25.readFile(path27.join(cwd, "tsconfig.json"), "utf-8");
+    const raw = await fs26.readFile(path28.join(cwd, "tsconfig.json"), "utf-8");
     const stripped = raw.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
     const tsconfig = JSON.parse(stripped);
     return tsconfig.compilerOptions?.strict === true;
@@ -8210,7 +8455,7 @@ function detectEntryPoint(files) {
 }
 async function fileExists5(cwd, ...parts) {
   try {
-    await fs25.access(path27.join(cwd, ...parts));
+    await fs26.access(path28.join(cwd, ...parts));
     return true;
   } catch {
     return false;
@@ -8218,8 +8463,8 @@ async function fileExists5(cwd, ...parts) {
 }
 
 // src/scanner/risk-detector.ts
-import fs26 from "fs/promises";
-import path28 from "path";
+import fs27 from "fs/promises";
+import path29 from "path";
 var LARGE_FILE_THRESHOLD = 500;
 var HUGE_FILE_THRESHOLD = 1e3;
 var SECRET_PATTERNS = [
@@ -8255,7 +8500,7 @@ async function detectRisks(cwd, files, fileContents) {
     }
   }
   for (const f of files) {
-    const basename = path28.basename(f);
+    const basename = path29.basename(f);
     if (SECRET_PATTERNS.some((p) => p.test(basename)) && !basename.endsWith(".example")) {
       items.push({
         level: "high",
@@ -8292,7 +8537,7 @@ async function detectRisks(cwd, files, fileContents) {
   } else if (todoCount > 5) {
     items.push({ level: "low", category: "quality", message: `${todoCount} TODO/FIXME/HACK comments found` });
   }
-  if (!files.some((f) => path28.basename(f) === ".gitignore")) {
+  if (!files.some((f) => path29.basename(f) === ".gitignore")) {
     items.push({ level: "medium", category: "hygiene", message: "No .gitignore found" });
   }
   const hasTestFiles = files.some(
@@ -8301,12 +8546,12 @@ async function detectRisks(cwd, files, fileContents) {
   if (!hasTestFiles) {
     items.push({ level: "high", category: "quality", message: "No test files detected" });
   }
-  if (!files.some((f) => /^readme\.md$/i.test(path28.basename(f)))) {
+  if (!files.some((f) => /^readme\.md$/i.test(path29.basename(f)))) {
     items.push({ level: "low", category: "documentation", message: "No README.md found" });
   }
-  const hasPackageJson = files.some((f) => path28.basename(f) === "package.json");
+  const hasPackageJson = files.some((f) => path29.basename(f) === "package.json");
   const hasLockFile = files.some(
-    (f) => ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"].includes(path28.basename(f))
+    (f) => ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "bun.lock"].includes(path29.basename(f))
   );
   if (hasPackageJson && !hasLockFile) {
     items.push({ level: "medium", category: "hygiene", message: "Node project has no lock file committed" });
@@ -8337,8 +8582,8 @@ async function loadFileContents(cwd, files, maxLines = 1500) {
   await Promise.all(
     readable.map(async (rel) => {
       try {
-        const abs = path28.join(cwd, rel);
-        const raw = await fs26.readFile(abs, "utf-8");
+        const abs = path29.join(cwd, rel);
+        const raw = await fs27.readFile(abs, "utf-8");
         const lines = raw.split("\n");
         map.set(rel, lines.slice(0, maxLines).join("\n"));
       } catch {
@@ -8349,7 +8594,7 @@ async function loadFileContents(cwd, files, maxLines = 1500) {
 }
 
 // src/scanner/test-detector.ts
-import path29 from "path";
+import path30 from "path";
 var TEST_FRAMEWORK_MARKERS = {
   vitest: ["vitest"],
   jest: ["jest", "@jest/core"],
@@ -8413,7 +8658,7 @@ function detectTests(files, deps, scripts) {
   );
   const coverageRatio = sourceFiles.length > 0 ? testFiles.length / sourceFiles.length : 0;
   const hasConfig = files.some(
-    (f) => TEST_CONFIG_FILES.some((c) => path29.basename(f) === c)
+    (f) => TEST_CONFIG_FILES.some((c) => path30.basename(f) === c)
   );
   const coverageEnabled = "c8" in deps || "@vitest/coverage-v8" in deps || "@vitest/coverage-istanbul" in deps || Boolean(scripts?.["coverage"]) || Boolean(scripts?.["test:coverage"]);
   const testCommand = scripts?.["test"] ?? scripts?.["test:unit"];
@@ -8480,13 +8725,13 @@ var IGNORE_EXTENSIONS = /* @__PURE__ */ new Set([
 var CodebaseScanner = class {
   constructor(cwd) {
     this.cwd = cwd;
-    this.codebaseDir = path30.join(cwd, ".brainforge", "codebase");
+    this.codebaseDir = path31.join(cwd, ".brainforge", "codebase");
   }
   cwd;
   codebaseDir;
   async scan(deep = false) {
     const files = await this.walkFiles(this.cwd, deep ? 8 : 5);
-    const relFiles = files.map((f) => path30.relative(this.cwd, f).replace(/\\/g, "/"));
+    const relFiles = files.map((f) => path31.relative(this.cwd, f).replace(/\\/g, "/"));
     const fileContents = await loadFileContents(this.cwd, relFiles);
     const [stack, dependencies, conventions, risks] = await Promise.all([
       detectStack(this.cwd),
@@ -8496,7 +8741,7 @@ var CodebaseScanner = class {
     ]);
     let scripts;
     try {
-      const raw = await fs27.readFile(path30.join(this.cwd, "package.json"), "utf-8");
+      const raw = await fs28.readFile(path31.join(this.cwd, "package.json"), "utf-8");
       scripts = JSON.parse(raw).scripts;
     } catch {
     }
@@ -8521,20 +8766,20 @@ var CodebaseScanner = class {
     };
   }
   async save(result) {
-    await fs27.mkdir(this.codebaseDir, { recursive: true });
+    await fs28.mkdir(this.codebaseDir, { recursive: true });
     await Promise.all([
-      fs27.writeFile(path30.join(this.codebaseDir, "STACK.json"), JSON.stringify(result.stack, null, 2), "utf-8"),
-      fs27.writeFile(path30.join(this.codebaseDir, "FILES.json"), JSON.stringify(result.files, null, 2), "utf-8"),
-      fs27.writeFile(path30.join(this.codebaseDir, "MAP.md"), this.toMapMd(result), "utf-8"),
-      fs27.writeFile(path30.join(this.codebaseDir, "CONVENTIONS.md"), this.toConventionsMd(result), "utf-8"),
-      fs27.writeFile(path30.join(this.codebaseDir, "RISKS.md"), this.toRisksMd(result), "utf-8"),
-      fs27.writeFile(path30.join(this.codebaseDir, "TESTS.md"), this.toTestsMd(result), "utf-8")
+      fs28.writeFile(path31.join(this.codebaseDir, "STACK.json"), JSON.stringify(result.stack, null, 2), "utf-8"),
+      fs28.writeFile(path31.join(this.codebaseDir, "FILES.json"), JSON.stringify(result.files, null, 2), "utf-8"),
+      fs28.writeFile(path31.join(this.codebaseDir, "MAP.md"), this.toMapMd(result), "utf-8"),
+      fs28.writeFile(path31.join(this.codebaseDir, "CONVENTIONS.md"), this.toConventionsMd(result), "utf-8"),
+      fs28.writeFile(path31.join(this.codebaseDir, "RISKS.md"), this.toRisksMd(result), "utf-8"),
+      fs28.writeFile(path31.join(this.codebaseDir, "TESTS.md"), this.toTestsMd(result), "utf-8")
     ]);
   }
   async loadLatest() {
     try {
-      const stack = JSON.parse(await fs27.readFile(path30.join(this.codebaseDir, "STACK.json"), "utf-8"));
-      const files = JSON.parse(await fs27.readFile(path30.join(this.codebaseDir, "FILES.json"), "utf-8"));
+      const stack = JSON.parse(await fs28.readFile(path31.join(this.codebaseDir, "STACK.json"), "utf-8"));
+      const files = JSON.parse(await fs28.readFile(path31.join(this.codebaseDir, "FILES.json"), "utf-8"));
       return { stack, files };
     } catch {
       return null;
@@ -8646,7 +8891,7 @@ var CodebaseScanner = class {
       let size = 0;
       let lines = 0;
       try {
-        const stat = await fs27.stat(abs);
+        const stat = await fs28.stat(abs);
         size = stat.size;
         const content = contents.get(rel);
         lines = content ? content.split("\n").length : 0;
@@ -8658,18 +8903,18 @@ var CodebaseScanner = class {
   }
   async walkFiles(dir, maxDepth, depth = 0) {
     if (depth > maxDepth) return [];
-    const entries = await fs27.readdir(dir, { withFileTypes: true });
+    const entries = await fs28.readdir(dir, { withFileTypes: true });
     const results = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".gitignore" && entry.name !== ".env.example") {
         if (IGNORE_DIRS.has(entry.name)) continue;
       }
       if (IGNORE_DIRS.has(entry.name)) continue;
-      const full = path30.join(dir, entry.name);
+      const full = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await this.walkFiles(full, maxDepth, depth + 1));
       } else if (entry.isFile()) {
-        const ext = path30.extname(entry.name).toLowerCase();
+        const ext = path31.extname(entry.name).toLowerCase();
         if (!IGNORE_EXTENSIONS.has(ext)) results.push(full);
       }
     }
@@ -8677,12 +8922,12 @@ var CodebaseScanner = class {
   }
   async readProjectName() {
     try {
-      const raw = await fs27.readFile(path30.join(this.cwd, "package.json"), "utf-8");
+      const raw = await fs28.readFile(path31.join(this.cwd, "package.json"), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name) return pkg.name;
     } catch {
     }
-    return path30.basename(this.cwd);
+    return path31.basename(this.cwd);
   }
 };
 function inferRole(filePath) {
@@ -8804,12 +9049,12 @@ function summariseEntries(entries) {
 }
 
 // src/memory/context-packets.ts
-import fs28 from "fs/promises";
-import path31 from "path";
+import fs29 from "fs/promises";
+import path32 from "path";
 var ContextPacketBuilder = class {
   constructor(cwd) {
     this.cwd = cwd;
-    this.packetDir = path31.join(cwd, ".brainforge", "memory", "context-packets");
+    this.packetDir = path32.join(cwd, ".brainforge", "memory", "context-packets");
   }
   cwd;
   packetDir;
@@ -8882,14 +9127,14 @@ var ContextPacketBuilder = class {
     };
   }
   async save(packet) {
-    await fs28.mkdir(this.packetDir, { recursive: true });
-    const jsonPath = path31.join(this.packetDir, "latest.json");
-    const mdPath = path31.join(this.packetDir, "latest.md");
-    await fs28.writeFile(jsonPath, JSON.stringify(packet, null, 2), "utf-8");
-    await fs28.writeFile(mdPath, this.toMarkdown(packet), "utf-8");
+    await fs29.mkdir(this.packetDir, { recursive: true });
+    const jsonPath = path32.join(this.packetDir, "latest.json");
+    const mdPath = path32.join(this.packetDir, "latest.md");
+    await fs29.writeFile(jsonPath, JSON.stringify(packet, null, 2), "utf-8");
+    await fs29.writeFile(mdPath, this.toMarkdown(packet), "utf-8");
     const ts = packet.generatedAt.replace(/[:.]/g, "-").slice(0, 19);
-    await fs28.writeFile(
-      path31.join(this.packetDir, `packet-${ts}.json`),
+    await fs29.writeFile(
+      path32.join(this.packetDir, `packet-${ts}.json`),
       JSON.stringify(packet, null, 2),
       "utf-8"
     );
@@ -8897,7 +9142,7 @@ var ContextPacketBuilder = class {
   }
   async loadLatest() {
     try {
-      const raw = await fs28.readFile(path31.join(this.packetDir, "latest.json"), "utf-8");
+      const raw = await fs29.readFile(path32.join(this.packetDir, "latest.json"), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;

package/package.json

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