solokit 0.1.1__py3-none-any.whl

solokit/quality/reporters/console.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Console reporter for quality gate results.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from solokit.quality.reporters.base import Reporter
+
+
+class ConsoleReporter(Reporter):
+    """Generates human-readable console reports."""
+
+    def generate(self, aggregated_results: dict[str, Any]) -> str:
+        """Generate a console-friendly report.
+
+        Args:
+            aggregated_results: Aggregated results from ResultAggregator
+
+        Returns:
+            Formatted console report
+        """
+        report = []
+        report.append("=" * 60)
+        report.append("QUALITY GATE RESULTS")
+        report.append("=" * 60)
+
+        # Overall summary
+        if aggregated_results["overall_passed"]:
+            report.append("\n✓ ALL CHECKS PASSED")
+        else:
+            report.append("\n✗ SOME CHECKS FAILED")
+
+        report.append(f"\nTotal Checks: {aggregated_results['total_checks']}")
+        report.append(f"Passed: {aggregated_results['passed_checks']}")
+        report.append(f"Failed: {aggregated_results['failed_checks']}")
+        report.append(f"Skipped: {aggregated_results['skipped_checks']}")
+        report.append(f"Execution Time: {aggregated_results['total_execution_time']:.2f}s")
+
+        # Individual checker results
+        report.append("\n" + "-" * 60)
+        report.append("INDIVIDUAL CHECKER RESULTS")
+        report.append("-" * 60)
+
+        for checker_name, result in aggregated_results["by_checker"].items():
+            status = result["status"]
+            if status == "passed":
+                status_symbol = "✓"
+            elif status == "skipped":
+                status_symbol = "⊘"
+            else:
+                status_symbol = "✗"
+
+            report.append(f"\n{status_symbol} {checker_name.upper()}: {status.upper()}")
+
+            # Add execution time
+            if result.get("execution_time", 0) > 0:
+                report.append(f"  Execution time: {result['execution_time']:.2f}s")
+
+            # Show errors
+            if result.get("errors"):
+                report.append("  Errors:")
+                for error in result["errors"][:5]:  # Limit to first 5
+                    if isinstance(error, dict):
+                        error_msg = error.get("message", str(error))
+                    else:
+                        error_msg = str(error)
+                    report.append(f"    - {error_msg}")
+                if len(result["errors"]) > 5:
+                    report.append(f"    ... and {len(result['errors']) - 5} more")
+
+            # Show warnings
+            if result.get("warnings"):
+                report.append("  Warnings:")
+                for warning in result["warnings"][:3]:  # Limit to first 3
+                    if isinstance(warning, dict):
+                        warning_msg = warning.get("message", str(warning))
+                    else:
+                        warning_msg = str(warning)
+                    report.append(f"    - {warning_msg}")
+                if len(result["warnings"]) > 3:
+                    report.append(f"    ... and {len(result['warnings']) - 3} more")
+
+            # Show key info
+            if result.get("info"):
+                info = result["info"]
+                # Show coverage if present
+                if "coverage" in info:
+                    report.append(f"  Coverage: {info['coverage']}%")
+                # Show reason for skipped
+                if "reason" in info and status == "skipped":
+                    report.append(f"  Reason: {info['reason']}")
+
+        report.append("\n" + "=" * 60)
+
+        return "\n".join(report)

solokit/quality/reporters/json_reporter.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+JSON reporter for quality gate results.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from solokit.quality.reporters.base import Reporter
+
+
+class JSONReporter(Reporter):
+    """Generates JSON-formatted reports."""
+
+    def __init__(self, indent: int = 2):
+        """Initialize the JSON reporter.
+
+        Args:
+            indent: Number of spaces for JSON indentation (default: 2)
+        """
+        self.indent = indent
+
+    def generate(self, aggregated_results: dict[str, Any]) -> str:
+        """Generate a JSON report.
+
+        Args:
+            aggregated_results: Aggregated results from ResultAggregator
+
+        Returns:
+            JSON-formatted report string
+        """
+        return json.dumps(aggregated_results, indent=self.indent)

