@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing_scripts/git/repos.py

@@ -0,0 +1,196 @@
+"""
+Repos.yaml loader — Python replacement for repo-utils.sh (778 lines).
+
+Reads .pennyfarthing/repos.yaml and provides structured access to repo
+configuration: paths, types, branches, build/test commands, dependencies.
+
+Usage:
+    from pennyfarthing_scripts.git.repos import load_repos_config, get_repo_paths
+
+    config = load_repos_config()
+    for name, repo in config.items():
+        print(f"{name}: {repo.path} ({repo.default_branch})")
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from pennyfarthing_scripts.common.config import get_project_root
+
+
+@dataclass
+class RepoConfig:
+    """Configuration for a single repository."""
+
+    name: str
+    path: str  # Relative to project root (e.g., "." or "pennyfarthing")
+    repo_type: str  # "orchestrator", "framework", "api", "ui", etc.
+    default_branch: str  # "main" for trunk-based, "develop" for gitflow
+    branch_strategy: str  # "trunk-based" or "gitflow"
+    description: str = ""
+    language: str = "unknown"
+    test_command: str = ""
+    build_command: str = ""
+    lint_command: str = ""
+    test_filter_flag: str = ""
+    dependencies: list[str] = field(default_factory=list)
+    owns: list[str] = field(default_factory=list)
+    never_edit: list[str] = field(default_factory=list)
+    ui_layer: str = "none"
+
+    @property
+    def is_gitflow(self) -> bool:
+        return self.branch_strategy == "gitflow"
+
+    @property
+    def upstream_ref(self) -> str:
+        """Remote ref to compare against for unpushed commits."""
+        return f"origin/{self.default_branch}"
+
+
+def _parse_repo_entry(name: str, data: dict[str, Any] | None) -> RepoConfig:
+    """Parse a single repo entry from repos.yaml."""
+    if data is None:
+        data = {}
+    return RepoConfig(
+        name=name,
+        path=data.get("path", name),
+        repo_type=data.get("type", "unknown"),
+        default_branch=data.get("default_branch", "main"),
+        branch_strategy=data.get("branch_strategy", "trunk-based"),
+        description=data.get("description", ""),
+        language=data.get("language", "unknown"),
+        test_command=data.get("test_command", ""),
+        build_command=data.get("build_command", ""),
+        lint_command=data.get("lint_command", ""),
+        test_filter_flag=data.get("test_filter_flag", ""),
+        dependencies=data.get("dependencies", []) or [],
+        owns=data.get("owns", []) or [],
+        never_edit=data.get("never_edit", []) or [],
+        ui_layer=data.get("ui_layer", "none"),
+    )
+
+
+def load_repos_config(project_root: Path | None = None) -> dict[str, RepoConfig]:
+    """Load repos.yaml and return a dict of name -> RepoConfig.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        Ordered dict of repo name -> RepoConfig.
+        Empty dict if repos.yaml not found.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos_path = project_root / ".pennyfarthing" / "repos.yaml"
+    if not repos_path.exists():
+        return {}
+
+    with open(repos_path) as f:
+        config = yaml.safe_load(f)
+
+    if not config or "repos" not in config:
+        return {}
+
+    repos: dict[str, RepoConfig] = {}
+    for name, data in config["repos"].items():
+        repos[name] = _parse_repo_entry(name, data)
+
+    return repos
+
+
+def get_repo_paths(project_root: Path | None = None) -> list[tuple[str, Path]]:
+    """Get list of (name, absolute_path) tuples for all configured repos.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        List of (repo_name, absolute_path) tuples.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos = load_repos_config(project_root)
+    result = []
+    for name, repo in repos.items():
+        abs_path = (project_root / repo.path).resolve()
+        if abs_path.exists():
+            result.append((name, abs_path))
+    return result
+
+
+def get_default_branch(
+    repo_name: str, project_root: Path | None = None
+) -> str:
+    """Get the default branch for a specific repo.
+
+    Args:
+        repo_name: Name of the repo in repos.yaml.
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        Default branch name (e.g., "main" or "develop").
+        Falls back to "main" if repo not found.
+    """
+    repos = load_repos_config(project_root)
+    if repo_name in repos:
+        return repos[repo_name].default_branch
+    return "main"
+
+
+def get_repo_config(
+    repo_name: str, project_root: Path | None = None
+) -> RepoConfig | None:
+    """Get the full config for a specific repo.
+
+    Args:
+        repo_name: Name of the repo in repos.yaml.
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        RepoConfig or None if not found.
+    """
+    repos = load_repos_config(project_root)
+    return repos.get(repo_name)
+
+
+def get_build_order(project_root: Path | None = None) -> list[str]:
+    """Get repos in build/dependency order.
+
+    Uses explicit build_order from repos.yaml if present,
+    otherwise returns repos in definition order.
+
+    Args:
+        project_root: Project root directory. Auto-detected if not provided.
+
+    Returns:
+        List of repo names in build order.
+    """
+    if project_root is None:
+        project_root = get_project_root()
+
+    repos_path = project_root / ".pennyfarthing" / "repos.yaml"
+    if not repos_path.exists():
+        return []
+
+    with open(repos_path) as f:
+        config = yaml.safe_load(f)
+
+    if not config:
+        return []
+
+    if "build_order" in config:
+        return config["build_order"]
+
+    if "repos" in config:
+        return list(config["repos"].keys())
+
+    return []

package/pennyfarthing_scripts/git/status_all.py

@@ -65,12 +65,15 @@ async def _run_git_command(args: list[str], cwd: Path) -> tuple[str, str, int]:
     )
 
 
-async def get_repo_status(name: str, path: Path) -> RepoStatus:
+async def get_repo_status(
+    name: str, path: Path, upstream_ref: str = "origin/develop"
+) -> RepoStatus:
     """Get git status for a single repository.
 
     Args:
         name: Display name for the repo
         path: Path to the repository
