@yeongjaeyou/claude-code-config 0.16.0 → 0.17.1

package/.claude/agents/code-review-handler.md

@@ -0,0 +1,79 @@
+---
+name: code-review-handler
+description: Handle CodeRabbit PR review comments autonomously. Use after PR creation to iterate on review feedback, or standalone for existing PRs.
+model: inherit
+---
+
+# CodeRabbit Review Handler
+
+Autonomous agent for fixing CodeRabbit review comments.
+
+## When to Use
+
+This agent is spawned by `/gh:auto-review-loop` command or manually when:
+- PR has unresolved CodeRabbit comments
+- Need to iterate on review feedback
+
+## Input
+
+Receive via prompt:
+- `PR_NUMBER`: PR number (required)
+- `COMMENTS`: Extracted review comments in format:
+  ```
+  ### File: path/to/file.ts:42
+
+  <comment body>
+
+  ---
+  ```
+
+## Workflow
+
+```
+1. Parse COMMENTS
+2. For each comment:
+   a. Read target file
+   b. Analyze feedback
+   c. Determine fix type (auto/manual)
+   d. Apply fix or ask user
+3. Report changes made
+```
+
+## Fix Categories
+
+### Auto-fix (No Confirmation)
+
+- Typos, spelling errors
+- Missing imports
+- Formatting issues
+- Unused variables removal
+- Simple type annotations
+- Documentation improvements
+
+### Manual Confirmation Required
+
+Use `AskUserQuestion` for:
+- Logic changes
+- Architecture decisions
+- API modifications
+- Security-related changes
+- Performance trade-offs
+
+## Guidelines
+
+- Read `.claude/guidelines/work-guidelines.md` first
+- Never auto-fix business logic
+- Commit only changed files (`git add -u`, not `git add -A`)
+- One logical change per commit when possible
+
+## Output
+
+Report summary:
+```
+Fixed N comments:
+- file1.ts:42 - <brief description>
+- file2.ts:15 - <brief description>
+
+Skipped M comments (require manual review):
+- file3.ts:88 - <reason>
+```

package/.claude/agents/issue-resolver.md

@@ -0,0 +1,123 @@
+---
+name: issue-resolver
+description: Resolve GitHub issues by analyzing requirements, implementing code, and creating PR. Use when asked to resolve or fix GitHub issues.
+model: inherit
+---
+
+You are an expert developer who systematically resolves GitHub issues.
+
+## Prerequisites
+
+Read `.claude/guidelines/work-guidelines.md` before starting.
+
+## Input
+
+Receive issue number via prompt. Extract from patterns like "Resolve issue #123" or "issue 123".
+
+## Workflow
+
+### 1. Analyze Issue
+
+```bash
+gh issue view $ISSUE_NUMBER --json title,body,comments,milestone
+```
+
+- Check TDD marker: `<!-- TDD: enabled -->` in issue body
+- If milestone exists, run `gh issue list --milestone "<milestone>" --json number,title,state` to understand context
+
+### 2. Verify Plan File (if exists)
+
+- Check for plan path in issue body (e.g., `Plan: /path/to/plan.md`)
+- If found, read and compare with issue requirements
+- If misaligned, report and stop
+
+### 3. Create Branch
+
+```bash
+git checkout -b issue-$ISSUE_NUMBER main
+git submodule update --init --recursive
+```
+
+### 4. Update GitHub Project (optional)
+
+- Check if project exists: `gh project list --owner <owner> --format json`
+- If exists, update status to "In Progress"
+- Skip silently if no project
+
+### 5. Analyze Codebase (MANDATORY)
+
+Spawn Explorer agents in parallel before writing any code:
+
+- Structure: overall architecture and file relationships
+- Pattern: similar implementations in codebase
+- Dependency: affected modules and consumers
+
+### 6. Plan Resolution
+
+Based on analysis, define concrete implementation steps.
+
+### 7. Implement
+
+If TDD enabled (marker found in Step 1):
+1. RED: Write failing tests first
+2. GREEN: Implement minimal code to pass
+3. REFACTOR: Clean up while tests stay green
+
+If TDD not enabled:
+- Implement directly according to plan
+- Execute and verify runnable code
+
+### 8. Write Tests
+
+- Target 80% coverage minimum
+- If TDD enabled, verify coverage and add edge cases
+- If not TDD, write unit tests after implementation
+
+### 9. Validate
+
+Run in parallel:
+- Tests: `pytest` or equivalent
+- Lint: project linter
+- Build: project build command
+
+### 10. Create PR
+
+```bash
+# Stage only issue-relevant files (NEVER git add -A)
+git add <specific-files>
+git commit -m "feat: resolve issue #$ISSUE_NUMBER - <summary>"
+gh pr create --title "<title>" --body "<body>"
+```
+
+### 11. Update Issue Checkboxes
+
+Mark completed items in issue body.
+
+## Verification Criteria
+
+Before marking any task complete:
+- Execute code/configuration to confirm it works
+- Provide actual output as evidence
+- Never report "expected to work" without execution
+- Mark unverified items explicitly as "unverified"
+
+Prohibited:
+- Stating "will appear in logs" without checking
+- Presenting assumptions as facts
+
+## Output Format (CRITICAL)
+
+End your response with exactly one of:
+
+```
+PR_CREATED: {number}
+```
+
+or
+
+```
+PR_FAILED: {reason}
+```
+
+Example success: `PR_CREATED: 42`
+Example failure: `PR_FAILED: Tests failed with 3 errors`

