crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/services/git.py

@@ -1,4 +1,5 @@
 import subprocess
+import typing as t
 from pathlib import Path
 
 from rich.console import Console
@@ -6,10 +7,23 @@ from rich.console import Console
 from .secure_subprocess import execute_secure_subprocess
 from .security_logger import get_security_logger
 
+GIT_COMMANDS = {
+    "git_dir": ["rev-parse", "--git-dir"],
+    "staged_files": ["diff", "--cached", "--name-only", "--diff-filter=ACMRT"],
+    "unstaged_files": ["diff", "--name-only", "--diff-filter=ACMRT"],
+    "untracked_files": ["ls-files", "--others", "--exclude-standard"],
+    "staged_files_simple": ["diff", "--cached", "--name-only"],
+    "add_file": ["add"],
+    "add_all": ["add", "-A", "."],
+    "commit": ["commit", "-m"],
+    "add_updated": ["add", "-u"],
+    "push_porcelain": ["push", "--porcelain"],
+    "current_branch": ["branch", "--show-current"],
+    "commits_ahead": ["rev-list[t.Any]", "--count", "@{u}..HEAD"],
+}
 
-class FailedGitResult:
-    """A Git result object compatible with subprocess.CompletedProcess."""
 
+class FailedGitResult:
     def __init__(self, command: list[str], error: str) -> None:
         self.args = command
         self.returncode = -1
@@ -25,7 +39,6 @@ class GitService:
     def _run_git_command(
         self, args: list[str]
     ) -> subprocess.CompletedProcess[str] | FailedGitResult:
-        """Execute Git commands with secure subprocess validation."""
         cmd = ["git", *args]
 
         try:
@@ -35,10 +48,9 @@ class GitService:
                 capture_output=True,
                 text=True,
                 timeout=60,
-                check=False,  # Don't raise on non-zero exit codes
+                check=False,
             )
         except Exception as e:
-            # Log security issues but return a compatible result
             security_logger = get_security_logger()
             security_logger.log_subprocess_failure(
                 command=cmd,
@@ -46,46 +58,39 @@ class GitService:
                 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(GIT_COMMANDS["git_dir"])
             return result.returncode == 0
         except (subprocess.SubprocessError, OSError, FileNotFoundError):
             return False
 
     def get_changed_files(self) -> list[str]:
         try:
-            staged_result = self._run_git_command(
-                ["diff", "--cached", "- - name-only", "- - diff-filter=ACMRT"]
-            )
+            staged_result = self._run_git_command(GIT_COMMANDS["staged_files"])
             staged_files = (
                 staged_result.stdout.strip().split("\n")
                 if staged_result.stdout.strip()
                 else []
             )
 
-            unstaged_result = self._run_git_command(
-                ["diff", "- - name-only", "- - diff-filter=ACMRT"]
-            )
+            unstaged_result = self._run_git_command(GIT_COMMANDS["unstaged_files"])
             unstaged_files = (
                 unstaged_result.stdout.strip().split("\n")
                 if unstaged_result.stdout.strip()
                 else []
             )
 
-            untracked_result = self._run_git_command(
-                ["ls-files", "--others", "- - exclude-standard"],
-            )
+            untracked_result = self._run_git_command(GIT_COMMANDS["untracked_files"])
             untracked_files = (
                 untracked_result.stdout.strip().split("\n")
                 if untracked_result.stdout.strip()
                 else []
             )
 
-            all_files = set(staged_files + unstaged_files + untracked_files)
+            all_files = set[t.Any](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}")
@@ -93,7 +98,7 @@ class GitService:
 
     def get_staged_files(self) -> list[str]:
         try:
-            result = self._run_git_command(["diff", "--cached", "- - name-only"])
+            result = self._run_git_command(GIT_COMMANDS["staged_files_simple"])
             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}")
@@ -102,7 +107,8 @@ class GitService:
     def add_files(self, files: list[str]) -> bool:
         try:
             for file in files:
-                result = self._run_git_command(["add", file])
+                cmd = GIT_COMMANDS["add_file"] + [file]
+                result = self._run_git_command(cmd)
                 if result.returncode != 0:
                     self.console.print(
                         f"[red]❌[/ red] Failed to add {file}: {result.stderr}",
@@ -114,9 +120,8 @@ class GitService:
             return False
 
     def add_all_files(self) -> bool:
-        """Stage all changes including new, modified, and deleted files."""
         try:
-            result = self._run_git_command(["add", "-A", "."])
+            result = self._run_git_command(GIT_COMMANDS["add_all"])
             if result.returncode == 0:
                 self.console.print("[green]✅[/ green] Staged all changes")
                 return True
@@ -130,7 +135,8 @@ class GitService:
 
     def commit(self, message: str) -> bool:
         try:
-            result = self._run_git_command(["commit", "- m", message])
+            cmd = GIT_COMMANDS["commit"] + [message]
+            result = self._run_git_command(cmd)
             if result.returncode == 0:
                 self.console.print(f"[green]✅[/ green] Committed: {message}")
                 return True
@@ -153,14 +159,15 @@ class GitService:
             "[yellow]🔄[/ yellow] Pre - commit hooks modified files - attempting to re-stage and retry commit"
         )
 
-        add_result = self._run_git_command(["add", "- u"])
+        add_result = self._run_git_command(GIT_COMMANDS["add_updated"])
         if add_result.returncode != 0:
             self.console.print(
                 f"[red]❌[/ red] Failed to re-stage files: {add_result.stderr}"
             )
             return False
 
-        retry_result = self._run_git_command(["commit", "- m", message])
+        cmd = GIT_COMMANDS["commit"] + [message]
+        retry_result = self._run_git_command(cmd)
         if retry_result.returncode == 0:
             self.console.print(
                 f"[green]✅[/ green] Committed after re-staging: {message}"
@@ -187,8 +194,7 @@ class GitService:
 
     def push(self) -> bool:
         try:
-            # Get detailed push information
-            result = self._run_git_command(["push", "--porcelain"])
+            result = self._run_git_command(GIT_COMMANDS["push_porcelain"])
             if result.returncode == 0:
                 self._display_push_success(result.stdout)
                 return True
@@ -199,7 +205,6 @@ class GitService:
             return False
 
     def _display_push_success(self, push_output: str) -> None:
-        """Display detailed push success information."""
         lines = push_output.strip().split("\n") if push_output.strip() else []
 
         if not lines:
@@ -210,15 +215,12 @@ class GitService:
         self._display_push_results(pushed_refs)
 
     def _display_no_commits_message(self) -> None:
-        """Display message for no new commits."""
         self.console.print("[green]✅[/ green] Pushed to remote (no new commits)")
 
     def _parse_pushed_refs(self, lines: list[str]) -> list[str]:
-        """Parse pushed references from git output."""
         pushed_refs = []
         for line in lines:
             if line.startswith(("*", "+", "=")):
-                # Parse porcelain output: flag:from:to summary
                 parts = line.split("\t")
                 if len(parts) >= 2:
                     summary = parts[1] if len(parts) > 1 else ""
@@ -226,22 +228,18 @@ class GitService:
         return pushed_refs
 
     def _display_push_results(self, pushed_refs: list[str]) -> None:
-        """Display the push results to console."""
         if pushed_refs:
             self.console.print(
-                f"[green]✅[/ green] Successfully pushed {len(pushed_refs)} ref(s) to remote:"
+                f"[green]✅[/ green] Successfully pushed {len(pushed_refs)} ref(s) to remote: "
             )
             for ref in pushed_refs:
-                self.console.print(f"  [dim]→ {ref}[/ dim]")
+                self.console.print(f" [dim]→ {ref}[/ dim]")
         else:
-            # Get commit count as fallback
             self._display_commit_count_push()
 
     def _display_commit_count_push(self) -> None:
-        """Fallback method to show commit count information."""
         try:
-            # Get commits ahead of remote
-            result = self._run_git_command(["rev-list", "--count", "@{u}..HEAD"])
+            result = self._run_git_command(GIT_COMMANDS["commits_ahead"])
             if result.returncode == 0 and result.stdout.strip().isdigit():
                 commit_count = int(result.stdout.strip())
                 if commit_count > 0:
@@ -253,24 +251,23 @@ class GitService:
                         "[green]✅[/ green] Pushed to remote (up to date)"
                     )
             else:
-                # Even more basic fallback
                 self.console.print("[green]✅[/ green] Successfully pushed to remote")
         except (ValueError, Exception):
             self.console.print("[green]✅[/ green] Successfully pushed to remote")
 
     def get_current_branch(self) -> str | None:
         try:
-            result = self._run_git_command(["branch", "- - show-current"])
+            result = self._run_git_command(GIT_COMMANDS["current_branch"])
             return result.stdout.strip() if result.returncode == 0 else None
         except (subprocess.SubprocessError, OSError, FileNotFoundError):
             return None
 
-    def get_commit_message_suggestions(self, files: list[str]) -> list[str]:
-        if not files:
+    def get_commit_message_suggestions(self, changed_files: list[str]) -> list[str]:
+        if not changed_files:
             return ["Update project files"]
-        file_categories = self._categorize_files(files)
+        file_categories = self._categorize_files(changed_files)
         messages = self._generate_category_messages(file_categories)
-        messages.extend(self._generate_specific_messages(files))
+        messages.extend(self._generate_specific_messages(changed_files))
 
         return messages[:5]
 
@@ -322,11 +319,10 @@ class GitService:
         return messages
 
     def get_unpushed_commit_count(self) -> int:
-        """Get the number of unpushed commits."""
         from contextlib import suppress
 
         with suppress(ValueError, Exception):
-            result = self._run_git_command(["rev-list", "--count", "@{u}..HEAD"])
+            result = self._run_git_command(GIT_COMMANDS["commits_ahead"])
             if result.returncode == 0 and result.stdout.strip().isdigit():
                 return int(result.stdout.strip())
         return 0

crackerjack/services/health_metrics.py

@@ -9,6 +9,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
+import requests
 from rich.console import Console
 
 from crackerjack.models.protocols import FileSystemInterface
@@ -18,7 +19,7 @@ from crackerjack.models.protocols import FileSystemInterface
 class ProjectHealth:
     lint_error_trend: list[int] = field(default_factory=list)
     test_coverage_trend: list[float] = field(default_factory=list)
-    dependency_age: dict[str, int] = field(default_factory=dict)
+    dependency_age: dict[str, int] = field(default_factory=dict[str, t.Any])
     config_completeness: float = 0.0
     last_updated: float = field(default_factory=time.time)
 
@@ -344,14 +345,13 @@ 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"
+            url = f"https: //pypi.org/pypi/{package_name}/json"
 
             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}"
+                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(
@@ -360,9 +360,10 @@ class HealthMetricsService:
                 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)
+            response = requests.get(url, timeout=10, verify=True)
+            response.raise_for_status()
+            json_result = response.json()
+            return t.cast(dict[str, t.Any] | None, json_result)
         except Exception:
             return None
 
@@ -378,7 +379,8 @@ class HealthMetricsService:
         if not release_info:
             return None
 
-        return release_info[0].get("upload_time", "")
+        upload_time_raw = release_info[0].get("upload_time", "")
+        return t.cast(str | None, upload_time_raw)
 
     def _calculate_days_since_upload(self, upload_time: str) -> int | None:
         try: