crackerjack 0.39.11__py3-none-any.whl → 0.40.1__py3-none-any.whl

crackerjack/agents/claude_code_bridge.py

@@ -8,10 +8,22 @@ agents to consult with expert external agents for complex scenarios.
 
 import logging
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 
+from crackerjack.services.file_modifier import SafeFileModifier
+
 from .base import AgentContext, FixResult, Issue, IssueType
 
+# Conditional import - ClaudeCodeFixer may not be available
+_claude_ai_available = False
+ClaudeCodeFixer: type[t.Any] | None = None
+
+with suppress(ImportError):
+    from crackerjack.adapters.ai.claude import ClaudeCodeFixer  # type: ignore[no-redef]
+
+    _claude_ai_available = True
+
 # Mapping of internal issue types to Claude Code external agents
 CLAUDE_CODE_AGENT_MAPPING = {
     IssueType.COMPLEXITY: ["refactoring-specialist", "crackerjack-architect"],
@@ -31,7 +43,7 @@ EXTERNAL_CONSULTATION_THRESHOLD = 0.8
 
 
 class ClaudeCodeBridge:
-    """Bridge for consulting Claude Code external agents."""
+    """Bridge for consulting Claude Code external agents with real AI integration."""
 
     def __init__(self, context: AgentContext) -> None:
         self.context = context
@@ -39,6 +51,16 @@ class ClaudeCodeBridge:
         self._agent_path = Path.home() / ".claude" / "agents"
         self._consultation_cache: dict[str, dict[str, t.Any]] = {}
 
+        # Real AI integration components (if available)
+        self.ai_fixer: t.Any | None = None  # ClaudeCodeFixer instance or None
+        self.file_modifier = SafeFileModifier()
+        self._ai_available = _claude_ai_available
+
+        if not self._ai_available:
+            self.logger.warning(
+                "Claude AI adapter not available - AI-powered fixes disabled"
+            )
+
     def should_consult_external_agent(
         self, issue: Issue, internal_confidence: float
     ) -> bool:
@@ -285,6 +307,185 @@ class ClaudeCodeBridge:
             "validation_steps": ["validate_domain_requirements"],
         }
 
+    async def _ensure_ai_fixer(self) -> t.Any:
+        """Lazy initialization of AI fixer adapter.
+
+        Returns:
+            Initialized ClaudeCodeFixer instance
+
+        Raises:
+            RuntimeError: If Claude AI is not available or initialization fails
+        """
+        if not self._ai_available:
+            raise RuntimeError(
+                "Claude AI adapter not available - install ACB with 'uv add acb[ai]'"
+            )
+
+        if self.ai_fixer is None:
+            if ClaudeCodeFixer is None:
+                raise RuntimeError("ClaudeCodeFixer import failed")
+
+            self.ai_fixer = ClaudeCodeFixer()
+            await self.ai_fixer.init()
+            self.logger.debug("Claude AI fixer initialized")
+
+        return self.ai_fixer
+
+    async def consult_on_issue(
+        self,
+        issue: Issue,
+        dry_run: bool = False,
+    ) -> FixResult:
+        """Consult with Claude AI to fix an issue using real AI integration.
+
+        This method replaces the simulation-based approach with real AI-powered
+        code fixing. It:
+        1. Calls the ClaudeCodeFixer adapter to generate a fix
+        2. Validates the AI response (confidence, success)
+        3. Uses SafeFileModifier to safely apply changes
+        4. Handles errors gracefully
+        5. Returns a proper FixResult
+
+        Args:
+            issue: Issue to fix
+            dry_run: If True, only generate fix without applying
+
+        Returns:
+            FixResult with fix details and success status
+        """
+        try:
+            # Initialize AI fixer if needed
+            fixer = await self._ensure_ai_fixer()
+
+            # Extract issue details for AI context
+            file_path = str(issue.file_path) if issue.file_path else "unknown"
+            issue_description = issue.message  # Issue uses 'message' not 'description'
+            code_snippet = "\n".join(issue.details) if issue.details else ""
+            fix_type = issue.type.value
+
+            self.logger.info(
+                f"Consulting Claude AI for {fix_type} issue in {file_path}"
+            )
+
+            # Call AI fixer to generate code fix
+            ai_result = await fixer.fix_code_issue(
+                file_path=file_path,
+                issue_description=issue_description,
+                code_context=code_snippet,
+                fix_type=fix_type,
+            )
+
+            # Check if AI fix was successful
+            if not ai_result.get("success"):
+                error_msg = ai_result.get("error", "Unknown AI error")
+                self.logger.error(f"AI fix failed: {error_msg}")
+
+                return FixResult(
+                    success=False,
+                    confidence=0.0,
+                    fixes_applied=[],
+                    remaining_issues=[issue.id],
+                    recommendations=[f"AI fix failed: {error_msg}"],
+                    files_modified=[],
+                )
+
+            # Extract AI response fields
+            fixed_code = str(ai_result.get("fixed_code", ""))
+            explanation = str(ai_result.get("explanation", "No explanation"))
+            confidence = float(ai_result.get("confidence", 0.0))
+            changes_made = ai_result.get("changes_made", [])
+            potential_side_effects = ai_result.get("potential_side_effects", [])
+
+            # Validate confidence threshold
+            min_confidence = 0.7  # Match AI fixer's default
+            if confidence < min_confidence:
+                self.logger.warning(
+                    f"AI confidence {confidence:.2f} below threshold {min_confidence}"
+                )
+
+                return FixResult(
+                    success=False,
+                    confidence=confidence,
+                    fixes_applied=[],
+                    remaining_issues=[issue.id],
+                    recommendations=[
+                        f"AI fix confidence {confidence:.2f} too low (threshold: {min_confidence})",
+                        explanation,
+                    ],
+                    files_modified=[],
+                )
+
+            # Apply fix using SafeFileModifier
+            if not dry_run and fixed_code:
+                modify_result = await self.file_modifier.apply_fix(
+                    file_path=file_path,
+                    fixed_content=fixed_code,
+                    dry_run=dry_run,
+                    create_backup=True,
+                )
+
+                if not modify_result.get("success"):
+                    error_msg = modify_result.get("error", "Unknown modification error")
+                    self.logger.error(f"File modification failed: {error_msg}")
+
+                    return FixResult(
+                        success=False,
+                        confidence=confidence,
+                        fixes_applied=[],
+                        remaining_issues=[issue.id],
+                        recommendations=[
+                            f"File modification failed: {error_msg}",
+                            explanation,
+                        ],
+                        files_modified=[],
+                    )
+
+                # Success - fix applied
+                self.logger.info(
+                    f"Successfully applied AI fix to {file_path} (confidence: {confidence:.2f})"
+                )
+
+                return FixResult(
+                    success=True,
+                    confidence=confidence,
+                    fixes_applied=[f"Fixed {fix_type} in {file_path}"],
+                    remaining_issues=[],
+                    recommendations=[
+                        explanation,
+                        *[f"Change: {change}" for change in changes_made],
+                        *[
+                            f"Potential side effect: {effect}"
+                            for effect in potential_side_effects
+                        ],
+                    ],
+                    files_modified=[file_path],
+                )
+            else:
+                # Dry-run mode or no code - just report recommendation
+                return FixResult(
+                    success=True,
+                    confidence=confidence,
+                    fixes_applied=[],
+                    remaining_issues=[issue.id],
+                    recommendations=[
+                        f"AI suggests (dry-run): {explanation}",
+                        *[f"Change: {change}" for change in changes_made],
+                    ],
+                    files_modified=[],
+                )
+
+        except Exception as e:
+            self.logger.exception(f"Unexpected error in consult_on_issue: {e}")
+
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                fixes_applied=[],
+                remaining_issues=[issue.id],
+                recommendations=[f"Unexpected error: {e}"],
+                files_modified=[],
+            )
+
     def create_enhanced_fix_result(
         self, base_result: FixResult, consultations: list[dict[str, t.Any]]
     ) -> FixResult:

crackerjack/cli/facade.py

@@ -1,4 +1,5 @@
 import asyncio
+import shlex
 from pathlib import Path
 
 from rich.console import Console
@@ -6,6 +7,67 @@ from rich.console import Console
 from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
 from crackerjack.models.protocols import OptionsProtocol
 
+# Valid semantic commands for crackerjack operations
+VALID_COMMANDS = {"test", "lint", "check", "format", "security", "complexity", "all"}
+
+
+def validate_command(
+    command: str | None, args: str | None = None
+) -> tuple[str, list[str]]:
+    """Validate command and detect common misuse patterns.
+
+    Args:
+        command: Semantic command name (test, lint, check, etc.)
+        args: Additional arguments as a string
+
+    Returns:
+        Tuple of (validated_command, cleaned_args_list)
+
+    Raises:
+        ValueError: If command is invalid or misused
+
+    Examples:
+        >>> validate_command("test", "")
+        ("test", [])
+        >>> validate_command("check", "--verbose")
+        ("check", ["--verbose"])
+        >>> validate_command("--ai-fix", "-t")
+        Traceback (most recent call last):
+        ...
+        ValueError: Invalid command: '--ai-fix'...
+    """
+    # CRITICAL: Check for None command first
+    if command is None:
+        raise ValueError("Command cannot be None")
+
+    # Detect if user put flags in command parameter
+    if command.startswith("--") or command.startswith("-"):
+        raise ValueError(
+            f"Invalid command: {command!r}\n"
+            f"Commands should be semantic (e.g., 'test', 'lint', 'check')\n"
+            f"Use ai_agent_mode=True parameter for auto-fix, not --ai-fix in command"
+        )
+
+    # Validate against known semantic commands
+    if command not in VALID_COMMANDS:
+        raise ValueError(
+            f"Unknown command: {command!r}\n"
+            f"Valid commands: {', '.join(sorted(VALID_COMMANDS))}"
+        )
+
+    # Parse args and detect --ai-fix misuse
+    # Handle None gracefully by converting to empty string
+    args_str = args if args is not None else ""
+    # Use shlex.split for proper shell argument parsing (handles quotes)
+    parsed_args = shlex.split(args_str) if args_str else []
+    if "--ai-fix" in parsed_args:
+        raise ValueError(
+            "Do not pass --ai-fix in args parameter\n"
+            "Use ai_agent_mode=True parameter instead"
+        )
+
+    return command, parsed_args
+
 
 class CrackerjackCLIFacade:
     def __init__(

crackerjack/cli/options.py

@@ -149,6 +149,7 @@ class Options(BaseModel):
     strip_code: bool | None = None  # Replaces clean
     run_tests: bool = False  # Replaces test
     ai_fix: bool | None = None  # Replaces ai_agent
+    dry_run: bool = False  # Preview fixes without applying
     full_release: str | None = None  # Replaces all
     show_progress: bool | None = None  # Replaces track_progress
     advanced_monitor: bool | None = None  # Replaces enhanced_monitor
@@ -583,9 +584,9 @@ CLI_OPTIONS = {
         help="Port for unified dashboard server (default: 8675).",
     ),
     "max_iterations": typer.Option(
-        5,
+        10,
         "--max-iterations",
-        help="Maximum number of iterations for AI agent auto-fixing workflows (default: 5).",
+        help="Maximum auto-fix iterations (default: 10).",
     ),
     "ai_debug": typer.Option(
         False,
@@ -706,10 +707,17 @@ CLI_OPTIONS = {
         None,
         "--ai-fix",
         help=(
-            "Enable AI-powered automatic fixing of code quality issues "
-            "and test failures."
+            "Enable AI-powered auto-fixing. "
+            "Iteratively fixes code issues using Claude AI. "
+            "Requires ANTHROPIC_API_KEY environment variable. "
+            "Max 10 iterations, stops when all hooks pass."
         ),
     ),
+    "dry_run": typer.Option(
+        False,
+        "--dry-run",
+        help="Preview fixes without modifying files (implies --ai-fix).",
+    ),
     "full_release": typer.Option(
         None,
         "-a",
@@ -1045,6 +1053,7 @@ def create_options(
     strip_code: bool | None = None,
     run_tests: bool = False,
     ai_fix: bool | None = None,
+    dry_run: bool = False,
     full_release: str | None = None,
     show_progress: bool | None = None,
     advanced_monitor: bool | None = None,
@@ -1142,6 +1151,7 @@ def create_options(
         strip_code=strip_code,
         run_tests=run_tests,
         ai_fix=ai_fix,
+        dry_run=dry_run,
         full_release=full_release,
         show_progress=show_progress,
         advanced_monitor=advanced_monitor,

crackerjack/dynamic_config.py

@@ -174,7 +174,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "stages": None,
             "args": None,
             "files": None,
-            "exclude": r"uv\.lock|pyproject\.toml|tests/.*|docs/.*|.*\.md",
+            "exclude": r"uv\.lock|pyproject\.toml|tests/.*|docs/.*|\.claude/.*|.*\.md",
             "additional_dependencies": None,
             "types_or": None,
             "language": None,

crackerjack/services/__init__.py

@@ -1,22 +1,9 @@
-from .cache import CacheEntry, CacheStats, CrackerjackCache, FileCache, InMemoryCache
-from .config import ConfigurationService
-from .file_hasher import FileHasher, SmartFileWatcher
-from .filesystem import FileSystemService
-from .git import GitService
-from .initialization import InitializationService
-from .security import SecurityService
+"""Services for crackerjack.
 
-__all__ = [
-    "CacheEntry",
-    "CacheStats",
-    "ConfigurationService",
-    "CrackerjackCache",
-    "FileCache",
-    "FileHasher",
-    "FileSystemService",
-    "GitService",
-    "InMemoryCache",
-    "InitializationService",
-    "SecurityService",
-    "SmartFileWatcher",
-]
+This package contains service classes that provide business logic
+and operations that are used across multiple components.
+"""
+
+from crackerjack.services.file_modifier import SafeFileModifier
+
+__all__ = ["SafeFileModifier"]