codingbuddy-rules 2.0.0 → 2.2.0

package/.ai-rules/adapters/antigravity.md

@@ -50,7 +50,7 @@ See full workflow details in `.ai-rules/rules/core.md`
 
 #### Tech Stack
 
-프로젝트의 `package.json`을 참조하세요.
+See project `package.json`.
 
 #### Project Structure
 ```
@@ -126,7 +126,7 @@ Antigravity uses artifact files for:
 
 ### Communication
 
-- **Always respond in Korean (한국어)** as specified in common rules
+- **Follow project's configured language setting**
 - Use structured markdown formatting
 - Provide clear, actionable feedback
 
@@ -161,7 +161,7 @@ When working with Antigravity, it automatically has access to:
 ### Workflow Example
 
 ```
-User: 새로운 뉴스레터 기능 만들어줘
+User: Build a new newsletter feature
 
 AI: # Mode: PLAN
     ## 📋 Plan Overview
@@ -187,6 +187,86 @@ AI: # Mode: EVAL
 - ✅ Access to all specialist agent knowledge
 - ✅ Easy to update: change `.ai-rules/` once, all tools benefit
 
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+User: AUTO Build a new payment system feature
+
+AI: # Mode: AUTO (Iteration 1/3)
+    ## Phase: PLAN
+    [Following .ai-rules/rules/core.md workflow]
+
+    ## Phase: ACT
+    [Execute with .ai-rules guidelines]
+
+    ## Phase: EVAL
+    [Evaluate with quality criteria]
+
+    ### Quality Status
+    - Critical: 0
+    - High: 0
+
+    ✅ AUTO mode completed successfully!
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Antigravity-Specific Integration
+
+AUTO mode works with Antigravity's task boundary tracking:
+
+```python
+task_boundary(
+  TaskName="AUTO: Feature Implementation",
+  Mode="AUTO_ITERATION",
+  TaskSummary="Iteration 1/3 - PLAN phase completed",
+  TaskStatus="Executing ACT phase",
+  PredictedTaskSize=30
+)
+```
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria
+
 ## Maintenance
 
 When updating rules:

package/.ai-rules/adapters/claude-code.md

@@ -27,7 +27,7 @@ See `.ai-rules/rules/core.md` for:
 
 ### Project Context
 See `.ai-rules/rules/project.md` for:
-- Tech stack (프로젝트의 package.json 참조)
+- Tech stack (see project package.json)
 - Project structure (app → widgets → features → entities → shared)
 - Development rules and file naming conventions
 - Domain knowledge
@@ -44,7 +44,7 @@ See `.ai-rules/agents/README.md` for available specialist agents and their exper
 
 ## Claude Code Specific
 
-- Always respond in Korean (한국어)
+- Follow project's configured language setting
 - Use structured markdown formatting
 - Provide clear, actionable feedback
 - Reference project context from `.ai-rules/rules/project.md`
@@ -85,7 +85,7 @@ See `.ai-rules/agents/README.md` for available specialist agents and their exper
 ### In Claude Chat
 
 ```
-User: 새로운 기능 만들어줘
+User: Build a new feature
 
 Claude: # Mode: PLAN
         [Following .ai-rules/rules/core.md workflow]
@@ -175,9 +175,11 @@ CodingBuddy uses a layered agent hierarchy for different types of tasks:
 | Mode | Agents | Description |
 |------|--------|-------------|
 | **PLAN** | solution-architect, technical-planner | Design and planning tasks |
-| **ACT** | frontend-developer, backend-developer, devops-engineer, agent-architect | Implementation tasks |
+| **ACT** | tooling-engineer, frontend-developer, backend-developer, devops-engineer, agent-architect | Implementation tasks |
 | **EVAL** | code-reviewer | Code review and evaluation |
 
+> **Note**: `tooling-engineer` has highest priority for config/build tool tasks (tsconfig, eslint, vite.config, package.json, etc.)
+
 ### Tier 2: Specialist Agents
 
 Specialist agents can be invoked by any Primary Agent as needed:
@@ -195,9 +197,34 @@ Specialist agents can be invoked by any Primary Agent as needed:
 ### Agent Resolution
 
 1. **PLAN mode**: Always uses `solution-architect` or `technical-planner` based on prompt analysis
-2. **ACT mode**: Uses recommended agent from PLAN, or falls back to AI analysis
+2. **ACT mode**: Resolution priority:
+   1. Explicit agent request in prompt (e.g., "work with backend-developer")
+   2. `recommended_agent` parameter (from PLAN mode recommendation)
+   3. Tooling pattern matching (config files, build tools → `tooling-engineer`)
+   4. Project configuration (`primaryAgent` setting)
+   5. Context inference (file extension/path)
+   6. Default: `frontend-developer`
 3. **EVAL mode**: Always uses `code-reviewer`
 
+### Using recommended_agent Parameter
+
+When transitioning from PLAN to ACT mode, pass the recommended agent:
+
+```typescript
+// After PLAN mode returns recommended_act_agent
+const planResult = await parse_mode({ prompt: "PLAN design auth API" });
+// planResult.recommended_act_agent = { agentName: "backend-developer", ... }
+
+// Pass to ACT mode for context preservation
+const actResult = await parse_mode({
+  prompt: "ACT implement the API",
+  recommended_agent: planResult.recommended_act_agent.agentName
+});
+// actResult.delegates_to = "backend-developer" (uses the recommendation)
+```
+
+This enables seamless agent context passing across PLAN → ACT workflow transitions.
+
 ## Activation Messages
 
 When agents or skills are activated, CodingBuddy displays activation messages for transparency:
@@ -257,3 +284,259 @@ AI assistants should display the `activation_message.formatted` field at the sta
 
 ...
 ```
+
+## Parallel Specialist Agents Execution
+
+CodingBuddy supports parallel execution of multiple specialist agents for comprehensive analysis.
+
+### When to Use Parallel Execution
+
+Parallel execution is recommended when `parse_mode` returns a `parallelAgentsRecommendation` field:
+
+| Mode | Default Specialists | Use Case |
+|------|---------------------|----------|
+| **PLAN** | architecture-specialist, test-strategy-specialist | Validate architecture and test approach |
+| **ACT** | code-quality-specialist, test-strategy-specialist | Verify implementation quality |
+| **EVAL** | security-specialist, accessibility-specialist, performance-specialist, code-quality-specialist | Comprehensive multi-dimensional review |
+
+### parallelAgentsRecommendation Response Field
+
+The `parse_mode` MCP tool returns this field to recommend parallel specialist execution:
+
+```json
+{
+  "mode": "EVAL",
+  "parallelAgentsRecommendation": {
+    "specialists": [
+      "security-specialist",
+      "accessibility-specialist",
+      "performance-specialist",
+      "code-quality-specialist"
+    ],
+    "hint": "Use Task tool with subagent_type=\"general-purpose\" and run_in_background=true for each specialist. Call prepare_parallel_agents MCP tool to get ready-to-use prompts."
+  }
+}
+```
+
+### Parallel Execution Workflow
+
+```
+Call parse_mode
+     ↓
+Check parallelAgentsRecommendation
+     ↓ (if exists)
+Display start message to user
+     ↓
+Call prepare_parallel_agents MCP
+     ↓
+Call each agent.taskPrompt via Task tool in parallel:
+  - subagent_type: "general-purpose"
+  - run_in_background: true
+  - prompt: agent.taskPrompt
+     ↓
+Collect results with TaskOutput
+     ↓
+Display consolidated results to user
+```
+
+### Code Example
+
+```typescript
+// Step 1: Parse mode returns parallelAgentsRecommendation
+const parseModeResult = await parse_mode({ prompt: "EVAL review auth implementation" });
+
+if (parseModeResult.parallelAgentsRecommendation) {
+  // Step 2: Display start message to user
+  console.log("🚀 Dispatching 4 specialist agents in parallel...");
+  console.log("   → 🔒 security-specialist");
+  console.log("   → ♿ accessibility-specialist");
+  console.log("   → ⚡ performance-specialist");
+  console.log("   → 📏 code-quality-specialist");
+
+  // Step 3: Prepare parallel agents
+  const preparedAgents = await prepare_parallel_agents({
+    mode: "EVAL",
+    specialists: parseModeResult.parallelAgentsRecommendation.specialists,
+    sharedContext: "Review authentication implementation",
+    targetFiles: ["src/auth/login.tsx"]
+  });
+
+  // Step 4: Execute in parallel using Task tool
+  const agentTasks = preparedAgents.agents.map(agent =>
+    Task({
+      subagent_type: "general-purpose",
+      prompt: agent.taskPrompt,
+      description: agent.description,
+      run_in_background: true,
+      model: "opus" // Use opus for thorough analysis
+    })
+  );
+
+  // Step 5: Collect results
+  const results = await Promise.all(agentTasks.map(task => TaskOutput(task.id)));
+
+  // Step 6: Display summary
+  console.log("📊 Specialist Analysis Complete:");
+  results.forEach(result => console.log(result.summary));
+}
+```
+
+### Visibility Pattern
+
+When executing parallel specialists, display clear status messages:
+
+**Start Message:**
+```
+🚀 Dispatching N specialist agents in parallel...
+   → 🔒 security-specialist
+   → ♿ accessibility-specialist
+   → ⚡ performance-specialist
+   → 📏 code-quality-specialist
+```
+
+**Completion Message:**
+```
+📊 Specialist Analysis Complete:
+
+🔒 Security Specialist:
+   [findings summary]
+
+♿ Accessibility Specialist:
+   [findings summary]
+
+⚡ Performance Specialist:
+   [findings summary]
+
+📏 Code Quality Specialist:
+   [findings summary]
+```
+
+### Specialist Icons
+
+| Icon | Specialist |
+|------|------------|
+| 🔒 | security-specialist |
+| ♿ | accessibility-specialist |
+| ⚡ | performance-specialist |
+| 📏 | code-quality-specialist |
+| 🧪 | test-strategy-specialist |
+| 🏛️ | architecture-specialist |
+| 📚 | documentation-specialist |
+| 🔍 | seo-specialist |
+| 🎨 | design-system-specialist |
+
+### Handling Failures
+
+When `prepare_parallel_agents` returns `failedAgents`:
+
+```
+⚠️ Some agents failed to load:
+   ✗ performance-specialist: Profile not found
+
+Continuing with 3/4 agents...
+```
+
+**Strategy:**
+- Continue with successfully loaded agents
+- Report failures clearly to user
+- Document which agents couldn't be loaded in final report
+
+### Specialist Activation Scope
+
+Each workflow mode activates different specialist agents:
+
+- **PLAN mode**: Architecture and test strategy specialists validate design
+- **ACT mode**: Code quality and test strategy specialists verify implementation
+- **EVAL mode**: Security, accessibility, performance, and code quality specialists provide comprehensive review
+
+**Important:** Specialists from one mode do NOT carry over to the next mode. Each mode has its own recommended specialist set.
+
+## AUTO Mode
+
+AUTO mode enables autonomous iteration through PLAN -> ACT -> EVAL cycles until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO implement user authentication with JWT tokens
+```
+
+```
+자동 사용자 인증 기능을 JWT로 구현해줘
+```
+
+### Expected Behavior
+
+1. **Initial PLAN**: Creates implementation plan with quality criteria
+2. **ACT Iteration**: Executes implementation following TDD workflow
+3. **EVAL Check**: Evaluates quality against exit criteria
+4. **Loop or Exit**:
+   - If quality met (Critical=0, High=0): Exits with success summary
+   - If max iterations reached: Exits with failure summary and remaining issues
+   - Otherwise: Returns to PLAN with improvement focus
+
+### Exit Criteria
+
+- **Success**: `Critical = 0 AND High = 0` severity issues
+- **Failure**: Max iterations reached (default: 3, configurable via `auto.maxIterations`)
+
+### Configuration
+
+Configure AUTO mode in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3  // Default: 3
+  }
+};
+```
+
+### AUTO Mode Output Format
+
+```
+# Mode: AUTO (Iteration 1/3)
+
+## Phase: PLAN
+[Planning content...]
+
+## Phase: ACT
+[Implementation content...]
+
+## Phase: EVAL
+[Evaluation content...]
+
+### Quality Status
+- Critical: 0
+- High: 0
+
+✅ AUTO mode completed successfully!
+```
+
+### When to Use AUTO Mode
+
+- **Large feature implementations** that require multiple refinement cycles
+- **Complex refactoring** where quality verification is critical
+- **Bug fixes** that need comprehensive testing and validation
+- **Code quality improvements** with measurable success criteria
+
+### Differences from Manual Mode Flow
+
+| Aspect | Manual Mode | AUTO Mode |
+|--------|-------------|-----------|
+| Transition | User triggers each mode | Automatic cycling |
+| Iterations | Single pass per mode | Multiple cycles until quality met |
+| Exit | User decides completion | Quality criteria or max iterations |
+| Intervention | Required for each step | Only when requested or on failure |

