crackerjack 0.39.1__tar.gz → 0.39.3__tar.gz

{crackerjack-0.39.1 → crackerjack-0.39.3}/.gitignore

@@ -137,3 +137,6 @@ crackerjack-debug-*.log
 dist/
 htmlcov/
 venv/
+/NOTES.md
+/.obsidian/
+/.smart-env/

crackerjack-0.39.3/AGENTS.md

@@ -0,0 +1,28 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+
+Crackerjack's core package lives under `crackerjack/`, where agents, the orchestrator, and CLI entrypoints are defined. Documentation and public guides sit in `docs/`, `README.md`, and `CLAUDE.md`, while reusable automation lives in `scripts/` and `tools/`. Tests mirror the package layout in `tests/` and leverage `test_docs_site/` for documentation fixtures. Use `examples/` and `example.mcp.json` when demonstrating integrations, and keep contributions aligned with the DRY/KISS/YAGNI philosophy.
+
+## Build, Test, and Development Commands
+
+- `uv sync --group dev` installs runtime, testing, and MCP dependencies.
+- `uv run pre-commit run --all-files` validates formatting, linting, and security hooks before you push.
+- `/crackerjack:run --debug` executes the full agent workflow locally; prefer this over raw `python -m` invocations.
+- `uv run python -m crackerjack --help` observes CLI entrypoints when adjusting commands or docs.
+
+## Coding Style & Naming Conventions
+
+Target Python 3.13 with 4-space indentation, full type annotations, and descriptive but concise identifiers. `ruff` owns style, import order, and formatting (`uv run ruff check --fix` and `uv run ruff format`), holding line length to 88 and cognitive complexity to ≤15. Favor self-documenting code; reserve comments for intent or non-obvious trade-offs. Name test files `test_<feature>.py`, fixtures descriptively, and end agent classes with `*Agent` to match the architecture.
+
+## Testing Guidelines
+
+Run `uv run pytest` for the default suite and add `--maxfail=1` while iterating. Follow up with `/crackerjack:run` to ensure the multi-agent iteration protocol still converges. Maintain ≥42% coverage; audit `coverage.json` or `htmlcov/` when adding modules and expand tests if thresholds slip. Leverage existing markers (`chaos`, `ai_generated`, `breakthrough`) to isolate heavyweight scenarios, and keep shared fixtures in `tests/conftest.py`.
+
+## Commit & Pull Request Guidelines
+
+Adopt the `type(scope): summary` convention from history—examples include `fix(agents): guard iteration retry` or `test(tests): update scenarios`. Keep commits tightly scoped, reference tickets or MCP jobs when relevant, and note any agent or workflow impacts. Pull requests need a concise motivation, implementation notes, and validation proof (commands run, test outcomes, screenshots for docs/UI tweaks). Link issues and flag required follow-up work.
+
+## Agent-Aware Workflow
+
+Favor MCP tooling in day-to-day work: start quality sweeps with `/crackerjack:run`, monitor progress via `get_job_progress`, and sanity-check the environment with `/crackerjack:status`. Document new agents or capabilities here, update `.mcp.json` when wiring servers, and ensure structured outputs (`test-results.xml`, `coverage.json`) stay current after changes.

{crackerjack-0.39.1 → crackerjack-0.39.3}/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.39.3] - 2025-10-01
+
+### Testing
+
+- tests: Update 7 files
+
+## [Unreleased] - 2025-10-01
+
+### Added
+- feat: add new feature
+
+### Fixed
+- fix: resolve bug in parser
+
+
+## [0.39.2] - 2025-10-01
+
+### Testing
+
+- tests: Update 5 files
+
+## [Unreleased] - 2025-10-01
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
 ## [0.39.1] - 2025-09-28
 
 ### Testing
@@ -14,11 +45,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased] - 2025-09-28
 
 ### Added
+
 - feat: add new feature
 
 ### Fixed
-- fix: resolve bug in parser
 
+- fix: resolve bug in parser
 
 ## [0.39.0] - 2025-09-28
 

crackerjack-0.39.3/GEMINI.md

