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

crackerjack/cli/handlers/changelog.py

@@ -0,0 +1,271 @@
+"""CLI handlers for changelog generation and version analysis.
+
+This module contains handlers for:
+- Changelog generation from git commits
+- Changelog dry-run previews
+- Automated version analysis and recommendations
+- Debug/verbose flag setup
+"""
+
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+if t.TYPE_CHECKING:
+    from crackerjack.services.changelog_automation import ChangelogGenerator
+    from crackerjack.services.git import GitService
+
+
+def setup_changelog_services() -> dict[str, t.Any]:
+    """Set up changelog generation services (git, generator, path)."""
+    from crackerjack.services.changelog_automation import ChangelogGenerator
+    from crackerjack.services.git import GitService
+
+    pkg_path = Path()
+    git_service = GitService()
+    changelog_generator = ChangelogGenerator()
+
+    return {
+        "pkg_path": pkg_path,
+        "git_service": git_service,
+        "generator": changelog_generator,
+    }
+
+
+@depends.inject  # type: ignore[misc]
+def handle_changelog_dry_run(
+    generator: "ChangelogGenerator",
+    changelog_since: str | None,
+    options: t.Any,
+    console: Inject[Console],
+) -> bool:
+    """Handle changelog dry-run (preview without writing)."""
+    console.print("🔍 [bold blue]Previewing changelog generation...[/bold blue]")
+    entries = generator.generate_changelog_entries(changelog_since)
+    if entries:
+        generator._display_changelog_preview(entries)
+        console.print("✅ [bold green]Changelog preview completed![/bold green]")
+    else:
+        console.print("⚠️ No new changelog entries to generate")
+
+    return should_continue_after_changelog(options)
+
+
+@depends.inject  # type: ignore[misc]
+def handle_changelog_generation(
+    services: dict[str, t.Any],
+    changelog_path: Path,
+    changelog_version: str | None,
+    changelog_since: str | None,
+    options: t.Any,
+    console: Inject[Console],
+) -> bool:
+    """Handle changelog generation and write to file."""
+    console.print("📝 [bold blue]Generating changelog...[/bold blue]")
+
+    version = determine_changelog_version(
+        services["git_service"], changelog_version, changelog_since, options
+    )
+
+    success = services["generator"].generate_changelog_from_commits(
+        changelog_path=changelog_path,
+        version=version,
+        since_version=changelog_since,
+    )
+
+    if success:
+        console.print(
+            f"✅ [bold green]Changelog updated for version {version}![/bold green]"
+        )
+        return should_continue_after_changelog(options)
+    console.print("❌ [bold red]Changelog generation failed![/bold red]")
+    return False
+
+
+@depends.inject  # type: ignore[misc]
+def determine_changelog_version(
+    git_service: "GitService",
+    changelog_version: str | None,
+    changelog_since: str | None,
+    options: t.Any,
+    console: Inject[Console],
+) -> str:
+    """Determine changelog version (auto-detect via AI or use provided version)."""
+    if getattr(options, "auto_version", False) and not changelog_version:
+        try:
+            import asyncio
+
+            from crackerjack.services.version_analyzer import VersionAnalyzer
+
+            version_analyzer = VersionAnalyzer(git_service)
+            console.print(
+                "[cyan]🔍[/cyan] Analyzing version changes for intelligent changelog..."
+            )
+
+            recommendation = asyncio.run(
+                version_analyzer.recommend_version_bump(changelog_since)
+            )
+            version = recommendation.recommended_version
+            console.print(f"[green]✨[/green] Using AI-recommended version: {version}")
+            return version
+        except Exception as e:
+            console.print(f"[yellow]⚠️[/yellow] Version analysis failed: {e}")
+            return changelog_version or "Unreleased"
+
+    return changelog_version or "Unreleased"
+
+
+def should_continue_after_changelog(options: t.Any) -> bool:
+    """Check if workflow should continue after changelog commands."""
+    return any(
+        [
+            options.run_tests,
+            options.strip_code,
+            options.all,
+            options.publish,
+            options.comp,
+        ]
+    )
+
+
+def handle_changelog_commands(
+    generate_changelog: bool,
+    changelog_dry_run: bool,
+    changelog_version: str | None,
+    changelog_since: str | None,
+    options: t.Any,
+) -> bool:
+    """Handle all changelog-related commands (generation, dry-run, versioning).
+
+    Args:
+        generate_changelog: Whether to generate changelog
+        changelog_dry_run: Whether to preview changelog without writing
+        changelog_version: Explicit version to use (or None for auto/unreleased)
+        changelog_since: Git reference to generate changelog since
+        options: CLI options object
+
+    Returns:
+        True if execution should continue to other workflows
+    """
+    if not (generate_changelog or changelog_dry_run):
+        return True
+
+    services = setup_changelog_services()
+    changelog_path = services["pkg_path"] / "CHANGELOG.md"
+
+    if changelog_dry_run:
+        return handle_changelog_dry_run(services["generator"], changelog_since, options)
+
+    if generate_changelog:
+        return handle_changelog_generation(
+            services, changelog_path, changelog_version, changelog_since, options
+        )
+
+    return should_continue_after_changelog(options)
+
+
+# === Version Analysis Handler ===
+
+
+@depends.inject  # type: ignore[misc]
+def handle_version_analysis(
+    auto_version: bool,
+    version_since: str | None,
+    accept_version: bool,
+    options: t.Any,
+    console: Inject[Console],
+) -> bool:
+    """Handle automated version analysis and recommendations.
+
+    Args:
+        auto_version: Whether to perform automated version analysis
+        version_since: Git reference to analyze changes since
+        accept_version: Whether to auto-accept the recommendation
+        options: CLI options object
+        console: Rich console for output
+
+    Returns:
+        True if execution should continue to other workflows
+    """
+    if not auto_version:
+        return True
+
+    from rich.prompt import Confirm
+
+    from crackerjack.services.git import GitService
+    from crackerjack.services.version_analyzer import VersionAnalyzer
+
+    Path()
+    git_service = GitService()
+    version_analyzer = VersionAnalyzer(git_service)
+
+    try:
+        import asyncio
+
+        recommendation = asyncio.run(
+            version_analyzer.recommend_version_bump(version_since)
+        )
+        version_analyzer.display_recommendation(recommendation)
+
+        if accept_version or Confirm.ask(
+            f"\nAccept recommendation ({recommendation.bump_type.value})",
+            default=True,
+        ):
+            console.print(
+                f"[green]✅ Version bump accepted: {recommendation.current_version} → {recommendation.recommended_version}[/green]"
+            )
+
+        else:
+            console.print("[yellow]❌ Version bump declined[/yellow]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Version analysis failed: {e}[/red]")
+
+    return any(
+        [
+            options.run_tests,
+            options.strip_code,
+            options.all,
+            options.publish,
+            options.comp,
+        ]
+    )
+
+
+# === Debug/Verbose Setup ===
+
+
+def setup_debug_and_verbose_flags(
+    ai_fix: bool, ai_debug: bool, debug: bool, verbose: bool, options: t.Any
+) -> tuple[bool, bool]:
+    """Set up debug and verbose flags for AI and general operations.
+
+    Args:
+        ai_fix: Whether AI fixing is enabled
+        ai_debug: Whether AI debug mode is enabled
+        debug: Whether general debug mode is enabled
+        verbose: Whether verbose output is enabled
+        options: CLI options object to update
+
+    Returns:
+        Tuple of (ai_fix, verbose) flags after processing
+    """
+    if ai_debug:
+        ai_fix = True
+        verbose = True
+        options.verbose = True
+        options.ai_debug = True  # Set ai_debug on options for downstream checks
+
+    if debug:
+        verbose = True
+        options.verbose = True
+
+    # Set up structured logging for AI-related operations if needed
+    if ai_fix or ai_debug:
+        from crackerjack.services.logging import setup_structured_logging
+
+        setup_structured_logging(level="DEBUG", json_output=True)
+
+    return ai_fix, verbose

crackerjack/cli/handlers/config_handlers.py

@@ -0,0 +1,16 @@
+"""Config-related handlers for the CLI."""
+
+# This is a placeholder - in a proper refactoring, these functions would be moved
+# from the original handlers.py file to the appropriate module
+
+
+def handle_config_updates(options, console=None):
+    """Handle configuration update commands."""
+    # This function would be implemented based on the original in handlers.py
+    # For now, we'll just raise an error to indicate this needs to be implemented
+    raise NotImplementedError(
+        "handle_config_updates needs to be properly implemented in the modular structure"
+    )
+
+
+__all__ = ["handle_config_updates"]

crackerjack/cli/handlers/coverage.py

@@ -0,0 +1,84 @@
+"""CLI handlers for test coverage reporting and status"""
+
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+
+@depends.inject  # type: ignore[misc]
+def display_coverage_info(
+    coverage_info: dict[str, t.Any], console: Inject[Console]
+) -> None:
+    coverage_percent = coverage_info.get("coverage_percent", 0.0)
+    coverage_source = coverage_info.get("source", "unknown")
+
+    if coverage_percent > 0:
+        console.print(
+            f"[green]Current Coverage:[/green] {coverage_percent:.2f}% (from {coverage_source})"
+        )
+    else:
+        console.print("[yellow]Current Coverage:[/yellow] No coverage data available")
+
+    status_message = coverage_info.get("message")
+    if status_message:
+        console.print(f"[dim]{status_message}[/dim]")
+
+
+@depends.inject  # type: ignore[misc]
+def display_coverage_report(test_manager: t.Any, console: Inject[Console]) -> None:
+    coverage_report = test_manager.get_coverage_report()
+    if coverage_report:
+        console.print(f"[cyan]Details:[/cyan] {coverage_report}")
+
+
+@depends.inject  # type: ignore[misc]
+def display_ratchet_status(test_manager: t.Any, console: Inject[Console]) -> None:
+    from contextlib import suppress
+
+    with suppress(Exception):
+        ratchet_status = test_manager.get_coverage_ratchet_status()
+        if ratchet_status:
+            next_milestone = ratchet_status.get("next_milestone")
+            if next_milestone:
+                console.print(f"[cyan]Next Milestone:[/cyan] {next_milestone:.0f}%")
+
+            milestones = ratchet_status.get("milestones_achieved", [])
+            if milestones:
+                console.print(f"[green]Milestones Achieved:[/green] {len(milestones)}")
+
+
+@depends.inject  # type: ignore[misc]
+def handle_coverage_status(
+    coverage_status: bool, options: t.Any, console: Inject[Console]
+) -> bool:
+    if not coverage_status:
+        return True
+
+    try:
+        from crackerjack.managers.test_manager import TestManager
+
+        pkg_path = Path.cwd()
+
+        test_manager = TestManager(pkg_path)
+
+        console.print("[cyan]📊[/cyan] Coverage Status Report")
+        console.print("=" * 50)
+
+        coverage_info = test_manager.get_coverage()
+        display_coverage_info(coverage_info)
+
+        display_coverage_report(test_manager)
+
+        display_ratchet_status(test_manager)
+
+        console.print()
+        return False
+
+    except Exception as e:
+        console.print(f"[red]❌[/red] Failed to get coverage status: {e}")
+        import traceback
+
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+        return False

