@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/en/Python/commands/check-code-quality.md

@@ -0,0 +1,174 @@
+---
+description: Check Python Code Quality
+argument-hint: [arguments]
+---
+
+# Check Python Code Quality
+
+## Arguments
+
+$ARGUMENTS (optional: path to project to analyze)
+
+## MISSION
+
+Perform a complete code quality audit of the Python project by verifying PEP8 compliance, typing, readability, and best practices defined in project rules.
+
+### Step 1: PEP8 Coding Standards
+
+Verify Python conventions compliance:
+- [ ] Naming: snake_case for functions/variables, PascalCase for classes
+- [ ] Indentation: 4 spaces (no tabs)
+- [ ] Line length: maximum 88 characters (Black)
+- [ ] Imports: organized (stdlib, third-party, local) and sorted
+- [ ] Spaces: around operators, after commas
+- [ ] Docstrings: present for modules, classes, public functions
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 python -m flake8 /app --max-line-length=88`
+
+**Reference**: `rules/03-coding-standards.md` section "PEP 8 Compliance"
+
+### Step 2: Type Hints and MyPy
+
+Check static typing usage:
+- [ ] Type hints on all function parameters
+- [ ] Type hints on return values
+- [ ] Annotations for class attributes
+- [ ] Use of `typing` for complex types (Optional, Union, List, Dict)
+- [ ] No MyPy errors in strict mode
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 python -m mypy /app --strict`
+
+**Reference**: `rules/03-coding-standards.md` section "Type Hints"
+
+### Step 3: Linting with Ruff
+
+Analyze code with Ruff (replaces Flake8, isort, pydocstyle):
+- [ ] No unused imports
+- [ ] No unused variables
+- [ ] No dead code (unreachable code)
+- [ ] Acceptable cyclomatic complexity (<10)
+- [ ] Security rules respected (S-rules)
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 pip install ruff && ruff check /app`
+
+**Reference**: `rules/06-tooling.md` section "Linting and Formatting"
+
+### Step 4: Formatting with Black
+
+Verify formatting consistency:
+- [ ] Code formatted with Black
+- [ ] Black configuration in pyproject.toml
+- [ ] No differences after `black --check`
+- [ ] Consistent line length (88 characters)
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 pip install black && black --check /app`
+
+**Reference**: `rules/06-tooling.md` section "Code Formatting"
+
+### Step 5: KISS, DRY, YAGNI Principles
+
+Analyze code simplicity and clarity:
+- [ ] Short functions (<20 lines ideally)
+- [ ] No code duplication (DRY)
+- [ ] No over-engineering (YAGNI)
+- [ ] Explicit and self-documenting naming
+- [ ] Single level of abstraction per function
+- [ ] Early returns to reduce complexity
+
+**Reference**: `rules/05-kiss-dry-yagni.md`
+
+### Step 6: Comments and Documentation
+
+Evaluate documentation quality:
+- [ ] Google or NumPy style docstrings
+- [ ] Comments only for "why", not "what"
+- [ ] Complete README.md with setup and usage
+- [ ] No commented code (use git)
+- [ ] Documentation of important architectural decisions
+
+**Reference**: `rules/03-coding-standards.md` section "Documentation"
+
+### Step 7: Error Handling
+
+Verify code robustness:
+- [ ] Specific exceptions (not generic Exception)
+- [ ] No silent `pass` in except
+- [ ] Informative error messages
+- [ ] User input validation
+- [ ] Proper resource management (context managers)
+
+**Reference**: `rules/03-coding-standards.md` section "Error Handling"
+
+### Step 8: Calculate Score
+
+Point attribution (out of 25):
+- PEP8 and formatting: 5 points
+- Type hints and MyPy: 5 points
+- Ruff linting: 4 points
+- KISS/DRY/YAGNI: 4 points
+- Documentation: 4 points
+- Error handling: 3 points
+
+## OUTPUT FORMAT
+
+```
+PYTHON CODE QUALITY AUDIT
+================================
+
+OVERALL SCORE: XX/25
+
+STRENGTHS:
+- [List of good practices observed]
+
+IMPROVEMENTS:
+- [List of minor improvements]
+
+CRITICAL ISSUES:
+- [List of serious standards violations]
+
+DETAILS BY CATEGORY:
+
+1. PEP8 AND FORMATTING (XX/5)
+   Status: [Python standards compliance]
+   Flake8 Errors: XX
+   Black Differences: XX files
+
+2. TYPE HINTS (XX/5)
+   Status: [Static typing coverage]
+   MyPy Errors: XX
+   Coverage: XX%
+
+3. RUFF LINTING (XX/4)
+   Status: [Code quality]
+   Warnings: XX
+   Unused Imports: XX
+   Max Complexity: XX
+
+4. KISS/DRY/YAGNI (XX/4)
+   Status: [Simplicity and clarity]
+   Functions >20 lines: XX
+   Duplicated Code: XX instances
+
+5. DOCUMENTATION (XX/4)
+   Status: [Documentation quality]
+   Missing Docstrings: XX
+   Coverage: XX%
+
+6. ERROR HANDLING (XX/3)
+   Status: [Code robustness]
+   Generic Exceptions: XX
+   `except pass`: XX
+
+TOP 3 PRIORITY ACTIONS:
+1. [Most critical action to improve quality]
+2. [Second priority action]
+3. [Third priority action]
+```
+
+## NOTES
+
+- Run all available linting tools in the project
+- Use Docker to abstract from local environment
+- Provide examples of problematic files/lines
+- Suggest automatable corrections (pre-commit hooks)
+- Prioritize quick wins (auto formatting) vs deep refactoring

package/Dev/i18n/en/Python/commands/check-compliance.md

@@ -0,0 +1,260 @@
+---
+description: Check Complete Python Compliance
+argument-hint: [arguments]
+---
+
+# Check Complete Python Compliance
+
+## Arguments
+
+$ARGUMENTS (optional: path to project to analyze)
+
+## MISSION
+
+Perform a complete compliance audit of the Python project by orchestrating the 4 major checks: Architecture, Code Quality, Tests, and Security. Produce a consolidated report with an overall score out of 100 points.
+
+### Step 1: Audit Preparation
+
+Prepare audit environment:
+- [ ] Identify project path to audit
+- [ ] Verify presence of configuration files (pyproject.toml, requirements.txt)
+- [ ] List main directories (src/, tests/, etc.)
+- [ ] Identify project structure
+
+**Note**: If $ARGUMENTS provided, use it as project path, otherwise use current directory.
+
+### Step 2: Architecture Audit (25 points)
+
+Execute complete architecture check:
+
+**Command**: Use slash command `/check-architecture` or manually follow steps in `check-architecture.md`
+
+**Evaluated Criteria**:
+- Structure and layer separation (6 pts)
+- Dependency respect (6 pts)
+- Ports and Adapters (4 pts)
+- Domain modeling (4 pts)
+- Use Cases and Services (3 pts)
+- SOLID Principles (2 pts)
+
+**Reference**: `claude-commands/python/check-architecture.md`
+
+### Step 3: Code Quality Audit (25 points)
+
+Execute code quality check:
+
+**Command**: Use slash command `/check-code-quality` or manually follow steps in `check-code-quality.md`
+
+**Evaluated Criteria**:
+- PEP8 and formatting (5 pts)
+- Type hints and MyPy (5 pts)
+- Ruff linting (4 pts)
+- KISS/DRY/YAGNI (4 pts)
+- Documentation (4 pts)
+- Error handling (3 pts)
+
+**Reference**: `claude-commands/python/check-code-quality.md`
+
+### Step 4: Testing Audit (25 points)
+
+Execute testing check:
+
+**Command**: Use slash command `/check-testing` or manually follow steps in `check-testing.md`
+
+**Evaluated Criteria**:
+- Code coverage (7 pts)
+- Unit tests (6 pts)
+- Integration tests (4 pts)
+- Assertion quality (3 pts)
+- Fixtures and organization (3 pts)
+- Performance (2 pts)
+
+**Reference**: `claude-commands/python/check-testing.md`
+
+### Step 5: Security Audit (25 points)
+
+Execute security check:
+
+**Command**: Use slash command `/check-security` or manually follow steps in `check-security.md`
+
+**Evaluated Criteria**:
+- Bandit scan (6 pts)
+- Secrets and credentials (5 pts)
+- Input validation (4 pts)
+- Secure dependencies (4 pts)
+- Error handling (3 pts)
+- Auth/Authz (2 pts)
+- Injections (1 pt)
+
+**Reference**: `claude-commands/python/check-security.md`
+
+### Step 6: Consolidation and Global Scoring
+
+Calculate overall score and produce consolidated report:
+- [ ] Sum the 4 scores (max 100 points)
+- [ ] Identify critical categories (<50%)
+- [ ] List all critical cross-cutting issues
+- [ ] Prioritize actions by impact/effort
+- [ ] Produce final consolidated report
+
+**Grading Scale**:
+- 90-100: Excellent - Reference project
+- 75-89: Very Good - Some minor improvements
+- 60-74: Acceptable - Requires improvements
+- 40-59: Insufficient - Major refactoring required
+- 0-39: Critical - Complete overhaul necessary
+
+### Step 7: Recommendations and Action Plan
+
+Produce final recommendations:
+- [ ] Identify top 3 priority actions across all categories
+- [ ] Estimate effort (Low/Medium/High) for each action
+- [ ] Estimate impact (Low/Medium/High) for each action
+- [ ] Propose implementation order
+- [ ] Suggest quick wins (high impact/effort ratio)
+
+## OUTPUT FORMAT
+
+```
+PYTHON COMPLIANCE AUDIT - COMPLETE REPORT
+=============================================
+
+OVERALL SCORE: XX/100
+
+COMPLIANCE LEVEL: [Excellent/Very Good/Acceptable/Insufficient/Critical]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+SCORES BY CATEGORY:
+
+ARCHITECTURE       : XX/25  [██████████░░░░░░░░░░] XX%
+CODE QUALITY       : XX/25  [██████████░░░░░░░░░░] XX%
+TESTS              : XX/25  [██████████░░░░░░░░░░] XX%
+SECURITY           : XX/25  [██████████░░░░░░░░░░] XX%
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+OVERALL STRENGTHS:
+1. [Strength identified in multiple categories]
+2. [Other major strength]
+3. [Third strength]
+
+OVERALL IMPROVEMENTS:
+1. [Minor cross-cutting improvement]
+2. [Other recommended improvement]
+3. [Third improvement]
+
+CRITICAL ISSUES:
+1. [Critical issue #1 - affected category]
+2. [Critical issue #2 - affected category]
+3. [Critical issue #3 - affected category]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+DETAILS BY CATEGORY:
+
+┌─────────────────────────────────────────────┐
+│ ARCHITECTURE (XX/25)                        │
+└─────────────────────────────────────────────┘
+
+Sub-scores:
+  • Structure and layers     : XX/6
+  • Dependencies             : XX/6
+  • Ports and Adapters       : XX/4
+  • Domain Modeling          : XX/4
+  • Use Cases                : XX/3
+  • SOLID Principles         : XX/2
+
+Strengths:
+- [Architecture strengths]
+
+Issues:
+- [Architecture issues]
+
+[Similar sections for Code Quality, Tests, and Security...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+TOP 3 PRIORITY ACTIONS (ALL CATEGORIES):
+
+1. CRITICAL - [Action #1]
+   Category  : [Architecture/Quality/Tests/Security]
+   Impact    : [High/Medium/Low]
+   Effort    : [High/Medium/Low]
+   Priority  : IMMEDIATE
+
+   Detailed description:
+   [Explanation of problem and proposed solution]
+
+   Affected files:
+   - [file:line]
+
+   Correction example:
+   [Code or correction command]
+
+2. IMPORTANT - [Action #2]
+   [Same format...]
+
+3. RECOMMENDED - [Action #3]
+   [Same format...]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+QUICK WINS (High Impact / Low Effort):
+
+- [Quick win #1] - Category: [X] - Impact: [X] - Effort: [X]
+- [Quick win #2] - Category: [X] - Impact: [X] - Effort: [X]
+- [Quick win #3] - Category: [X] - Impact: [X] - Effort: [X]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+RECOMMENDED ACTION PLAN:
+
+WEEK 1 (Immediate):
+- [ ] [Critical action #1]
+- [ ] [Priority quick win]
+
+WEEK 2-4 (Short term):
+- [ ] [Important action #2]
+- [ ] [Other quick wins]
+
+MONTH 2-3 (Medium term):
+- [ ] [Recommended action #3]
+- [ ] [Progressive improvements]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+REFERENCES:
+
+Architecture     : rules/02-architecture.md
+Coding Standards : rules/03-coding-standards.md
+SOLID            : rules/04-solid-principles.md
+KISS/DRY/YAGNI   : rules/05-kiss-dry-yagni.md
+Tooling          : rules/06-tooling.md
+Testing          : rules/07-testing.md
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+EXECUTIVE SUMMARY:
+
+[Summary paragraph on overall project state, major strengths,
+major weaknesses, and recommended trajectory to improve
+compliance. Mention if project is production-ready,
+requires corrections, or needs refactoring.]
+
+General Recommendation: [Production-ready / Minor corrections /
+Major refactoring / Overhaul necessary]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## IMPORTANT NOTES
+
+- This command orchestrates the 4 specialized audits
+- Use Docker for all analysis tools
+- Provide concrete examples with file:line for each problem
+- Prioritize actions based on Impact/Effort matrix
+- Security problems are ALWAYS top priority
+- Propose automatable corrections (scripts, pre-commit hooks)
+- Report must be actionable, not just descriptive
+- Adapt recommendations to project business context

package/Dev/i18n/en/Python/commands/check-security.md

@@ -0,0 +1,207 @@
+---
+description: Check Python Security
+argument-hint: [arguments]
+---
+
+# Check Python Security
+
+## Arguments
+
+$ARGUMENTS (optional: path to project to analyze)
+
+## MISSION
+
+Perform a complete security audit of the Python project by identifying vulnerabilities, exposed secrets, and security bad practices defined in project rules.
+
+### Step 1: Security Analysis with Bandit
+
+Scan code with Bandit to detect vulnerabilities:
+- [ ] No hardcoded passwords/secrets
+- [ ] No use of `eval()` or `exec()`
+- [ ] No insecure deserialization (pickle)
+- [ ] No SQL injection (ORM or parameterized queries)
+- [ ] No shell command injection
+- [ ] Secure cryptography (not MD5/SHA1)
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install bandit && bandit -r /app -f json"`
+
+**Reference**: `rules/06-tooling.md` section "Security Analysis"
+
+### Step 2: Secret Detection
+
+Search for secrets and credentials in code:
+- [ ] No API keys in source code
+- [ ] No tokens in files
+- [ ] No plain text passwords
+- [ ] Environment variables for sensitive configuration
+- [ ] .env in .gitignore
+- [ ] .env.example provided (without real values)
+
+**Command**: Use grep/search to detect secret patterns
+
+**Patterns to search**:
+- `password\s*=\s*["'][^"']+["']`
+- `api_key\s*=\s*["'][^"']+["']`
+- `secret\s*=\s*["'][^"']+["']`
+- `token\s*=\s*["'][^"']+["']`
+
+**Reference**: `rules/03-coding-standards.md` section "Security Best Practices"
+
+### Step 3: User Input Validation
+
+Verify data validation and sanitization:
+- [ ] Validation of all user inputs
+- [ ] Use of Pydantic for validation
+- [ ] Data sanitization before processing
+- [ ] No blind trust in external data
+- [ ] Type and format validation
+- [ ] Limits on input size
+
+**Reference**: `rules/03-coding-standards.md` section "Input Validation"
+
+### Step 4: Dependencies and Vulnerabilities
+
+Analyze dependencies for known vulnerabilities:
+- [ ] No dependencies with critical CVEs
+- [ ] Up-to-date library versions
+- [ ] requirements.txt with pinned versions
+- [ ] Use of `pip-audit` or `safety`
+- [ ] No obsolete dependencies
+
+**Command**: Run `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install pip-audit && pip-audit --requirement /app/requirements.txt"`
+
+**Reference**: `rules/06-tooling.md` section "Dependency Management"
+
+### Step 5: Error and Log Management
+
+Check secure error handling:
+- [ ] No exposed stack traces in production
+- [ ] Generic error messages for users
+- [ ] Secure logs (no sensitive data)
+- [ ] No debug mode in production
+- [ ] Proper exception handling
+- [ ] Logging of security events
+
+**Reference**: `rules/03-coding-standards.md` section "Error Handling"
+
+### Step 6: Authentication and Authorization
+
+Verify authentication security:
+- [ ] No manual password management (use bcrypt/argon2)
+- [ ] JWT tokens with expiration
+- [ ] HTTPS mandatory for sensitive endpoints
+- [ ] CSRF protection if applicable
+- [ ] Rate limiting on sensitive endpoints
+- [ ] Permission validation (RBAC/ABAC)
+
+**Reference**: `rules/02-architecture.md` section "Security Layer"
+
+### Step 7: Configuration and Environment
+
+Analyze security configuration:
+- [ ] Environment variables for secrets
+- [ ] Different configuration per environment (dev/staging/prod)
+- [ ] No secrets in docker-compose.yml
+- [ ] Secrets in environment variables or vault
+- [ ] Documented .env.example
+- [ ] DEBUG=False in production
+
+**Reference**: `rules/06-tooling.md` section "Environment Configuration"
+
+### Step 8: Injection and XSS
+
+Verify protection against injections:
+- [ ] No SQL injection (ORM or parameterized queries)
+- [ ] Data escaping in templates
+- [ ] No command injection (secure subprocess)
+- [ ] File path validation (path traversal)
+- [ ] Content-Security-Policy if web application
+- [ ] HTML input sanitization
+
+**Reference**: `rules/03-coding-standards.md` section "Security Best Practices"
+
+### Step 9: Calculate Score
+
+Point attribution (out of 25):
+- Bandit (vulnerabilities): 6 points
+- Secrets and credentials: 5 points
+- Input validation: 4 points
+- Secure dependencies: 4 points
+- Error handling: 3 points
+- Auth/Authz: 2 points
+- Injection/XSS: 1 point
+
+## OUTPUT FORMAT
+
+```
+PYTHON SECURITY AUDIT
+================================
+
+OVERALL SCORE: XX/25
+
+STRENGTHS:
+- [List of observed security good practices]
+
+IMPROVEMENTS:
+- [List of minor security improvements]
+
+CRITICAL ISSUES:
+- [List of critical vulnerabilities to fix IMMEDIATELY]
+
+DETAILS BY CATEGORY:
+
+1. BANDIT SCAN (XX/6)
+   Status: [Vulnerability analysis]
+   Critical Issues: XX
+   Medium Issues: XX
+   Low Issues: XX
+
+2. EXPOSED SECRETS (XX/5)
+   Status: [Secret detection]
+   Hardcoded Secrets: XX
+   Secure .env Files: ✅/❌
+
+3. INPUT VALIDATION (XX/4)
+   Status: [Validation and sanitization]
+   Unvalidated Inputs: XX
+   Pydantic Usage: ✅/❌
+
+4. DEPENDENCIES (XX/4)
+   Status: [Dependency vulnerabilities]
+   Critical CVEs: XX
+   Medium CVEs: XX
+   Obsolete Dependencies: XX
+
+5. ERROR HANDLING (XX/3)
+   Status: [Error and log security]
+   Exposed Stack Traces: XX
+   Sensitive Data in Logs: XX
+
+6. AUTHENTICATION (XX/2)
+   Status: [Auth/Authz]
+   Secure Hashing: ✅/❌
+   JWT with Expiration: ✅/❌
+
+7. INJECTIONS (XX/1)
+   Status: [Injection protection]
+   SQL Injection Risks: XX
+   Command Injection Risks: XX
+
+CRITICAL VULNERABILITIES:
+[Detailed list of vulnerabilities to fix immediately with file:line]
+
+TOP 3 PRIORITY ACTIONS:
+1. [Most critical security action - URGENT]
+2. [Second priority action - IMPORTANT]
+3. [Third priority action - RECOMMENDED]
+```
+
+## NOTES
+
+- Security issues MUST be treated with absolute priority
+- Use Docker to run security tools
+- Provide exact file and line for each vulnerability
+- Propose concrete corrections for each problem
+- Document risks and potential impact
+- Test suggested fixes
+- NEVER commit secrets in code