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

specify_cli/upgrade/migrations/m_0_5_0_encoding_hooks.py

@@ -0,0 +1,141 @@
+"""Migration: Install encoding validation pre-commit hooks."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+
+
+@MigrationRegistry.register
+class EncodingHooksMigration(BaseMigration):
+    """Install encoding validation pre-commit hooks.
+
+    This migration installs git hooks that validate file encoding
+    before commits, preventing encoding issues from being committed.
+    """
+
+    migration_id = "0.5.0_encoding_hooks"
+    description = "Install encoding validation pre-commit hooks"
+    target_version = "0.5.0"
+
+    HOOK_FILES = [
+        "pre-commit",
+        "pre-commit-encoding-check",
+        "pre-commit-agent-check",
+    ]
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if encoding hooks are missing."""
+        git_dir = project_path / ".git"
+        if not git_dir.exists():
+            return False  # Not a git repo, can't install hooks
+
+        pre_commit = git_dir / "hooks" / "pre-commit"
+        if not pre_commit.exists():
+            return True
+
+        try:
+            content = pre_commit.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return True
+
+        # Check if it's our hook or a custom one
+        return "spec-kitty" not in content.lower() and "encoding" not in content.lower()
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check if we can install hooks."""
+        git_dir = project_path / ".git"
+        if not git_dir.exists():
+            return False, "Not a git repository"
+
+        hooks_dir = git_dir / "hooks"
+        if not hooks_dir.exists():
+            return True, ""
+
+        pre_commit = hooks_dir / "pre-commit"
+        if pre_commit.exists():
+            try:
+                content = pre_commit.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                return False, "Cannot read existing pre-commit hook"
+
+            # Check if it's our hook
+            if "spec-kitty" not in content.lower() and "encoding" not in content.lower():
+                # It's a custom hook - warn but allow (will append)
+                pass
+
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Install or update pre-commit hooks."""
+        changes: list[str] = []
+        warnings: list[str] = []
+        errors: list[str] = []
+
+        git_dir = project_path / ".git"
+        if not git_dir.exists():
+            errors.append("Not a git repository")
+            return MigrationResult(success=False, errors=errors)
+
+        hooks_dir = git_dir / "hooks"
+
+        # Find hook templates - try .kittify/templates first, then package
+        template_hooks_dir = project_path / ".kittify" / "templates" / "git-hooks"
+
+        if not template_hooks_dir.exists():
+            # Try to find from package
+            try:
+                from importlib.resources import files
+
+                pkg_hooks = files("specify_cli").joinpath("templates", "git-hooks")
+                if hasattr(pkg_hooks, "is_dir") and pkg_hooks.is_dir():
+                    template_hooks_dir = Path(str(pkg_hooks))
+                else:
+                    warnings.append(
+                        "Hook templates not found in .kittify/templates/ or package"
+                    )
+                    return MigrationResult(
+                        success=True, changes_made=changes, warnings=warnings
+                    )
+            except (ImportError, TypeError):
+                warnings.append("Could not locate hook templates")
+                return MigrationResult(
+                    success=True, changes_made=changes, warnings=warnings
+                )
+
+        if dry_run:
+            changes.append("Would install pre-commit hooks from templates")
+            return MigrationResult(success=True, changes_made=changes)
+
+        # Create hooks directory if needed
+        try:
+            hooks_dir.mkdir(exist_ok=True)
+        except OSError as e:
+            errors.append(f"Failed to create hooks directory: {e}")
+            return MigrationResult(success=False, errors=errors)
+
+        # Copy hook files
+        for hook_name in self.HOOK_FILES:
+            template_hook = template_hooks_dir / hook_name
+            dest_hook = hooks_dir / hook_name
+
+            if template_hook.exists():
+                try:
+                    shutil.copy2(template_hook, dest_hook)
+                    dest_hook.chmod(0o755)
+                    changes.append(f"Installed {hook_name} hook")
+                except OSError as e:
+                    errors.append(f"Failed to install {hook_name}: {e}")
+            else:
+                warnings.append(f"Template for {hook_name} not found")
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )

specify_cli/upgrade/migrations/m_0_6_5_commands_rename.py

@@ -0,0 +1,169 @@
+"""Migration: Rename commands/ to command-templates/ directories."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+
+
+@MigrationRegistry.register
+class CommandsRenameMigration(BaseMigration):
+    """Rename commands/ to command-templates/ in templates and missions.
+
+    This migration fixes the issue where Claude Code discovers commands
+    from .kittify/templates/commands/ and .kittify/missions/*/commands/
+    causing duplicate slash commands.
+
+    The directories are renamed to command-templates/ which Claude Code
+    does not automatically discover.
+    """
+
+    migration_id = "0.6.5_commands_rename"
+    description = "Rename commands/ to command-templates/ directories"
+    target_version = "0.6.5"
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if project uses old commands/ directories."""
+        kittify_dir = project_path / ".kittify"
+
+        # Check templates/commands/
+        if (kittify_dir / "templates" / "commands").exists():
+            return True
+
+        # Check missions/*/commands/
+        missions_dir = kittify_dir / "missions"
+        if missions_dir.exists():
+            for mission in missions_dir.iterdir():
+                if mission.is_dir() and (mission / "commands").exists():
+                    return True
+
+        # Check worktrees
+        worktrees_dir = project_path / ".worktrees"
+        if worktrees_dir.exists():
+            for worktree in worktrees_dir.iterdir():
+                if worktree.is_dir():
+                    wt_kittify = worktree / ".kittify"
+                    if (wt_kittify / "templates" / "commands").exists():
+                        return True
+                    wt_missions = wt_kittify / "missions"
+                    if wt_missions.exists():
+                        for mission in wt_missions.iterdir():
+                            if mission.is_dir() and (mission / "commands").exists():
+                                return True
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check for conflicts."""
+        kittify_dir = project_path / ".kittify"
+
+        # Check if both old and new exist in templates
+        templates_dir = kittify_dir / "templates"
+        if templates_dir.exists():
+            old_exists = (templates_dir / "commands").exists()
+            new_exists = (templates_dir / "command-templates").exists()
+            if old_exists and new_exists:
+                return (
+                    False,
+                    "Both commands/ and command-templates/ exist in templates - manual merge required",
+                )
+
+        # Check missions
+        missions_dir = kittify_dir / "missions"
+        if missions_dir.exists():
+            for mission in missions_dir.iterdir():
+                if mission.is_dir():
+                    old_exists = (mission / "commands").exists()
+                    new_exists = (mission / "command-templates").exists()
+                    if old_exists and new_exists:
+                        return (
+                            False,
+                            f"Both directories exist in mission {mission.name} - manual merge required",
+                        )
+
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Rename commands/ to command-templates/."""
+        changes: list[str] = []
+        warnings: list[str] = []
+        errors: list[str] = []
+
+        kittify_dir = project_path / ".kittify"
+
+        def rename_dir(old: Path, new: Path, context: str) -> None:
+            if old.exists() and not new.exists():
+                if dry_run:
+                    changes.append(f"Would rename {context}: commands/ -> command-templates/")
+                else:
+                    try:
+                        shutil.move(str(old), str(new))
+                        changes.append(f"Renamed {context}: commands/ -> command-templates/")
+                    except OSError as e:
+                        errors.append(f"Failed to rename {context}: {e}")
+
+        # Rename in templates/
+        templates_dir = kittify_dir / "templates"
+        if templates_dir.exists():
+            rename_dir(
+                templates_dir / "commands",
+                templates_dir / "command-templates",
+                ".kittify/templates",
+            )
+
+        # Rename in each mission
+        missions_dir = kittify_dir / "missions"
+        if missions_dir.exists():
+            for mission in missions_dir.iterdir():
+                if mission.is_dir():
+                    rename_dir(
+                        mission / "commands",
+                        mission / "command-templates",
+                        f".kittify/missions/{mission.name}",
+                    )
+
+        # Handle worktrees - remove old commands/ directories
+        # (worktrees should use their own .claude/commands/ not templates)
+        worktrees_dir = project_path / ".worktrees"
+        if worktrees_dir.exists():
+            for worktree in worktrees_dir.iterdir():
+                if worktree.is_dir():
+                    # Remove old templates/commands/
+                    wt_templates_commands = worktree / ".kittify" / "templates" / "commands"
+                    if wt_templates_commands.exists():
+                        if dry_run:
+                            changes.append(
+                                f"Would remove old commands/ from worktree {worktree.name}"
+                            )
+                        else:
+                            try:
+                                shutil.rmtree(wt_templates_commands)
+                                changes.append(
+                                    f"Removed old commands/ from worktree {worktree.name}"
+                                )
+                            except OSError as e:
+                                warnings.append(
+                                    f"Could not remove old commands/ from worktree {worktree.name}: {e}"
+                                )
+
+                    # Rename missions/*/commands/ in worktree
+                    wt_missions = worktree / ".kittify" / "missions"
+                    if wt_missions.exists():
+                        for mission in wt_missions.iterdir():
+                            if mission.is_dir():
+                                rename_dir(
+                                    mission / "commands",
+                                    mission / "command-templates",
+                                    f".worktrees/{worktree.name}/.kittify/missions/{mission.name}",
+                                )
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )

specify_cli/upgrade/migrations/m_0_6_7_ensure_missions.py

@@ -0,0 +1,228 @@
+"""Migration: Ensure all missions are present in the project."""
+
+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 EnsureMissionsMigration(BaseMigration):
+    """Ensure all required missions are present in the project.
+
+    This migration addresses the bug in v0.6.5-0.6.6 where the software-dev
+    mission was missing from PyPI packages due to symlink handling issues
+    during build.
+
+    It copies missing missions from the package to the project.
+    """
+
+    migration_id = "0.6.7_ensure_missions"
+    description = "Ensure all required missions (software-dev, research) are present"
+    target_version = "0.6.7"
+
+    # Required missions that should always be present
+    REQUIRED_MISSIONS = ["software-dev", "research"]
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if any required missions are missing."""
+        missions_dir = project_path / ".kittify" / "missions"
+
+        if not missions_dir.exists():
+            return True  # No missions directory at all
+
+        for mission_name in self.REQUIRED_MISSIONS:
+            mission_dir = missions_dir / mission_name
+            if not mission_dir.exists():
+                return True
+            # Check for essential files
+            if not (mission_dir / "mission.yaml").exists():
+                return True
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check if we can copy missions from the package."""
+        # Try to find package missions
+        package_missions = self._find_package_missions()
+        if package_missions is None:
+            # In test environments, package missions may not be available
+            # Skip gracefully rather than blocking all upgrades
+            return (
+                False,
+                "Could not locate package missions to copy from. "
+                "This is expected in test environments. "
+                "Run 'spec-kitty init --force' to repair missions manually.",
+            )
+
+        # Check we have all required missions in the package
+        missing_in_pkg = []
+        for mission_name in self.REQUIRED_MISSIONS:
+            pkg_mission = package_missions / mission_name
+            if not pkg_mission.exists():
+                missing_in_pkg.append(mission_name)
+
+        if missing_in_pkg:
+            return (
+                False,
+                f"Package is missing missions: {', '.join(missing_in_pkg)}. "
+                "Please upgrade spec-kitty-cli to the latest version.",
+            )
+
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Copy missing missions from the package."""
+        changes: list[str] = []
+        warnings: list[str] = []
+        errors: list[str] = []
+
+        missions_dir = project_path / ".kittify" / "missions"
+        package_missions = self._find_package_missions()
+
+        if package_missions is None:
+            errors.append("Could not locate package missions")
+            return MigrationResult(success=False, errors=errors)
+
+        # Ensure missions directory exists
+        if not missions_dir.exists():
+            if dry_run:
+                changes.append("Would create .kittify/missions/ directory")
+            else:
+                missions_dir.mkdir(parents=True, exist_ok=True)
+                changes.append("Created .kittify/missions/ directory")
+
+        # Copy missing missions
+        for mission_name in self.REQUIRED_MISSIONS:
+            dest_mission = missions_dir / mission_name
+            src_mission = package_missions / mission_name
+
+            if dest_mission.exists():
+                # Check if it has essential files
+                if (dest_mission / "mission.yaml").exists():
+                    continue
+                else:
+                    # Mission directory exists but is incomplete
+                    if dry_run:
+                        changes.append(
+                            f"Would repair incomplete mission: {mission_name}"
+                        )
+                    else:
+                        try:
+                            # Remove incomplete and copy fresh
+                            shutil.rmtree(dest_mission)
+                            shutil.copytree(src_mission, dest_mission)
+                            changes.append(f"Repaired incomplete mission: {mission_name}")
+                        except OSError as e:
+                            errors.append(f"Failed to repair mission {mission_name}: {e}")
+            else:
+                # Mission doesn't exist, copy it
+                if dry_run:
+                    changes.append(f"Would copy missing mission: {mission_name}")
+                else:
+                    try:
+                        shutil.copytree(src_mission, dest_mission)
+                        changes.append(f"Copied missing mission: {mission_name}")
+                    except OSError as e:
+                        errors.append(f"Failed to copy mission {mission_name}: {e}")
+
+        # Also fix worktrees
+        worktrees_dir = project_path / ".worktrees"
+        if worktrees_dir.exists():
+            for worktree in worktrees_dir.iterdir():
+                if not worktree.is_dir():
+                    continue
+
+                wt_missions = worktree / ".kittify" / "missions"
+                if not wt_missions.exists():
+                    continue
+
+                for mission_name in self.REQUIRED_MISSIONS:
+                    wt_mission = wt_missions / mission_name
+                    src_mission = package_missions / mission_name
+
+                    if not wt_mission.exists():
+                        if dry_run:
+                            changes.append(
+                                f"Would copy missing mission to worktree {worktree.name}: {mission_name}"
+                            )
+                        else:
+                            try:
+                                shutil.copytree(src_mission, wt_mission)
+                                changes.append(
+                                    f"Copied missing mission to worktree {worktree.name}: {mission_name}"
+                                )
+                            except OSError as e:
+                                warnings.append(
+                                    f"Could not copy mission to worktree {worktree.name}: {e}"
+                                )
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )
+
+    def _find_package_missions(self) -> Path | None:
+        """Find the missions directory in the installed package or local repo."""
+        # First try from installed package
+        try:
+            from importlib.resources import files
+
+            pkg_files = files("specify_cli")
+            missions_path = pkg_files.joinpath("missions")
+
+            # Convert to Path and check if it exists
+            missions_str = str(missions_path)
+            if Path(missions_str).exists():
+                return Path(missions_str)
+
+        except (ImportError, TypeError, AttributeError):
+            pass
+
+        # Try from package __file__ location
+        try:
+            import specify_cli
+
+            pkg_dir = Path(specify_cli.__file__).parent
+            missions_dir = pkg_dir / "missions"
+            if missions_dir.exists():
+                return missions_dir
+        except (ImportError, AttributeError):
+            pass
+
+        # Fallback for development: Check SPEC_KITTY_TEMPLATE_ROOT env var
+        import os
+
+        template_root = os.environ.get("SPEC_KITTY_TEMPLATE_ROOT")
+        if template_root:
+            missions_dir = Path(template_root) / ".kittify" / "missions"
+            if missions_dir.exists():
+                return missions_dir
+
+        # Fallback: Try to find the spec-kitty repo root from current working directory
+        # This handles cases where we're running from the repo in development
+        try:
+            cwd = Path.cwd()
+            # Check if we're in the spec-kitty repo
+            for parent in [cwd] + list(cwd.parents):
+                missions_dir = parent / ".kittify" / "missions"
+                pyproject = parent / "pyproject.toml"
+                if missions_dir.exists() and pyproject.exists():
+                    # Verify it's the spec-kitty repo by checking pyproject.toml
+                    try:
+                        content = pyproject.read_text(encoding='utf-8-sig')
+                        if "spec-kitty-cli" in content:
+                            return missions_dir
+                    except OSError:
+                        pass
+        except OSError:
+            pass
+
+        return None

specify_cli/upgrade/migrations/m_0_7_2_worktree_commands_dedup.py

@@ -0,0 +1,89 @@
+"""Migration: Remove duplicate .claude/commands/ from worktrees."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from ..registry import MigrationRegistry
+from .base import BaseMigration, MigrationResult
+
+
+@MigrationRegistry.register
+class WorktreeCommandsDedupMigration(BaseMigration):
+    """Remove .claude/commands/ from worktrees - they inherit from main repo.
+
+    Claude Code traverses parent directories looking for .claude/commands/.
+    When a worktree is located inside the main repo (at .worktrees/),
+    the worktree can find commands by traversing up to the main repo.
+
+    This migration removes .claude/commands/ from worktrees since they
+    don't need their own copy - they inherit from the main repo.
+    """
+
+    migration_id = "0.7.2_worktree_commands_dedup"
+    description = "Remove duplicate .claude/commands/ from worktrees (inherit from main repo)"
+    target_version = "0.7.2"
+
+    def detect(self, project_path: Path) -> bool:
+        """Check if any worktrees have their own .claude/commands/."""
+        worktrees_dir = project_path / ".worktrees"
+
+        if not worktrees_dir.exists():
+            return False
+
+        for worktree in worktrees_dir.iterdir():
+            if worktree.is_dir():
+                wt_commands = worktree / ".claude" / "commands"
+                if wt_commands.exists():
+                    return True
+
+        return False
+
+    def can_apply(self, project_path: Path) -> tuple[bool, str]:
+        """Check that main repo has commands before removing from worktrees."""
+        main_claude_commands = project_path / ".claude" / "commands"
+
+        if not main_claude_commands.exists():
+            return (
+                False,
+                "Main repo .claude/commands/ must exist before removing from worktrees"
+            )
+
+        return True, ""
+
+    def apply(self, project_path: Path, dry_run: bool = False) -> MigrationResult:
+        """Remove .claude/commands/ from all worktrees."""
+        changes: list[str] = []
+        warnings: list[str] = []
+        errors: list[str] = []
+
+        worktrees_dir = project_path / ".worktrees"
+
+        if worktrees_dir.exists():
+            for worktree in worktrees_dir.iterdir():
+                if worktree.is_dir():
+                    wt_commands = worktree / ".claude" / "commands"
+                    if wt_commands.exists():
+                        if dry_run:
+                            changes.append(
+                                f"Would remove .claude/commands/ from worktree {worktree.name}"
+                            )
+                        else:
+                            try:
+                                shutil.rmtree(wt_commands)
+                                changes.append(
+                                    f"Removed .claude/commands/ from worktree {worktree.name} (inherits from main repo)"
+                                )
+                            except OSError as e:
+                                errors.append(
+                                    f"Failed to remove .claude/commands/ from {worktree.name}: {e}"
+                                )
+
+        success = len(errors) == 0
+        return MigrationResult(
+            success=success,
+            changes_made=changes,
+            errors=errors,
+            warnings=warnings,
+        )