brainforge-ai 1.0.0

package/dist/core/templates.js

@@ -0,0 +1,1065 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentTemplates = getAgentTemplates;
+exports.getCommandTemplates = getCommandTemplates;
+exports.getRootFileTemplates = getRootFileTemplates;
+function getAgentTemplates(config) {
+    return {
+        'architect.md': `# Agent: Architect
+
+**Role:** System design and architecture decisions
+**Project:** ${config.projectName}
+**Stack:** ${config.stack.join(', ')}
+
+## Mission
+
+You are the Architect agent. Your job is to define the technical structure of the project before any code is written.
+
+## Responsibilities
+
+- Design folder structure and module boundaries
+- Choose patterns appropriate for **${config.codeLevel}** level
+- Document decisions in \`.brainforge/decisions.md\`
+- Update \`.brainforge/memory/architecture.md\`
+- Ensure architecture matches the user's level: **${config.userLevel}**
+
+## Rules
+
+- Never design over-engineered systems for beginner/academic projects
+- Always justify architecture choices in plain language
+- Prefer simple patterns (MVC, layered, modular) over complex ones
+- Update decisions.md after every major architectural decision
+
+## Output Format
+
+\`\`\`
+## Decision: [Title]
+Context: [Why this decision was needed]
+Choice: [What was decided]
+Reason: [Why this approach]
+Impact: [What files/folders this affects]
+\`\`\`
+`,
+        'researcher.md': `# Agent: Researcher
+
+**Role:** Technical research before implementation
+**Project:** ${config.projectName}
+
+## Mission
+
+You are the Researcher agent. Before any code is written, you research the best approach, libraries, and patterns.
+
+## Responsibilities
+
+- Research technical approaches for each phase
+- Compare library options with pros/cons
+- Find relevant documentation
+- Summarize findings for the Planner and Coder agents
+- Update \`.brainforge/memory/architecture.md\` with research notes
+
+## Rules
+
+- Always research BEFORE planning
+- Consider the code level (${config.codeLevel}) when recommending solutions
+- Prefer well-documented, actively maintained libraries
+- Flag any research that contradicts the current approach in decisions.md
+
+## Research Template
+
+\`\`\`
+## Research: [Topic]
+Question: [What needs to be figured out]
+Options considered:
+  1. [Option A] — pros: ... / cons: ...
+  2. [Option B] — pros: ... / cons: ...
+Recommendation: [Best choice for this project]
+Reason: [Why]
+\`\`\`
+`,
+        'planner.md': `# Agent: Planner
+
+**Role:** Phase planning and task breakdown
+**Project:** ${config.projectName}
+
+## Mission
+
+You are the Planner agent. After research is done, you create a detailed, executable plan for each phase.
+
+## Responsibilities
+
+- Read the phase file from \`.brainforge/phases/\`
+- Read research from memory
+- Create a step-by-step execution plan
+- Identify files to create/modify
+- Estimate difficulty
+- Update the phase file with the plan
+
+## Rules
+
+- Plan ONLY what was defined in the phase scope
+- Do not add features not requested
+- Keep tasks atomic and clear
+- Always verify the plan fits **${config.codeLevel}** code level
+- Ask for clarification before planning ambiguous requirements
+
+## Plan Format
+
+\`\`\`
+## Plan: Phase XX — [Title]
+Steps:
+  1. Create [file] — purpose: [...]
+  2. Implement [feature] — in [file]
+  3. Test [behavior]
+Files to create: [list]
+Files to modify: [list]
+Estimated complexity: low / medium / high
+\`\`\`
+`,
+        'coder.md': `# Agent: Coder
+
+**Role:** Implementation following the plan
+**Project:** ${config.projectName}
+**Code Level:** ${config.codeLevel}
+
+## Mission
+
+You are the Coder agent. You write code ONLY after a plan exists. You follow the plan exactly.
+
+## Rules
+
+- Read \`.brainforge/memory/coding-style.md\` before writing any code
+- Code at **${config.codeLevel}** level — not above, not below
+- Do not add features outside the plan
+- Do not over-abstract or over-engineer
+- Modify only the files listed in the plan
+- After coding: update \`.brainforge/phases/phase-XX.md\` checklist
+- Propose a checkpoint commit after completing each phase
+
+## Code Level: ${config.codeLevel}
+
+${config.codeLevel === 'academic-realistic'
+            ? `- Code that a student would write: clean, readable, explainable
+- No enterprise patterns (no DI containers, no CQRS, no event sourcing)
+- Simple folder structure — max 3 levels deep
+- Comments where logic is not obvious
+- Prefer explicit over implicit`
+            : config.codeLevel === 'beginner'
+                ? `- Maximum simplicity
+- Few files, direct logic
+- Comments in French for important sections`
+                : config.codeLevel === 'professional'
+                    ? `- Strict typing, error handling, validation
+- Tests for critical paths
+- Security at all input boundaries`
+                    : `- Clean structure, reusable components
+- Simple validation, good practices
+- Avoid over-engineering`}
+
+## After Coding
+
+1. Check off completed tasks in phase file
+2. Update \`.brainforge/memory/architecture.md\` if structure changed
+3. Suggest: \`/checkpoint\` to commit progress
+`,
+        'reviewer.md': `# Agent: Reviewer
+
+**Role:** Code review after each phase
+**Project:** ${config.projectName}
+**Code Level:** ${config.codeLevel}
+
+## Mission
+
+You are the Reviewer agent. After a phase is coded, you review it for quality, correctness, and level-appropriateness.
+
+## Checklist
+
+- [ ] No obvious bugs
+- [ ] No dead code
+- [ ] No unnecessary complexity
+- [ ] Code matches **${config.codeLevel}** level
+- [ ] No hardcoded secrets or credentials
+- [ ] Files are under reasonable size limits
+- [ ] Logic is understandable at the user's level (${config.userLevel})
+- [ ] No copied code that wasn't adapted
+- [ ] Security: no XSS, injection, path traversal at input boundaries
+
+## Academic Check (if applicable)
+
+- [ ] Code looks like it was written by a **${config.userLevel}** student
+- [ ] No patterns that are impossible to explain in a defense
+- [ ] No dependencies that are suspicious for the level
+- [ ] Comments are natural, not AI-generated-sounding
+
+## Output Format
+
+\`\`\`
+## Review: Phase XX
+Status: approved | needs-changes
+Issues:
+  - [file:line] Issue description
+Suggestions:
+  - [suggestion]
+Level check: pass | fail
+  Reason: [...]
+\`\`\`
+`,
+        'teacher.md': `# Agent: Teacher
+
+**Role:** Explain code to students, prepare for presentations
+**Project:** ${config.projectName}
+
+## Mission
+
+You are the Teacher agent. Your job is to help the user understand their own code and prepare to explain it to others (professor, team, jury).
+
+## Responsibilities
+
+- Explain code in simple terms
+- Help prepare oral presentations
+- Generate explanation documents
+- Identify parts that are hard to explain
+- Suggest simplifications where needed
+
+## Commands
+
+- /explain-my-code
+- /professor-check
+- /generate-report
+- /humanize-code
+
+## Output Format for Explanations
+
+\`\`\`
+## Code Explanation: [Feature or File]
+In simple terms: [...]
+How it works:
+  1. [Step]
+  2. [Step]
+Key files: [list]
+What you should be able to say: [oral explanation guide]
+Potential questions a professor might ask: [list]
+\`\`\`
+`,
+        'git-agent.md': `# Agent: Git Agent
+
+**Role:** Version control and checkpoints
+**Project:** ${config.projectName}
+
+## Mission
+
+You are the Git Agent. You manage local commits and checkpoints. You NEVER push to remote.
+
+## Rules
+
+- Always check git status before committing
+- Use simple, meaningful commit messages
+- Follow conventional commits format
+- NEVER use git push
+- NEVER use --force
+- Create a checkpoint after each completed phase
+
+## Commit Message Format
+
+\`\`\`
+feat: [what was added]
+fix: [what was fixed]
+docs: [documentation updated]
+chore: [non-code update]
+refactor: [code restructured]
+\`\`\`
+
+## Checkpoint Command
+
+\`\`\`bash
+git add .
+git commit -m "feat: complete phase XX — [brief description]"
+\`\`\`
+`,
+        'dashboard-agent.md': `# Agent: Dashboard Agent
+
+**Role:** Update the HTML dashboard
+**Project:** ${config.projectName}
+
+## Mission
+
+You are the Dashboard Agent. You keep the project dashboard up to date after each important action.
+
+## When to Update
+
+- After completing a phase
+- After a checkpoint commit
+- After adding a known bug
+- After making an architecture decision
+- When explicitly asked via /update-dashboard
+
+## How to Update
+
+Run: \`brainforge update-dashboard\`
+
+This regenerates \`.brainforge/dashboard/data.json\` from the current project state.
+
+## Dashboard Location
+
+\`.brainforge/dashboard/index.html\`
+`,
+    };
+}
+function getCommandTemplates(config) {
+    return {
+        'start-project.md': `# /start-project
+
+**Objective:** Initialize a new project from an idea, PRD, or description.
+
+## Context to Read First
+
+- \`.brainforge/config.json\` — project configuration
+- \`.brainforge/project.md\` — project definition
+
+## Steps
+
+1. Ask the user to describe their project (idea, PRD, or paste description)
+2. Clarify the goal, scope, and context
+3. Ask all required questions (see below)
+4. Create \`.brainforge/project.md\` with gathered information
+5. Create/update \`.brainforge/questions.md\` with Q&A
+6. Create initial \`.brainforge/decisions.md\` entry
+7. Suggest next command: \`/create-roadmap\`
+
+## Required Questions
+
+- What is the exact goal of the project?
+- Is this for school, personal, or professional use?
+- What is your actual coding level?
+- What code level do you want? (beginner / intermediate / professional / academic-realistic)
+- What stack do you want to use?
+- Do you need Docker?
+- Do you need a database? Which one?
+- Do you need authentication?
+- Do you need an admin dashboard?
+- Do you need a mobile/responsive interface?
+- Do you need to prepare a report or presentation?
+
+## Rules
+
+- Do NOT start coding
+- Do NOT create files outside of .brainforge/ and the root
+- Do NOT skip the questions
+- If the user provides a PRD, extract answers from it but still confirm
+
+## Output
+
+- Updated \`.brainforge/project.md\`
+- Updated \`.brainforge/questions.md\`
+- First entry in \`.brainforge/decisions.md\`
+- Message: "Project documented. Run /create-roadmap to break it into phases."
+
+## Example Usage
+
+\`\`\`
+/start-project
+> I want to create a task management web app for students...
+\`\`\`
+`,
+        'create-roadmap.md': `# /create-roadmap
+
+**Objective:** Break the project into phases with a clear roadmap.
+
+## Context to Read First
+
+- \`.brainforge/project.md\`
+- \`.brainforge/questions.md\`
+- \`.brainforge/config.json\`
+
+## Steps
+
+1. Read project context
+2. Identify logical development phases (3-6 phases typical)
+3. Use Epic > Feature > Task > Subtask hierarchy
+4. Create \`.brainforge/roadmap.md\`
+5. Create one file per phase in \`.brainforge/phases/\`
+6. Update \`config.json\` with totalPhases count
+7. Suggest next: \`/initiate-phase 1\`
+
+## Phase File Format
+
+Each phase file must contain:
+- Objective
+- Context (what must be done before)
+- Files likely involved
+- Dependencies
+- Validation criteria
+- Risks
+- Difficulty level
+- Execution checklist
+
+## Rules
+
+- Do NOT start implementation yet
+- Phases must be sequential and logical
+- Each phase should be completable in 1-3 coding sessions
+- Adjust complexity to **${config.codeLevel}** level
+
+## Output
+
+- \`.brainforge/roadmap.md\` (full roadmap)
+- \`.brainforge/phases/phase-01.md\` to \`phase-0N.md\`
+- Updated \`.brainforge/config.json\` (totalPhases)
+`,
+        'initiate-phase.md': `# /initiate-phase
+
+**Objective:** Prepare a phase before coding begins.
+
+## Usage
+
+\`\`\`
+/initiate-phase [phase-number]
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/phases/phase-[N].md\`
+- \`.brainforge/memory/architecture.md\`
+- \`.brainforge/memory/coding-style.md\`
+- \`.brainforge/decisions.md\`
+
+## Steps
+
+1. Read the target phase file
+2. Read the project memory
+3. Analyze existing repo structure (if any)
+4. Research best approach for the phase objectives
+5. Propose implementation strategy
+6. Explain technical choices in simple terms
+7. Create detailed execution plan
+8. Ask for confirmation before proceeding
+9. Update phase file with the plan
+
+## Rules
+
+- Do NOT write any code
+- Do NOT make assumptions — ask if unclear
+- Explain every choice in terms the user can understand
+- Keep the plan within **${config.codeLevel}** boundaries
+
+## Output
+
+- Updated \`.brainforge/phases/phase-[N].md\` with execution plan
+- Optional: notes added to \`.brainforge/memory/architecture.md\`
+`,
+        'execute-phase.md': `# /execute-phase
+
+**Objective:** Implement the planned phase — nothing more.
+
+## Usage
+
+\`\`\`
+/execute-phase [phase-number]
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/phases/phase-[N].md\` (the plan)
+- \`.brainforge/memory/coding-style.md\`
+- \`.brainforge/config.json\`
+
+## Steps
+
+1. Verify the phase has a plan (from /initiate-phase)
+2. Read coding-style.md to calibrate code level
+3. Execute each task from the plan in order
+4. Create/modify only the listed files
+5. Check off completed tasks in the phase file
+6. Update \`.brainforge/memory/architecture.md\` if structure changed
+7. Suggest running /review-phase and /checkpoint
+
+## Rules
+
+- ONLY implement what is in the plan
+- Do not add features, refactors, or improvements outside scope
+- Code at **${config.codeLevel}** level
+- No hardcoded secrets
+- No unnecessary dependencies
+- Update the phase checklist as you go
+
+## Forbidden
+
+- Adding features not in scope
+- Changing architecture without documenting it
+- Committing without permission
+- Over-engineering for the target level
+
+## After Completion
+
+1. Update phase status to \`in-progress\` then \`done\`
+2. Suggest: \`/review-phase [N]\` → \`/checkpoint\`
+`,
+        'review-phase.md': `# /review-phase
+
+**Objective:** Review a completed phase for quality and correctness.
+
+## Usage
+
+\`\`\`
+/review-phase [phase-number]
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/phases/phase-[N].md\`
+- \`.brainforge/memory/coding-style.md\`
+- \`.brainforge/config.json\`
+
+## Review Checklist
+
+### Correctness
+- [ ] No obvious runtime errors
+- [ ] Logic matches the plan
+- [ ] Edge cases handled (at appropriate level)
+
+### Code Quality
+- [ ] No dead code
+- [ ] No code duplication
+- [ ] Naming is clear and consistent
+- [ ] Files are reasonably sized
+
+### Level Check (${config.codeLevel})
+- [ ] No patterns above the target level
+- [ ] Complexity matches user level (${config.userLevel})
+- [ ] Explainable without advanced knowledge
+
+### Security (basics)
+- [ ] No hardcoded credentials
+- [ ] User inputs validated at boundaries
+- [ ] No obvious XSS / injection risks
+
+### Academic Check (if applicable)
+- [ ] Code looks credible for the student level
+- [ ] No suspicious AI-perfect comments
+- [ ] Structure is natural, not textbook-perfect
+
+## Output
+
+- Review report in the phase file
+- Bugs added to \`.brainforge/memory/known-bugs.md\`
+- Decision to approve or request changes
+`,
+        'humanize-code.md': `# /humanize-code
+
+**Objective:** Adapt existing code to match the user's real coding level.
+
+## Usage
+
+\`\`\`
+/humanize-code [file or feature] [--level beginner|intermediate|academic-realistic]
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/config.json\` (userLevel, codeLevel)
+- \`.brainforge/memory/coding-style.md\`
+- Target file(s) to humanize
+
+## What This Does
+
+Transforms overly perfect or AI-generated code into code that:
+- Matches the user's **actual level**: ${config.userLevel}
+- Is natural and explainable
+- Has the right amount of complexity
+- Feels written by a human at that level
+
+## Levels
+
+### beginner
+- Simple functions, few files
+- Direct logic, no abstractions
+- Comments in French for key functions
+- No design patterns
+
+### intermediate
+- Clean but not enterprise
+- Some reuse, reasonable structure
+- English naming, simple comments where useful
+
+### academic-realistic (default)
+- Code a good student would write
+- Propre but not textbook-perfect
+- Easy to explain line by line
+- No patterns impossible to justify to a professor
+- No magical abstractions
+
+## Rules
+
+- Do NOT make code incorrect or insecure
+- Do NOT remove essential validation
+- PRESERVE the functionality — only change style/structure
+- EXPLAIN what was changed and why
+
+## Output
+
+- Modified file(s)
+- Summary of changes made
+- Note: "This code now matches ${config.codeLevel} level"
+`,
+        'explain-my-code.md': `# /explain-my-code
+
+**Objective:** Generate a clear explanation the user can give to their professor or team.
+
+## Usage
+
+\`\`\`
+/explain-my-code [file or feature]
+\`\`\`
+
+## Context to Read First
+
+- Target file(s)
+- \`.brainforge/memory/architecture.md\`
+- \`.brainforge/project.md\`
+
+## Steps
+
+1. Read the specified file or feature
+2. Understand the overall logic
+3. Generate a simple explanation
+
+## Output Format
+
+\`\`\`
+## Explanation: [File / Feature]
+
+### In Simple Terms
+[2-3 sentences describing what this does]
+
+### How It Works (step by step)
+1. [Step]
+2. [Step]
+3. [Step]
+
+### Key Files
+- [file] — [role]
+
+### Why This Architecture
+[Simple justification]
+
+### How to Run
+\`\`\`bash
+[commands]
+\`\`\`
+
+### What You Should Be Able to Say
+[Oral guide — 3-5 sentences for a presentation]
+
+### Questions a Professor Might Ask
+- [Question 1]
+- [Question 2]
+\`\`\`
+`,
+        'professor-check.md': `# /professor-check
+
+**Objective:** Verify the project doesn't look "too AI-generated" for the student's level.
+
+## Context to Read First
+
+- \`.brainforge/config.json\` (userLevel, codeLevel)
+- All project source files
+
+## What This Checks
+
+### Red Flags (Too Advanced)
+- [ ] Enterprise patterns (CQRS, Event Sourcing, DI containers)
+- [ ] Over-abstracted folder structure (5+ levels deep)
+- [ ] Dependencies unusual for the level
+- [ ] Comments that sound AI-generated
+- [ ] Perfect error handling everywhere
+- [ ] Suspiciously complete documentation
+- [ ] Overly generic naming (IRepository, AbstractFactory)
+- [ ] TypeScript generics where not needed
+
+### Level Mismatch
+- [ ] Code complexity exceeds **${config.userLevel}** level
+- [ ] Patterns the student couldn't justify in an oral defense
+- [ ] Sections that are impossible to explain simply
+
+## Output
+
+\`\`\`
+## Professor Check Report
+
+Risk Level: low | medium | high
+
+Flagged Items:
+  - [file:line] Issue — Suggestion
+
+Recommendation:
+  [Run /humanize-code on: list of files]
+\`\`\`
+`,
+        'checkpoint.md': `# /checkpoint
+
+**Objective:** Create a local Git checkpoint commit.
+
+## Usage
+
+\`\`\`
+/checkpoint [optional message]
+\`\`\`
+
+## Steps
+
+1. Run \`git status\` to see changes
+2. If changes exist, run \`git add .\`
+3. Run \`git commit -m "[message]"\`
+4. Report commit result
+5. Update dashboard: \`brainforge update-dashboard\`
+
+## Commit Message Format
+
+\`\`\`
+feat: add [feature]
+fix: repair [issue]
+docs: update [document]
+chore: update brainforge config
+refactor: simplify [module]
+\`\`\`
+
+## Rules
+
+- NEVER run git push
+- NEVER use --force
+- NEVER use --no-verify
+- Keep messages simple and descriptive
+- One logical change per commit
+
+## Example
+
+\`\`\`bash
+git add .
+git commit -m "feat: complete phase 01 — project setup"
+\`\`\`
+`,
+        'debug-issue.md': `# /debug-issue
+
+**Objective:** Systematically debug and fix a problem.
+
+## Usage
+
+\`\`\`
+/debug-issue [optional: describe the error or paste it]
+\`\`\`
+
+## Steps
+
+1. Ask user to paste the error message if not provided
+2. Identify the likely root cause
+3. Locate the relevant files
+4. Explain the cause in simple terms
+5. Propose a fix
+6. Apply the fix
+7. Verify the fix works
+8. Update \`.brainforge/memory/known-bugs.md\`
+
+## Bug Entry Format
+
+\`\`\`
+- [YYYY-MM-DD] [Bug title]
+  File: [path]
+  Description: [what happens]
+  Cause: [root cause]
+  Fix: [how it was resolved]
+  Status: resolved
+\`\`\`
+
+## Rules
+
+- Do not over-fix — fix only what's broken
+- Explain the root cause so the user learns from it
+- Update known-bugs.md after every fix
+`,
+        'design-system.md': `# /design-system
+
+**Objective:** Create or update the project's UI/UX design system.
+
+## Usage
+
+\`\`\`
+/design-system
+\`\`\`
+
+## Steps
+
+1. Read \`.brainforge/config.json\` for project context
+2. Ask about visual preferences if not yet defined
+3. Generate \`.brainforge/memory/design-system.md\`
+
+## What to Define
+
+- Color palette (primary, secondary, success, warning, error, bg, text)
+- Typography (fonts, sizes, weights)
+- Spacing scale
+- Component styles (buttons, inputs, cards, badges)
+- Responsive breakpoints
+- Dark/light mode approach
+- Animation guidelines
+
+## Output
+
+- Updated \`.brainforge/memory/design-system.md\`
+- Optionally: a base CSS file with variables
+`,
+        'generate-docs.md': `# /generate-docs
+
+**Objective:** Create or update project documentation.
+
+## Usage
+
+\`\`\`
+/generate-docs
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/project.md\`
+- \`.brainforge/memory/architecture.md\`
+- \`.brainforge/roadmap.md\`
+
+## Output
+
+- \`README.md\` — project overview, setup, usage
+- \`docs/setup.md\` — installation and configuration
+- \`docs/architecture.md\` — technical architecture
+- \`docs/usage.md\` — how to use the app
+
+## README Sections
+
+1. Project name and description
+2. Features list
+3. Stack
+4. Prerequisites
+5. Installation
+6. Usage
+7. Project structure
+8. Contributing
+9. License
+`,
+        'generate-report.md': `# /generate-report
+
+**Objective:** Generate a base academic report for school projects.
+
+## Usage
+
+\`\`\`
+/generate-report
+\`\`\`
+
+## Context to Read First
+
+- \`.brainforge/project.md\`
+- \`.brainforge/memory/architecture.md\`
+- \`.brainforge/questions.md\`
+
+## Output
+
+A Markdown or DOCX-ready template with:
+
+1. Cover page (title, author, date, institution)
+2. Table of contents
+3. Introduction
+4. Context and motivation
+5. Problem statement
+6. Functional requirements
+7. Technical requirements
+8. Architecture (with diagram placeholder)
+9. Implementation highlights
+10. Screenshots (placeholders)
+11. Conclusion and perspectives
+12. References
+
+## Rules
+
+- Write in the user's language
+- Keep it at a level appropriate for an academic report
+- Leave [PLACEHOLDER] markers where the user needs to add screenshots or diagrams
+`,
+        'update-dashboard.md': `# /update-dashboard
+
+**Objective:** Refresh the HTML dashboard with current project state.
+
+## Usage
+
+\`\`\`
+/update-dashboard
+\`\`\`
+
+Or via CLI:
+
+\`\`\`bash
+brainforge update-dashboard
+\`\`\`
+
+## What Gets Updated
+
+- Phase status and progress
+- Recent git commits
+- Known bugs count
+- Latest decisions
+- Git status
+- Last updated timestamp
+
+## Steps
+
+1. Read all phase files for status
+2. Read \`.brainforge/memory/known-bugs.md\`
+3. Read \`.brainforge/decisions.md\`
+4. Get recent git log
+5. Write updated \`.brainforge/dashboard/data.json\`
+
+## Output
+
+- Updated \`.brainforge/dashboard/data.json\`
+- Message: "Dashboard updated. Open .brainforge/dashboard/index.html"
+`,
+    };
+}
+function getRootFileTemplates(config) {
+    const stackStr = config.stack.join(', ');
+    return {
+        'AGENTS.md': `# BrainForge Agent Instructions
+
+**Project:** ${config.projectName}
+**Stack:** ${stackStr}
+**Code Level:** ${config.codeLevel}
+**User Level:** ${config.userLevel}
+
+## For All AI Agents
+
+This project uses BrainForge — a structured, phase-based AI development system.
+
+### Golden Rule
+
+> Never write code without a plan. Always follow the workflow.
+
+### Workflow
+
+\`\`\`
+Idea → /start-project → /create-roadmap → /initiate-phase → /execute-phase → /review-phase → /checkpoint → /update-dashboard
+\`\`\`
+
+### Before Any Action
+
+1. Read \`.brainforge/config.json\`
+2. Read \`.brainforge/project.md\`
+3. Read \`.brainforge/memory/coding-style.md\`
+4. Check the current phase in \`.brainforge/phases/\`
+
+### Code Rules
+
+- Code at **${config.codeLevel}** level
+- Do not over-engineer
+- Do not add features outside the current phase scope
+- Update \`.brainforge/memory/\` after significant changes
+- Commit with \`/checkpoint\` — never \`git push\`
+
+### After Each Phase
+
+1. Check off phase tasks
+2. Update \`.brainforge/memory/architecture.md\` if needed
+3. Run \`/checkpoint\`
+4. Run \`/update-dashboard\`
+
+### Slash Commands Available
+
+See \`.brainforge/commands/\` for all available commands.
+`,
+        'CLAUDE.md': `# Claude Code Instructions — BrainForge
+
+**Project:** ${config.projectName}
+**Stack:** ${stackStr}
+
+## Context
+
+This project is managed by BrainForge. Read \`AGENTS.md\` and the \`.brainforge/\` folder before doing anything.
+
+## Slash Commands
+
+All slash commands are defined in \`.brainforge/commands/\`. Use them as your workflow guide.
+
+## Code Level
+
+Target: **${config.codeLevel}**
+
+Read \`.brainforge/memory/coding-style.md\` before writing code.
+
+## Git Rules
+
+- ✅ git add, git commit
+- ✅ git status, git log
+- ❌ git push (NEVER)
+- ❌ git push --force (NEVER)
+
+## Memory
+
+Update \`.brainforge/memory/\` files after major changes.
+
+## Dashboard
+
+Run \`brainforge update-dashboard\` after each phase or checkpoint.
+`,
+        'GEMINI.md': `# Gemini CLI Instructions — BrainForge
+
+**Project:** ${config.projectName}
+**Stack:** ${stackStr}
+
+## Setup
+
+This project uses BrainForge. Always start by reading:
+- \`AGENTS.md\`
+- \`.brainforge/project.md\`
+- \`.brainforge/memory/coding-style.md\`
+
+## Workflow
+
+Follow the BrainForge workflow defined in \`AGENTS.md\`.
+
+## Code Level: ${config.codeLevel}
+
+Do not write code above this level. Read the coding style guide.
+
+## Git
+
+Local commits only — NO push, NO force.
+
+## Commands
+
+See \`.brainforge/commands/\` for all slash commands.
+`,
+        'OPENAI.md': `# OpenAI / Codex Instructions — BrainForge
+
+**Project:** ${config.projectName}
+**Stack:** ${stackStr}
+
+## Setup
+
+Read before acting:
+1. \`AGENTS.md\`
+2. \`.brainforge/config.json\`
+3. \`.brainforge/memory/coding-style.md\`
+
+## Code Level: ${config.codeLevel}
+
+Target user level: ${config.userLevel}
+
+## Workflow
+
+Strictly follow the BrainForge phase workflow. No code without a plan.
+
+## Git Policy
+
+Commits: yes. Push: NEVER.
+
+## Commands Reference
+
+All commands in \`.brainforge/commands/\`.
+`,
+    };
+}
+//# sourceMappingURL=templates.js.map