@yeongjaeyou/claude-code-config 0.16.0 → 0.17.1

package/.claude/skills/slash-command-creator/references/examples.md

@@ -0,0 +1,161 @@
+# Slash Command Examples
+
+## Simple Commands
+
+### Code Review Command
+```markdown
+---
+description: Review code for bugs and improvements
+---
+
+Review this code for:
+- Security vulnerabilities
+- Performance issues
+- Code style violations
+- Potential bugs
+
+$ARGUMENTS
+```
+
+### Explain Command
+```markdown
+---
+description: Explain code in simple terms
+---
+
+Explain the following code in simple, easy-to-understand terms:
+
+$ARGUMENTS
+```
+
+## Commands with Arguments
+
+### Single Argument (`$ARGUMENTS`)
+```markdown
+---
+description: Fix a GitHub issue
+---
+
+Fix issue #$ARGUMENTS following our coding standards.
+```
+
+### Positional Arguments (`$1`, `$2`, etc.)
+```markdown
+---
+argument-hint: [pr-number] [priority] [assignee]
+description: Review pull request
+---
+
+Review PR #$1 with priority $2 and assign to $3.
+Focus on security, performance, and code style.
+```
+
+## Commands with Bash Execution
+
+Use `!` prefix to execute bash commands and include output in context.
+
+### Git Commit Command
+```markdown
+---
+allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
+description: Create a git commit
+---
+
+## Context
+
+- Current git status: !`git status`
+- Current git diff: !`git diff HEAD`
+- Current branch: !`git branch --show-current`
+- Recent commits: !`git log --oneline -10`
+
+## Task
+
+Based on the above changes, create a single git commit.
+```
+
+### Deploy Command
+```markdown
+---
+allowed-tools: Bash(npm:*), Bash(docker:*)
+argument-hint: [environment]
+description: Deploy to specified environment
+---
+
+## Current State
+
+- Branch: !`git branch --show-current`
+- Last commit: !`git log -1 --oneline`
+
+## Deploy to $1
+
+Run the deployment process for the $1 environment.
+```
+
+## Commands with File References
+
+Use `@` prefix to include file contents.
+
+### Review Implementation
+```markdown
+---
+description: Review implementation against spec
+---
+
+Review the implementation in @src/utils/helpers.js against the specification.
+```
+
+### Compare Files
+```markdown
+---
+argument-hint: [old-file] [new-file]
+description: Compare two files
+---
+
+Compare @$1 with @$2 and summarize the differences.
+```
+
+## Namespaced Commands
+
+Commands in subdirectories appear with namespace in description.
+
+### Frontend Component (`.claude/commands/frontend/component.md`)
+```markdown
+---
+description: Generate a React component
+---
+
+Generate a React component with the following requirements:
+
+$ARGUMENTS
+
+Follow our frontend coding standards and use TypeScript.
+```
+
+### Backend API (`.claude/commands/backend/api.md`)
+```markdown
+---
+description: Generate API endpoint
+---
+
+Generate a REST API endpoint for:
+
+$ARGUMENTS
+
+Include validation, error handling, and documentation.
+```
+
+## Extended Thinking Commands
+
+Include thinking keywords to trigger extended thinking.
+
+```markdown
+---
+description: Analyze architecture deeply
+---
+
+Think step by step about the architecture implications of:
+
+$ARGUMENTS
+
+Consider scalability, maintainability, and performance.
+```

package/.claude/skills/slash-command-creator/references/frontmatter.md

@@ -0,0 +1,74 @@
+# Slash Command Frontmatter Reference
+
+## Required Fields
+
+### `description`
+Brief description of what the command does. Shown in `/help` output.
+
+```yaml
+description: Create a git commit with staged changes
+```
+
+## Optional Fields
+
+### `allowed-tools`
+Specifies which tools the command can use. Format: `ToolName(pattern:*)` or just `ToolName`.
+
+```yaml
+# Single tool
+allowed-tools: Bash(git status:*)
+
+# Multiple tools
+allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
+
+# Tool without pattern
+allowed-tools: Read, Write, Edit
+```
+
+Common tool patterns:
+- `Bash(command:*)` - Allow specific bash commands
+- `Read` - File reading
+- `Write` - File writing
+- `Edit` - File editing
+- `Grep` - Content search
+- `Glob` - File pattern matching
+
+### `argument-hint`
+Shows expected arguments when auto-completing the command.
+
+```yaml
+# Single argument
+argument-hint: [message]
+
+# Multiple arguments
+argument-hint: [pr-number] [priority] [assignee]
+
+# Alternative syntax
+argument-hint: add [tagId] | remove [tagId] | list
+```
+
+### `model`
+Specific model to use for this command. See [Models overview](https://docs.claude.com/en/docs/about-claude/models/overview).
+
+```yaml
+model: claude-3-5-haiku-20241022
+model: claude-sonnet-4-5-20250929
+```
+
+### `disable-model-invocation`
+Prevents the `SlashCommand` tool from calling this command programmatically.
+
+```yaml
+disable-model-invocation: true
+```
+
+## Complete Frontmatter Example
+
+```yaml
+---
+allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*)
+argument-hint: [message]
+description: Create a git commit with staged changes
+model: claude-3-5-haiku-20241022
+---
+```

package/.claude/skills/slash-command-creator/scripts/init_command.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Slash Command Initializer - Creates a new slash command from template
+
+Usage:
+    init_command.py <command-name> [--scope project|personal] [--path <custom-path>]
+
+Examples:
+    init_command.py review                    # Creates .claude/commands/review.md
+    init_command.py deploy --scope personal   # Creates ~/.claude/commands/deploy.md
+    init_command.py test --path ./my-commands # Creates ./my-commands/test.md
+"""
+
+import sys
+import os
+from pathlib import Path
+import argparse
+
+
+COMMAND_TEMPLATE = '''---
+description: {description}
+---
+
+# {command_title}
+
+{body}
+'''
+
+COMMAND_TEMPLATE_WITH_TOOLS = '''---
+allowed-tools: {allowed_tools}
+description: {description}
+---
+
+# {command_title}
+
+{body}
+'''
+
+COMMAND_TEMPLATE_FULL = '''---
+allowed-tools: {allowed_tools}
+argument-hint: {argument_hint}
+description: {description}
+model: {model}
+---
+
+# {command_title}
+
+{body}
+'''
+
+
+def title_case(name: str) -> str:
+    """Convert hyphenated name to Title Case."""
+    return ' '.join(word.capitalize() for word in name.replace('-', ' ').split())
+
+
+def get_project_commands_path() -> Path:
+    """Get the project-level commands directory."""
+    return Path.cwd() / '.claude' / 'commands'
+
+
+def get_personal_commands_path() -> Path:
+    """Get the user-level commands directory."""
+    return Path.home() / '.claude' / 'commands'
+
+
+def init_command(
+    command_name: str,
+    scope: str = 'project',
+    custom_path: str = None,
+    description: str = None,
+    body: str = None,
+    allowed_tools: str = None,
+    argument_hint: str = None,
+    model: str = None,
+    namespace: str = None
+) -> Path:
+    """
+    Initialize a new slash command.
+
+    Args:
+        command_name: Name of the command (without .md extension)
+        scope: 'project' or 'personal'
+        custom_path: Optional custom path override
+        description: Command description
+        body: Command body content
+        allowed_tools: Comma-separated list of allowed tools
+        argument_hint: Hint for command arguments
+        model: Specific model to use
+        namespace: Optional subdirectory namespace
+
+    Returns:
+        Path to created command file, or None if error
+    """
+    # Determine base path
+    if custom_path:
+        base_path = Path(custom_path).resolve()
+    elif scope == 'personal':
+        base_path = get_personal_commands_path()
+    else:
+        base_path = get_project_commands_path()
+
+    # Add namespace subdirectory if specified
+    if namespace:
+        base_path = base_path / namespace
+
+    # Create directory if it doesn't exist
+    try:
+        base_path.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        print(f"Error creating directory {base_path}: {e}")
+        return None
+
+    # Create command file path
+    command_file = base_path / f'{command_name}.md'
+
+    # Check if file already exists
+    if command_file.exists():
+        print(f"Error: Command already exists: {command_file}")
+        return None
+
+    # Prepare content
+    command_title = title_case(command_name)
+    description = description or f"[TODO: Brief description of /{command_name}]"
+    body = body or f"[TODO: Add instructions for /{command_name}]\n\n$ARGUMENTS"
+
+    # Choose template based on options
+    if allowed_tools and argument_hint and model:
+        content = COMMAND_TEMPLATE_FULL.format(
+            allowed_tools=allowed_tools,
+            argument_hint=argument_hint,
+            description=description,
+            model=model,
+            command_title=command_title,
+            body=body
+        )
+    elif allowed_tools:
+        content = COMMAND_TEMPLATE_WITH_TOOLS.format(
+            allowed_tools=allowed_tools,
+            description=description,
+            command_title=command_title,
+            body=body
+        )
+    else:
+        content = COMMAND_TEMPLATE.format(
+            description=description,
+            command_title=command_title,
+            body=body
+        )
+
+    # Write command file
+    try:
+        command_file.write_text(content)
+        print(f"Created: {command_file}")
+        return command_file
+    except Exception as e:
+        print(f"Error writing command file: {e}")
+        return None
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Initialize a new Claude Code slash command',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  %(prog)s review
+      Creates .claude/commands/review.md (project command)
+
+  %(prog)s deploy --scope personal
+      Creates ~/.claude/commands/deploy.md (personal command)
+
+  %(prog)s component --namespace frontend
+      Creates .claude/commands/frontend/component.md
+
+  %(prog)s commit --allowed-tools "Bash(git add:*), Bash(git commit:*)"
+      Creates command with specific tool permissions
+
+Command naming:
+  - Use lowercase with hyphens (e.g., 'review-pr', 'run-tests')
+  - Avoid spaces and special characters
+  - Keep names concise and descriptive
+'''
+    )
+
+    parser.add_argument('command_name', help='Name of the slash command (without .md)')
+    parser.add_argument('--scope', choices=['project', 'personal'], default='project',
+                        help='Command scope: project (.claude/commands) or personal (~/.claude/commands)')
+    parser.add_argument('--path', dest='custom_path', help='Custom path for command file')
+    parser.add_argument('--namespace', help='Subdirectory namespace (e.g., frontend, backend)')
+    parser.add_argument('--description', help='Command description')
+    parser.add_argument('--allowed-tools', dest='allowed_tools', help='Comma-separated list of allowed tools')
+    parser.add_argument('--argument-hint', dest='argument_hint', help='Hint for command arguments')
+    parser.add_argument('--model', help='Specific model to use (e.g., claude-3-5-haiku-20241022)')
+
+    args = parser.parse_args()
+
+    result = init_command(
+        command_name=args.command_name,
+        scope=args.scope,
+        custom_path=args.custom_path,
+        description=args.description,
+        allowed_tools=args.allowed_tools,
+        argument_hint=args.argument_hint,
+        model=args.model,
+        namespace=args.namespace
+    )
+
+    if result:
+        print(f"\nSlash command '/{args.command_name}' initialized successfully!")
+        print("\nNext steps:")
+        print("1. Edit the command file to update the description and body")
+        print("2. Test the command by running it in Claude Code")
+        print(f"\nUsage: /{args.command_name} [arguments]")
+        sys.exit(0)
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,127 @@
+---
+name: subagent-creator
+description: Create specialized Claude Code sub-agents with custom system prompts and tool configurations. Use when users ask to create a new sub-agent, custom agent, specialized assistant, or want to configure task-specific AI workflows for Claude Code.
+---
+
+# Sub-agent Creator
+
+Create specialized AI sub-agents for Claude Code that handle specific tasks with customized prompts and tool access.
+
+## Sub-agent File Format
+
+Sub-agents are Markdown files with YAML frontmatter stored in:
+- **Project**: `.claude/agents/` (higher priority)
+- **User**: `~/.claude/agents/` (lower priority)
+
+### Structure
+
+```markdown
+---
+name: subagent-name
+description: When to use this subagent (include "use proactively" for auto-delegation)
+tools: Tool1, Tool2, Tool3  # Optional - inherits all if omitted
+model: sonnet               # Optional - sonnet/opus/haiku/inherit
+permissionMode: default     # Optional - default/acceptEdits/bypassPermissions/plan
+skills: skill1, skill2      # Optional - auto-load skills
+---
+
+System prompt goes here. Define role, responsibilities, and behavior.
+```
+
+### Configuration Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `name` | Yes | Lowercase with hyphens |
+| `description` | Yes | Purpose and when to use (key for auto-delegation) |
+| `tools` | No | Comma-separated tool list (omit to inherit all) |
+| `model` | No | `sonnet`, `opus`, `haiku`, or `inherit` |
+| `permissionMode` | No | `default`, `acceptEdits`, `bypassPermissions`, `plan` |
+| `skills` | No | Skills to auto-load |
+
+## Creation Workflow
+
+1. **Gather requirements**: Ask about the sub-agent's purpose, when to use it, and required capabilities
+2. **Choose scope**: Project (`.claude/agents/`) or user (`~/.claude/agents/`)
+3. **Define configuration**: Name, description, tools, model
+4. **Write system prompt**: Clear role, responsibilities, and output format
+5. **Create file**: Write the `.md` file to the appropriate location
+
+## Writing Effective Sub-agents
+
+### Description Best Practices
+
+The `description` field is critical for automatic delegation:
+
+```yaml
+# Good - specific triggers
+description: Expert code reviewer. Use PROACTIVELY after writing or modifying code.
+
+# Good - clear use cases
+description: Debugging specialist for errors, test failures, and unexpected behavior.
+
+# Bad - too vague
+description: Helps with code
+```
+
+### System Prompt Guidelines
+
+1. **Define role clearly**: "You are a [specific expert role]"
+2. **List actions on invocation**: What to do first
+3. **Specify responsibilities**: What the sub-agent handles
+4. **Include guidelines**: Constraints and best practices
+5. **Define output format**: How to structure responses
+
+### Tool Selection
+
+- **Read-only tasks**: `Read, Grep, Glob, Bash`
+- **Code modification**: `Read, Write, Edit, Grep, Glob, Bash`
+- **Full access**: Omit `tools` field
+
+See [references/available-tools.md](references/available-tools.md) for complete tool list.
+
+## Example Sub-agents
+
+See [references/examples.md](references/examples.md) for complete examples:
+- Code Reviewer
+- Debugger
+- Data Scientist
+- Test Runner
+- Documentation Writer
+- Security Auditor
+
+## Template
+
+Copy from [assets/subagent-template.md](assets/subagent-template.md) to start a new sub-agent.
+
+## Quick Start Example
+
+Create a code reviewer sub-agent:
+
+```bash
+mkdir -p .claude/agents
+```
+
+Write to `.claude/agents/code-reviewer.md`:
+
+```markdown
+---
+name: code-reviewer
+description: Reviews code for quality and security. Use proactively after code changes.
+tools: Read, Grep, Glob, Bash
+model: inherit
+---
+
+You are a senior code reviewer.
+
+When invoked:
+1. Run git diff to see changes
+2. Review modified files
+3. Report issues by priority
+
+Focus on:
+- Code readability
+- Security vulnerabilities
+- Error handling
+- Best practices
+```

package/.claude/skills/subagent-creator/assets/subagent-template.md

@@ -0,0 +1,31 @@
+---
+name: your-subagent-name
+description: Clear description of what this subagent does and when to use it. Include "use proactively" or "MUST BE USED" for automatic delegation.
+tools: Read, Grep, Glob, Bash
+model: sonnet
+---
+
+You are an expert [role/specialty].
+
+When invoked:
+
+1. [First action to take]
+2. [Second action]
+3. [Third action]
+
+Key responsibilities:
+
+- [Responsibility 1]
+- [Responsibility 2]
+- [Responsibility 3]
+
+Guidelines:
+
+- [Guideline 1]
+- [Guideline 2]
+- [Guideline 3]
+
+Output format:
+
+- [What to include in responses]
+- [How to structure findings]

package/.claude/skills/subagent-creator/references/available-tools.md

@@ -0,0 +1,63 @@
+# Available Tools for Sub-agents
+
+Sub-agents can be granted access to any of Claude Code's internal tools. If `tools` field is omitted, the sub-agent inherits all tools from the main thread.
+
+## Core Tools
+
+| Tool | Description |
+|------|-------------|
+| `Read` | Read file contents |
+| `Write` | Create or overwrite files |
+| `Edit` | Make precise edits to existing files |
+| `Glob` | Find files by pattern matching |
+| `Grep` | Search file contents with regex |
+| `Bash` | Execute shell commands |
+| `Task` | Spawn sub-agents (not recommended for sub-agents) |
+
+## Interaction Tools
+
+| Tool | Description |
+|------|-------------|
+| `AskUser` | Ask user questions for clarification |
+| `TodoWrite` | Manage task lists |
+
+## Web Tools
+
+| Tool | Description |
+|------|-------------|
+| `WebFetch` | Fetch and process web content |
+| `WebSearch` | Search the web |
+
+## IDE Tools (when available)
+
+| Tool | Description |
+|------|-------------|
+| `mcp__ide__getDiagnostics` | Get language diagnostics from VS Code |
+| `mcp__ide__executeCode` | Execute code in Jupyter kernel |
+
+## MCP Tools
+
+Sub-agents can also access tools from configured MCP servers. MCP tool names follow the pattern `mcp__<server>__<tool>`.
+
+## Common Tool Combinations
+
+### Read-Only Research
+```
+tools: Read, Grep, Glob, Bash
+```
+Best for: Code analysis, documentation review, codebase exploration
+
+### Code Modification
+```
+tools: Read, Write, Edit, Grep, Glob, Bash
+```
+Best for: Implementing features, fixing bugs, refactoring
+
+### Minimal Write Access
+```
+tools: Read, Grep, Glob
+```
+Best for: Security audits, code review (report-only)
+
+### Full Access
+Omit the `tools` field to inherit all available tools.