crackerjack 0.39.0__tar.gz → 0.39.2__tar.gz

{crackerjack-0.39.0 → crackerjack-0.39.2}/.gitignore

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

crackerjack-0.39.2/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.0 → crackerjack-0.39.2}/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.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
+
+- tests: Update 6 files
+
+## [Unreleased] - 2025-09-28
+
+### Added
+
+- feat: add new feature
+
+### Fixed
+
+- fix: resolve bug in parser
+
 ## [0.39.0] - 2025-09-28
 
 ### Added
@@ -25,11 +56,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
 
 ## [Unreleased] - 2025-09-28
 

crackerjack-0.39.2/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.0 → crackerjack-0.39.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crackerjack
-Version: 0.39.0
+Version: 0.39.2
 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.0 → crackerjack-0.39.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "crackerjack"
-version = "0.39.0"
+version = "0.39.2"
 description = "Crackerjack Python project management tool"
 readme = "README.md"
 authors = [
@@ -398,4 +398,6 @@ real_time_feedback = true
 [dependency-groups]
 dev = [
     "crackerjack",
+    "excalidraw-mcp>=0.34.0",
+    "session-mgmt-mcp>=0.4.0",
 ]

{crackerjack-0.39.0 → crackerjack-0.39.2}/tests/test_async_workflow_orchestrator.py

@@ -104,4 +104,4 @@ def test_run_configuration_phase_basic(self):
             "Function requires specific arguments - manual implementation needed"
         )
     except Exception as e:
-        pytest.fail(f"Unexpected error in run_configuration_phase: {e}")
+        pytest.fail(f"Unexpected error in run_configuration_phase: {e}")

crackerjack-0.39.2/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}")