codingbuddy-rules 2.0.0 → 2.2.0

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

@@ -1,151 +1,229 @@
 # Cursor Integration Guide
 
-This guide explains how to use the common AI rules (`.ai-rules/`) in Cursor.
+Guide for using codingbuddy with Cursor.
 
 ## Overview
 
-Cursor continues to use its native `.cursor/` directory structure while referencing the common rules from `.ai-rules/`.
+codingbuddy integrates with Cursor in two ways:
 
-## Integration Method
+1. **AGENTS.md** - Industry standard format compatible with all AI tools
+2. **.cursor/rules/*.mdc** - Cursor-specific optimization (glob-based auto-activation)
 
-### 1. Reference Common Rules
+## Two Usage Contexts
 
-Create `.cursor/rules/imports.mdc` to reference common rules:
+### End Users (Your Project)
 
-```markdown
+End users access rules **only through MCP tools**. No local rule files needed.
+
+```json
+// .cursor/mcp.json
+{
+  "mcpServers": {
+    "codingbuddy": {
+      "command": "npx",
+      "args": ["-y", "codingbuddy"]
+    }
+  }
+}
+```
+
+Optional: Create `.cursor/rules/codingbuddy.mdc` for basic integration:
+
+```yaml
 ---
-description: Common AI Rules Import
+description: codingbuddy integration
 globs:
 alwaysApply: true
 ---
 
-# Common Rules
+When PLAN, ACT, EVAL keywords detected → call `parse_mode` MCP tool
+```
+
+### Monorepo Contributors
 
-This project uses shared rules from `.ai-rules/` directory for all AI assistants.
+Contributors to the codingbuddy repository can use direct file references:
 
-## 📚 Core Rules
-See [../../.ai-rules/rules/core.md](../../.ai-rules/rules/core.md) for:
-- PLAN/ACT/EVAL workflow modes
-- Agent activation rules
-- Communication guidelines
+```
+Project Root/
+├── AGENTS.md                    # Cross-platform entry point
+├── .cursor/rules/
+│   ├── imports.mdc              # Common rules (alwaysApply: true)
+│   ├── auto-agent.mdc           # File pattern-based Agent auto-activation
+│   └── custom.mdc               # Personal settings (Git ignored)
+└── packages/rules/.ai-rules/    # Single Source of Truth
+```
 
-## 🏗️ Project Setup
-See [../../.ai-rules/rules/project.md](../../.ai-rules/rules/project.md) for:
-- Tech stack and dependencies
-- Project structure and architecture
-- Development rules and conventions
-- Domain knowledge and business context
+## DRY Principle
 
-## 🎯 Augmented Coding Principles
-See [../../.ai-rules/rules/augmented-coding.md](../../.ai-rules/rules/augmented-coding.md) for:
-- TDD cycle (Red → Green → Refactor)
-- Code quality standards (SOLID, DRY)
-- Testing best practices
-- Commit discipline
+**Single Source of Truth**: `packages/rules/.ai-rules/`
 
-## 🤖 Specialist Agents
-See [../../.ai-rules/agents/README.md](../../.ai-rules/agents/README.md) for available specialist agents:
-- Frontend Developer, Code Reviewer
-- Architecture, Test Strategy, Performance, Security
-- Accessibility, SEO, Design System, Documentation
-- Code Quality, DevOps Engineer
-```
+- All Agent definitions, rules, skills managed only in `.ai-rules/`
+- AGENTS.md and .mdc files act as **pointers only**
+- No duplication, only references
 
-### 2. Keep Cursor-Specific Features
+## Configuration Files
 
-Maintain `.cursor/rules/cursor-specific.mdc` for Cursor-only features:
+### imports.mdc (alwaysApply)
 
-```markdown
+Core rules automatically applied to all conversations:
+
+```yaml
 ---
-description: Cursor-specific configurations
+description: codingbuddy common rules
 globs:
 alwaysApply: true
 ---
 
-# Cursor-Specific Features
+# Core principles only (details in .ai-rules/)
+```
 
-## File Globbing
+### auto-agent.mdc (glob-based)
 
-[Add Cursor-specific glob patterns here]
+Automatically provides appropriate Agent context based on file patterns:
 
-## Agent Tool Integration
+```yaml
+---
+description: Agent auto-activation
+globs:
+  - "**/*.tsx"
+  - "**/*.ts"
+  - "**/*.go"
+alwaysApply: false
+---
 
