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

specify_cli/upgrade/migrations/m_0_10_6_workflow_simplification.py

@@ -0,0 +1,174 @@
+"""Migration: Simplify implement and review templates to use workflow commands."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import List
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+from .m_0_9_1_complete_lane_migration import get_agent_dirs_for_project
+
+
+@MigrationRegistry.register
+class WorkflowSimplificationMigration(BaseMigration):
+    """Update implement and review slash commands to use new workflow commands.
+
+    This migration simplifies the agent workflow by:
+    1. Replacing complex implement.md template (78 lines) with minimal version (9 lines)
+    2. Replacing complex review.md template (72 lines) with minimal version (9 lines)
+    3. Templates now call `spec-kitty agent workflow implement/review` which:
+       - Displays the full WP prompt directly to the agent
+       - Shows clear "when done" instructions
+       - No more file navigation or path confusion
+    """
+
+    migration_id = "0.10.6_workflow_simplification"
+    description = "Simplify implement and review templates to use workflow commands"
+    target_version = "0.10.6"
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if slash commands need updating to workflow commands."""
+        # Check configured agent directories for old complex templates
+        agent_dirs = get_agent_dirs_for_project(project_path)
+
+        for agent_root, subdir in agent_dirs:
+            agent_dir = project_path / agent_root / subdir
+
+            if not agent_dir.exists():
+                continue
+
+            # Check implement.md for old structure (looking for complex instructions)
+            implement_file = agent_dir / "spec-kitty.implement.md"
+            if implement_file.exists():
+                content = implement_file.read_text(encoding="utf-8")
+                # Old template has "Work Package Selection" or "Setup (Do This First)"
+                if "Work Package Selection" in content or "Setup (Do This First)" in content:
+                    return True
+                # Or doesn't have the new workflow command
+                if "spec-kitty agent workflow implement" not in content:
+                    return True
+
+            # Check review.md for old structure
+            review_file = agent_dir / "spec-kitty.review.md"
+            if review_file.exists():
+                content = review_file.read_text(encoding="utf-8")
+                # Old template has complex outline
+                if "Location Pre-flight Check" in content or "Conduct the review:" in content:
+                    return True
+                # Or doesn't have the new workflow command
+                if "spec-kitty agent workflow review" not in content:
+                    return True
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check if we can apply this migration."""
+        kittify_dir = project_path / ".kittify"
+        if not kittify_dir.exists():
+            return False, "No .kittify directory (not a spec-kitty project)"
+
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Update implement and review slash commands with new workflow-based templates."""
+        changes: List[str] = []
+        warnings: List[str] = []
+        errors: List[str] = []
+
+        missions_dir = project_path / ".kittify" / "missions"
+        software_dev_templates = missions_dir / "software-dev" / "command-templates"
+
+        # Copy updated mission templates from package first (if available)
+        try:
+            import specify_cli
+        except ImportError as exc:
+            errors.append(f"Failed to import specify_cli: {exc}")
+            return MigrationResult(
+                success=False,
+                changes_made=changes,
+                errors=errors,
+                warnings=warnings,
+            )
+
+        pkg_root = Path(specify_cli.__file__).parent
+        pkg_templates = pkg_root / "missions" / "software-dev" / "command-templates"
+        if not pkg_templates.exists():
+            pkg_templates = pkg_root / ".kittify" / "missions" / "software-dev" / "command-templates"
+
+        if pkg_templates.exists():
+            if not dry_run:
+                software_dev_templates.mkdir(parents=True, exist_ok=True)
+            for template_name in ("implement.md", "review.md"):
+                src = pkg_templates / template_name
+                if not src.exists():
+                    warnings.append(f"Package template missing: {template_name}")
+                    continue
+                if dry_run:
+                    changes.append(f"Would update mission template: software-dev/{template_name}")
+                else:
+                    try:
+                        shutil.copy2(src, software_dev_templates / template_name)
+                        changes.append(f"Updated mission template: software-dev/{template_name}")
+                    except OSError as e:
+                        warnings.append(f"Failed to copy mission template {template_name}: {e}")
+        else:
+            warnings.append(
+                "Mission templates not found in package. "
+                "Slash commands may already be updated or require manual repair."
+            )
+
+        # Update implement.md and review.md in ALL agent directories
+        templates_to_update = ["implement.md", "review.md"]
+        total_updated = 0
+
+        agent_dirs = get_agent_dirs_for_project(project_path)
+        for agent_root, subdir in agent_dirs:
+            agent_dir = project_path / agent_root / subdir
+
+            if not agent_dir.exists():
+                continue
+
+            updated_count = 0
+            for template_name in templates_to_update:
+                source_template = software_dev_templates / template_name
+                if not source_template.exists():
+                    continue
+
+                dest_filename = f"spec-kitty.{template_name}"
+                dest_path = agent_dir / dest_filename
+
+                if dry_run:
+                    changes.append(f"Would update {agent_root}: {dest_filename}")
+                else:
+                    try:
+                        dest_path.write_text(
+                            source_template.read_text(encoding="utf-8"),
+                            encoding="utf-8",
+                        )
+                        updated_count += 1
+                    except OSError as e:
+                        warnings.append(f"Failed to update {agent_root}/{dest_filename}: {e}")
+
+            if updated_count > 0:
+                agent_name = agent_root.strip(".")
+                changes.append(f"Updated {updated_count} templates for {agent_name}")
+                total_updated += updated_count
+
+        if total_updated > 0:
+            changes.append(f"Total: Updated {total_updated} slash command templates")
+            changes.append("Templates now use 'spec-kitty agent workflow' commands")
+            changes.append("Agents now see prompts directly, no file navigation needed")
+        elif not changes:
+            warnings.append(
+                "No templates were updated (already updated or mission templates missing)"
+            )
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )

specify_cli/upgrade/migrations/m_0_10_8_fix_memory_structure.py

@@ -0,0 +1,252 @@
+"""Migration: Fix memory/ and AGENTS.md structure - move from root to .kittify/."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import List
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+
+
+@MigrationRegistry.register
+class FixMemoryStructureMigration(BaseMigration):
+    """Move memory/ directory and AGENTS.md from root to .kittify/.
+
+    Historical context: When spec-kitty was developed in a worktree, symlinks
+    were created (.kittify/memory -> ../../../.kittify/memory) that became
+    circular when merged to main. All code expects files in .kittify/ but some
+    user projects may have them at root level.
+
+    This migration:
+    1. Moves memory/ from root to .kittify/memory/ (if needed)
+    2. Removes broken .kittify/memory symlink (if exists)
+    3. Ensures .kittify/AGENTS.md exists (not symlink)
+    4. Updates worktrees to use proper .kittify/ paths
+    """
+
+    migration_id = "0.10.8_fix_memory_structure"
+    description = "Move memory/ and AGENTS.md from root to .kittify/"
+    target_version = "0.10.8"
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if project has broken memory structure."""
+        # Check for root-level memory/ directory
+        root_memory = project_path / "memory"
+        kittify_memory = project_path / ".kittify" / "memory"
+
+        # If root memory exists and .kittify/memory doesn't (or is a broken symlink)
+        if root_memory.exists() and root_memory.is_dir():
+            if not kittify_memory.exists():
+                return True
+            if kittify_memory.is_symlink() and not kittify_memory.resolve().exists():
+                return True  # Broken symlink
+
+        # Check for broken .kittify/memory symlink
+        if kittify_memory.is_symlink():
+            try:
+                # Try to resolve - if it points to itself or doesn't exist, it's broken
+                resolved = kittify_memory.resolve()
+                if not resolved.exists() or resolved == kittify_memory:
+                    return True
+            except (OSError, RuntimeError):
+                return True  # Circular symlink or resolution error
+
+        # Check for broken .kittify/AGENTS.md symlink
+        kittify_agents = project_path / ".kittify" / "AGENTS.md"
+        if kittify_agents.is_symlink():
+            try:
+                resolved = kittify_agents.resolve()
+                if not resolved.exists() or resolved == kittify_agents:
+                    return True
+            except (OSError, RuntimeError):
+                return True
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check if migration can be safely applied."""
+        root_memory = project_path / "memory"
+        kittify_dir = project_path / ".kittify"
+
+        # .kittify must exist
+        if not kittify_dir.exists():
+            return False, ".kittify directory must exist before migration"
+
+        # If root memory exists, we can migrate it
+        if root_memory.exists() and root_memory.is_dir():
+            return True, "Ready to migrate memory/ to .kittify/"
+
+        # If broken symlinks exist, we can fix them
+        kittify_memory = kittify_dir / "memory"
+        kittify_agents = kittify_dir / "AGENTS.md"
+
+        if kittify_memory.is_symlink() or kittify_agents.is_symlink():
+            return True, "Ready to fix broken symlinks"
+
+        return True, "Ready to apply"
+
+    def apply(self, project_path: Path, *, dry_run: bool = False) -> MigrationResult:
+        """Move memory/ and fix broken symlinks."""
+        warnings: List[str] = []
+        changes_made: List[str] = []
+
+        root_memory = project_path / "memory"
+        kittify_dir = project_path / ".kittify"
+        kittify_memory = kittify_dir / "memory"
+        kittify_agents = kittify_dir / "AGENTS.md"
+        templates_agents = kittify_dir / "templates" / "AGENTS.md"
+
+        # Step 1: Fix .kittify/memory
+        if kittify_memory.exists():
+            if kittify_memory.is_symlink():
+                # Remove broken symlink
+                if dry_run:
+                    changes_made.append(f"Would remove broken symlink: {kittify_memory}")
+                else:
+                    kittify_memory.unlink()
+                    changes_made.append(f"Removed broken symlink: {kittify_memory}")
+
+        # Step 2: Move or copy root memory/ to .kittify/memory/
+        if root_memory.exists() and root_memory.is_dir():
+            if not kittify_memory.exists():
+                if dry_run:
+                    changes_made.append(f"Would move {root_memory} -> {kittify_memory}")
+                else:
+                    try:
+                        # Move the directory
+                        shutil.move(str(root_memory), str(kittify_memory))
+                        changes_made.append(f"Moved {root_memory} -> {kittify_memory}")
+                    except Exception as e:
+                        # If move fails, try copy
+                        try:
+                            shutil.copytree(root_memory, kittify_memory)
+                            changes_made.append(f"Copied {root_memory} -> {kittify_memory} (move failed: {e})")
+                            warnings.append(f"Could not move (copied instead): {e}")
+                        except Exception as copy_error:
+                            return MigrationResult(
+                                success=False,
+                                changes_made=changes_made,
+                                warnings=warnings,
+                                errors=[f"Failed to move or copy memory/: {copy_error}"]
+                            )
+            else:
+                warnings.append(f"{kittify_memory} already exists, skipping root memory/ migration")
+
+        # Step 3: Create .kittify/memory/ from template if missing
+        if not kittify_memory.exists():
+            # Check if there's a template in missions
+            template_constitution = None
+            missions_dir = kittify_dir / "missions" / "software-dev"
+            if missions_dir.exists():
+                # Look for constitution template in command templates
+                template_path = missions_dir / "command-templates" / "constitution.md"
+                if not template_path.exists():
+                    template_path = kittify_dir / "templates" / "command-templates" / "constitution.md"
+                if template_path.exists():
+                    template_constitution = template_path
+
+            if template_constitution:
+                if dry_run:
+                    changes_made.append(f"Would create {kittify_memory} from template")
+                else:
+                    kittify_memory.mkdir(parents=True, exist_ok=True)
+                    constitution_dest = kittify_memory / "constitution.md"
+                    shutil.copy2(template_constitution, constitution_dest)
+                    changes_made.append(f"Created {kittify_memory} from template")
+            else:
+                warnings.append(f"{kittify_memory} doesn't exist and no template found")
+
+        # Step 4: Fix .kittify/AGENTS.md
+        if kittify_agents.exists() and kittify_agents.is_symlink():
+            # Remove broken symlink
+            if dry_run:
+                changes_made.append(f"Would remove broken symlink: {kittify_agents}")
+            else:
+                kittify_agents.unlink()
+                changes_made.append(f"Removed broken symlink: {kittify_agents}")
+
+        # Step 5: Create .kittify/AGENTS.md from template if missing
+        if not kittify_agents.exists() or kittify_agents.is_symlink():
+            if templates_agents.exists():
+                if dry_run:
+                    changes_made.append(f"Would copy {templates_agents} -> {kittify_agents}")
+                else:
+                    shutil.copy2(templates_agents, kittify_agents)
+                    changes_made.append(f"Copied {templates_agents} -> {kittify_agents}")
+            else:
+                warnings.append(f"No AGENTS.md template found at {templates_agents}")
+
+        # Step 6: Update worktrees if they exist
+        worktrees_dir = project_path / ".worktrees"
+        if worktrees_dir.exists():
+            for worktree_path in worktrees_dir.iterdir():
+                if not worktree_path.is_dir():
+                    continue
+
+                wt_kittify = worktree_path / ".kittify"
+                if not wt_kittify.exists():
+                    continue
+
+                wt_memory = wt_kittify / "memory"
+                wt_agents = wt_kittify / "AGENTS.md"
+
+                # Remove broken symlinks in worktrees
+                if wt_memory.is_symlink():
+                    try:
+                        resolved = wt_memory.resolve()
+                        if not resolved.exists() or resolved == wt_memory:
+                            if dry_run:
+                                changes_made.append(f"Would remove broken worktree symlink: {wt_memory}")
+                            else:
+                                wt_memory.unlink()
+                                changes_made.append(f"Removed broken worktree symlink: {wt_memory}")
+                    except (OSError, RuntimeError):
+                        if not dry_run:
+                            wt_memory.unlink()
+                            changes_made.append(f"Removed broken worktree symlink: {wt_memory}")
+
+                # Recreate worktree symlink to point to main repo's .kittify/memory
+                if not wt_memory.exists() and kittify_memory.exists():
+                    relative_path = Path("../../../.kittify/memory")
+                    if dry_run:
+                        changes_made.append(f"Would create worktree symlink: {wt_memory} -> {relative_path}")
+                    else:
+                        try:
+                            wt_memory.symlink_to(relative_path, target_is_directory=True)
+                            changes_made.append(f"Created worktree symlink: {wt_memory} -> {relative_path}")
+                        except OSError:
+                            # Fallback: copy instead of symlink
+                            shutil.copytree(kittify_memory, wt_memory)
+                            changes_made.append(f"Copied to worktree (symlink failed): {wt_memory}")
+
+                # Fix AGENTS.md in worktree
+                if wt_agents.is_symlink():
+                    try:
+                        resolved = wt_agents.resolve()
+                        if not resolved.exists() or resolved == wt_agents:
+                            if not dry_run:
+                                wt_agents.unlink()
+                    except (OSError, RuntimeError):
+                        if not dry_run:
+                            wt_agents.unlink()
+
+                if not wt_agents.exists() and kittify_agents.exists():
+                    relative_path = Path("../../../.kittify/AGENTS.md")
+                    if dry_run:
+                        changes_made.append(f"Would create worktree symlink: {wt_agents} -> {relative_path}")
+                    else:
+                        try:
+                            wt_agents.symlink_to(relative_path)
+                            changes_made.append(f"Created worktree symlink: {wt_agents} -> {relative_path}")
+                        except OSError:
+                            shutil.copy2(kittify_agents, wt_agents)
+                            changes_made.append(f"Copied to worktree (symlink failed): {wt_agents}")
+
+        return MigrationResult(
+            success=True,
+            changes_made=changes_made,
+            warnings=warnings,
+            errors=[]
+        )

specify_cli/upgrade/migrations/m_0_10_9_repair_templates.py

@@ -0,0 +1,168 @@
+"""Migration: Repair broken templates for users affected by #62, #63, #64."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import List
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+
+
+@MigrationRegistry.register
+class RepairTemplatesMigration(BaseMigration):
+    """Repair templates for projects with broken bash script references.
+
+    This migration addresses issues #62, #63, #64 where PyPI installations
+    received outdated templates with bash script references. It detects
+    broken templates and regenerates them from the correct source.
+    """
+
+    migration_id = "0.10.9_repair_templates"
+    description = "Repair broken templates with bash script references"
+    target_version = "0.10.9"
+
+    def detect(self, project_path: Path) -> bool:
+        """Detect if project has broken templates with bash script references."""
+        # Check all agent directories for broken slash commands
+        agent_dirs = [
+            (".claude", "commands"),
+            (".github", "prompts"),
+            (".gemini", "commands"),
+            (".cursor", "commands"),
+            (".qwen", "commands"),
+            (".opencode", "command"),
+            (".windsurf", "workflows"),
+            (".codex", "prompts"),
+            (".kilocode", "workflows"),
+            (".augment", "commands"),
+            (".roo", "commands"),
+            (".amazonq", "prompts"),
+        ]
+
+        for agent_dir, subdir in agent_dirs:
+            commands_dir = project_path / agent_dir / subdir
+            if not commands_dir.exists():
+                continue
+
+            # Check for bash script references in any command file
+            for cmd_file in commands_dir.glob("spec-kitty.*.md"):
+                try:
+                    content = cmd_file.read_text(encoding="utf-8")
+                    if "scripts/bash/" in content or "scripts/powershell/" in content:
+                        return True  # Found broken template
+                except Exception:
+                    # Skip files we can't read
+                    continue
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Migration can always be applied if broken templates detected."""
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Regenerate templates from correct source."""
+        changes: List[str] = []
+        errors: List[str] = []
+        warnings: List[str] = []
+
+        # Step 1: Remove broken templates from .kittify/templates/
+        kittify_templates = project_path / ".kittify" / "templates"
+        if kittify_templates.exists():
+            if not dry_run:
+                shutil.rmtree(kittify_templates)
+                changes.append("Removed broken templates from .kittify/templates/")
+            else:
+                changes.append("Would remove broken templates from .kittify/templates/")
+
+        # Step 2: Copy correct templates from package
+        try:
+            # Import here to avoid circular dependencies
+            from specify_cli.template.manager import (
+                get_local_repo_root,
+                copy_specify_base_from_local,
+                copy_specify_base_from_package,
+            )
+
+            local_repo = get_local_repo_root()
+            command_templates_dir = None
+
+            if local_repo:
+                # For local dev, get templates from .kittify/templates/
+                if not dry_run:
+                    command_templates_dir = copy_specify_base_from_local(
+                        local_repo, project_path, "sh"
+                    )
+                    changes.append("Copied correct templates from local repo")
+                else:
+                    changes.append("Would copy correct templates from local repo")
+            else:
+                # For package install, use bundled templates (now fixed)
+                if not dry_run:
+                    command_templates_dir = copy_specify_base_from_package(
+                        project_path, "sh"
+                    )
+                    changes.append("Copied correct templates from package")
+                else:
+                    changes.append("Would copy correct templates from package")
+
+            # Step 3: Regenerate all agent slash commands
+            if not dry_run and command_templates_dir:
+                # Import here to avoid circular dependencies
+                from specify_cli.cli.commands.init import generate_agent_assets
+                import yaml
+
+                # Get AI configuration from metadata
+                metadata_file = project_path / ".kittify" / "metadata.yaml"
+                ai_config = "claude"  # default
+                if metadata_file.exists():
+                    try:
+                        with open(metadata_file, encoding="utf-8") as f:
+                            metadata = yaml.safe_load(f)
+                            ai_config = metadata.get("ai", "claude")
+                    except Exception:
+                        # Use default if we can't read metadata
+                        pass
+
+                # Regenerate commands
+                try:
+                    generate_agent_assets(
+                        command_templates_dir=command_templates_dir,
+                        project_path=project_path,
+                        agent_key=ai_config,
+                        script_type="sh"
+                    )
+                    changes.append("Regenerated all agent slash commands")
+                except Exception as e:
+                    errors.append(f"Failed to regenerate agent commands: {e}")
+
+                # Cleanup temporary templates
+                if kittify_templates.exists():
+                    shutil.rmtree(kittify_templates)
+                    changes.append("Cleaned up temporary templates")
+            else:
+                changes.append("Would regenerate all agent slash commands")
+
+        except Exception as e:
+            errors.append(f"Failed to repair templates: {e}")
+
+        # Step 4: Verify repair
+        if not dry_run and len(errors) == 0:
+            still_broken = self.detect(project_path)
+            if still_broken:
+                warnings.append(
+                    "Some bash script references may still remain. "
+                    "Please run 'spec-kitty upgrade' again or report an issue."
+                )
+            else:
+                changes.append("✓ Templates successfully repaired - no bash script references found")
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )