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

doit_cli/formatters/json_formatter.py

@@ -0,0 +1,126 @@
+"""JSON formatter for status output."""
+
+import json
+from datetime import datetime
+from typing import Any
+
+from ..models.status_models import SpecState, StatusReport
+from .base import StatusFormatter
+
+
+class JsonFormatter(StatusFormatter):
+    """Formats status as JSON for machine consumption.
+
+    Produces structured JSON output suitable for parsing by other tools,
+    CI/CD systems, or programmatic analysis.
+    """
+
+    def format(self, report: StatusReport, verbose: bool = False) -> str:
+        """Format the status report as JSON.
+
+        Args:
+            report: The StatusReport to format.
+            verbose: Include detailed validation errors.
+
+        Returns:
+            JSON string representation.
+        """
+        data = self._build_json_data(report, verbose)
+        return json.dumps(data, indent=2, default=self._json_serializer)
+
+    def _build_json_data(self, report: StatusReport, verbose: bool) -> dict[str, Any]:
+        """Build the JSON data structure.
+
+        Args:
+            report: The StatusReport to convert.
+            verbose: Include detailed validation errors.
+
+        Returns:
+            Dictionary ready for JSON serialization.
+        """
+        # Build summary
+        summary = {
+            "total": report.total_count,
+            "by_status": {
+                "draft": report.by_status.get(SpecState.DRAFT, 0),
+                "in_progress": report.by_status.get(SpecState.IN_PROGRESS, 0),
+                "complete": report.by_status.get(SpecState.COMPLETE, 0),
+                "approved": report.by_status.get(SpecState.APPROVED, 0),
+            },
+            "blocking": report.blocking_count,
+            "validation_pass": sum(
+                1 for s in report.specs if s.validation_passed
+            ),
+            "validation_fail": sum(
+                1 for s in report.specs
+                if s.validation_result is not None and not s.validation_passed
+            ),
+            "completion_percentage": round(report.completion_percentage, 2),
+            "ready_to_commit": report.is_ready_to_commit,
+        }
+
+        # Build specs list
+        specs = []
+        for spec in report.specs:
+            spec_data = {
+                "name": spec.name,
+                "path": str(spec.path),
+                "status": spec.status.value,
+                "last_modified": spec.last_modified.isoformat(),
+                "is_blocking": spec.is_blocking,
+                "error": spec.error,
+            }
+
+            # Add validation info
+            if spec.validation_result is not None:
+                validation_data = {
+                    "passed": spec.validation_passed,
+                    "score": spec.validation_score,
+                    "error_count": spec.validation_result.error_count,
+                    "warning_count": spec.validation_result.warning_count,
+                }
+
+                if verbose and spec.validation_result.issues:
+                    validation_data["issues"] = [
+                        {
+                            "rule_id": issue.rule_id,
+                            "severity": issue.severity.value,
+                            "line": issue.line_number,
+                            "message": issue.message,
+                            "suggestion": issue.suggestion,
+                        }
+                        for issue in spec.validation_result.issues
+                    ]
+                else:
+                    validation_data["issues"] = []
+
+                spec_data["validation"] = validation_data
+            else:
+                spec_data["validation"] = None
+
+            specs.append(spec_data)
+
+        return {
+            "generated_at": report.generated_at.isoformat(),
+            "project_root": str(report.project_root),
+            "summary": summary,
+            "specs": specs,
+        }
+
+    def _json_serializer(self, obj: Any) -> Any:
+        """Custom JSON serializer for non-standard types.
+
+        Args:
+            obj: Object to serialize.
+
+        Returns:
+            JSON-serializable representation.
+
+        Raises:
+            TypeError: If object cannot be serialized.
+        """
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")

doit_cli/formatters/markdown_formatter.py

@@ -0,0 +1,97 @@
+"""Markdown formatter for status output."""
+
+from ..models.status_models import SpecState, StatusReport
+from .base import StatusFormatter
+
+
+class MarkdownFormatter(StatusFormatter):
+    """Formats status as markdown table for documentation.
+
+    Produces GitHub-flavored markdown output suitable for embedding
+    in documentation, README files, or issue descriptions.
+    """
+
+    def format(self, report: StatusReport, verbose: bool = False) -> str:
+        """Format the status report as markdown.
+
+        Args:
+            report: The StatusReport to format.
+            verbose: Include detailed validation errors.
+
+        Returns:
+            Markdown string representation.
+        """
+        lines = []
+
+        # Header
+        lines.append("# Spec Status Report")
+        lines.append("")
+        lines.append(f"**Generated**: {report.generated_at.strftime('%Y-%m-%d %H:%M:%S')}")
+        lines.append(f"**Project**: {report.project_root.name}")
+        lines.append("")
+
+        # Specifications table
+        lines.append("## Specifications")
+        lines.append("")
+
+        if report.specs:
+            lines.append("| Spec | Status | Validation | Last Modified |")
+            lines.append("|------|--------|------------|---------------|")
+
+            for spec in report.specs:
+                status_display = f"{spec.status.emoji} {spec.status.display_name}"
+
+                # Validation indicator
+                if spec.error:
+                    validation = "❌ Error"
+                elif spec.validation_result is None:
+                    validation = "—"
+                elif spec.validation_passed:
+                    validation = "✅ Pass"
+                else:
+                    validation = f"❌ Fail ({spec.validation_result.error_count})"
+
+                if spec.is_blocking:
+                    validation += " ⛔"
+
+                modified = spec.last_modified.strftime("%Y-%m-%d")
+
+                lines.append(f"| {spec.name} | {status_display} | {validation} | {modified} |")
+
+            # Add verbose details
+            if verbose:
+                lines.append("")
+                lines.append("### Validation Details")
+                lines.append("")
+                for spec in report.specs:
+                    if spec.validation_result and spec.validation_result.issues:
+                        lines.append(f"#### {spec.name}")
+                        lines.append("")
+                        for issue in spec.validation_result.issues:
+                            severity = issue.severity.value.upper()
+                            lines.append(f"- **{severity}** (line {issue.line_number}): {issue.message}")
+                            if issue.suggestion:
+                                lines.append(f"  - Suggestion: {issue.suggestion}")
+                        lines.append("")
+        else:
+            lines.append("*No specifications found.*")
+            lines.append("")
+
+        # Summary
+        lines.append("## Summary")
+        lines.append("")
+        lines.append(f"- **Total Specs**: {report.total_count}")
+        lines.append(f"- **Draft**: {report.by_status.get(SpecState.DRAFT, 0)}")
+        lines.append(f"- **In Progress**: {report.by_status.get(SpecState.IN_PROGRESS, 0)}")
+        lines.append(f"- **Complete**: {report.by_status.get(SpecState.COMPLETE, 0)}")
+        lines.append(f"- **Approved**: {report.by_status.get(SpecState.APPROVED, 0)}")
+        lines.append(f"- **Completion**: {report.completion_percentage:.0f}%")
+
+        if report.is_ready_to_commit:
+            lines.append("- **Status**: ✅ Ready to commit")
+        else:
+            lines.append(f"- **Status**: ⛔ {report.blocking_count} spec(s) blocking")
+
+        lines.append("")
+
+        return "\n".join(lines)

doit_cli/formatters/rich_formatter.py

@@ -0,0 +1,257 @@
+"""Rich terminal formatter for status output."""
+
+from datetime import datetime
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..models.status_models import SpecState, SpecStatus, StatusReport
+from .base import StatusFormatter
+
+
+class RichFormatter(StatusFormatter):
+    """Formats status as rich terminal output with colors and tables.
+
+    Uses the Rich library to produce attractive terminal output with:
+    - Colored status indicators
+    - Formatted tables
+    - Summary panels
+    """
+
+    def __init__(self, console: Optional[Console] = None) -> None:
+        """Initialize formatter with optional console.
+
+        Args:
+            console: Rich Console instance. Creates new one if not provided.
+        """
+        self.console = console or Console()
+
+    def format(self, report: StatusReport, verbose: bool = False) -> str:
+        """Format the status report as a string.
+
+        Note: For rich terminal output, use format_to_console() instead.
+        This method captures the output as a string.
+
+        Args:
+            report: The StatusReport to format.
+            verbose: Include detailed validation errors.
+
+        Returns:
+            Formatted string representation (with ANSI codes).
+        """
+        # Capture output to string
+        from io import StringIO
+
+        string_io = StringIO()
+        temp_console = Console(file=string_io, force_terminal=True)
+
+        self._render_to_console(report, verbose, temp_console)
+
+        return string_io.getvalue()
+
+    def format_to_console(self, report: StatusReport, verbose: bool = False) -> None:
+        """Format and print directly to console with rich formatting.
+
+        Args:
+            report: The StatusReport to format.
+            verbose: Include detailed validation errors.
+        """
+        self._render_to_console(report, verbose, self.console)
+
+    def _render_to_console(
+        self, report: StatusReport, verbose: bool, console: Console
+    ) -> None:
+        """Internal method to render report to a console.
+
+        Args:
+            report: The StatusReport to format.
+            verbose: Include detailed validation errors.
+            console: Console to render to.
+        """
+        # Header panel
+        project_name = report.project_root.name
+        generated = report.generated_at.strftime("%Y-%m-%d %H:%M:%S")
+
+        header = f"[bold]📊 Project:[/bold] {project_name}\n"
+        header += f"[bold]📅 Generated:[/bold] {generated}"
+
+        console.print(
+            Panel(header, title="Spec Status Dashboard", border_style="blue")
+        )
+        console.print()
+
+        # Specs table
+        if report.specs:
+            table = self._create_specs_table(report, verbose)
+            console.print(table)
+            console.print()
+
+            # Summary panel
+            summary = self._create_summary_panel(report)
+            console.print(summary)
+        else:
+            console.print(
+                "[yellow]No specifications found.[/yellow] "
+                "Run 'doit specit' to create one."
+            )
+
+    def _create_specs_table(
+        self, report: StatusReport, verbose: bool
+    ) -> Table:
+        """Create the main specs table.
+
+        Args:
+            report: The StatusReport containing specs.
+            verbose: Include validation error details.
+
+        Returns:
+            Rich Table with spec information.
+        """
+        table = Table(show_header=True, header_style="bold")
+
+        # Columns
+        table.add_column("Spec", style="cyan", no_wrap=True)
+        table.add_column("Status", justify="center")
+        table.add_column("Validation", justify="center")
+        table.add_column("Modified", justify="right")
+
+        if verbose:
+            table.add_column("Details", style="dim")
+
+        for spec in report.specs:
+            # Status with emoji
+            status_display = f"{spec.status.emoji} {spec.status.display_name}"
+            status_style = self._get_status_style(spec.status)
+
+            # Validation indicator
+            if spec.error:
+                validation_display = "[red]❌ Error[/red]"
+            elif spec.validation_result is None:
+                validation_display = "[dim]—[/dim]"
+            elif spec.validation_passed:
+                validation_display = "[green]✅ Pass[/green]"
+            else:
+                validation_display = f"[red]❌ Fail ({spec.validation_result.error_count})[/red]"
+
+            # Blocking indicator
+            if spec.is_blocking:
+                validation_display += " [bold red]⛔[/bold red]"
+
+            # Modified date (relative)
+            modified = self._format_relative_date(spec.last_modified)
+
+            # Build row
+            row = [
+                spec.name,
+                f"[{status_style}]{status_display}[/{status_style}]",
+                validation_display,
+                modified,
+            ]
+
+            if verbose:
+                details = self._get_spec_details(spec)
+                row.append(details)
+
+            table.add_row(*row)
+
+        return table
+
+    def _create_summary_panel(self, report: StatusReport) -> Panel:
+        """Create the summary panel with statistics.
+
+        Args:
+            report: The StatusReport to summarize.
+
+        Returns:
+            Rich Panel with summary statistics.
+        """
+        # Status counts
+        counts = report.by_status
+        status_line = (
+            f"[dim]Draft:[/dim] {counts.get(SpecState.DRAFT, 0)}  │  "
+            f"[dim]In Progress:[/dim] {counts.get(SpecState.IN_PROGRESS, 0)}  │  "
+            f"[dim]Complete:[/dim] {counts.get(SpecState.COMPLETE, 0)}  │  "
+            f"[dim]Approved:[/dim] {counts.get(SpecState.APPROVED, 0)}"
+        )
+
+        # Completion percentage
+        completion = f"[bold]Completion:[/bold] {report.completion_percentage:.0f}%"
+
+        # Ready to commit indicator
+        if report.is_ready_to_commit:
+            ready = "[green]✅ Ready to commit[/green]"
+        else:
+            ready = f"[red]⛔ {report.blocking_count} spec(s) blocking[/red]"
+
+        summary = f"{status_line}\n{completion}  │  {ready}"
+
+        return Panel(summary, title="Summary", border_style="green" if report.is_ready_to_commit else "red")
+
+    def _get_status_style(self, status: SpecState) -> str:
+        """Get Rich style for a status.
+
+        Args:
+            status: The SpecState to style.
+
+        Returns:
+            Rich style string.
+        """
+        styles = {
+            SpecState.DRAFT: "dim",
+            SpecState.IN_PROGRESS: "yellow",
+            SpecState.COMPLETE: "green",
+            SpecState.APPROVED: "bold green",
+            SpecState.ERROR: "red",
+        }
+        return styles.get(status, "white")
+
+    def _format_relative_date(self, dt: datetime) -> str:
+        """Format a datetime as relative time (Today, Yesterday, etc.).
+
+        Args:
+            dt: Datetime to format.
+
+        Returns:
+            Human-readable relative date string.
+        """
+        now = datetime.now()
+        diff = now - dt
+
+        if diff.days == 0:
+            return "Today"
+        elif diff.days == 1:
+            return "Yesterday"
+        elif diff.days < 7:
+            return f"{diff.days} days ago"
+        else:
+            return dt.strftime("%Y-%m-%d")
+
+    def _get_spec_details(self, spec: SpecStatus) -> str:
+        """Get detailed information about a spec for verbose mode.
+
+        Args:
+            spec: The SpecStatus to describe.
+
+        Returns:
+            Details string with validation errors if any.
+        """
+        if spec.error:
+            return spec.error
+
+        if spec.validation_result is None:
+            return "Not validated"
+
+        if spec.validation_passed:
+            return f"Score: {spec.validation_score}"
+
+        # Show validation errors
+        errors = []
+        for issue in spec.validation_result.issues[:3]:  # Limit to 3
+            errors.append(f"• {issue.message}")
+
+        if len(spec.validation_result.issues) > 3:
+            errors.append(f"• ... and {len(spec.validation_result.issues) - 3} more")
+
+        return "\n".join(errors)

doit_cli/main.py

@@ -0,0 +1,49 @@
+"""Main CLI application for doit-cli new commands (init, verify)."""
+
+import typer
+
+from .cli.analytics_command import app as analytics_app
+from .cli.context_command import context_app
+from .cli.diagram_command import diagram_app
+from .cli.fixit_command import app as fixit_app
+from .cli.hooks_command import hooks_app
+from .cli.init_command import init_command
+from .cli.memory_command import memory_app
+from .cli.status_command import status_command
+from .cli.sync_prompts_command import sync_prompts_command
+from .cli.validate_command import validate_command
+from .cli.verify_command import verify_command
+from .cli.xref_command import xref_app
+
+
+# Create a new typer app for the refactored commands
+app = typer.Typer(
+    name="doit",
+    help="Doit CLI - Setup tool for Doit spec-driven development projects",
+    add_completion=False,
+)
+
+# Register commands
+app.command(name="init")(init_command)
+app.command(name="status")(status_command)
+app.command(name="sync-prompts")(sync_prompts_command)
+app.command(name="validate")(validate_command)
+app.command(name="verify")(verify_command)
+
+# Register subcommand groups
+app.add_typer(analytics_app, name="analytics")
+app.add_typer(context_app, name="context")
+app.add_typer(diagram_app, name="diagram")
+app.add_typer(fixit_app, name="fixit")
+app.add_typer(hooks_app, name="hooks")
+app.add_typer(memory_app, name="memory")
+app.add_typer(xref_app, name="xref")
+
+
+def main():
+    """Main entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

doit_cli/models/__init__.py

@@ -0,0 +1,139 @@
+"""Data models for doit-cli."""
+
+from .agent import Agent
+from .project import Project
+from .template import Template
+from .results import InitResult, VerifyResult, VerifyCheck, VerifyStatus
+from .context_config import (
+    ContextConfig,
+    SourceConfig,
+    CommandOverride,
+    ContextSource,
+    LoadedContext,
+)
+from .validation_models import (
+    Severity,
+    ValidationStatus,
+    ValidationRule,
+    ValidationIssue,
+    ValidationResult,
+    RuleOverride,
+    CustomRule,
+    ValidationConfig,
+)
+from .workflow_models import (
+    WorkflowStatus,
+    WorkflowStep,
+    Workflow,
+    StepResponse,
+    WorkflowState,
+    ValidationResult as WorkflowValidationResult,
+    WorkflowError,
+    ValidationError as WorkflowValidationError,
+    NavigationCommand,
+    StateCorruptionError,
+)
+from .status_models import (
+    SpecState,
+    SpecStatus,
+    StatusReport,
+)
+from .crossref_models import (
+    CoverageStatus,
+    Requirement,
+    TaskReference,
+    Task,
+    CrossReference,
+    RequirementCoverage,
+    CoverageReport,
+)
+from .diagram_models import (
+    DiagramType,
+    Cardinality,
+    AcceptanceScenario,
+    ParsedUserStory,
+    EntityAttribute,
+    EntityRelationship,
+    ParsedEntity,
+    DiagramSection,
+    ValidationResult as DiagramValidationResult,
+    GeneratedDiagram,
+    DiagramResult,
+)
+from .search_models import (
+    QueryType,
+    SourceType,
+    SourceFilter,
+    SearchQuery,
+    SearchResult,
+    MemorySource,
+    ContentSnippet,
+    SearchHistory,
+)
+
+__all__ = [
+    "Agent",
+    "Project",
+    "Template",
+    "InitResult",
+    "VerifyResult",
+    "VerifyCheck",
+    "VerifyStatus",
+    "ContextConfig",
+    "SourceConfig",
+    "CommandOverride",
+    "ContextSource",
+    "LoadedContext",
+    "Severity",
+    "ValidationStatus",
+    "ValidationRule",
+    "ValidationIssue",
+    "ValidationResult",
+    "RuleOverride",
+    "CustomRule",
+    "ValidationConfig",
+    # Workflow models
+    "WorkflowStatus",
+    "WorkflowStep",
+    "Workflow",
+    "StepResponse",
+    "WorkflowState",
+    "WorkflowValidationResult",
+    "WorkflowError",
+    "WorkflowValidationError",
+    "NavigationCommand",
+    "StateCorruptionError",
+    # Status models
+    "SpecState",
+    "SpecStatus",
+    "StatusReport",
+    # Cross-reference models
+    "CoverageStatus",
+    "Requirement",
+    "TaskReference",
+    "Task",
+    "CrossReference",
+    "RequirementCoverage",
+    "CoverageReport",
+    # Diagram models
+    "DiagramType",
+    "Cardinality",
+    "AcceptanceScenario",
+    "ParsedUserStory",
+    "EntityAttribute",
+    "EntityRelationship",
+    "ParsedEntity",
+    "DiagramSection",
+    "DiagramValidationResult",
+    "GeneratedDiagram",
+    "DiagramResult",
+    # Search models
+    "QueryType",
+    "SourceType",
+    "SourceFilter",
+    "SearchQuery",
+    "SearchResult",
+    "MemorySource",
+    "ContentSnippet",
+    "SearchHistory",
+]