+        upstream_ref: Remote ref to compare for unpushed commits (default: origin/develop)
 
     Returns:
         RepoStatus with current branch, changes, and unpushed commits
@@ -124,9 +127,9 @@ async def get_repo_status(name: str, path: Path) -> RepoStatus:
         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)
+        # Get unpushed commits (comparing to upstream ref)
         unpushed_out, _, unpushed_rc = await _run_git_command(
-            ["log", "origin/develop..HEAD", "--oneline"], path
+            ["log", f"{upstream_ref}..HEAD", "--oneline"], path
         )
         if unpushed_rc == 0 and unpushed_out:
             unpushed_commits = [
@@ -154,11 +157,13 @@ async def get_repo_status(name: str, path: Path) -> RepoStatus:
         )
 
 
-async def get_all_repo_status(repos: Sequence[tuple[str, Path]]) -> list[RepoStatus]:
+async def get_all_repo_status(
+    repos: Sequence[tuple[str, Path, str] | 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
+        repos: Sequence of (name, path) or (name, path, upstream_ref) tuples
 
     Returns:
         List of RepoStatus objects in same order as input
@@ -166,7 +171,14 @@ async def get_all_repo_status(repos: Sequence[tuple[str, Path]]) -> list[RepoSta
     if not repos:
         return []
 
-    tasks = [get_repo_status(name, path) for name, path in repos]
+    tasks = []
+    for entry in repos:
+        if len(entry) == 3:
+            name, path, upstream_ref = entry  # type: ignore[misc]
+            tasks.append(get_repo_status(name, path, upstream_ref))
+        else:
+            name, path = entry  # type: ignore[misc]
+            tasks.append(get_repo_status(name, path))
     results = await asyncio.gather(*tasks, return_exceptions=False)
     return list(results)
 
@@ -279,13 +291,17 @@ async def main(brief: bool = False) -> int:
     Returns:
         0 if all repos clean, 1 if any have changes/unpushed
     """
-    from pennyfarthing_scripts.common.config import get_project_root
+    from pennyfarthing_scripts.git.repos import load_repos_config, get_repo_paths
+
+    repos_with_upstream: list[tuple[str, Path, str]] = []
+    repo_paths = get_repo_paths()
+    config = load_repos_config()
 
-    # For now, just check the current project
-    project_root = get_project_root()
-    repos = [("pennyfarthing", project_root)]
+    for name, path in repo_paths:
+        upstream = config[name].upstream_ref if name in config else "origin/develop"
+        repos_with_upstream.append((name, path, upstream))
 
-    statuses = await get_all_repo_status(repos)
+    statuses = await get_all_repo_status(repos_with_upstream)
 
     if brief:
         print(format_status_brief(statuses))

package/pennyfarthing_scripts/git/worktree.py

@@ -0,0 +1,302 @@
+"""
+Git worktree management — Python replacement for worktree-manager.sh (498 lines).
+
+Manages git worktrees for parallel development across multiple repos.
+
+Usage via CLI:
+    pf git worktree create <name> <branch> [--repos all|api|ui|name1,name2]
+    pf git worktree remove <name>
+    pf git worktree list
+    pf git worktree status
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from pennyfarthing_scripts.common.config import get_project_root
+from pennyfarthing_scripts.git.repos import load_repos_config
+
+
+def _git(args: list[str], cwd: Path) -> tuple[str, int]:
+    """Run a git command synchronously.
+
+    Returns:
+        Tuple of (stdout, return_code)
+    """
+    result = subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip(), result.returncode
+
+
+def _get_worktree_root(project_root: Path | None = None) -> Path:
+    """Get worktree root directory."""
+    if project_root is None:
+        project_root = get_project_root()
+    env_root = os.environ.get("WORKTREE_ROOT")
+    if env_root:
+        return Path(env_root)
+    return project_root / "worktrees"
+
+
+def _filter_repos(
+    repos: dict[str, object], filter_str: str
+) -> list[str]:
+    """Filter repo names by type or comma-separated list."""
+    from pennyfarthing_scripts.git.repos import RepoConfig
+
+    if filter_str in ("all", "both"):
+        return list(repos.keys())
+
+    # Check if it's a type filter
+    if filter_str in ("api", "ui", "adapter", "service"):
+        return [
+            name
+            for name, cfg in repos.items()
+            if isinstance(cfg, RepoConfig) and cfg.repo_type == filter_str
+        ]
+
+    # Comma-separated list of names
+    return [n.strip() for n in filter_str.split(",") if n.strip()]
+
+
+def create_worktree(name: str, branch: str, repos_filter: str = "all") -> int:
+    """Create worktree(s) for parallel work.
+
+    Args:
+        name: Worktree name (e.g., wt-5-3a)
+        branch: Branch name (e.g., feat/5-3a-file-upload)
+        repos_filter: Which repos to target (all, api, ui, or comma-separated)
+
+    Returns:
+        0 on success, 1 on error
+    """
+    project_root = get_project_root()
+    wt_root = _get_worktree_root(project_root)
+    wt_path = wt_root / name
+
+    if wt_path.exists():
+        print(f"Error: Worktree '{name}' already exists at {wt_path}")
+        return 1
+
+    repos = load_repos_config(project_root)
+    if not repos:
+        print("Error: No repositories configured in repos.yaml")
+        return 1
+
+    target_names = _filter_repos(repos, repos_filter)
+    if not target_names:
+        print(f"No repos match filter: {repos_filter}")
+        return 1
+
+    wt_path.mkdir(parents=True, exist_ok=True)
+
+    print(f"Creating worktree: {name}")
+    print(f"  Branch: {branch}")
+    print(f"  Path: {wt_path}")
+    print(f"  Repos: {repos_filter}")
+    print()
+
+    created = []
+    for repo_name in target_names:
+        if repo_name not in repos:
+            print(f"  SKIP {repo_name} (not in config)")
+            continue
+
+        cfg = repos[repo_name]
+        full_path = (project_root / cfg.path).resolve()
+
+        if not full_path.exists():
+            print(f"  SKIP {repo_name} (path not found: {full_path})")
+            continue
+
+        print(f"Creating worktree for {repo_name} ({cfg.repo_type})...")
+        repo_wt = wt_path / repo_name
+
+        # Check if branch exists locally or remotely
+        _, local_rc = _git(
+            ["show-ref", "--verify", "--quiet", f"refs/heads/{branch}"],
+            full_path,
+        )
+        _, remote_rc = _git(
+            ["show-ref", "--verify", "--quiet", f"refs/remotes/origin/{branch}"],
+            full_path,
+        )
+
+        if local_rc == 0 or remote_rc == 0:
+            _, rc = _git(["worktree", "add", str(repo_wt), branch], full_path)
+        else:
+            # Create new branch from default branch
+            base = cfg.default_branch
+            _, base_rc = _git(
+                ["show-ref", "--verify", "--quiet", f"refs/heads/{base}"],
+                full_path,
+            )
+            if base_rc != 0:
+                base = "main"
+            _, rc = _git(
+                ["worktree", "add", "-b", branch, str(repo_wt), base],
+                full_path,
+            )
+
+        if rc == 0:
+            print(f"  OK {repo_name}")
+            created.append(repo_name)
+        else:
+            print(f"  FAIL {repo_name}")
+
+    print()
+    if created:
+        print(f"Worktree '{name}' created successfully!")
+        print()
+        print("Next steps:")
+        for repo_name in created:
+            print(f"  cd {wt_path / repo_name}")
+    else:
+        print("No worktrees created.")
+        return 1
+
+    return 0
+
+
+def remove_worktree(name: str) -> int:
+    """Remove worktree and clean up.
+
+    Args:
+        name: Worktree name to remove
+
+    Returns:
+        0 on success, 1 on error
+    """
+    project_root = get_project_root()
+    wt_root = _get_worktree_root(project_root)
+    wt_path = wt_root / name
+
+    if not wt_path.exists():
+        print(f"Error: Worktree '{name}' not found at {wt_path}")
+        return 1
+
+    print(f"Removing worktree: {name}")
+
+    repos = load_repos_config(project_root)
+    for repo_name, cfg in repos.items():
+        repo_wt = wt_path / repo_name
+        if repo_wt.exists():
+            full_path = (project_root / cfg.path).resolve()
+            print(f"  Removing {repo_name} worktree...")
+            _git(["worktree", "remove", str(repo_wt), "--force"], full_path)
+
+    # Clean up directory
+    import shutil
+
+    if wt_path.exists():
+        shutil.rmtree(wt_path)
+
+    # Prune worktree references
+    for repo_name, cfg in repos.items():
+        full_path = (project_root / cfg.path).resolve()
+        if full_path.exists():
+            _git(["worktree", "prune"], full_path)
+
+    print()
+    print("Note: Session file (if any) should be archived via /sm finish")
+    print()
+    print(f"Worktree '{name}' removed successfully!")
+    return 0
+
+
+def list_worktrees() -> int:
+    """List all active worktrees.
+
+    Returns:
+        0 always
+    """
+    project_root = get_project_root()
+    wt_root = _get_worktree_root(project_root)
+    repos = load_repos_config(project_root)
+
+    print("=== Active Worktrees ===")
+    print()
+
+    for repo_name, cfg in repos.items():
+        full_path = (project_root / cfg.path).resolve()
+        if full_path.exists():
+            print(f"{repo_name} ({cfg.repo_type}):")
+            output, _ = _git(["worktree", "list"], full_path)
+            if output:
+                print(output)
+            print()
+
+    print("Worktree Directory:")
+    if wt_root.exists() and any(wt_root.iterdir()):
+        for item in sorted(wt_root.iterdir()):
+            if item.is_dir():
+                print(f"  {item.name}/")
+    else:
+        print("  (empty)")
+
+    return 0
+
+
+def show_worktree_status() -> int:
+    """Show detailed worktree status.
+
+    Returns:
+        0 always
+    """
+    project_root = get_project_root()
+    wt_root = _get_worktree_root(project_root)
+    repos = load_repos_config(project_root)
+
+    print("=== Worktree Status ===")
+    print()
+
+    if not wt_root.exists() or not any(wt_root.iterdir()):
+        print("No active worktrees.")
+        print()
+        print("Create one with:")
+        print("  pf git worktree create <name> <branch>")
+        return 0
+
+    for wt_dir in sorted(wt_root.iterdir()):
+        if not wt_dir.is_dir():
+            continue
+
+        wt_name = wt_dir.name
+        print(f"{wt_name}")
+        print(f"  Path: {wt_dir}")
+
+        for repo_name, cfg in repos.items():
+            repo_wt = wt_dir / repo_name
+            if repo_wt.exists():
+                branch, _ = _git(["branch", "--show-current"], repo_wt)
+                status_out, _ = _git(["status", "--short"], repo_wt)
+                count = len([l for l in status_out.split("\n") if l.strip()]) if status_out else 0
+                print(f"  {repo_name} ({cfg.repo_type}): {branch} ({count} uncommitted)")
+
+        # Check for session files referencing this worktree
+        session_dir = project_root / ".session"
+        found_session = None
+        if session_dir.exists():
+            for sf in session_dir.glob("*-session.md"):
+                try:
+                    content = sf.read_text()
+                    if f"worktree: {wt_name}" in content:
+                        found_session = sf.name
+                        break
+                except OSError:
+                    pass
+
+        if found_session:
+            print(f"  Session: .session/{found_session}")
+        else:
+            print("  Session: (no session file references this worktree)")
+        print()
+
+    return 0