claude-code-templates 1.21.13 → 1.22.1

package/cli-tool/components/commands/utilities/directory-deep-dive.md

@@ -1,34 +0,0 @@
-# Directory Deep Dive
-
-Analyze directory structure and purpose
-
-## Instructions
-
-1. **Target Directory**
-   - Focus on the specified directory `$ARGUMENTS` or the current working directory
-
-2. **Investigate Architecture**
-   - Analyze the implementation principles and architecture of the code in this directory and its subdirectories
-   - Look for:
-     - Design patterns being used
-     - Dependencies and their purposes
-     - Key abstractions and interfaces
-     - Naming conventions and code organization
-
-3. **Create or Update Documentation**
-   - Create a CLAUDE.md file capturing this knowledge
-   - If one already exists, update it with newly discovered information
-   - Include:
-     - Purpose and responsibility of this module
-     - Key architectural decisions
-     - Important implementation details
-     - Common patterns used throughout the code
-     - Any gotchas or non-obvious behaviors
-
-4. **Ensure Proper Placement**
-   - Place the CLAUDE.md file in the directory being analyzed
-   - This ensures the context is loaded when working in that specific area
-
-## Credit
-
-This command is based on the work of Thomas Landgraf: https://thomaslandgraf.substack.com/p/claude-codes-memory-working-with

package/cli-tool/components/commands/utilities/explain-code.md

@@ -1,194 +0,0 @@
-# Analyze and Explain Code Functionality
-
-Analyze and explain code functionality
-
-## Instructions
-
-Follow this systematic approach to explain code: **$ARGUMENTS**
-
-1. **Code Context Analysis**
-   - Identify the programming language and framework
-   - Understand the broader context and purpose of the code
-   - Identify the file location and its role in the project
-   - Review related imports, dependencies, and configurations
-
-2. **High-Level Overview**
-   - Provide a summary of what the code does
-   - Explain the main purpose and functionality
-   - Identify the problem the code is solving
-   - Describe how it fits into the larger system
-
-3. **Code Structure Breakdown**
-   - Break down the code into logical sections
-   - Identify classes, functions, and methods
-   - Explain the overall architecture and design patterns
-   - Map out data flow and control flow
-
-4. **Line-by-Line Analysis**
-   - Explain complex or non-obvious lines of code
-   - Describe variable declarations and their purposes
-   - Explain function calls and their parameters
-   - Clarify conditional logic and loops
-
-5. **Algorithm and Logic Explanation**
-   - Describe the algorithm or approach being used
-   - Explain the logic behind complex calculations
-   - Break down nested conditions and loops
-   - Clarify recursive or asynchronous operations
-
-6. **Data Structures and Types**
-   - Explain data types and structures being used
-   - Describe how data is transformed or processed
-   - Explain object relationships and hierarchies
-   - Clarify input and output formats
-
-7. **Framework and Library Usage**
-   - Explain framework-specific patterns and conventions
-   - Describe library functions and their purposes
-   - Explain API calls and their expected responses
-   - Clarify configuration and setup code
-
-8. **Error Handling and Edge Cases**
-   - Explain error handling mechanisms
-   - Describe exception handling and recovery
-   - Identify edge cases being handled
-   - Explain validation and defensive programming
-
-9. **Performance Considerations**
-   - Identify performance-critical sections
-   - Explain optimization techniques being used
-   - Describe complexity and scalability implications
-   - Point out potential bottlenecks or inefficiencies
-
-10. **Security Implications**
-    - Identify security-related code sections
-    - Explain authentication and authorization logic
-    - Describe input validation and sanitization
-    - Point out potential security vulnerabilities
-
-11. **Testing and Debugging**
-    - Explain how the code can be tested
-    - Identify debugging points and logging
-    - Describe mock data or test scenarios
-    - Explain test helpers and utilities
-
-12. **Dependencies and Integrations**
-    - Explain external service integrations
-    - Describe database operations and queries
-    - Explain API interactions and protocols
-    - Clarify third-party library usage
-
-**Explanation Format Examples:**
-
-**For Complex Algorithms:**
-```
-This function implements a depth-first search algorithm:
-
-1. Line 1-3: Initialize a stack with the starting node and a visited set
-2. Line 4-8: Main loop - continue until stack is empty
-3. Line 9-11: Pop a node and check if it's the target
-4. Line 12-15: Add unvisited neighbors to the stack
-5. Line 16: Return null if target not found
-
-Time Complexity: O(V + E) where V is vertices and E is edges
-Space Complexity: O(V) for the visited set and stack
-```
-
-**For API Integration Code:**
-```
-This code handles user authentication with a third-party service:
-
-1. Extract credentials from request headers
-2. Validate credential format and required fields
-3. Make API call to authentication service
-4. Handle response and extract user data
-5. Create session token and set cookies
-6. Return user profile or error response
-
-Error Handling: Catches network errors, invalid credentials, and service unavailability
-Security: Uses HTTPS, validates inputs, and sanitizes responses
-```
-
-**For Database Operations:**
-```
-This function performs a complex database query with joins:
-
-1. Build base query with primary table
-2. Add LEFT JOIN for related user data
-3. Apply WHERE conditions for filtering
-4. Add ORDER BY for consistent sorting
-5. Implement pagination with LIMIT/OFFSET
-6. Execute query and handle potential errors
-7. Transform raw results into domain objects
-
-Performance Notes: Uses indexes on filtered columns, implements connection pooling
-```
-
-13. **Common Patterns and Idioms**
-    - Identify language-specific patterns and idioms
-    - Explain design patterns being implemented
-    - Describe architectural patterns in use
-    - Clarify naming conventions and code style
-
-14. **Potential Improvements**
-    - Suggest code improvements and optimizations
-    - Identify possible refactoring opportunities
-    - Point out maintainability concerns
-    - Recommend best practices and standards
-
-15. **Related Code and Context**
-    - Reference related functions and classes
-    - Explain how this code interacts with other components
-    - Describe the calling context and usage patterns
-    - Point to relevant documentation and resources
-
-16. **Debugging and Troubleshooting**
-    - Explain how to debug issues in this code
-    - Identify common failure points
-    - Describe logging and monitoring approaches
-    - Suggest testing strategies
-
-**Language-Specific Considerations:**
-
-**JavaScript/TypeScript:**
-- Explain async/await and Promise handling
-- Describe closure and scope behavior
-- Clarify this binding and arrow functions
-- Explain event handling and callbacks
-
-**Python:**
-- Explain list comprehensions and generators
-- Describe decorator usage and purpose
-- Clarify context managers and with statements
-- Explain class inheritance and method resolution
-
-**Java:**
-- Explain generics and type parameters
-- Describe annotation usage and processing
-- Clarify stream operations and lambda expressions
-- Explain exception hierarchy and handling
-
-**C#:**
-- Explain LINQ queries and expressions
-- Describe async/await and Task handling
-- Clarify delegate and event usage
-- Explain nullable reference types
-
-**Go:**
-- Explain goroutines and channel usage
-- Describe interface implementation
-- Clarify error handling patterns
-- Explain package structure and imports
-
-**Rust:**
-- Explain ownership and borrowing
-- Describe lifetime annotations
-- Clarify pattern matching and Option/Result types
-- Explain trait implementations
-
-Remember to:
-- Use clear, non-technical language when possible
-- Provide examples and analogies for complex concepts
-- Structure explanations logically from high-level to detailed
-- Include visual diagrams or flowcharts when helpful
-- Tailor the explanation level to the intended audience

