claude-skill-lord 1.5.0

package/skills/tier-2/claude-code/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: claude-code
+description: Use when users ask about Claude Code features, setup, configuration, troubleshooting, slash commands, MCP servers, Agent Skills, hooks, plugins, CI/CD integration, or enterprise deployment. Activate for questions like 'How do I use Claude Code?', 'What slash commands are available?', 'How to set up MCP?', 'Create a skill', 'Fix Claude Code issues', or 'Deploy Claude Code in enterprise'.
+---
+
+# Claude Code Expert
+
+Claude Code is Anthropic's agentic coding tool that lives in the terminal and helps turn ideas into code faster. It combines autonomous planning, execution, and validation with extensibility through skills, plugins, MCP servers, and hooks.
+
+## When to Use This Skill
+
+Use when users need help with:
+- Understanding Claude Code features and capabilities
+- Installation, setup, and authentication
+- Using slash commands for development workflows
+- Creating or managing Agent Skills
+- Configuring MCP servers for external tool integration
+- Setting up hooks and plugins
+- Troubleshooting Claude Code issues
+- Enterprise deployment (SSO, sandboxing, monitoring)
+- IDE integration (VS Code, JetBrains)
+- CI/CD integration (GitHub Actions, GitLab)
+- Advanced features (extended thinking, caching, checkpointing)
+- Cost tracking and optimization
+
+**Activation examples:**
+- "How do I use Claude Code?"
+- "What slash commands are available?"
+- "How to set up MCP servers?"
+- "Create a new skill for X"
+- "Fix Claude Code authentication issues"
+- "Deploy Claude Code in enterprise environment"
+
+## Core Architecture
+
+**Subagents**: Specialized AI agents (planner, code-reviewer, tester, debugger, docs-manager, ui-ux-designer, database-admin, etc.)
+
+**Agent Skills**: Modular capabilities with instructions, metadata, and resources that Claude uses automatically
+
+**Slash Commands**: User-defined operations in `.claude/commands/` that expand to prompts
+
+**Hooks**: Shell commands executing in response to events (pre/post-tool, user-prompt-submit)
+
+**MCP Servers**: Model Context Protocol integrations connecting external tools and services
+
+**Plugins**: Packaged collections of commands, skills, hooks, and MCP servers
+
+## Quick Reference
+
+Load these references when needed for detailed guidance:
+
+### Getting Started
+- **Installation & Setup**: `references/getting-started.md`
+  - Prerequisites, installation methods, authentication, first run
+
+### Development Workflows
+- **Slash Commands**: `references/slash-commands.md`
+  - Complete command catalog: /cook, /plan, /debug, /test, /fix:*, /docs:*, /git:*, /design:*, /content:*
+
+- **Agent Skills**: `references/agent-skills.md`
+  - Creating skills, skill.json format, best practices, API usage
+
+### Integration & Extension
+- **MCP Integration**: `references/mcp-integration.md`
+  - Configuration, common servers, remote servers
+
+- **Hooks & Plugins**: `references/hooks-and-plugins.md`
+  - Hook types, configuration, environment variables, plugin structure, installation
+
+### Configuration & Settings
+- **Configuration**: `references/configuration.md`
+  - Settings hierarchy, key settings, model configuration, output styles
+
+### Enterprise & Production
+- **Enterprise Features**: `references/enterprise-features.md`
+  - IAM, SSO, RBAC, sandboxing, audit logging, deployment options, monitoring
+
+- **IDE Integration**: `references/ide-integration.md`
+  - VS Code extension, JetBrains plugin setup and features
+
+- **CI/CD Integration**: `references/cicd-integration.md`
+  - GitHub Actions, GitLab CI/CD workflow examples
+
+### Advanced Usage
+- **Advanced Features**: `references/advanced-features.md`
+  - Extended thinking, prompt caching, checkpointing, memory management
+
+- **Troubleshooting**: `references/troubleshooting.md`
+  - Common issues, authentication failures, MCP problems, performance, debug mode
+
+- **API Reference**: `references/api-reference.md`
+  - Admin API, Messages API, Files API, Models API, Skills API
+
+- **Best Practices**: `references/best-practices.md`
+  - Project organization, security, performance, team collaboration, cost management
+
+## Common Workflows
+
+### Feature Implementation
+```bash
+/cook implement user authentication with JWT
+# Or plan first
+/plan implement payment integration with Stripe
+```
+
+### Bug Fixing
+```bash
+/fix:fast the login button is not working
+/debug the API returns 500 errors intermittently
+/fix:types  # Fix TypeScript errors
+```
+
+### Code Review & Testing
+```bash
+claude "review my latest commit"
+/test
+/fix:test the user service tests are failing
+```
+
+### Documentation
+```bash
+/docs:init      # Create initial documentation
+/docs:update    # Update existing docs
+/docs:summarize # Summarize changes
+```
+
+### Git Operations
+```bash
+/git:cm                    # Stage and commit
+/git:cp                    # Stage, commit, and push
+/git:pr feature-branch main  # Create pull request
+```
+
+### Design & Content
+```bash
+/design:fast create landing page for SaaS product
+/content:good write product description for new feature
+```
+
+## Instructions for Claude
+
+When responding to Claude Code questions:
+
+1. **Identify the topic** from the user's question
+2. **Load relevant references** from the Quick Reference section above
+3. **Provide specific guidance** using information from loaded references
+4. **Include examples** when helpful
+
+**Loading references:**
+- Read reference files only when needed for the specific question
+- Multiple references can be loaded for complex queries
+- Use grep patterns if searching within references
+
+**For setup/installation questions:** Load `references/getting-started.md`
+
+**For slash command questions:** Load `references/slash-commands.md`
+
+**For skill creation:** Load `references/agent-skills.md`
+
+**For MCP questions:** Load `references/mcp-integration.md`
+
+**For hooks/plugins:** Load `references/hooks-and-plugins.md`
+
+**For configuration:** Load `references/configuration.md`
+
+**For enterprise deployment:** Load `references/enterprise-features.md`
+
+**For IDE integration:** Load `references/ide-integration.md`
+
+**For CI/CD:** Load `references/cicd-integration.md`
+
+**For advanced features:** Load `references/advanced-features.md`
+
+**For troubleshooting:** Load `references/troubleshooting.md`
+
+**For API usage:** Load `references/api-reference.md`
+
+**For best practices:** Load `references/best-practices.md`
+
+**Documentation links:**
+- llms.txt: https://context7.com/websites/claude_en_claude-code/llms.txt?tokens=10000
+  - Search for specific topics: `https://context7.com/websites/claude_en_claude-code/llms.txt?topic=<topic>&tokens=5000`
+  - Eg. Search for "subagent": `https://context7.com/websites/claude_en_claude-code/llms.txt?topic=subagent&tokens=5000`
+- Main docs: https://docs.claude.com/en/docs/claude-code/
+- GitHub: https://github.com/anthropics/claude-code
+- Support: support.claude.com
+
+Provide accurate, actionable guidance based on the loaded references and official documentation.

package/skills/tier-2/claude-code/references/advanced-features.md

@@ -0,0 +1,399 @@
+# Advanced Features
+
+Extended thinking, prompt caching, checkpointing, and memory management in Claude Code.
+
+## Extended Thinking
+
+Deep reasoning for complex problems.
+
+### Enable Extended Thinking
+
+**Global configuration:**
+```bash
+claude config set thinking.enabled true
+claude config set thinking.budget 15000
+```
+
+**Project settings (.claude/settings.json):**
+```json
+{
+  "thinking": {
+    "enabled": true,
+    "budget": 10000,
+    "mode": "auto"
+  }
+}
+```
+
+**Command-line flag:**
+```bash
+claude --thinking "architect microservices system"
+```
+
+### Thinking Modes
+
+**auto**: Claude decides when to use extended thinking
+**manual**: User explicitly requests thinking
+**disabled**: No extended thinking
+
+```json
+{
+  "thinking": {
+    "mode": "auto",
+    "budget": 10000,
+    "minComplexity": 0.7
+  }
+}
+```
+
+### Budget Control
+
+Set token budget for thinking:
+
+```json
+{
+  "thinking": {
+    "budget": 10000,      // Max tokens for thinking
+    "budgetPerRequest": 5000,  // Per-request limit
+    "adaptive": true      // Adjust based on task complexity
+  }
+}
+```
+
+### Best Use Cases
+
+- Architecture design
+- Complex algorithm development
+- System refactoring
+- Performance optimization
+- Security analysis
+- Bug investigation
+
+### Example
+
+```bash
+claude --thinking "Design a distributed caching system with:
+- High availability
+- Consistency guarantees
+- Horizontal scalability
+- Fault tolerance"
+```
+
+## Prompt Caching
+
+Reduce costs by caching repeated context.
+
+### Enable Caching
+
+**API usage:**
+```typescript
+const response = await client.messages.create({
+  model: 'claude-sonnet-4-5-20250929',
+  system: [
+    {
+      type: 'text',
+      text: 'You are a coding assistant...',
+      cache_control: { type: 'ephemeral' }
+    }
+  ],
+  messages: [...]
+});
+```
+
+**CLI configuration:**
+```json
+{
+  "caching": {
+    "enabled": true,
+    "ttl": 300,
+    "maxSize": "100MB"
+  }
+}
+```
+
+### Cache Strategy
+
+**What to cache:**
+- Large codebases
+- Documentation
+- API specifications
+- System prompts
+- Project context
+
+**What not to cache:**
+- User queries
+- Dynamic content
+- Temporary data
+- Session-specific info
+
+### Cache Control
+
+```typescript
+// Cache large context
+{
+  type: 'text',
+  text: largeCodebase,
+  cache_control: { type: 'ephemeral' }
+}
+
+// Update without invalidating cache
+{
+  type: 'text',
+  text: newUserQuery
+  // No cache_control = not cached
+}
+```
+
+### Cost Savings
+
+With caching:
+- First request: Full cost
+- Subsequent requests: ~90% discount on cached tokens
+- Cache TTL: 5 minutes
+
+Example:
+```
+Without caching:
+Request 1: 10,000 tokens @ $3/M = $0.03
+Request 2: 10,000 tokens @ $3/M = $0.03
+Total: $0.06
+
+With caching (8,000 tokens cached):
+Request 1: 10,000 tokens @ $3/M = $0.03
+Request 2: 2,000 new + 8,000 cached @ $0.30/M = $0.0024
+Total: $0.0324 (46% savings)
+```
+
+## Checkpointing
+
+Automatically track and rewind changes.
+
+### Enable Checkpointing
+
+```bash
+claude config set checkpointing.enabled true
+```
+
+**Settings:**
+```json
+{
+  "checkpointing": {
+    "enabled": true,
+    "autoSave": true,
+    "interval": 300,
+    "maxCheckpoints": 50
+  }
+}
+```
+
+### View Checkpoints
+
+```bash
+# List checkpoints
+claude checkpoint list
+
+# View checkpoint details
+claude checkpoint show checkpoint-123
+```
+
+### Restore Checkpoint
+
+```bash
+# Restore to checkpoint
+claude checkpoint restore checkpoint-123
+
+# Restore to time
+claude checkpoint restore --time "2025-11-06T10:00:00Z"
+
+# Restore specific files
+claude checkpoint restore checkpoint-123 --files src/main.js
+```
+
+### Create Manual Checkpoint
+
+```bash
+# Create checkpoint with message
+claude checkpoint create "before refactoring auth module"
+
+# Create at important moments
+claude checkpoint create "working state before experiment"
+```
+
+### Checkpoint Strategies
+
+**Auto-save checkpoints:**
+- Before major changes
+- After successful tests
+- Every N minutes
+- Before destructive operations
+
+**Manual checkpoints:**
+- Before risky refactors
+- At working states
+- Before experiments
+- After milestones
+
+### Example Workflow
+
+```bash
+# Create checkpoint before risky change
+claude checkpoint create "before performance optimization"
+
+# Make changes
+claude "optimize database queries for 10x performance"
+
+# If something breaks
+claude checkpoint restore "before performance optimization"
+
+# Or continue with improvements
+claude checkpoint create "performance optimization complete"
+```
+
+## Memory Management
+
+Control how Claude remembers context across sessions.
+
+### Memory Locations
+
+**global**: Share memory across all projects
+**project**: Project-specific memory
+**none**: Disable memory
+
+```bash
+# Set memory location
+claude config set memory.location project
+
+# Enable memory
+claude config set memory.enabled true
+```
+
+### Configuration
+
+```json
+{
+  "memory": {
+    "enabled": true,
+    "location": "project",
+    "ttl": 86400,
+    "maxSize": "10MB",
+    "autoSummarize": true
+  }
+}
+```
+
+### Memory Operations
+
+```bash
+# View stored memories
+claude memory list
+
+# View specific memory
+claude memory show memory-123
+
+# Clear all memories
+claude memory clear
+
+# Clear old memories
+claude memory clear --older-than 7d
+
+# Clear project memories
+claude memory clear --project
+```
+
+### What Gets Remembered
+
+**Automatically:**
+- Project structure
+- Coding patterns
+- Preferences
+- Common commands
+- File locations
+
+**Explicitly stored:**
+- Important context
+- Design decisions
+- Architecture notes
+- Team conventions
+
+### Memory Best Practices
+
+**Project memory:**
+- Good for project-specific context
+- Shares across team members
+- Persists in `.claude/memory/`
+- Commit to version control (optional)
+
+**Global memory:**
+- Personal preferences
+- General knowledge
+- Common patterns
+- Cross-project learnings
+
+**Disable memory when:**
+- Working with sensitive data
+- One-off tasks
+- Testing/experimentation
+- Troubleshooting
+
+### Example
+
+```bash
+# Remember project architecture
+claude "Remember: This project uses Clean Architecture with:
+- Domain layer (core business logic)
+- Application layer (use cases)
+- Infrastructure layer (external dependencies)
+- Presentation layer (API/UI)"
+
+# Claude will recall this in future sessions
+claude "Add a new user registration feature"
+# Claude: "I'll implement this following the Clean Architecture..."
+```
+
+## Context Windows
+
+Manage large context effectively.
+
+### Maximum Context
+
+Model context limits:
+- Claude Sonnet: 200k tokens
+- Claude Opus: 200k tokens
+- Claude Haiku: 200k tokens
+
+### Context Management
+
+```json
+{
+  "context": {
+    "maxTokens": 200000,
+    "autoTruncate": true,
+    "prioritize": ["recent", "relevant"],
+    "summarizeLong": true
+  }
+}
+```
+
+### Strategies
+
+**Summarization:**
+- Auto-summarize old context
+- Keep summaries of large files
+- Compress conversation history
+
+**Prioritization:**
+- Recent messages first
+- Most relevant files
+- Explicit user priorities
+
+**Chunking:**
+- Process large codebases in chunks
+- Incremental analysis
+- Parallel processing
+
+## See Also
+
+- Pricing: https://docs.claude.com/about-claude/pricing
+- Token counting: https://docs.claude.com/build-with-claude/token-counting
+- Best practices: `references/best-practices.md`
+- Configuration: `references/configuration.md`