doit-toolkit-cli 0.1.10__py3-none-any.whl

doit_cli/services/report_generator.py

@@ -0,0 +1,256 @@
+"""Report generator for validation results."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.tree import Tree
+
+from ..models.validation_models import Severity, ValidationResult, ValidationStatus
+
+
+class ReportGenerator:
+    """Generates validation reports in human-readable and JSON formats."""
+
+    def __init__(self, console: Optional[Console] = None) -> None:
+        """Initialize report generator.
+
+        Args:
+            console: Rich console for output. Creates new one if None.
+        """
+        self.console = console or Console()
+
+    def display_result(self, result: ValidationResult) -> None:
+        """Display a single validation result with rich formatting.
+
+        Args:
+            result: The validation result to display.
+        """
+        spec_name = Path(result.spec_path).parent.name
+        self.console.print()
+        self.console.print(f"[bold]Validating:[/bold] {result.spec_path}")
+        self.console.print()
+
+        if not result.issues:
+            self.console.print("[green]No issues found[/green]")
+        else:
+            # Group issues by severity
+            errors = [i for i in result.issues if i.severity == Severity.ERROR]
+            warnings = [i for i in result.issues if i.severity == Severity.WARNING]
+            infos = [i for i in result.issues if i.severity == Severity.INFO]
+
+            # Display errors
+            if errors:
+                self._display_issue_group("ERRORS", errors, "red")
+
+            # Display warnings
+            if warnings:
+                self._display_issue_group("WARNINGS", warnings, "yellow")
+
+            # Display info
+            if infos:
+                self._display_issue_group("INFO", infos, "blue")
+
+        # Display summary line
+        self.console.print()
+        self.console.print("━" * 50)
+        self._display_summary_line(result)
+
+    def _display_issue_group(
+        self,
+        title: str,
+        issues: list,
+        color: str,
+    ) -> None:
+        """Display a group of issues with tree formatting.
+
+        Args:
+            title: Group title (e.g., "ERRORS").
+            issues: List of issues to display.
+            color: Color for the group.
+        """
+        tree = Tree(f"[{color}]{title} ({len(issues)})[/{color}]")
+
+        for i, issue in enumerate(issues):
+            is_last = i == len(issues) - 1
+            prefix = "└─" if is_last else "├─"
+
+            line_info = f"Line {issue.line_number}: " if issue.line_number > 0 else ""
+            tree.add(f"[{color}]{line_info}{issue.message}[/{color}]")
+
+            if issue.suggestion:
+                # Add suggestion as child
+                tree.add(f"   [dim]Suggestion: {issue.suggestion}[/dim]")
+
+        self.console.print(tree)
+
+    def _display_summary_line(self, result: ValidationResult) -> None:
+        """Display the summary line with score and status.
+
+        Args:
+            result: The validation result.
+        """
+        # Determine status color
+        status_colors = {
+            ValidationStatus.PASS: "green",
+            ValidationStatus.WARN: "yellow",
+            ValidationStatus.FAIL: "red",
+        }
+        color = status_colors.get(result.status, "white")
+
+        # Build status text
+        parts = []
+        if result.error_count > 0:
+            parts.append(f"{result.error_count} error{'s' if result.error_count != 1 else ''}")
+        if result.warning_count > 0:
+            parts.append(f"{result.warning_count} warning{'s' if result.warning_count != 1 else ''}")
+        if result.info_count > 0:
+            parts.append(f"{result.info_count} info")
+
+        status_detail = ", ".join(parts) if parts else "no issues"
+
+        self.console.print(
+            f"[bold]Quality Score:[/bold] {result.quality_score}/100"
+        )
+        self.console.print(
+            f"[bold]Status:[/bold] [{color}]{result.status.value.upper()}[/{color}] ({status_detail})"
+        )
+
+    def display_summary(
+        self,
+        results: list[ValidationResult],
+        summary: dict,
+    ) -> None:
+        """Display summary table for multiple validation results.
+
+        Args:
+            results: List of validation results.
+            summary: Summary statistics from ValidationService.get_summary().
+        """
+        self.console.print()
+        self.console.print("[bold]Spec Validation Summary[/bold]")
+        self.console.print()
+
+        if not results:
+            self.console.print("[yellow]No spec files found to validate[/yellow]")
+            return
+
+        # Create table
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("Spec", style="dim")
+        table.add_column("Score", justify="center")
+        table.add_column("Status", justify="center")
+        table.add_column("Errors", justify="center")
+        table.add_column("Warnings", justify="center")
+
+        for result in results:
+            # Get spec name from path
+            spec_name = Path(result.spec_path).parent.name
+
+            # Determine status color
+            status_colors = {
+                ValidationStatus.PASS: "green",
+                ValidationStatus.WARN: "yellow",
+                ValidationStatus.FAIL: "red",
+            }
+            color = status_colors.get(result.status, "white")
+
+            table.add_row(
+                spec_name,
+                str(result.quality_score),
+                f"[{color}]{result.status.value.upper()}[/{color}]",
+                str(result.error_count),
+                str(result.warning_count),
+            )
+
+        self.console.print(table)
+
+        # Display summary line
+        self.console.print()
+        self.console.print("━" * 50)
+        self.console.print(
+            f"[bold]Total:[/bold] {summary['total_specs']} specs | "
+            f"[green]Passed: {summary['passed']}[/green] | "
+            f"[yellow]Warned: {summary['warned']}[/yellow] | "
+            f"[red]Failed: {summary['failed']}[/red] | "
+            f"Avg Score: {summary['average_score']}"
+        )
+
+    def to_json(self, result: ValidationResult) -> str:
+        """Convert single validation result to JSON string.
+
+        Args:
+            result: The validation result.
+
+        Returns:
+            JSON string representation.
+        """
+        output = {
+            "spec_path": result.spec_path,
+            "status": result.status.value,
+            "quality_score": result.quality_score,
+            "error_count": result.error_count,
+            "warning_count": result.warning_count,
+            "info_count": result.info_count,
+            "issues": [
+                {
+                    "rule_id": issue.rule_id,
+                    "severity": issue.severity.value,
+                    "line_number": issue.line_number,
+                    "message": issue.message,
+                    "suggestion": issue.suggestion,
+                }
+                for issue in result.issues
+            ],
+            "validated_at": result.validated_at.isoformat(),
+        }
+        return json.dumps(output, indent=2)
+
+    def to_json_summary(
+        self,
+        results: list[ValidationResult],
+        summary: dict,
+    ) -> str:
+        """Convert multiple results to JSON summary string.
+
+        Args:
+            results: List of validation results.
+            summary: Summary statistics.
+
+        Returns:
+            JSON string representation.
+        """
+        output = {
+            "summary": {
+                "total_specs": summary["total_specs"],
+                "passed": summary["passed"],
+                "warned": summary["warned"],
+                "failed": summary["failed"],
+                "average_score": summary["average_score"],
+            },
+            "results": [
+                {
+                    "spec_path": result.spec_path,
+                    "status": result.status.value,
+                    "quality_score": result.quality_score,
+                    "error_count": result.error_count,
+                    "warning_count": result.warning_count,
+                    "info_count": result.info_count,
+                    "issues": [
+                        {
+                            "rule_id": issue.rule_id,
+                            "severity": issue.severity.value,
+                            "line_number": issue.line_number,
+                            "message": issue.message,
+                            "suggestion": issue.suggestion,
+                        }
+                        for issue in result.issues
+                    ],
+                }
+                for result in results
+            ],
+        }
+        return json.dumps(output, indent=2)

doit_cli/services/requirement_parser.py

@@ -0,0 +1,112 @@
+"""Parser for extracting requirements from spec.md files."""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+from ..models.crossref_models import Requirement
+
+
+class RequirementParser:
+    """Parses spec.md files to extract functional requirements.
+
+    This parser extracts FR-XXX requirements from specification files
+    using the standard format: `- **FR-XXX**: Description text`
+    """
+
+    # Pattern to match: - **FR-XXX**: Description
+    # Captures: group(1) = FR-XXX, group(2) = description
+    REQUIREMENT_PATTERN = re.compile(
+        r"^\s*-\s*\*\*(?P<id>FR-\d{3})\*\*:\s*(?P<description>.+)$",
+        re.MULTILINE,
+    )
+
+    def __init__(self, spec_path: Optional[Path] = None) -> None:
+        """Initialize parser with optional spec file path.
+
+        Args:
+            spec_path: Path to spec.md file. Can be set later via parse().
+        """
+        self.spec_path = spec_path
+
+    def parse(self, spec_path: Optional[Path] = None) -> list[Requirement]:
+        """Parse spec.md and extract all functional requirements.
+
+        Args:
+            spec_path: Path to spec.md file. Overrides constructor path.
+
+        Returns:
+            List of Requirement objects sorted by ID.
+
+        Raises:
+            FileNotFoundError: If spec file doesn't exist.
+            ValueError: If no spec path provided.
+        """
+        path = spec_path or self.spec_path
+        if path is None:
+            raise ValueError("No spec path provided")
+
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(f"Spec file not found: {path}")
+
+        content = path.read_text(encoding="utf-8")
+        return self.parse_content(content, str(path))
+
+    def parse_content(self, content: str, spec_path: str) -> list[Requirement]:
+        """Parse content string and extract requirements.
+
+        Args:
+            content: Full content of spec.md file.
+            spec_path: Path to associate with extracted requirements.
+
+        Returns:
+            List of Requirement objects sorted by ID.
+        """
+        requirements: list[Requirement] = []
+        lines = content.split("\n")
+
+        for line_num, line in enumerate(lines, start=1):
+            match = self.REQUIREMENT_PATTERN.match(line)
+            if match:
+                req = Requirement(
+                    id=match.group("id"),
+                    spec_path=spec_path,
+                    description=match.group("description").strip(),
+                    line_number=line_num,
+                )
+                requirements.append(req)
+
+        # Sort by requirement ID (FR-001, FR-002, etc.)
+        requirements.sort(key=lambda r: r.id)
+        return requirements
+
+    def get_requirement(
+        self, requirement_id: str, spec_path: Optional[Path] = None
+    ) -> Optional[Requirement]:
+        """Get a specific requirement by ID.
+
+        Args:
+            requirement_id: The FR-XXX ID to find.
+            spec_path: Path to spec.md file.
+
+        Returns:
+            Requirement if found, None otherwise.
+        """
+        requirements = self.parse(spec_path)
+        for req in requirements:
+            if req.id == requirement_id:
+                return req
+        return None
+
+    def get_requirement_ids(self, spec_path: Optional[Path] = None) -> list[str]:
+        """Get list of all requirement IDs in a spec.
+
+        Args:
+            spec_path: Path to spec.md file.
+
+        Returns:
+            List of FR-XXX IDs.
+        """
+        requirements = self.parse(spec_path)
+        return [req.id for req in requirements]

doit_cli/services/roadmap_summarizer.py

@@ -0,0 +1,209 @@
+"""Roadmap summarization service for AI context injection.
+
+This module provides the RoadmapSummarizer service that parses roadmap.md
+and generates condensed summaries with P1/P2 items prioritized.
+"""
+
+import re
+from typing import Optional
+
+from ..models.context_config import (
+    RoadmapItem,
+    RoadmapSummary,
+    SummarizationConfig,
+)
+
+
+class RoadmapSummarizer:
+    """Service for parsing and summarizing roadmap content.
+
+    Parses roadmap.md by priority sections (P1-P4) and generates condensed
+    summaries that include full P1/P2 items with rationale while reducing
+    P3/P4 to titles only.
+    """
+
+    def __init__(self, config: Optional[SummarizationConfig] = None) -> None:
+        """Initialize with summarization configuration.
+
+        Args:
+            config: Summarization configuration (uses defaults if None).
+        """
+        self.config = config or SummarizationConfig()
+
+    def parse_roadmap(self, content: str) -> list[RoadmapItem]:
+        """Parse roadmap.md content into structured items.
+
+        Extracts items from markdown, parsing P1-P4 sections, rationale,
+        and feature references.
+
+        Args:
+            content: Raw markdown content of roadmap.md
+
+        Returns:
+            List of RoadmapItem objects
+        """
+        items: list[RoadmapItem] = []
+        lines = content.split("\n")
+
+        current_priority = "P4"  # Default priority
+        i = 0
+
+        while i < len(lines):
+            line = lines[i]
+
+            # Check for priority section headers (### P1 - Critical, ## P2, etc.)
+            priority_match = re.match(r"^#{2,3}\s*(P[1-4])\s*[-:]?\s*", line, re.IGNORECASE)
+            if priority_match:
+                current_priority = priority_match.group(1).upper()
+                i += 1
+                continue
+
+            # Check for checklist items (- [ ] or - [x]) or plain list items (- text)
+            item_match = re.match(r"^-\s*\[([ xX])\]\s*(.+)$", line)
+            plain_match = re.match(r"^-\s+([^[\s].+)$", line) if not item_match else None
+
+            if item_match:
+                completed = item_match.group(1).lower() == "x"
+                text = item_match.group(2).strip()
+            elif plain_match:
+                completed = False
+                text = plain_match.group(1).strip()
+            else:
+                i += 1
+                continue
+
+            # Extract feature reference from text (e.g., `[034-fixit-workflow]` or [034-fixit])
+            feature_ref = ""
+            feature_match = re.search(r"`?\[?(\d{3}-[\w-]+)\]?`?", text)
+            if feature_match:
+                feature_ref = feature_match.group(1)
+
+            # Look for rationale in following lines
+            rationale = ""
+            j = i + 1
+            while j < len(lines):
+                next_line = lines[j].strip()
+                # Check for rationale line
+                rationale_match = re.match(r"^-?\s*\*?\*?Rationale\*?\*?:\s*(.+)$", next_line, re.IGNORECASE)
+                if rationale_match:
+                    rationale = rationale_match.group(1).strip()
+                    break
+                # Stop if we hit another item or section
+                if next_line.startswith("- [") or next_line.startswith("-") or next_line.startswith("#"):
+                    break
+                j += 1
+
+            items.append(RoadmapItem(
+                text=text,
+                priority=current_priority,
+                rationale=rationale,
+                feature_ref=feature_ref,
+                completed=completed,
+            ))
+
+            i += 1
+
+        return items
+
+    def summarize(
+        self,
+        items: list[RoadmapItem],
+        max_tokens: int = 2000,
+        current_feature: Optional[str] = None,
+    ) -> RoadmapSummary:
+        """Generate condensed roadmap summary.
+
+        Creates a summary with:
+        - Full P1/P2 items including rationale
+        - P3/P4 items as titles only
+        - Current feature highlighted if provided
+
+        Args:
+            items: Parsed roadmap items
+            max_tokens: Maximum tokens for output
+            current_feature: Current feature branch name for highlighting
+
+        Returns:
+            RoadmapSummary with condensed content
+        """
+        if not items:
+            return RoadmapSummary(
+                condensed_text="",
+                item_count=0,
+                priorities_included=[],
+            )
+
+        sections: list[str] = ["## Roadmap Summary", ""]
+        priorities_included: set[str] = set()
+        item_count = 0
+
+        # Group items by priority
+        by_priority: dict[str, list[RoadmapItem]] = {"P1": [], "P2": [], "P3": [], "P4": []}
+        current_feature_items: list[RoadmapItem] = []
+
+        for item in items:
+            if item.completed:
+                continue  # Skip completed items in roadmap summary
+
+            priority = item.priority.upper()
+            if priority in by_priority:
+                by_priority[priority].append(item)
+
+            # Check if this is the current feature
+            if current_feature and item.feature_ref:
+                # Match feature ref against current branch
+                if current_feature in item.feature_ref or item.feature_ref in current_feature:
+                    current_feature_items.append(item)
+
+        # Add current feature section if we found matches
+        if current_feature_items:
+            sections.append("### Current Feature")
+            for item in current_feature_items:
+                sections.append(f"- **[CURRENT]** {item.text}")
+                if item.rationale:
+                    sections.append(f"  - *Rationale*: {item.rationale}")
+                item_count += 1
+                priorities_included.add(item.priority)
+            sections.append("")
+
+        # High priority section (P1/P2) - full details
+        high_priority = by_priority["P1"] + by_priority["P2"]
+        # Filter out items already shown in current feature
+        high_priority = [i for i in high_priority if i not in current_feature_items]
+
+        if high_priority:
+            sections.append("### High Priority (P1-P2)")
+            for item in high_priority:
+                marker = "[P1]" if item.priority == "P1" else "[P2]"
+                sections.append(f"- {marker} {item.text}")
+                if item.rationale:
+                    sections.append(f"  - *Rationale*: {item.rationale}")
+                item_count += 1
+                priorities_included.add(item.priority)
+            sections.append("")
+
+        # Lower priority section (P3/P4) - titles only
+        low_priority = by_priority["P3"] + by_priority["P4"]
+        # Filter out items already shown
+        low_priority = [i for i in low_priority if i not in current_feature_items]
+
+        if low_priority:
+            sections.append("### Other Priorities (P3-P4)")
+            for item in low_priority:
+                # Extract just the title (first sentence or up to first period)
+                title = item.text.split(".")[0].strip()
+                if len(title) > 80:
+                    title = title[:77] + "..."
+                marker = "[P3]" if item.priority == "P3" else "[P4]"
+                sections.append(f"- {marker} {title}")
+                item_count += 1
+                priorities_included.add(item.priority)
+            sections.append("")
+
+        condensed_text = "\n".join(sections)
+
+        return RoadmapSummary(
+            condensed_text=condensed_text,
+            item_count=item_count,
+            priorities_included=sorted(priorities_included),
+        )