package/cli-tool/components/commands/utilities/fix-issue.md

@@ -1,85 +0,0 @@
-# Fix Issue Command
-
-Identify and resolve code issues
-
-## Instructions
-
-Follow this structured approach to analyze and fix issues: **$ARGUMENTS**
-
-1. **Issue Analysis**
-   - Use `gh issue view $ARGUMENTS` to get complete issue details
-   - Read the issue description, comments, and any attached logs/screenshots
-   - Identify the type of issue (bug, feature request, enhancement, etc.)
-   - Understand the expected vs actual behavior
-
-2. **Environment Setup**
-   - Ensure you're on the correct branch (usually main/master)
-   - Pull latest changes: `git pull origin main`
-   - Create a new feature branch: `git checkout -b fix/issue-$ARGUMENTS`
-
-3. **Reproduce the Issue**
-   - Follow the steps to reproduce described in the issue
-   - Set up the development environment if needed
-   - Run the application/tests to confirm the issue exists
-   - Document the current behavior
-
-4. **Root Cause Analysis**
-   - Search the codebase for relevant files and functions
-   - Use grep/search tools to locate the problematic code
-   - Analyze the code logic and identify the root cause
-   - Check for related issues or similar patterns
-
-5. **Solution Design**
-   - Design a fix that addresses the root cause, not just symptoms
-   - Consider edge cases and potential side effects
-   - Ensure the solution follows project conventions and patterns
-   - Plan for backward compatibility if needed
-
-6. **Implementation**
-   - Implement the fix with clean, readable code
-   - Follow the project's coding standards and style
-   - Add appropriate error handling and logging
-   - Keep changes minimal and focused
-
-7. **Testing Strategy**
-   - Write or update tests to cover the fix
-   - Ensure existing tests still pass
-   - Test edge cases and error conditions
-   - Run the full test suite to check for regressions
-
-8. **Code Quality Checks**
-   - Run linting and formatting tools
-   - Perform static analysis if available
-   - Check for security implications
-   - Ensure performance isn't negatively impacted
-
-9. **Documentation Updates**
-   - Update relevant documentation if needed
-   - Add or update code comments for clarity
-   - Update changelog if the project maintains one
-   - Document any breaking changes
-
-10. **Commit and Push**
-    - Stage the changes: `git add .`
-    - Create a descriptive commit message following project conventions
-    - Example: `fix: resolve issue with user authentication timeout (#$ARGUMENTS)`
-    - Push the branch: `git push origin fix/issue-$ARGUMENTS`
-
-11. **Create Pull Request**
-    - Use `gh pr create` to create a pull request
-    - Reference the issue in the PR description: "Fixes #$ARGUMENTS"
-    - Provide a clear description of the changes and testing performed
-    - Add appropriate labels and reviewers
-
-12. **Follow-up**
-    - Monitor the PR for feedback and requested changes
-    - Address any review comments promptly
-    - Update the issue with progress and resolution
-    - Ensure CI/CD checks pass
-
-13. **Verification**
-    - Once merged, verify the fix in the main branch
-    - Close the issue if not automatically closed
-    - Monitor for any related issues or regressions
-
-Remember to communicate clearly in both code and comments, and always prioritize maintainable solutions over quick fixes.