-[Add Cursor-specific todo_write tool usage]
+# File pattern → Agent mapping table
 ```
 
-## Current Structure
+## Usage
 
-```
-.cursor/
-├── agents/              # Keep for Cursor compatibility
-├── rules/
-│   ├── core.mdc        # Keep existing (can add reference to .ai-rules)
-│   ├── project.mdc     # Keep existing (can add reference to .ai-rules)
-│   ├── augmented-coding.mdc  # Keep existing
-│   ├── imports.mdc     # NEW: References to .ai-rules
-│   └── cursor-specific.mdc   # NEW: Cursor-only features
-└── config.json         # Cursor configuration
+### Mode Keywords
 
-.ai-rules/              # Common rules for all AI tools
-├── rules/
-│   ├── core.md
-│   ├── project.md
-│   └── augmented-coding.md
-├── agents/
-│   └── *.json
-└── adapters/
-    └── cursor.md (this file)
+```
+PLAN Design user authentication feature
 ```
 
-## Usage
-
-### In Cursor Chat
+→ `parse_mode` MCP tool is called, loading appropriate Agent and rules
 
-Reference rules directly:
-```
-@.ai-rules/rules/core.md
-@.ai-rules/agents/frontend-developer.json
+### Auto-Activation on File Edit
 
-Create a new feature following our common workflow
-```
+Open `.tsx` file → `auto-agent.mdc` auto-applies → frontend-developer Agent recommended
 
-### In Cursor Composer
+### Specialist Usage
 
-The `.cursor/rules/imports.mdc` with `alwaysApply: true` will automatically apply common rules to all Composer sessions.
+```
+EVAL Review from security perspective
+```
 
-## Benefits
+→ security-specialist activated
 
-- ✅ Seamless integration with existing Cursor setup
-- ✅ Access to common rules shared across all AI tools
-- ✅ Cursor-specific features (globs, alwaysApply) still work
-- ✅ Easy to update: change `.ai-rules/` once, all tools benefit
+## MCP Tools
 
-## Maintenance
+Available codingbuddy MCP tools in Cursor:
 
-When updating rules:
-1. Update `.ai-rules/rules/*.md` for changes affecting all AI tools
-2. Update `.cursor/rules/*.mdc` only for Cursor-specific changes
-3. Keep both in sync for best experience
+| Tool | Purpose |
+|------|---------|
+| `parse_mode` | Parse mode keywords + load Agent/rules |
+| `get_agent_details` | Get specific Agent details |
+| `get_project_config` | Get project configuration |
+| `recommend_skills` | Recommend skills based on prompt |
+| `prepare_parallel_agents` | Prepare parallel Agent execution |
 
 ## Skills
 
 ### Using Skills in Cursor
 
-Reference skills in your prompts using file inclusion:
+Load skills via file reference (monorepo only):
 
 ```
-@.ai-rules/skills/test-driven-development/SKILL.md
+@packages/rules/.ai-rules/skills/test-driven-development/SKILL.md
 ```
 
-Or manually include skill content in `.cursorrules`.
+For end users, use `recommend_skills` MCP tool instead.
 
 ### Available Skills
 
-- `.ai-rules/skills/brainstorming/SKILL.md`
-- `.ai-rules/skills/test-driven-development/SKILL.md`
-- `.ai-rules/skills/systematic-debugging/SKILL.md`
-- `.ai-rules/skills/writing-plans/SKILL.md`
-- `.ai-rules/skills/executing-plans/SKILL.md`
-- `.ai-rules/skills/subagent-driven-development/SKILL.md`
-- `.ai-rules/skills/dispatching-parallel-agents/SKILL.md`
-- `.ai-rules/skills/frontend-design/SKILL.md`
+- `brainstorming/SKILL.md` - Idea → Design
+- `test-driven-development/SKILL.md` - TDD workflow
+- `systematic-debugging/SKILL.md` - Systematic debugging
+- `writing-plans/SKILL.md` - Implementation plan writing
+- `executing-plans/SKILL.md` - Plan execution
+- `subagent-driven-development/SKILL.md` - Subagent development
+- `dispatching-parallel-agents/SKILL.md` - Parallel Agent dispatch
+- `frontend-design/SKILL.md` - Frontend design
+
+## AGENTS.md
+
+Industry standard format compatible with all AI tools (Cursor, Claude Code, Codex, etc.):
+
+```markdown
+# AGENTS.md
+
+This project uses codingbuddy MCP server to manage AI Agents.
+
+## Quick Start
+...
+```
+
+See `AGENTS.md` in project root for details.
+
+## 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 feature
+```
+
+```
+자동 사용자 인증 기능 구현해줘
+```
+
+When AUTO keyword is detected, Cursor calls `parse_mode` MCP tool which returns AUTO mode instructions.
+
+### 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)
+
+### 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
+
+## Reference
+
+- [AGENTS.md Official Spec](https://agents.md)
+- [Cursor Rules Documentation](https://cursor.com/docs/context/rules)
+- [codingbuddy MCP API](../../docs/api.md)

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

@@ -29,7 +29,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
 - **Architecture**: Layered structure (app → widgets → features → entities → shared)
 - **Conventions**: File naming, import/export rules, pure/impure function separation
 
@@ -56,7 +56,7 @@ See `.ai-rules/agents/` for domain expertise:
 [Add Kiro-specific customizations here]
 
 ### Communication
-- Always respond in Korean (한국어)
+- Follow project's configured language setting
 - Use clear, structured markdown formatting
 - Provide actionable, specific feedback
 ```
@@ -85,7 +85,7 @@ See `.ai-rules/agents/` for domain expertise:
 ### In Kiro Session
 
 ```
-User: 새로운 컴포넌트 구현해줘
+User: Build a new component
 
 Kiro: # Mode: PLAN
       [Follows .ai-rules/rules/core.md workflow]
@@ -122,9 +122,75 @@ Kiro will generate code following:
 2. Update `.kiro/rules/guidelines.md` only for Kiro-specific features
 3. Common rules propagate automatically to all Kiro sessions
 
+## 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 새로운 컴포넌트 구현해줘
+
+Kiro: # Mode: AUTO (Iteration 1/3)
+      ## Phase: PLAN
+      [Follows .ai-rules/rules/core.md workflow]
+
+      ## Phase: ACT
+      [Executes with quality standards from .ai-rules]
+
+      ## Phase: EVAL
+      [Evaluates against 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)
+
+### 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
+
 ## Getting Started
 
 1. Ensure `.ai-rules/` directory exists with all common rules
 2. Create `.kiro/rules/guidelines.md` with content above
 3. Start a Kiro session - it will automatically reference common rules
-4. Use PLAN/ACT/EVAL workflow as defined in `.ai-rules/rules/core.md`
+4. Use PLAN/ACT/EVAL/AUTO workflow as defined in `.ai-rules/rules/core.md`

package/.ai-rules/adapters/opencode-skills.md

@@ -50,24 +50,24 @@ OpenCode/Crush supports Agent Skills standard for structured AI capabilities. Th
 ### 1. Direct Skill Invocation
 ```bash
 # In OpenCode CLI
-/skill brainstorming "새로운 기능 아이디어"
-/skill tdd "사용자 인증 구현"
-/skill debug "로그인 버그 해결"
+/skill brainstorming "new feature ideas"
+/skill tdd "user authentication implementation"
+/skill debug "fix login bug"
 ```
 
 ### 2. Agent + Skill Combination
 ```bash
 # Planning with brainstorming skill
 /agent plan
-/skill brainstorming "대시보드 UI 개선"
+/skill brainstorming "improve dashboard UI"
 
-# Implementation with TDD skill  
+# Implementation with TDD skill
 /agent build
-/skill tdd "API 연동 구현"
+/skill tdd "implement API integration"
 
 # Review with debugging skill
 /agent reviewer
-/skill debug "성능 이슈 분석"
+/skill debug "analyze performance issues"
 ```
 
 ### 3. Automatic Skill Recommendation
@@ -76,9 +76,9 @@ OpenCode can automatically recommend skills based on prompts using the `recommen
 
 ```typescript
 // Auto-triggered when user enters certain keywords
-"버그가 있어" → recommends: systematic-debugging
-"계획을 세워줘" → recommends: writing-plans  
-"UI를 만들어줘" → recommends: frontend-design
+"there's a bug" → recommends: systematic-debugging
+"create a plan" → recommends: writing-plans
+"build the UI" → recommends: frontend-design
 ```
 
 ## Skill Conversion Process
@@ -201,20 +201,20 @@ The MCP server handles Korean→English skill name mapping automatically.
 /agent plan
 
 # Use brainstorming skill
-/skill brainstorming "사용자 대시보드 개선"
+/skill brainstorming "improve user dashboard"
 
 # Generate implementation plan
-계획을 세워줘
+Create a plan for me
 ```
 
 ### Implementing with TDD
 
-```bash  
+```bash
 # Switch to build agent
 /agent build
 
 # Load TDD skill
-/skill test-driven-development "로그인 API 구현"
+/skill test-driven-development "implement login API"
 
 # Start TDD cycle
 ACT
@@ -224,10 +224,10 @@ ACT
 
 ```bash
 # Use systematic debugging
