codingbuddy-rules 0.0.0-canary.20251222065027.7844cd5

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

@@ -0,0 +1,124 @@
+# GitHub Copilot / Codex Integration Guide
+
+This guide explains how to use the common AI rules (`.ai-rules/`) with GitHub Copilot and Codex.
+
+## Overview
+
+GitHub Copilot can use custom instructions from `.github/` or `.codex/` directory.
+
+## Integration Method
+
+### Option 1: Using .github/copilot-instructions.md
+
+Create `.github/copilot-instructions.md`:
+
+```markdown
+# GitHub Copilot Custom Instructions
+
+## Common AI Rules
+
+This project uses shared rules from `.ai-rules/` directory.
+
+### Workflow (PLAN/ACT/EVAL)
+Refer to `.ai-rules/rules/core.md` for detailed workflow guidance.
+
+### Tech Stack & Project Structure
+- See `.ai-rules/rules/project.md` for complete project setup
+- Refer to project's package.json
+- Layered architecture: app → widgets → features → entities → shared
+
+### Coding Standards
+- See `.ai-rules/rules/augmented-coding.md`
+- TDD for core logic, test-after for UI
+- SOLID principles, 90%+ test coverage
+- No mocking, test real behavior
+
+### Specialist Knowledge
+- Refer to `.ai-rules/agents/*.json` for domain-specific guidance
+```
+
+### Option 2: Using .codex/ directory (Recommended)
+
+This project includes a pre-configured `.codex/rules/system-prompt.md` file.
+
+**Included features:**
+- Common AI rules reference from `.ai-rules/`
+- PLAN/ACT/EVAL workflow modes
+- Keyword Invocation support
+- TDD and code quality guidelines
+- Specialist agents reference
+
+**File location**: `.codex/rules/system-prompt.md`
+
+See [docs/codex-adapter-configuration.md](../../docs/codex-adapter-configuration.md) for detailed configuration guide.
+
+## Directory Structure
+
+```
+.codex/
+└── rules/
+    └── system-prompt.md    # Codex system prompt (pre-configured)
+
+.github/
+└── copilot-instructions.md  # GitHub Copilot instructions (optional)
+
+.ai-rules/                   # Common rules for all AI tools
+├── rules/
+│   ├── core.md
+│   ├── project.md
+│   └── augmented-coding.md
+├── agents/
+│   └── *.json
+└── adapters/
+    └── codex.md             # This guide
+```
+
+## Configuration Guide
+
+For detailed setup instructions, see:
+- **Quick Start**: [docs/codex-adapter-configuration.md](../../docs/codex-adapter-configuration.md)
+- **Keyword Invocation**: [docs/keyword-invocation.md](../../docs/keyword-invocation.md)
+
+## Usage
+
+### In GitHub Copilot Chat
+
+```
+You: Implement new feature following our TDD workflow
+
+Copilot: [References .ai-rules/rules/augmented-coding.md]
+         [Follows project structure from .ai-rules/rules/project.md]
+```
+
+### In Code Completions
+
+Copilot will use context from:
+- `.ai-rules/rules/project.md` for naming conventions
+- `.ai-rules/rules/augmented-coding.md` for code quality patterns
+- Existing codebase structure
+
+## GitHub Copilot Workspace Integration
+
+When using Copilot Workspace:
+1. It automatically reads `.github/copilot-instructions.md`
+2. Can reference `.ai-rules/` files for detailed context
+3. Applies rules across all generated code
+
+## Benefits
+
+- ✅ Better code suggestions aligned with project standards
+- ✅ Consistent with other AI tools (Cursor, Claude, etc.)
+- ✅ Leverages GitHub's integration
+- ✅ Easy to maintain
+
+## Limitations
+
+- GitHub Copilot has shorter context compared to chat-based tools
+- Instructions must be concise
+- Best used as reference + code completion, not full workflow execution
+
+## Maintenance
+
+1. Update `.ai-rules/rules/*.md` for universal rule changes
+2. Keep `.github/copilot-instructions.md` concise (Copilot's context limit)
+3. Link to detailed rules in `.ai-rules/` rather than duplicating

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

@@ -0,0 +1,128 @@
+# Cursor Integration Guide
+
+This guide explains how to use the common AI rules (`.ai-rules/`) in Cursor.
+
+## Overview
+
+Cursor continues to use its native `.cursor/` directory structure while referencing the common rules from `.ai-rules/`.
+
+## Integration Method
+
+### 1. Reference Common Rules
+
+Create `.cursor/rules/imports.mdc` to reference common rules:
+
+```markdown
+---
+description: Common AI Rules Import
+globs:
+alwaysApply: true
+---
+
+# Common Rules
+
+This project uses shared rules from `.ai-rules/` directory for all AI assistants.
+
+## 📚 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 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
+
+## 🎯 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
+
+## 🤖 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
+```
+
+### 2. Keep Cursor-Specific Features
+
+Maintain `.cursor/rules/cursor-specific.mdc` for Cursor-only features:
+
+```markdown
+---
+description: Cursor-specific configurations
+globs:
+alwaysApply: true
+---
+
+# Cursor-Specific Features
+
+## File Globbing
+
+[Add Cursor-specific glob patterns here]
+
+## Agent Tool Integration
+
+[Add Cursor-specific todo_write tool usage]
+```
+
+## Current Structure
+
+```
+.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
+
+.ai-rules/              # Common rules for all AI tools
+├── rules/
+│   ├── core.md
+│   ├── project.md
+│   └── augmented-coding.md
+├── agents/
+│   └── *.json
+└── adapters/
+    └── cursor.md (this file)
+```
+
+## Usage
+
+### In Cursor Chat
+
+Reference rules directly:
+```
+@.ai-rules/rules/core.md
+@.ai-rules/agents/frontend-developer.json
+
+Create a new feature following our common workflow
+```
+
+### In Cursor Composer
+
+The `.cursor/rules/imports.mdc` with `alwaysApply: true` will automatically apply common rules to all Composer sessions.
+
+## Benefits
+
+- ✅ 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
+
+## Maintenance
+
+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

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

@@ -0,0 +1,130 @@
+# Kiro Integration Guide
+
+This guide explains how to use the common AI rules (`.ai-rules/`) with Kiro.
+
+## Overview
+
+Kiro uses the `.kiro/` directory for custom guidelines and configuration.
+
+## Integration Method
+
+### Create Kiro Configuration
+
+Create `.kiro/rules/guidelines.md`:
+
+```markdown
+# Kiro Guidelines
+
+## Common AI Rules
+
+This project uses shared coding rules from `.ai-rules/` for consistency across all AI coding assistants.
+
+### Workflow Reference
+
+See `.ai-rules/rules/core.md` for:
+- **PLAN mode**: Create implementation plans with TDD approach
+- **ACT mode**: Execute changes following quality standards
+- **EVAL mode**: Evaluate code quality and suggest improvements
+
+### Project Context
+
+See `.ai-rules/rules/project.md` for:
+- **Tech Stack**: 프로젝트의 package.json 참조
+- **Architecture**: Layered structure (app → widgets → features → entities → shared)
+- **Conventions**: File naming, import/export rules, pure/impure function separation
+
+### Coding Principles
+
+See `.ai-rules/rules/augmented-coding.md` for:
+- **TDD Cycle**: Red (failing test) → Green (minimal code) → Refactor
+- **Quality Standards**: SOLID principles, DRY, code complexity management
+- **Testing**: 90%+ coverage goal, no mocking, real behavior testing
+- **Commit Discipline**: Separate structural and behavioral changes
+
+### Specialist Knowledge
+
+See `.ai-rules/agents/` for domain expertise:
+- Frontend Development (React/Next.js, TDD, design system)
+- Code Review (quality evaluation, architecture analysis)
+- Security (OAuth 2.0, JWT, XSS/CSRF protection)
+- Performance (bundle optimization, rendering)
+- Accessibility (WCAG 2.1 AA compliance)
+- And more...
+
+## Kiro-Specific Features
+
+[Add Kiro-specific customizations here]
+
+### Communication
+- Always respond in Korean (한국어)
+- Use clear, structured markdown formatting
+- Provide actionable, specific feedback
+```
+
+## Directory Structure
+
+```
+.kiro/
+├── rules/
+│   └── guidelines.md  # References .ai-rules
+└── config.json        # Kiro configuration (optional)
+
+.ai-rules/
+├── rules/
+│   ├── core.md
+│   ├── project.md
+│   └── augmented-coding.md
+├── agents/
+│   └── *.json
+└── adapters/
+    └── kiro.md  # This guide
+```
+
+## Usage
+
+### In Kiro Session
+
+```
+User: 새로운 컴포넌트 구현해줘
+
+Kiro: # Mode: PLAN
+      [Follows .ai-rules/rules/core.md workflow]
+      [References .ai-rules/rules/project.md for structure]
+      [Applies .ai-rules/rules/augmented-coding.md TDD]
+
+User: ACT
+
+Kiro: # Mode: ACT
+      [Executes with quality standards from .ai-rules]
+```
+
+### Code Generation
+
+Kiro will generate code following:
+- Project structure from `.ai-rules/rules/project.md`
+- Code quality patterns from `.ai-rules/rules/augmented-coding.md`
+- Specialist knowledge from `.ai-rules/agents/*.json`
+
+## Benefits
+
+- ✅ Consistent standards across all AI tools (Cursor, Claude, Antigravity, Q, etc.)
+- ✅ Well-defined workflow and quality expectations
+- ✅ Access to specialist domain knowledge
+- ✅ Easy maintenance: update `.ai-rules/` once, all tools benefit
+
+## Kiro-Specific Advantages
+
+[Document Kiro's unique capabilities here and how they complement common rules]
+
+## Maintenance
+
+1. Update `.ai-rules/rules/*.md` for changes affecting all AI tools
+2. Update `.kiro/rules/guidelines.md` only for Kiro-specific features
+3. Common rules propagate automatically to all Kiro sessions
+
+## 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`

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

@@ -0,0 +1,126 @@
+# Amazon Q Integration Guide
+
+This guide explains how to use the common AI rules (`.ai-rules/`) with Amazon Q Developer.
+
+## Overview
+
+Amazon Q uses the `.q/` directory or AWS-specific configuration for custom instructions.
+
+## Integration Method
+
+### Create Amazon Q Configuration
+
+Create `.q/rules/customizations.md`:
+
+```markdown
+# Amazon Q Customizations
+
+## Common AI Rules
+
+This project follows shared coding rules from `.ai-rules/` for consistency across all AI assistants.
+
+### Workflow Modes (PLAN/ACT/EVAL)
+
+Refer to `.ai-rules/rules/core.md` for:
+- PLAN: Create implementation plans
+- ACT: Execute code changes
+- EVAL: Quality assessment and improvements
+
+### Project Setup
+
+Refer to `.ai-rules/rules/project.md` for:
+- **Tech Stack**: 프로젝트의 package.json 참조
+- **Architecture**: Layered structure (app → widgets → features → entities → shared)
+- **Development Rules**: File naming, import/export conventions
+
+### Coding Standards
+
+Refer to `.ai-rules/rules/augmented-coding.md` for:
+- **TDD Workflow**: Red → Green → Refactor
+- **Code Quality**: SOLID principles, DRY, 90%+ coverage
+- **Testing**: No mocking, test real behavior
+
+### Specialist Expertise
+
+Refer to `.ai-rules/agents/*.json` for domain-specific knowledge:
+- Frontend development patterns
+- Security best practices
+- Performance optimization
+- Accessibility guidelines
+
+## Amazon Q Specific Features
+
+### AWS Integration
+- Leverage Q's AWS knowledge for deployment
+- Use Q's security scanning with our security rules
+- Apply Q's cost optimization suggestions
+
+### Language Support
+- Respond in Korean (한국어) as per project standard
+- Use technical Korean terminology
+```
+
+## Directory Structure
+
+```
+.q/
+├── rules/
+│   └── customizations.md  # References .ai-rules
+└── config.json            # Q configuration (optional)
+
+.ai-rules/
+├── rules/
+│   ├── core.md
+│   ├── project.md
+│   └── augmented-coding.md
+├── agents/
+│   └── *.json
+└── adapters/
+    └── q.md  # This guide
+```
+
+## Usage
+
+### In Amazon Q Chat
+
+```
+You: 새로운 API 엔드포인트 만들어줘
+
+Q: [Follows .ai-rules/rules/core.md workflow]
+   [Applies .ai-rules/rules/augmented-coding.md TDD]
+   [Uses .ai-rules/rules/project.md structure]
+```
+
+### Code Suggestions
+
+Amazon Q will provide suggestions based on:
+- Your project structure from `.ai-rules/rules/project.md`
+- Code quality patterns from `.ai-rules/rules/augmented-coding.md`
+- Language/framework idioms from specialist agents
+
+## Benefits
+
+- ✅ Consistent rules across all AI tools
+- ✅ AWS-specific guidance when needed
+- ✅ Security and cost optimization aligned with project standards
+- ✅ Easy updates via `.ai-rules/`
+
+## AWS-Specific Considerations
+
+### When Using Q for AWS Services
+
+Amazon Q excels at:
+- AWS service integration (S3, Lambda, DynamoDB, etc.)
+- Infrastructure as Code (CDK, CloudFormation)
+- Security best practices for AWS
+
+Combine Q's AWS expertise with project rules:
+- Use `.ai-rules/agents/security-specialist.json` for general security
+- Let Q provide AWS-specific security guidance
+- Apply `.ai-rules/agents/devops-engineer.json` for deployment patterns
+
+## Maintenance
+
+1. Update `.ai-rules/rules/*.md` for universal changes
+2. Update `.q/rules/customizations.md` for Q-specific enhancements
+3. Leverage Q's AWS knowledge alongside project standards