package/cli-tool/components/commands/utilities/generate-linear-worklog.md

@@ -1,113 +0,0 @@
-# Generate Linear Work Log
-
-You are tasked with generating a technical work log comment for a Linear issue based on recent git commits.
-
-## Instructions
-
-1. **Check Linear MCP Availability**
-   - Verify that Linear MCP tools are available (mcp__linear__* functions)
-   - If Linear MCP is not installed, inform the user to install it and provide installation instructions
-   - Do not proceed with work log generation if Linear MCP is unavailable
-
-2. **Check for Existing Work Log**
-   - Use Linear MCP to get existing comments on the issue
-   - Look for comments with today's date in the format "## Work Completed [TODAY'S DATE]"
-   - If found, note the existing content to append/update rather than duplicate
-
-2. **Extract Git Information**
-   - Get the current branch name
-   - Get recent commits on the current branch (last 10 commits)
-   - Get commits that are on the current branch but not on main branch
-   - For each relevant commit, get detailed information including file changes and line counts
-   - Focus on commits since the last work log update (if any exists)
-
-3. **Generate Work Log Content**
-   - Use dry, technical language without adjectives or emojis
-   - Focus on factual implementation details
-   - Structure the log with date, branch, and commit information
-   - Include quantitative metrics (file counts, line counts) where relevant
-   - Avoid subjective commentary or promotional language
-
-4. **Handle Existing Work Log**
-   - If no work log exists for today: Create new comment
-   - If work log exists for today: Replace the existing comment with updated content including all today's work
-   - Ensure chronological order of commits
-   - Include both previous and new work completed today
-
-5. **Format Structure**
-   ```
-   ## Work Completed [TODAY'S DATE]
-
-   ### Branch: [current-branch-name]
-
-   **Commit [short-hash]: [Commit Title]**
-   - [Technical detail 1]
-   - [Technical detail 2]
-   - [Line count] lines of code across [file count] files
-
-   [Additional commits in chronological order]
-
-   ### [Status Section]
-   - [Current infrastructure/testing status]
-   - [What is now available/ready]
-   ```
-
-6. **Post to Linear**
-   - Use the Linear MCP integration to create or update the comment
-   - Post the formatted work log to the specified Linear issue
-   - If updating, replace the entire existing work log comment
-   - Confirm successful posting
-
-## Git Commands to Use
-- `git branch --show-current` - Get current branch
-- `git log --oneline -10` - Get recent commits
-- `git log main..HEAD --oneline` - Get branch-specific commits
-- `git show --stat [commit-hash]` - Get detailed commit info
-- `git log --since="[today's date]" --pretty=format:"%h %ad %s" --date=short` - Get today's commits
-
-## Content Guidelines
-- Include commit hashes and descriptive titles
-- Provide specific technical implementations
-- Include file counts and line counts for significant changes
-- Maintain consistent formatting
-- Focus on technical accomplishments
-- Include current status summary
-- No emojis or special characters
-
-## Error Handling
-- Check if Linear MCP client is available before proceeding
-- If Linear MCP is not available, display installation instructions:
-  ```
-  Linear MCP client is not installed. To install it:
-  
-  1. Install the Linear MCP server:
-     npm install -g @modelcontextprotocol/server-linear
-  
-  2. Add Linear MCP to your Claude configuration:
-     Add the following to your Claude MCP settings:
-     {
-       "mcpServers": {
-         "linear": {
-           "command": "npx",
-           "args": ["@modelcontextprotocol/server-linear"],
-           "env": {
-             "LINEAR_API_KEY": "your_linear_api_key_here"
-           }
-         }
-       }
-     }
-  
-  3. Restart Claude Code
-  4. Get your Linear API key from: https://linear.app/settings/api
-  ```
-- Validate that the Linear ticket ID exists
-- Handle cases where no recent commits are found
-- Provide clear error messages for git operation failures
-- Confirm successful comment posting
-
-## Example Usage
-When invoked with `/generate-linear-worklog BLA2-2`, the command should:
-1. Analyze git commits on the current branch
-2. Generate a structured work log
-3. Post the comment to Linear issue BLA2-2
-4. Confirm successful posting

