claude-code-templates 1.21.0 → 1.21.1

package/cli-tool/templates/javascript-typescript/.claude/commands/api-endpoint.md

@@ -0,0 +1,51 @@
+# API Endpoint Generator
+
+Generate a complete API endpoint for $ARGUMENTS following project conventions.
+
+## Task
+
+I'll analyze the project structure and create a new API endpoint with:
+
+1. Route definition
+2. Controller/handler function
+3. Input validation
+4. Service layer logic (if applicable)
+5. Data access layer (if applicable)
+6. Unit tests
+7. Documentation
+
+## Process
+
+I'll follow these steps:
+
+1. Examine the project structure to understand the architecture pattern
+2. Identify existing patterns for routes, controllers, and validation
+3. Create all necessary files following project conventions
+4. Implement the endpoint with proper error handling
+5. Add appropriate tests
+6. Document the new endpoint
+
+## Best Practices
+
+I'll ensure the implementation includes:
+
+- Strong typing with TypeScript
+- Comprehensive error handling
+- Input validation
+- Security considerations (authentication/authorization)
+- Proper logging
+- Performance considerations
+- Test coverage
+
+## Adaptability
+
+I'll adapt to various API architectures:
+
+- Express/Koa/Fastify REST APIs
+- GraphQL resolvers
+- Next.js/Nuxt.js API routes
+- Serverless functions
+- tRPC endpoints
+- NestJS controllers
+
+I'll examine your project first to determine which pattern to follow.

package/cli-tool/templates/javascript-typescript/.claude/commands/debug.md

@@ -0,0 +1,52 @@
+# Debug Assistant
+
+Help me debug the issue with $ARGUMENTS in this project.
+
+## Task
+
+I'll help you identify and fix the problem by:
+
+1. Understanding the issue description
+2. Analyzing relevant code
+3. Identifying potential causes
+4. Suggesting and implementing fixes
+5. Verifying the solution works
+
+## Process
+
+I'll follow these steps:
+
+1. Examine error messages, logs, or unexpected behaviors
+2. Locate relevant files and code sections
+3. Analyze the code flow and potential failure points
+4. Identify common JavaScript/TypeScript pitfalls that might apply
+5. Suggest specific fixes with explanations
+6. Help implement and test the solution
+
+## Debugging Techniques
+
+I'll apply appropriate debugging techniques such as:
+
+- Static code analysis to find syntax or type errors
+- Runtime error analysis from logs or stack traces
+- Control flow tracing to understand execution paths
+- State inspection to identify incorrect values
+- Dependency analysis to find version conflicts
+- Network request inspection for API issues
+- Browser console analysis for frontend problems
+- Database query inspection for data issues
+
+## Common Issues I Can Help With
+
+- Type errors and null/undefined issues
+- Asynchronous code problems (Promises, async/await)
+- React/Vue/Angular component lifecycle issues
+- API integration problems
+- State management bugs
+- Performance bottlenecks
+- Memory leaks
+- Build/compilation errors
+- Testing failures
+- Environment configuration issues
+
+I'll adapt my approach based on your specific project structure, frameworks, and the nature of the problem.

package/cli-tool/templates/javascript-typescript/.claude/commands/lint.md

@@ -0,0 +1,48 @@
+# Lint Assistant
+
+Analyze and fix linting issues in $ARGUMENTS following project conventions.
+
+## Task
+
+I'll help you identify and fix code style and quality issues by:
+
+1. Running appropriate linters for the project
+2. Analyzing linting errors and warnings
+3. Fixing issues automatically when possible
+4. Explaining complex issues that require manual intervention
+5. Ensuring code follows project style guidelines
+
+## Process
+
+I'll follow these steps:
+
+1. Identify the linting tools used in the project (ESLint, Prettier, TSLint, etc.)
+2. Run the appropriate linting commands
+3. Parse and categorize the results
+4. Apply automatic fixes for common issues
+5. Provide explanations and suggestions for more complex problems
+6. Verify fixes don't introduce new issues
+
+## Common Linting Issues I Can Fix
+
+- Code style inconsistencies (spacing, indentation, quotes, etc.)
+- Unused variables and imports
+- Missing type annotations in TypeScript
+- Accessibility (a11y) issues in UI components
+- Potential bugs flagged by static analysis
+- Performance issues in React/Vue components
+- Security vulnerabilities detected by linters
+- Deprecated API usage
+- Import ordering problems
+- Missing documentation
+
+## Linting Tools I Can Work With
+
+- ESLint (with various plugins and configs)
+- Prettier
+- TSLint (legacy)
+- stylelint (for CSS/SCSS)
+- commitlint (for commit messages)
+- Custom lint rules specific to your project
+
+I'll adapt my approach based on your project's specific linting configuration and style guide requirements.