-/skill systematic-debugging "로그인 후 화면이 안 나와"
+/skill systematic-debugging "screen not showing after login"
 
 # Apply debugging methodology
-디버깅해줘
+Debug this for me
 ```
 
 ## Benefits

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

@@ -220,16 +220,16 @@ The `parse_mode` tool now returns additional Mode Agent information and dynamic
 ```json
 {
   "mode": "PLAN",
-  "originalPrompt": "새로운 사용자 등록 기능을 만들어줘",
-  "instructions": "설계 우선 접근. TDD 관점에서...",
+  "originalPrompt": "Build a new user registration feature",
+  "instructions": "Design-first approach. From TDD perspective...",
   "rules": [...],
-  "language": "ko",
-  "languageInstruction": "Always respond in Korean (한국어).",
+  "language": "en",
+  "languageInstruction": "Always respond in English.",
   "agent": "plan-mode",
-  "delegates_to": "frontend-developer", 
+  "delegates_to": "frontend-developer",
   "delegate_agent_info": {
     "name": "Frontend Developer",
-    "description": "React/Next.js 전문가, TDD 및 디자인 시스템 경험",
+    "description": "React/Next.js expert, TDD and design system experience",
     "expertise": ["React", "Next.js", "TDD", "TypeScript"]
   }
 }
@@ -255,11 +255,11 @@ The `parse_mode` tool now returns additional Mode Agent information and dynamic
 /agent plan-mode
 
 # Then in chat
-새로운 사용자 등록 기능을 만들어줘
+Build a new user registration feature
 ```
 
 **Plan-mode agent will:**
-- Analyze requirements (Korean response)
+- Analyze requirements
 - Create structured implementation plan
 - Generate todo list using todo_write tool
 - Reference .ai-rules for consistent standards
@@ -477,7 +477,7 @@ npx codingbuddy@latest mcp
 ```bash
 # Terminal 1: Planning
 opencode --agent plan-mode
-계획을 세워줘
+Create a plan for me
 
 # Terminal 2: Implementation  
 opencode --agent act-mode
@@ -514,10 +514,10 @@ EVAL
 ```bash
 # 1. Start planning
 /agent plan-mode
-React 컴포넌트 라이브러리를 만들어줘
+Build a React component library
 
 # 2. Implement
-/agent act-mode  
+/agent act-mode
 ACT
 
 # 3. Review
@@ -526,7 +526,7 @@ EVAL
 
 # 4. Optimize
 /agent performance
-성능 최적화 제안해줘
+Suggest performance optimizations
 ```
 
 ### Full-Stack Development
@@ -534,16 +534,107 @@ EVAL
 ```bash
 # Frontend work
 /agent plan-mode
-사용자 대시보드 UI 계획
+Plan user dashboard UI
 
-# Backend work  
+# Backend work
 /agent backend
-API 엔드포인트 구현
+Implement API endpoint
 
 # Security review
 /agent security
-보안 취약점 검사
+Check security vulnerabilities
+```
+
+## 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
+
+```bash
+# Start AUTO mode
+/agent plan-mode
+AUTO Build a new user authentication feature
+```
+
+### Workflow
+
+1. **PLAN Phase**: Creates implementation plan with quality criteria (read-only)
+2. **ACT Phase**: Executes implementation following TDD workflow (full permissions)
+3. **EVAL Phase**: Evaluates quality against exit criteria (read-only)
+4. **Loop/Exit**: Continues cycling until:
+   - Success: `Critical = 0 AND High = 0`
+   - Failure: Max iterations reached (default: 3)
+
+### OpenCode Agent Integration
+
+AUTO mode automatically switches between agents:
+
 ```
+AUTO detected
+    ↓
+plan-mode agent (PLAN phase)
+    ↓
+act-mode agent (ACT phase)
+    ↓
+eval-mode agent (EVAL phase)
+    ↓
+[Check quality criteria]
+    ↓
+Loop or Exit
+```
+
+### Configuration
+
+Configure in `codingbuddy.config.js`:
+
+```javascript
+module.exports = {
+  auto: {
+    maxIterations: 3
+  }
+};
+```
+
+### AUTO Mode Output Format
+
+```
+# Mode: AUTO (Iteration 1/3)
+
+## Phase: PLAN
+[Planning with plan-mode agent...]
+
+## Phase: ACT
+[Implementation with act-mode agent...]
+
+## Phase: EVAL
+[Evaluation with eval-mode agent...]
+
+### Quality Status
+- Critical: 0
+- High: 0
+
+✅ AUTO mode completed successfully!
+```
+
+### 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
 
 ---