@@ -0,0 +1,83 @@
+# Crackerjack: AI-Powered Python Development Platform
+
+## Project Overview
+
+Crackerjack is a sophisticated, AI-driven platform designed to enhance Python development by enforcing high code quality standards through intelligent automation. It streamlines the development process by integrating a comprehensive suite of tools for linting, formatting, testing, and security analysis into a single, powerful command-line interface.
+
+The core philosophy of Crackerjack is to proactively prevent issues rather than reactively fixing them. It employs a multi-agent AI system to automatically identify and resolve code quality problems, including type errors, security vulnerabilities, performance bottlenecks, and style inconsistencies. This allows developers to focus on writing high-quality code, confident that Crackerjack will handle the rest.
+
+**Key Technologies:**
+
+- **Python 3.13+:** The project is built on the latest version of Python, leveraging modern language features.
+- **`uv`:** Used for high-performance package management and virtual environment creation.
+- **`typer`:** Powers the command-line interface, providing a user-friendly experience with a rich set of options.
+- **`ruff`:** A fast Python linter and code formatter that ensures consistent code style.
+- **`pytest`:** The testing framework used to run the project's extensive test suite.
+- **`pyright` and `zuban`:** Used for static type checking, with the custom Rust-based `zuban` providing significant performance improvements.
+- **`bandit`:** A tool for finding common security issues in Python code.
+- **AI Agents:** A team of specialized AI agents, coordinated by an `EnhancedAgentCoordinator`, that can automatically fix a wide range of code quality issues.
+- **MCP (Model Context Protocol):** A WebSocket-based protocol that allows AI agents to interact with the Crackerjack CLI.
+
+**Architecture:**
+
+The project follows a modular architecture, with a clear separation of concerns between the CLI, core workflow orchestration, and various services.
+
+- **`crackerjack/__main__.py`:** The main entry point for the CLI, which uses `typer` to define the available commands and options.
+- **`crackerjack/cli/handlers.py`:** Contains the logic for handling the different CLI commands, delegating the actual work to the appropriate services and managers.
+- **`crackerjack/core/workflow_orchestrator.py`:** The heart of the application, which defines the `WorkflowOrchestrator` and `WorkflowPipeline` classes that manage the execution of the code quality workflow.
+- **`crackerjack/services/`:** A collection of services that provide specific functionality, such as Git integration, documentation generation, and AI-powered code analysis.
+- **`crackerjack/agents/`:** Contains the implementation of the specialized AI agents that are responsible for fixing code quality issues.
+- **`crackerjack/mcp/`:** Implements the Model Context Protocol server, which enables communication between the Crackerjack CLI and external AI agents.
+
+## Building and Running
+
+**Installation:**
+
+1. Install `uv` (if not already installed):
+   ```bash
+   pipx install uv
+   ```
+1. Install Crackerjack and its dependencies:
+   ```bash
+   uv sync --all-groups
+   ```
+
+**Running the Main Workflow:**
+
+The primary way to use Crackerjack is through its command-line interface. The main command is `python -m crackerjack`.
+
+- **Run all quality checks:**
+  ```bash
+  python -m crackerjack
+  ```
+- **Run quality checks and tests:**
+  ```bash
+  python -m crackerjack --run-tests
+  ```
+- **Enable AI-powered auto-fixing:**
+  ```bash
+  python -m crackerjack --ai-fix
+  ```
+- **Run the full release workflow (including version bumping and publishing):**
+  ```bash
+  python -m crackerjack --all patch
+  ```
+
+**Starting the MCP Server:**
+
+To enable AI agent integration, you can start the MCP server:
+
+```bash
+python -m crackerjack --start-mcp-server
+```
+
+This will start a WebSocket server on `localhost:8675`, allowing AI agents to connect and interact with the Crackerjack CLI.
+
+## Development Conventions
+
+- **Code Style:** The project uses `ruff` to enforce a consistent code style. All code should be formatted according to the rules defined in `pyproject.toml`.
+- **Testing:** The project has an extensive test suite that is run using `pytest`. The "coverage ratchet" system ensures that test coverage can only increase over time, with a goal of 100% coverage.
+- **Type Hinting:** The project uses modern Python type hints (e.g., `|` for unions) and enforces strict type checking with `pyright` and `zuban`.
+- **Self-Documenting Code:** The project favors self-documenting code over extensive docstrings.
+- **Commit Messages:** The project uses a standardized format for commit messages, which are automatically generated based on the changes made.
+- **Pre-commit Hooks:** The project uses a comprehensive set of pre-commit hooks to ensure that all code is formatted, linted, and tested before it is committed.