package/cli-tool/templates/javascript-typescript/.claude/commands/npm-scripts.md

@@ -0,0 +1,48 @@
+# NPM Scripts Assistant
+
+Help me with NPM scripts: $ARGUMENTS
+
+## Task
+
+I'll help you work with package.json scripts by:
+
+1. Analyzing existing npm scripts in your project
+2. Creating new scripts or modifying existing ones
+3. Explaining what specific scripts do
+4. Suggesting improvements or optimizations
+5. Troubleshooting script execution issues
+
+## Process
+
+I'll follow these steps:
+
+1. Examine your package.json file to understand current scripts
+2. Analyze dependencies and devDependencies for available tools
+3. Identify common patterns and conventions in your scripts
+4. Implement requested changes or create new scripts
+5. Provide explanations of how the scripts work
+6. Test scripts when possible to verify functionality
+
+## Common Script Types I Can Help With
+
+- Build processes (webpack, rollup, esbuild, etc.)
+- Development servers and hot reloading
+- Testing (unit, integration, e2e)
+- Linting and code formatting
+- Type checking
+- Deployment and CI/CD
+- Database migrations
+- Code generation
+- Environment setup
+- Pre/post hooks for git operations
+
+## Script Optimization Techniques
+
+- Parallelizing tasks for faster execution
+- Adding cross-platform compatibility
+- Improving error reporting and logging
+- Implementing watch modes for development
+- Creating composite scripts for common workflows
+- Adding appropriate exit codes for CI/CD pipelines
+
+I'll adapt my approach based on your project's specific needs, dependencies, and build tools.

package/cli-tool/templates/javascript-typescript/.claude/commands/refactor.md

@@ -0,0 +1,55 @@
+# Code Refactoring Assistant
+
+Refactor $ARGUMENTS following modern JavaScript/TypeScript best practices.
+
+## Task
+
+I'll help you refactor code by:
+
+1. Analyzing the current implementation
+2. Identifying improvement opportunities
+3. Applying modern patterns and practices
+4. Maintaining existing functionality
+5. Ensuring type safety and test coverage
+6. Documenting the changes made
+
+## Process
+
+I'll follow these steps:
+
+1. Examine the code to understand its purpose and structure
+2. Identify code smells, anti-patterns, or outdated approaches
+3. Plan the refactoring strategy with clear goals
+4. Implement changes incrementally while maintaining behavior
+5. Verify refactored code with tests
+6. Document improvements and benefits
+
+## Refactoring Techniques
+
+I can apply various refactoring techniques:
+
+- Converting to modern JavaScript/TypeScript features
+- Improving type definitions and type safety
+- Extracting reusable functions and components
+- Applying design patterns appropriately
+- Converting callbacks to Promises or async/await
+- Simplifying complex conditionals and loops
+- Removing duplicate code
+- Improving naming and readability
+- Optimizing performance
+- Enhancing error handling
+
+## Modern Practices I Can Apply
+
+- ES modules and import/export syntax
+- Optional chaining and nullish coalescing
+- Array and object destructuring
+- Spread and rest operators
+- Template literals
+- Arrow functions
+- Class fields and private methods
+- TypeScript utility types
+- Functional programming patterns
+- React hooks (for React components)
+
+I'll ensure the refactored code maintains compatibility with your project's requirements while improving quality and maintainability.

package/cli-tool/templates/javascript-typescript/.claude/commands/test.md