package/.ai-rules/adapters/codex.md

@@ -147,3 +147,60 @@ Skills are located in `.ai-rules/skills/`. To use a skill:
 - `subagent-driven-development` - In-session plan execution
 - `dispatching-parallel-agents` - Handle parallel tasks
 - `frontend-design` - Build production-grade UI
+
+## AUTO Mode
+
+AUTO mode enables autonomous PLAN -> ACT -> EVAL cycling until quality criteria are met.
+
+### Triggering AUTO Mode
+
+Use the `AUTO` keyword (or localized versions) at the start of your message:
+
+| Language | Keyword |
+|----------|---------|
+| English | `AUTO` |
+| Korean | `자동` |
+| Japanese | `自動` |
+| Chinese | `自动` |
+| Spanish | `AUTOMATICO` |
+
+### Example Usage
+
+```
+AUTO implement user authentication with JWT
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria
+2. **ACT Phase**: Executes implementation following TDD workflow
+3. **EVAL Phase**: Evaluates quality against exit criteria
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### Copilot Integration
+
+When using GitHub Copilot Chat with AUTO mode:
+- Copilot references `.ai-rules/rules/core.md` for workflow
+- Applies `.ai-rules/rules/augmented-coding.md` TDD principles
+- Uses project structure from `.ai-rules/rules/project.md`
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### When to Use
+
+- Large feature implementations requiring multiple refinement cycles
+- Complex refactoring with quality verification
+- Bug fixes needing comprehensive testing
+- Code quality improvements with measurable criteria