dh-cli 0.12.2__tar.gz → 0.12.3__tar.gz

{dh_cli-0.12.2 → dh_cli-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dh-cli
-Version: 0.12.2
+Version: 0.12.3
 Summary: Dayhoff Labs developer CLI
 Author-email: Dayhoff Labs <dev@dayhofflabs.com>
 License: # PolyForm Noncommercial License 1.0.0
@@ -166,7 +166,7 @@ dh --version
 | `dh gh` | GitHub authentication |
 | `dh wget` | Download from data warehouse |
 | `dh wheel` | Build and publish packages |
-| `dh clean` | Delete local git branches |
+| `dh sweep` | Clean up merged branches across all workspace repos |
 
 ## Requirements
 

{dh_cli-0.12.2 → dh_cli-0.12.3}/README.md

@@ -27,7 +27,7 @@ dh --version
 | `dh gh` | GitHub authentication |
 | `dh wget` | Download from data warehouse |
 | `dh wheel` | Build and publish packages |
-| `dh clean` | Delete local git branches |
+| `dh sweep` | Clean up merged branches across all workspace repos |
 
 ## Requirements
 

{dh_cli-0.12.2 → dh_cli-0.12.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dh-cli"
-version = "0.12.2"
+version = "0.12.3"
 description = "Dayhoff Labs developer CLI"
 requires-python = ">=3.11"
 readme = "README.md"

{dh_cli-0.12.2 → dh_cli-0.12.3}/src/dh_cli/main.py

@@ -6,10 +6,8 @@ import typer
 
 from dh_cli.cloud_commands import aws_app, gcp_app
 from dh_cli.github_commands import gh_app
-from dh_cli.utility_commands import (
-    build_and_upload_wheel,
-    delete_local_branch,
-)
+from dh_cli.sweep import sweep
+from dh_cli.utility_commands import build_and_upload_wheel
 from dh_cli.warehouse import get_from_warehouse_typer
 
 
@@ -26,7 +24,7 @@ app = typer.Typer(
 )
 
 # Utility commands
-app.command("clean")(delete_local_branch)
+app.command("sweep")(sweep)
 app.command("wget")(get_from_warehouse_typer)
 
 # Cloud commands

dh_cli-0.12.3/src/dh_cli/sweep.py

@@ -0,0 +1,293 @@
+"""Post-merge branch cleanup across every repo in the workspace.
+
+`dh sweep` takes no arguments: the work to do is derived entirely from
+origin state. A local branch whose upstream has been deleted (`[gone]`
+after `git fetch -p`) is a cleanup candidate; it is only deleted once a
+merged PR for it is confirmed via `gh`. Anything unproven or unsafe is
+skipped and reported.
+
+Because the outcome depends only on origin, the command is idempotent and
+convergent -- running it on several machines needs no coordination.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import typer
+
+FETCH_WORKERS = 8
+
+
+@dataclass
+class RepoReport:
+    """What happened (or didn't) in one repo."""
+
+    name: str
+    deleted: list[str] = field(default_factory=list)
+    skipped: list[tuple[str, str]] = field(default_factory=list)
+    advanced: str | None = None
+    note: str | None = None
+    error: str | None = None
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.deleted) or self.advanced is not None
+
+    @property
+    def quiet(self) -> bool:
+        return not self.changed and not self.skipped and self.note is None
+
+
+def _git(repo: Path, *args: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _git_out(repo: Path, *args: str) -> str:
+    return _git(repo, *args).stdout.strip()
+
+
+def discover_repos(root: Path) -> list[Path]:
+    """Return immediate subdirectories of root that are distinct git repos.
+
+    Linked worktrees share their parent's ref store, so sweeping them
+    separately both races on concurrent fetch and double-counts branches.
+    Only one checkout per repo is returned, preferring the primary one.
+    """
+    found: dict[str, Path] = {}
+    for path in sorted(p for p in root.iterdir() if (p / ".git").exists()):
+        common = _git_out(path, "rev-parse", "--path-format=absolute", "--git-common-dir")
+        key = common or str(path)
+        # A primary checkout owns its common dir; a linked worktree points elsewhere.
+        if key not in found or Path(key).is_relative_to(path):
+            found[key] = path
+    return sorted(found.values())
+
+
+def default_branch(repo: Path) -> str | None:
+    """Resolve the repo's default branch from origin/HEAD, else main/master."""
+    head = _git_out(repo, "symbolic-ref", "--quiet", "refs/remotes/origin/HEAD")
+    if head.startswith("refs/remotes/origin/"):
+        return head.rsplit("/", 1)[-1]
+    for candidate in ("main", "master"):
+        if _git(repo, "show-ref", "--verify", "--quiet", f"refs/remotes/origin/{candidate}").returncode == 0:
+            return candidate
+    return None
+
+
+def gone_branches(repo: Path) -> list[str]:
+    """Local branches whose upstream no longer exists on the remote."""
+    out = _git_out(
+        repo,
+        "for-each-ref",
+        "--format=%(refname:short)%09%(upstream:track)",
+        "refs/heads",
+    )
+    gone = []
+    for line in out.splitlines():
+        name, _, track = line.partition("\t")
+        if "[gone]" in track:
+            gone.append(name)
+    return gone
+
+
+def is_dirty(repo: Path) -> bool:
+    """True if the working tree has staged, unstaged, or untracked changes."""
+    return bool(_git_out(repo, "status", "--porcelain"))
+
+
+def pr_is_merged(repo: Path, branch: str) -> bool | None:
+    """Whether branch has a merged PR. None if gh cannot answer."""
+    result = subprocess.run(
+        [
+            "gh",
+            "pr",
+            "list",
+            "--head",
+            branch,
+            "--state",
+            "merged",
+            "--limit",
+            "1",
+            "--json",
+            "number",
+        ],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    body = result.stdout.strip()
+    if not body:
+        return None
+    return body != "[]"
+
+
+def fetch_pruned(repo: Path) -> str | None:
+    """Fetch with prune. Returns an error message on failure."""
+    result = _git(repo, "fetch", "--prune", "--quiet")
+    if result.returncode == 0:
+        return None
+    lines = (result.stderr or result.stdout).strip().splitlines()
+    return lines[-1] if lines else "fetch failed"
+
+
+def _advance_default(repo: Path, default: str, current: str) -> str | None:
+    """Fast-forward the local default branch to origin. Returns new short sha."""
+    before = _git_out(repo, "rev-parse", "--short", default)
+    if current == default:
+        result = _git(repo, "merge", "--ff-only", f"origin/{default}")
+    else:
+        # Updates the ref without a checkout; git refuses if not a fast-forward.
+        result = _git(repo, "fetch", "origin", f"{default}:{default}")
+    if result.returncode != 0:
+        return None
+    after = _git_out(repo, "rev-parse", "--short", default)
+    return after if after != before else None
+
+
+def _behind_count(repo: Path, default: str) -> int:
+    """How many commits origin/<default> is ahead of the local default branch."""
+    out = _git_out(repo, "rev-list", "--count", f"{default}..origin/{default}")
+    return int(out) if out.isdigit() else 0
+
+
+def sweep_repo(repo: Path, *, dry_run: bool = False) -> RepoReport:
+    """Clean up one repo. Assumes fetch --prune has already run."""
+    report = RepoReport(name=repo.name)
+
+    default = default_branch(repo)
+    if default is None:
+        report.error = "no origin default branch"
+        return report
+
+    candidates = gone_branches(repo)
+    current = _git_out(repo, "branch", "--show-current")
+    dirty = is_dirty(repo)
+
+    for branch in candidates:
+        if branch == default:
+            report.skipped.append((branch, "is the default branch"))
+            continue
+
+        merged = pr_is_merged(repo, branch)
+        if merged is None:
+            report.skipped.append((branch, "no merged PR found (gh could not confirm)"))
+            continue
+        if not merged:
+            report.skipped.append((branch, "no merged PR — may hold unmerged work"))
+            continue
+
+        if branch == current:
+            if dirty:
+                report.skipped.append((branch, "checked out with uncommitted changes"))
+                continue
+            if not dry_run:
+                if _git(repo, "switch", "--quiet", default).returncode != 0:
+                    report.skipped.append((branch, f"could not switch to {default}"))
+                    continue
+            current = default
+
+        if dry_run:
+            report.deleted.append(branch)
+            continue
+
+        # -D is required: a squash-merged branch is never "fully merged" to git.
+        result = _git(repo, "branch", "-D", branch)
+        if result.returncode != 0:
+            report.skipped.append((branch, (result.stderr or "delete failed").strip().splitlines()[0]))
+        else:
+            report.deleted.append(branch)
+
+    if not (dirty and current == default):
+        if dry_run:
+            behind = _behind_count(repo, default)
+            if behind:
+                report.advanced = f"would fast-forward {default} ({behind} commit(s) behind)"
+        else:
+            new_sha = _advance_default(repo, default, current)
+            if new_sha:
+                report.advanced = f"{default} → {new_sha}"
+    else:
+        behind = _behind_count(repo, default)
+        if behind:
+            report.note = f"{default} is {behind} commit(s) behind — uncommitted changes, left alone"
+
+    return report
+
+
+def _render(reports: list[RepoReport], dry_run: bool) -> None:
+    verb = "would delete" if dry_run else "deleted"
+    quiet = []
+
+    for report in reports:
+        if report.error:
+            typer.echo(f"  {report.name}: {report.error}")
+            continue
+        if report.quiet:
+            quiet.append(report.name)
+            continue
+        typer.echo(f"  {report.name}")
+        for branch in report.deleted:
+            typer.echo(f"      {verb} {branch}")
+        if report.advanced:
+            typer.echo(f"      {report.advanced}")
+        if report.note:
+            typer.echo(f"      {report.note}")
+        for branch, reason in report.skipped:
+            typer.echo(f"      kept {branch} — {reason}")
+
+    if quiet:
+        typer.echo(f"  nothing to do: {', '.join(quiet)}")
+
+
+def sweep(
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        "-n",
+        help="Report what would change without touching anything.",
+    ),
+) -> None:
+    """Delete merged branches and fast-forward main in every workspace repo.
+
+    Derived entirely from origin state, so it is safe to re-run and needs
+    no coordination between machines. Branches without a confirmed merged
+    PR are always kept.
+    """
+    root = Path(os.environ.get("WORKSPACE_ROOT", "/workspaces/code"))
+    if not root.is_dir():
+        typer.echo(f"Workspace root not found: {root}")
+        raise typer.Exit(1)
+
+    repos = discover_repos(root)
+    if not repos:
+        typer.echo(f"No git repos found in {root}")
+        raise typer.Exit(1)
+
+    typer.echo(f"Fetching {len(repos)} repos...")
+    with ThreadPoolExecutor(max_workers=FETCH_WORKERS) as pool:
+        fetch_errors = dict(zip(repos, pool.map(fetch_pruned, repos)))
+
+    reports = []
+    for repo in repos:
+        if fetch_errors[repo]:
+            reports.append(RepoReport(name=repo.name, error=fetch_errors[repo]))
+        else:
+            reports.append(sweep_repo(repo, dry_run=dry_run))
+
+    _render(reports, dry_run)
+
+    kept = sum(len(r.skipped) for r in reports)
+    if kept:
+        typer.echo(f"\n{kept} branch(es) kept for review.")

{dh_cli-0.12.2 → dh_cli-0.12.3}/src/dh_cli/utility_commands.py

@@ -11,38 +11,6 @@ import toml
 # Import cloud helper lazily inside functions to avoid heavy deps at module load
 
 
-def delete_local_branch(branch_name: str, folder_path: str):
-    """Delete a local Git branch after fetching with pruning.
-
-    Args:
-        branch_name: Name of the branch to delete
-        folder_path: Path to the git repository folder
-    """
-    try:
-        # Store current working directory
-        original_dir = os.getcwd()
-
-        # Change to the specified directory
-        os.chdir(folder_path)
-        print(f"Changed to directory: {folder_path}")
-
-        # Delete the specified branch
-        delete_branch_cmd = ["git", "branch", "-D", branch_name]
-        subprocess.run(delete_branch_cmd, check=True)
-        print(f"Deleted branch: {branch_name}")
-
-        # Fetch changes from the remote repository and prune obsolete branches
-        fetch_prune_cmd = ["git", "fetch", "-p"]
-        subprocess.run(fetch_prune_cmd, check=True)
-        print("Fetched changes and pruned obsolete branches")
-
-    except subprocess.CalledProcessError as e:
-        print(f"Error occurred while running Git commands: {e}")
-    finally:
-        # Always return to the original directory
-        os.chdir(original_dir)
-
-
 def get_current_version_from_toml(file_path="pyproject.toml"):
     """Reads the version from a pyproject.toml file."""
     try:

dh_cli-0.12.3/tests/test_sweep.py

@@ -0,0 +1,306 @@
+"""Tests for `dh sweep`.
+
+These drive real git repositories in a temp dir. The command's entire job is
+interacting with git's upstream-tracking bookkeeping across a squash-merge,
+which a mocked subprocess would not exercise at all. Only the GitHub PR
+lookup is stubbed.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import typer
+from click.testing import CliRunner
+from typer.main import get_command
+
+
+def _git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def make_repo(tmp_path: Path, name: str) -> Path:
+    """Create a bare origin plus a working clone holding one commit on main."""
+    origin = tmp_path / "remotes" / f"{name}.git"
+    subprocess.run(
+        ["git", "init", "--quiet", "--bare", "-b", "main", str(origin)],
+        check=True,
+        capture_output=True,
+    )
+    work = tmp_path / "ws" / name
+    subprocess.run(
+        ["git", "clone", "--quiet", str(origin), str(work)],
+        check=True,
+        capture_output=True,
+    )
+    _git(work, "symbolic-ref", "HEAD", "refs/heads/main")
+    _git(work, "config", "user.email", "test@dayhofflabs.com")
+    _git(work, "config", "user.name", "Test")
+    (work / "base.txt").write_text("base\n")
+    _git(work, "add", ".")
+    _git(work, "commit", "--quiet", "-m", "base")
+    _git(work, "push", "--quiet", "-u", "origin", "main")
+    return work
+
+
+def start_branch(work: Path, branch: str) -> None:
+    """Branch off main, commit, and push with upstream tracking."""
+    _git(work, "switch", "--quiet", "main")
+    _git(work, "switch", "--quiet", "-c", branch)
+    (work / f"{branch}.txt").write_text(f"{branch}\n")
+    _git(work, "add", ".")
+    _git(work, "commit", "--quiet", "-m", f"{branch} work")
+    _git(work, "push", "--quiet", "-u", "origin", branch)
+
+
+def squash_merge_on_server(tmp_path: Path, name: str, branch: str) -> None:
+    """Squash-merge `branch` into main and delete it, the way GitHub does.
+
+    Performed through a throwaway second clone so the developer's clone is
+    left with a stale local main -- exactly the state sweep must repair.
+    """
+    origin = tmp_path / "remotes" / f"{name}.git"
+    server = tmp_path / "server"
+    subprocess.run(
+        ["git", "clone", "--quiet", str(origin), str(server)],
+        check=True,
+        capture_output=True,
+    )
+    _git(server, "config", "user.email", "test@dayhofflabs.com")
+    _git(server, "config", "user.name", "Test")
+    _git(server, "merge", "--squash", f"origin/{branch}")
+    _git(server, "commit", "--quiet", "-m", f"{branch} (#1)")
+    _git(server, "push", "--quiet", "origin", "main")
+    _git(server, "push", "--quiet", "origin", "--delete", branch)
+    subprocess.run(["rm", "-rf", str(server)], check=True)
+
+
+def branches(work: Path) -> set[str]:
+    return set(_git(work, "branch", "--format=%(refname:short)").split())
+
+
+def current_branch(work: Path) -> str:
+    return _git(work, "branch", "--show-current")
+
+
+def sha(work: Path, rev: str) -> str:
+    return _git(work, "rev-parse", rev)
+
+
+@pytest.fixture
+def ws(tmp_path: Path) -> Path:
+    (tmp_path / "ws").mkdir()
+    (tmp_path / "remotes").mkdir()
+    return tmp_path / "ws"
+
+
+def run_sweep(ws: Path, merged: object = True, args: tuple[str, ...] = ()):
+    from dh_cli import sweep as sweep_mod
+
+    app = typer.Typer()
+    app.command("sweep")(sweep_mod.sweep)
+    resolve = merged if callable(merged) else (lambda repo, branch: merged)
+    with (
+        patch.dict("os.environ", {"WORKSPACE_ROOT": str(ws)}),
+        patch.object(sweep_mod, "pr_is_merged", side_effect=resolve),
+    ):
+        return CliRunner().invoke(get_command(app), list(args))
+
+
+def test_deletes_merged_branch_and_returns_to_main(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    assert current_branch(work) == "feat"
+
+    result = run_sweep(ws)
+
+    assert result.exit_code == 0, result.output
+    assert "feat" not in branches(work)
+    assert current_branch(work) == "main"
+
+
+def test_fast_forwards_stale_main(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    stale = sha(work, "main")
+
+    run_sweep(ws)
+
+    assert sha(work, "main") != stale
+    assert sha(work, "main") == sha(work, "origin/main")
+
+
+def test_keeps_branch_without_merged_pr(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+
+    result = run_sweep(ws, merged=False)
+
+    assert "feat" in branches(work)
+    assert "unmerged work" in result.output
+
+
+def test_keeps_branch_when_gh_cannot_confirm(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+
+    result = run_sweep(ws, merged=None)
+
+    assert "feat" in branches(work)
+    assert "gh could not confirm" in result.output
+
+
+def test_dirty_worktree_on_merged_branch_is_left_alone(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    (work / "scratch.txt").write_text("uncommitted\n")
+
+    result = run_sweep(ws)
+
+    assert "feat" in branches(work)
+    assert current_branch(work) == "feat"
+    assert "uncommitted changes" in result.output
+
+
+def test_advances_main_without_leaving_the_active_branch(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    start_branch(work, "live")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    stale = sha(work, "main")
+    assert current_branch(work) == "live"
+
+    run_sweep(ws, merged=lambda repo, branch: branch == "feat")
+
+    assert current_branch(work) == "live"
+    assert "live" in branches(work)
+    assert "feat" not in branches(work)
+    assert sha(work, "main") != stale
+
+
+def test_leaves_branches_with_live_upstream_alone(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "live")
+
+    result = run_sweep(ws)
+
+    assert result.exit_code == 0, result.output
+    assert branches(work) == {"main", "live"}
+
+
+def test_sweeps_every_repo_in_the_workspace(tmp_path, ws):
+    works = []
+    for name in ("alpha", "beta", "gamma"):
+        work = make_repo(tmp_path, name)
+        start_branch(work, "shared")
+        squash_merge_on_server(tmp_path, name, "shared")
+        works.append(work)
+
+    result = run_sweep(ws)
+
+    assert result.exit_code == 0, result.output
+    for work in works:
+        assert "shared" not in branches(work)
+        assert current_branch(work) == "main"
+
+
+def test_dry_run_changes_nothing(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    stale = sha(work, "main")
+
+    result = run_sweep(ws, args=("--dry-run",))
+
+    assert "feat" in branches(work)
+    assert sha(work, "main") == stale
+    assert "would delete feat" in result.output
+
+
+def test_second_run_is_a_no_op(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+
+    run_sweep(ws)
+    result = run_sweep(ws)
+
+    assert result.exit_code == 0, result.output
+    assert branches(work) == {"main"}
+    assert "nothing to do" in result.output
+
+
+def test_dry_run_previews_pending_fast_forward(tmp_path, ws):
+    # A dry run must not call a repo with a stale main "nothing to do".
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+
+    result = run_sweep(ws, args=("--dry-run",))
+
+    assert "would fast-forward main" in result.output
+    assert "nothing to do" not in result.output
+
+
+def test_dirty_default_branch_behind_origin_is_reported_not_hidden(tmp_path, ws):
+    # Left alone on purpose, but it must not be filed under "nothing to do".
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "feat")
+    squash_merge_on_server(tmp_path, "repo", "feat")
+    _git(work, "switch", "--quiet", "main")
+    stale = sha(work, "main")
+    (work / "wip.txt").write_text("in flight\n")
+
+    result = run_sweep(ws)
+
+    assert sha(work, "main") == stale
+    assert "nothing to do" not in result.output
+    assert "uncommitted changes, left alone" in result.output
+
+
+def test_linked_worktrees_are_swept_once(tmp_path, ws):
+    # A linked worktree shares the parent's ref store; treating it as a
+    # separate repo races on concurrent fetch and double-counts branches.
+    from dh_cli.sweep import discover_repos
+
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "side")
+    linked = ws / "repo-side"
+    _git(work, "switch", "--quiet", "main")
+    _git(work, "worktree", "add", "--quiet", str(linked), "side")
+
+    assert discover_repos(ws) == [work]
+
+    result = run_sweep(ws)
+    assert result.exit_code == 0, result.output
+    assert "cannot lock ref" not in result.output
+
+
+def test_branch_checked_out_in_linked_worktree_is_kept(tmp_path, ws):
+    work = make_repo(tmp_path, "repo")
+    start_branch(work, "side")
+    linked = ws / "repo-side"
+    _git(work, "switch", "--quiet", "main")
+    _git(work, "worktree", "add", "--quiet", str(linked), "side")
+    squash_merge_on_server(tmp_path, "repo", "side")
+
+    result = run_sweep(ws)
+
+    assert result.exit_code == 0, result.output
+    assert "side" in branches(work)
+    assert "kept side" in result.output