@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/git/worktree.py

@@ -1,302 +0,0 @@
-"""
-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([line for line in status_out.split("\n") if line.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

package/pennyfarthing_scripts/git_group/cli.py

@@ -1,203 +0,0 @@
-"""
-Git CLI - Click-based CLI for git repository operations.
-
-Usage:
-    pf git [COMMAND] [ARGS]...
-
-Commands:
-    status       Check git status of all project repos
-    cleanup      Organize changes into proper commits/branches
-    branches     Create feature branches from a story
-    worktree     Manage git worktrees for parallel work
-    install-hooks Install git hooks with .d/ dispatcher pattern
-"""
-
-import asyncio
-
-import click
-
-
-@click.group()
-def git():
-    """Repository operations across all configured repos.
-
-    \b
-    Commands:
-      status        - Check git status of all repos
-      cleanup       - Organize changes into commits/branches
-      branches      - Create feature branches from a story
-      worktree      - Manage git worktrees for parallel work
-      install-hooks - Install git hooks with .d/ dispatcher
-    """
-    pass
-
-
-@git.command()
-@click.option("--brief", is_flag=True, help="One-line-per-repo summary")
-def status(brief: bool):
-    """Check git status of all project repos.
-
-    Shows branch, uncommitted changes, and ahead/behind status for each repo.
-    """
-    from pennyfarthing_scripts.git.repos import get_repo_paths, load_repos_config
-    from pennyfarthing_scripts.git.status_all import (
-        format_status_brief,
-        format_status_full,
-        format_summary,
-        get_all_repo_status,
-    )
-
-    repo_paths = get_repo_paths()
-    config = load_repos_config()
-
-    # Build repo list with per-repo upstream refs
-    repos_with_upstream: list[tuple[str, object, str]] = []
-    for name, path in repo_paths:
-        upstream = config[name].upstream_ref if name in config else "origin/main"
-        repos_with_upstream.append((name, path, upstream))
-
-    statuses = asyncio.run(get_all_repo_status(repos_with_upstream))
-
-    if brief:
-        click.echo(format_status_brief(statuses))
-    else:
-        click.echo("━" * 40)
-        click.echo("  Git Status - All Repos")
-        click.echo("━" * 40)
-        click.echo()
-        click.echo(format_status_full(statuses))
-        click.echo("━" * 40)
-        click.echo(format_summary(statuses))
-
-    has_issues = any(not s.is_clean or s.has_unpushed for s in statuses)
-    raise SystemExit(1 if has_issues else 0)
-
-
-@git.command()
-def cleanup():
-    """Organize changes into proper commits and branches.
-
-    Starts the git-cleanup stepped workflow via BikeLane.
-    Equivalent to: /pf-workflow start git-cleanup
-    """
-    click.echo("Starting git-cleanup workflow...")
-    click.echo("Run: /pf-workflow start git-cleanup")
-    click.echo("Or:  pf workflow start git-cleanup")
-
-
-@git.command()
-@click.argument("branch_name")
-@click.option(
-    "--repos",
-    type=click.Choice(["all", "api", "ui"]),
-    default="all",
-    help="Which repos to target",
-)
-def branches(branch_name: str, repos: str):
-    """Create feature branches across all configured repos.
-
-    \b
-    Arguments:
-      BRANCH_NAME  - The branch name to create (e.g., feat/86-3-file-upload)
-    """
-    from pennyfarthing_scripts.git.create_branches import (
-        create_feature_branches,
-        detect_worktree,
-        filter_repos,
-        format_results,
-    )
-    from pennyfarthing_scripts.git.repos import get_repo_paths
-
-    is_worktree, worktree_name, _ = detect_worktree()
-    if is_worktree:
-        click.echo(f"📂 Detected worktree: {worktree_name}")
-    else:
-        click.echo("📂 Using main checkout")
-
-    all_repos = get_repo_paths()
-    filtered = filter_repos(all_repos, repos)
-
-    if not filtered:
-        click.echo(f"No repos match filter: {repos}", err=True)
-        raise SystemExit(1)
-
-    results = asyncio.run(create_feature_branches(filtered, branch_name))
-    click.echo(format_results(results, branch_name))
-
-    from pennyfarthing_scripts.git.create_branches import BranchAction
-
-    has_errors = any(r.action == BranchAction.ERROR for r in results)
-    raise SystemExit(1 if has_errors else 0)
-
-
-# Worktree subgroup
-@git.group()
-def worktree():
-    """Manage git worktrees for parallel development.
-
-    \b
-    Commands:
-      create  - Create worktree(s) for parallel work
-      remove  - Remove worktree and clean up
-      list    - List all active worktrees
-      status  - Show detailed worktree status
-    """
-    pass
-
-
-@worktree.command("create")
-@click.argument("name")
-@click.argument("branch")
-@click.option(
-    "--repos",
-    default="all",
-    help="Repos filter: all, api, ui, or comma-separated names",
-)
-def worktree_create(name: str, branch: str, repos: str):
-    """Create worktree(s) for parallel work.
-
-    \b
-    Arguments:
-      NAME    - Worktree name (e.g., wt-5-3a)
-      BRANCH  - Branch name (e.g., feat/5-3a-file-upload)
-    """
-    from pennyfarthing_scripts.git.worktree import create_worktree
-
-    raise SystemExit(create_worktree(name, branch, repos))
-
-
-@worktree.command("remove")
-@click.argument("name")
-def worktree_remove(name: str):
-    """Remove worktree and clean up."""
-    from pennyfarthing_scripts.git.worktree import remove_worktree
-
-    raise SystemExit(remove_worktree(name))
-
-
-@worktree.command("list")
-def worktree_list():
-    """List all active worktrees."""
-    from pennyfarthing_scripts.git.worktree import list_worktrees
-
-    raise SystemExit(list_worktrees())
-
-
-@worktree.command("status")
-def worktree_status():
-    """Show detailed worktree status."""
-    from pennyfarthing_scripts.git.worktree import show_worktree_status
-
-    raise SystemExit(show_worktree_status())
-
-
-@git.command("install-hooks")
-def install_hooks():
-    """Install git hooks with .d/ dispatcher pattern.
-
-    Creates .d/ directories, symlinks pennyfarthing hooks, and
-    migrates existing user hooks.
-    """
-    from pennyfarthing_scripts.git.hooks_installer import install_git_hooks
-
-    raise SystemExit(install_git_hooks())

package/pennyfarthing_scripts/handoff/cli.py

@@ -1,152 +0,0 @@
-"""Handoff CLI — Phase gate resolution, session transitions, and marker generation.
-
-Usage:
-    pf handoff resolve-gate STORY_ID WORKFLOW PHASE
-    pf handoff complete-phase STORY_ID WORKFLOW FROM_PHASE TO_PHASE GATE_TYPE
-    pf handoff marker NEXT_AGENT [--error MESSAGE]
-    pf handoff phase-check AGENT
-
-Stories: 105-1, 105-4 (Script-First Handoff), 110-8 (CLI Relay Handoff Fix)
-"""
-
-from __future__ import annotations
-
-import click
-
-
-@click.group()
-def handoff():
-    """Phase gate resolution and session transitions.
-
-    \b
-    Commands:
-      resolve-gate    - Resolve gate for current phase
-      complete-phase  - Complete phase transition atomically
-      marker          - Generate AGENT_COMMAND handoff marker
-      phase-check     - Check if agent owns current phase
-    """
-    pass
-
-
-@handoff.command("resolve-gate")
-@click.argument("story_id")
-@click.argument("workflow")
-@click.argument("phase")
-def resolve_gate_cmd(story_id: str, workflow: str, phase: str):
-    """Resolve the gate for the current workflow phase.
-
-    Reads workflow YAML, checks assessment, returns RESOLVE_RESULT.
-
-    \b
-    Arguments:
-      STORY_ID  - Story identifier (e.g., 105-1)
-      WORKFLOW  - Workflow name (e.g., tdd, trivial, patch)
-      PHASE     - Current phase name (e.g., green, implement, fix)
-    """
-    from pennyfarthing_scripts.handoff.resolve_gate import resolve_gate
-
-    result = resolve_gate(story_id, workflow, phase)
-
-    import yaml
-
-    click.echo(yaml.dump({"RESOLVE_RESULT": result}, default_flow_style=False).rstrip())
-
-    if result.get("status") == "blocked":
-        raise SystemExit(1)
-
-
-@handoff.command("complete-phase")
-@click.argument("story_id")
-@click.argument("workflow")
-@click.argument("from_phase")
-@click.argument("to_phase")
-@click.argument("gate_type")
-def complete_phase_cmd(
-    story_id: str,
-    workflow: str,
-    from_phase: str,
-    to_phase: str,
-    gate_type: str,
-):
-    """Complete a phase transition with atomic session update.
-
-    Updates session file: phase line, timestamps, history tables.
-
-    \b
-    Arguments:
-      STORY_ID    - Story identifier (e.g., 105-1)
-      WORKFLOW    - Workflow name (e.g., tdd, trivial)
-      FROM_PHASE  - Phase being completed (e.g., green)
-      TO_PHASE    - Phase being entered (e.g., review)
-      GATE_TYPE   - Gate type that was passed (e.g., tests_pass)
-    """
-    from pennyfarthing_scripts.handoff.complete_phase import complete_phase
-
-    result = complete_phase(story_id, workflow, from_phase, to_phase, gate_type)
-
-    import yaml
-
-    click.echo(yaml.dump({"COMPLETE_RESULT": result}, default_flow_style=False).rstrip())
-
-    if result.get("status") == "error":
-        raise SystemExit(1)
-
-
-@handoff.command("marker")
-@click.argument("next_agent", required=False, default=None)
-@click.option("--error", "error_msg", default=None, help="Generate error marker")
-def marker_cmd(next_agent: str | None, error_msg: str | None):
-    """Generate AGENT_COMMAND handoff marker block.
-
-    Environment-aware marker generation. Detects Cyclist, relay mode,
-    and context usage to choose the appropriate marker type.
-
-    \b
-    Arguments:
-      NEXT_AGENT  - Agent to hand off to (e.g., dev, tea, reviewer)
-
-    \b
-    Options:
-      --error MSG - Generate an error marker instead of a handoff
-    """
-    from pennyfarthing_scripts.handoff.marker import generate_marker
-
-    if not next_agent and not error_msg:
-        raise click.UsageError(
-            "Provide NEXT_AGENT or --error MESSAGE.\n\n"
-            "Examples:\n"
-            "  pf handoff marker dev\n"
-            "  pf handoff marker --error 'Tests failing'"
-        )
-
-    click.echo(generate_marker(next_agent, error=error_msg))
-
-
-@handoff.command("phase-check")
-@click.argument("agent")
-def phase_check_cmd(agent: str):
-    """Check if the requested agent owns the current workflow phase.
-
-    Returns a YAML block with action ("start" or "redirect"), the correct
-    agent, story ID, phase, and a human-readable message.
-
-    If the agent does not own the phase, generates a handoff marker for
-    the correct agent.
-
-    \b
-    Arguments:
-      AGENT  - Agent to check (e.g., dev, tea, reviewer, sm)
-    """
-    from pennyfarthing_scripts.handoff.phase_check import phase_check_start
-
-    result = phase_check_start(agent)
-
-    import yaml
-
-    click.echo(yaml.dump({"PHASE_CHECK": result}, default_flow_style=False).rstrip())
-
-    if result["action"] == "redirect":
-        click.echo("")
-        from pennyfarthing_scripts.handoff.marker import generate_marker
-
-        click.echo(generate_marker(result["agent"]))