spec-kitty-cli 0.12.1__py3-none-any.whl

specify_cli/cli/commands/mission.py

@@ -0,0 +1,240 @@
+"""Mission management CLI commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+import typer
+from rich.panel import Panel
+from rich.table import Table
+
+from specify_cli.cli.helpers import check_version_compatibility, console, get_project_root_or_exit
+from specify_cli.mission import (
+    Mission,
+    MissionError,
+    MissionNotFoundError,
+    discover_missions,
+    get_active_mission,
+    get_mission_by_name,
+    list_available_missions,
+)
+
+app = typer.Typer(
+    name="mission",
+    help="View available Spec Kitty missions. Missions are selected per-feature during /spec-kitty.specify.",
+    no_args_is_help=True,
+)
+
+
+def _resolve_primary_repo_root(project_root: Path) -> Path:
+    """Return the primary repository root even when invoked from a worktree."""
+    resolved = project_root.resolve()
+    parts = list(resolved.parts)
+    if ".worktrees" not in parts:
+        return resolved
+
+    idx = parts.index(".worktrees")
+    # Rebuild the path up to (but excluding) ".worktrees"
+    base = Path(parts[0])
+    for segment in parts[1:idx]:
+        base /= segment
+    return base
+
+
+def _list_active_worktrees(repo_root: Path) -> List[str]:
+    """Return list of active worktree directories relative to the repo root."""
+    worktrees_dir = repo_root / ".worktrees"
+    if not worktrees_dir.exists():
+        return []
+
+    active: List[str] = []
+    for entry in sorted(worktrees_dir.iterdir()):
+        if not entry.is_dir():
+            continue
+        try:
+            rel = entry.relative_to(repo_root)
+        except ValueError:
+            rel = entry
+        active.append(str(rel))
+    return active
+
+
+def _mission_details_lines(mission: Mission, include_description: bool = True) -> List[str]:
+    """Return formatted mission details."""
+    details: List[str] = [
+        f"[cyan]Name:[/cyan] {mission.name}",
+        f"[cyan]Domain:[/cyan] {mission.domain}",
+        f"[cyan]Version:[/cyan] {mission.version}",
+        f"[cyan]Path:[/cyan] {mission.path}",
+    ]
+    if include_description and mission.description:
+        details.append(f"[cyan]Description:[/cyan] {mission.description}")
+    details.extend(["", "[cyan]Workflow Phases:[/cyan]"])
+    for phase in mission.config.workflow.phases:
+        details.append(f"  • {phase.name} – {phase.description}")
+
+    details.extend(["", "[cyan]Required Artifacts:[/cyan]"])
+    if mission.config.artifacts.required:
+        for artifact in mission.config.artifacts.required:
+            details.append(f"  • {artifact}")
+    else:
+        details.append("  • (none)")
+
+    if mission.config.artifacts.optional:
+        details.extend(["", "[cyan]Optional Artifacts:[/cyan]"])
+        for artifact in mission.config.artifacts.optional:
+            details.append(f"  • {artifact}")
+
+    details.extend(["", "[cyan]Validation Checks:[/cyan]"])
+    if mission.config.validation.checks:
+        for check in mission.config.validation.checks:
+            details.append(f"  • {check}")
+    else:
+        details.append("  • (none)")
+
+    if mission.config.paths:
+        details.extend(["", "[cyan]Path Conventions:[/cyan]"])
+        for key, value in mission.config.paths.items():
+            details.append(f"  • {key}: {value}")
+
+    if mission.config.mcp_tools:
+        details.extend(["", "[cyan]MCP Tools:[/cyan]"])
+        details.append(f"  • Required: {', '.join(mission.config.mcp_tools.required) or 'none'}")
+        details.append(f"  • Recommended: {', '.join(mission.config.mcp_tools.recommended) or 'none'}")
+        details.append(f"  • Optional: {', '.join(mission.config.mcp_tools.optional) or 'none'}")
+
+    return details
+
+
+def _print_available_missions(project_root: Path) -> None:
+    """Print available missions with source indicators (project/built-in)."""
+    missions = discover_missions(project_root)
+    if not missions:
+        console.print("[yellow]No missions found in .kittify/missions/[/yellow]")
+        return
+
+    table = Table(title="Available Missions", show_header=True)
+    table.add_column("Key", style="cyan")
+    table.add_column("Name", style="green")
+    table.add_column("Domain", style="magenta")
+    table.add_column("Description", overflow="fold")
+    table.add_column("Source", style="dim")
+
+    for key, (mission, source) in sorted(missions.items()):
+        table.add_row(
+            key,
+            mission.name,
+            mission.domain,
+            mission.description or "",
+            source,
+        )
+
+    console.print(table)
+    console.print()
+    console.print("[dim]Missions are selected per-feature during /spec-kitty.specify[/dim]")
+
+
+@app.command("list")
+def list_cmd() -> None:
+    """List all available missions with their source (project/built-in)."""
+    project_root = get_project_root_or_exit()
+    check_version_compatibility(project_root, "mission")
+    kittify_dir = project_root / ".kittify"
+    if not kittify_dir.exists():
+        console.print(f"[red]Spec Kitty project not initialized at:[/red] {project_root}")
+        console.print("[dim]Run 'spec-kitty init <project-name>' or execute this command from a feature worktree created under .worktrees/<feature>/.[/dim]")
+        raise typer.Exit(1)
+
+    try:
+        _print_available_missions(project_root)
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        console.print(f"[red]Error listing missions:[/red] {exc}")
+        raise typer.Exit(1)
+
+
+@app.command("current")
+def current_cmd() -> None:
+    """Show currently active mission."""
+    project_root = get_project_root_or_exit()
+    check_version_compatibility(project_root, "mission")
+    try:
+        mission = get_active_mission(project_root)
+    except MissionNotFoundError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+    except MissionError as exc:
+        console.print(f"[red]Failed to load active mission:[/red] {exc}")
+        raise typer.Exit(1)
+
+    panel = Panel(
+        "\n".join(_mission_details_lines(mission)),
+        title="Active Mission",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+
+@app.command("info")
+def info_cmd(
+    mission_name: str = typer.Argument(..., help="Mission name to display details for"),
+) -> None:
+    """Show details for a specific mission without switching."""
+    project_root = get_project_root_or_exit()
+    check_version_compatibility(project_root, "mission")
+    kittify_dir = project_root / ".kittify"
+
+    try:
+        mission = get_mission_by_name(mission_name, kittify_dir)
+    except MissionNotFoundError:
+        console.print(f"[red]Mission not found:[/red] {mission_name}")
+        available = list_available_missions(kittify_dir)
+        if available:
+            console.print("\n[yellow]Available missions:[/yellow]")
+            for name in available:
+                console.print(f"  • {name}")
+        raise typer.Exit(1)
+    except MissionError as exc:
+        console.print(f"[red]Error loading mission '{mission_name}':[/red] {exc}")
+        raise typer.Exit(1)
+
+    panel = Panel(
+        "\n".join(_mission_details_lines(mission, include_description=True)),
+        title=f"Mission Details · {mission.name}",
+        border_style="cyan",
+    )
+    console.print(panel)
+
+
+def _print_active_worktrees(active_worktrees: Iterable[str]) -> None:
+    console.print("[red]Cannot switch missions: active features exist[/red]")
+    console.print("\n[yellow]Active worktrees:[/yellow]")
+    for wt in active_worktrees:
+        console.print(f"  • {wt}")
+    console.print(
+        "\n[cyan]Suggestion:[/cyan] Complete, merge, or remove these worktrees before switching missions."
+    )
+
+
+@app.command("switch", deprecated=True)
+def switch_cmd(
+    mission_name: str = typer.Argument(..., help="Mission name (no longer supported)"),
+    force: bool = typer.Option(False, "--force", help="(ignored)"),
+) -> None:
+    """[REMOVED] Switch active mission - this command was removed in v0.8.0."""
+    console.print("[bold red]Error:[/bold red] The 'mission switch' command was removed in v0.8.0.")
+    console.print()
+    console.print("Missions are now selected [bold]per-feature[/bold] during [cyan]/spec-kitty.specify[/cyan].")
+    console.print()
+    console.print("[cyan]New workflow:[/cyan]")
+    console.print("  1. Run [bold]/spec-kitty.specify[/bold] to start a new feature")
+    console.print("  2. The system will infer and confirm the appropriate mission")
+    console.print("  3. Mission is stored in the feature's [dim]meta.json[/dim]")
+    console.print()
+    console.print("[cyan]To see available missions:[/cyan]")
+    console.print("  spec-kitty mission list")
+    console.print()
+    console.print("[dim]See: https://github.com/your-org/spec-kitty#per-feature-missions[/dim]")
+    raise typer.Exit(1)

specify_cli/cli/commands/ops.py

@@ -0,0 +1,265 @@
+"""Ops command - operation history and undo functionality.
+
+This command provides access to VCS operation history and undo capabilities.
+For jj, this leverages the full operation log with undo support.
+For git, this provides read-only access to the reflog.
+
+Key differences:
+- jj: Full operation log with complete undo capability
+- git: Reflog as read-only operation history (no undo)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from specify_cli.core.vcs import (
+    OperationInfo,
+    VCSBackend,
+    get_vcs,
+)
+
+app = typer.Typer(
+    name="ops",
+    help="Operation history and undo (jj: full undo, git: reflog only)",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+def _display_operations(ops: list[OperationInfo], backend: VCSBackend) -> None:
+    """Display operation history in a formatted table.
+
+    Args:
+        ops: List of operations to display
+        backend: VCS backend (affects column display)
+    """
+    if not ops:
+        console.print("[dim]No operations found[/dim]")
+        return
+
+    backend_label = "jj" if backend == VCSBackend.JUJUTSU else "git reflog"
+    table = Table(title=f"Operation History ({backend_label})")
+
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Time", style="dim")
+    table.add_column("Description")
+
+    if backend == VCSBackend.JUJUTSU:
+        table.add_column("Undoable", style="green", justify="center")
+
+    for op in ops:
+        # Truncate operation ID for display
+        short_id = op.operation_id[:12] if len(op.operation_id) > 12 else op.operation_id
+
+        # Format timestamp
+        time_str = op.timestamp.strftime("%Y-%m-%d %H:%M")
+
+        # Truncate description if too long
+        desc = op.description[:60] + "..." if len(op.description) > 60 else op.description
+
+        row = [short_id, time_str, desc]
+
+        if backend == VCSBackend.JUJUTSU:
+            row.append("✓" if op.is_undoable else "")
+
+        table.add_row(*row)
+
+    console.print(table)
+
+
+@app.command()
+def log(
+    limit: int = typer.Option(
+        20,
+        "--limit",
+        "-n",
+        help="Number of operations to show",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show full operation IDs and details",
+    ),
+) -> None:
+    """Show operation history.
+
+    For jj workspaces, shows the operation log with undo information.
+    For git workspaces, shows the reflog (read-only history).
+
+    Examples:
+        # Show recent operations
+        spec-kitty ops log
+
+        # Show last 5 operations
+        spec-kitty ops log --limit 5
+
+        # Show with full details
+        spec-kitty ops log --verbose
+    """
+    workspace_path = Path.cwd()
+
+    # Get VCS implementation
+    try:
+        vcs = get_vcs(workspace_path)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] Failed to detect VCS: {e}")
+        raise typer.Exit(1)
+
+    console.print(f"\n[cyan]Backend:[/cyan] git")
+    console.print()
+
+    # Get operation history (git reflog only)
+    from specify_cli.core.vcs.git import git_get_reflog
+
+    ops = git_get_reflog(workspace_path, limit=limit)
+
+    _display_operations(ops, vcs.backend)
+
+    if verbose and ops:
+        console.print("\n[dim]Full operation IDs:[/dim]")
+        for op in ops[:5]:  # Show first 5 full IDs
+            console.print(f"  {op.operation_id}")
+
+    console.print()
+
+
+@app.command()
+def undo(
+    operation_id: str = typer.Argument(
+        None,
+        help="Operation ID to undo (jj only, defaults to last operation)",
+    ),
+) -> None:
+    """Undo last operation (jj only).
+
+    Reverts the repository to the state before the last operation.
+    This is only supported for jj workspaces - git does not have
+    reversible operation history.
+
+    Examples:
+        # Undo last operation
+        spec-kitty ops undo
+
+        # Undo specific operation
+        spec-kitty ops undo abc123def456
+    """
+    workspace_path = Path.cwd()
+
+    # Get VCS implementation
+    try:
+        vcs = get_vcs(workspace_path)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] Failed to detect VCS: {e}")
+        raise typer.Exit(1)
+
+    # Capability check - undo only supported for jj
+    if not vcs.capabilities.supports_operation_undo:
+        console.print(f"\n[red]✗ Undo not supported for {vcs.backend.value}[/red]")
+        console.print()
+        console.print("[dim]Git does not have reversible operation history.[/dim]")
+        console.print("[dim]Consider using these alternatives manually:[/dim]")
+        console.print("  • git reset --soft HEAD~1  (undo last commit, keep changes)")
+        console.print("  • git reset --hard HEAD~1  (undo last commit, discard changes)")
+        console.print("  • git revert <commit>      (create reverting commit)")
+        console.print("  • git reflog               (find previous states)")
+        console.print()
+        raise typer.Exit(1)
+
+    # jj undo
+    console.print("\n[cyan]Undoing operation...[/cyan]")
+
+    from specify_cli.core.vcs.jujutsu import jj_undo_operation
+
+    success = jj_undo_operation(workspace_path, operation_id)
+
+    if success:
+        console.print("[green]✓ Operation undone successfully[/green]")
+        console.print()
+        console.print("[dim]Use 'spec-kitty ops log' to see the updated history.[/dim]")
+    else:
+        console.print("[red]✗ Undo failed[/red]")
+        console.print()
+        console.print("[dim]Try these commands to debug:[/dim]")
+        console.print("  jj op log          # View operation history")
+        console.print("  jj status          # Check current state")
+        raise typer.Exit(1)
+
+    console.print()
+
+
+@app.command()
+def restore(
+    operation_id: str = typer.Argument(
+        ...,
+        help="Operation ID to restore to (jj only)",
+    ),
+) -> None:
+    """Restore to a specific operation (jj only).
+
+    Restores the repository to the exact state at a specific operation.
+    This is more powerful than undo - it can jump to any point in history.
+
+    Examples:
+        # Restore to specific operation
+        spec-kitty ops restore abc123def456
+    """
+    workspace_path = Path.cwd()
+
+    # Get VCS implementation
+    try:
+        vcs = get_vcs(workspace_path)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] Failed to detect VCS: {e}")
+        raise typer.Exit(1)
+
+    # Capability check - restore only supported for jj
+    if not vcs.capabilities.supports_operation_undo:
+        console.print(f"\n[red]✗ Restore not supported for {vcs.backend.value}[/red]")
+        console.print()
+        console.print("[dim]Git does not support operation-level restore.[/dim]")
+        console.print("[dim]Consider using these alternatives:[/dim]")
+        console.print("  • git checkout <commit>    (detached HEAD)")
+        console.print("  • git reset --hard <commit>(destructive)")
+        console.print()
+        raise typer.Exit(1)
+
+    # jj restore
+    console.print(f"\n[cyan]Restoring to operation {operation_id[:12]}...[/cyan]")
+
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            ["jj", "op", "restore", operation_id],
+            cwd=workspace_path,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=60,
+        )
+
+        if result.returncode == 0:
+            console.print("[green]✓ Restored successfully[/green]")
+            console.print()
+            console.print("[dim]Use 'spec-kitty ops log' to see the updated history.[/dim]")
+        else:
+            console.print("[red]✗ Restore failed[/red]")
+            if result.stderr:
+                console.print(f"[dim]{result.stderr.strip()}[/dim]")
+            raise typer.Exit(1)
+
+    except subprocess.TimeoutExpired:
+        console.print("[red]✗ Restore timed out[/red]")
+        raise typer.Exit(1)
+    except FileNotFoundError:
+        console.print("[red]✗ jj command not found[/red]")
+        raise typer.Exit(1)
+
+    console.print()