{crackerjack-0.39.1 → crackerjack-0.39.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.39.1
+Version: 0.39.3
 Summary: Crackerjack Python project management tool
 Project-URL: documentation, https://github.com/lesleslie/crackerjack
 Project-URL: homepage, https://github.com/lesleslie/crackerjack

{crackerjack-0.39.1 → crackerjack-0.39.3}/crackerjack/hooks/lsp_hook.py

@@ -10,9 +10,10 @@ type checking during pre-commit hooks.
 import sys
 from pathlib import Path
 
-from crackerjack.services.lsp_client import LSPClient
 from rich.console import Console
 
+from crackerjack.services.lsp_client import LSPClient
+
 
 def main() -> int:
     """Main entry point for LSP hook."""

{crackerjack-0.39.1 → crackerjack-0.39.3}/crackerjack/mcp/client_runner.py

@@ -4,9 +4,8 @@ import subprocess
 import sys
 from pathlib import Path
 
-from rich.console import Console
-
 from mcp import stdio_client
+from rich.console import Console
 
 from .progress_monitor import (
     run_crackerjack_with_enhanced_progress as run_crackerjack_with_progress,

{crackerjack-0.39.1 → crackerjack-0.39.3}/crackerjack/models/semantic_models.py

@@ -4,7 +4,7 @@ import typing as t
 from datetime import datetime
 from pathlib import Path
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
 
 class EmbeddingVector(BaseModel):
@@ -26,13 +26,17 @@ class EmbeddingVector(BaseModel):
     end_line: int = Field(..., description="Ending line number in the source file")
     file_type: str = Field(..., description="File extension or type identifier")
 
-    class Config:
-        """Pydantic configuration."""
+    model_config = ConfigDict(ser_json_timedelta="iso8601")
 
-        json_encoders = {
-            Path: str,
-            datetime: lambda v: v.isoformat(),
-        }
+    @field_serializer("file_path")
+    def serialize_path(self, value: Path) -> str:
+        """Serialize Path to string."""
+        return str(value)
+
+    @field_serializer("created_at")
+    def serialize_datetime(self, value: datetime) -> str:
+        """Serialize datetime to ISO format."""
+        return value.isoformat()
 
 
 class SearchResult(BaseModel):
@@ -51,12 +55,10 @@ class SearchResult(BaseModel):
         default_factory=list, description="Surrounding context lines"
     )
 
-    class Config:
-        """Pydantic configuration."""
-
-        json_encoders = {
-            Path: str,
-        }
+    @field_serializer("file_path")
+    def serialize_path(self, value: Path) -> str:
+        """Serialize Path to string."""
+        return str(value)
 
 
 class IndexStats(BaseModel):
@@ -72,12 +74,10 @@ class IndexStats(BaseModel):
     embedding_model: str = Field(..., description="Name of the embedding model used")
     avg_chunk_size: float = Field(..., description="Average chunk size in characters")
 
-    class Config:
-        """Pydantic configuration."""
-
-        json_encoders = {
-            datetime: lambda v: v.isoformat(),
-        }
+    @field_serializer("last_updated")
+    def serialize_datetime(self, value: datetime) -> str:
+        """Serialize datetime to ISO format."""
+        return value.isoformat()
 
 
 class SearchQuery(BaseModel):
@@ -100,10 +100,7 @@ class SearchQuery(BaseModel):
         default=3, ge=0, le=10, description="Number of context lines"
     )
 
-    class Config:
-        """Pydantic configuration."""
-
-        validate_assignment = True
+    model_config = ConfigDict(validate_assignment=True)
 
 
 class IndexingProgress(BaseModel):
@@ -125,12 +122,10 @@ class IndexingProgress(BaseModel):
             return 0.0
         return min(100.0, (self.files_processed / self.total_files) * 100.0)
 
-    class Config:
-        """Pydantic configuration."""
-
-        json_encoders = {
-            Path: str,
-        }
+    @field_serializer("current_file")
+    def serialize_path(self, value: Path) -> str:
+        """Serialize Path to string."""
+        return str(value)
 
 
 class SemanticConfig(BaseModel):
@@ -195,10 +190,7 @@ class SemanticConfig(BaseModel):
         default=24, ge=1, le=168, description="Cache time-to-live in hours"
     )
 
-    class Config:
-        """Pydantic configuration."""
-
-        validate_assignment = True
+    model_config = ConfigDict(validate_assignment=True)
 
 
 class FileChangeEvent(BaseModel):
@@ -215,13 +207,15 @@ class FileChangeEvent(BaseModel):
         default=None, description="New file hash if available"
     )
 
-    class Config:
-        """Pydantic configuration."""
+    @field_serializer("file_path")
+    def serialize_path(self, value: Path) -> str:
+        """Serialize Path to string."""
+        return str(value)
 
-        json_encoders = {
-            Path: str,
-            datetime: lambda v: v.isoformat(),
-        }
+    @field_serializer("timestamp")
+    def serialize_datetime(self, value: datetime) -> str:
+        """Serialize datetime to ISO format."""
+        return value.isoformat()
 
 
 class SemanticContext(BaseModel):
@@ -241,13 +235,6 @@ class SemanticContext(BaseModel):
         ..., ge=0.0, le=1.0, description="Confidence in the context relevance"
     )
 
-    class Config:
-        """Pydantic configuration."""
-
-        json_encoders = {
-            Path: str,
-        }
-
 
 # Type aliases for better code readability
 EmbeddingMatrix = list[list[float]]