@@ -0,0 +1,61 @@
+# Test Assistant
+
+Help with tests for $ARGUMENTS following project conventions and testing best practices.
+
+## Task
+
+I'll help you with testing by:
+
+1. Creating comprehensive test suites for your code
+2. Implementing different types of tests (unit, integration, e2e)
+3. Mocking dependencies and external services
+4. Improving test coverage for existing code
+5. Troubleshooting failing tests
+6. Setting up testing infrastructure
+
+## Process
+
+I'll follow these steps:
+
+1. Examine your project to understand testing frameworks and patterns
+2. Analyze the code to be tested to understand its functionality
+3. Identify appropriate testing strategies and edge cases
+4. Implement tests with proper structure and assertions
+5. Ensure tests are maintainable and follow best practices
+6. Run tests to verify they pass and provide adequate coverage
+
+## Testing Frameworks I Can Work With
+
+- Jest, Vitest, Mocha, Jasmine for JavaScript/TypeScript
+- React Testing Library, Enzyme for React components
+- Cypress, Playwright, Puppeteer for E2E testing
+- Supertest, Pactum for API testing
+- Storybook for component testing
+- Testing-library family for various frameworks
+
+## Testing Techniques
+
+I can implement various testing approaches:
+
+- TDD (Test-Driven Development)
+- BDD (Behavior-Driven Development)
+- Snapshot testing
+- Property-based testing
+- Parameterized tests
+- Contract testing
+- Visual regression testing
+- Performance testing
+
+## Mocking Strategies
+
+I can help with different mocking approaches:
+
+- Function mocks and spies
+- Module mocks
+- HTTP request mocking
+- Browser API mocking
+- Timer mocking
+- Database mocking
+- Service worker mocking
+
+I'll adapt to your project's specific testing frameworks, patterns, and conventions to ensure consistency with your existing codebase.

package/cli-tool/templates/javascript-typescript/.claude/commands/typescript-migrate.md

@@ -0,0 +1,51 @@
+# TypeScript Migration Assistant
+
+Migrate $ARGUMENTS from JavaScript to TypeScript with proper typing and modern practices.
+
+## Task
+
+I'll help you migrate JavaScript code to TypeScript by:
+
+1. Converting JavaScript files to TypeScript (.js/.jsx to .ts/.tsx)
+2. Adding appropriate type definitions and interfaces
+3. Configuring TypeScript settings for your project
+4. Resolving type errors and compatibility issues
+5. Implementing modern TypeScript patterns and features
+6. Ensuring backward compatibility with existing code
+
+## Process
+
+I'll follow these steps:
+
+1. Examine your project structure and dependencies
+2. Analyze the JavaScript code to understand its functionality
+3. Create or update tsconfig.json with appropriate settings
+4. Convert files to TypeScript with proper type annotations
+5. Add necessary type definitions for libraries
+6. Fix type errors and implement type safety
+7. Refactor code to leverage TypeScript features
+
+## TypeScript Features I Can Implement
+
+- Interfaces and type aliases for complex data structures
+- Generics for reusable, type-safe components and functions
+- Union and intersection types for flexible typing
+- Enums for related constants
+- Utility types (Partial, Pick, Omit, etc.)
+- Type guards and type narrowing
+- Mapped and conditional types
+- Function overloading
+- Readonly properties and immutability
+- Module augmentation for extending third-party types
+
+## Migration Strategies
+
+I can apply different migration approaches based on your needs:
+
+- Gradual migration with allowJs and incremental adoption
+- File-by-file conversion while maintaining functionality
+- Comprehensive migration with full type safety
+- Hybrid approach with .d.ts files for complex modules
+- Integration with existing type definitions (@types packages)
+
+I'll adapt to your project's specific requirements and ensure a smooth transition to TypeScript while maintaining existing functionality.

package/cli-tool/templates/javascript-typescript/.claude/settings.json