package/cli-tool/components/commands/utilities/git-status.md

@@ -1,39 +0,0 @@
-# Git Status Command
-
-Show detailed git repository status
-
-*Command originally created by IndyDevDan (YouTube: https://www.youtube.com/@indydevdan) / DislerH (GitHub: https://github.com/disler)*
-
-## Instructions
-
-Analyze the current state of the git repository by performing the following steps:
-
-1. **Run Git Status Commands**
-   - Execute `git status` to see current working tree state
-   - Run `git diff HEAD origin/main` to check differences with remote
-   - Execute `git branch --show-current` to display current branch
-   - Check for uncommitted changes and untracked files
-
-2. **Analyze Repository State**
-   - Identify staged vs unstaged changes
-   - List any untracked files
-   - Check if branch is ahead/behind remote
-   - Review any merge conflicts if present
-
-3. **Read Key Files**
-   - Review README.md for project context
-   - Check for any recent changes in important files
-   - Understand project structure if needed
-
-4. **Provide Summary**
-   - Current branch and its relationship to main/master
-   - Number of commits ahead/behind
-   - List of modified files with change types
-   - Any action items (commits needed, pulls required, etc.)
-
-This command helps developers quickly understand:
-- What changes are pending
-- The repository's sync status
-- Whether any actions are needed before continuing work
-
-Arguments: $ARGUMENTS

package/cli-tool/components/commands/utilities/initref.md

@@ -1,3 +0,0 @@
-Build a reference for the implementation details of this project. Use provided summarize tool to get summary of the files. Avoid reading the content of many files yourself, as we might hit usage limits. Do read the content of important files though. Use the returned summaries to create reference files in /ref directory. Use markdown format for writing the documentation files.
-
-Update CLAUDE.md file with the pointers to important documentation files.

package/cli-tool/components/commands/utilities/prime.md

@@ -1,41 +0,0 @@
-# Enhanced AI Mode for Complex Tasks
-
-Enhanced AI mode for complex tasks
-
-*Command originally created by IndyDevDan (YouTube: https://www.youtube.com/@indydevdan) / DislerH (GitHub: https://github.com/disler)*
-
-## Instructions
-
-Initialize a new Claude Code session with comprehensive project context:
-
-1. **Analyze Codebase Structure**
-   - Run `git ls-files` to understand file organization and project layout
-   - Execute directory tree commands (if available) for visual structure
-   - Identify key directories and their purposes
-   - Note the technology stack and frameworks in use
-
-2. **Read Project Documentation**
-   - Read README.md for project overview and setup instructions
-   - Check for any additional documentation in docs/ or ai_docs/
-   - Review any CONTRIBUTING.md or development guides
-   - Look for architecture or design documents
-
-3. **Understand Project Context**
-   - Identify the project's primary purpose and goals
-   - Note any special setup requirements or dependencies
-   - Check for environment configuration needs
-   - Review any CI/CD configuration files
-
-4. **Provide Concise Overview**
-   - Summarize the project's purpose in 2-3 sentences
-   - List the main technologies and frameworks
-   - Highlight any important setup steps
-   - Note key areas of the codebase
-
-This command helps establish context quickly when:
-- Starting work on a new project
-- Returning to a project after time away
-- Onboarding new team members
-- Preparing for deep technical work
-
-The goal is to "prime" the AI assistant with essential project knowledge for more effective assistance.

package/cli-tool/components/commands/utilities/refactor-code.md

@@ -1,116 +0,0 @@
-# Intelligently Refactor and Improve Code Quality
-
-Intelligently refactor and improve code quality
-
-## Instructions
-
-Follow this systematic approach to refactor code: **$ARGUMENTS**
-
-1. **Pre-Refactoring Analysis**
-   - Identify the code that needs refactoring and the reasons why
-   - Understand the current functionality and behavior completely
-   - Review existing tests and documentation
-   - Identify all dependencies and usage points
-
-2. **Test Coverage Verification**
-   - Ensure comprehensive test coverage exists for the code being refactored
-   - If tests are missing, write them BEFORE starting refactoring
-   - Run all tests to establish a baseline
-   - Document current behavior with additional tests if needed
-
-3. **Refactoring Strategy**
-   - Define clear goals for the refactoring (performance, readability, maintainability)
-   - Choose appropriate refactoring techniques:
-     - Extract Method/Function
-     - Extract Class/Component
-     - Rename Variable/Method
-     - Move Method/Field
-     - Replace Conditional with Polymorphism
-     - Eliminate Dead Code
-   - Plan the refactoring in small, incremental steps
-
-4. **Environment Setup**
-   - Create a new branch: `git checkout -b refactor/$ARGUMENTS`
-   - Ensure all tests pass before starting
-   - Set up any additional tooling needed (profilers, analyzers)
-
-5. **Incremental Refactoring**
-   - Make small, focused changes one at a time
-   - Run tests after each change to ensure nothing breaks
-   - Commit working changes frequently with descriptive messages
-   - Use IDE refactoring tools when available for safety
-
-6. **Code Quality Improvements**
-   - Improve naming conventions for clarity
-   - Eliminate code duplication (DRY principle)
-   - Simplify complex conditional logic
-   - Reduce method/function length and complexity
-   - Improve separation of concerns
-
-7. **Performance Optimizations**
-   - Identify and eliminate performance bottlenecks
-   - Optimize algorithms and data structures
-   - Reduce unnecessary computations
-   - Improve memory usage patterns
-
-8. **Design Pattern Application**
-   - Apply appropriate design patterns where beneficial
-   - Improve abstraction and encapsulation
-   - Enhance modularity and reusability
-   - Reduce coupling between components
-
-9. **Error Handling Improvement**
-   - Standardize error handling approaches
-   - Improve error messages and logging
-   - Add proper exception handling
-   - Enhance resilience and fault tolerance
-
-10. **Documentation Updates**
-    - Update code comments to reflect changes
-    - Revise API documentation if interfaces changed
-    - Update inline documentation and examples
-    - Ensure comments are accurate and helpful
-
-11. **Testing Enhancements**
-    - Add tests for any new code paths created
-    - Improve existing test quality and coverage
-    - Remove or update obsolete tests
-    - Ensure tests are still meaningful and effective
-
-12. **Static Analysis**
-    - Run linting tools to catch style and potential issues
-    - Use static analysis tools to identify problems
-    - Check for security vulnerabilities
-    - Verify code complexity metrics
-
-13. **Performance Verification**
-    - Run performance benchmarks if applicable
-    - Compare before/after metrics
-    - Ensure refactoring didn't degrade performance
-    - Document any performance improvements
-
-14. **Integration Testing**
-    - Run full test suite to ensure no regressions
-    - Test integration with dependent systems
-    - Verify all functionality works as expected
-    - Test edge cases and error scenarios
-
-15. **Code Review Preparation**
-    - Review all changes for quality and consistency
-    - Ensure refactoring goals were achieved
-    - Prepare clear explanation of changes made
-    - Document benefits and rationale
-
-16. **Documentation of Changes**
-    - Create a summary of refactoring changes
-    - Document any breaking changes or new patterns
-    - Update project documentation if needed
-    - Explain benefits and reasoning for future reference
-
-17. **Deployment Considerations**
-    - Plan deployment strategy for refactored code
-    - Consider feature flags for gradual rollout
-    - Prepare rollback procedures
-    - Set up monitoring for the refactored components
-
-Remember: Refactoring should preserve external behavior while improving internal structure. Always prioritize safety over speed, and maintain comprehensive test coverage throughout the process.