solokit/quality/results.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+Result aggregation for quality gates.
+
+Combines results from multiple checkers into a comprehensive report.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from solokit.quality.checkers.base import CheckResult
+
+
+class ResultAggregator:
+    """Aggregates results from multiple quality checkers."""
+
+    def aggregate(self, results: list[CheckResult]) -> dict[str, Any]:
+        """Aggregate multiple check results into a summary.
+
+        Args:
+            results: List of CheckResult objects from various checkers
+
+        Returns:
+            Dictionary containing aggregated results with:
+                - overall_passed: Whether all checks passed
+                - total_checks: Number of checks run
+                - passed_checks: Number of checks that passed
+                - failed_checks: Number of checks that failed
+                - skipped_checks: Number of checks that were skipped
+                - by_checker: Results organized by checker name
+                - failed_checkers: List of checker names that failed
+        """
+        aggregated: dict[str, Any] = {
+            "overall_passed": True,
+            "total_checks": len(results),
+            "passed_checks": 0,
+            "failed_checks": 0,
+            "skipped_checks": 0,
+            "by_checker": {},
+            "failed_checkers": [],
+            "total_execution_time": 0.0,
+        }
+
+        for result in results:
+            # Add to by_checker mapping
+            aggregated["by_checker"][result.checker_name] = {
+                "passed": result.passed,
+                "status": result.status,
+                "errors": result.errors,
+                "warnings": result.warnings,
+                "info": result.info,
+                "execution_time": result.execution_time,
+            }
+
+            # Update counters
+            if result.status == "skipped":
+                aggregated["skipped_checks"] += 1
+            elif result.passed:
+                aggregated["passed_checks"] += 1
+            else:
+                aggregated["failed_checks"] += 1
+                aggregated["overall_passed"] = False
+                aggregated["failed_checkers"].append(result.checker_name)
+
+            # Add execution time
+            aggregated["total_execution_time"] += result.execution_time
+
+        return aggregated
+
+    def get_summary_text(self, aggregated: dict[str, Any]) -> str:
+        """Generate a text summary of aggregated results.
+
+        Args:
+            aggregated: Aggregated results dictionary
+
+        Returns:
+            Human-readable summary string
+        """
+        total = aggregated["total_checks"]
+        passed = aggregated["passed_checks"]
+        failed = aggregated["failed_checks"]
+        skipped = aggregated["skipped_checks"]
+        exec_time = aggregated["total_execution_time"]
+
+        summary = []
+        summary.append(f"Total Checks: {total}")
+        summary.append(f"Passed: {passed}")
+        summary.append(f"Failed: {failed}")
+        summary.append(f"Skipped: {skipped}")
+        summary.append(f"Execution Time: {exec_time:.2f}s")
+
+        if aggregated["overall_passed"]:
+            summary.append("\n✓ All quality checks passed")
+        else:
+            summary.append(f"\n✗ Quality checks failed: {', '.join(aggregated['failed_checkers'])}")
+
+        return "\n".join(summary)

solokit/session/__init__.py

@@ -0,0 +1 @@
+"""Session management for Solokit workflow."""

