@yeongjaeyou/claude-code-config 0.17.0 → 0.18.0

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

@@ -4,200 +4,76 @@ description: Handle CodeRabbit PR review comments autonomously. Use after PR cre
 model: inherit
 ---
 
-You are an autonomous code review handler for CodeRabbit comments.
+# CodeRabbit Review Handler
 
-## Prerequisites
+Autonomous agent for fixing CodeRabbit review comments.
 
-Read `.claude/guidelines/work-guidelines.md` before starting.
+## 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 (required)
-- Repository in owner/repo format (optional, auto-detect if omitted)
+- `PR_NUMBER`: PR number (required)
+- `COMMENTS`: Extracted review comments in format:
+  ```
+  ### File: path/to/file.ts:42
 
-## Safety Limits
+  <comment body>
 
-- MAX_ITERATIONS: 10
-- POLL_INTERVAL: 30 seconds
-- POLL_TIMEOUT: 300 seconds (only when waiting for initial review)
+  ---
+  ```
 
 ## Workflow
 
-### 1. Get PR Info
-
-```bash
-# PR_NUMBER from prompt
-REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
-OWNER=$(echo "$REPO" | cut -d'/' -f1)
-REPO_NAME=$(echo "$REPO" | cut -d'/' -f2)
-```
-
-### 2. Check if CodeRabbit Review Exists (CRITICAL)
-
-**Before any polling**, check if CodeRabbit has already reviewed:
-
-```bash
-# Get CodeRabbit review body
-REVIEW_BODY=$(gh pr view $PR_NUMBER --json reviews \
-  --jq '[.reviews[] | select(.author.login | contains("coderabbit"))] | last | .body // ""')
-
-# Check for review completion marker
-if echo "$REVIEW_BODY" | grep -q "Actionable comments posted:"; then
-  # Review exists - extract actionable count
-  ACTIONABLE=$(echo "$REVIEW_BODY" | grep -oP "Actionable comments posted: \K\d+" || echo "0")
-
-  if [ "$ACTIONABLE" -eq 0 ]; then
-    # No actionable comments (only nitpicks or none) -> done
-    echo "REVIEW_COMPLETE: all comments resolved"
-    exit 0
-  fi
-  # ACTIONABLE > 0 -> proceed to step 4 (extract and fix)
-else
-  # No review yet -> proceed to step 3 (polling)
-fi
 ```
-
-### 3. Poll for CodeRabbit Review (Only if No Review)
-
-Only enter polling loop if step 2 found no review:
-
-```bash
-ELAPSED=0
-POLL_TIMEOUT=300  # 5 minutes max
-
-while [ $ELAPSED -lt $POLL_TIMEOUT ]; do
-  REVIEW_BODY=$(gh pr view $PR_NUMBER --json reviews \
-    --jq '[.reviews[] | select(.author.login | contains("coderabbit"))] | last | .body // ""')
-
-  if echo "$REVIEW_BODY" | grep -q "Actionable comments posted:"; then
-    ACTIONABLE=$(echo "$REVIEW_BODY" | grep -oP "Actionable comments posted: \K\d+" || echo "0")
-
-    if [ "$ACTIONABLE" -eq 0 ]; then
-      echo "REVIEW_COMPLETE: all comments resolved"
-      exit 0
-    fi
-    break  # Found actionable comments, process them
-  fi
-
-  sleep 30
-  ELAPSED=$((ELAPSED + 30))
-done
-
-# Timeout with no review
-if [ $ELAPSED -ge $POLL_TIMEOUT ]; then
-  echo "REVIEW_SKIPPED: no CodeRabbit review found within timeout"
-  exit 0
-fi
+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
 ```
 
-### 4. Create GraphQL Query File
-
-```bash
-cat > /tmp/gh_review_query.graphql << 'GRAPHQL'
-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
-            }
-          }
-        }
-      }
-    }
-  }
-}
-GRAPHQL
-```
+## Fix Categories
 
-### 5. Extract Unresolved Comments
-
-```bash
-# Extract actionable comments only (exclude nitpick)
-UNRESOLVED=$(gh api graphql \
-  -F query=@/tmp/gh_review_query.graphql \
-  -f owner="$OWNER" -f repo="$REPO_NAME" -F pr="$PR_NUMBER" \
-  --jq '[.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)] | length')
-
-if [ "$UNRESOLVED" -eq 0 ]; then
-  echo "REVIEW_COMPLETE: all comments resolved"
-  exit 0
-fi
-
-REVIEW_CONTENT=$(gh api graphql \
-  -F query=@/tmp/gh_review_query.graphql \
-  -f owner="$OWNER" -f repo="$REPO_NAME" -F pr="$PR_NUMBER" \
-  --jq '.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) |
-    "File: \(.path)\nLine: \(.line)\n\nComment:\n\(.comments.nodes[0].body)\n\n---"')
-```
+### Auto-fix (No Confirmation)
 
-### 6. Apply Fixes
+- Typos, spelling errors
+- Missing imports
+- Formatting issues
+- Unused variables removal
+- Simple type annotations
+- Documentation improvements
 
-For each comment:
-1. Read `.claude/commands/code-review.md` for fix guidelines
-2. Analyze the feedback
-3. Determine if auto-fixable or requires confirmation
-4. Apply appropriate fix
+### Manual Confirmation Required
 
-### 7. Commit and Push
-
-```bash
-if [ -n "$(git status --porcelain)" ]; then
-  git add -u
-  git commit -m "fix: apply CodeRabbit review (iteration $ITERATION)"
-  git push
-fi
-```
-
-### 8. Repeat
-
-After push, go back to step 2 (check review exists).
-
-Loop until:
-- All comments resolved (ACTIONABLE=0 or UNRESOLVED=0)
-- MAX_ITERATIONS reached
-- No changes to commit
-
-## Error Handling
-
-| Error | Action |
-|-------|--------|
-| PR not found | Report and stop |
-| API rate limit | Increase poll interval, retry |
-| No CodeRabbit review | Exit after timeout (REVIEW_SKIPPED) |
-| Git push failed | Report and stop iteration |
+Use `AskUserQuestion` for:
+- Logic changes
+- Architecture decisions
+- API modifications
+- Security-related changes
+- Performance trade-offs
 
 ## Guidelines
 
-- Use AskUserQuestion for architecture/logic changes
-- Never auto-fix business logic without confirmation
-- Commit only changed files (no `git add -A`)
+- 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 Format (CRITICAL)
+## Output
 
-End your response with exactly one of:
-
-```
-REVIEW_COMPLETE: all comments resolved
-```
-
-```
-REVIEW_INCOMPLETE: max iterations reached, N comments remaining
+Report summary:
 ```
+Fixed N comments:
+- file1.ts:42 - <brief description>
+- file2.ts:15 - <brief description>
 
-```
-REVIEW_SKIPPED: no CodeRabbit review found within timeout
+Skipped M comments (require manual review):
+- file3.ts:88 - <reason>
 ```

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

@@ -14,56 +14,75 @@ Automatically fix and push until CodeRabbit review comments reach zero.
 
 ## Safety Limits
 
-- **MAX_ITERATIONS**: 10 (prevent infinite loops)
-- **POLL_INTERVAL**: 30 seconds (API rate limit consideration)
-- **POLL_TIMEOUT**: 300 seconds (max wait time for review)
+| Limit | Value | Purpose |
+|-------|-------|---------|
+| MAX_ITERATIONS | 10 | Prevent infinite loops |
+| POLL_TIMEOUT | 300s | Wait for CodeRabbit analysis |
+| POLL_INTERVAL | 30s | Status check frequency |
 
-## Workflow
+## Workflow (2-API Design)
 
-### 1. Get PR Info
+```
+┌─────────────────────────────────────────────────────────────┐
+│  1. Init → 2. Wait (Status API) → 3. Check (GraphQL) → 4. Fix │
+│                 ↑                                        ↓    │
+│                 └──────────── push & loop ───────────────┘    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Step 1: Initialize
 
 ```bash
-# Get PR number and repo info
+# Get PR info
 PR_NUMBER=${ARGUMENTS:-$(gh pr view --json number -q .number 2>/dev/null)}
 REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
-OWNER=$(echo "$REPO" | cut -d'/' -f1)
-REPO_NAME=$(echo "$REPO" | cut -d'/' -f2)
+SHA=$(gh pr view $PR_NUMBER --json commits --jq '.commits[-1].oid')
 
-echo "Target PR: #${PR_NUMBER} in ${REPO}"
+ITERATION=1
 ```
 
-### 2. Start Iteration Loop
+### Step 2: Wait for CodeRabbit (Status API)
 
-```
-MAX_ITERATIONS=10
-ITERATION=0
+CodeRabbit uses Commit Status API, not Check Runs.
 
-while [ $ITERATION -lt $MAX_ITERATIONS ]; do
-  ITERATION=$((ITERATION + 1))
-  echo "=== Iteration $ITERATION/$MAX_ITERATIONS ==="
+```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
+}
 ```
 
-### 3. Poll for Unresolved CodeRabbit Comments
+### Step 3: Check Unresolved Threads (GraphQL)
 
-Use GraphQL API with file-based query (inline `$` causes bash variable expansion issues):
+Single query for count + content. This is the ground truth.
 
 ```bash
-# Timeout settings: first iteration waits longer for initial review
-POLL_TIMEOUT_INITIAL=300   # First iteration: 5 minutes
-POLL_TIMEOUT_SUBSEQUENT=120  # Subsequent iterations: 2 minutes (wait for new review)
-POLL_INTERVAL=30
-MIN_WAIT_BEFORE_EXIT=60  # Minimum wait before declaring "all resolved"
-
-if [ $ITERATION -eq 1 ]; then
-  CURRENT_TIMEOUT=$POLL_TIMEOUT_INITIAL
-else
-  CURRENT_TIMEOUT=$POLL_TIMEOUT_SUBSEQUENT
-fi
-
-ELAPSED=0
-
-# Create GraphQL query file (avoids $ variable expansion in bash)
-cat > /tmp/gh_review_query.graphql << 'GRAPHQL'
+GRAPHQL_QUERY='
 query($owner: String!, $repo: String!, $pr: Int!) {
   repository(owner: $owner, name: $repo) {
     pullRequest(number: $pr) {
@@ -82,120 +101,78 @@ query($owner: String!, $repo: String!, $pr: Int!) {
       }
     }
   }
-}
-GRAPHQL
-
-echo "Waiting for CodeRabbit review... (timeout: ${CURRENT_TIMEOUT}s)"
-while [ $ELAPSED -lt $CURRENT_TIMEOUT ]; do
-  # Query unresolved review threads from CodeRabbit
-  # Filter: unresolved + coderabbit + NOT nitpick (actionable only)
-  UNRESOLVED=$(gh api graphql \
-    -F query=@/tmp/gh_review_query.graphql \
-    -f owner="$OWNER" -f repo="$REPO_NAME" -F pr="$PR_NUMBER" \
-    --jq '[.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)] | length')
-
-  if [ "$UNRESOLVED" -gt 0 ]; then
-    echo "Found $UNRESOLVED unresolved CodeRabbit comments"
-    break
-  fi
-
-  # For subsequent iterations: require minimum wait before exit
-  if [ $ITERATION -gt 1 ] && [ $ELAPSED -ge $MIN_WAIT_BEFORE_EXIT ]; then
-    echo "No new comments after ${MIN_WAIT_BEFORE_EXIT}s wait. All resolved!"
-    exit 0
-  fi
-
-  sleep $POLL_INTERVAL
-  ELAPSED=$((ELAPSED + POLL_INTERVAL))
-  echo "Still waiting... ($ELAPSED/$CURRENT_TIMEOUT seconds)"
-done
-
-# Handle timeout
+}'
+
+# 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
-  if [ $ITERATION -eq 1 ]; then
-    echo "No CodeRabbit review received within timeout. Exiting."
-    exit 0
-  else
-    echo "All CodeRabbit comments resolved!"
-    exit 0
-  fi
+  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\"")
 ```
 
-### 4. Extract Unresolved Comments
+### Step 4: Fix, Commit, Loop
 
 ```bash
-# Extract actionable comments only (exclude nitpick)
-REVIEW_CONTENT=$(gh api graphql \
-  -F query=@/tmp/gh_review_query.graphql \
-  -f owner="$OWNER" -f repo="$REPO_NAME" -F pr="$PR_NUMBER" \
-  --jq '.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) |
-    "File: \(.path)\nLine: \(.line)\n\nComment:\n\(.comments.nodes[0].body)\n\n---"')
-
-echo "=== Unresolved CodeRabbit Comments ==="
-echo "$REVIEW_CONTENT"
-```
+# For each comment: analyze and fix
+# Follow code-review.md guidelines for auto-fix vs manual
 
-### 5. Apply Fixes
+# After fixes applied:
+if [ -z "$(git status --porcelain)" ]; then
+  echo "REVIEW_COMPLETE: no changes needed"
+  exit 0
+fi
 
-Read `.claude/commands/code-review.md` and process each comment following its Auto-fix vs Checklist criteria.
+git add -u
+git commit -m "fix: address CodeRabbit review (iteration $ITERATION)"
+git push
 
-### 6. Commit & Push
+ITERATION=$((ITERATION + 1))
+[ $ITERATION -gt 10 ] && {
+  echo "REVIEW_INCOMPLETE: max iterations (10) reached, $UNRESOLVED comments remaining"
+  exit 1
+}
 
-```bash
-# Check for changes
-if [ -n "$(git status --porcelain)" ]; then
-  git add -u
-  git commit -m "fix: apply CodeRabbit review (iteration $ITERATION)"
-  git push
-  echo "Changes pushed. Waiting for next review..."
-  sleep 60  # Wait for new review
-else
-  echo "No changes to commit"
-  break
-fi
+# Update SHA and loop back to Step 2
+SHA=$(git rev-parse HEAD)
+# Go to Step 2
 ```
 
-### 7. Loop Termination
+## Output Format
 
-```
-done  # end while loop
+End with exactly one of:
 
-if [ $ITERATION -ge $MAX_ITERATIONS ]; then
-  echo "Max iterations reached. Manual review may be required."
-  exit 1
-fi
-```
+| 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 |
 
-## Output Format
+## Fix Guidelines
 
-Each iteration outputs:
-```
-=== Iteration N/10 ===
-- Unresolved comments: X
-- Auto-fixed: Y
-- Requires confirmation: Z
-- Pushed commit: abc1234
-```
+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 message |
-| API rate limit | Increase poll interval, retry |
-| No CodeRabbit review | Exit after timeout |
-| Git push failed | Report error, stop iteration |
-
-## Guidelines
-
-- Follow `@CLAUDE.md` project conventions
-- Use `AskUserQuestion` for architecture/logic changes
-- Never auto-fix business logic without confirmation
-- Commit only issue-relevant files (no `git add -A`)
+| 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/guidelines/work-guidelines.md

@@ -156,6 +156,35 @@ When Built-in LSP returns "No LSP server available" error:
 3. Prefer symbolic editing over file-based editing when modifying functions/classes
 4. Always check `find_referencing_symbols` before renaming/removing symbols
 
+### Self-Verification (MANDATORY)
+
+#### Execution Requirement
+- **MUST** execute code after writing, not just write and report
+- For Python scripts: run with appropriate interpreter
+- For tests: run pytest or equivalent
+- For notebooks: execute cells via `mcp__ide__executeCode`
+
+#### Error-Free Loop
+1. Write code
+2. Execute
+3. Error? → Analyze → Fix → Re-execute
+4. Repeat until success
+5. Only then proceed or report
+
+**NEVER:**
+- Report "code written" without executing it
+- Move to next step while errors exist
+- Ask user to run code that you should verify yourself
+
+#### Result Sanity Check
+After successful execution, verify output makes sense:
+- Data types/shapes as expected
+- No unexpected NaN/None/empty values
+- Numeric ranges reasonable
+- Visualizations render correctly
+
+If results look wrong → investigate and fix, don't just report the anomaly.
+
 ### Large File Handling
 - Files exceeding 25000 tokens cannot be read at once (Claude Code internal limit)
 - When encountering "exceeds maximum allowed tokens" error: