crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/version_analyzer.py

@@ -6,7 +6,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from .changelog_automation import ChangelogEntry, ChangelogGenerator
 from .git import GitService
@@ -194,7 +195,8 @@ class ConventionalCommitAnalyzer:
 class VersionAnalyzer:
     """Main service for analyzing changes and recommending version bumps."""
 
-    def __init__(self, console: Console, git_service: GitService) -> None:
+    @depends.inject
+    def __init__(self, console: Inject[Console], git_service: GitService) -> None:
         self.console = console
         self.git = git_service
 
@@ -203,8 +205,8 @@ class VersionAnalyzer:
         self.feature_analyzer = FeatureAnalyzer()
         self.commit_analyzer = ConventionalCommitAnalyzer()
 
-        # Initialize changelog generator for getting entries
-        self.changelog_generator = ChangelogGenerator(console, git_service)
+        # Initialize changelog generator for getting entries (ACB DI injects dependencies)
+        self.changelog_generator = ChangelogGenerator()
 
     def _get_current_version(self) -> str | None:
         """Get current version from pyproject.toml."""

crackerjack/services/version_checker.py

@@ -3,7 +3,10 @@ import typing as t
 from dataclasses import dataclass
 
 import aiohttp
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
+
+from crackerjack.core.retry import retry_api_call
 
 
 @dataclass
@@ -16,7 +19,8 @@ class VersionInfo:
 
 
 class VersionChecker:
-    def __init__(self, console: Console) -> None:
+    @depends.inject
+    def __init__(self, console: Inject[Console]) -> None:
         self.console = console
         self.tools_to_check = {
             "ruff": self._get_ruff_version,
@@ -115,13 +119,15 @@ class VersionChecker:
             pass
         return None
 
+    @retry_api_call(max_attempts=3, delay=1.0, backoff=2.0, max_delay=30.0)
     async def _fetch_latest_version(self, tool_name: str) -> str | None:
         try:
+            # Fix URLs - remove spaces that were added
             pypi_urls = {
-                "ruff": "https: / / pypi.org / pypi / ruff / json",
-                "pyright": "https: / / pypi.org / pypi / pyright / json",
-                "pre-commit": "https: / / pypi.org / pypi / pre-commit / json",
-                "uv": "https: / / pypi.org / pypi / uv / json",
+                "ruff": "https://pypi.org/pypi/ruff/json",
+                "pyright": "https://pypi.org/pypi/pyright/json",
+                "pre-commit": "https://pypi.org/pypi/pre-commit/json",
+                "uv": "https://pypi.org/pypi/uv/json",
             }
 
             url = pypi_urls.get(tool_name)
@@ -132,8 +138,8 @@ class VersionChecker:
             async with aiohttp.ClientSession(timeout=timeout) as session:
                 async with session.get(url) as response:
                     response.raise_for_status()
-                    data = await response.json()
-                    return data.get("info", {}).get("version")  # type: ignore[no-any-return]
+                    data: dict[str, t.Any] = await response.json()
+                    return data.get("info", {}).get("version")
 
         except Exception:
             return None

crackerjack/services/zuban_lsp_service.py

@@ -9,7 +9,8 @@ import typing as t
 from contextlib import suppress
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import depends
 
 from .security_logger import get_security_logger
 
@@ -34,7 +35,7 @@ class ZubanLSPService:
         """
         self.port = port
         self.mode = mode
-        self.console = console or Console()
+        self.console = console or depends.get_sync(Console)
         self.process: subprocess.Popen[bytes] | None = None
         self.start_time: float = 0.0
         self.security_logger = get_security_logger()
@@ -358,7 +359,7 @@ class ZubanLSPService:
         # This is a simplified implementation
         # In a production system, you'd want to use proper async I/O
         loop = asyncio.get_event_loop()
-        line = await loop.run_in_executor(None, self.process.stdout.readline)
+        line = await loop.run_in_executor(None, self.process.stdout.readline)  # type: ignore[call-arg]
         return line.decode("utf-8").rstrip("\r\n")
 
     async def _read_bytes_async(self, count: int) -> bytes:
@@ -367,7 +368,7 @@ class ZubanLSPService:
             return b""
 
         loop = asyncio.get_event_loop()
-        data = await loop.run_in_executor(None, self.process.stdout.read, count)
+        data = await loop.run_in_executor(None, self.process.stdout.read, count)  # type: ignore[call-arg]
         return data
 
 

crackerjack/slash_commands/README.md

@@ -0,0 +1,11 @@
+> Crackerjack Docs: [Main](<../../README.md>) | [Crackerjack Package](<../README.md>) | [Slash Commands](<./README.md>)
+
+# Slash Commands
+
+Slash command handlers and related routing.
+
+## Related
+
+- [Crackerjack Package](<../README.md>) - Parent package
+- [MCP](<../mcp/README.md>) - MCP server slash command integration
+- [CLI](<../cli/README.md>) - Command-line interface handlers

crackerjack/slash_commands/init.md

@@ -22,11 +22,9 @@ This slash command initializes a new Python project with crackerjack's best prac
 1. **Checks Project State**: Verifies which configuration files exist
 1. **Smart Merge Configuration**:
    - `pyproject.toml` - Intelligently merges tool configurations, preserves higher coverage requirements
-   - `.pre-commit-config.yaml` - Adds missing repos, preserves existing hooks
    - `CLAUDE.md` - Appends crackerjack guidelines without overwriting existing content
    - `RULES.md` - Copies only if missing, preserves existing coding standards
 1. **Preserves Project Identity**: Never overwrites existing project metadata, dependencies, or configurations
-1. **Installs Pre-commit Hooks**: Sets up git hooks for quality enforcement
 
 ## When to Use /crackerjack:init
 
@@ -34,9 +32,8 @@ This slash command initializes a new Python project with crackerjack's best prac
 
 The MCP server can detect when initialization is needed:
 
-- **Missing Core Files**: No pyproject.toml or .pre-commit-config.yaml
+- **Missing Core Files**: No pyproject.toml
 - **New Project**: Git repository just initialized
-- **Outdated Hooks**: Pre-commit hooks older than 30 days
 - **Manual Request**: User explicitly asks for initialization
 
 ### Recommended Frequency
@@ -62,7 +59,6 @@ AI: I'll initialize crackerjack configuration for your project.
 
 The project has been initialized with:
 ✅ pyproject.toml - Project configuration
-✅ .pre-commit-config.yaml - Quality hooks
 ✅ CLAUDE.md - AI guidelines
 ✅ RULES.md - Coding standards
 
@@ -75,7 +71,7 @@ When connected via MCP, crackerjack can automatically suggest initialization whe
 
 1. Running `/crackerjack:run` in an uninitialized project
 1. Detecting missing critical configuration files
-1. Finding outdated pre-commit hooks (>30 days old)
+1. Finding configuration files that need updates
 
 This ensures projects always have up-to-date quality standards without manual intervention.
 
@@ -97,12 +93,6 @@ This ensures projects always have up-to-date quality standards without manual in
 - **Prevents Duplicates**: Skips if crackerjack section already exists
 - **Clear Boundaries**: Uses `<!-- CRACKERJACK_START -->` and `<!-- CRACKERJACK_END -->` markers
 
-### .pre-commit-config.yaml Smart Merge
-
-- **Adds Missing Repos**: Only adds pre-commit repos that don't already exist
-- **Preserves Existing Hooks**: Never modifies existing hook configurations
-- **Skips if No New Repos**: Intelligent detection prevents unnecessary changes
-
 ### Universal Compatibility
 
 This smart merge approach works with **any Python package**, not just specific projects:

crackerjack/slash_commands/run.md

@@ -1,15 +1,15 @@
 ______________________________________________________________________
 
-## description: Run Crackerjack with advanced orchestrated AI-powered auto-fix mode to automatically resolve all code quality issues with intelligent execution strategies and granular progress tracking.
+## description: Run crackerjack with AI-powered auto-fixing using intelligent session integration. Automatically tries enhanced session-mgmt execution first, then gracefully falls back to standard crackerjack execution if unavailable. Perfect for comprehensive code quality enforcement with zero configuration required.
 
-# /crackerjack:run
+# /run
 
-Run Crackerjack with advanced orchestrated AI-powered auto-fix mode to automatically resolve all code quality issues with intelligent execution strategies and granular progress tracking.
+Intelligent crackerjack runner that tries session-mgmt:crackerjack-run first with fallback to crackerjack:run for optimal integration with session management systems.
 
 ## Usage
 
 ```
-/crackerjack:run [--debug]
+/run [--debug]
 ```
 
 ### Arguments
@@ -22,7 +22,12 @@ Run Crackerjack with advanced orchestrated AI-powered auto-fix mode to automatic
 
 ## Description
 
-This slash command runs Crackerjack with AI agent mode for autonomous code quality enforcement:
+This slash command provides intelligent crackerjack execution with automatic fallback:
+
+1. **Primary**: Attempts `session-mgmt:crackerjack-run` for enhanced session integration
+1. **Fallback**: Uses `crackerjack:run` if session-mgmt is unavailable
+
+Both execution paths use AI agent mode for autonomous code quality enforcement:
 
 - `--ai-fix`: AI auto-fixing mode for structured error output and intelligent fixing
 - `--test`: Run tests with comprehensive test coverage
@@ -30,25 +35,46 @@ This slash command runs Crackerjack with AI agent mode for autonomous code quali
 
 ## 💡 Agent Recommendation
 
-**For optimal results, use the `crackerjack-architect` agent alongside `/crackerjack:run`:**
+**For optimal results, use the `crackerjack-architect` agent alongside `/run`:**
 
 ```bash
 # 1. Plan with crackerjack-architect first
 Task tool with subagent_type="crackerjack-architect" for feature planning
 
 # 2. Run crackerjack for quality enforcement
-/crackerjack:run
+/run
 
 # 3. Use crackerjack-architect for any remaining issues
 ```
 
-**Why?** The crackerjack-architect agent ensures code follows crackerjack patterns from the start, reducing the number of iterations needed for `/crackerjack:run` to achieve full compliance.
+**Why?** The crackerjack-architect agent ensures code follows crackerjack patterns from the start, reducing the number of iterations needed for `/run` to achieve full compliance.
 
 ## What It Does
 
-**Iterative AI-Powered Auto-Fixing Process (up to 10 iterations):**
+**Smart Execution Strategy:**
+
+### 1. 🧠 **Session-Mgmt Integration (Primary)**
+
+When `session-mgmt:crackerjack-run` is available:
+
+- **Enhanced Context**: Leverages session history for better AI decisions
+- **Progress Continuity**: Builds on previous session learnings
+- **Memory Integration**: Remembers past error patterns and fixes
+- **Quality Trends**: Uses historical quality metrics for optimization
+
+### 2. 🔄 **Standard Execution (Fallback)**
+
+When session-mgmt is unavailable, falls back to `crackerjack:run`:
+
+- **Full Functionality**: Complete AI auto-fixing capabilities
+- **Zero Degradation**: All quality features remain available
+- **Seamless Transition**: User experience unchanged
 
-### Pre-Execution Safety Checks:
+### 3. ⚡ **Iterative AI-Powered Auto-Fixing Process (up to 10 iterations)**
+
+Both execution paths follow the same comprehensive workflow:
+
+#### Pre-Execution Safety Checks:
 
 0. 🔍 **Comprehensive Status Check** (automatic conflict prevention)
 
@@ -58,7 +84,7 @@ Task tool with subagent_type="crackerjack-architect" for feature planning
    - Auto-start missing services if needed
    - Report resource usage and system health
 
-### Each Iteration Cycle:
+#### Each Iteration Cycle:
 
 1. ⚡ **Fast Hooks** (formatting & basic fixes)
 
@@ -90,7 +116,7 @@ Task tool with subagent_type="crackerjack-architect" for feature planning
 
 1. 🔄 **Next Full Iteration**: Repeat entire cycle until ALL checks pass or max iterations (10) reached
 
-### Final Result:
+#### Final Result:
 
 🎉 **Perfect Code Quality**: All hooks pass, all tests pass, zero manual intervention!
 
@@ -100,64 +126,72 @@ When an AI assistant uses this command:
 
 ```
 User: Can you fix all the code quality issues in this project?
-AI: I'll use the /crackerjack:run command to automatically fix all code quality issues.
+AI: I'll use the /run command to automatically fix all code quality issues with intelligent session integration.
+
+/run
+
+[AI first tries: session-mgmt:crackerjack-run]
+✅ Session-mgmt available - using enhanced execution mode
 
-/crackerjack:run
+[Enhanced execution with session context: python -m crackerjack --ai-fix --test --verbose]
 
-[AI runs: python -m crackerjack --ai-fix --test --verbose]
+The crackerjack AI agent completed successfully after 2 iterations! Here's what was automatically fixed:
 
-The crackerjack AI agent completed successfully after 3 iterations! Here's what was automatically fixed:
+**Session Context Benefits**:
+- Leveraged previous session learnings about this codebase
+- Applied remembered fix patterns from similar issues
+- Optimized execution based on historical performance data
 
 **Iteration 1**: Fixed formatting and imports
 - Reformatted 5 files with proper indentation
-- Organized imports in 3 modules
+- Organized imports in 3 modules (using cached preferences)
 - Removed trailing whitespace
 
-**Iteration 2**: Resolved type and security issues
-- Added type hints to 7 functions
-- Fixed 2 hardcoded temp path security warnings
-- Removed 1 unused variable
+**Iteration 2**: Final quality improvements
+- Added type hints to 4 functions (improved from previous 7 due to session learning)
+- All 42 tests now pass with 47% coverage
 
-**Iteration 3**: Final test fixes
-- Fixed missing test fixture import
-- Updated assertion in test_workflow.py
-- All 42 tests now pass with 45% coverage
-
-🎉 **Result**: Perfect code quality achieved with zero manual intervention!
+🎉 **Result**: Perfect code quality achieved with enhanced session integration!
 ```
 
 ## Benefits
 
-- **Zero Configuration**: AI doesn't need to remember complex flag combinations
-- **Optimal Settings**: Always uses the most effective options
-- **Complete Automation**: Handles the entire quality workflow automatically
-- **Consistent Results**: Same high-quality outcome every time
+- **Smart Integration**: Automatically leverages session-mgmt when available
+- **Graceful Fallback**: No functionality loss when session-mgmt unavailable
+- **Enhanced Learning**: Session context improves AI decision quality
+- **Zero Configuration**: AI doesn't need to remember complex integration logic
+- **Optimal Performance**: Uses best available execution method automatically
+- **Consistent Results**: Same high-quality outcome regardless of execution path
 
 ## Implementation
 
-**CRITICAL**: When an AI assistant encounters `/crackerjack:run`, it MUST ONLY use the MCP server tools. Never fall back to bash/shell execution of `python -m crackerjack`.
-
-When an AI assistant encounters `/crackerjack:run`, it calls the MCP server tool directly:
+**CRITICAL**: When an AI assistant encounters `/run`, it MUST implement the intelligent fallback strategy using MCP server tools.
 
-**Note**: The WebSocket server on localhost:8675 is automatically started when the command runs, so no manual setup is required.
+### Execution Strategy
 
 ```python
-# Call MCP server tool for orchestrated iterative auto-fixing (returns job_id immediately)
-job_result = execute_crackerjack("/crackerjack:run")
-job_id = job_result["job_id"]
-
-# For debugging, use the --debug flag:
-job_result = execute_crackerjack("/crackerjack:run --debug")
-# This runs in foreground and shows all output directly
+# 1. Try session-mgmt integration first
+try:
+    job_result = session_mgmt_crackerjack_run()
+    job_id = job_result["job_id"]
+    print("✅ Using session-mgmt enhanced execution")
+except (ConnectionError, ServiceUnavailable, ToolNotFound):
+    # 2. Fallback to standard crackerjack execution
+    job_result = execute_crackerjack("/crackerjack:run")
+    job_id = job_result["job_id"]
+    print("⚡ Using standard crackerjack execution")
+
+# For debugging, append --debug flag to either execution path:
+# session_mgmt_crackerjack_run("--debug") or execute_crackerjack("/crackerjack:run --debug")
 ```
 
-This runs the AI agent auto-fixing process:
+### Key Features
 
-- **Background Execution**: Workflow runs in background, returns job_id immediately
-- **Progress Tracking**: Real-time progress updates via MCP tools
-- **Autonomous Fixing**: Makes actual code changes to resolve all issues
-- **Comprehensive Coverage**: Handles ALL error types (not just formatting)
-- **Iterative Process**: Continues fixing until perfect quality achieved (up to 10 iterations)
-- **Zero Manual Work**: No human intervention required
+- **Automatic Detection**: No manual configuration needed
+- **Seamless Fallback**: User unaware of which execution path used
+- **Progress Tracking**: Real-time progress updates via MCP tools for both paths
+- **Enhanced Context**: Session-mgmt path leverages conversation history
+- **Background Execution**: Both paths run in background, return job_id immediately
+- **Debug Support**: --debug flag works with both execution methods
 
-**Note**: This is NOT the same as basic hook auto-fix modes (like `ruff --fix`) which only handle simple formatting. The AI agent performs sophisticated code analysis and coordinated modification.
+**Note**: This command provides the best of both worlds - enhanced session integration when available, with full functionality guaranteed through intelligent fallback.

crackerjack/tools/README.md

@@ -0,0 +1,11 @@
+> Crackerjack Docs: [Main](<../../README.md>) | [Crackerjack Package](<../README.md>) | [Tools](<./README.md>)
+
+# Package Tools
+
+Internal helper tools used within the package (distinct from top-level `tools/`).
+
+## Related
+
+- [Crackerjack Package](<../README.md>) - Parent package
+- [MCP](<../mcp/README.md>) - MCP tool implementations
+- [Services](<../services/README.md>) - Service layer using these tools

crackerjack/tools/__init__.py

@@ -0,0 +1,30 @@
+"""Native tool implementations for crackerjack (Phase 8).
+
+This package contains Python implementations of quality checking tools,
+providing direct invocation without pre-commit wrapper overhead.
+
+Native tools replace pre-commit-hooks utilities with equivalent functionality:
+- trailing_whitespace: Remove trailing whitespace
+- end_of_file_fixer: Ensure files end with newline
+- check_yaml: Validate YAML syntax
+- check_toml: Validate TOML syntax
+- check_json: Validate JSON syntax
+- check_ast: Validate Python AST syntax
+- format_json: Format JSON files
+- check_jsonschema: Validate JSON files against schemas
+- check_added_large_files: Warn on large file additions
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "trailing_whitespace",
+    "end_of_file_fixer",
+    "check_yaml",
+    "check_toml",
+    "check_json",
+    "check_ast",
+    "format_json",
+    "check_jsonschema",
+    "check_added_large_files",
+]

