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

doit_cli/cli/context_command.py

@@ -0,0 +1,213 @@
+"""CLI commands for AI context management."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..models.context_config import ContextConfig
+from ..services.context_loader import ContextLoader
+
+console = Console()
+
+# Create the context command group
+context_app = typer.Typer(
+    name="context",
+    help="Manage AI context injection for doit commands.",
+    no_args_is_help=True,
+)
+
+
+@context_app.command("show")
+def show_context(
+    command: str = typer.Option(
+        None, "--command", "-c", help="Show context for specific command (applies overrides)"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show full content of each source"
+    ),
+) -> None:
+    """Show what context would be loaded for commands."""
+    project_root = Path.cwd()
+
+    # Load configuration
+    config = ContextConfig.load_from_project(project_root)
+
+    console.print("[bold]AI Context Status[/bold]")
+    console.print("=" * 50)
+
+    # Show global status
+    if not config.enabled:
+        console.print("\n[yellow]Context loading is disabled globally.[/yellow]")
+        console.print("Enable in .doit/config/context.yaml by setting 'enabled: true'")
+        return
+
+    console.print(f"\n[bold]Global Settings:[/bold]")
+    console.print(f"  Enabled: [green]yes[/green]")
+    console.print(f"  Max tokens per source: {config.max_tokens_per_source:,}")
+    console.print(f"  Total max tokens: {config.total_max_tokens:,}")
+
+    # Show summarization settings
+    if config.summarization.enabled:
+        soft_threshold = int(config.total_max_tokens * (config.summarization.threshold_percentage / 100.0))
+        console.print(f"\n[bold]Summarization:[/bold]")
+        console.print(f"  Enabled: [green]yes[/green]")
+        console.print(f"  Soft threshold: {soft_threshold:,} tokens ({config.summarization.threshold_percentage}%)")
+        console.print(f"  Fallback to truncation: {'yes' if config.summarization.fallback_to_truncation else 'no'}")
+
+    # Load context
+    loader = ContextLoader(
+        project_root=project_root,
+        config=config,
+        command=command,
+    )
+
+    try:
+        context = loader.load()
+    except Exception as e:
+        console.print(f"\n[red]Error loading context: {e}[/red]")
+        raise typer.Exit(1)
+
+    # Show command-specific info
+    if command:
+        console.print(f"\n[bold]Context for command:[/bold] {command}")
+        if command in config.commands:
+            console.print("  [dim]Command-specific overrides applied[/dim]")
+
+    # Create source table
+    console.print(f"\n[bold]Loaded Sources:[/bold]")
+
+    if not context.sources:
+        console.print("  [dim]No sources loaded[/dim]")
+        console.print("\n[dim]Check that .doit/memory/ contains constitution.md or roadmap.md[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Source", style="cyan")
+    table.add_column("Path", style="dim")
+    table.add_column("Tokens", justify="right")
+    table.add_column("Status")
+
+    for source in context.sources:
+        # Truncate path for display
+        path_str = str(source.path)
+        if len(path_str) > 40:
+            path_str = "..." + path_str[-37:]
+
+        # Status indicator
+        if source.truncated:
+            status = f"[yellow]truncated ({source.original_tokens:,} -> {source.token_count:,})[/yellow]"
+        elif source.source_type == "roadmap" and config.summarization.enabled:
+            status = "[cyan]summarized[/cyan]"
+        elif source.source_type == "completed_roadmap":
+            status = "[cyan]formatted[/cyan]"
+        else:
+            status = "[green]complete[/green]"
+
+        table.add_row(
+            source.source_type,
+            path_str,
+            f"{source.token_count:,}",
+            status,
+        )
+
+    console.print(table)
+
+    # Summary
+    console.print(f"\n[bold]Summary:[/bold]")
+    console.print(f"  Total sources: {len(context.sources)}")
+    console.print(f"  Total tokens: {context.total_tokens:,}")
+
+    if context.any_truncated:
+        console.print("  [yellow]Some sources were truncated to fit token limits[/yellow]")
+
+    # Check for guidance prompt (indicates context was condensed)
+    if hasattr(context, '_guidance_prompt') and context._guidance_prompt:
+        console.print("  [cyan]AI guidance prompt included (context condensed)[/cyan]")
+
+    # Show verbose content
+    if verbose:
+        console.print(f"\n[bold]Source Content Preview:[/bold]")
+        for source in context.sources:
+            console.print(f"\n[cyan]--- {source.source_type} ---[/cyan]")
+            # Show first 500 chars
+            preview = source.content[:500]
+            if len(source.content) > 500:
+                preview += "\n... [truncated for display]"
+            console.print(preview)
+
+
+@context_app.command("status")
+def context_status() -> None:
+    """Show context configuration and file availability."""
+    project_root = Path.cwd()
+
+    console.print("[bold]Context Configuration Status[/bold]")
+    console.print("=" * 50)
+
+    # Check config file
+    config_path = project_root / ".doit" / "config" / "context.yaml"
+    console.print(f"\n[bold]Configuration:[/bold]")
+
+    if config_path.exists():
+        console.print(f"  [green]\u2713[/green] Config file: {config_path}")
+        config = ContextConfig.load_from_project(project_root)
+    else:
+        console.print(f"  [dim]\u2717[/dim] Config file: {config_path} [dim](using defaults)[/dim]")
+        config = ContextConfig.load_default()
+
+    # Show source availability
+    console.print(f"\n[bold]Source Files:[/bold]")
+
+    memory_dir = project_root / ".doit" / "memory"
+    specs_dir = project_root / "specs"
+
+    sources = [
+        ("constitution", memory_dir / "constitution.md"),
+        ("roadmap", memory_dir / "roadmap.md"),
+        ("completed_roadmap", memory_dir / "completed_roadmap.md"),
+    ]
+
+    for name, path in sources:
+        source_config = config.get_source_config(name)
+        enabled = source_config.enabled if source_config else True
+
+        if path.exists():
+            if enabled:
+                console.print(f"  [green]\u2713[/green] {name}: {path}")
+            else:
+                console.print(f"  [yellow]\u2713[/yellow] {name}: {path} [dim](disabled)[/dim]")
+        else:
+            console.print(f"  [dim]\u2717[/dim] {name}: {path} [dim](not found)[/dim]")
+
+    # Check specs directory
+    if specs_dir.exists():
+        spec_count = len(list(specs_dir.glob("*/")))
+        console.print(f"  [green]\u2713[/green] specs directory: {spec_count} feature(s)")
+    else:
+        console.print(f"  [dim]\u2717[/dim] specs directory: [dim](not found)[/dim]")
+
+    # Show current branch info
+    console.print(f"\n[bold]Git Branch:[/bold]")
+    loader = ContextLoader(project_root=project_root, config=config)
+    branch = loader.get_current_branch()
+
+    if branch:
+        console.print(f"  Current: {branch}")
+        feature = loader.extract_feature_name(branch)
+        if feature:
+            console.print(f"  Feature: {feature}")
+            spec_path = specs_dir / feature
+            if spec_path.exists():
+                console.print(f"  [green]\u2713[/green] Current spec: {spec_path}")
+            else:
+                console.print(f"  [dim]\u2717[/dim] Current spec: [dim](no matching spec)[/dim]")
+        else:
+            console.print(f"  [dim]Not a feature branch (pattern: NNN-feature-name)[/dim]")
+    else:
+        console.print(f"  [dim]Not in a git repository or git not available[/dim]")
+
+    # Usage hints
+    console.print(f"\n[dim]Use 'doit context show' to see loaded context[/dim]")
+    console.print(f"[dim]Use 'doit context show --command specit' to see command-specific context[/dim]")

doit_cli/cli/diagram_command.py

@@ -0,0 +1,304 @@
+"""CLI commands for diagram generation."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..models.diagram_models import DiagramType
+from ..services.diagram_service import DiagramService
+
+# Create Typer app for diagram subcommands
+app = typer.Typer(
+    name="diagram",
+    help="Generate and validate Mermaid diagrams from specifications",
+    add_completion=False,
+)
+
+console = Console()
+
+
+def _resolve_file_path(file: Optional[Path]) -> Optional[Path]:
+    """Resolve file path, auto-detecting if not provided.
+
+    Args:
+        file: Optional path to spec/plan file
+
+    Returns:
+        Resolved path or None if not found
+    """
+    if file:
+        return file.resolve()
+
+    # Try to auto-detect spec.md in current directory or specs/
+    cwd = Path.cwd()
+
+    # Check current directory
+    if (cwd / "spec.md").exists():
+        return cwd / "spec.md"
+
+    # Check for specs/ directory with current feature
+    specs_dir = cwd / "specs"
+    if specs_dir.exists():
+        # Look for most recently modified spec.md
+        spec_files = list(specs_dir.glob("*/spec.md"))
+        if spec_files:
+            return max(spec_files, key=lambda p: p.stat().st_mtime)
+
+    return None
+
+
+def _parse_diagram_types(type_str: str) -> list[DiagramType]:
+    """Parse diagram type string to list of DiagramType.
+
+    Args:
+        type_str: Type string (user-journey, er-diagram, architecture, all)
+
+    Returns:
+        List of DiagramType values
+    """
+    if type_str == "all":
+        return [DiagramType.USER_JOURNEY, DiagramType.ER_DIAGRAM]
+
+    try:
+        return [DiagramType.from_string(type_str)]
+    except ValueError:
+        return []
+
+
+@app.command(name="generate")
+def generate_command(
+    file: Optional[Path] = typer.Argument(
+        None,
+        help="Path to spec.md or plan.md file",
+        exists=False,
+    ),
+    strict: bool = typer.Option(
+        False,
+        "--strict",
+        "-s",
+        help="Fail on validation errors",
+    ),
+    no_insert: bool = typer.Option(
+        False,
+        "--no-insert",
+        help="Output diagrams without inserting into file",
+    ),
+    diagram_type: str = typer.Option(
+        "all",
+        "--type",
+        "-t",
+        help="Diagram type: user-journey, er-diagram, architecture, all",
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Write diagrams to separate file",
+    ),
+) -> None:
+    """Generate Mermaid diagrams for a specification file.
+
+    If FILE is not provided, auto-detects spec.md in current directory
+    or finds the most recently modified spec in specs/.
+
+    Examples:
+        doit diagram generate
+        doit diagram generate specs/035-feature/spec.md
+        doit diagram generate --type er-diagram --strict
+        doit diagram generate --no-insert --output diagrams.md
+    """
+    # Resolve file path
+    resolved_path = _resolve_file_path(file)
+    if not resolved_path:
+        console.print("[red]Error:[/red] No spec file found. Provide a path or run from a spec directory.")
+        raise typer.Exit(code=1)
+
+    if not resolved_path.exists():
+        console.print(f"[red]Error:[/red] File not found: {resolved_path}")
+        raise typer.Exit(code=1)
+
+    # Parse diagram types
+    types = _parse_diagram_types(diagram_type)
+    if not types and diagram_type != "all":
+        console.print(f"[red]Error:[/red] Unknown diagram type: {diagram_type}")
+        console.print("Valid types: user-journey, er-diagram, architecture, all")
+        raise typer.Exit(code=1)
+
+    console.print(f"Generating diagrams for: [cyan]{resolved_path}[/cyan]")
+    console.print()
+
+    # Create service and generate
+    service = DiagramService(strict=strict, backup=True)
+    result = service.generate(
+        file_path=resolved_path,
+        diagram_types=types if types else None,
+        insert=not no_insert,
+    )
+
+    # Handle errors
+    if not result.success:
+        console.print(f"[red]Error:[/red] {result.error}")
+        raise typer.Exit(code=2 if strict else 1)
+
+    # Display results table
+    if result.diagrams:
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Diagram Type")
+        table.add_column("Status")
+        table.add_column("Nodes")
+
+        for diagram in result.diagrams:
+            status = "[green]✅ Generated[/green]" if diagram.is_valid else "[yellow]⚠️ Generated (warnings)[/yellow]"
+            table.add_row(
+                diagram.diagram_type.value,
+                status,
+                str(diagram.node_count),
+            )
+
+        console.print(table)
+        console.print()
+
+        # Show validation warnings
+        for diagram in result.diagrams:
+            if diagram.validation and diagram.validation.warnings:
+                console.print(f"[yellow]Warnings for {diagram.diagram_type.value}:[/yellow]")
+                for warning in diagram.validation.warnings:
+                    console.print(f"  • {warning}")
+                console.print()
+
+        # Output to file if requested
+        if output:
+            output_content = []
+            for diagram in result.diagrams:
+                output_content.append(f"## {diagram.diagram_type.value}\n")
+                output_content.append(diagram.wrapped_content)
+                output_content.append("\n")
+
+            output.write_text("\n".join(output_content), encoding="utf-8")
+            console.print(f"[green]✅[/green] Diagrams written to: {output}")
+        elif not no_insert and result.sections_updated:
+            console.print(f"[green]✅[/green] Diagrams inserted into {resolved_path.name}")
+            console.print(f"   Sections updated: {', '.join(result.sections_updated)}")
+        elif no_insert:
+            # Print diagram content to stdout
+            for diagram in result.diagrams:
+                console.print(f"\n[bold]## {diagram.diagram_type.value}[/bold]\n")
+                console.print(diagram.wrapped_content)
+    else:
+        console.print("[yellow]No diagrams generated.[/yellow] Check that the spec has User Stories or Key Entities.")
+        raise typer.Exit(code=3)
+
+
+@app.command(name="validate")
+def validate_command(
+    file: Optional[Path] = typer.Argument(
+        None,
+        help="Path to file containing Mermaid diagrams",
+        exists=False,
+    ),
+    strict: bool = typer.Option(
+        False,
+        "--strict",
+        "-s",
+        help="Use stricter validation rules",
+    ),
+) -> None:
+    """Validate Mermaid diagrams in a file.
+
+    Checks all Mermaid code blocks in the file for syntax errors.
+
+    Examples:
+        doit diagram validate spec.md
+        doit diagram validate --strict
+    """
+    import re
+
+    # Resolve file path
+    resolved_path = _resolve_file_path(file)
+    if not resolved_path:
+        console.print("[red]Error:[/red] No file found to validate.")
+        raise typer.Exit(code=2)
+
+    if not resolved_path.exists():
+        console.print(f"[red]Error:[/red] File not found: {resolved_path}")
+        raise typer.Exit(code=2)
+
+    console.print(f"Validating diagrams in: [cyan]{resolved_path}[/cyan]")
+    console.print()
+
+    content = resolved_path.read_text(encoding="utf-8")
+
+    # Find all mermaid code blocks
+    mermaid_pattern = re.compile(r"```mermaid\s*\n(.*?)\n```", re.DOTALL)
+    matches = list(mermaid_pattern.finditer(content))
+
+    if not matches:
+        console.print("[yellow]No Mermaid diagrams found in file.[/yellow]")
+        raise typer.Exit(code=0)
+
+    from ..services.mermaid_validator import MermaidValidator
+
+    validator = MermaidValidator()
+    has_errors = False
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Diagram #")
+    table.add_column("Type")
+    table.add_column("Status")
+    table.add_column("Issues")
+
+    for i, match in enumerate(matches, start=1):
+        diagram_content = match.group(1)
+        result = validator.validate(diagram_content)
+
+        # Determine type
+        if "erDiagram" in diagram_content.lower():
+            diagram_type = "ER Diagram"
+        elif "flowchart" in diagram_content.lower():
+            diagram_type = "Flowchart"
+        else:
+            diagram_type = "Unknown"
+
+        if result.passed and not result.warnings:
+            status = "[green]✅ Valid[/green]"
+            issues = "None"
+        elif result.passed:
+            status = "[yellow]⚠️ Warning[/yellow]"
+            issues = f"{result.warning_count} warnings"
+        else:
+            status = "[red]❌ Invalid[/red]"
+            issues = f"{result.error_count} errors"
+            has_errors = True
+
+        table.add_row(str(i), diagram_type, status, issues)
+
+    console.print(table)
+
+    # Show detailed errors/warnings
+    for i, match in enumerate(matches, start=1):
+        diagram_content = match.group(1)
+        result = validator.validate(diagram_content)
+
+        if result.errors:
+            console.print(f"\n[red]Errors in diagram {i}:[/red]")
+            for error in result.errors:
+                console.print(f"  • {error}")
+
+        if result.warnings:
+            console.print(f"\n[yellow]Warnings in diagram {i}:[/yellow]")
+            for warning in result.warnings:
+                console.print(f"  • {warning}")
+
+    if has_errors:
+        console.print("\n[red]Validation failed.[/red]")
+        raise typer.Exit(code=1)
+    else:
+        console.print("\n[green]All diagrams valid.[/green]")
+        raise typer.Exit(code=0)
+
+
+# Export the app for registration
+diagram_app = app