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

specify_cli/cli/commands/accept.py

@@ -0,0 +1,189 @@
+"""Accept command implementation."""
+
+from __future__ import annotations
+
+import json
+from typing import List, Optional
+
+import typer
+from rich.table import Table
+
+from specify_cli.acceptance import (
+    AcceptanceError,
+    AcceptanceResult,
+    AcceptanceSummary,
+    choose_mode,
+    collect_feature_summary,
+    detect_feature_slug,
+    perform_acceptance,
+)
+from specify_cli.cli import StepTracker
+from specify_cli.cli.helpers import check_version_compatibility, console, show_banner
+from specify_cli.tasks_support import LANES, TaskCliError, find_repo_root
+
+
+def _print_acceptance_summary(summary: AcceptanceSummary) -> None:
+    table = Table(title="Work Packages by Lane", header_style="cyan")
+    table.add_column("Lane")
+    table.add_column("Count", justify="right")
+    table.add_column("Work Packages", justify="left")
+    for lane in LANES:
+        items = summary.lanes.get(lane, [])
+        display = ", ".join(items) if items else "-"
+        table.add_row(lane, str(len(items)), display)
+    console.print(table)
+
+    outstanding = summary.outstanding()
+    if outstanding:
+        console.print("\n[bold red]Outstanding items[/bold red]")
+        for key, values in outstanding.items():
+            console.print(f"[red]- {key}[/red]")
+            for value in values:
+                console.print(f"    • {value}")
+    else:
+        console.print("\n[green]No outstanding acceptance issues detected.[/green]")
+
+    if summary.optional_missing:
+        console.print(
+            "\n[yellow]Optional artifacts missing:[/yellow] "
+            + ", ".join(summary.optional_missing)
+        )
+        console.print()
+
+
+def _print_acceptance_result(result: AcceptanceResult) -> None:
+    console.print(
+        "\n[bold]Acceptance metadata[/bold]\n"
+        f"• Feature: {result.summary.feature}\n"
+        f"• Accepted at: {result.accepted_at}\n"
+        f"• Accepted by: {result.accepted_by}"
+    )
+    if result.accept_commit:
+        console.print(f"• Acceptance commit: {result.accept_commit}")
+    if result.parent_commit:
+        console.print(f"• Parent commit: {result.parent_commit}")
+    if not result.commit_created:
+        console.print("• Commit status: no changes were committed (dry-run)")
+
+    if result.instructions:
+        console.print("\n[bold]Next steps[/bold]")
+        for idx, instruction in enumerate(result.instructions, start=1):
+            console.print(f"  {idx}. {instruction}")
+
+    if result.cleanup_instructions:
+        console.print("\n[bold]Cleanup[/bold]")
+        for idx, instruction in enumerate(result.cleanup_instructions, start=1):
+            console.print(f"  {idx}. {instruction}")
+
+    if result.notes:
+        console.print("\n[bold]Notes[/bold]")
+        for note in result.notes:
+            console.print(f"  - {note}")
+
+
+def accept(
+    feature: Optional[str] = typer.Option(None, "--feature", help="Feature slug to accept (auto-detected by default)"),
+    mode: str = typer.Option("auto", "--mode", case_sensitive=False, help="Acceptance mode: auto, pr, local, or checklist"),
+    actor: Optional[str] = typer.Option(None, "--actor", help="Name to record as the acceptance actor"),
+    test: List[str] = typer.Option([], "--test", help="Validation command executed (repeatable)", show_default=False),
+    json_output: bool = typer.Option(False, "--json", help="Emit JSON instead of formatted text"),
+    lenient: bool = typer.Option(False, "--lenient", help="Skip strict metadata validation"),
+    no_commit: bool = typer.Option(False, "--no-commit", help="Skip auto-commit; report only"),
+    allow_fail: bool = typer.Option(False, "--allow-fail", help="Return checklist even when issues remain"),
+) -> None:
+    """Validate feature readiness before merging to main."""
+
+    show_banner()
+
+    try:
+        repo_root = find_repo_root()
+    except TaskCliError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+    check_version_compatibility(repo_root, "accept")
+
+    tracker = StepTracker("Feature Acceptance")
+    tracker.add("detect", "Identify feature slug")
+    tracker.add("verify", "Run readiness checks")
+    console.print()
+
+    tracker.start("detect")
+    try:
+        feature_slug = (feature or detect_feature_slug(repo_root)).strip()
+    except AcceptanceError as exc:
+        tracker.error("detect", str(exc))
+        console.print(tracker.render())
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+    tracker.complete("detect", feature_slug)
+
+    requested_mode = (mode or "auto").lower()
+    actual_mode = choose_mode(requested_mode, repo_root)
+    commit_required = actual_mode != "checklist" and not no_commit
+    if commit_required:
+        tracker.add("commit", "Record acceptance metadata")
+    tracker.add("guide", "Share next steps")
+
+    tracker.start("verify")
+    summary = collect_feature_summary(
+        repo_root,
+        feature_slug,
+        strict_metadata=not lenient,
+    )
+    tracker.complete("verify", "ready" if summary.ok else "issues found")
+
+    if actual_mode == "checklist":
+        if json_output:
+            console.print(json.dumps(summary.to_dict(), indent=2))
+        else:
+            _print_acceptance_summary(summary)
+        raise typer.Exit(0 if summary.ok else 1)
+
+    if not summary.ok:
+        if json_output:
+            console.print(json.dumps(summary.to_dict(), indent=2))
+        else:
+            _print_acceptance_summary(summary)
+        if not allow_fail:
+            console.print(
+                "\n[red]Outstanding acceptance issues detected. Resolve them before merging or rerun with --allow-fail for a checklist-only report.[/red]"
+            )
+            raise typer.Exit(1)
+        raise typer.Exit(1)
+
+    acceptance_tests = list(test)
+
+    try:
+        if commit_required:
+            tracker.start("commit")
+        result = perform_acceptance(
+            summary,
+            mode=actual_mode,
+            actor=actor,
+            tests=acceptance_tests,
+            auto_commit=commit_required,
+        )
+        if commit_required:
+            detail = "commit created" if result.commit_created else "no changes"
+            tracker.complete("commit", detail)
+    except AcceptanceError as exc:
+        if commit_required:
+            tracker.error("commit", str(exc))
+            console.print(tracker.render())
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(1)
+
+    tracker.start("guide")
+    tracker.complete("guide", "instructions ready")
+    console.print(tracker.render())
+
+    if json_output:
+        console.print(json.dumps(result.to_dict(), indent=2))
+        return
+
+    _print_acceptance_summary(result.summary)
+    _print_acceptance_result(result)
+
+
+__all__ = ["accept"]

specify_cli/cli/commands/agent/__init__.py

@@ -0,0 +1,22 @@
+"""Agent command namespace for AI agents to execute spec-kitty workflows programmatically."""
+
+import typer
+from typing_extensions import Annotated
+
+from . import config, feature, tasks, context, release, workflow
+
+app = typer.Typer(
+    name="agent",
+    help="Commands for AI agents to execute spec-kitty workflows programmatically",
+    no_args_is_help=True
+)
+
+# Register sub-apps for each command module
+app.add_typer(config.app, name="config")
+app.add_typer(feature.app, name="feature")
+app.add_typer(tasks.app, name="tasks")
+app.add_typer(context.app, name="context")
+app.add_typer(release.app, name="release")
+app.add_typer(workflow.app, name="workflow")
+
+__all__ = ["app"]

specify_cli/cli/commands/agent/config.py

@@ -0,0 +1,382 @@
+"""Agent configuration management commands."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import List
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from specify_cli.orchestrator.agent_config import (
+    load_agent_config,
+    save_agent_config,
+    AgentConfig,
+)
+from specify_cli.upgrade.migrations.m_0_9_1_complete_lane_migration import (
+    AGENT_DIR_TO_KEY,
+    CompleteLaneMigration,
+)
+from specify_cli.tasks_support import find_repo_root
+
+app = typer.Typer(
+    name="config",
+    help="Manage project AI agent configuration (add, remove, list agents)",
+    no_args_is_help=True,
+)
+console = Console()
+
+# Reverse mapping: key to (dir, subdir)
+KEY_TO_AGENT_DIR = {
+    AGENT_DIR_TO_KEY[agent_dir]: (agent_dir, subdir)
+    for agent_dir, subdir in CompleteLaneMigration.AGENT_DIRS
+    if agent_dir in AGENT_DIR_TO_KEY
+}
+
+
+@app.command(name="list")
+def list_agents():
+    """List configured agents and their status."""
+    try:
+        repo_root = find_repo_root()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    # Load config
+    config = load_agent_config(repo_root)
+
+    if not config.available:
+        console.print("[yellow]No agents configured.[/yellow]")
+        console.print("\nRun 'spec-kitty init' or use 'spec-kitty agent config add' to add agents.")
+        return
+
+    # Display configured agents
+    console.print("[cyan]Configured agents:[/cyan]")
+    for agent_key in config.available:
+        agent_dir_info = KEY_TO_AGENT_DIR.get(agent_key)
+        if agent_dir_info:
+            agent_dir, subdir = agent_dir_info
+            agent_path = repo_root / agent_dir / subdir
+            status = "✓" if agent_path.exists() else "⚠"
+            console.print(f"  {status} {agent_key} ({agent_dir}/{subdir}/)")
+        else:
+            console.print(f"  ✗ {agent_key} (unknown agent)")
+
+    # Show available but not configured
+    all_agent_keys = set(AGENT_DIR_TO_KEY.values())
+    not_configured = all_agent_keys - set(config.available)
+
+    if not_configured:
+        console.print("\n[dim]Available but not configured:[/dim]")
+        for agent_key in sorted(not_configured):
+            console.print(f"  - {agent_key}")
+
+
+@app.command(name="add")
+def add_agents(
+    agents: List[str] = typer.Argument(..., help="Agent keys to add (e.g., claude codex)"),
+):
+    """Add agents to the project.
+
+    Creates agent directories and updates config.yaml.
+
+    Example:
+        spec-kitty agent config add claude codex
+    """
+    try:
+        repo_root = find_repo_root()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    # Load current config
+    config = load_agent_config(repo_root)
+
+    # Validate agent keys
+    invalid = [a for a in agents if a not in AGENT_DIR_TO_KEY.values()]
+    if invalid:
+        console.print(f"[red]Error:[/red] Invalid agent keys: {', '.join(invalid)}")
+        console.print(f"\nValid agents: {', '.join(sorted(AGENT_DIR_TO_KEY.values()))}")
+        raise typer.Exit(1)
+
+    added = []
+    already_configured = []
+    errors = []
+
+    for agent_key in agents:
+        # Check if already configured
+        if agent_key in config.available:
+            already_configured.append(agent_key)
+            continue
+
+        # Get directory for this agent
+        agent_dir_info = KEY_TO_AGENT_DIR.get(agent_key)
+        if not agent_dir_info:
+            errors.append(f"Unknown agent: {agent_key}")
+            continue
+
+        agent_root, subdir = agent_dir_info
+        agent_dir = repo_root / agent_root / subdir
+
+        # Create directory structure
+        try:
+            agent_dir.mkdir(parents=True, exist_ok=True)
+
+            # Generate templates for this agent
+            # Copy from mission templates
+            missions_dir = repo_root / ".kittify" / "missions" / "software-dev" / "command-templates"
+
+            if missions_dir.exists():
+                for template_file in missions_dir.glob("*.md"):
+                    dest_file = agent_dir / f"spec-kitty.{template_file.name}"
+                    shutil.copy2(template_file, dest_file)
+
+            added.append(agent_key)
+            config.available.append(agent_key)
+            console.print(f"[green]✓[/green] Added {agent_root}/{subdir}/")
+
+        except OSError as e:
+            errors.append(f"Failed to create {agent_root}/{subdir}/: {e}")
+
+    # Save updated config
+    if added:
+        save_agent_config(repo_root, config)
+        console.print(f"\n[cyan]Updated config.yaml:[/cyan] added {', '.join(added)}")
+
+    if already_configured:
+        console.print(f"\n[dim]Already configured:[/dim] {', '.join(already_configured)}")
+
+    if errors:
+        console.print("\n[red]Errors:[/red]")
+        for error in errors:
+            console.print(f"  - {error}")
+        raise typer.Exit(1)
+
+
+@app.command(name="remove")
+def remove_agents(
+    agents: List[str] = typer.Argument(..., help="Agent keys to remove"),
+    keep_config: bool = typer.Option(
+        False,
+        "--keep-config",
+        help="Keep in config.yaml but delete directory",
+    ),
+):
+    """Remove agents from the project.
+
+    Deletes agent directories and updates config.yaml.
+
+    Example:
+        spec-kitty agent config remove codex gemini
+    """
+    try:
+        repo_root = find_repo_root()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    # Load current config
+    config = load_agent_config(repo_root)
+
+    # Validate agent keys
+    invalid = [a for a in agents if a not in AGENT_DIR_TO_KEY.values()]
+    if invalid:
+        console.print(f"[red]Error:[/red] Invalid agent keys: {', '.join(invalid)}")
+        console.print(f"\nValid agents: {', '.join(sorted(AGENT_DIR_TO_KEY.values()))}")
+        raise typer.Exit(1)
+
+    removed = []
+    errors = []
+
+    for agent_key in agents:
+        # Get directory for this agent
+        agent_dir_info = KEY_TO_AGENT_DIR.get(agent_key)
+        if not agent_dir_info:
+            errors.append(f"Unknown agent: {agent_key}")
+            continue
+
+        agent_root, subdir = agent_dir_info
+
+        # Delete directory
+        agent_path = repo_root / agent_root
+        if agent_path.exists():
+            try:
+                shutil.rmtree(agent_path)
+                removed.append(agent_key)
+                console.print(f"[green]✓[/green] Removed {agent_root}/")
+            except OSError as e:
+                errors.append(f"Failed to remove {agent_root}/: {e}")
+        else:
+            console.print(f"[dim]• {agent_root}/ already removed[/dim]")
+
+        # Update config (unless --keep-config)
+        if not keep_config and agent_key in config.available:
+            config.available.remove(agent_key)
+
+    # Save updated config
+    if not keep_config and (removed or any(a in config.available for a in agents)):
+        save_agent_config(repo_root, config)
+        console.print(f"\n[cyan]Updated config.yaml:[/cyan] removed {', '.join(removed)}")
+
+    if errors:
+        console.print("\n[yellow]Warnings:[/yellow]")
+        for error in errors:
+            console.print(f"  - {error}")
+
+
+@app.command(name="status")
+def agent_status():
+    """Show which agents are configured vs present on filesystem.
+
+    Identifies:
+    - Configured and present (✓)
+    - Configured but missing (⚠)
+    - Not configured but present (orphaned) (✗)
+    """
+    try:
+        repo_root = find_repo_root()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    # Load config
+    config = load_agent_config(repo_root)
+
+    # Check filesystem for each agent
+    table = Table(title="Agent Status")
+    table.add_column("Agent Key", style="cyan")
+    table.add_column("Directory", style="dim")
+    table.add_column("Configured", justify="center")
+    table.add_column("Exists", justify="center")
+    table.add_column("Status")
+
+    all_agent_keys = sorted(AGENT_DIR_TO_KEY.values())
+
+    for agent_key in all_agent_keys:
+        agent_dir_info = KEY_TO_AGENT_DIR.get(agent_key)
+        if not agent_dir_info:
+            continue
+
+        agent_root, subdir = agent_dir_info
+        agent_path = repo_root / agent_root / subdir
+
+        configured = "✓" if agent_key in config.available else "✗"
+        exists = "✓" if agent_path.exists() else "✗"
+
+        if agent_key in config.available and agent_path.exists():
+            status = "[green]OK[/green]"
+        elif agent_key in config.available and not agent_path.exists():
+            status = "[yellow]Missing[/yellow]"
+        elif agent_key not in config.available and agent_path.exists():
+            status = "[red]Orphaned[/red]"
+        else:
+            status = "[dim]Not used[/dim]"
+
+        table.add_row(agent_key, f"{agent_root}/{subdir}", configured, exists, status)
+
+    console.print(table)
+
+    # Summary
+    orphaned = [
+        key
+        for key in all_agent_keys
+        if key not in config.available and (repo_root / KEY_TO_AGENT_DIR[key][0]).exists()
+    ]
+
+    if orphaned:
+        console.print(
+            f"\n[yellow]⚠ {len(orphaned)} orphaned directories found[/yellow] "
+            f"(present but not configured)"
+        )
+        console.print(f"Run 'spec-kitty agent config sync --remove-orphaned' to clean up")
+
+
+@app.command(name="sync")
+def sync_agents(
+    create_missing: bool = typer.Option(
+        False,
+        "--create-missing",
+        help="Create directories for configured agents that are missing",
+    ),
+    remove_orphaned: bool = typer.Option(
+        True,
+        "--remove-orphaned/--keep-orphaned",
+        help="Remove directories for agents not in config",
+    ),
+):
+    """Sync filesystem with config.yaml.
+
+    By default, removes orphaned directories (present but not configured).
+    Use --create-missing to also create directories for configured agents.
+    """
+    try:
+        repo_root = find_repo_root()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+    # Load config
+    config = load_agent_config(repo_root)
+
+    changes_made = False
+
+    # Remove orphaned directories
+    if remove_orphaned:
+        console.print("[cyan]Checking for orphaned directories...[/cyan]")
+        all_agent_keys = set(AGENT_DIR_TO_KEY.values())
+        orphaned = [
+            key
+            for key in all_agent_keys
+            if key not in config.available and (repo_root / KEY_TO_AGENT_DIR[key][0]).exists()
+        ]
+
+        for agent_key in orphaned:
+            agent_root, _ = KEY_TO_AGENT_DIR[agent_key]
+            agent_path = repo_root / agent_root
+
+            try:
+                shutil.rmtree(agent_path)
+                console.print(f"  [green]✓[/green] Removed orphaned {agent_root}/")
+                changes_made = True
+            except OSError as e:
+                console.print(f"  [red]✗[/red] Failed to remove {agent_root}/: {e}")
+
+    # Create missing directories
+    if create_missing:
+        console.print("\n[cyan]Checking for missing directories...[/cyan]")
+        missions_dir = repo_root / ".kittify" / "missions" / "software-dev" / "command-templates"
+
+        for agent_key in config.available:
+            agent_dir_info = KEY_TO_AGENT_DIR.get(agent_key)
+            if not agent_dir_info:
+                console.print(f"  [yellow]⚠[/yellow] Unknown agent: {agent_key}")
+                continue
+
+            agent_root, subdir = agent_dir_info
+            agent_dir = repo_root / agent_root / subdir
+
+            if not agent_dir.exists():
+                try:
+                    agent_dir.mkdir(parents=True, exist_ok=True)
+
+                    # Copy templates if available
+                    if missions_dir.exists():
+                        for template_file in missions_dir.glob("*.md"):
+                            dest_file = agent_dir / f"spec-kitty.{template_file.name}"
+                            shutil.copy2(template_file, dest_file)
+
+                    console.print(f"  [green]✓[/green] Created {agent_root}/{subdir}/")
+                    changes_made = True
+                except OSError as e:
+                    console.print(f"  [red]✗[/red] Failed to create {agent_root}/{subdir}/: {e}")
+
+    if not changes_made:
+        console.print("[dim]No changes needed - filesystem matches config[/dim]")
+    else:
+        console.print("\n[green]✓ Sync complete[/green]")
+
+
+__all__ = ["app"]