claude-code-templates 1.3.2 → 1.3.3

package/templates/javascript-typescript/examples/vue-app/.claude/commands/components.md

@@ -0,0 +1,46 @@
+# Vue Components
+
+Create Vue Single File Components for $ARGUMENTS following project conventions.
+
+## Task
+
+Create or optimize Vue components based on the requirements:
+
+1. **Analyze project structure**: Check existing Vue components to understand patterns, conventions, and file organization
+2. **Examine Vue setup**: Identify Vue version (2/3), TypeScript usage, and Composition/Options API preference
+3. **Check styling approach**: Determine if using CSS modules, SCSS, styled-components, or other styling methods
+4. **Review testing patterns**: Check existing component tests to understand testing framework and conventions
+5. **Create component structure**: Generate SFC with template, script, and style sections
+6. **Implement component**: Write TypeScript interfaces, props, emits, and component logic
+7. **Add accessibility**: Include proper ARIA attributes and semantic HTML
+8. **Create tests**: Write comprehensive component tests following project patterns
+9. **Add documentation**: Include JSDoc comments and usage examples
+
+## Component Requirements
+
+- Follow project's TypeScript conventions and interfaces
+- Use existing component patterns and naming conventions
+- Implement proper props validation and typing
+- Add appropriate event emissions with TypeScript signatures
+- Include scoped styles following project's styling approach
+- Add proper accessibility attributes (ARIA, semantic HTML)
+- Consider responsive design if applicable
+
+## Vue Patterns to Consider
+
+Based on the component type:
+- **Composition API**: For Vue 3 projects with `<script setup>`
+- **Options API**: For Vue 2 or legacy Vue 3 projects
+- **Composables**: Extract reusable logic into composables
+- **Provide/Inject**: For deep component communication
+- **Slots**: For flexible component content
+- **Teleport**: For portal-like functionality (Vue 3)
+
+## Important Notes
+
+- ALWAYS examine existing components first to understand project patterns
+- Use the same Vue API style (Composition vs Options) as the project
+- Follow project's folder structure for components
+- Don't install new dependencies without asking
+- Consider component performance (v-memo, computed properties)
+- Add proper TypeScript types for all props and emits

package/templates/javascript-typescript/examples/vue-app/.claude/commands/composables.md

@@ -0,0 +1,51 @@
+# Vue Composables
+
+Create Vue composables for $ARGUMENTS following project conventions.
+
+## Task
+
+Create or optimize Vue composables based on the requirements:
+
+1. **Analyze existing composables**: Check project for existing composable patterns, naming conventions, and file organization
+2. **Examine Vue setup**: Verify Vue 3 Composition API usage and TypeScript configuration
+3. **Identify composable type**: Determine the composable category:
+   - State management (reactive data, computed properties)
+   - API/HTTP operations (data fetching, mutations)
+   - DOM interactions (event listeners, element refs)
+   - Utility functions (validation, formatting, storage)
+   - Lifecycle management (cleanup, watchers)
+4. **Check dependencies**: Review existing composables to avoid duplication
+5. **Implement composable**: Create composable with proper TypeScript types and reactivity
+6. **Add lifecycle management**: Include proper cleanup with onUnmounted when needed
+7. **Create tests**: Write comprehensive unit tests for composable logic
+8. **Add documentation**: Include JSDoc comments and usage examples
+
+## Implementation Requirements
+
+- Follow project's TypeScript conventions and interfaces
+- Use appropriate Vue reactivity APIs (ref, reactive, computed, watch)
+- Include proper error handling and loading states
+- Add cleanup for side effects (event listeners, timers, subscriptions)
+- Make composables reusable and focused on single responsibility
+- Consider performance implications (shallow vs deep reactivity)
+
+## Common Composable Patterns
+
+Based on the request:
+- **Data fetching**: API calls with loading/error states
+- **Form handling**: Input management, validation, submission
+- **State management**: Local state, persistence, computed values
+- **DOM utilities**: Element refs, event handling, intersection observer
+- **Storage**: localStorage, sessionStorage, IndexedDB
+- **Authentication**: User state, token management, permissions
+- **UI utilities**: Dark mode, responsive breakpoints, modals
+
+## Important Notes
+
+- ALWAYS examine existing composables first to understand project patterns
+- Use proper Vue 3 Composition API patterns
+- Follow project's folder structure for composables (usually /composables)
+- Don't install new dependencies without asking
+- Consider composable composition (using other composables within composables)
+- Add proper TypeScript return types and generic constraints
+- Include proper reactivity patterns (avoid losing reactivity)