crackerjack/cli/handlers/documentation.py

@@ -0,0 +1,280 @@
+"""CLI handlers for documentation generation and validation.
+
+This module contains handlers for:
+- API documentation generation
+- Documentation validation
+- MkDocs integration and site building
+"""
+
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import Inject, depends
+
+
+@depends.inject  # type: ignore[misc]
+def generate_documentation(doc_service: t.Any, console: Inject[Console]) -> bool:
+    """Generate API documentation using documentation service."""
+    console.print("📖 [bold blue]Generating API documentation...[/bold blue]")
+    success = doc_service.generate_full_api_documentation()
+    if success:
+        console.print(
+            "✅ [bold green]Documentation generated successfully![/bold green]"
+        )
+        return True
+    console.print("❌ [bold red]Documentation generation failed![/bold red]")
+    return False
+
+
+@depends.inject  # type: ignore[misc]
+def validate_documentation_files(doc_service: t.Any, console: Inject[Console]) -> None:
+    """Validate existing documentation files for consistency."""
+    console.print("🔍 [bold blue]Validating documentation...[/bold blue]")
+    doc_paths = [Path("docs"), Path("README.md"), Path("CHANGELOG.md")]
+    existing_docs = [p for p in doc_paths if p.exists()]
+
+    if existing_docs:
+        issues = doc_service.validate_documentation(existing_docs)
+        if issues:
+            console.print(f"⚠️ Found {len(issues)} documentation issues:")
+            for issue in issues:
+                file_path = issue.get("path", issue.get("file", "unknown"))
+                console.print(f" - {file_path}: {issue['message']}")
+        else:
+            console.print(
+                "✅ [bold green]Documentation validation passed![/bold green]"
+            )
+    else:
+        console.print("⚠️ No documentation files found to validate")
+
+
+def handle_documentation_commands(
+    generate_docs: bool, validate_docs: bool, options: t.Any
+) -> bool:
+    """Handle documentation generation and validation commands.
+
+    Args:
+        generate_docs: Whether to generate API documentation
+        validate_docs: Whether to validate existing documentation
+        options: CLI options object with run_tests, strip_code, all, publish, comp flags
+
+    Returns:
+        True if execution should continue to other workflows
+    """
+    if not (generate_docs or validate_docs):
+        return True
+
+    from crackerjack.services.documentation_service import DocumentationServiceImpl
+
+    # Use current working directory instead of hardcoded "crackerjack"
+    pkg_path = Path.cwd()
+    doc_service = DocumentationServiceImpl(pkg_path=pkg_path)
+
+    if generate_docs:
+        if not generate_documentation(doc_service):
+            return False
+
+    if validate_docs:
+        validate_documentation_files(doc_service)
+
+    return any(
+        [
+            options.run_tests,
+            options.strip_code,
+            options.all,
+            options.publish,
+            options.comp,
+        ]
+    )
+
+
+# === MkDocs Integration Handlers ===
+
+
+def create_sync_filesystem_service() -> t.Any:
+    """Create synchronous filesystem service for MkDocs integration."""
+
+    class SyncFileSystemService:
+        def read_file(self, path: str | Path) -> str:
+            return Path(path).read_text()
+
+        def write_file(self, path: str | Path, content: str) -> None:
+            Path(path).write_text(content)
+
+        def exists(self, path: str | Path) -> bool:
+            return Path(path).exists()
+
+        def mkdir(self, path: str | Path, parents: bool = False) -> None:
+            Path(path).mkdir(parents=parents, exist_ok=True)
+
+        def ensure_directory(self, path: str | Path) -> None:
+            Path(path).mkdir(parents=True, exist_ok=True)
+
+    return SyncFileSystemService()
+
+
+def create_config_manager() -> t.Any:
+    """Create configuration manager for MkDocs integration."""
+
+    class ConfigManager:
+        def __init__(self) -> None:
+            self._config: dict[str, t.Any] = {}
+
+        def get(self, key: str, default: t.Any = None) -> t.Any:
+            return self._config.get(key, default)
+
+        def set(self, key: str, value: t.Any) -> None:
+            self._config[key] = value
+
+        def save(self) -> bool:
+            return True
+
+        def load(self) -> bool:
+            return True
+
+    return ConfigManager()
+
+
+def create_logger_adapter(logger: t.Any) -> t.Any:
+    """Create logger adapter for MkDocs integration."""
+
+    class LoggerAdapter:
+        def __init__(self, logger: t.Any) -> None:
+            self._logger = logger
+
+        def debug(self, message: str, **kwargs: t.Any) -> None:
+            self._logger.debug(message)
+
+        def info(self, message: str, **kwargs: t.Any) -> None:
+            self._logger.info(message)
+
+        def warning(self, message: str, **kwargs: t.Any) -> None:
+            self._logger.warning(message)
+
+        def error(self, message: str, **kwargs: t.Any) -> None:
+            self._logger.error(message)
+
+    return LoggerAdapter(logger)
+
+
+def create_mkdocs_services() -> dict[str, t.Any]:
+    """Create MkDocs service instances (integration, builder, filesystem, config)."""
+    from logging import getLogger
+
+    from crackerjack.documentation.mkdocs_integration import (
+        MkDocsIntegrationService,
+        MkDocsSiteBuilder,
+    )
+
+    filesystem = create_sync_filesystem_service()
+    config_manager = create_config_manager()
+    logger = getLogger(__name__)
+    logger_adapter = create_logger_adapter(logger)
+
+    integration_service = MkDocsIntegrationService(
+        config_manager, filesystem, logger_adapter
+    )
+    builder = MkDocsSiteBuilder(integration_service)
+
+    return {"builder": builder, "filesystem": filesystem, "config": config_manager}
+
+
+def determine_mkdocs_output_dir(mkdocs_output: str | None) -> Path:
+    """Determine output directory for MkDocs site."""
+    return Path(mkdocs_output) if mkdocs_output else Path.cwd() / "docs_site"
+
+
+def create_sample_docs_content() -> dict[str, str]:
+    """Create sample documentation content for MkDocs site."""
+    return {
+        "index.md": "# Project Documentation\n\nWelcome to the project documentation.",
+        "getting-started.md": "# Getting Started\n\nQuick start guide for the project.",
+        "api-reference.md": "# API Reference\n\nAPI documentation and examples.",
+    }
+
+
+def build_mkdocs_site(
+    builder: t.Any, docs_content: dict[str, str], output_dir: Path, serve: bool
+) -> None:
+    """Build MkDocs documentation site asynchronously."""
+    import asyncio
+
+    asyncio.run(
+        builder.build_documentation_site(
+            project_name="Project Documentation",
+            project_description="Comprehensive project documentation",
+            author="Crackerjack",
+            documentation_content=docs_content,
+            output_dir=output_dir,
+            serve=serve,
+        )
+    )
+
+
+@depends.inject  # type: ignore[misc]
+def handle_mkdocs_build_result(
+    site: t.Any, mkdocs_serve: bool, console: Inject[Console] = None
+) -> None:
+    """Display MkDocs build results to console."""
+    if site:
+        console.print(
+            f"[green]✅[/green] MkDocs site generated successfully at: {site.build_path}"
+        )
+        console.print(
+            f"[blue]📄[/blue] Generated {len(site.pages)} documentation pages"
+        )
+
+        if mkdocs_serve:
+            console.print(
+                "[blue]🌐[/blue] MkDocs development server started at http://127.0.0.1:8000"
+            )
+            console.print("[yellow]Press Ctrl+C to stop the server[/yellow]")
+    else:
+        console.print("[red]❌[/red] Failed to generate MkDocs site")
+
+
+@depends.inject  # type: ignore[misc]
+def handle_mkdocs_integration(
+    mkdocs_integration: bool,
+    mkdocs_serve: bool,
+    mkdocs_theme: str,
+    mkdocs_output: str | None,
+    console: Inject[Console],
+) -> bool:
+    """Handle MkDocs integration command for documentation site generation.
+
+    Args:
+        mkdocs_integration: Whether MkDocs integration is requested
+        mkdocs_serve: Whether to serve the site locally
+        mkdocs_theme: Theme to use for MkDocs site
+        mkdocs_output: Output directory for site
+        console: Rich console for output
+
+    Returns:
+        True if execution should continue, False otherwise
+    """
+    if not mkdocs_integration:
+        return True
+
+    console.print("[cyan]📚[/cyan] Generating MkDocs documentation site...")
+
+    try:
+        services = create_mkdocs_services()
+        builder = services["builder"]
+        output_dir = determine_mkdocs_output_dir(mkdocs_output)
+        docs_content = create_sample_docs_content()
+
+        console.print(
+            f"[blue]🏗️[/blue] Building documentation site with {mkdocs_theme} theme..."
+        )
+
+        build_mkdocs_site(builder, docs_content, output_dir, mkdocs_serve)
+        site = None
+        handle_mkdocs_build_result(site, mkdocs_serve)
+
+        return False
+
+    except Exception as e:
+        console.print(f"[red]❌[/red] MkDocs integration error: {e}")
+        return False