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

crackerjack/__main__.py

@@ -35,7 +35,6 @@ def _handle_monitoring_commands(
     watchdog: bool,
     dev: bool,
 ) -> bool:
-    """Handle monitoring commands."""
     if monitor:
         handle_monitor_mode(dev_mode=dev)
         return True
@@ -57,7 +56,6 @@ def _handle_websocket_commands(
     restart_websocket_server: bool,
     websocket_port: int | None,
 ) -> bool:
-    """Handle WebSocket server commands."""
     if start_websocket_server:
         port = websocket_port or 8675
         handle_start_websocket_server(port)
@@ -78,7 +76,6 @@ def _handle_mcp_commands(
     restart_mcp_server: bool,
     websocket_port: int | None,
 ) -> bool:
-    """Handle MCP server commands."""
     if start_mcp_server:
         handle_mcp_server(websocket_port)
         return True
@@ -105,7 +102,6 @@ def _handle_server_commands(
     websocket_port: int | None,
     dev: bool,
 ) -> bool:
-    """Handle server-related commands. Returns True if a server command was handled."""
     return (
         _handle_monitoring_commands(monitor, enhanced_monitor, dashboard, watchdog, dev)
         or _handle_websocket_commands(
@@ -130,6 +126,7 @@ def main(
     no_config_updates: bool = CLI_OPTIONS["no_config_updates"],
     update_precommit: bool = CLI_OPTIONS["update_precommit"],
     verbose: bool = CLI_OPTIONS["verbose"],
+    debug: bool = CLI_OPTIONS["debug"],
     publish: BumpOption | None = CLI_OPTIONS["publish"],
     all: BumpOption | None = CLI_OPTIONS["all"],
     bump: BumpOption | None = CLI_OPTIONS["bump"],
@@ -172,6 +169,12 @@ def main(
     coverage_goal: float | None = CLI_OPTIONS["coverage_goal"],
     no_coverage_ratchet: bool = CLI_OPTIONS["no_coverage_ratchet"],
     boost_coverage: bool = CLI_OPTIONS["boost_coverage"],
+    disable_global_locks: bool = CLI_OPTIONS["disable_global_locks"],
+    global_lock_timeout: int = CLI_OPTIONS["global_lock_timeout"],
+    global_lock_cleanup: bool = CLI_OPTIONS["global_lock_cleanup"],
+    global_lock_dir: str | None = CLI_OPTIONS["global_lock_dir"],
+    quick: bool = CLI_OPTIONS["quick"],
+    thorough: bool = CLI_OPTIONS["thorough"],
 ) -> None:
     options = create_options(
         commit,
@@ -179,6 +182,7 @@ def main(
         no_config_updates,
         update_precommit,
         verbose,
+        debug,
         publish,
         all,
         bump,
@@ -209,15 +213,27 @@ def main(
         coverage_goal,
         no_coverage_ratchet,
         boost_coverage,
+        disable_global_locks,
+        global_lock_timeout,
+        global_lock_cleanup,
+        global_lock_dir,
+        quick,
+        thorough,
     )
 
     if ai_debug:
         ai_agent = True
         verbose = True
+        # Update the options object to reflect the verbose setting
+        options.verbose = True
 
-    setup_ai_agent_env(ai_agent, verbose or ai_debug)
+    # If debug flag is set, enable verbose mode as well
+    if debug:
+        verbose = True
+        options.verbose = True
+
+    setup_ai_agent_env(ai_agent, verbose or ai_debug or debug)
 
-    # Handle server commands
     if _handle_server_commands(
         monitor,
         enhanced_monitor,
@@ -234,7 +250,6 @@ def main(
     ):
         return
 
-    # Handle main workflow
     if interactive:
         handle_interactive_mode(options)
     else:
@@ -242,7 +257,6 @@ def main(
 
 
 def cli() -> None:
-    """Entry point for console script."""
     app()
 
 

crackerjack/agents/__init__.py

@@ -1,4 +1,3 @@
-# Import all agent modules to trigger registration
 from . import (
     architect_agent,
     documentation_agent,
@@ -20,12 +19,10 @@ __all__ = [
     "AgentCoordinator",
     "AgentTracker",
     "FixResult",
-    # Exported classes
     "Issue",
     "IssueType",
     "Priority",
     "SubAgent",
-    # Agent modules (imported for registration)
     "architect_agent",
     "documentation_agent",
     "dry_agent",

crackerjack/agents/architect_agent.py

@@ -5,15 +5,7 @@ from .proactive_agent import ProactiveAgent
 
 
 class ArchitectAgent(ProactiveAgent):
-    """Agent that provides architectural planning and guidance.
-
-    This agent bridges to the external crackerjack-architect specialist
-    for complex architectural decisions while handling simpler planning
-    internally through cached patterns.
-    """
-
     def get_supported_types(self) -> set[IssueType]:
-        """Support all issue types for architectural planning."""
         return {
             IssueType.COMPLEXITY,
             IssueType.DRY_VIOLATION,
@@ -30,58 +22,39 @@ class ArchitectAgent(ProactiveAgent):
         }
 
     async def can_handle(self, issue: Issue) -> float:
-        """Determine confidence in handling this issue architecturally."""
-        # High confidence for complex issues that benefit from planning
         if issue.type == IssueType.COMPLEXITY:
             return 0.9
 
-        # High confidence for DRY violations (architectural)
         if issue.type == IssueType.DRY_VIOLATION:
             return 0.85
 
-        # Medium-high confidence for performance issues
         if issue.type == IssueType.PERFORMANCE:
             return 0.8
 
-        # Medium confidence for security (architectural patterns)
         if issue.type == IssueType.SECURITY:
             return 0.75
 
-        # Lower confidence for formatting/imports (less architectural)
         if issue.type in {IssueType.FORMATTING, IssueType.IMPORT_ERROR}:
             return 0.4
 
-        # Medium confidence for other types
         return 0.6
 
     async def plan_before_action(self, issue: Issue) -> dict[str, t.Any]:
-        """Create architectural plan for fixing the issue."""
-        # Check if this is a complex issue requiring external specialist
         if await self._needs_external_specialist(issue):
             return await self._get_specialist_plan(issue)
 
-        # Use internal planning for simpler issues
         return await self._get_internal_plan(issue)
 
     async def _needs_external_specialist(self, issue: Issue) -> bool:
-        """Determine if external crackerjack-architect specialist is needed."""
-        # Always use specialist for complexity issues
         if issue.type == IssueType.COMPLEXITY:
             return True
 
-        # Use specialist for DRY violations
         if issue.type == IssueType.DRY_VIOLATION:
             return True
 
-        # Use specialist for multiple related issues
-        # (This would be determined by the coordinator in practice)
         return False
 
     async def _get_specialist_plan(self, issue: Issue) -> dict[str, t.Any]:
-        """Get plan from external crackerjack-architect specialist."""
-        # This would use the Task tool to invoke crackerjack-architect
-        # For now, return a structured plan that mimics what the specialist would provide
-
         plan = {
             "strategy": "external_specialist_guided",
             "specialist": "crackerjack-architect",
@@ -95,7 +68,6 @@ class ArchitectAgent(ProactiveAgent):
         return plan
 
     async def _get_internal_plan(self, issue: Issue) -> dict[str, t.Any]:
-        """Create plan using internal architectural knowledge."""
         plan = {
             "strategy": "internal_pattern_based",
             "approach": self._get_internal_approach(issue),
@@ -108,7 +80,6 @@ class ArchitectAgent(ProactiveAgent):
         return plan
 
     def _get_specialist_approach(self, issue: Issue) -> str:
-        """Get the approach that crackerjack-architect would recommend."""
         if issue.type == IssueType.COMPLEXITY:
             return "break_into_helper_methods"
         elif issue.type == IssueType.DRY_VIOLATION:
@@ -120,7 +91,6 @@ class ArchitectAgent(ProactiveAgent):
         return "apply_clean_code_principles"
 
     def _get_internal_approach(self, issue: Issue) -> str:
-        """Get internal approach for simpler issues."""
         return {
             IssueType.FORMATTING: "apply_standard_formatting",
             IssueType.IMPORT_ERROR: "optimize_imports",
@@ -131,7 +101,6 @@ class ArchitectAgent(ProactiveAgent):
         }.get(issue.type, "apply_standard_fix")
 
     def _get_recommended_patterns(self, issue: Issue) -> list[str]:
-        """Get patterns recommended by crackerjack-architect."""
         return {
             IssueType.COMPLEXITY: [
                 "extract_method",
@@ -160,7 +129,6 @@ class ArchitectAgent(ProactiveAgent):
         }.get(issue.type, ["standard_patterns"])
 
     def _get_cached_patterns_for_issue(self, issue: Issue) -> list[str]:
-        """Get cached patterns that match this issue type."""
         cached = self.get_cached_patterns()
         matching_patterns = []
 
@@ -173,7 +141,6 @@ class ArchitectAgent(ProactiveAgent):
         return matching_patterns or ["default_pattern"]
 
     def _analyze_dependencies(self, issue: Issue) -> list[str]:
-        """Analyze what other changes might be needed."""
         dependencies = []
 
         if issue.type == IssueType.COMPLEXITY:
@@ -193,7 +160,6 @@ class ArchitectAgent(ProactiveAgent):
         return dependencies
 
     def _identify_risks(self, issue: Issue) -> list[str]:
-        """Identify potential risks in fixing this issue."""
         risks = []
 
         if issue.type == IssueType.COMPLEXITY:
@@ -211,7 +177,6 @@ class ArchitectAgent(ProactiveAgent):
         return risks
 
     def _get_validation_steps(self, issue: Issue) -> list[str]:
-        """Get steps to validate the fix."""
         return [
             "run_fast_hooks",
             "run_full_tests",
@@ -221,13 +186,11 @@ class ArchitectAgent(ProactiveAgent):
         ]
 
     async def analyze_and_fix(self, issue: Issue) -> FixResult:
-        """Standard fix method - delegates to proactive version."""
         return await self.analyze_and_fix_proactively(issue)
 
     async def _execute_with_plan(
         self, issue: Issue, plan: dict[str, t.Any]
     ) -> FixResult:
-        """Execute fix following the architectural plan."""
         strategy = plan.get("strategy", "internal_pattern_based")
 
         if strategy == "external_specialist_guided":
@@ -237,10 +200,6 @@ class ArchitectAgent(ProactiveAgent):
     async def _execute_specialist_guided_fix(
         self, issue: Issue, plan: dict[str, t.Any]
     ) -> FixResult:
-        """Execute fix guided by external specialist plan."""
-        # This would invoke the actual Task tool with crackerjack-architect
-        # For now, return a structured result indicating the plan was followed
-
         return FixResult(
             success=True,
             confidence=0.9,
@@ -260,7 +219,6 @@ class ArchitectAgent(ProactiveAgent):
     async def _execute_pattern_based_fix(
         self, issue: Issue, plan: dict[str, t.Any]
     ) -> FixResult:
-        """Execute fix using cached patterns and internal logic."""
         patterns = plan.get("patterns", [])
         approach = plan.get("approach", "standard")
 
@@ -277,5 +235,4 @@ class ArchitectAgent(ProactiveAgent):
         )
 
 
-# Register the agent
 agent_registry.register(ArchitectAgent)

crackerjack/agents/base.py

@@ -27,6 +27,7 @@ class IssueType(Enum):
     DOCUMENTATION = "documentation"
     TEST_ORGANIZATION = "test_organization"
     COVERAGE_IMPROVEMENT = "coverage_improvement"
+    REGEX_VALIDATION = "regex_validation"
 
 
 @dataclass
@@ -40,10 +41,6 @@ class Issue:
     details: list[str] = field(default_factory=list)
     stage: str = "unknown"
 
-    @property
-    def context_key(self) -> str:
-        return f"{self.type.value}: {self.file_path}: {self.line_number}"
-
 
 @dataclass
 class FixResult:
@@ -145,11 +142,9 @@ class SubAgent(ABC):
         pass
 
     async def plan_before_action(self, issue: Issue) -> dict[str, t.Any]:
-        """Plan actions before executing fixes. Override in subclasses."""
         return {"strategy": "default", "confidence": 0.5}
 
     def get_cached_patterns(self) -> dict[str, t.Any]:
-        """Get cached patterns for this agent. Override in subclasses."""
         return {}
 
 
@@ -163,8 +158,5 @@ class AgentRegistry:
     def create_all(self, context: AgentContext) -> list[SubAgent]:
         return [agent_cls(context) for agent_cls in self._agents.values()]
 
-    def get_by_name(self, name: str) -> type[SubAgent] | None:
-        return self._agents.get(name)
-
 
 agent_registry = AgentRegistry()

crackerjack/agents/coordinator.py

@@ -1,6 +1,5 @@
 import asyncio
 import logging
-import operator
 import typing as t
 from collections import defaultdict
 
@@ -11,7 +10,6 @@ from .base import (
     FixResult,
     Issue,
     IssueType,
-    Priority,
     SubAgent,
     agent_registry,
 )
@@ -27,7 +25,7 @@ class AgentCoordinator:
         self._collaboration_threshold = 0.7
         self.tracker = get_agent_tracker()
         self.debugger = get_ai_agent_debugger()
-        self.proactive_mode = True  # Enabled by default
+        self.proactive_mode = True
 
     def initialize_agents(self) -> None:
         self.agents = agent_registry.create_all(self.context)
@@ -62,40 +60,7 @@ class AgentCoordinator:
 
         return overall_result
 
-    async def handle_single_issue(self, issue: Issue) -> FixResult:
-        if not self.agents:
-            self.initialize_agents()
-
-        cache_key = issue.context_key
-        if cache_key in self._issue_cache:
-            cached_result = self._issue_cache[cache_key]
-            self.logger.info(f"Using cached result for {cache_key}")
-            self.tracker.track_cache_hit()
-            return cached_result
-
-        self.tracker.track_cache_miss()
-
-        agent_scores = await self._evaluate_agents_for_issue(issue)
-
-        if not agent_scores:
-            self.logger.warning(f"No agents can handle issue: {issue.message}")
-            return FixResult(
-                success=False,
-                confidence=0.0,
-                remaining_issues=[f"No agent available for: {issue.message}"],
-                recommendations=["Manual intervention required"],
-            )
-
-        best_agent, best_score = agent_scores[0]
-
-        if best_score >= self._collaboration_threshold:
-            result = await self._handle_with_single_agent(best_agent, issue)
-        else:
-            result = await self._handle_with_collaboration(agent_scores[:3], issue)
-
-        self._issue_cache[cache_key] = result
-
-        return result
+    # Removed unused method: handle_single_issue
 
     async def _handle_issues_by_type(
         self,
@@ -139,23 +104,6 @@ class AgentCoordinator:
 
         return combined_result
 
-    async def _evaluate_agents_for_issue(
-        self,
-        issue: Issue,
-    ) -> list[tuple[SubAgent, float]]:
-        evaluations: list[tuple[SubAgent, float]] = []
-
-        for agent in self.agents:
-            try:
-                confidence = await agent.can_handle(issue)
-                if confidence > 0.0:
-                    evaluations.append((agent, confidence))
-            except Exception as e:
-                self.logger.exception(f"Error evaluating {agent.name} for issue: {e}")
-
-        evaluations.sort(key=operator.itemgetter(1), reverse=True)
-        return evaluations
-
     async def _find_best_specialist(
         self,
         specialists: list[SubAgent],
@@ -226,45 +174,6 @@ class AgentCoordinator:
             self.tracker.track_agent_complete(agent.name, error_result)
             return error_result
 
-    async def _handle_with_collaboration(
-        self,
-        agent_scores: list[tuple[SubAgent, float]],
-        issue: Issue,
-    ) -> FixResult:
-        self.logger.info(
-            f"Using collaborative approach for issue: {issue.message[:100]}",
-        )
-
-        results: list[FixResult] = []
-
-        for agent, _ in agent_scores:
-            try:
-                result = await agent.analyze_and_fix(issue)
-                results.append(result)
-
-                if result.success and result.confidence >= 0.8:
-                    self.logger.info(f"{agent.name} solved issue with high confidence")
-                    break
-
-            except Exception as e:
-                self.logger.exception(f"Collaborative agent {agent.name} failed: {e}")
-                results.append(
-                    FixResult(
-                        success=False,
-                        confidence=0.0,
-                        remaining_issues=[f"{agent.name} failed: {e}"],
-                    ),
-                )
-
-        if not results:
-            return FixResult(success=False, confidence=0.0)
-
-        combined_result = results[0]
-        for result in results[1:]:
-            combined_result = combined_result.merge_with(result)
-
-        return combined_result
-
     def _group_issues_by_type(
         self,
         issues: list[Issue],
@@ -286,34 +195,7 @@ class AgentCoordinator:
             }
         return capabilities
 
-    def clear_cache(self) -> None:
-        self._issue_cache.clear()
-        self.logger.info("Cleared issue cache")
-
-    async def test_agent_connectivity(self) -> dict[str, bool]:
-        if not self.agents:
-            self.initialize_agents()
-
-        test_issue = Issue(
-            id="test",
-            type=IssueType.FORMATTING,
-            severity=Priority.LOW,
-            message="Test connectivity",
-        )
-
-        connectivity = {}
-        for agent in self.agents:
-            try:
-                confidence = await agent.can_handle(test_issue)
-                connectivity[agent.name] = confidence >= 0.0
-            except Exception as e:
-                self.logger.exception(f"Connectivity test failed for {agent.name}: {e}")
-                connectivity[agent.name] = False
-
-        return connectivity
-
     async def handle_issues_proactively(self, issues: list[Issue]) -> FixResult:
-        """Handle issues with proactive planning phase."""
         if not self.proactive_mode:
             return await self.handle_issues(issues)
 
@@ -325,13 +207,10 @@ class AgentCoordinator:
 
         self.logger.info(f"Handling {len(issues)} issues with proactive planning")
 
-        # Phase 1: Create architectural plan
         architectural_plan = await self._create_architectural_plan(issues)
 
-        # Phase 2: Apply fixes following the plan
         overall_result = await self._apply_fixes_with_plan(issues, architectural_plan)
 
-        # Phase 3: Validate against plan
         validation_result = await self._validate_against_plan(
             overall_result, architectural_plan
         )
@@ -339,14 +218,12 @@ class AgentCoordinator:
         return validation_result
 
     async def _create_architectural_plan(self, issues: list[Issue]) -> dict[str, t.Any]:
-        """Create architectural plan using ArchitectAgent."""
         architect = self._get_architect_agent()
 
         if not architect:
             self.logger.warning("No ArchitectAgent available for planning")
             return {"strategy": "reactive_fallback", "patterns": []}
 
-        # Analyze all issues together for comprehensive planning
         complex_issues = [
             issue
             for issue in issues
@@ -357,14 +234,11 @@ class AgentCoordinator:
         if not complex_issues:
             return {"strategy": "simple_fixes", "patterns": ["standard_patterns"]}
 
-        # Use the first complex issue for planning (represents the architectural challenge)
         primary_issue = complex_issues[0]
 
         try:
-            # Get plan from ArchitectAgent
             plan = await architect.plan_before_action(primary_issue)
 
-            # Extend plan to cover all issues
             plan["all_issues"] = [issue.id for issue in issues]
             plan["issue_types"] = list({issue.type.value for issue in issues})
 
@@ -380,16 +254,13 @@ class AgentCoordinator:
     async def _apply_fixes_with_plan(
         self, issues: list[Issue], plan: dict[str, t.Any]
     ) -> FixResult:
-        """Apply fixes following the architectural plan."""
         strategy = plan.get("strategy", "reactive_fallback")
 
         if strategy == "reactive_fallback":
-            # Fallback to standard processing
             return await self.handle_issues(issues)
 
         self.logger.info(f"Applying fixes with {strategy} strategy")
 
-        # Group issues by priority based on plan
         prioritized_issues = self._prioritize_issues_by_plan(issues, plan)
 
         overall_result = FixResult(success=True, confidence=1.0)
@@ -398,7 +269,6 @@ class AgentCoordinator:
             group_result = await self._handle_issue_group_with_plan(issue_group, plan)
             overall_result = overall_result.merge_with(group_result)
 
-            # If a critical group fails, consider the overall strategy
             if not group_result.success and self._is_critical_group(issue_group, plan):
                 overall_result.success = False
                 overall_result.remaining_issues.append(
@@ -410,7 +280,6 @@ class AgentCoordinator:
     async def _validate_against_plan(
         self, result: FixResult, plan: dict[str, t.Any]
     ) -> FixResult:
-        """Validate the results against the architectural plan."""
         validation_steps = plan.get("validation", [])
 
         if not validation_steps:
@@ -418,7 +287,6 @@ class AgentCoordinator:
 
         self.logger.info(f"Validating against plan: {validation_steps}")
 
-        # Add validation recommendations
         result.recommendations.extend(
             [
                 f"Validate with: {', '.join(validation_steps)}",
@@ -430,7 +298,6 @@ class AgentCoordinator:
         return result
 
     def _get_architect_agent(self) -> SubAgent | None:
-        """Get the ArchitectAgent from available agents."""
         for agent in self.agents:
             if agent.__class__.__name__ == "ArchitectAgent":
                 return agent
@@ -439,11 +306,9 @@ class AgentCoordinator:
     def _prioritize_issues_by_plan(
         self, issues: list[Issue], plan: dict[str, t.Any]
     ) -> list[list[Issue]]:
-        """Prioritize issues based on the architectural plan."""
         strategy = plan.get("strategy", "reactive_fallback")
 
         if strategy == "external_specialist_guided":
-            # Handle complex issues first, then simple ones
             complex_issues = [
                 issue
                 for issue in issues
@@ -452,24 +317,20 @@ class AgentCoordinator:
             other_issues = [issue for issue in issues if issue not in complex_issues]
             return [complex_issues, other_issues] if complex_issues else [other_issues]
 
-        # Default: group by type for parallel processing
         groups = self._group_issues_by_type(issues)
         return list(groups.values())
 
     async def _handle_issue_group_with_plan(
         self, issues: list[Issue], plan: dict[str, t.Any]
     ) -> FixResult:
-        """Handle a group of issues with architectural guidance."""
         if not issues:
             return FixResult(success=True, confidence=1.0)
 
-        # Get the best agent for this group, preferring ArchitectAgent for complex issues
         representative_issue = issues[0]
 
         if self._should_use_architect_for_group(issues, plan):
             architect = self._get_architect_agent()
             if architect:
-                # Use architect for the whole group
                 group_result = FixResult(success=True, confidence=1.0)
 
                 for issue in issues:
@@ -478,20 +339,16 @@ class AgentCoordinator:
 
                 return group_result
 
-        # Use standard routing for simpler issues
         return await self._handle_issues_by_type(representative_issue.type, issues)
 
     def _should_use_architect_for_group(
         self, issues: list[Issue], plan: dict[str, t.Any]
     ) -> bool:
-        """Determine if ArchitectAgent should handle this group."""
         strategy = plan.get("strategy", "")
 
-        # Always use architect for specialist-guided strategies
         if strategy == "external_specialist_guided":
             return True
 
-        # Use architect for complex or architectural issues
         architectural_types = {
             IssueType.COMPLEXITY,
             IssueType.DRY_VIOLATION,
@@ -501,12 +358,9 @@ class AgentCoordinator:
         return any(issue.type in architectural_types for issue in issues)
 
     def _is_critical_group(self, issues: list[Issue], plan: dict[str, t.Any]) -> bool:
-        """Determine if this issue group is critical to the plan."""
-        # Complex and DRY violations are typically critical
         critical_types = {IssueType.COMPLEXITY, IssueType.DRY_VIOLATION}
         return any(issue.type in critical_types for issue in issues)
 
     def set_proactive_mode(self, enabled: bool) -> None:
-        """Enable or disable proactive planning mode."""
         self.proactive_mode = enabled
         self.logger.info(f"Proactive mode {'enabled' if enabled else 'disabled'}")