package/templates/python/.claude/commands/lint.md

@@ -0,0 +1,111 @@
+# Python Linter
+
+Run Python code linting and formatting tools.
+
+## Purpose
+
+This command helps you maintain code quality using Python's best linting and formatting tools.
+
+## Usage
+
+```
+/lint
+```
+
+## What this command does
+
+1. **Runs multiple linters** (flake8, pylint, black, isort)
+2. **Provides detailed feedback** on code quality issues
+3. **Auto-fixes formatting** where possible
+4. **Checks type hints** if mypy is configured
+
+## Example Commands
+
+### Black (code formatting)
+```bash
+# Format all Python files
+black .
+
+# Check formatting without changing files
+black --check .
+
+# Format specific file
+black src/main.py
+```
+
+### flake8 (style guide enforcement)
+```bash
+# Check all Python files
+flake8 .
+
+# Check specific directory
+flake8 src/
+
+# Check with specific rules
+flake8 --max-line-length=88 .
+```
+
+### isort (import sorting)
+```bash
+# Sort imports in all files
+isort .
+
+# Check import sorting
+isort --check-only .
+
+# Sort imports in specific file
+isort src/main.py
+```
+
+### pylint (comprehensive linting)
+```bash
+# Run pylint on all files
+pylint src/
+
+# Run with specific score threshold
+pylint --fail-under=8.0 src/
+
+# Generate detailed report
+pylint --output-format=html src/ > pylint_report.html
+```
+
+### mypy (type checking)
+```bash
+# Check types in all files
+mypy .
+
+# Check specific module
+mypy src/models.py
+
+# Check with strict mode
+mypy --strict src/
+```
+
+## Configuration Files
+
+Most projects benefit from configuration files:
+
+### .flake8
+```ini
+[flake8]
+max-line-length = 88
+exclude = .git,__pycache__,venv
+ignore = E203,W503
+```
+
+### pyproject.toml
+```toml
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"
+```
+
+## Best Practices
+
+- Run linters before committing code
+- Use consistent formatting across the project
+- Fix linting issues promptly
+- Configure linters to match your team's style
+- Use type hints for better code documentation

package/templates/python/.claude/commands/test.md

@@ -0,0 +1,73 @@
+# Test Runner
+
+Run Python tests with pytest, unittest, or other testing frameworks.
+
+## Purpose
+
+This command helps you run Python tests effectively with proper configuration and reporting.
+
+## Usage
+
+```
+/test
+```
+
+## What this command does
+
+1. **Detects test framework** (pytest, unittest, nose2)
+2. **Runs appropriate tests** with proper configuration
+3. **Provides coverage reporting** if available
+4. **Shows clear test results** with failure details
+
+## Example Commands
+
+### pytest (recommended)
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=src --cov-report=html
+
+# Run specific test file
+pytest tests/test_models.py
+
+# Run with verbose output
+pytest -v
+
+# Run tests matching pattern
+pytest -k "test_user"
+```
+
+### unittest
+```bash
+# Run all tests
+python -m unittest discover
+
+# Run specific test file
+python -m unittest tests.test_models
+
+# Run with verbose output
+python -m unittest -v
+```
+
+### Django tests
+```bash
+# Run all Django tests
+python manage.py test
+
+# Run specific app tests
+python manage.py test myapp
+
+# Run with coverage
+coverage run --source='.' manage.py test
+coverage report
+```
+
+## Best Practices
+
+- Write tests for all critical functionality
+- Use descriptive test names
+- Keep tests isolated and independent
+- Mock external dependencies
+- Aim for high test coverage (80%+)

package/templates/python/.claude/settings.json

@@ -0,0 +1,153 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash",
+      "Edit",
+      "MultiEdit",
+      "Write",
+      "Bash(python:*)",
+      "Bash(pip:*)",
+      "Bash(pytest:*)",
+      "Bash(black:*)",
+      "Bash(isort:*)",
+      "Bash(flake8:*)",
+      "Bash(mypy:*)",
+      "Bash(django-admin:*)",
+      "Bash(flask:*)",
+      "Bash(uvicorn:*)",
+      "Bash(gunicorn:*)",
+      "Bash(git:*)"
+    ],
+    "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",
+    "PYTHONPATH": "."
+  },
+  "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\" =~ \\.py$ ]] && echo \"$CONTENT\" | grep -q 'print('; then echo 'Warning: print() statements should be replaced with logging' >&2; exit 2; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" == \"requirements.txt\" ]] || [[ \"$FILE\" == \"pyproject.toml\" ]] || [[ \"$FILE\" == \"setup.py\" ]]; then echo 'Checking for vulnerable dependencies...'; if command -v safety >/dev/null 2>&1; then safety check; elif command -v pip-audit >/dev/null 2>&1; then pip-audit; else echo 'No security audit tool found. Install safety or pip-audit'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.py$ ]]; then black \"$FILE\" 2>/dev/null || echo 'Black formatting skipped (not installed)'; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.py$ ]]; then isort \"$FILE\" 2>/dev/null || echo 'isort skipped (not installed)'; fi",
+            "timeout": 30
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "FILE=$(echo $STDIN_JSON | jq -r '.tool_input.file_path // \"\"'); if [[ \"$FILE\" =~ \\.py$ ]]; then RESULT=$(flake8 \"$FILE\" 2>&1); if [ $? -ne 0 ] && command -v flake8 >/dev/null 2>&1; then echo \"Flake8 linting issues 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\" =~ \\.py$ ]]; then RESULT=$(mypy \"$FILE\" 2>&1); if [ $? -ne 0 ] && command -v mypy >/dev/null 2>&1; then echo \"MyPy type checking issues 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\" =~ \\.py$ && \"$FILE\" != *\"test_\"* && \"$FILE\" != *\"_test.py\" ]]; then DIR=$(dirname \"$FILE\"); BASENAME=$(basename \"$FILE\" .py); for TEST_FILE in \"$DIR/test_$BASENAME.py\" \"$DIR/${BASENAME}_test.py\" \"tests/test_$BASENAME.py\"; do if [ -f \"$TEST_FILE\" ]; then echo \"Running tests for $TEST_FILE...\"; if command -v pytest >/dev/null 2>&1; then pytest \"$TEST_FILE\" -v; elif python -m pytest \"$TEST_FILE\" 2>/dev/null; then python -m pytest \"$TEST_FILE\" -v; else python -m unittest \"$TEST_FILE\" 2>/dev/null || echo 'No test runner found'; 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 requirements.txt || -f pyproject.toml || -f setup.py ]] && [[ $(git status --porcelain | grep '\\.py$') ]]; then echo 'Running linter on changed Python files...'; if command -v flake8 >/dev/null 2>&1; then flake8 $(git diff --name-only --diff-filter=ACMR | grep '\\.py$'); elif command -v pylint >/dev/null 2>&1; then pylint $(git diff --name-only --diff-filter=ACMR | grep '\\.py$'); else echo 'No Python linter found (flake8/pylint)'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if [[ -f requirements.txt || -f pyproject.toml || -f setup.py ]] && [[ $(git status --porcelain | grep '\\.py$') ]]; then echo 'Running type checking on changed files...'; if command -v mypy >/dev/null 2>&1; then mypy $(git diff --name-only --diff-filter=ACMR | grep '\\.py$') || echo 'Type checking completed with issues'; else echo 'MyPy not found for type checking'; fi; fi",
+            "timeout": 60
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/python/.mcp.json

@@ -0,0 +1,78 @@
+{
+  "mcpServers": {
+    "python-sdk": {
+      "name": "Python SDK",
+      "description": "Official Python SDK with FastMCP for rapid MCP development",
+      "command": "python",
+      "args": ["-m", "python_sdk.server"],
+      "env": {}
+    },
+    "docker": {
+      "name": "Docker MCP",
+      "description": "Isolated code execution via Docker containers",
+      "command": "python",
+      "args": ["-m", "mcp_server_docker"],
+      "env": {}
+    },
+    "jupyter": {
+      "name": "Jupyter MCP",
+      "description": "MCP integration for interactive Jupyter notebooks",
+      "command": "python",
+      "args": ["-m", "server_jupyter"],
+      "env": {}
+    },
+    "postgresql": {
+      "name": "PostgreSQL MCP",
+      "description": "Natural language queries to PostgreSQL databases",
+      "command": "python",
+      "args": ["-m", "server_postgres"],
+      "env": {
+        "DATABASE_URL": "postgresql://user:pass@host/db"
+      }
+    },
+    "opik": {
+      "name": "Opik MCP",
+      "description": "Observability for LLM apps with tracing and metrics",
+      "command": "python",
+      "args": ["-m", "opik_mcp"],
+      "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": {}
+    }
+  }
+}