claude-code-templates 1.21.13 → 1.22.1

package/cli-tool/templates/python/.claude/settings.json

@@ -1,153 +0,0 @@
-{
-  "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/cli-tool/templates/python/.mcp.json

@@ -1,78 +0,0 @@
-{
-  "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": {}
-    }
-  }
-}

package/cli-tool/templates/python/CLAUDE.md

@@ -1,276 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-This is a Python project optimized for modern Python development. The project uses industry-standard tools and follows best practices for scalable application development.
-
-## Development Commands
-
-### Environment Management
-- `python -m venv venv` - Create virtual environment
-- `source venv/bin/activate` (Linux/Mac) or `venv\Scripts\activate` (Windows) - Activate virtual environment
-- `deactivate` - Deactivate virtual environment
-- `pip install -r requirements.txt` - Install dependencies
-- `pip install -r requirements-dev.txt` - Install development dependencies
-
-### Package Management
-- `pip install <package>` - Install a package
-- `pip install -e .` - Install project in development mode
-- `pip freeze > requirements.txt` - Generate requirements file
-- `pip-tools compile requirements.in` - Compile requirements with pip-tools
-
-### Testing Commands
-- `pytest` - Run all tests
-- `pytest -v` - Run tests with verbose output
-- `pytest --cov` - Run tests with coverage report
-- `pytest --cov-report=html` - Generate HTML coverage report
-- `pytest -x` - Stop on first failure
-- `pytest -k "test_name"` - Run specific test by name
-- `python -m unittest` - Run tests with unittest
-
-### Code Quality Commands
-- `black .` - Format code with Black
-- `black --check .` - Check code formatting without changes
-- `isort .` - Sort imports
-- `isort --check-only .` - Check import sorting
-- `flake8` - Run linting with Flake8
-- `pylint src/` - Run linting with Pylint
-- `mypy src/` - Run type checking with MyPy
-
-### Development Tools
-- `python -m pip install --upgrade pip` - Upgrade pip
-- `python -c "import sys; print(sys.version)"` - Check Python version
-- `python -m site` - Show Python site information
-- `python -m pdb script.py` - Debug with pdb
-
-## Technology Stack
-
-### Core Technologies
-- **Python** - Primary programming language (3.8+)
-- **pip** - Package management
-- **venv** - Virtual environment management
-
-### Common Frameworks
-- **Django** - High-level web framework
-- **Flask** - Micro web framework
-- **FastAPI** - Modern API framework with automatic documentation
-- **SQLAlchemy** - SQL toolkit and ORM
-- **Pydantic** - Data validation using Python type hints
-
-### Data Science & ML
-- **NumPy** - Numerical computing
-- **Pandas** - Data manipulation and analysis
-- **Matplotlib/Seaborn** - Data visualization
-- **Scikit-learn** - Machine learning library
-- **TensorFlow/PyTorch** - Deep learning frameworks
-
-### Testing Frameworks
-- **pytest** - Testing framework
-- **unittest** - Built-in testing framework
-- **pytest-cov** - Coverage plugin for pytest
-- **factory-boy** - Test fixtures
-- **responses** - Mock HTTP requests
-
-### Code Quality Tools
-- **Black** - Code formatter
-- **isort** - Import sorter
-- **flake8** - Style guide enforcement
-- **pylint** - Code analysis
-- **mypy** - Static type checker
-- **pre-commit** - Git hooks framework
-
-## Project Structure Guidelines
-
-### File Organization
-```
-src/
-├── package_name/
-│   ├── __init__.py
-│   ├── main.py          # Application entry point
-│   ├── models/          # Data models
-│   ├── views/           # Web views (Django/Flask)
-│   ├── api/             # API endpoints
-│   ├── services/        # Business logic
-│   ├── utils/           # Utility functions
-│   └── config/          # Configuration files
-tests/
-├── __init__.py
-├── conftest.py          # pytest configuration
-├── test_models.py
-├── test_views.py
-└── test_utils.py
-requirements/
-├── base.txt            # Base requirements
-├── dev.txt             # Development requirements
-└── prod.txt            # Production requirements
-```
-
-### Naming Conventions
-- **Files/Modules**: Use snake_case (`user_profile.py`)
-- **Classes**: Use PascalCase (`UserProfile`)
-- **Functions/Variables**: Use snake_case (`get_user_data`)
-- **Constants**: Use UPPER_SNAKE_CASE (`API_BASE_URL`)
-- **Private methods**: Prefix with underscore (`_private_method`)
-
-## Python Guidelines
-
-### Type Hints
-- Use type hints for function parameters and return values
-- Import types from `typing` module when needed
-- Use `Optional` for nullable values
-- Use `Union` for multiple possible types
-- Document complex types with comments
-
-### Code Style
-- Follow PEP 8 style guide
-- Use meaningful variable and function names
-- Keep functions focused and single-purpose
-- Use docstrings for modules, classes, and functions
-- Limit line length to 88 characters (Black default)
-
-### Best Practices
-- Use list comprehensions for simple transformations
-- Prefer `pathlib` over `os.path` for file operations
-- Use context managers (`with` statements) for resource management
-- Handle exceptions appropriately with try/except blocks
-- Use `logging` module instead of print statements
-
-## Testing Standards
-
-### Test Structure
-- Organize tests to mirror source code structure
-- Use descriptive test names that explain the behavior
-- Follow AAA pattern (Arrange, Act, Assert)
-- Use fixtures for common test data
-- Group related tests in classes
-
-### Coverage Goals
-- Aim for 90%+ test coverage
-- Write unit tests for business logic
-- Use integration tests for external dependencies
-- Mock external services in tests
-- Test error conditions and edge cases
-
-### pytest Configuration
-```python
-# pytest.ini or pyproject.toml
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-python_files = ["test_*.py", "*_test.py"]
-python_classes = ["Test*"]
-python_functions = ["test_*"]
-addopts = "--cov=src --cov-report=term-missing"
-```
-
-## Virtual Environment Setup
-
-### Creation and Activation
-```bash
-# Create virtual environment
-python -m venv venv
-
-# Activate (Linux/Mac)
-source venv/bin/activate
-
-# Activate (Windows)
-venv\Scripts\activate
-
-# Install dependencies
-pip install -r requirements.txt
-pip install -r requirements-dev.txt
-```
-
-### Requirements Management
-- Use `requirements.txt` for production dependencies
-- Use `requirements-dev.txt` for development dependencies
-- Consider using `pip-tools` for dependency resolution
-- Pin versions for reproducible builds
-
-## Django-Specific Guidelines
-
-### Project Structure
-```
-project_name/
-├── manage.py
-├── project_name/
-│   ├── __init__.py
-│   ├── settings/
-│   ├── urls.py
-│   └── wsgi.py
-├── apps/
-│   ├── users/
-│   ├── products/
-│   └── orders/
-└── requirements/
-```
-
-### Common Commands
-- `python manage.py runserver` - Start development server
-- `python manage.py migrate` - Apply database migrations
-- `python manage.py makemigrations` - Create new migrations
-- `python manage.py createsuperuser` - Create admin user
-- `python manage.py collectstatic` - Collect static files
-- `python manage.py test` - Run Django tests
-
-## FastAPI-Specific Guidelines
-
-### Project Structure
-```
-src/
-├── main.py              # FastAPI application
-├── api/
-│   ├── __init__.py
-│   ├── dependencies.py  # Dependency injection
-│   └── v1/
-│       ├── __init__.py
-│       └── endpoints/
-├── core/
-│   ├── __init__.py
-│   ├── config.py       # Settings
-│   └── security.py    # Authentication
-├── models/
-├── schemas/            # Pydantic models
-└── services/
-```
-
-### Common Commands
-- `uvicorn main:app --reload` - Start development server
-- `uvicorn main:app --host 0.0.0.0 --port 8000` - Start production server
-
-## Security Guidelines
-
-### Dependencies
-- Regularly update dependencies with `pip list --outdated`
-- Use `safety` package to check for known vulnerabilities
-- Pin dependency versions in requirements files
-- Use virtual environments to isolate dependencies
-
-### Code Security
-- Validate input data with Pydantic or similar
-- Use environment variables for sensitive configuration
-- Implement proper authentication and authorization
-- Sanitize data before database operations
-- Use HTTPS for production deployments
-
-## Development Workflow
-
-### Before Starting
-1. Check Python version compatibility
-2. Create and activate virtual environment
-3. Install dependencies from requirements files
-4. Run type checking with `mypy`
-
-### During Development
-1. Use type hints for better code documentation
-2. Run tests frequently to catch issues early
-3. Use meaningful commit messages
-4. Format code with Black before committing
-
-### Before Committing
-1. Run full test suite: `pytest`
-2. Check code formatting: `black --check .`
-3. Sort imports: `isort --check-only .`
-4. Run linting: `flake8`
-5. Run type checking: `mypy src/`