@@ -0,0 +1,142 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash",
+      "Edit",
+      "MultiEdit",
+      "Write",
+      "Bash(npm:*)",
+      "Bash(yarn:*)",
+      "Bash(npx:*)",
+      "Bash(node:*)",
+      "Bash(git:*)",
+      "Bash(eslint:*)",
+      "Bash(prettier:*)",
+      "Bash(tsc:*)",
+      "Bash(jest:*)",
+      "Bash(vitest:*)",
+      "Bash(webpack:*)",
+      "Bash(vite:*)"
+    ],
+    "deny": [
+      "Bash(curl:*)",
+      "Bash(wget:*)",
+      "Bash(rm -rf:*)"
+    ],
+    "defaultMode": "allowEdits"
+  },
+  "env": {
+    "BASH_DEFAULT_TIMEOUT_MS": "60000",
+    "BASH_MAX_OUTPUT_LENGTH": "20000",
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
+    "NODE_ENV": "development"
+  },
+  "includeCoAuthoredBy": true,
+  "cleanupPeriodDays": 30,
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"No description\")\"' >> ~/.claude/bash-command-log.txt"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"); CONTENT=$(echo $STDIN_JSON | jq -r '.tool_input.content // \"\"); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]] && echo \"$CONTENT\" | grep -q 'console\\.log'; then echo 'Warning: console.log statements should be removed before committing' >&2; exit 2; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" == \"package.json\" ]]; then echo 'Checking for vulnerable dependencies...'; npm audit --audit-level=moderate; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]]; then npx prettier --write \"$FILE\"; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(ts|tsx)$ ]]; then RESULT=$(npx tsc --noEmit 2>&1); if [ $? -ne 0 ]; then echo \"TypeScript errors found: $RESULT\" >&2; exit 2; fi; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ ]] && grep -q 'import \\* from' \"$FILE\"; then echo 'Warning: Avoid wildcard imports for better tree-shaking' >&2; exit 2; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.(js|jsx|ts|tsx)$ && \"$FILE\" != *\".test.\"* && \"$FILE\" != *\".spec.\"* ]]; then DIR=$(dirname \"$FILE\"); BASENAME=$(basename \"$FILE\" | sed -E 's/\\.(js|jsx|ts|tsx)$//'); for TEST_FILE in \"$DIR/$BASENAME.test.\"* \"$DIR/$BASENAME.spec.\"*; do if [ -f \"$TEST_FILE\" ]; then echo \"Running tests for $TEST_FILE...\"; if command -v jest >/dev/null 2>&1; then npx jest \"$TEST_FILE\" --passWithNoTests; elif command -v vitest >/dev/null 2>&1; then npx vitest run \"$TEST_FILE\"; fi; break; fi; done; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Claude Code notification: $(date)\" >> ~/.claude/notifications.log"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f package.json && $(git status --porcelain | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$') ]]; then echo 'Running linter on changed files...'; npx eslint $(git diff --name-only --diff-filter=ACMR | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$'); fi",
+            "timeout": 60
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f package.json && $(git status --porcelain | grep -E '\\.js$|\\.jsx$|\\.ts$|\\.tsx$') ]]; then echo 'Analyzing bundle size impact...'; if command -v bundlesize >/dev/null 2>&1; then npx bundlesize; elif npm list webpack-bundle-analyzer >/dev/null 2>&1; then echo 'Use: npx webpack-bundle-analyzer build/static/js/*.js'; else echo 'No bundle analysis tool found'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}

package/cli-tool/templates/javascript-typescript/.mcp.json

@@ -0,0 +1,80 @@
+{
+  "mcpServers": {
+    "typescript-sdk": {
+      "name": "TypeScript SDK",
+      "description": "Official Anthropic SDK for building MCP servers and clients in JS/TS",
+      "command": "node",
+      "args": ["path/to/ts-sdk-server.js"],
+      "env": {}
+    },
+    "github": {
+      "name": "GitHub MCP",
+      "description": "Integration with GitHub API for managing repos, issues, and PRs",
+      "command": "node",
+      "args": ["path/to/server-github"],
+      "env": {
+        "GITHUB_TOKEN": "..."
+      }
+    },
+    "puppeteer": {
+      "name": "Puppeteer MCP",
+      "description": "Browser automation using Google Puppeteer",
+      "command": "node",
+      "args": ["path/to/server-puppeteer"],
+      "env": {}
+    },
+    "slack": {
+      "name": "Slack MCP",
+      "description": "Access to real-time Slack conversations and workflows",
+      "command": "node",
+      "args": ["path/to/server-slack"],
+      "env": {
+        "SLACK_TOKEN": "..."
+      }
+    },
+    "filesystem": {
+      "name": "File System MCP",
+      "description": "Local file management; compatible with any language",
+      "command": "node",
+      "args": ["path/to/server-filesystem"],
+      "env": {}
+    },
+    "memory-bank": {
+      "name": "Memory Bank MCP",
+      "description": "Centralized memory system for AI agents",
+      "command": "server-memory",
+      "args": [],
+      "env": {}
+    },
+    "sequential-thinking": {
+      "name": "Sequential Thinking MCP",
+      "description": "Helps LLMs decompose complex tasks into logical steps",
+      "command": "code-reasoning",
+      "args": [],
+      "env": {}
+    },
+    "brave-search": {
+      "name": "Brave Search MCP",
+      "description": "Privacy-focused web search tool",
+      "command": "server-brave-search",
+      "args": [],
+      "env": {}
+    },
+    "google-maps": {
+      "name": "Google Maps MCP",
+      "description": "Integrates Google Maps for geolocation and directions",
+      "command": "server-google-maps",
+      "args": [],
+      "env": {
+        "GOOGLE_MAPS_API_KEY": "..."
+      }
+    },
+    "deep-graph": {
+      "name": "Deep Graph MCP (Code Graph)",
+      "description": "Transforms source code into semantic graphs via DeepGraph",
+      "command": "mcp-code-graph",
+      "args": [],
+      "env": {}
+    }
+  }
+}