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

specify_cli/verify_enhanced.py

@@ -0,0 +1,270 @@
+"""
+Enhanced verify_setup implementation for spec-kitty.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .manifest import FileManifest, WorktreeStatus
+
+
+def run_enhanced_verify(
+    repo_root: Path,
+    project_root: Path,
+    cwd: Path,
+    feature: Optional[str],
+    json_output: bool,
+    check_files: bool,
+    console: Console
+) -> Dict:
+    """
+    Run the enhanced verification with manifest checking and worktree status.
+
+    Returns a dict suitable for JSON output if needed.
+    """
+    output_data = {
+        "environment": {},
+        "feature_detection": {},
+        "worktree_status": {},
+        "file_integrity": {},
+        "feature_analysis": {},
+        "recommendations": []
+    }
+
+    # Initialize helpers
+    kittify_dir = project_root / ".kittify"
+    manifest = FileManifest(kittify_dir)
+    worktree_status = WorktreeStatus(repo_root)
+
+    # 1. Environment Information
+    in_worktree = '.worktrees' in str(cwd)
+
+    try:
+        current_branch = subprocess.run(
+            ["git", "branch", "--show-current"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True
+        ).stdout.strip()
+    except subprocess.CalledProcessError:
+        current_branch = None
+
+    output_data["environment"] = {
+        "working_directory": str(cwd),
+        "repo_root": str(repo_root),
+        "project_root": str(project_root),
+        "in_worktree": in_worktree,
+        "current_branch": current_branch,
+        "active_mission": manifest.active_mission
+    }
+
+    if not json_output:
+        console.print("\n[bold]System Integrity Check[/bold]\n")
+
+        # Environment section
+        console.print("[cyan]1. Environment[/cyan]")
+        console.print(f"   Working directory: {cwd}")
+        console.print(f"   Repository root: {repo_root}")
+
+        if in_worktree:
+            console.print(f"   [green]✓[/green] In worktree")
+        else:
+            console.print(f"   [dim]○[/dim] Not in worktree")
+
+        if current_branch:
+            console.print(f"   Current branch: {current_branch}")
+            if current_branch == "main":
+                console.print(f"   [yellow]⚠[/yellow] On main branch")
+        else:
+            console.print(f"   [yellow]⚠[/yellow] Could not detect branch")
+
+    # 2. File Integrity Check
+    if check_files:
+        file_check = manifest.check_files()
+        expected_files = manifest.get_expected_files()
+
+        total_expected = sum(len(files) for files in expected_files.values())
+        total_present = len(file_check["present"])
+        total_missing = len(file_check["missing"])
+
+        output_data["file_integrity"] = {
+            "active_mission": manifest.active_mission,
+            "total_expected": total_expected,
+            "total_present": total_present,
+            "total_missing": total_missing,
+            "missing_files": file_check["missing"],
+            "categories": {}
+        }
+
+        # Count by category
+        for category, files in expected_files.items():
+            present_in_category = sum(1 for f in files if f in file_check["present"])
+            output_data["file_integrity"]["categories"][category] = {
+                "expected": len(files),
+                "present": present_in_category,
+                "missing": len(files) - present_in_category
+            }
+
+        if not json_output:
+            console.print("\n[cyan]2. Mission File Integrity[/cyan]")
+            console.print(f"   Active mission: {manifest.active_mission}")
+
+            if total_missing == 0:
+                console.print(f"   [green]✓[/green] All {total_expected} expected files present")
+            else:
+                console.print(f"   [yellow]⚠[/yellow] {total_missing} of {total_expected} files missing")
+
+                # Show missing by category
+                for category in ["commands", "templates", "scripts"]:
+                    cat_missing = [f for f, c in file_check["missing"].items() if c == category]
+                    if cat_missing:
+                        console.print(f"   Missing {category}:")
+                        for file in cat_missing[:3]:  # Show first 3
+                            console.print(f"     - {file}")
+                        if len(cat_missing) > 3:
+                            console.print(f"     ... and {len(cat_missing) - 3} more")
+
+    # 3. Worktree Status Overview
+    worktree_summary = worktree_status.get_worktree_summary()
+    output_data["worktree_status"] = worktree_summary
+
+    if not json_output:
+        console.print("\n[cyan]3. Worktree Overview[/cyan]")
+        console.print(f"   Total features: {worktree_summary['total_features']}")
+        console.print(f"   Active worktrees: {worktree_summary['active_worktrees']}")
+        console.print(f"   Merged features: {worktree_summary['merged_features']}")
+        console.print(f"   In development: {worktree_summary['in_development']}")
+
+    # 4. Feature Detection and Analysis
+    try:
+        from .acceptance import detect_feature_slug, AcceptanceError
+        feature_slug = (feature or detect_feature_slug(repo_root, cwd=cwd)).strip()
+
+        output_data["feature_detection"] = {
+            "detected": True,
+            "feature": feature_slug
+        }
+
+        # Get detailed status for this feature
+        feature_status = worktree_status.get_feature_status(feature_slug)
+        output_data["feature_analysis"] = feature_status
+
+        if not json_output:
+            console.print("\n[cyan]4. Current Feature Status[/cyan]")
+            console.print(f"   Feature: {feature_slug}")
+            console.print(f"   State: {feature_status['state'].upper()}")
+
+            # Status indicators
+            if feature_status["branch_exists"]:
+                status_text = "merged" if feature_status["branch_merged"] else "active"
+                console.print(f"   [green]✓[/green] Branch exists ({status_text})")
+            else:
+                console.print(f"   [dim]○[/dim] No branch")
+
+            if feature_status["worktree_exists"]:
+                console.print(f"   [green]✓[/green] Worktree at: {feature_status['worktree_path']}")
+            else:
+                console.print(f"   [dim]○[/dim] No worktree")
+
+            # Artifacts
+            if feature_status["artifacts_in_main"]:
+                console.print(f"   Artifacts in main: {', '.join(feature_status['artifacts_in_main'])}")
+            if feature_status["artifacts_in_worktree"]:
+                console.print(f"   Artifacts in worktree: {', '.join(feature_status['artifacts_in_worktree'])}")
+
+            # State-based observations
+            if feature_status["state"] == "merged":
+                console.print("   [green]✓[/green] Feature appears to be merged")
+            elif feature_status["state"] == "in_development":
+                console.print("   [blue]●[/blue] Feature is in active development")
+            elif feature_status["state"] == "not_started":
+                console.print("   [dim]○[/dim] Feature not yet started")
+
+    except AcceptanceError as exc:
+        output_data["feature_detection"] = {
+            "detected": False,
+            "error": str(exc)
+        }
+
+        if not json_output:
+            console.print("\n[cyan]4. Feature Detection[/cyan]")
+            console.print(f"   [yellow]⚠[/yellow] Could not detect feature: {exc}")
+
+    # 5. All Features Status Table
+    all_features = worktree_status.get_all_features()
+
+    if not json_output and all_features:
+        console.print("\n[cyan]5. All Features Status[/cyan]")
+
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Feature", style="cyan")
+        table.add_column("State", style="white")
+        table.add_column("Branch", style="white")
+        table.add_column("Worktree", style="white")
+        table.add_column("Artifacts", style="white")
+
+        for feat in all_features[:10]:  # Show first 10
+            feat_status = worktree_status.get_feature_status(feat)
+
+            # Determine display values
+            state_display = {
+                "merged": "[green]MERGED[/green]",
+                "in_development": "[yellow]ACTIVE[/yellow]",
+                "ready_to_merge": "[blue]READY[/blue]",
+                "not_started": "[dim]NOT STARTED[/dim]",
+                "unknown": "[dim]?[/dim]"
+            }.get(feat_status["state"], feat_status["state"])
+
+            branch_display = "✓" if feat_status["branch_exists"] else "-"
+            if feat_status["branch_merged"]:
+                branch_display = "merged"
+
+            worktree_display = "✓" if feat_status["worktree_exists"] else "-"
+
+            artifact_count = len(feat_status["artifacts_in_main"]) + len(feat_status["artifacts_in_worktree"])
+            artifacts_display = str(artifact_count) if artifact_count > 0 else "-"
+
+            table.add_row(
+                feat,
+                state_display,
+                branch_display,
+                worktree_display,
+                artifacts_display
+            )
+
+        console.print(table)
+
+        if len(all_features) > 10:
+            console.print(f"   [dim]... and {len(all_features) - 10} more features[/dim]")
+
+    # 6. Observations (not recommendations)
+    observations = []
+
+    if current_branch == "main" and in_worktree:
+        observations.append("Unusual: In worktree but on main branch")
+
+    if output_data.get("feature_analysis", {}).get("state") == "in_development":
+        if not output_data["feature_analysis"].get("worktree_exists"):
+            observations.append(f"Feature {feature_slug} has no worktree but has development artifacts")
+
+    if total_missing > 0 and check_files:
+        observations.append(f"Mission integrity: {total_missing} expected files not found")
+
+    output_data["observations"] = observations
+
+    if not json_output and observations:
+        console.print("\n[cyan]6. Observations[/cyan]")
+        for obs in observations:
+            console.print(f"   • {obs}")
+
+    # Final summary
+    if not json_output:
+        console.print("\n[bold green]✓ Verification complete[/bold green]\n")
+
+    return output_data

specify_cli/workspace_context.py

@@ -0,0 +1,224 @@
+"""Workspace context management for runtime visibility.
+
+This module manages persistent workspace context files stored in .kittify/workspaces/.
+These files provide runtime visibility into workspace state for LLM agents and CLI tools.
+
+Context files are:
+- Created during `spec-kitty implement` command
+- Stored in main repo's .kittify/workspaces/ directory
+- Readable from both main repo and worktrees (via relative path)
+- Cleaned up during merge or explicit workspace deletion
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict
+
+
+@dataclass
+class WorkspaceContext:
+    """
+    Runtime context for a work package workspace.
+
+    Provides all information an agent needs to understand workspace state.
+    Stored as JSON in .kittify/workspaces/###-feature-WP##.json
+    """
+
+    # Identity
+    wp_id: str  # e.g., "WP02"
+    feature_slug: str  # e.g., "010-workspace-per-wp"
+
+    # Paths
+    worktree_path: str  # Relative path from repo root (e.g., ".worktrees/010-feature-WP02")
+    branch_name: str  # Git branch name (e.g., "010-feature-WP02")
+
+    # Base tracking
+    base_branch: str  # Branch this was created from (e.g., "010-feature-WP01" or "main")
+    base_commit: str  # Git SHA this was created from
+
+    # Dependencies
+    dependencies: list[str]  # List of WP IDs this depends on (e.g., ["WP01"])
+
+    # Metadata
+    created_at: str  # ISO timestamp when workspace was created
+    created_by: str  # Command that created this (e.g., "implement-command")
+    vcs_backend: str  # "git" or "jj"
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> WorkspaceContext:
+        """Create from dictionary (JSON deserialization)."""
+        return cls(**data)
+
+
+def get_workspaces_dir(repo_root: Path) -> Path:
+    """Get or create the workspaces context directory.
+
+    Args:
+        repo_root: Repository root path
+
+    Returns:
+        Path to .kittify/workspaces/ directory
+    """
+    workspaces_dir = repo_root / ".kittify" / "workspaces"
+    workspaces_dir.mkdir(parents=True, exist_ok=True)
+    return workspaces_dir
+
+
+def get_context_path(repo_root: Path, workspace_name: str) -> Path:
+    """Get path to workspace context file.
+
+    Args:
+        repo_root: Repository root path
+        workspace_name: Workspace name (e.g., "010-feature-WP02")
+
+    Returns:
+        Path to context JSON file
+    """
+    workspaces_dir = get_workspaces_dir(repo_root)
+    return workspaces_dir / f"{workspace_name}.json"
+
+
+def save_context(repo_root: Path, context: WorkspaceContext) -> Path:
+    """Save workspace context to JSON file.
+
+    Args:
+        repo_root: Repository root path
+        context: Workspace context to save
+
+    Returns:
+        Path to saved context file
+    """
+    workspace_name = f"{context.feature_slug}-{context.wp_id}"
+    context_path = get_context_path(repo_root, workspace_name)
+
+    # Write JSON with pretty formatting
+    context_path.write_text(
+        json.dumps(context.to_dict(), indent=2) + "\n",
+        encoding="utf-8"
+    )
+
+    return context_path
+
+
+def load_context(repo_root: Path, workspace_name: str) -> WorkspaceContext | None:
+    """Load workspace context from JSON file.
+
+    Args:
+        repo_root: Repository root path
+        workspace_name: Workspace name (e.g., "010-feature-WP02")
+
+    Returns:
+        WorkspaceContext if file exists, None otherwise
+    """
+    context_path = get_context_path(repo_root, workspace_name)
+
+    if not context_path.exists():
+        return None
+
+    try:
+        data = json.loads(context_path.read_text(encoding="utf-8"))
+        return WorkspaceContext.from_dict(data)
+    except (json.JSONDecodeError, TypeError, KeyError):
+        # Malformed context file
+        return None
+
+
+def delete_context(repo_root: Path, workspace_name: str) -> bool:
+    """Delete workspace context file.
+
+    Args:
+        repo_root: Repository root path
+        workspace_name: Workspace name (e.g., "010-feature-WP02")
+
+    Returns:
+        True if deleted, False if didn't exist
+    """
+    context_path = get_context_path(repo_root, workspace_name)
+
+    if context_path.exists():
+        context_path.unlink()
+        return True
+
+    return False
+
+
+def list_contexts(repo_root: Path) -> list[WorkspaceContext]:
+    """List all workspace contexts.
+
+    Args:
+        repo_root: Repository root path
+
+    Returns:
+        List of all workspace contexts (empty if none exist)
+    """
+    workspaces_dir = get_workspaces_dir(repo_root)
+
+    if not workspaces_dir.exists():
+        return []
+
+    contexts = []
+    for context_file in workspaces_dir.glob("*.json"):
+        workspace_name = context_file.stem
+        context = load_context(repo_root, workspace_name)
+        if context:
+            contexts.append(context)
+
+    return contexts
+
+
+def find_orphaned_contexts(repo_root: Path) -> list[tuple[str, WorkspaceContext]]:
+    """Find context files for workspaces that no longer exist.
+
+    Args:
+        repo_root: Repository root path
+
+    Returns:
+        List of (workspace_name, context) tuples for orphaned contexts
+    """
+    orphaned = []
+
+    for context in list_contexts(repo_root):
+        workspace_path = repo_root / context.worktree_path
+        if not workspace_path.exists():
+            workspace_name = f"{context.feature_slug}-{context.wp_id}"
+            orphaned.append((workspace_name, context))
+
+    return orphaned
+
+
+def cleanup_orphaned_contexts(repo_root: Path) -> int:
+    """Remove context files for deleted workspaces.
+
+    Args:
+        repo_root: Repository root path
+
+    Returns:
+        Number of orphaned contexts cleaned up
+    """
+    orphaned = find_orphaned_contexts(repo_root)
+
+    for workspace_name, _ in orphaned:
+        delete_context(repo_root, workspace_name)
+
+    return len(orphaned)
+
+
+__all__ = [
+    "WorkspaceContext",
+    "get_workspaces_dir",
+    "get_context_path",
+    "save_context",
+    "load_context",
+    "delete_context",
+    "list_contexts",
+    "find_orphaned_contexts",
+    "cleanup_orphaned_contexts",
+]