{crackerjack-0.39.1 → crackerjack-0.39.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "crackerjack"
-version = "0.39.1"
+version = "0.39.3"
 description = "Crackerjack Python project management tool"
 readme = "README.md"
 authors = [

crackerjack-0.39.3/tests/test_performance_monitor.py

@@ -0,0 +1,203 @@
+def test_get_performance_monitor_basic(self):
+    """Test basic functionality of get_performance_monitor."""
+    try:
+        result = get_performance_monitor()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_performance_monitor: {e}")
+
+def test_reset_performance_monitor_basic(self):
+    """Test basic functionality of reset_performance_monitor."""
+    try:
+        result = reset_performance_monitor()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in reset_performance_monitor: {e}")
+
+def test_success_rate_basic(self):
+    """Test basic functionality of success_rate."""
+    try:
+        result = success_rate()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in success_rate: {e}")
+
+def test_average_time_basic(self):
+    """Test basic functionality of average_time."""
+    try:
+        result = average_time()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in average_time: {e}")
+
+def test_recent_average_time_basic(self):
+    """Test basic functionality of recent_average_time."""
+    try:
+        result = recent_average_time()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in recent_average_time: {e}")
+
+def test_record_operation_start_basic(self):
+    """Test basic functionality of record_operation_start."""
+    try:
+        result = record_operation_start()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in record_operation_start: {e}")
+
+def test_record_operation_success_basic(self):
+    """Test basic functionality of record_operation_success."""
+    try:
+        result = record_operation_success()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in record_operation_success: {e}")
+
+def test_record_operation_failure_basic(self):
+    """Test basic functionality of record_operation_failure."""
+    try:
+        result = record_operation_failure()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in record_operation_failure: {e}")
+
+def test_record_operation_timeout_basic(self):
+    """Test basic functionality of record_operation_timeout."""
+    try:
+        result = record_operation_timeout()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in record_operation_timeout: {e}")
+
+def test_record_circuit_breaker_event_basic(self):
+    """Test basic functionality of record_circuit_breaker_event."""
+    try:
+        result = record_circuit_breaker_event()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in record_circuit_breaker_event: {e}")
+
+def test_get_operation_metrics_basic(self):
+    """Test basic functionality of get_operation_metrics."""
+    try:
+        result = get_operation_metrics()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_operation_metrics: {e}")
+
+def test_get_all_metrics_basic(self):
+    """Test basic functionality of get_all_metrics."""
+    try:
+        result = get_all_metrics()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_all_metrics: {e}")
+
+def test_get_recent_timeout_events_basic(self):
+    """Test basic functionality of get_recent_timeout_events."""
+    try:
+        result = get_recent_timeout_events()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_recent_timeout_events: {e}")
+
+def test_get_performance_alerts_basic(self):
+    """Test basic functionality of get_performance_alerts."""
+    try:
+        result = get_performance_alerts()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_performance_alerts: {e}")
+
+def test_get_summary_stats_basic(self):
+    """Test basic functionality of get_summary_stats."""
+    try:
+        result = get_summary_stats()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in get_summary_stats: {e}")
+
+def test_export_metrics_json_basic(self):
+    """Test basic functionality of export_metrics_json."""
+    try:
+        result = export_metrics_json()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in export_metrics_json: {e}")
+
+def test_print_performance_report_basic(self):
+    """Test basic functionality of print_performance_report."""
+    try:
+        result = print_performance_report()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in print_performance_report: {e}")

crackerjack-0.39.3/tests/test_resource_manager.py

@@ -0,0 +1,59 @@
+def test_register_global_resource_manager_basic(self):
+    """Test basic functionality of register_global_resource_manager."""
+    try:
+        result = register_global_resource_manager()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in register_global_resource_manager: {e}")
+
+def test_cleanup_all_global_resources_basic(self):
+    """Test basic functionality of cleanup_all_global_resources."""
+    try:
+        result = cleanup_all_global_resources()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in cleanup_all_global_resources: {e}")
+
+def test_with_resource_cleanup_basic(self):
+    """Test basic functionality of with_resource_cleanup."""
+    try:
+        result = with_resource_cleanup()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in with_resource_cleanup: {e}")
+
+def test_with_temp_file_basic(self):
+    """Test basic functionality of with_temp_file."""
+    try:
+        result = with_temp_file()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in with_temp_file: {e}")
+
+def test_with_temp_dir_basic(self):
+    """Test basic functionality of with_temp_dir."""
+    try:
+        result = with_temp_dir()
+        assert result is not None or result is None
+    except TypeError:
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
+    except Exception as e:
+        pytest.fail(f"Unexpected error in with_temp_dir: {e}")