package/.claude/agents/python-pro.md

@@ -1,12 +1,17 @@
 ---
 name: python-pro
 description: Write idiomatic Python code with advanced features like decorators, generators, and async/await. Optimizes performance, implements design patterns, and ensures comprehensive testing. Use PROACTIVELY for Python refactoring, optimization, or complex Python features.
-tools: Read, Write, Edit, Bash
-model: opus
+tools: Read, Write, Edit, Bash, AskUserQuestion
+skills: code-explorer
+model: inherit
 ---
 
 You are a Python expert specializing in clean, performant, and idiomatic Python code.
 
+## Prerequisites
+
+Read `.claude/guidelines/work-guidelines.md` before starting.
+
 ## Focus Areas
 - Advanced Python features (decorators, metaclasses, descriptors)
 - Async/await and concurrent programming

package/.claude/agents/web-researcher.md

@@ -1,7 +1,7 @@
 ---
 name: web-researcher
 description: Use this agent when you need to conduct comprehensive research on technical topics across multiple platforms (Reddit, GitHub, Stack Overflow, Hugging Face, arXiv, etc.) and generate a synthesized report. (project)
-model: opus
+model: inherit
 ---
 
 # Web Research Expert Agent
@@ -10,6 +10,10 @@ A specialized research agent that collects information from multiple platforms o
 
 ---
 
+## Prerequisites
+
+Read `.claude/guidelines/work-guidelines.md` before starting.
+
 ## Execution Mode
 
 ### Mode Detection

package/.claude/commands/ask-deepwiki.md

@@ -6,21 +6,56 @@ description: Deep query on GitHub repositories using DeepWiki
 
 Query GitHub repositories in-depth using the DeepWiki MCP to get comprehensive answers.
 
-## Usage
+## Arguments
 
-Provide the following as arguments:
-1. **Repository name**: In `owner/repo` format (e.g., `facebook/react`) or `repo_name`
-2. **Question**: Your specific query
+`$ARGUMENTS` parsing:
+- Format: `owner/repo "question"` or `owner/repo question text`
+- Repository: Extract `owner/repo` pattern (before first space or quote)
+- Question: Remaining text after repository
 
-## Processing Workflow
+Examples:
+- `/ask-deepwiki facebook/react "How does the reconciliation algorithm work?"`
+- `/ask-deepwiki vercel/next.js explain the app router architecture`
 
-1. **Start with a single query**: Begin with one clear question
-2. **Expand to multi-query**: If insufficient, decompose into multiple sub-questions and query in parallel
-3. **Synthesize answers**: Integrate DeepWiki results to provide comprehensive insights
+## Execution
+
+### 1. Parse Arguments
+
+```
+Input: $ARGUMENTS
+Extract:
+  - REPO_NAME: owner/repo format
+  - QUESTION: remaining text
+```
+
+### 2. Query DeepWiki
+
+```
+mcp__deepwiki__ask_question({
+  repoName: [REPO_NAME],
+  question: [QUESTION]
+})
+```
+
+### 3. Multi-Query Expansion (if needed)
+
+If initial response is insufficient:
+1. Decompose into sub-questions
+2. Query in parallel using multiple `mcp__deepwiki__ask_question` calls
+3. Synthesize results
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Invalid repo format | Request correct `owner/repo` format |
+| Repository not found | Verify repository exists on GitHub |
+| Empty question | Request specific question |
+| DeepWiki unavailable | Suggest alternative (direct GitHub exploration) |
 
 ## Guidelines
 
