@yeongjaeyou/claude-code-config 0.16.0 → 0.17.1

package/.claude/commands/tm/convert-prd.md

@@ -1,3 +1,7 @@
+---
+description: Convert Draft to TaskMaster PRD
+---
+
 # Convert Draft to TaskMaster PRD
 
 Convert a draft file to TaskMaster PRD format.

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

@@ -1,3 +1,7 @@
+---
+description: Post-Merge Cleanup (TaskMaster Integration)
+---
+
 # Post-Merge Cleanup (TaskMaster Integration)
 
 After PR merge, perform branch cleanup, TaskMaster status update, and CLAUDE.md update.
@@ -12,7 +16,9 @@ Follow project guidelines in `@CLAUDE.md`.
 
 ## Arguments
 
-- PR number (optional): If not provided, determine from conversation context or request selection from recent merged PR list
+`$ARGUMENTS` parsing:
+- If provided: Use as PR number (e.g., `/tm:post-merge 42`)
+- If empty: Determine from conversation context or show recent merged PR list for selection
 
 ---
 

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

@@ -1,3 +1,7 @@
+---
+description: Resolve GitHub Issue with TaskMaster
+---
+
 # Resolve GitHub Issue with TaskMaster
 
 Systematically resolve GitHub Issues by TaskMaster subtask units and create PR.

package/.claude/commands/tm/sync-to-github.md

@@ -1,3 +1,7 @@
+---
+description: TaskMaster -> GitHub Issue Sync
+---
+
 # TaskMaster -> GitHub Issue Sync
 
 Reads TaskMaster's tasks.json and automatically creates GitHub Issues and Milestones.

package/.claude/settings.json

@@ -0,0 +1,15 @@
+{
+    "hooks": {
+        "UserPromptSubmit": [
+            {
+                "matcher": "",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "bash .claude/hooks/inject-guidelines.sh"
+                    }
+                ]
+            }
+        ]
+    }
+}

package/.claude/skills/claude-md-generator/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: claude-md-generator
+description: Generate or restructure CLAUDE.md systems for any project. This skill should be used when starting new projects (provide project description + tech stack), reorganizing existing CLAUDE.md files into modular .claude/rules/ structures, or creating team coding standards with central control and delegation patterns.
+---
+
+# CLAUDE.md Generator
+
+This skill designs optimized CLAUDE.md systems following Claude Code official patterns with central control and delegation structure.
+
+## Role
+
+Act as an AI Context Architect with authority to design and implement CLAUDE.md systems. Analyze project structure, identify high-context zones, and create modular rule files.
+
+## Core Philosophy
+
+1. **500-Line Limit** - All context files must remain under 500 lines for readability and token efficiency
+2. **No Emojis** - Never use emojis anywhere for maximum context efficiency
+3. **Central Control + Delegation** - Root file serves as control tower; details delegate to `.claude/rules/`
+4. **Golden Rules** - Provide Do's/Don'ts format for clear behavioral guidance
+5. **@import Syntax** - Use `@path/to/file.md` for referencing modular rules
+
+## Operation Modes
+
+### Mode 1: New Project
+
+When no CLAUDE.md exists:
+
+1. Collect project description (1-2 sentences) and tech stack
+2. Analyze directory structure to identify boundaries
+3. Propose file list with paths and roles
+4. Wait for user confirmation
+5. Generate files sequentially
+6. Summarize created structure
+
+### Mode 2: Restructure Existing
+
+When CLAUDE.md already exists:
+
+1. Read and analyze current CLAUDE.md content
+2. Identify sections that should delegate to `.claude/rules/`
+3. Propose restructuring plan showing before/after
+4. Preserve existing information while improving structure
+5. Wait for user confirmation
+6. Execute restructuring
+7. Summarize changes
+
+## Execution Flow
+
+1. **Analyze** - Scan project structure, identify Dependency/Framework/Logical boundaries
+2. **Propose** - List files to create with paths and brief descriptions
+3. **Confirm** - Wait for user approval before any file operations
+4. **Generate** - Create files sequentially after approval
+5. **Summarize** - Report created files and provide next steps
+
+## Boundary Detection
+
+Create separate `.claude/rules/*.md` files when these signals appear:
+
+**Dependency Boundary**
+- Separate package.json, requirements.txt, Cargo.toml, etc.
+- Indicates isolated dependency scope
+
+**Framework Boundary**
+- Tech stack transition points (frontend/backend, API/infra)
+- Different tooling or patterns required
+
+**Logical Boundary**
+- High business logic density modules
+- Core engine, billing, auth, ML pipeline, etc.
+
+## Agent Rules
+
+1. **Analyze First** - Always scan project structure before proposing
+2. **Propose Before Execute** - Present file list and wait for confirmation
+3. **Preserve Existing** - When restructuring, keep existing information intact
+4. **Markdown Only** - Output valid Markdown without unnecessary prose
+
+## Official Patterns
+
+### Folder Structure
+
+Claude Code recognizes this hierarchy:
+
+```
+.claude/
+├── CLAUDE.md              # Alternative to root CLAUDE.md
+├── CLAUDE.local.md        # Personal overrides (auto-gitignored)
+├── rules/                 # Modular rules (AUTO-LOADED)
+│   ├── code-style.md
+│   ├── testing.md
+│   └── security.md
+├── agents/                # Custom subagents
+├── skills/                # Project skills
+└── settings.json          # Project settings
+```
+
+### @import Syntax
+
+Reference other files using `@` syntax:
+
+```markdown
+See @.claude/rules/models.md for model architecture guidance
+See @README.md for project overview
+```
+
+### Path-Specific Rules
+
+Use `paths:` frontmatter for conditional loading:
+
+```markdown
+---
+paths: src/models/**/*.py
+---
+
+# Model Rules
+[These rules only apply when working on matching files]
+```
+
+## Maintenance Policy
+
+When rules and actual code diverge:
+- Report the discrepancy to user
+- Propose update (either modify rules or suggest code changes)
+- Apply changes only after confirmation
+
+## References
+
+For detailed templates and examples, see:
+- @references/templates.md - Root and rules file templates
+- @references/examples.md - Project type examples (ML, Web, CLI, Monorepo)

