crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/services/git.py

@@ -3,35 +3,63 @@ from pathlib import Path
 
 from rich.console import Console
 
+from .secure_subprocess import execute_secure_subprocess
+from .security_logger import get_security_logger
+
+
+class FailedGitResult:
+    """A Git result object compatible with subprocess.CompletedProcess."""
+
+    def __init__(self, command: list[str], error: str) -> None:
+        self.args = command
+        self.returncode = -1
+        self.stdout = ""
+        self.stderr = f"Git security validation failed: {error}"
+
 
 class GitService:
     def __init__(self, console: Console, pkg_path: Path | None = None) -> None:
         self.console = console
         self.pkg_path = pkg_path or Path.cwd()
 
-    def _run_git_command(self, args: list[str]) -> subprocess.CompletedProcess[str]:
+    def _run_git_command(
+        self, args: list[str]
+    ) -> subprocess.CompletedProcess[str] | FailedGitResult:
+        """Execute Git commands with secure subprocess validation."""
         cmd = ["git", *args]
-        return subprocess.run(
-            cmd,
-            check=False,
-            cwd=self.pkg_path,
-            capture_output=True,
-            text=True,
-            timeout=60,
-        )
+
+        try:
+            return execute_secure_subprocess(
+                command=cmd,
+                cwd=self.pkg_path,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                check=False,  # Don't raise on non-zero exit codes
+            )
+        except Exception as e:
+            # Log security issues but return a compatible result
+            security_logger = get_security_logger()
+            security_logger.log_subprocess_failure(
+                command=cmd,
+                exit_code=-1,
+                error_output=str(e),
+            )
+
+            # Create compatible result for Git operations
+            return FailedGitResult(cmd, str(e))
 
     def is_git_repo(self) -> bool:
         try:
-            result = self._run_git_command(["rev-parse", "--git-dir"])
+            result = self._run_git_command(["rev-parse", "- - git-dir"])
             return result.returncode == 0
         except (subprocess.SubprocessError, OSError, FileNotFoundError):
             return False
 
     def get_changed_files(self) -> list[str]:
         try:
-            # Get staged files excluding deletions
             staged_result = self._run_git_command(
-                ["diff", "--cached", "--name-only", "--diff-filter=ACMRT"]
+                ["diff", "--cached", "- - name-only", "- - diff-filter=ACMRT"]
             )
             staged_files = (
                 staged_result.stdout.strip().split("\n")
@@ -39,9 +67,8 @@ class GitService:
                 else []
             )
 
-            # Get unstaged files excluding deletions
             unstaged_result = self._run_git_command(
-                ["diff", "--name-only", "--diff-filter=ACMRT"]
+                ["diff", "- - name-only", "- - diff-filter=ACMRT"]
             )
             unstaged_files = (
                 unstaged_result.stdout.strip().split("\n")
@@ -49,9 +76,8 @@ class GitService:
                 else []
             )
 
-            # Get untracked files
             untracked_result = self._run_git_command(
-                ["ls-files", "--others", "--exclude-standard"],
+                ["ls-files", "--others", "- - exclude-standard"],
             )
             untracked_files = (
                 untracked_result.stdout.strip().split("\n")
@@ -62,15 +88,15 @@ class GitService:
             all_files = set(staged_files + unstaged_files + untracked_files)
             return [f for f in all_files if f]
         except Exception as e:
-            self.console.print(f"[yellow]⚠️[/yellow] Error getting changed files: {e}")
+            self.console.print(f"[yellow]⚠️[/ yellow] Error getting changed files: {e}")
             return []
 
     def get_staged_files(self) -> list[str]:
         try:
-            result = self._run_git_command(["diff", "--cached", "--name-only"])
+            result = self._run_git_command(["diff", "--cached", "- - name-only"])
             return result.stdout.strip().split("\n") if result.stdout.strip() else []
         except Exception as e:
-            self.console.print(f"[yellow]⚠️[/yellow] Error getting staged files: {e}")
+            self.console.print(f"[yellow]⚠️[/ yellow] Error getting staged files: {e}")
             return []
 
     def add_files(self, files: list[str]) -> bool:
@@ -79,30 +105,29 @@ class GitService:
                 result = self._run_git_command(["add", file])
                 if result.returncode != 0:
                     self.console.print(
-                        f"[red]❌[/red] Failed to add {file}: {result.stderr}",
+                        f"[red]❌[/ red] Failed to add {file}: {result.stderr}",
                     )
                     return False
             return True
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error adding files: {e}")
+            self.console.print(f"[red]❌[/ red] Error adding files: {e}")
             return False
 
     def commit(self, message: str) -> bool:
         try:
-            result = self._run_git_command(["commit", "-m", message])
+            result = self._run_git_command(["commit", "- m", message])
             if result.returncode == 0:
-                self.console.print(f"[green]✅[/green] Committed: {message}")
+                self.console.print(f"[green]✅[/ green] Committed: {message}")
                 return True
 
             return self._handle_commit_failure(result, message)
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error committing: {e}")
+            self.console.print(f"[red]❌[/ red] Error committing: {e}")
             return False
 
     def _handle_commit_failure(
-        self, result: subprocess.CompletedProcess[str], message: str
+        self, result: subprocess.CompletedProcess[str] | FailedGitResult, message: str
     ) -> bool:
-        # Check if pre-commit hooks modified files and need re-staging
         if "files were modified by this hook" in result.stderr:
             return self._retry_commit_after_restage(message)
 
@@ -110,57 +135,56 @@ class GitService:
 
     def _retry_commit_after_restage(self, message: str) -> bool:
         self.console.print(
-            "[yellow]🔄[/yellow] Pre-commit hooks modified files - attempting to re-stage and retry commit"
+            "[yellow]🔄[/ yellow] Pre - commit hooks modified files - attempting to re-stage and retry commit"
         )
 
-        # Re-stage all modified files
-        add_result = self._run_git_command(["add", "-u"])
+        add_result = self._run_git_command(["add", "- u"])
         if add_result.returncode != 0:
             self.console.print(
-                f"[red]❌[/red] Failed to re-stage files: {add_result.stderr}"
+                f"[red]❌[/ red] Failed to re-stage files: {add_result.stderr}"
             )
             return False
 
-        # Retry the commit
-        retry_result = self._run_git_command(["commit", "-m", message])
+        retry_result = self._run_git_command(["commit", "- m", message])
         if retry_result.returncode == 0:
             self.console.print(
-                f"[green]✅[/green] Committed after re-staging: {message}"
+                f"[green]✅[/ green] Committed after re-staging: {message}"
             )
             return True
 
         self.console.print(
-            f"[red]❌[/red] Commit failed on retry: {retry_result.stderr}"
+            f"[red]❌[/ red] Commit failed on retry: {retry_result.stderr}"
         )
         return False
 
-    def _handle_hook_error(self, result: subprocess.CompletedProcess[str]) -> bool:
-        # When git commit fails due to pre-commit hooks, stderr contains hook output
+    def _handle_hook_error(
+        self, result: subprocess.CompletedProcess[str] | FailedGitResult
+    ) -> bool:
         if "pre-commit" in result.stderr or "hook" in result.stderr.lower():
-            self.console.print("[red]❌[/red] Commit blocked by pre-commit hooks")
+            self.console.print("[red]❌[/ red] Commit blocked by pre-commit hooks")
             if result.stderr.strip():
                 self.console.print(
-                    f"[yellow]Hook output:[/yellow]\n{result.stderr.strip()}"
+                    f"[yellow]Hook output: [/ yellow]\n{result.stderr.strip()}"
                 )
         else:
-            self.console.print(f"[red]❌[/red] Commit failed: {result.stderr}")
+            self.console.print(f"[red]❌[/ red] Commit failed: {result.stderr}")
         return False
 
     def push(self) -> bool:
         try:
             result = self._run_git_command(["push"])
             if result.returncode == 0:
-                self.console.print("[green]✅[/green] Pushed to remote")
+                self.console.print("[green]✅[/ green] Pushed to remote")
                 return True
-            self.console.print(f"[red]❌[/red] Push failed: {result.stderr}")
+            self.console.print(f"[red]❌[/ red] Push failed: {result.stderr}")
             return False
         except Exception as e:
-            self.console.print(f"[red]❌[/red] Error pushing: {e}")
+            self.console.print(f"[red]❌[/ red] Error pushing: {e}")
             return False
 
     def get_current_branch(self) -> str | None:
         try:
-            result = self._run_git_command(["branch", "--show-current"])
+            result = self._run_git_command(["branch", "- - show-current"])
             return result.stdout.strip() if result.returncode == 0 else None
         except (subprocess.SubprocessError, OSError, FileNotFoundError):
             return None
@@ -176,10 +200,10 @@ class GitService:
 
     def _categorize_files(self, files: list[str]) -> set[str]:
         categories = {
-            "docs": ["README", "CLAUDE", "docs/", ".md"],
-            "tests": ["test_", "tests/", "conftest.py"],
+            "docs": ["README", "CLAUDE", "docs /", ".md"],
+            "tests": ["test_", "tests /", "conftest.py"],
             "config": ["pyproject.toml", ".yaml", ".yml", ".json", ".gitignore"],
-            "ci": [".github/", "ci/", ".pre-commit"],
+            "ci": [".github /", "ci /", ".pre-commit"],
             "deps": ["requirements", "uv.lock", "Pipfile"],
         }
         file_categories: set[str] = set()
@@ -205,7 +229,7 @@ class GitService:
             "docs": "Update documentation",
             "tests": "Update tests",
             "config": "Update configuration",
-            "ci": "Update CI/CD configuration",
+            "ci": "Update CI / CD configuration",
             "deps": "Update dependencies",
         }
         return [category_messages.get(category, "Update core functionality")]

