@pennyfarthing/core 10.0.2 → 10.0.5

package/pennyfarthing_scripts/git/status_all.py

@@ -0,0 +1,310 @@
+"""
+Git status for all repos - async parallel execution.
+
+Story: MSSCI-12402 - Port git utility scripts to Python
+
+Replaces: pennyfarthing-dist/scripts/git/git-status-all.sh
+
+Features:
+- asyncio.gather for true parallel git operations
+- Structured RepoStatus dataclass for programmatic access
+- Both brief and full output formatting
+- Cross-platform compatible
+"""
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+
+
+@dataclass
+class RepoStatus:
+    """Status information for a single repository."""
+
+    name: str
+    path: Path
+    branch: str
+    changes: list[str]  # List of changed files (git status --short lines)
+    unpushed_commits: list[str]  # List of unpushed commit messages
+    error: str | None = None  # Error message if status check failed
+
+    @property
+    def is_clean(self) -> bool:
+        """Return True if repo has no uncommitted changes."""
+        return len(self.changes) == 0
+
+    @property
+    def has_unpushed(self) -> bool:
+        """Return True if repo has unpushed commits."""
+        return len(self.unpushed_commits) > 0
+
+
+async def _run_git_command(args: list[str], cwd: Path) -> tuple[str, str, int]:
+    """Run a git command asynchronously.
+
+    Args:
+        args: Git command arguments (without 'git')
+        cwd: Working directory for the command
+
+    Returns:
+        Tuple of (stdout, stderr, return_code)
+    """
+    proc = await asyncio.create_subprocess_exec(
+        "git",
+        *args,
+        cwd=cwd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    return (
+        stdout.decode("utf-8", errors="replace").strip(),
+        stderr.decode("utf-8", errors="replace").strip(),
+        proc.returncode or 0,
+    )
+
+
+async def get_repo_status(name: str, path: Path) -> RepoStatus:
+    """Get git status for a single repository.
+
+    Args:
+        name: Display name for the repo
+        path: Path to the repository
+
+    Returns:
+        RepoStatus with current branch, changes, and unpushed commits
+    """
+    # Check if path exists
+    if not path.exists():
+        return RepoStatus(
+            name=name,
+            path=path,
+            branch="",
+            changes=[],
+            unpushed_commits=[],
+            error=f"Path not found: {path}",
+        )
+
+    # Check if it's a git repo
+    git_dir = path / ".git"
+    if not git_dir.exists() and not (path / "..").joinpath(".git").exists():
+        # Also check if path itself is a git dir (bare repo or worktree)
+        try:
+            _, _, rc = await _run_git_command(["rev-parse", "--git-dir"], path)
+            if rc != 0:
+                return RepoStatus(
+                    name=name,
+                    path=path,
+                    branch="",
+                    changes=[],
+                    unpushed_commits=[],
+                    error=f"Not a git repository: {path}",
+                )
+        except Exception as e:
+            return RepoStatus(
+                name=name,
+                path=path,
+                branch="",
+                changes=[],
+                unpushed_commits=[],
+                error=f"Git command failed: {e}",
+            )
+
+    try:
+        # Get current branch
+        branch_out, _, branch_rc = await _run_git_command(
+            ["branch", "--show-current"], path
+        )
+        if branch_rc != 0 or not branch_out:
+            # Might be in detached HEAD state
+            branch_out = "detached"
+
+        # Get status (uncommitted changes)
+        status_out, _, _ = await _run_git_command(["status", "--short"], path)
+        changes = [line for line in status_out.split("\n") if line.strip()]
+
+        # Get unpushed commits (comparing to origin/develop)
+        unpushed_out, _, unpushed_rc = await _run_git_command(
+            ["log", "origin/develop..HEAD", "--oneline"], path
+        )
+        if unpushed_rc == 0 and unpushed_out:
+            unpushed_commits = [
+                line for line in unpushed_out.split("\n") if line.strip()
+            ]
+        else:
+            unpushed_commits = []
+
+        return RepoStatus(
+            name=name,
+            path=path,
+            branch=branch_out,
+            changes=changes,
+            unpushed_commits=unpushed_commits,
+        )
+
+    except Exception as e:
+        return RepoStatus(
+            name=name,
+            path=path,
+            branch="",
+            changes=[],
+            unpushed_commits=[],
+            error=f"Error getting status: {e}",
+        )
+
+
+async def get_all_repo_status(repos: Sequence[tuple[str, Path]]) -> list[RepoStatus]:
+    """Get git status for all repos in parallel using asyncio.gather.
+
+    Args:
+        repos: Sequence of (name, path) tuples for each repo
+
+    Returns:
+        List of RepoStatus objects in same order as input
+    """
+    if not repos:
+        return []
+
+    tasks = [get_repo_status(name, path) for name, path in repos]
+    results = await asyncio.gather(*tasks, return_exceptions=False)
+    return list(results)
+
+
+def format_status_brief(statuses: Sequence[RepoStatus]) -> str:
+    """Format repo statuses as brief one-line-per-repo output.
+
+    Format: "repo_name: branch_name [M] [↑N]"
+    - M = has modifications
+    - ↑N = N unpushed commits
+
+    Args:
+        statuses: Sequence of RepoStatus objects
+
+    Returns:
+        Multi-line string with brief status for each repo
+    """
+    lines = []
+    for status in statuses:
+        indicators = []
+
+        # Modification indicator
+        if not status.is_clean:
+            indicators.append("M")
+        else:
+            indicators.append("✓")
+
+        # Unpushed indicator
+        if status.has_unpushed:
+            indicators.append(f"↑{len(status.unpushed_commits)}")
+
+        indicator_str = " ".join(indicators)
+        lines.append(f"{status.name}: {status.branch} {indicator_str}")
+
+    return "\n".join(lines)
+
+
+def format_status_full(statuses: Sequence[RepoStatus]) -> str:
+    """Format repo statuses as full detailed output.
+
+    Shows branch, changes (up to 10), and unpushed commits (up to 5).
+
+    Args:
+        statuses: Sequence of RepoStatus objects
+
+    Returns:
+        Multi-line string with detailed status for each repo
+    """
+    sections = []
+
+    for status in statuses:
+        lines = []
+        lines.append(f"=== {status.name} ===")
+        lines.append(f"Branch: {status.branch}")
+
+        if status.error:
+            lines.append(f"Error: {status.error}")
+        elif status.changes:
+            lines.append("Changes:")
+            for change in status.changes[:10]:
+                lines.append(f"  {change}")
+            if len(status.changes) > 10:
+                lines.append(f"  ... and {len(status.changes) - 10} more")
+        else:
+            lines.append("Clean")
+
+        if status.unpushed_commits:
+            lines.append(f"Unpushed ({len(status.unpushed_commits)}):")
+            for commit in status.unpushed_commits[:5]:
+                lines.append(f"  {commit}")
+            if len(status.unpushed_commits) > 5:
+                lines.append(f"  ... and {len(status.unpushed_commits) - 5} more")
+
+        lines.append("")
+        sections.append("\n".join(lines))
+
+    return "\n".join(sections)
+
+
+def format_summary(statuses: Sequence[RepoStatus]) -> str:
+    """Format summary of all repo statuses.
+
+    Args:
+        statuses: Sequence of RepoStatus objects
+
+    Returns:
+        Summary string with total changes and unpushed counts
+    """
+    total_changes = sum(len(s.changes) for s in statuses)
+    total_unpushed = sum(len(s.unpushed_commits) for s in statuses)
+
+    if total_changes == 0 and total_unpushed == 0:
+        return "✅ All repos clean and pushed"
+
+    parts = []
+    if total_changes > 0:
+        parts.append(f"{total_changes} uncommitted change(s)")
+    if total_unpushed > 0:
+        parts.append(f"{total_unpushed} unpushed commit(s)")
+
+    return " | ".join(parts)
+
+
+async def main(brief: bool = False) -> int:
+    """CLI entry point for git-status-all.
+
+    Args:
+        brief: If True, use brief output format
+
+    Returns:
+        0 if all repos clean, 1 if any have changes/unpushed
+    """
+    from pennyfarthing_scripts.common.config import get_project_root
+
+    # For now, just check the current project
+    project_root = get_project_root()
+    repos = [("pennyfarthing", project_root)]
+
+    statuses = await get_all_repo_status(repos)
+
+    if brief:
+        print(format_status_brief(statuses))
+    else:
+        print("━" * 40)
+        print("  Git Status - All Repos")
+        print("━" * 40)
+        print()
+        print(format_status_full(statuses))
+        print("━" * 40)
+        print(format_summary(statuses))
+
+    # Return 1 if any repo has changes or unpushed
+    has_issues = any(not s.is_clean or s.has_unpushed for s in statuses)
+    return 1 if has_issues else 0
+
+
+if __name__ == "__main__":
+    import sys
+
+    brief_mode = "--brief" in sys.argv or "-b" in sys.argv
+    sys.exit(asyncio.run(main(brief=brief_mode)))

package/pennyfarthing_scripts/hooks/cyclist-pretooluse-hook.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Cyclist PreToolUse Hook - Shell wrapper for Python implementation
+# Calls pretooluse_hook.py which handles WheelHub communication
+# Story: MSSCI-14320
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec python3 "$SCRIPT_DIR/../pretooluse_hook.py"