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

crackerjack/services/log_manager.py

@@ -48,15 +48,15 @@ class LogManager:
     def create_debug_log_file(self, session_id: str | None = None) -> Path:
         timestamp = int(time.time())
         if session_id:
-            filename = f"debug-{timestamp}-{session_id}.log"
+            filename = f"debug -{timestamp}-{session_id}.log"
         else:
-            filename = f"debug-{timestamp}.log"
+            filename = f"debug -{timestamp}.log"
 
         return self.debug_dir / filename
 
     def create_error_log_file(self, error_type: str = "general") -> Path:
         timestamp = int(time.time())
-        filename = f"error-{error_type}-{timestamp}.log"
+        filename = f"error -{error_type}-{timestamp}.log"
         return self.error_dir / filename
 
     def rotate_logs(
@@ -95,7 +95,7 @@ class LogManager:
                     log_file.unlink()
                     removed_count += 1
                     console.print(
-                        f"[dim]🗑️ Removed old log: {log_file.name} ({reason})[/dim]",
+                        f"[dim]🗑️ Removed old log: {log_file.name} ({reason})[/ dim]",
                     )
 
         return removed_count
@@ -146,40 +146,40 @@ class LogManager:
         results = {"found": len(legacy_files), "moved": 0, "failed": 0}
 
         if not legacy_files:
-            console.print("[green]✅ No legacy log files found to migrate[/green]")
+            console.print("[green]✅ No legacy log files found to migrate[/ green]")
             return results
 
         console.print(
-            f"[yellow]📦 Found {len(legacy_files)} legacy debug log files to migrate[/yellow]",
+            f"[yellow]📦 Found {len(legacy_files)} legacy debug log files to migrate[/ yellow]",
         )
 
         for legacy_file in legacy_files:
             try:
-                parts = legacy_file.stem.split(" - ")
+                parts = legacy_file.stem.split("-")
                 if len(parts) >= 3 and parts[-1].isdigit():
                     timestamp = parts[-1]
                 else:
                     timestamp = str(int(legacy_file.stat().st_mtime))
 
-                new_filename = f"debug-{timestamp}-migrated.log"
+                new_filename = f"debug -{timestamp}- migrated.log"
                 new_path = self.debug_dir / new_filename
 
                 if dry_run:
                     console.print(
-                        f"[cyan]📋 Would move: {legacy_file.name} → {new_filename}[/cyan]",
+                        f"[cyan]📋 Would move: {legacy_file.name} → {new_filename}[/ cyan]",
                     )
                     results["moved"] += 1
                 else:
                     shutil.move(str(legacy_file), str(new_path))
                     results["moved"] += 1
                     console.print(
-                        f"[green]✅ Moved: {legacy_file.name} → {new_filename}[/green]",
+                        f"[green]✅ Moved: {legacy_file.name} → {new_filename}[/ green]",
                     )
 
             except (OSError, ValueError) as e:
                 results["failed"] += 1
                 console.print(
-                    f"[red]❌ Failed to migrate {legacy_file.name}: {e}[/red]",
+                    f"[red]❌ Failed to migrate {legacy_file.name}: {e}[/ red]",
                 )
 
         return results
@@ -236,7 +236,7 @@ class LogManager:
         )
 
         formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            "%(asctime)s - %(name)s - %(levelname)s-%(message)s",
         )
         handler.setFormatter(formatter)
 
@@ -247,8 +247,8 @@ class LogManager:
     def print_log_summary(self) -> None:
         stats = self.get_log_stats()
 
-        console.print("\n[bold]📊 Log File Summary[/bold]")
-        console.print(f"[dim]Location: {self.log_dir}[/dim]")
+        console.print("\n[bold]📊 Log File Summary[/ bold]")
+        console.print(f"[dim]Location: {self.log_dir}[/ dim]")
 
         total_files = 0
         total_size = 0.0
@@ -273,10 +273,10 @@ class LogManager:
 
         if total_files > 0:
             console.print(
-                f"\n[bold]Total: {total_files} files, {total_size:.2f}MB[/bold]",
+                f"\n[bold]Total: {total_files} files, {total_size: .2f}MB[/ bold]",
             )
         else:
-            console.print("\n[dim]No log files found[/dim]")
+            console.print("\n[dim]No log files found[/ dim]")
 
 
 log_manager = LogManager()

crackerjack/services/logging.py

@@ -9,6 +9,7 @@ from types import TracebackType
 from typing import Any
 
 import structlog
+from structlog.types import EventDict, Processor
 
 correlation_id: ContextVar[str | None] = ContextVar("correlation_id", default=None)
 
@@ -25,12 +26,12 @@ def get_correlation_id() -> str:
     return cid
 
 
-def add_correlation_id(_: Any, __: Any, event_dict: dict[str, Any]) -> dict[str, Any]:
+def add_correlation_id(_: Any, __: Any, event_dict: EventDict) -> EventDict:
     event_dict["correlation_id"] = get_correlation_id()
     return event_dict
 
 
-def add_timestamp(_: Any, __: Any, event_dict: dict[str, Any]) -> dict[str, Any]:
+def add_timestamp(_: Any, __: Any, event_dict: EventDict) -> EventDict:
     event_dict["timestamp"] = time.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
     return event_dict
 
@@ -40,7 +41,7 @@ def setup_structured_logging(
     json_output: bool = True,
     log_file: Path | None = None,
 ) -> None:
-    processors = [
+    processors: list[Processor] = [
         structlog.stdlib.filter_by_level,
         add_timestamp,
         add_correlation_id,
@@ -52,12 +53,12 @@ def setup_structured_logging(
     ]
 
     if json_output:
-        processors.append(structlog.processors.JSONRenderer())  # type: ignore[arg-type]
+        processors.append(structlog.processors.JSONRenderer())
     else:
-        processors.append(structlog.dev.ConsoleRenderer(colors=True))  # type: ignore[arg-type]
+        processors.append(structlog.dev.ConsoleRenderer(colors=True))
 
     structlog.configure(
-        processors=processors,  # type: ignore[arg-type]
+        processors=processors,
         wrapper_class=structlog.stdlib.BoundLogger,
         logger_factory=structlog.stdlib.LoggerFactory(),
         cache_logger_on_first_use=True,

crackerjack/services/metrics.py

@@ -21,45 +21,45 @@ class MetricsCollector:
     def _init_database(self) -> None:
         with self._get_connection() as conn:
             conn.executescript("""
-                -- Jobs table
+                - - Jobs table
                 CREATE TABLE IF NOT EXISTS jobs (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT UNIQUE NOT NULL,
                     start_time TIMESTAMP NOT NULL,
                     end_time TIMESTAMP,
-                    status TEXT NOT NULL, -- 'running', 'success', 'failed', 'cancelled'
+                    status TEXT NOT NULL, - - 'running', 'success', 'failed', 'cancelled'
                     iterations INTEGER DEFAULT 0,
                     ai_agent BOOLEAN DEFAULT 0,
                     error_message TEXT,
-                    metadata TEXT -- JSON field for additional data
+                    metadata TEXT - - JSON field for additional data
                 );
 
-                -- Errors table
+                - - Errors table
                 CREATE TABLE IF NOT EXISTS errors (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
                     timestamp TIMESTAMP NOT NULL,
-                    error_type TEXT NOT NULL, -- 'hook', 'test', 'lint', 'type_check', etc.
-                    error_category TEXT, -- 'ruff', 'pyright', 'pytest', etc.
+                    error_type TEXT NOT NULL, - - 'hook', 'test', 'lint', 'type_check', etc.
+                    error_category TEXT, - - 'ruff', 'pyright', 'pytest', etc.
                     error_message TEXT,
                     file_path TEXT,
                     line_number INTEGER,
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Hook executions table
+                - - Hook executions table
                 CREATE TABLE IF NOT EXISTS hook_executions (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
                     timestamp TIMESTAMP NOT NULL,
                     hook_name TEXT NOT NULL,
-                    hook_type TEXT, -- 'fast', 'comprehensive'
+                    hook_type TEXT, - - 'fast', 'comprehensive'
                     execution_time_ms INTEGER,
-                    status TEXT, -- 'success', 'failed', 'skipped'
+                    status TEXT, - - 'success', 'failed', 'skipped'
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Test executions table
+                - - Test executions table
                 CREATE TABLE IF NOT EXISTS test_executions (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
@@ -73,17 +73,17 @@ class MetricsCollector:
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Orchestration executions table (NEW)
+                - - Orchestration executions table (NEW)
                 CREATE TABLE IF NOT EXISTS orchestration_executions (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
                     timestamp TIMESTAMP NOT NULL,
-                    execution_strategy TEXT NOT NULL, -- 'batch', 'individual', 'adaptive', 'selective'
-                    progress_level TEXT NOT NULL, -- 'basic', 'detailed', 'granular', 'streaming'
-                    ai_mode TEXT NOT NULL, -- 'single-agent', 'multi-agent', 'coordinator'
+                    execution_strategy TEXT NOT NULL, - - 'batch', 'individual', 'adaptive', 'selective'
+                    progress_level TEXT NOT NULL, - - 'basic', 'detailed', 'granular', 'streaming'
+                    ai_mode TEXT NOT NULL, - - 'single - agent', 'multi - agent', 'coordinator'
                     iteration_count INTEGER DEFAULT 1,
-                    strategy_switches INTEGER DEFAULT 0, -- How many times strategy changed
-                    correlation_insights TEXT, -- JSON of correlation analysis results
+                    strategy_switches INTEGER DEFAULT 0, - - How many times strategy changed
+                    correlation_insights TEXT, - - JSON of correlation analysis results
                     total_execution_time_ms INTEGER,
                     hooks_execution_time_ms INTEGER,
                     tests_execution_time_ms INTEGER,
@@ -91,7 +91,7 @@ class MetricsCollector:
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Strategy decisions table (NEW)
+                - - Strategy decisions table (NEW)
                 CREATE TABLE IF NOT EXISTS strategy_decisions (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
@@ -99,29 +99,29 @@ class MetricsCollector:
                     timestamp TIMESTAMP NOT NULL,
                     previous_strategy TEXT,
                     selected_strategy TEXT NOT NULL,
-                    decision_reason TEXT, -- Why this strategy was chosen
-                    context_data TEXT, -- JSON of execution context
-                    effectiveness_score REAL, -- How well the strategy worked (0-1)
+                    decision_reason TEXT, - - Why this strategy was chosen
+                    context_data TEXT, - - JSON of execution context
+                    effectiveness_score REAL, - - How well the strategy worked (0 - 1)
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Individual test executions table (NEW - more granular than test_executions)
+                - - Individual test executions table (NEW - more granular than test_executions)
                 CREATE TABLE IF NOT EXISTS individual_test_executions (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     job_id TEXT,
                     timestamp TIMESTAMP NOT NULL,
-                    test_id TEXT NOT NULL, -- Full test identifier
+                    test_id TEXT NOT NULL, - - Full test identifier
                     test_file TEXT NOT NULL,
                     test_class TEXT,
                     test_method TEXT,
-                    status TEXT NOT NULL, -- 'passed', 'failed', 'skipped', 'error'
+                    status TEXT NOT NULL, - - 'passed', 'failed', 'skipped', 'error'
                     execution_time_ms INTEGER,
                     error_message TEXT,
                     error_traceback TEXT,
                     FOREIGN KEY (job_id) REFERENCES jobs(job_id)
                 );
 
-                -- Daily summary table (for quick stats)
+                - - Daily summary table (for quick stats)
                 CREATE TABLE IF NOT EXISTS daily_summary (
                     date DATE PRIMARY KEY,
                     total_jobs INTEGER DEFAULT 0,
@@ -134,12 +134,12 @@ class MetricsCollector:
                     type_errors INTEGER DEFAULT 0,
                     avg_job_duration_ms INTEGER,
                     total_ai_fixes INTEGER DEFAULT 0,
-                    orchestrated_jobs INTEGER DEFAULT 0, -- NEW
-                    avg_orchestration_iterations REAL DEFAULT 0, -- NEW
-                    most_effective_strategy TEXT -- NEW
+                    orchestrated_jobs INTEGER DEFAULT 0, - - NEW
+                    avg_orchestration_iterations REAL DEFAULT 0, - - NEW
+                    most_effective_strategy TEXT - - NEW
                 );
 
-                -- Create indexes for performance
+                --Create indexes for performance
                 CREATE INDEX IF NOT EXISTS idx_jobs_start_time ON jobs(start_time);
                 CREATE INDEX IF NOT EXISTS idx_errors_job_id ON errors(job_id);
                 CREATE INDEX IF NOT EXISTS idx_errors_type ON errors(error_type);
@@ -190,8 +190,8 @@ class MetricsCollector:
             conn.execute(
                 """
                     UPDATE jobs
-                    SET end_time = ?, status = ?, iterations = ?, error_message = ?
-                    WHERE job_id = ?
+                    SET end_time=?, status=?, iterations=?, error_message=?
+                    WHERE job_id=?
                 """,
                 (datetime.now(), status, iterations, error_message, job_id),
             )
@@ -394,7 +394,7 @@ class MetricsCollector:
                     AVG(
                         SELECT iteration_count
                         FROM orchestration_executions o
-                        WHERE o.job_id = sd.job_id
+                        WHERE o.job_id=sd.job_id
                     ) as avg_iterations_needed
                 FROM strategy_decisions sd
                 WHERE effectiveness_score IS NOT NULL
@@ -435,7 +435,7 @@ class MetricsCollector:
                     COUNT(*) as failure_count,
                     AVG(execution_time_ms) as avg_execution_time
                 FROM individual_test_executions
-                WHERE status = 'failed'
+                WHERE status='failed'
                 GROUP BY test_file, test_class, test_method
                 ORDER BY failure_count DESC
                 LIMIT 15
@@ -457,14 +457,14 @@ class MetricsCollector:
             """
             SELECT
                 COUNT(*) as total_jobs,
-                SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful_jobs,
-                SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_jobs,
+                SUM(CASE WHEN status='success' THEN 1 ELSE 0 END) as successful_jobs,
+                SUM(CASE WHEN status='failed' THEN 1 ELSE 0 END) as failed_jobs,
                 AVG(CASE
                     WHEN end_time IS NOT NULL
-                    THEN (julianday(end_time) - julianday(start_time)) * 86400000
+                    THEN (julianday(end_time)-julianday(start_time)) * 86400000
                     ELSE NULL
                 END) as avg_duration_ms,
-                SUM(CASE WHEN ai_agent = 1 AND status = 'success' THEN 1 ELSE 0 END) as ai_fixes
+                SUM(CASE WHEN ai_agent=1 AND status='success' THEN 1 ELSE 0 END) as ai_fixes
             FROM jobs
             WHERE DATE(start_time) = ?
         """,
@@ -475,10 +475,10 @@ class MetricsCollector:
             """
             SELECT
                 COUNT(*) as total_errors,
-                SUM(CASE WHEN error_type = 'hook' THEN 1 ELSE 0 END) as hook_errors,
-                SUM(CASE WHEN error_type = 'test' THEN 1 ELSE 0 END) as test_errors,
-                SUM(CASE WHEN error_type = 'lint' THEN 1 ELSE 0 END) as lint_errors,
-                SUM(CASE WHEN error_type = 'type_check' THEN 1 ELSE 0 END) as type_errors
+                SUM(CASE WHEN error_type='hook' THEN 1 ELSE 0 END) as hook_errors,
+                SUM(CASE WHEN error_type='test' THEN 1 ELSE 0 END) as test_errors,
+                SUM(CASE WHEN error_type='lint' THEN 1 ELSE 0 END) as lint_errors,
+                SUM(CASE WHEN error_type='type_check' THEN 1 ELSE 0 END) as type_errors
             FROM errors
             WHERE DATE(timestamp) = ?
         """,
@@ -534,9 +534,9 @@ class MetricsCollector:
             job_stats = conn.execute("""
                 SELECT
                     COUNT(*) as total_jobs,
-                    SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successful_jobs,
-                    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed_jobs,
-                    SUM(CASE WHEN ai_agent = 1 THEN 1 ELSE 0 END) as ai_agent_jobs,
+                    SUM(CASE WHEN status='success' THEN 1 ELSE 0 END) as successful_jobs,
+                    SUM(CASE WHEN status='failed' THEN 1 ELSE 0 END) as failed_jobs,
+                    SUM(CASE WHEN ai_agent=1 THEN 1 ELSE 0 END) as ai_agent_jobs,
                     AVG(iterations) as avg_iterations
                 FROM jobs
             """).fetchone()

crackerjack/services/pattern_cache.py

@@ -10,8 +10,6 @@ from ..agents.base import FixResult, Issue, IssueType
 
 @dataclass
 class CachedPattern:
-    """A cached pattern from successful fixes."""
-
     pattern_id: str
     issue_type: IssueType
     strategy: str
@@ -27,27 +25,18 @@ class CachedPattern:
 
 
 class PatternCache:
-    """Cache for successful architectural patterns and fixes.
-
-    Learns from successful fixes and provides patterns for reuse,
-    reducing iteration cycles and improving code quality consistency.
-    """
-
     def __init__(self, project_path: Path) -> None:
         self.project_path = project_path
         self.cache_dir = project_path / ".crackerjack" / "patterns"
         self.cache_file = self.cache_dir / "pattern_cache.json"
         self.logger = logging.getLogger(__name__)
 
-        # In-memory cache for performance
         self._patterns: dict[str, CachedPattern] = {}
         self._loaded = False
 
-        # Ensure cache directory exists
         self.cache_dir.mkdir(parents=True, exist_ok=True)
 
     def _load_patterns(self) -> None:
-        """Load patterns from disk cache."""
         if self._loaded:
             return
 
@@ -83,7 +72,6 @@ class PatternCache:
         self._loaded = True
 
     def _save_patterns(self) -> None:
-        """Save patterns to disk cache."""
         try:
             data = {
                 "version": "1.0",
@@ -105,22 +93,19 @@ class PatternCache:
     def cache_successful_pattern(
         self, issue: Issue, plan: dict[str, t.Any], result: FixResult
     ) -> str:
-        """Cache a successful pattern for future reuse."""
         self._load_patterns()
 
-        # Generate pattern ID
         pattern_id = (
             f"{issue.type.value}_{plan.get('strategy', 'default')}_{int(time.time())}"
         )
 
-        # Create cached pattern
         cached_pattern = CachedPattern(
             pattern_id=pattern_id,
             issue_type=issue.type,
             strategy=plan.get("strategy", "unknown"),
             patterns=plan.get("patterns", []),
             confidence=result.confidence,
-            success_rate=1.0,  # Initial success rate
+            success_rate=1.0,
             usage_count=0,
             last_used=0.0,
             created_at=time.time(),
@@ -138,7 +123,6 @@ class PatternCache:
             },
         )
 
-        # Store in memory and disk
         self._patterns[pattern_id] = cached_pattern
         self._save_patterns()
 
@@ -146,7 +130,6 @@ class PatternCache:
         return pattern_id
 
     def get_patterns_for_issue(self, issue: Issue) -> list[CachedPattern]:
-        """Get cached patterns that match the given issue type."""
         self._load_patterns()
 
         matching_patterns = [
@@ -155,7 +138,6 @@ class PatternCache:
             if pattern.issue_type == issue.type
         ]
 
-        # Sort by success rate and confidence
         matching_patterns.sort(
             key=lambda p: (p.success_rate, p.confidence), reverse=True
         )
@@ -163,17 +145,14 @@ class PatternCache:
         return matching_patterns
 
     def get_best_pattern_for_issue(self, issue: Issue) -> CachedPattern | None:
-        """Get the best cached pattern for the given issue."""
         patterns = self.get_patterns_for_issue(issue)
 
         if not patterns:
             return None
 
-        # Return the highest-rated pattern
         return patterns[0]
 
     def use_pattern(self, pattern_id: str) -> bool:
-        """Mark a pattern as used and update usage statistics."""
         self._load_patterns()
 
         if pattern_id not in self._patterns:
@@ -191,7 +170,6 @@ class PatternCache:
         return True
 
     def update_pattern_success_rate(self, pattern_id: str, success: bool) -> None:
-        """Update the success rate of a pattern based on usage outcome."""
         self._load_patterns()
 
         if pattern_id not in self._patterns:
@@ -199,7 +177,6 @@ class PatternCache:
 
         pattern = self._patterns[pattern_id]
 
-        # Update success rate using weighted average
         total_uses = pattern.usage_count
         if total_uses > 0:
             current_successes = pattern.success_rate * total_uses
@@ -209,11 +186,10 @@ class PatternCache:
 
         self._save_patterns()
         self.logger.debug(
-            f"Updated pattern {pattern_id} success rate: {pattern.success_rate:.2f}"
+            f"Updated pattern {pattern_id} success rate: {pattern.success_rate: .2f}"
         )
 
     def get_pattern_statistics(self) -> dict[str, t.Any]:
-        """Get statistics about cached patterns."""
         self._load_patterns()
 
         if not self._patterns:
@@ -241,7 +217,6 @@ class PatternCache:
         }
 
     def _get_most_used_patterns(self, limit: int = 5) -> list[dict[str, t.Any]]:
-        """Get the most frequently used patterns."""
         patterns = sorted(
             self._patterns.values(), key=lambda p: p.usage_count, reverse=True
         )[:limit]
@@ -261,7 +236,6 @@ class PatternCache:
     def cleanup_old_patterns(
         self, max_age_days: int = 30, min_usage_count: int = 2
     ) -> int:
-        """Clean up old, unused patterns to prevent cache bloat."""
         self._load_patterns()
 
         cutoff_time = time.time() - (max_age_days * 24 * 60 * 60)
@@ -285,7 +259,6 @@ class PatternCache:
         return len(patterns_to_remove)
 
     def clear_cache(self) -> None:
-        """Clear all cached patterns."""
         self._patterns.clear()
         self._loaded = False
 
@@ -295,7 +268,6 @@ class PatternCache:
         self.logger.info("Cleared pattern cache")
 
     def export_patterns(self, export_path: Path) -> bool:
-        """Export patterns to a file for sharing or backup."""
         self._load_patterns()
 
         try:
@@ -322,7 +294,6 @@ class PatternCache:
             return False
 
     def import_patterns(self, import_path: Path, merge: bool = True) -> bool:
-        """Import patterns from a file."""
         try:
             with import_path.open() as f:
                 data = json.load(f)