Merge pull request #166 from Priivacy-ai/codex/2x-upgrade-auto-commit-project-dirs

feat(upgrade): auto-commit project-directory upgrade changes

Author: robertDouglass

src/specify_cli/cli/commands/upgrade.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import subprocess
 from datetime import datetime
 from pathlib import Path
 from typing import Optional
@@ -12,6 +13,126 @@
 from rich.table import Table
 
 from specify_cli.cli.helpers import console, show_banner
+from specify_cli.git.commit_helpers import safe_commit
+
+
+def _git_status_paths(repo_path: Path) -> set[str] | None:
+    """Return git status paths for *repo_path* using porcelain -z output.
+
+    Returns ``None`` when ``git status`` fails (e.g. not a git repo) so
+    callers can distinguish "no dirty files" from "unable to determine".
+    """
+    result = subprocess.run(
+        ["git", "status", "--porcelain", "-z"],
+        cwd=repo_path,
+        capture_output=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+
+    entries = result.stdout.decode("utf-8", errors="replace").split("\0")
+    paths: set[str] = set()
+
+    i = 0
+    while i < len(entries):
+        entry = entries[i]
+        i += 1
+        if not entry or len(entry) < 4:
+            continue
+
+        status = entry[:2]
+        path = entry[3:]
+
+        # With -z format, renames/copies include a second NUL-separated
+        # path.  We take the *destination* (new name); the source (old name)
+        # is intentionally discarded because we care about "what exists now".
+        if "R" in status or "C" in status:
+            if i < len(entries) and entries[i]:
+                path = entries[i]
+                i += 1
+
+        normalized = path.strip().replace("\\", "/")
+        if normalized.startswith("./"):
+            normalized = normalized[2:]
+
+        if normalized:
+            paths.add(normalized)
+
+    return paths
+
+
+def _is_upgrade_commit_eligible(path: str, project_path: Path) -> bool:
+    """Return True when a changed file should be included in upgrade auto-commit."""
+    normalized = path.strip().replace("\\", "/")
+    if not normalized:
+        return False
+
+    # Ignore paths that are outside the repo and root-level files.
+    if normalized.startswith("../") or "/" not in normalized:
+        return False
+
+    # Never auto-commit ~/.kittify when users run inside their home directory.
+    if project_path.resolve() == Path.home().resolve() and normalized.startswith(".kittify/"):
+        return False
+
+    return True
+
+
+def _prepare_upgrade_commit_files(
+    project_path: Path,
+    baseline_paths: set[str] | None,
+) -> list[Path]:
+    """Collect newly changed project-directory files after an upgrade run.
+
+    Returns an empty list when *baseline_paths* is ``None`` (git status
+    failed at baseline time) to avoid accidentally committing unrelated work.
+    """
+    if baseline_paths is None:
+        return []
+
+    current_paths = _git_status_paths(project_path)
+    if current_paths is None:
+        return []
+
+    new_paths = sorted(
+        path
+        for path in current_paths
+        if path not in baseline_paths and _is_upgrade_commit_eligible(path, project_path)
+    )
+    return [Path(path) for path in new_paths]
+
+
+def _auto_commit_upgrade_changes(
+    project_path: Path,
+    from_version: str,
+    to_version: str,
+    baseline_paths: set[str] | None,
+) -> tuple[bool, list[str], str | None]:
+    """Auto-commit newly introduced project-directory upgrade changes."""
+    files_to_commit = _prepare_upgrade_commit_files(project_path, baseline_paths)
+    if not files_to_commit:
+        return False, [], None
+
+    commit_message = (
+        f"chore: apply spec-kitty upgrade changes ({from_version} -> {to_version})"
+    )
+    commit_success = safe_commit(
+        repo_path=project_path,
+        files_to_commit=files_to_commit,
+        commit_message=commit_message,
+        allow_empty=False,
+    )
+    committed_paths = [str(path).replace("\\", "/") for path in files_to_commit]
+
+    if commit_success:
+        return True, committed_paths, None
+
+    return (
+        False,
+        committed_paths,
+        "Could not auto-commit upgrade changes; please review and commit manually.",
+    )
 
 
 def upgrade(
@@ -44,6 +165,7 @@ def upgrade(
         show_banner()
 
     project_path = Path.cwd()
+    baseline_changed_paths = _git_status_paths(project_path)
     kittify_dir = project_path / ".kittify"
     specify_dir = project_path / ".specify"  # Old name
 
@@ -89,27 +211,49 @@ def upgrade(
     migrations_needed = MigrationRegistry.get_applicable(version_for_migration, target_version, project_path=project_path)
 
     if not migrations_needed:
+        auto_committed = False
+        auto_commit_paths: list[str] = []
+        auto_commit_warning: str | None = None
+
         # Still stamp the version even when no migrations are needed
         from specify_cli.upgrade.metadata import ProjectMetadata
 
         metadata = ProjectMetadata.load(kittify_dir)
-        if metadata and metadata.version != target_version:
+        if metadata and metadata.version != target_version and not dry_run:
             metadata.version = target_version
             metadata.last_upgraded_at = datetime.now()
             metadata.save(kittify_dir)
 
+        if not dry_run:
+            auto_committed, auto_commit_paths, auto_commit_warning = _auto_commit_upgrade_changes(
+                project_path=project_path,
+                from_version=current_version,
+                to_version=target_version,
+                baseline_paths=baseline_changed_paths,
+            )
+
         if json_output:
+            warnings = [auto_commit_warning] if auto_commit_warning else []
             console.print(
                 json.dumps(
                     {
                         "status": "up_to_date",
                         "current_version": current_version,
                         "target_version": target_version,
+                        "auto_committed": auto_committed,
+                        "auto_commit_paths": auto_commit_paths,
+                        "warnings": warnings,
                     }
                 )
             )
         else:
             console.print("[green]Project is already up to date![/green]")
+            if auto_committed:
+                console.print(
+                    f"[cyan]→ Auto-committed upgrade changes ({len(auto_commit_paths)} files)[/cyan]"
+                )
+            if auto_commit_warning:
+                console.print(f"[yellow]Warning:[/yellow] {auto_commit_warning}")
         return
 
     # Show migration plan
@@ -162,6 +306,19 @@ def upgrade(
         include_worktrees=not no_worktrees,
     )
 
+    auto_committed = False
+    auto_commit_paths: list[str] = []
+    auto_commit_warning: str | None = None
+    if result.success and not dry_run:
+        auto_committed, auto_commit_paths, auto_commit_warning = _auto_commit_upgrade_changes(
+            project_path=project_path,
+            from_version=result.from_version,
+            to_version=result.to_version,
+            baseline_paths=baseline_changed_paths,
+        )
+        if auto_commit_warning:
+            result.warnings.append(auto_commit_warning)
+
     if json_output:
         # Build detailed migrations array
         migrations_detail = []
@@ -187,6 +344,8 @@ def upgrade(
             "success": result.success,
             "errors": result.errors,
             "warnings": result.warnings,
+            "auto_committed": auto_committed,
+            "auto_commit_paths": auto_commit_paths,
         }
         console.print(json.dumps(output, indent=2))
         return
@@ -227,6 +386,10 @@ def upgrade(
         console.print(
             f"[bold green]Upgrade complete![/bold green] {result.from_version} -> {result.to_version}"
         )
+        if auto_committed:
+            console.print(
+                f"[cyan]→ Auto-committed upgrade changes ({len(auto_commit_paths)} files)[/cyan]"
+            )
     else:
         console.print("[bold red]Upgrade failed.[/bold red]")
         raise typer.Exit(1)