package/.claude/skills/claude-md-generator/references/examples.md

@@ -0,0 +1,261 @@
+# Project Type Examples
+
+## Python ML/DL Project
+
+**Input:**
+```
+Project: Deepfake detection using DINOv3-ViT with LoRA adaptation
+Tech: Python, PyTorch, Optuna, YOLO, Gradio
+```
+
+**Output Structure:**
+```
+./CLAUDE.md (root - overview + @imports)
+.claude/rules/
+  - models.md       # paths: src/models/**/*.py
+  - data.md         # paths: src/data/**/*.py
+  - inference.md    # paths: src/inference/**/*.py
+  - optimization.md # paths: src/optimization/**/*.py
+  - labeling.md     # paths: src/labeling/**/*.py
+```
+
+**Sample Root CLAUDE.md:**
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+Deepfake detection competition project using DINOv3-ViT with LoRA adaptation.
+Tech: Python 3.11, PyTorch, Optuna, YOLO-Face, Gradio
+
+## Operational Commands
+
+```bash
+uv sync
+uv run python run_inference.py
+uv run pytest tests/
+```
+
+## Golden Rules
+
+### Immutable
+
+- BGR to RGB conversion required for all OpenCV inputs
+- LoRA rank/alpha must match checkpoint exactly
+
+### Do's
+
+- Use albumentations for image augmentation
+- Back-half sampling for video inference
+
+### Don'ts
+
+- Optimize solely for local metrics (inverse LDB correlation)
+- Use system Python directly
+
+## Modular Rules
+
+See @.claude/rules/models.md for detector architecture and checkpoints
+See @.claude/rules/data.md for preprocessing, caching, face detection
+See @.claude/rules/inference.md for prediction pipeline and aggregation
+See @.claude/rules/optimization.md for Optuna hyperparameter tuning
+```
+
+---
+
+## Web Application (Fullstack)
+
+**Input:**
+```
+Project: SaaS dashboard with user auth and billing
+Tech: Next.js 14, TypeScript, Prisma, Stripe, Tailwind
+```
+
+**Output Structure:**
+```
+./CLAUDE.md (root)
+.claude/rules/
+  - api.md          # paths: app/api/**/*
+  - components.md   # paths: components/**/*
+  - auth.md         # paths: lib/auth/**/*
+  - billing.md      # paths: lib/billing/**/*
+  - db.md           # paths: prisma/**/*
+```
+
+**Sample Root CLAUDE.md:**
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+SaaS dashboard with authentication, team management, and Stripe billing.
+Tech: Next.js 14 (App Router), TypeScript, Prisma, Stripe, Tailwind CSS
+
+## Operational Commands
+
+```bash
+pnpm install
+pnpm dev
+pnpm test
+pnpm db:push
+```
+
+## Golden Rules
+
+### Immutable
+
+- Never commit .env files
+- All API routes require authentication middleware
+
+### Do's
+
+- Use server components by default
+- Validate all inputs with Zod
+
+### Don'ts
+
+- Store API keys in client code
+- Skip error boundaries
+
+## Modular Rules
+
+See @.claude/rules/api.md for API route patterns
+See @.claude/rules/components.md for UI component guidelines
+See @.claude/rules/auth.md for authentication flow
+See @.claude/rules/billing.md for Stripe integration
+See @.claude/rules/db.md for Prisma schema conventions
+```
+
+---
+
+## CLI Tool
+
+**Input:**
+```
+Project: CLI for managing cloud infrastructure
+Tech: Rust, clap, tokio, AWS SDK
+```
+
+**Output Structure:**
+```
+./CLAUDE.md (root)
+.claude/rules/
+  - commands.md     # paths: src/commands/**/*
+  - core.md         # paths: src/core/**/*
+  - aws.md          # paths: src/aws/**/*
+```
+
+**Sample Root CLAUDE.md:**
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+CLI tool for managing AWS infrastructure with declarative configs.
+Tech: Rust, clap (CLI parsing), tokio (async), AWS SDK
+
+## Operational Commands
+
+```bash
+cargo build --release
+cargo test
+cargo run -- --help
+```
+
+## Golden Rules
+
+### Immutable
+
+- All AWS operations must be idempotent
+- Never store credentials in code
+
+### Do's
+
+- Use structured logging with tracing
+- Provide --dry-run for destructive operations
+
+### Don'ts
+
+- Block the async runtime
+- Panic in library code
+
+## Modular Rules
+
+See @.claude/rules/commands.md for CLI command structure
+See @.claude/rules/core.md for business logic patterns
+See @.claude/rules/aws.md for AWS SDK usage
+```
+
+---
+
+## Monorepo
+
+**Input:**
+```
+Project: E-commerce platform with web, mobile API, and shared packages
+Tech: Turborepo, Next.js, Fastify, React Native, TypeScript
+```
+
+**Output Structure:**
+```
+./CLAUDE.md (root - routing only)
+apps/
+  web/CLAUDE.md           # Next.js storefront
+  api/CLAUDE.md           # Fastify backend
+  mobile/CLAUDE.md        # React Native app
+packages/
+  shared/CLAUDE.md        # Shared utilities
+  ui/CLAUDE.md            # Component library
+infra/CLAUDE.md           # Terraform/Pulumi
+```
+
+**Sample Root CLAUDE.md:**
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+E-commerce platform monorepo with web storefront, API, mobile app, and shared packages.
+Tech: Turborepo, pnpm workspaces, TypeScript throughout
+
+## Operational Commands
+
+```bash
+pnpm install
+pnpm dev           # Run all apps
+pnpm build         # Build all packages
+pnpm test          # Test all packages
+```
+
+## Golden Rules
+
+### Immutable
+
+- All packages must have explicit dependencies (no implicit imports)
+- Shared types live in @repo/shared only
+
+### Do's
+
+- Use workspace protocol for internal deps
+- Run affected tests before PR
+
+### Don'ts
+
+- Import directly from other apps
+- Skip the build step for packages
+
+## App-Specific Rules
+
+Web storefront: @apps/web/CLAUDE.md
+API server: @apps/api/CLAUDE.md
+Mobile app: @apps/mobile/CLAUDE.md
+
+## Package Rules
+
+Shared utilities: @packages/shared/CLAUDE.md
+UI components: @packages/ui/CLAUDE.md
+
+## Infrastructure
+
+Terraform configs: @infra/CLAUDE.md
+```

package/.claude/skills/claude-md-generator/references/templates.md

@@ -0,0 +1,156 @@
+# Templates
+
+## Root CLAUDE.md Template
+
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+[1-2 line business goal + tech stack summary]
+
+## Operational Commands
+
+```bash
+# [Package manager commands]
+[install command]
+[run command]
+[test command]
+```
+
+## Golden Rules
+
+### Immutable
+
+- [Non-negotiable security/architecture constraints]
+- [Critical patterns that must never be violated]
+
+### Do's
+
+- [Clear positive actions]
+- [Required patterns]
+
+### Don'ts
+
+- [Clear prohibitions]
+- [Anti-patterns to avoid]
+
+## Modular Rules
+
+See @.claude/rules/[module].md for [description]
+See @.claude/rules/[module].md for [description]
+
+## [Project-Specific Sections]
+
+[Data locations, submission tracking, deployment info, etc.]
+```
+
+## Rules File Template (General)
+
+```markdown
+---
+paths: [glob pattern, optional]
+---
+
+# [Module] Rules
+
+## Role
+
+[What this module does, 1-2 lines]
+
+## Dependencies
+
+- [Key external libraries]
+- [Internal module dependencies]
+
+## Patterns
+
+- [Common code patterns]
+- [File naming conventions]
+- [Directory structure expectations]
+
+## Do's
+
+- [Module-specific positive actions]
+- [Required patterns for this area]
+
+### Don'ts
+
+- [Module-specific prohibitions]
+- [Common mistakes to avoid]
+
+## Testing
+
+```bash
+[Module-specific test commands]
+```
+```
+
+## Rules File Template (Path-Specific)
+
+```markdown
+---
+paths: src/api/**/*.ts, src/api/**/*.tsx
+---
+
+# API Development Rules
+
+## Role
+
+Handle all backend API routes and server-side logic.
+
+## Patterns
+
+- All endpoints follow REST conventions
+- Use standard error response format
+- Include input validation on all routes
+
+## Do's
+
+- Validate all incoming data
+- Return consistent error structures
+- Log meaningful error context
+
+## Don'ts
+
+- Expose internal error details to clients
+- Skip authentication checks
+- Use raw SQL without parameterization
+```
+
+## Restructured Root Template
+
+When converting a large CLAUDE.md to modular structure:
+
+```markdown
+# CLAUDE.md
+
+## Project Context
+
+[Keep existing overview, condensed to 2-3 lines]
+
+## Operational Commands
+
+[Keep essential commands only]
+
+## Golden Rules
+
+### Immutable
+
+[Extract from existing, keep only critical rules]
+
+### Do's / Don'ts
+
+[Keep top 5-7 most important rules here]
+
+## Modular Rules
+
+Architecture and core pipeline: @.claude/rules/architecture.md
+Data processing and caching: @.claude/rules/data.md
+Model and inference: @.claude/rules/inference.md
+[Add more as needed based on existing sections]
+
+## [Keep minimal project-specific sections]
+
+[Submission tracking, data locations - things that change rarely]
+```

package/.claude/skills/hook-creator/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: hook-creator
+description: Create and configure Claude Code hooks for customizing agent behavior. Use when the user wants to (1) create a new hook, (2) configure automatic formatting, logging, or notifications, (3) add file protection or custom permissions, (4) set up pre/post tool execution actions, or (5) asks about hook events like PreToolUse, PostToolUse, Notification, etc.
+---
+
+# Hook Creator
+
+Create Claude Code hooks that execute shell commands at specific lifecycle events.
+
+## Hook Creation Workflow
+
+1. **Identify the use case** - Determine what the hook should accomplish
+2. **Select the appropriate event** - Choose from available hook events (see references/hook-events.md)
+3. **Design the hook command** - Write shell command that processes JSON input from stdin
+4. **Configure the matcher** - Set tool/event filter (use `*` for all, or specific tool names like `Bash`, `Edit|Write`)
+5. **Choose storage location** - User settings (`~/.claude/settings.json`) or project (`.claude/settings.json`)
+6. **Test the hook** - Verify behavior with a simple test case
+
+## Hook Configuration Structure
+
+```json
+{
+  "hooks": {
+    "<EventName>": [
+      {
+        "matcher": "<ToolPattern>",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "<shell-command>"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+## Common Patterns
+
+### Reading Input Data
+
+Hooks receive JSON via stdin. Use `jq` to extract fields:
+
+```bash
+# Extract tool input field
+jq -r '.tool_input.file_path'
+
+# Extract with fallback
+jq -r '.tool_input.description // "No description"'
+
+# Conditional processing
+jq -r 'if .tool_input.file_path then .tool_input.file_path else empty end'
+```
+
+### Exit Codes for PreToolUse
+
+- `0` - Allow the tool to proceed
+- `2` - Block the tool and provide feedback to Claude
+
+### Matcher Patterns
+
+- `*` - Match all tools
+- `Bash` - Match only Bash tool
+- `Edit|Write` - Match Edit or Write tools
+- `Read` - Match Read tool
+
+## Quick Examples
+
+**Log all bash commands:**
+```bash
+jq -r '"\(.tool_input.command)"' >> ~/.claude/bash-log.txt
+```
+
+**Auto-format TypeScript after edit:**
+```bash
+jq -r '.tool_input.file_path' | { read f; [[ "$f" == *.ts ]] && npx prettier --write "$f"; }
+```
+
+**Block edits to .env files:**
+```bash
+python3 -c "import json,sys; p=json.load(sys.stdin).get('tool_input',{}).get('file_path',''); sys.exit(2 if '.env' in p else 0)"
+```
+
+## Resources
+
+- **Hook Events Reference**: See `references/hook-events.md` for detailed event documentation with input/output schemas
+- **Example Configurations**: See `references/examples.md` for complete, tested hook configurations