gwc-pybundle 2.1.2__py3-none-any.whl

pybundle/steps/migration_history.py

@@ -0,0 +1,336 @@
+"""
+Step: Migration History Tracking
+Analyze database migrations and track migration status.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Optional
+
+from .base import Step, StepResult
+
+
+class MigrationHistoryStep(Step):
+    """Track and analyze database migrations."""
+
+    name = "migration history"
+
+    def run(self, ctx: "BundleContext") -> StepResult:  # type: ignore[name-defined]
+        """Analyze database migrations."""
+        import time
+
+        start = time.time()
+
+        root = ctx.root
+
+        # Find migrations
+        migrations = self._find_migrations(root)
+
+        # Generate report
+        lines = [
+            "=" * 80,
+            "DATABASE MIGRATION ANALYSIS REPORT",
+            "=" * 80,
+            "",
+        ]
+
+        # Summary
+        lines.extend(
+            [
+                "SUMMARY",
+                "=" * 80,
+                "",
+                f"Migration frameworks detected: {len(migrations['frameworks'])}",
+                f"Total migration files found: {migrations['total_migrations']}",
+                "",
+            ]
+        )
+
+        if not migrations["frameworks"]:
+            lines.extend(
+                [
+                    "⊘ No database migrations detected",
+                    "",
+                    "This project does not appear to use database migrations.",
+                    "Consider using migrations for schema versioning and deployment.",
+                    "",
+                ]
+            )
+        else:
+            # Framework breakdown
+            lines.extend(
+                [
+                    "MIGRATION FRAMEWORKS DETECTED",
+                    "=" * 80,
+                    "",
+                ]
+            )
+
+            for framework, details in migrations["frameworks"].items():
+                lines.append(f"✓ {framework}")
+                lines.append(f"  Location: {details['location']}")
+                lines.append(f"  Migration count: {len(details['migrations'])}")
+
+                if details["migrations"]:
+                    lines.append("  Files:")
+                    for mig_file in sorted(details["migrations"])[:10]:
+                        lines.append(f"    - {mig_file}")
+                    if len(details["migrations"]) > 10:
+                        lines.append(
+                            f"    ... and {len(details['migrations']) - 10} more"
+                        )
+
+                lines.append("")
+
+            # Django-specific analysis
+            if "Django" in migrations["frameworks"]:
+                django_info = migrations["frameworks"]["Django"]
+                lines.extend(
+                    [
+                        "DJANGO MIGRATIONS DETAIL",
+                        "=" * 80,
+                        "",
+                    ]
+                )
+
+                lines.append(f"Total Django migrations: {len(django_info['migrations'])}")
+
+                # Extract migration info
+                initial_count = sum(
+                    1
+                    for m in django_info["migrations"]
+                    if "0001_initial" in m or "initial" in m.lower()
+                )
+                lines.append(f"Initial migrations: {initial_count}")
+
+                # Check for dependencies
+                has_dependencies = self._check_django_dependencies(
+                    root, django_info["location"]
+                )
+                if has_dependencies:
+                    lines.append("✓ Migration dependencies detected")
+                else:
+                    lines.append("⚠ No migration dependencies detected")
+
+                lines.append("")
+
+                lines.append("Latest migrations:")
+                for mig_file in sorted(django_info["migrations"])[-5:]:
+                    lines.append(f"  - {mig_file}")
+
+                lines.append("")
+
+            # Alembic-specific analysis
+            if "Alembic" in migrations["frameworks"]:
+                alembic_info = migrations["frameworks"]["Alembic"]
+                lines.extend(
+                    [
+                        "ALEMBIC MIGRATIONS DETAIL",
+                        "=" * 80,
+                        "",
+                    ]
+                )
+
+                lines.append(f"Total Alembic versions: {len(alembic_info['migrations'])}")
+
+                # Check for downgrade capability
+                versions_with_downgrade = self._check_alembic_downgrades(
+                    root, alembic_info["location"]
+                )
+                lines.append(
+                    f"Versions with downgrade support: {versions_with_downgrade}"
+                )
+
+                lines.append("Latest versions:")
+                for mig_file in sorted(alembic_info["migrations"])[-5:]:
+                    lines.append(f"  - {mig_file}")
+
+                lines.append("")
+
+        # Migration statistics
+        if migrations["total_migrations"] > 0:
+            lines.extend(
+                [
+                    "=" * 80,
+                    "MIGRATION STATISTICS",
+                    "=" * 80,
+                    "",
+                ]
+            )
+
+            lines.append(f"Total migration files: {migrations['total_migrations']}")
+
+            # Check for common issues
+            issues = self._check_migration_issues(root, migrations)
+            if issues:
+                lines.append(f"Potential issues found: {len(issues)}")
+                lines.append("")
+                for issue in issues[:10]:
+                    lines.append(f"  ⚠ {issue}")
+                if len(issues) > 10:
+                    lines.append(f"  ... and {len(issues) - 10} more")
+            else:
+                lines.append("✓ No obvious migration issues detected")
+
+            lines.append("")
+
+        # Recommendations
+        lines.extend(
+            [
+                "=" * 80,
+                "RECOMMENDATIONS",
+                "=" * 80,
+                "",
+            ]
+        )
+
+        if migrations["frameworks"]:
+            lines.append("  - Review migration dependencies for circular references")
+            lines.append("  - Ensure downgrade paths are tested")
+            lines.append("  - Keep migration files in version control")
+            lines.append("  - Document any manual migrations")
+            lines.append("  - Test migrations in CI/CD pipeline")
+            lines.append("  - Consider squashing old migrations periodically")
+
+        else:
+            lines.append("  - Consider implementing database migrations")
+            lines.append("  - Django projects: python manage.py makemigrations")
+            lines.append("  - SQLAlchemy projects: alembic init migrations")
+            lines.append("  - Tortoise ORM: aerich init-db")
+            lines.append("  - Benefits: reproducible deployments, rollback capability")
+
+        lines.append("")
+
+        # Write report
+        output = "\n".join(lines)
+        dest = ctx.workdir / "meta" / "140_migrations.txt"
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(output, encoding="utf-8")
+
+        elapsed = int(time.time() - start)
+        return StepResult(self.name, "OK", elapsed, "")
+
+    def _find_migrations(self, root: Path) -> Dict:
+        """Find all migration directories and files."""
+        frameworks = {}
+        total_migrations = 0
+
+        # Django migrations
+        django_migrations = list(root.rglob("migrations"))
+        for mig_dir in django_migrations:
+            # Check if it's a Django migration directory
+            init_file = mig_dir / "__init__.py"
+            py_files = list(mig_dir.glob("*.py"))
+
+            if init_file.exists() and any(
+                f.name.startswith(("0001_", "0002_", "0003_")) or "000" in f.name
+                for f in py_files
+            ):
+                rel_path = str(mig_dir.relative_to(root))
+                migration_files = [
+                    f.name
+                    for f in py_files
+                    if f.name != "__init__.py" and f.name != "__pycache__"
+                ]
+                if migration_files:
+                    if "Django" not in frameworks:
+                        frameworks["Django"] = {"location": rel_path, "migrations": []}
+                    frameworks["Django"]["migrations"].extend(migration_files)
+                    total_migrations += len(migration_files)
+
+        # Alembic migrations
+        alembic_dirs = list(root.rglob("alembic"))
+        for alembic_dir in alembic_dirs:
+            versions_dir = alembic_dir / "versions"
+            if versions_dir.exists():
+                py_files = list(versions_dir.glob("*.py"))
+                migration_files = [f.name for f in py_files if f.name != "__init__.py"]
+                if migration_files:
+                    rel_path = str(alembic_dir.relative_to(root))
+                    frameworks["Alembic"] = {
+                        "location": rel_path,
+                        "migrations": migration_files,
+                    }
+                    total_migrations += len(migration_files)
+
+        # Check for Tortoise ORM migrations
+        tortoise_dirs = list(root.rglob("aerich_migrations"))
+        for tortoise_dir in tortoise_dirs:
+            py_files = list(tortoise_dir.glob("*.sql"))
+            if py_files:
+                rel_path = str(tortoise_dir.relative_to(root))
+                migration_files = [f.name for f in py_files]
+                frameworks["Tortoise ORM"] = {
+                    "location": rel_path,
+                    "migrations": migration_files,
+                }
+                total_migrations += len(migration_files)
+
+        return {
+            "frameworks": frameworks,
+            "total_migrations": total_migrations,
+        }
+
+    def _check_django_dependencies(self, root: Path, location: str) -> bool:
+        """Check if Django migrations have dependency information."""
+        mig_dir = root / location
+        if not mig_dir.exists():
+            return False
+
+        py_files = list(mig_dir.glob("*.py"))
+        for py_file in py_files:
+            if py_file.name == "__init__.py":
+                continue
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+                if "dependencies" in content and "[" in content:
+                    return True
+            except (OSError, UnicodeDecodeError):
+                continue
+
+        return False
+
+    def _check_alembic_downgrades(self, root: Path, location: str) -> int:
+        """Check how many Alembic versions have downgrade functions."""
+        versions_dir = root / location / "versions"
+        if not versions_dir.exists():
+            return 0
+
+        with_downgrade = 0
+        py_files = list(versions_dir.glob("*.py"))
+
+        for py_file in py_files:
+            try:
+                content = py_file.read_text(encoding="utf-8", errors="ignore")
+                if "def downgrade()" in content or "def downgrade():" in content:
+                    with_downgrade += 1
+            except (OSError, UnicodeDecodeError):
+                continue
+
+        return with_downgrade
+
+    def _check_migration_issues(self, root: Path, migrations: Dict) -> List[str]:
+        """Check for common migration issues."""
+        issues = []
+
+        # Check for migration files without corresponding reverse
+        if "Alembic" in migrations["frameworks"]:
+            alembic_info = migrations["frameworks"]["Alembic"]
+            alembic_dir = root / alembic_info["location"]
+            versions_dir = alembic_dir / "versions"
+
+            if versions_dir.exists():
+                for py_file in versions_dir.glob("*.py"):
+                    try:
+                        content = py_file.read_text(encoding="utf-8", errors="ignore")
+                        if "def upgrade()" in content and "def downgrade()" not in content:
+                            if "pass" not in content.split("def downgrade()")[1].split(
+                                "\n"
+                            )[0]:
+                                issues.append(
+                                    f"Missing downgrade path in {py_file.name}"
+                                )
+                    except (OSError, UnicodeDecodeError, IndexError):
+                        continue
+
+        return issues

pybundle/steps/mutation_testing.py

@@ -0,0 +1,141 @@
+"""
+Mutation testing with mutmut - Milestone 4 (v1.4.1)
+"""
+
+from __future__ import annotations
+
+import subprocess
+import time
+from dataclasses import dataclass
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+@dataclass
+class MutationTestingStep:
+    """
+    Mutation testing to measure test suite effectiveness.
+
+    EXPENSIVE: Disabled by default. Run many test executions with code mutations.
+
+    Outputs:
+    - logs/72_mutation_testing.txt: Mutation testing results
+    """
+
+    name: str = "mutation_testing"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+
+        # Only run if explicitly enabled (very slow!)
+        if not ctx.options.enable_mutation_testing:
+            return StepResult(
+                self.name, "SKIP", 0, "mutation testing not enabled (slow!)"
+            )
+
+        # Check for mutmut
+        mutmut = which("mutmut")
+        if not mutmut:
+            output_file = ctx.workdir / "logs" / "72_mutation_testing.txt"
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            output_file.write_text(
+                "mutmut not found; install with: pip install mutmut\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "mutmut not installed")
+
+        if not ctx.tools.pytest:
+            return StepResult(self.name, "SKIP", 0, "pytest not found")
+
+        tests_dir = ctx.root / "tests"
+        if not tests_dir.is_dir():
+            return StepResult(self.name, "SKIP", 0, "no tests/ directory")
+
+        ctx.emit("  ⚠️  Running mutation testing (this may take several minutes)...")
+
+        output_file = ctx.workdir / "logs" / "72_mutation_testing.txt"
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # Run mutmut
+            # First, run mutmut run to generate mutations
+            run_result = subprocess.run(
+                [mutmut, "run", "--paths-to-mutate", "."],
+                cwd=ctx.root,
+                capture_output=True,
+                text=True,
+                timeout=600,  # 10 minute timeout (mutation testing is SLOW)
+            )
+
+            # Then get results summary
+            results_result = subprocess.run(
+                [mutmut, "results"],
+                cwd=ctx.root,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            # Generate report
+            with output_file.open("w") as f:
+                f.write("=" * 70 + "\n")
+                f.write("MUTATION TESTING (mutmut)\n")
+                f.write("=" * 70 + "\n")
+                f.write("⚠️  WARNING: Mutation testing is VERY SLOW\n")
+                f.write("=" * 70 + "\n\n")
+
+                f.write("MUTATION RUN OUTPUT:\n")
+                f.write("-" * 70 + "\n")
+                f.write(run_result.stdout)
+                if run_result.stderr:
+                    f.write("\nErrors:\n")
+                    f.write(run_result.stderr)
+
+                f.write("\n" + "=" * 70 + "\n")
+                f.write("MUTATION RESULTS SUMMARY:\n")
+                f.write("-" * 70 + "\n")
+                f.write(results_result.stdout)
+                if results_result.stderr:
+                    f.write("\nErrors:\n")
+                    f.write(results_result.stderr)
+
+                f.write("\n" + "=" * 70 + "\n")
+                f.write("INTERPRETATION:\n")
+                f.write("-" * 70 + "\n")
+                f.write("- Killed mutations: Your tests caught the bug (GOOD!)\n")
+                f.write("- Survived mutations: Your tests missed the bug (BAD!)\n")
+                f.write("- Timeout/Suspicious: Tests took too long or behaved oddly\n")
+                f.write("\n")
+                f.write("Mutation Score = Killed / (Killed + Survived + Timeout)\n")
+                f.write("Target: >80% mutation score for well-tested code\n")
+                f.write("\n")
+                f.write("To see specific survived mutations:\n")
+                f.write("  mutmut show <id>\n")
+                f.write("\n")
+                f.write("=" * 70 + "\n")
+                f.write("RECOMMENDATIONS:\n")
+                f.write("- Add tests for survived mutations\n")
+                f.write("- Focus on edge cases and boundary conditions\n")
+                f.write("- Improve assertion quality (not just 'assert result')\n")
+
+            elapsed = int((time.time() - start) * 1000)
+
+            if run_result.returncode == 0:
+                return StepResult(self.name, "OK", elapsed)
+            else:
+                return StepResult(
+                    self.name, "FAIL", elapsed, f"exit {run_result.returncode}"
+                )
+
+        except subprocess.TimeoutExpired:
+            elapsed = int((time.time() - start) * 1000)
+            with output_file.open("w") as f:
+                f.write("Mutation testing timed out after 10 minutes\n")
+                f.write(
+                    "Consider testing a smaller subset or using --paths-to-mutate\n"
+                )
+            return StepResult(self.name, "FAIL", elapsed, "timeout")
+        except Exception as e:
+            elapsed = int((time.time() - start) * 1000)
+            return StepResult(self.name, "FAIL", elapsed, str(e))

pybundle/steps/mypy.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import subprocess  # nosec B404 - Required for tool execution, paths validated
+import time
+import sys
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .base import StepResult
+from ..context import BundleContext
+from ..tools import which
+
+
+def _has_mypy_config(root: Path) -> bool:
+    if (root / "mypy.ini").is_file():
+        return True
+    if (root / "setup.cfg").is_file():
+        return True
+    if (root / "pyproject.toml").is_file():
+        # we don't parse TOML here; presence is enough for v1
+        return True
+    return False
+
+
+def _check_python_version_mismatch(root: Path) -> tuple[str | None, str | None]:
+    """Check for Python version mismatch between runtime and mypy config.
+    
+    Returns (runtime_version, config_version) where config_version is from mypy.ini
+    """
+    # Get runtime Python version (e.g., "3.11")
+    runtime_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+    
+    # Check mypy.ini for python_version
+    mypy_ini = root / "mypy.ini"
+    if mypy_ini.is_file():
+        try:
+            content = mypy_ini.read_text(encoding="utf-8")
+            match = re.search(r'^python_version\s*=\s*["\']?(\d+\.\d+)', content, re.MULTILINE)
+            if match:
+                config_version = match.group(1)
+                if config_version != runtime_version:
+                    return (runtime_version, config_version)
+        except Exception:
+            pass
+    
+    return (None, None)
+
+
+@dataclass
+class MypyStep:
+    name: str = "mypy"
+    target: str = "pybundle"
+    outfile: str = "logs/33_mypy.txt"
+
+    def run(self, ctx: BundleContext) -> StepResult:
+        start = time.time()
+        out = ctx.workdir / self.outfile
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        mypy = which("mypy")
+        if not mypy:
+            out.write_text(
+                "mypy not found; skipping (pip install mypy)\n", encoding="utf-8"
+            )
+            return StepResult(self.name, "SKIP", 0, "missing mypy")
+
+        if not _has_mypy_config(ctx.root):
+            out.write_text(
+                "no mypy config detected (mypy.ini/setup.cfg/pyproject.toml); skipping\n",
+                encoding="utf-8",
+            )
+            return StepResult(self.name, "SKIP", 0, "no config")
+
+        # Check for Python version mismatch
+        runtime_ver, config_ver = _check_python_version_mismatch(ctx.root)
+        version_warning = ""
+        if runtime_ver and config_ver:
+            version_warning = (
+                f"\n⚠ WARNING: Python version mismatch!\n"
+                f"  Runtime: Python {runtime_ver}\n"
+                f"  mypy.ini: python_version = {config_ver}\n"
+                f"  This may allow/reject syntax that won't work at runtime.\n"
+                f"  Recommendation: Set mypy.ini python_version = {runtime_ver}\n\n"
+            )
+
+        cmd = [mypy, "--exclude", "^artifacts/", self.target]
+        header = f"## PWD: {ctx.root}\n## CMD: {' '.join(cmd)}\n{version_warning}\n"
+
+        cp = subprocess.run(  # nosec B603
+            cmd, cwd=str(ctx.root), text=True, capture_output=True, check=False
+        )
+        text = header + (cp.stdout or "") + ("\n" + cp.stderr if cp.stderr else "")
+        out.write_text(ctx.redact_text(text), encoding="utf-8")
+
+        dur = int(time.time() - start)
+        note = "" if cp.returncode == 0 else f"exit={cp.returncode} (type findings)"
+        
+        # Add version warning to note if present
+        if version_warning:
+            note = (note + "; " if note else "") + f"Python {runtime_ver} vs config {config_ver}"
+        
+        return StepResult(self.name, "PASS", dur, note)