crackerjack/services/health_metrics.py

@@ -41,7 +41,7 @@ class ProjectHealth:
             return False
 
         recent = values[-min_points:]
-        # Performance: Use pairwise comparison with zip
+
         return all(a <= b for a, b in zip(recent, recent[1:]))
 
     def _is_trending_down(
@@ -51,7 +51,7 @@ class ProjectHealth:
             return False
 
         recent = values[-min_points:]
-        # Performance: Use pairwise comparison with zip
+
         return all(a >= b for a, b in zip(recent, recent[1:]))
 
     def get_health_score(self) -> float:
@@ -88,11 +88,11 @@ class ProjectHealth:
 
         if self._is_trending_up(self.lint_error_trend):
             recommendations.append(
-                "🔧 Lint errors are increasing - consider running formatting tools",
+                "🔧 Lint errors are increasing-consider running formatting tools",
             )
 
         if self._is_trending_down(self.test_coverage_trend):
-            recommendations.append("🧪 Test coverage is declining - add more tests")
+            recommendations.append("🧪 Test coverage is declining-add more tests")
 
         if any(age > 365 for age in self.dependency_age.values()):
             old_deps: list[str] = [
@@ -104,7 +104,7 @@ class ProjectHealth:
 
         if self.config_completeness < 0.5:
             recommendations.append(
-                "⚙️ Project configuration is incomplete - run crackerjack init",
+                "⚙️ Project configuration is incomplete-run crackerjack init",
             )
         elif self.config_completeness < 0.8:
             recommendations.append("⚙️ Project configuration could be improved")
@@ -179,13 +179,13 @@ class HealthMetricsService:
                 json.dump(data, f, indent=2)
         except Exception as e:
             self.console.print(
-                f"[yellow]Warning: Failed to save health metrics: {e}[/yellow]",
+                f"[yellow]Warning: Failed to save health metrics: {e}[/ yellow]",
             )
 
     def _count_lint_errors(self) -> int | None:
         with suppress(Exception):
             result = subprocess.run(
-                ["uv", "run", "ruff", "check", ".", "--output-format=json"],
+                ["uv", "run", "ruff", "check", ".", "- - output-format=json"],
                 check=False,
                 capture_output=True,
                 text=True,
@@ -238,12 +238,12 @@ class HealthMetricsService:
                 "uv",
                 "run",
                 "python",
-                "-m",
+                "- m",
                 "pytest",
-                "--cov=.",
-                "--cov-report=json",
+                "--cov =.",
+                "- - cov-report=json",
                 "--tb=no",
-                "-q",
+                "- q",
                 "--maxfail=1",
             ],
             check=False,
@@ -322,7 +322,7 @@ class HealthMetricsService:
         if not dep_spec or dep_spec.startswith("-"):
             return None
 
-        for operator in (">=", "<=", "==", "~=", "!=", ">", "<"):
+        for operator in ("> =", "< =", "= =", "~=", "! =", ">", "<"):
             if operator in dep_spec:
                 return dep_spec.split(operator)[0].strip()
 
@@ -345,13 +345,22 @@ class HealthMetricsService:
     def _fetch_package_data(self, package_name: str) -> dict[str, t.Any] | None:
         try:
             import urllib.request
+            from urllib.parse import urlparse
 
             url = f"https://pypi.org/pypi/{package_name}/json"
 
-            if not url.startswith("https://pypi.org/"):
-                msg = f"Invalid URL scheme: {url}"
+            parsed = urlparse(url)
+            if parsed.scheme != "https" or parsed.netloc != "pypi.org":
+                msg = f"Invalid URL: only https://pypi.org URLs are allowed, got {url}"
+                raise ValueError(msg)
+
+            if not parsed.path.startswith("/pypi/") or not parsed.path.endswith(
+                "/json"
+            ):
+                msg = f"Invalid PyPI API path: {parsed.path}"
                 raise ValueError(msg)
 
+            # B310: Safe urllib.urlopen with scheme validation above
             with urllib.request.urlopen(url, timeout=10) as response:  # nosec B310
                 return json.load(response)
         except Exception:
@@ -457,7 +466,7 @@ class HealthMetricsService:
     def _assess_precommit_config(self) -> tuple[float, int]:
         precommit_files = [
             self.project_root / ".pre-commit-config.yaml",
-            self.project_root / ".pre-commit-config.yml",
+            self.project_root / ".pre - commit-config.yml",
         ]
         score = 0.1 if any(f.exists() for f in precommit_files) else 0.0
         return score, 1
@@ -489,7 +498,6 @@ class HealthMetricsService:
         return health
 
     def report_health_status(self, health: ProjectHealth) -> None:
-        """Generate and display comprehensive project health report."""
         health_score = health.get_health_score()
 
         self._print_health_summary(health_score)
@@ -497,18 +505,16 @@ class HealthMetricsService:
         self._print_health_recommendations(health)
 
     def _print_health_summary(self, health_score: float) -> None:
-        """Print the overall health score with appropriate styling."""
         status_icon, status_text, status_color = self._get_health_status_display(
             health_score,
         )
 
-        self.console.print("\n[bold]📊 Project Health Report[/bold]")
+        self.console.print("\n[bold]📊 Project Health Report[/ bold]")
         self.console.print(
-            f"{status_icon} Overall Health: [{status_color}]{status_text} ({health_score:.1%})[/{status_color}]",
+            f"{status_icon} Overall Health: [{status_color}]{status_text} ({health_score: .1 %})[/{status_color}]",
         )
 
     def _get_health_status_display(self, health_score: float) -> tuple[str, str, str]:
-        """Get display elements (icon, text, color) for health score."""
         if health_score >= 0.8:
             return "🟢", "Excellent", "green"
         if health_score >= 0.6:
@@ -518,32 +524,30 @@ class HealthMetricsService:
         return "🔴", "Poor", "red"
 
     def _print_health_metrics(self, health: ProjectHealth) -> None:
-        """Print detailed health metrics."""
         if health.lint_error_trend:
             recent_errors = health.lint_error_trend[-1]
             self.console.print(f"🔧 Lint Errors: {recent_errors}")
 
         if health.test_coverage_trend:
             recent_coverage = health.test_coverage_trend[-1]
-            self.console.print(f"🧪 Test Coverage: {recent_coverage:.1f}%")
+            self.console.print(f"🧪 Test Coverage: {recent_coverage: .1f}%")
 
         if health.dependency_age:
             avg_age = sum(health.dependency_age.values()) / len(health.dependency_age)
-            self.console.print(f"📦 Avg Dependency Age: {avg_age:.0f} days")
+            self.console.print(f"📦 Avg Dependency Age: {avg_age: .0f} days")
 
-        self.console.print(f"⚙️ Config Completeness: {health.config_completeness:.1%}")
+        self.console.print(f"⚙️ Config Completeness: {health.config_completeness: .1 %}")
 
     def _print_health_recommendations(self, health: ProjectHealth) -> None:
-        """Print health recommendations and init suggestions."""
         recommendations = health.get_recommendations()
         if recommendations:
-            self.console.print("\n[bold]💡 Recommendations:[/bold]")
+            self.console.print("\n[bold]💡 Recommendations: [/ bold]")
             for rec in recommendations:
                 self.console.print(f" {rec}")
 
         if health.needs_init():
             self.console.print(
-                "\n[bold yellow]⚠️ Consider running `crackerjack --init` to improve project health[/bold yellow]",
+                "\n[bold yellow]⚠️ Consider running `crackerjack --init` to improve project health[/ bold yellow]",
             )
 
     def get_health_trend_summary(self, days: int = 30) -> dict[str, Any]: