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

doit_cli/cli/validate_command.py

@@ -0,0 +1,196 @@
+"""Validate command for spec file linting and quality checking."""
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+
+from ..models.validation_models import ValidationConfig
+from ..services.report_generator import ReportGenerator
+from ..services.validation_service import ValidationService
+
+
+console = Console()
+
+# Type aliases for CLI options
+JsonFlag = Annotated[
+    bool,
+    typer.Option(
+        "--json", "-j",
+        help="Output results as JSON"
+    )
+]
+
+AllFlag = Annotated[
+    bool,
+    typer.Option(
+        "--all", "-a",
+        help="Validate all specs in specs/ directory"
+    )
+]
+
+VerboseFlag = Annotated[
+    bool,
+    typer.Option(
+        "--verbose", "-v",
+        help="Show detailed output including all issues"
+    )
+]
+
+
+def validate_command(
+    path: Annotated[
+        Optional[Path],
+        typer.Argument(
+            help="Spec file or directory to validate (defaults to current directory)"
+        )
+    ] = None,
+    all_specs: AllFlag = False,
+    json_output: JsonFlag = False,
+    verbose: VerboseFlag = False,
+) -> None:
+    """Validate spec files for quality and standards compliance.
+
+    Checks spec files against validation rules including:
+    - Required sections (User Scenarios, Requirements, Success Criteria)
+    - Naming conventions (FR-XXX, SC-XXX patterns)
+    - Acceptance scenario format (Given/When/Then)
+    - Clarity markers ([NEEDS CLARIFICATION], TODO)
+
+    Custom rules can be configured via .doit/validation-rules.yaml:
+    - disabled_rules: List of rule IDs to skip
+    - overrides: Change severity of specific rules
+    - custom_rules: Add project-specific pattern checks
+
+    Examples:
+        doit validate                        # Validate current spec
+        doit validate specs/001-feature/     # Validate specific spec directory
+        doit validate spec.md                # Validate specific file
+        doit validate --all                  # Validate all specs
+        doit validate --all --json           # Output as JSON
+    """
+    # Resolve path
+    project_root = Path.cwd()
+
+    if path:
+        target_path = path if path.is_absolute() else project_root / path
+    else:
+        target_path = project_root
+
+    # Create services
+    config = ValidationConfig.default()
+    service = ValidationService(project_root=project_root, config=config)
+    reporter = ReportGenerator(console=console)
+
+    try:
+        if all_specs:
+            # Validate all specs in specs/ directory
+            results = service.validate_all()
+
+            if not results:
+                if json_output:
+                    print('{"error": "No spec files found in specs/ directory"}')
+                else:
+                    console.print("[yellow]No spec files found in specs/ directory[/yellow]")
+                raise typer.Exit(1)
+
+            summary = service.get_summary(results)
+
+            if json_output:
+                print(reporter.to_json_summary(results, summary))
+            else:
+                if verbose:
+                    # Show each result in detail
+                    for result in results:
+                        reporter.display_result(result)
+                        console.print()
+
+                # Always show summary for --all
+                reporter.display_summary(results, summary)
+
+            # Exit with error if any specs failed
+            if summary["failed"] > 0:
+                raise typer.Exit(1)
+
+        elif target_path.is_file():
+            # Validate single file
+            if not target_path.suffix.lower() == ".md":
+                if json_output:
+                    print('{"error": "Not a markdown file"}')
+                else:
+                    console.print(f"[red]Error:[/red] Not a markdown file: {target_path}")
+                raise typer.Exit(1)
+
+            result = service.validate_file(target_path)
+
+            if json_output:
+                print(reporter.to_json(result))
+            else:
+                reporter.display_result(result)
+
+            # Exit with error if validation failed
+            if result.error_count > 0:
+                raise typer.Exit(1)
+
+        elif target_path.is_dir():
+            # Check if this is a spec directory (contains spec.md)
+            spec_file = target_path / "spec.md"
+
+            if spec_file.exists():
+                # Validate single spec directory
+                result = service.validate_file(spec_file)
+
+                if json_output:
+                    print(reporter.to_json(result))
+                else:
+                    reporter.display_result(result)
+
+                if result.error_count > 0:
+                    raise typer.Exit(1)
+            else:
+                # Validate all specs in the directory
+                results = service.validate_directory(target_path)
+
+                if not results:
+                    if json_output:
+                        print('{"error": "No spec files found in directory"}')
+                    else:
+                        console.print(f"[yellow]No spec files found in {target_path}[/yellow]")
+                    raise typer.Exit(1)
+
+                summary = service.get_summary(results)
+
+                if json_output:
+                    print(reporter.to_json_summary(results, summary))
+                else:
+                    if verbose:
+                        for result in results:
+                            reporter.display_result(result)
+                            console.print()
+
+                    reporter.display_summary(results, summary)
+
+                if summary["failed"] > 0:
+                    raise typer.Exit(1)
+
+        else:
+            if json_output:
+                print(f'{{"error": "Path not found: {target_path}"}}')
+            else:
+                console.print(f"[red]Error:[/red] Path not found: {target_path}")
+            raise typer.Exit(1)
+
+    except FileNotFoundError as e:
+        if json_output:
+            print(f'{{"error": "{e}"}}')
+        else:
+            console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    except ValueError as e:
+        if json_output:
+            print(f'{{"error": "{e}"}}')
+        else:
+            console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)

doit_cli/cli/verify_command.py

@@ -0,0 +1,204 @@
+"""Verify command for checking doit project setup."""
+
+import json
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..models.agent import Agent
+from ..models.project import Project
+from ..models.results import VerifyResult, VerifyStatus
+from ..services.validator import Validator
+
+
+console = Console()
+
+# Type aliases for CLI options
+JsonFlag = Annotated[
+    bool,
+    typer.Option(
+        "--json", "-j",
+        help="Output results as JSON"
+    )
+]
+
+AgentOption = Annotated[
+    Optional[str],
+    typer.Option(
+        "--agent", "-a",
+        help="Specific agent to check: claude, copilot, or both"
+    )
+]
+
+
+def parse_agent_string(agent_str: str) -> list[Agent]:
+    """Parse agent string into list of Agent enums.
+
+    Args:
+        agent_str: Comma-separated agent names
+
+    Returns:
+        List of Agent enums
+    """
+    agents = []
+    for name in agent_str.lower().split(","):
+        name = name.strip()
+        if name == "claude":
+            agents.append(Agent.CLAUDE)
+        elif name == "copilot":
+            agents.append(Agent.COPILOT)
+        else:
+            raise typer.BadParameter(
+                f"Unknown agent: {name}. Use 'claude', 'copilot', or 'claude,copilot'"
+            )
+    return agents
+
+
+def get_status_style(status: VerifyStatus) -> str:
+    """Get rich style for verification status."""
+    if status == VerifyStatus.PASS:
+        return "green"
+    elif status == VerifyStatus.WARN:
+        return "yellow"
+    else:  # FAIL
+        return "red"
+
+
+def get_status_symbol(status: VerifyStatus) -> str:
+    """Get symbol for verification status."""
+    if status == VerifyStatus.PASS:
+        return "✓"
+    elif status == VerifyStatus.WARN:
+        return "!"
+    else:  # FAIL
+        return "✗"
+
+
+def display_verify_result(result: VerifyResult) -> None:
+    """Display verification result with rich formatting.
+
+    Args:
+        result: The verification result to display
+    """
+    # Create table
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        title="Project Verification Results",
+    )
+    table.add_column("Status", width=8, justify="center")
+    table.add_column("Check", width=20)
+    table.add_column("Message")
+
+    for check in result.checks:
+        style = get_status_style(check.status)
+        symbol = get_status_symbol(check.status)
+        status_text = f"[{style}]{symbol} {check.status.value.upper()}[/{style}]"
+
+        table.add_row(
+            status_text,
+            check.name,
+            check.message,
+        )
+
+    console.print()
+    console.print(table)
+
+    # Summary
+    console.print()
+    console.print(f"[bold]Summary:[/bold] {result.summary}")
+
+    # Show suggestions if there are warnings or failures
+    suggestions = [
+        c.suggestion for c in result.checks
+        if c.suggestion and c.status != VerifyStatus.PASS
+    ]
+
+    if suggestions:
+        console.print()
+        console.print(
+            Panel(
+                "\n".join(f"• {s}" for s in suggestions),
+                title="[yellow]Suggestions[/yellow]",
+                border_style="yellow",
+            )
+        )
+
+    # Final status
+    console.print()
+    if result.passed:
+        if result.has_warnings:
+            console.print("[yellow]Project setup complete with warnings[/yellow]")
+        else:
+            console.print("[bold green]Project setup verified successfully[/bold green]")
+    else:
+        console.print("[bold red]Project setup has issues that need attention[/bold red]")
+
+
+def display_json_result(result: VerifyResult) -> None:
+    """Display verification result as JSON.
+
+    Args:
+        result: The verification result to display
+    """
+    output = result.to_dict()
+    console.print(json.dumps(output, indent=2, default=str))
+
+
+def verify_command(
+    path: Annotated[
+        Path,
+        typer.Argument(
+            default=...,
+            help="Project directory path (use '.' for current directory)"
+        )
+    ] = Path("."),
+    agent: AgentOption = None,
+    json_output: JsonFlag = False,
+) -> None:
+    """Verify doit project setup and report status.
+
+    Checks for:
+    - .doit/ folder structure
+    - Agent command directories
+    - Command template files
+    - Project constitution and roadmap
+    - Copilot-specific configuration (if applicable)
+
+    Examples:
+        doit verify .                    # Verify current directory
+        doit verify . --agent claude     # Check only Claude setup
+        doit verify . --json             # Output as JSON
+    """
+    # Parse agent string if provided
+    agents = None
+    if agent:
+        try:
+            agents = parse_agent_string(agent)
+        except typer.BadParameter as e:
+            if json_output:
+                console.print(json.dumps({"error": str(e)}))
+            else:
+                console.print(f"[red]Error:[/red] {e}")
+            raise typer.Exit(1)
+
+    # Create project and validator
+    project = Project(path=path.resolve())
+    validator = Validator(project)
+
+    # Run verification
+    result = validator.run_all_checks(agents=agents)
+
+    # Display results
+    if json_output:
+        display_json_result(result)
+    else:
+        display_verify_result(result)
+
+    # Exit with appropriate code
+    if not result.passed:
+        raise typer.Exit(1)

doit_cli/cli/workflow_mixin.py

@@ -0,0 +1,224 @@
+"""Workflow mixin for CLI commands.
+
+This module provides a mixin class that adds guided workflow functionality
+to Typer CLI commands, including --non-interactive flag support and
+default value handling.
+"""
+
+import os
+from typing import Any, Callable, TypeVar
+
+import typer
+from rich.console import Console
+
+from ..models.workflow_models import Workflow, WorkflowStep
+from ..prompts.interactive import InteractivePrompt
+from ..services.workflow_engine import WorkflowEngine
+from ..services.state_manager import StateManager
+
+
+# Type variable for decorator
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+class WorkflowMixin:
+    """Mixin providing guided workflow functionality for CLI commands.
+
+    This class adds workflow execution capabilities to CLI commands,
+    including interactive prompting, progress display, and state recovery.
+
+    Usage:
+        class MyCommand(WorkflowMixin):
+            def __init__(self):
+                super().__init__()
+                self.workflow = Workflow(...)
+
+            def run(self, non_interactive: bool = False):
+                self.init_workflow(non_interactive=non_interactive)
+                results = self.execute_workflow(self.workflow)
+                # Use results...
+    """
+
+    def __init__(
+        self,
+        console: Console | None = None,
+        state_dir: str | None = None,
+    ):
+        """Initialize the workflow mixin.
+
+        Args:
+            console: Rich console for output
+            state_dir: Directory for state files (defaults to .doit/state)
+        """
+        self.console = console or Console()
+        self._state_dir = state_dir
+        self._engine: WorkflowEngine | None = None
+        self._non_interactive = False
+
+    def init_workflow(
+        self,
+        non_interactive: bool = False,
+        no_state: bool = False,
+    ) -> None:
+        """Initialize the workflow engine.
+
+        Args:
+            non_interactive: Force non-interactive mode
+            no_state: Disable state persistence
+        """
+        self._non_interactive = non_interactive
+
+        # Check environment variable if not explicitly set
+        if not non_interactive:
+            env_value = os.environ.get("DOIT_NON_INTERACTIVE", "").lower()
+            self._non_interactive = env_value in ("true", "1", "yes")
+
+        # Create state manager if enabled
+        state_manager = None
+        if not no_state:
+            state_manager = StateManager(state_dir=self._state_dir)
+
+        # Create prompt with non-interactive flag
+        prompt = InteractivePrompt(
+            console=self.console,
+            force_non_interactive=self._non_interactive,
+        )
+
+        # Create engine
+        self._engine = WorkflowEngine(
+            console=self.console,
+            state_manager=state_manager,
+        )
+        self._engine.prompt = prompt
+
+    def execute_workflow(self, workflow: Workflow) -> dict[str, str]:
+        """Execute a guided workflow.
+
+        Args:
+            workflow: Workflow definition to execute
+
+        Returns:
+            Dictionary of step_id -> response value
+
+        Raises:
+            ValueError: If engine not initialized
+            WorkflowError: If workflow fails
+        """
+        if self._engine is None:
+            raise ValueError("Workflow engine not initialized. Call init_workflow() first.")
+
+        return self._engine.run(workflow)
+
+    @property
+    def is_non_interactive(self) -> bool:
+        """Check if running in non-interactive mode."""
+        return self._non_interactive
+
+
+def non_interactive_option() -> Callable[[F], F]:
+    """Decorator that adds --non-interactive option to a command.
+
+    Usage:
+        @app.command()
+        @non_interactive_option()
+        def my_command(non_interactive: bool = False):
+            ...
+    """
+    def decorator(func: F) -> F:
+        return typer.Option(
+            False,
+            "--non-interactive",
+            "-n",
+            help="Run without interactive prompts, using default values.",
+            envvar="DOIT_NON_INTERACTIVE",
+        )(func)
+    return decorator
+
+
+def workflow_command_options(
+    func: Callable[..., Any] | None = None,
+) -> Callable[[F], F]:
+    """Add standard workflow options to a command.
+
+    Adds the following options:
+    - --non-interactive / -n: Disable interactive prompts
+    - --no-resume: Don't prompt to resume interrupted workflow
+
+    Usage:
+        @app.command()
+        @workflow_command_options
+        def my_command(
+            non_interactive: bool = typer.Option(False),
+            no_resume: bool = typer.Option(False),
+        ):
+            ...
+    """
+    def decorator(f: F) -> F:
+        # This would add the options via typer decorators
+        # Implementation depends on how typer handles stacked decorators
+        return f
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+def validate_required_defaults(workflow: Workflow) -> list[str]:
+    """Validate that all required steps have defaults for non-interactive mode.
+
+    Args:
+        workflow: Workflow to validate
+
+    Returns:
+        List of step IDs that are required but have no default
+    """
+    missing = []
+    for step in workflow.steps:
+        if step.required and step.default_value is None:
+            missing.append(step.id)
+    return missing
+
+
+def create_non_interactive_workflow(
+    original: Workflow,
+    overrides: dict[str, str] | None = None,
+) -> Workflow:
+    """Create a workflow with defaults for non-interactive execution.
+
+    This creates a modified workflow where required steps that don't
+    have defaults get values from the overrides dict.
+
+    Args:
+        original: Original workflow definition
+        overrides: Step ID to default value mapping
+
+    Returns:
+        Modified workflow suitable for non-interactive mode
+    """
+    overrides = overrides or {}
+    new_steps = []
+
+    for step in original.steps:
+        if step.required and step.default_value is None and step.id in overrides:
+            # Create new step with override as default
+            new_step = WorkflowStep(
+                id=step.id,
+                name=step.name,
+                prompt_text=step.prompt_text,
+                required=step.required,
+                order=step.order,
+                validation_type=step.validation_type,
+                default_value=overrides[step.id],
+                options=step.options,
+            )
+            new_steps.append(new_step)
+        else:
+            new_steps.append(step)
+
+    return Workflow(
+        id=original.id,
+        command_name=original.command_name,
+        description=original.description,
+        interactive=original.interactive,
+        steps=new_steps,
+    )