solokit/session/briefing/__init__.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""
+Session briefing package.
+
+This package provides modular components for generating comprehensive session briefings.
+The package is organized into focused, single-responsibility modules.
+
+Public API exports maintain backward compatibility with the original briefing.py module.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from solokit.core.logging_config import get_logger
+
+from .documentation_loader import DocumentationLoader
+from .formatter import BriefingFormatter
+from .git_context import GitContext
+from .learning_loader import LearningLoader
+from .milestone_builder import MilestoneBuilder
+from .orchestrator import SessionBriefing
+from .stack_detector import StackDetector
+from .tree_generator import TreeGenerator
+from .work_item_loader import WorkItemLoader
+
+# Package-level logger for backward compatibility
+logger = get_logger(__name__)
+
+# Get the parent module (solokit.session)
+_parent_module_path = Path(__file__).parent.parent
+if str(_parent_module_path) not in sys.path:
+    sys.path.insert(0, str(_parent_module_path))
+
+
+# Import main from the briefing.py module (not package)
+# This is a bit tricky since briefing is now a package, but main() is in briefing.py
+# We need to import the actual module file, not the package
+def main() -> int:
+    """Main entry point - delegates to briefing.py main()."""
+    # Import the briefing module file (not the package) using importlib
+    import importlib.util
+    import sys
+    from pathlib import Path
+
+    # Get the path to briefing.py (the module file, not the package)
+    module_path = Path(__file__).parent.parent / "briefing.py"
+
+    # Load the module directly from the file
+    spec = importlib.util.spec_from_file_location("solokit.session._briefing_module", module_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load briefing module from {module_path}")
+    briefing_module = importlib.util.module_from_spec(spec)
+    sys.modules["solokit.session._briefing_module"] = briefing_module
+    spec.loader.exec_module(briefing_module)
+
+    # Call the main function from the loaded module
+    return briefing_module.main()  # type: ignore[no-any-return]
+
+
+# Export commonly used functions for backward compatibility
+# These maintain the original module-level function API
+
+__all__ = [
+    # Classes
+    "SessionBriefing",
+    "WorkItemLoader",
+    "LearningLoader",
+    "DocumentationLoader",
+    "StackDetector",
+    "TreeGenerator",
+    "GitContext",
+    "MilestoneBuilder",
+    "BriefingFormatter",
+    # Functions (for backward compatibility with old code that imports functions)
+    "load_work_items",
+    "load_learnings",
+    "get_next_work_item",
+    "get_relevant_learnings",
+    "load_milestone_context",
+    "load_project_docs",
+    "load_current_stack",
+    "load_current_tree",
+    "load_work_item_spec",
+    "shift_heading_levels",
+    "extract_section",
+    "generate_previous_work_section",
+    "extract_keywords",
+    "calculate_days_ago",
+    "validate_environment",
+    "check_git_status",
+    "generate_briefing",
+    "check_command_exists",
+    "generate_integration_test_briefing",
+    "generate_deployment_briefing",
+    "determine_git_branch_final_status",
+    "finalize_previous_work_item_git_status",
+    "main",  # Add main to exports
+]
+
+
+# Backward compatibility: Module-level function wrappers
+
+
+def load_work_items() -> dict[str, Any]:
+    """Load work items from tracking file (backward compatibility wrapper)."""
+    from pathlib import Path
+
+    work_items_file = Path(".session/tracking/work_items.json")
+    logger.debug("Loading work items from: %s", work_items_file)
+
+    loader = WorkItemLoader()
+    return loader.load_work_items()
+
+
+def load_learnings() -> dict[str, Any]:
+    """Load learnings from tracking file (backward compatibility wrapper)."""
+    loader = LearningLoader()
+    return loader.load_learnings()
+
+
+def get_next_work_item(work_items_data: dict) -> tuple[str | None, dict | None]:
+    """Find next available work item (backward compatibility wrapper)."""
+    loader = WorkItemLoader()
+    return loader.get_next_work_item(work_items_data)
+
+
+def get_relevant_learnings(
+    learnings_data: dict, work_item: dict, spec_content: str = ""
+) -> list[dict]:
+    """Get relevant learnings (backward compatibility wrapper)."""
+    loader = LearningLoader()
+    return loader.get_relevant_learnings(learnings_data, work_item, spec_content)
+
+
+def load_milestone_context(work_item: dict) -> dict | None:
+    """Load milestone context (backward compatibility wrapper)."""
+    builder = MilestoneBuilder()
+    return builder.load_milestone_context(work_item)
+
+
+def load_project_docs() -> dict[str, str]:
+    """Load project documentation (backward compatibility wrapper)."""
+    loader = DocumentationLoader()
+    return loader.load_project_docs()
+
+
+def load_current_stack() -> str:
+    """Load current technology stack (backward compatibility wrapper)."""
+    detector = StackDetector()
+    return detector.load_current_stack()
+
+
+def load_current_tree() -> str:
+    """Load current project structure (backward compatibility wrapper)."""
+    generator = TreeGenerator()
+    return generator.load_current_tree()
+
+
+def load_work_item_spec(work_item: str | dict[str, Any]) -> str:
+    """Load work item specification file (backward compatibility wrapper)."""
+    loader = WorkItemLoader()
+    return loader.load_work_item_spec(work_item)
+
+
+def shift_heading_levels(markdown_content: str, shift: int) -> str:
+    """Shift markdown heading levels (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.shift_heading_levels(markdown_content, shift)
+
+
+def extract_section(markdown: str, heading: str) -> str:
+    """Extract section from markdown (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.extract_section(markdown, heading)
+
+
+def generate_previous_work_section(item_id: str, item: dict) -> str:
+    """Generate previous work context (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.generate_previous_work_section(item_id, item)
+
+
+def extract_keywords(text: str) -> set[str]:
+    """Extract meaningful keywords from text (backward compatibility wrapper)."""
+    loader = LearningLoader()
+    return loader._extract_keywords(text)
+
+
+def calculate_days_ago(timestamp: str) -> int:
+    """Calculate days since timestamp (backward compatibility wrapper)."""
+    loader = LearningLoader()
+    return loader._calculate_days_ago(timestamp)
+
+
+def validate_environment() -> list[str]:
+    """Validate development environment (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.validate_environment()
+
+
+def check_git_status() -> dict[str, Any]:
+    """Check git status for session start (backward compatibility wrapper)."""
+    context = GitContext()
+    return context.check_git_status()
+
+
+def generate_briefing(item_id: str, item: dict, learnings_data: dict) -> str:
+    """Generate comprehensive markdown briefing (backward compatibility wrapper)."""
+    briefing = SessionBriefing()
+    return briefing.generate_briefing(item_id, item, learnings_data)
+
+
+def check_command_exists(command: str) -> bool:
+    """Check if a command is available (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.check_command_exists(command)
+
+
+def generate_integration_test_briefing(work_item: dict) -> str:
+    """Generate integration test briefing (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.generate_integration_test_briefing(work_item)
+
+
+def generate_deployment_briefing(work_item: dict) -> str:
+    """Generate deployment briefing (backward compatibility wrapper)."""
+    formatter = BriefingFormatter()
+    return formatter.generate_deployment_briefing(work_item)
+
+
+def determine_git_branch_final_status(branch_name: str, git_info: dict) -> str:
+    """Determine final git branch status (backward compatibility wrapper)."""
+    context = GitContext()
+    return context.determine_git_branch_final_status(branch_name, git_info)
+
+
+def finalize_previous_work_item_git_status(
+    work_items_data: dict, current_work_item_id: str
+) -> str | None:
+    """Finalize git status for previous work item (backward compatibility wrapper)."""
+    context = GitContext()
+    return context.finalize_previous_work_item_git_status(work_items_data, current_work_item_id)

solokit/session/briefing/documentation_loader.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Documentation discovery and loading.
+Part of the briefing module decomposition.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from solokit.core.exceptions import FileOperationError
+from solokit.core.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class DocumentationLoader:
+    """Load project documentation for context."""
+
+    def __init__(self, project_root: Path | None = None):
+        """Initialize documentation loader.
+
+        Args:
+            project_root: Path to project root (defaults to current directory)
+        """
+        self.project_root = project_root or Path.cwd()
+
+    def load_project_docs(self) -> dict[str, str]:
+        """Load project documentation for context.
+
+        Returns:
+            Dictionary mapping doc filename to content
+        """
+        docs = {}
+
+        # Look for common doc files
+        doc_files = ["docs/vision.md", "docs/prd.md", "docs/architecture.md", "README.md"]
+
+        for doc_file in doc_files:
+            path = self.project_root / doc_file
+            if path.exists():
+                try:
+                    docs[path.name] = path.read_text()
+                    logger.debug("Loaded documentation: %s", doc_file)
+                except (OSError, UnicodeDecodeError) as e:
+                    raise FileOperationError(
+                        operation="read",
+                        file_path=str(path),
+                        details=f"Failed to read documentation file: {e}",
+                        cause=e,
+                    ) from e
+
+        return docs