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

doit_cli/cli/memory_command.py

@@ -0,0 +1,293 @@
+"""CLI commands for memory search and query functionality.
+
+This module provides the `doit memory` subcommand group for searching
+across project context files.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..models.search_models import QueryType, SourceFilter
+from ..services.memory_search import MemorySearchService
+
+# Create the memory app
+memory_app = typer.Typer(
+    name="memory",
+    help="Search and query project memory (constitution, roadmap, specs)",
+    add_completion=False,
+)
+
+console = Console()
+
+
+def get_project_root() -> Path:
+    """Get the project root directory.
+
+    Walks up from current directory looking for .doit directory.
+
+    Returns:
+        Path to project root.
+
+    Raises:
+        typer.Exit: If no .doit directory found.
+    """
+    current = Path.cwd()
+    for parent in [current] + list(current.parents):
+        if (parent / ".doit").is_dir():
+            return parent
+
+    console.print(
+        "[red]Error:[/red] Not in a doit project. "
+        "Run 'doit init' to initialize."
+    )
+    raise typer.Exit(1)
+
+
+@memory_app.command(name="search")
+def search_command(
+    query: str = typer.Argument(
+        ...,
+        help="Search term, phrase, or natural language question",
+    ),
+    query_type: str = typer.Option(
+        "keyword",
+        "--type",
+        "-t",
+        help="Query type: keyword, phrase, natural, regex",
+    ),
+    source: str = typer.Option(
+        "all",
+        "--source",
+        "-s",
+        help="Source filter: all, governance, specs",
+    ),
+    max_results: int = typer.Option(
+        20,
+        "--max",
+        "-m",
+        help="Maximum results to return (1-100)",
+    ),
+    case_sensitive: bool = typer.Option(
+        False,
+        "--case-sensitive",
+        "-c",
+        help="Enable case-sensitive matching",
+    ),
+    use_regex: bool = typer.Option(
+        False,
+        "--regex",
+        "-r",
+        help="Interpret query as regular expression",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output results as JSON",
+    ),
+):
+    """Search across project memory files.
+
+    Search the constitution, roadmap, and spec files for keywords,
+    phrases, or ask natural language questions.
+
+    Examples:
+        doit memory search authentication
+        doit memory search -t phrase "user story"
+        doit memory search -t natural "what is the project vision?"
+        doit memory search -s specs "FR-001"
+    """
+    project_root = get_project_root()
+
+    # Validate and convert query type
+    try:
+        qt = QueryType(query_type.lower())
+    except ValueError:
+        console.print(
+            f"[red]Error:[/red] Invalid query type '{query_type}'. "
+            "Use: keyword, phrase, natural, regex"
+        )
+        raise typer.Exit(1)
+
+    # If regex flag is set, override query type
+    if use_regex:
+        qt = QueryType.REGEX
+
+    # Validate and convert source filter
+    try:
+        sf = SourceFilter(source.lower())
+    except ValueError:
+        console.print(
+            f"[red]Error:[/red] Invalid source filter '{source}'. "
+            "Use: all, governance, specs"
+        )
+        raise typer.Exit(1)
+
+    # Validate max results
+    if not 1 <= max_results <= 100:
+        console.print(
+            "[red]Error:[/red] Max results must be between 1 and 100"
+        )
+        raise typer.Exit(1)
+
+    # Create service and search
+    service = MemorySearchService(project_root, console)
+
+    start_time = time.time()
+    try:
+        results, sources, search_query = service.search(
+            query_text=query,
+            query_type=qt,
+            source_filter=sf,
+            max_results=max_results,
+            case_sensitive=case_sensitive,
+            use_regex=use_regex,
+        )
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(3)
+
+    execution_time_ms = int((time.time() - start_time) * 1000)
+
+    # Output results
+    if json_output:
+        output = service.format_results_json(
+            results, sources, search_query, execution_time_ms
+        )
+        console.print_json(json.dumps(output, indent=2))
+        return
+
+    # Rich output
+    if not results:
+        console.print("\n[yellow]No results found.[/yellow]")
+        console.print(
+            f"\nSearched {len(sources)} files in {execution_time_ms}ms"
+        )
+        return
+
+    # Header
+    console.print()
+    console.print("[bold]Memory Search Results[/bold]")
+    console.print()
+
+    # Show interpretation info for natural language queries
+    if qt == QueryType.NATURAL and hasattr(search_query, "_interpreted"):
+        interpreted = search_query._interpreted
+        console.print(f'Query: "{query}" ({qt.value})')
+        console.print(f"  ↳ Type: {interpreted.question_type.value}")
+        console.print(f"  ↳ Keywords: {', '.join(interpreted.keywords[:5])}")
+        if interpreted.section_hints:
+            console.print(f"  ↳ Sections: {', '.join(interpreted.section_hints[:3])}")
+        console.print(f"  ↳ Confidence: {interpreted.confidence:.0%}")
+    else:
+        console.print(f'Query: "{query}" ({qt.value})')
+
+    console.print(
+        f"Sources: {sf.value} | Found: {len(results)} results"
+    )
+    console.print()
+
+    # Display results
+    source_map = {s.id: s for s in sources}
+    for result in results:
+        panel = service.format_result_rich(result, source_map, query)
+        console.print(panel)
+        console.print()
+
+    # Footer
+    console.print(
+        f"Searched {len(sources)} files in {execution_time_ms}ms"
+    )
+
+
+@memory_app.command(name="history")
+def history_command(
+    clear: bool = typer.Option(
+        False,
+        "--clear",
+        "-c",
+        help="Clear search history",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        "-j",
+        help="Output history as JSON",
+    ),
+):
+    """View or clear search history.
+
+    Shows recent searches from the current session.
+
+    Examples:
+        doit memory history
+        doit memory history --clear
+        doit memory history --json
+    """
+    project_root = get_project_root()
+    service = MemorySearchService(project_root, console)
+
+    if clear:
+        service.clear_history()
+        console.print("[green]Search history cleared.[/green]")
+        return
+
+    history = service.get_history()
+    entries = history.get_recent(10)
+
+    if json_output:
+        output = {
+            "session_id": history.session_id,
+            "session_start": history.session_start.isoformat(),
+            "entries": [
+                {
+                    "query_text": q.query_text,
+                    "query_type": q.query_type.value,
+                    "timestamp": q.timestamp.isoformat(),
+                }
+                for q in entries
+            ],
+            "total_entries": len(history.entries),
+        }
+        console.print_json(json.dumps(output, indent=2))
+        return
+
+    if not entries:
+        console.print("\n[yellow]No search history.[/yellow]")
+        console.print(
+            "\nRun 'doit memory search <query>' to start searching."
+        )
+        return
+
+    console.print()
+    console.print("[bold]Search History (Session)[/bold]")
+    console.print()
+    console.print(f"Started: {history.session_start.strftime('%Y-%m-%d %H:%M:%S')}")
+    console.print()
+
+    # Create table
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("#", justify="right", width=3)
+    table.add_column("Time", width=10)
+    table.add_column("Query", width=30)
+    table.add_column("Type", width=10)
+
+    for i, entry in enumerate(entries, 1):
+        time_str = entry.timestamp.strftime("%H:%M:%S")
+        query_display = entry.query_text[:27] + "..." if len(entry.query_text) > 30 else entry.query_text
+        table.add_row(
+            str(i),
+            time_str,
+            query_display,
+            entry.query_type.value,
+        )
+
+    console.print(table)
+    console.print()
+    console.print(f"{len(history.entries)} queries this session")

doit_cli/cli/status_command.py

@@ -0,0 +1,117 @@
+"""Status command for displaying spec status dashboard."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..formatters.json_formatter import JsonFormatter
+from ..formatters.markdown_formatter import MarkdownFormatter
+from ..formatters.rich_formatter import RichFormatter
+from ..models.status_models import SpecState
+from ..services.spec_scanner import NotADoitProjectError
+from ..services.status_reporter import StatusReporter
+
+console = Console()
+
+# Valid status filter values
+VALID_STATUSES = ["draft", "in-progress", "complete", "approved"]
+
+
+def status_command(
+    status_filter: Optional[str] = typer.Option(
+        None,
+        "--status",
+        "-s",
+        help="Filter by status (draft, in-progress, complete, approved)",
+    ),
+    blocking: bool = typer.Option(
+        False, "--blocking", "-b", help="Show only blocking specs"
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Show detailed validation errors"
+    ),
+    recent: Optional[int] = typer.Option(
+        None, "--recent", "-r", help="Show specs modified in last N days"
+    ),
+    output_format: str = typer.Option(
+        "rich", "--format", "-f", help="Output format: rich, json, markdown"
+    ),
+    output_file: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Write report to file"
+    ),
+) -> None:
+    """Display status of all specifications in the project.
+
+    Shows a dashboard of all specs with their status, validation results,
+    and commit blocking indicators.
+
+    Exit codes:
+      0 - Success, no blocking specs
+      1 - Success, but blocking specs exist
+      2 - Error (not a doit project, invalid options)
+    """
+    try:
+        # Validate status filter
+        spec_state_filter = None
+        if status_filter:
+            status_lower = status_filter.lower()
+            if status_lower not in VALID_STATUSES:
+                console.print(
+                    f"[red]Error:[/red] Invalid status '{status_filter}'. "
+                    f"Valid: {', '.join(VALID_STATUSES)}"
+                )
+                raise typer.Exit(code=2)
+            spec_state_filter = SpecState.from_string(status_lower)
+
+        # Validate format
+        valid_formats = ["rich", "json", "markdown"]
+        if output_format not in valid_formats:
+            console.print(
+                f"[red]Error:[/red] Invalid format '{output_format}'. "
+                f"Valid: {', '.join(valid_formats)}"
+            )
+            raise typer.Exit(code=2)
+
+        # Initialize reporter
+        reporter = StatusReporter()
+
+        # Generate report with filters
+        report = reporter.generate_report(
+            status_filter=spec_state_filter,
+            blocking_only=blocking,
+            recent_days=recent,
+        )
+
+        # Select formatter based on format option
+        if output_format == "json":
+            formatter = JsonFormatter()
+        elif output_format == "markdown":
+            formatter = MarkdownFormatter()
+        else:
+            formatter = RichFormatter(console)
+
+        # Generate formatted output
+        output_str = formatter.format(report, verbose=verbose)
+
+        # Handle output destination
+        if output_file:
+            output_file.write_text(output_str)
+            console.print(f"[green]Report written to {output_file}[/green]")
+        elif output_format == "rich":
+            # Rich formatter should print directly for better terminal rendering
+            RichFormatter(console).format_to_console(report, verbose=verbose)
+        else:
+            # JSON and Markdown output to stdout - use print() for raw output
+            print(output_str)
+
+        # Determine exit code based on blocking status
+        if report.blocking_count > 0:
+            raise typer.Exit(code=1)
+        else:
+            raise typer.Exit(code=0)
+
+    except NotADoitProjectError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(code=2)

doit_cli/cli/sync_prompts_command.py

@@ -0,0 +1,248 @@
+"""Sync-prompts command for synchronizing GitHub Copilot prompts with doit commands."""
+
+import json
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..models.sync_models import OperationType, SyncResult
+from ..services.prompt_writer import PromptWriter
+from ..services.template_reader import TemplateReader
+
+
+console = Console()
+
+# Type aliases for CLI options
+JsonFlag = Annotated[
+    bool,
+    typer.Option(
+        "--json", "-j",
+        help="Output results as JSON"
+    )
+]
+
+CheckFlag = Annotated[
+    bool,
+    typer.Option(
+        "--check", "-c",
+        help="Check sync status without making changes"
+    )
+]
+
+ForceFlag = Annotated[
+    bool,
+    typer.Option(
+        "--force", "-f",
+        help="Force sync even if files are up-to-date"
+    )
+]
+
+
+def get_operation_style(operation_type: OperationType) -> str:
+    """Get rich style for operation type."""
+    styles = {
+        OperationType.CREATED: "green",
+        OperationType.UPDATED: "yellow",
+        OperationType.SKIPPED: "dim",
+        OperationType.FAILED: "red",
+    }
+    return styles.get(operation_type, "white")
+
+
+def get_operation_symbol(operation_type: OperationType) -> str:
+    """Get symbol for operation type."""
+    symbols = {
+        OperationType.CREATED: "+",
+        OperationType.UPDATED: "~",
+        OperationType.SKIPPED: "-",
+        OperationType.FAILED: "✗",
+    }
+    return symbols.get(operation_type, "?")
+
+
+def display_sync_result(result: SyncResult) -> None:
+    """Display sync result with rich formatting.
+
+    Args:
+        result: The sync result to display.
+    """
+    if not result.operations:
+        console.print("[yellow]No command templates found to sync.[/yellow]")
+        return
+
+    # Create table
+    table = Table(
+        show_header=True,
+        header_style="bold cyan",
+        title="Prompt Synchronization Results",
+    )
+    table.add_column("Status", width=10, justify="center")
+    table.add_column("File", width=40)
+    table.add_column("Message")
+
+    for op in result.operations:
+        style = get_operation_style(op.operation_type)
+        symbol = get_operation_symbol(op.operation_type)
+        status_text = f"[{style}]{symbol} {op.operation_type.value.upper()}[/{style}]"
+
+        # Show just the filename, not full path
+        filename = Path(op.file_path).name
+
+        table.add_row(
+            status_text,
+            filename,
+            op.message,
+        )
+
+    console.print()
+    console.print(table)
+
+    # Summary
+    console.print()
+    console.print(
+        f"[bold]Summary:[/bold] "
+        f"{result.total_commands} commands, "
+        f"[green]{result.synced} synced[/green], "
+        f"[dim]{result.skipped} skipped[/dim], "
+        f"[red]{result.failed} failed[/red]"
+    )
+
+    # Final status
+    console.print()
+    if result.success:
+        if result.synced > 0:
+            console.print("[bold green]Prompts synchronized successfully[/bold green]")
+        else:
+            console.print("[green]All prompts are up-to-date[/green]")
+    else:
+        console.print("[bold red]Some prompts failed to sync[/bold red]")
+
+
+def display_json_result(result: SyncResult) -> None:
+    """Display sync result as JSON.
+
+    Args:
+        result: The sync result to display.
+    """
+    output = {
+        "total_commands": result.total_commands,
+        "synced": result.synced,
+        "skipped": result.skipped,
+        "failed": result.failed,
+        "success": result.success,
+        "operations": [
+            {
+                "file_path": op.file_path,
+                "operation_type": op.operation_type.value,
+                "success": op.success,
+                "message": op.message,
+            }
+            for op in result.operations
+        ],
+    }
+    # Use print() instead of console.print() to avoid Rich's line wrapping
+    print(json.dumps(output, indent=2))
+
+
+def sync_prompts_command(
+    command_name: Annotated[
+        Optional[str],
+        typer.Argument(
+            help="Specific command to sync (e.g., 'doit.checkin')"
+        )
+    ] = None,
+    check: CheckFlag = False,
+    force: ForceFlag = False,
+    json_output: JsonFlag = False,
+    path: Annotated[
+        Path,
+        typer.Option(
+            "--path", "-p",
+            help="Project directory path"
+        )
+    ] = Path("."),
+) -> None:
+    """Synchronize GitHub Copilot prompts with doit command templates.
+
+    Reads command templates from .doit/templates/commands/ and generates
+    corresponding prompt files in .github/prompts/ with naming convention
+    doit.<name>.prompt.md.
+
+    Examples:
+        doit sync-prompts                     # Sync all commands
+        doit sync-prompts doit.checkin        # Sync specific command
+        doit sync-prompts --check             # Check sync status only
+        doit sync-prompts --force             # Force re-sync all
+        doit sync-prompts --json              # Output as JSON
+    """
+    project_root = path.resolve()
+
+    # Initialize services
+    reader = TemplateReader(project_root=project_root)
+    writer = PromptWriter(project_root=project_root)
+
+    # Read templates
+    templates = reader.scan_templates(filter_name=command_name)
+
+    if not templates:
+        if command_name:
+            msg = f"Command template '{command_name}' not found"
+        else:
+            msg = "No command templates found in .doit/templates/commands/"
+
+        if json_output:
+            console.print(json.dumps({"error": msg}))
+        else:
+            console.print(f"[red]Error:[/red] {msg}")
+        raise typer.Exit(1)
+
+    # Check mode - just report status without making changes
+    if check:
+        result = SyncResult(total_commands=len(templates))
+        for template in templates:
+            prompt_path = writer.get_prompt_path(template)
+
+            if not prompt_path.exists():
+                from ..models.sync_models import FileOperation
+                result.add_operation(FileOperation(
+                    file_path=str(prompt_path),
+                    operation_type=OperationType.FAILED,
+                    success=False,
+                    message="Missing - needs sync",
+                ))
+            else:
+                prompt_mtime = prompt_path.stat().st_mtime
+                template_mtime = template.modified_at.timestamp()
+
+                if prompt_mtime < template_mtime:
+                    from ..models.sync_models import FileOperation
+                    result.add_operation(FileOperation(
+                        file_path=str(prompt_path),
+                        operation_type=OperationType.UPDATED,
+                        success=True,
+                        message="Out-of-sync - needs update",
+                    ))
+                else:
+                    from ..models.sync_models import FileOperation
+                    result.add_operation(FileOperation(
+                        file_path=str(prompt_path),
+                        operation_type=OperationType.SKIPPED,
+                        success=True,
+                        message="Up-to-date",
+                    ))
+    else:
+        # Perform actual sync
+        result = writer.write_prompts(templates, force=force)
+
+    # Display results
+    if json_output:
+        display_json_result(result)
+    else:
+        display_sync_result(result)
+
+    # Exit with appropriate code
+    if not result.success:
+        raise typer.Exit(1)