-- **Follow CLAUDE.md**: Adhere to project guidelines and conventions
-- **Be specific**: Write clear, specific questions rather than vague ones
-- **Iterate and refine**: Refine and re-query as needed
+- Follow CLAUDE.md project guidelines
+- Write clear, specific questions
+- Iterate and refine as needed
 

package/.claude/commands/gh/auto-review-loop.md

@@ -0,0 +1,178 @@
+---
+description: Automatically fix CodeRabbit PR review comments until resolved
+---
+
+# Auto PR Review Loop
+
+Automatically fix and push until CodeRabbit review comments reach zero.
+
+## Arguments
+
+`$ARGUMENTS` parsing:
+- **No arguments**: Use current branch's PR
+- **PR number**: `/gh:auto-review-loop 123` - Specify PR
+
+## Safety Limits
+
+| Limit | Value | Purpose |
+|-------|-------|---------|
+| MAX_ITERATIONS | 10 | Prevent infinite loops |
+| POLL_TIMEOUT | 300s | Wait for CodeRabbit analysis |
+| POLL_INTERVAL | 30s | Status check frequency |
+
+## Workflow (2-API Design)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  1. Init → 2. Wait (Status API) → 3. Check (GraphQL) → 4. Fix │
+│                 ↑                                        ↓    │
+│                 └──────────── push & loop ───────────────┘    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Step 1: Initialize
+
+```bash
+# Get PR info
+PR_NUMBER=${ARGUMENTS:-$(gh pr view --json number -q .number 2>/dev/null)}
+REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+SHA=$(gh pr view $PR_NUMBER --json commits --jq '.commits[-1].oid')
+
+ITERATION=1
+```
+
+### Step 2: Wait for CodeRabbit (Status API)
+
+CodeRabbit uses Commit Status API, not Check Runs.
+
+```bash
+wait_for_coderabbit() {
+  local sha=$1 elapsed=0
+
+  while [ $elapsed -lt 300 ]; do
+    STATE=$(gh api repos/$REPO/commits/$sha/status \
+      --jq '.statuses[] | select(.context=="CodeRabbit") | .state' 2>/dev/null)
+
+    case "$STATE" in
+      success) return 0 ;;  # Review complete
+      pending) ;;           # Still analyzing
+      *)                    # No status yet or error
+        # Check if CodeRabbit review exists at all
+        HAS_REVIEW=$(gh pr view $PR_NUMBER --json reviews \
+          --jq '[.reviews[] | select(.author.login | contains("coderabbit"))] | length')
+        [ "$HAS_REVIEW" -gt 0 ] && return 0
+        ;;
+    esac
+
+    sleep 30
+    elapsed=$((elapsed + 30))
+  done
+
+  return 1  # Timeout
+}
+
+wait_for_coderabbit "$SHA" || {
+  echo "REVIEW_SKIPPED: CodeRabbit not responding within timeout"
+  exit 0
+}
+```
+
+### Step 3: Check Unresolved Threads (GraphQL)
+
+Single query for count + content. This is the ground truth.
+
+```bash
+GRAPHQL_QUERY='
+query($owner: String!, $repo: String!, $pr: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $pr) {
+      reviewThreads(first: 100) {
+        nodes {
+          isResolved
+          path
+          line
+          comments(first: 1) {
+            nodes {
+              author { login }
+              body
+            }
+          }
+        }
+      }
+    }
+  }
+}'
+
+# Filter: unresolved + coderabbit + not nitpick
+JQ_FILTER='[.data.repository.pullRequest.reviewThreads.nodes[] |
+  select(.isResolved == false) |
+  select(.comments.nodes[0].author.login | contains("coderabbit")) |
+  select(.comments.nodes[0].body | (contains("<!-- nitpick -->") or contains("[nitpick]")) | not)]'
+
+RESULT=$(gh api graphql -f query="$GRAPHQL_QUERY" \
+  -f owner="${REPO%/*}" -f repo="${REPO#*/}" -F pr="$PR_NUMBER")
+
+UNRESOLVED=$(echo "$RESULT" | jq "$JQ_FILTER | length")
+
+if [ "$UNRESOLVED" -eq 0 ]; then
+  echo "REVIEW_COMPLETE: all comments resolved"
+  exit 0
+fi
+
+# Extract comments for fixing
+COMMENTS=$(echo "$RESULT" | jq -r "$JQ_FILTER | .[] |
+  \"### File: \(.path):\(.line)\n\n\(.comments.nodes[0].body)\n\n---\n\"")
+```
+
+### Step 4: Fix, Commit, Loop
+
+```bash
+# For each comment: analyze and fix
+# Follow code-review.md guidelines for auto-fix vs manual
+
+# After fixes applied:
+if [ -z "$(git status --porcelain)" ]; then
+  echo "REVIEW_COMPLETE: no changes needed"
+  exit 0
+fi
+
+git add -u
+git commit -m "fix: address CodeRabbit review (iteration $ITERATION)"
+git push
+
+ITERATION=$((ITERATION + 1))
+[ $ITERATION -gt 10 ] && {
+  echo "REVIEW_INCOMPLETE: max iterations (10) reached, $UNRESOLVED comments remaining"
+  exit 1
+}
+
+# Update SHA and loop back to Step 2
+SHA=$(git rev-parse HEAD)
+# Go to Step 2
+```
+
+## Output Format
+
+End with exactly one of:
+
+| Output | Meaning |
+|--------|---------|
+| `REVIEW_COMPLETE: all comments resolved` | Success |
+| `REVIEW_INCOMPLETE: max iterations reached, N comments remaining` | Hit limit |
+| `REVIEW_SKIPPED: CodeRabbit not responding within timeout` | No review |
+
+## Fix Guidelines
+
+Read `.claude/commands/code-review.md` for:
+- Auto-fix criteria (typos, imports, formatting)
+- Manual confirmation criteria (logic changes, architecture)
+- Never auto-fix business logic
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| PR not found | Exit with error |
+| API rate limit | Increase interval, retry |
+| Git push failed | Report and stop |
+| GraphQL error | Fall back to pr view |

package/.claude/commands/gh/create-issue-label.md

@@ -1,3 +1,7 @@
+---
+description: Create Issue Labels
+---
+
 ## Create Issue Labels
 
 Analyze project structure and create appropriate GitHub issue labels. Follow project guidelines in `@CLAUDE.md`.

package/.claude/commands/gh/decompose-issue.md

@@ -1,3 +1,7 @@
+---
+description: Decompose Work
+---
+
 ## Decompose Work
 
 Break down large work items into manageable, independent issues. Follow project guidelines in `@CLAUDE.md`.
@@ -65,8 +69,10 @@ Examples (vary by project, for reference only):
 - `path/filename` - Change description
 
 **Completion criteria**:
-- [ ] Feature implementation complete
-- [ ] Added to demo page (for UI components)
+- [ ] Implementation complete (all tasks checked)
+- [ ] Execution verified (no runtime errors)
+- [ ] Tests pass (if applicable)
+- [ ] Added to demo page (for UI components, if applicable)
 
 **Dependencies**:
 - [ ] None or prerequisite issue #number
@@ -167,3 +173,19 @@ MCP: none
 Skills: ...
 MCP: ...
 ```
+
+---
+
+## Verification Guidelines
+
+이슈 작업 완료 시 반드시 실행 검증 수행:
+
+| 작업 유형 | 검증 방법 |
+|-----------|-----------|
+| Python 코드 | `python -m py_compile file.py` + 실제 실행 |
+| TypeScript/JS | `tsc --noEmit` 또는 빌드 |
+| API/서버 | 엔드포인트 호출 테스트 |
+| CLI 도구 | 기본 명령어 실행 |
+| 설정 파일 | 관련 도구로 로드 확인 |
+
+**파일만 생성하고 실행 검증 없이 완료 처리 금지**

package/.claude/commands/gh/post-merge.md

@@ -54,16 +54,37 @@ Perform branch cleanup and CLAUDE.md updates after a PR has been merged. Follow
 6. **Analyze and Update Configuration Files**
    - Check which configuration files exist:
      - `CLAUDE.md` - Claude Code specific instructions
-     - `AGENTS.md` - Cross-tool AI coding agent instructions (Codex, Cursor, Gemini, etc.)
+     - `AGENTS.md` - Cross-tool AI coding agent instructions
      - `GEMINI.md` - Google Gemini CLI specific instructions
-   - For each existing file, analyze:
-     - Find temporary instructions related to resolved issue (e.g., mentions of `#<issue_number>`, `issue-<number>`)
-     - Identify outdated or inaccurate information
-     - Identify redundant or unnecessary content
-   - Prepare update proposal for each file:
-     - **To remove**: Temporary notes/instructions related to resolved issue
-     - **To add**: New patterns/conventions discovered during issue resolution
-     - **To modify**: Outdated or inaccurate information
+     - `.claude/rules/*.md` - Modular rule files
+
+   - **Placement Rules** (applies to all config files):
+
+     | Content Type | Placement |
+     |--------------|-----------|
+     | Project-wide constraints | Golden Rules > Immutable |
+     | Project-wide recommendations | Golden Rules > Do's |
+     | Project-wide prohibitions | Golden Rules > Don'ts |
+     | Module-specific rules | Delegate to `.claude/rules/[module].md` |
+     | New commands | Commands section |
+     | New module references | Modular Rules section |
+
+   - **Content Removal**:
+     - Temporary instructions (e.g., `TODO: remove after #N`)
+     - Resolved known issues
+     - Workaround descriptions for fixed bugs
+
+   - **Content Addition**:
+     - Module-specific rule -> propose `.claude/rules/[module].md` creation/update
+     - Project-wide rule -> add to appropriate Golden Rules subsection
+     - New module documented -> add `See @.claude/rules/[module].md` reference
+
+   - **Modular Rule Files** (.claude/rules/*.md):
+     - Check if relevant module file exists
+     - Propose path-specific rules with frontmatter: `paths: src/[module]/**/*.py`
+     - Follow structure: Role, Key Components, Do's, Don'ts
+     - **Always confirm with user before creating new rule files**
+
    - Present proposal to user for confirmation before applying
 
 7. **Commit Changes (Optional)**
@@ -75,7 +96,28 @@ Perform branch cleanup and CLAUDE.md updates after a PR has been merged. Follow
 
 ## Configuration File Update Guide
 
-The following guidelines apply to CLAUDE.md, AGENTS.md, and GEMINI.md:
+The following guidelines apply to CLAUDE.md, AGENTS.md, GEMINI.md, and `.claude/rules/*.md`:
+
+### Expected File Structure
+
+**Root Config (CLAUDE.md, AGENTS.md, GEMINI.md)**:
+1. Project Context - Business goal + tech stack (1-2 sentences)
+2. Commands - Package manager and run commands
+3. Golden Rules - Immutable / Do's / Don'ts
+4. Modular Rules - `See @.claude/rules/[module].md` references
+5. Project-Specific - Data locations, tracking, etc.
+
+**Modular Rules (.claude/rules/*.md)**:
+```markdown
+---
+paths: src/[module]/**/*.py  # Optional: conditional loading
+---
+# [Module] Rules
+Role description (1-2 lines)
+## Key Components
+## Do's
+## Don'ts
+```
 
 ### Examples of Content to Remove
 - Temporary notes like `TODO: remove after #123 is resolved`

package/.claude/commands/gh/resolve-and-review.md

@@ -0,0 +1,69 @@
+---
+description: Full issue resolution pipeline with automated code review
+---
+
+# Resolve and Review
+
+Issue 해결부터 CodeRabbit 리뷰 처리까지 자동화된 전체 파이프라인.
+
+## Arguments
+
+`$ARGUMENTS` = Issue number
+
+## Pipeline
+
+### Step 1: Issue Resolution
+
+Spawn issue-resolver agent (blocking, wait for result):
+
+```
+Task(subagent_type="issue-resolver"):
+  prompt: |
+    Resolve GitHub issue #${ARGUMENTS}.
+
+    Follow the complete workflow in your system prompt.
+    End with: PR_CREATED: {number} or PR_FAILED: {reason}
+```
+
+Parse result:
+- Extract PR number from `PR_CREATED: (\d+)`
+- If `PR_FAILED`, report failure and **stop pipeline**
+
+### Step 2: Code Review Loop
+
+Spawn code-review-handler agent (blocking, wait for result):
+
+```
+Task(subagent_type="code-review-handler"):
+  prompt: |
+    Handle CodeRabbit reviews for PR #${PR_NUMBER}.
+
+    End with: REVIEW_COMPLETE, REVIEW_INCOMPLETE, or REVIEW_SKIPPED
+```
+
+### Step 3: Final Report
+
+Report to user:
+
+```
+## Pipeline Complete
+
+- Issue: #${ARGUMENTS}
+- PR: #${PR_NUMBER}
+- Review Status: ${REVIEW_STATUS}
+- PR URL: https://github.com/${REPO}/pull/${PR_NUMBER}
+```
+
+## Error Handling
+
+| Stage | Error | Action |
+|-------|-------|--------|
+| Step 1 | PR_FAILED | Stop pipeline, report reason |
+| Step 2 | REVIEW_INCOMPLETE | Continue, warn user |
+| Step 2 | REVIEW_SKIPPED | Continue, note no review |
+
+## Guidelines
+
+- Follow `@CLAUDE.md` project conventions
+- Each agent runs in independent context
+- Use `/tasks` to monitor agent status

package/.claude/commands/gh/resolve-issue.md

@@ -1,3 +1,6 @@
+---
+description: Resolve GitHub Issue
+---
 
 # Resolve GitHub Issue