crackerjack/tools/_git_utils.py

@@ -0,0 +1,105 @@
+"""Git-aware file discovery utilities for native tools.
+
+This module provides utilities for discovering files while respecting .gitignore
+patterns. It uses `git ls-files` to automatically handle gitignore compliance,
+making crackerjack behave identically to pre-commit.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def get_git_tracked_files(pattern: str | None = None) -> list[Path]:
+    """Get list of files tracked by git, optionally filtered by pattern.
+
+    This function uses `git ls-files` which automatically respects .gitignore
+    patterns. This is the industry-standard approach used by pre-commit and
+    ensures only git-tracked files are processed.
+
+    Args:
+        pattern: Optional glob pattern to filter files (e.g., "*.py", "*.yaml")
+                If None, returns all tracked files.
+
+    Returns:
+        List of Path objects for git-tracked files matching the pattern.
+        Falls back to empty list if not in a git repository.
+
+    Example:
+        >>> # Get all tracked Python files
+        >>> python_files = get_git_tracked_files("*.py")
+        >>> # Get all tracked YAML files
+        >>> yaml_files = get_git_tracked_files("*.yaml")
+    """
+    try:
+        cmd = ["git", "ls-files"]
+        if pattern:
+            cmd.append(pattern)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=Path.cwd(),
+        )
+
+        # Filter to only include files that actually exist on disk
+        # (git ls-files can include deleted files still in the index)
+        return [
+            Path(line.strip())
+            for line in result.stdout.splitlines()
+            if line.strip() and Path(line.strip()).exists()
+        ]
+
+    except subprocess.CalledProcessError:
+        # Git command failed (not in a git repo, etc.)
+        return []
+    except FileNotFoundError:
+        # Git not available
+        return []
+
+
+def get_files_by_extension(extensions: list[str], use_git: bool = True) -> list[Path]:
+    """Get files with specified extensions, respecting git if available.
+
+    Args:
+        extensions: List of file extensions to match (e.g., [".py", ".yaml"])
+        use_git: If True (default), use git ls-files when in a git repo.
+                If False, use Path.rglob() for all files.
+
+    Returns:
+        List of Path objects matching the extensions.
+        Automatically respects .gitignore when use_git=True.
+
+    Example:
+        >>> # Get Python files (git-aware)
+        >>> py_files = get_files_by_extension([".py"])
+        >>> # Get YAML files (all files, ignore git)
+        >>> yaml_files = get_files_by_extension([".yaml", ".yml"], use_git=False)
+    """
+    if not use_git:
+        # Fallback to rglob for all files
+        files = []
+        for ext in extensions:
+            files.extend(Path.cwd().rglob(f"*{ext}"))
+        return [f for f in files if f.is_file()]
+
+    # Try git-aware discovery first
+    files = []
+    for ext in extensions:
+        # git ls-files pattern: *.ext
+        pattern = f"*{ext}"
+        git_files = get_git_tracked_files(pattern)
+        if git_files:
+            files.extend(git_files)
+
+    if files:
+        return files
+
+    # Fallback to rglob if git unavailable
+    result = []
+    for ext in extensions:
+        result.extend(Path.cwd().rglob(f"*{ext}"))
+    return [f for f in result if f.is_file()]