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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dh-cli
-Version: 0.12.2
+Version: 0.12.4
 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.4}/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.4}/pyproject.toml

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

{dh_cli-0.12.2 → dh_cli-0.12.4}/src/dh_cli/engines_studios/engine_commands.py

@@ -8,8 +8,65 @@ import click
 from .api_client import StudioManagerClient
 from .auth import check_aws_auth, detect_aws_environment, get_aws_username
 from .progress import format_idle_state, format_time_ago, wait_with_progress
+from .retry import retry_on_capacity
 from .ssh_config import update_ssh_config_silent
 
+# Default capacity-retry budget: transient InsufficientInstanceCapacity in our
+# G-family AZs usually clears within a few minutes (see topic-quota-and-caps.md).
+_DEFAULT_RETRY_TIMEOUT = 600  # seconds (~10 min)
+_DEFAULT_RETRY_INTERVAL = 30  # seconds
+
+
+def _retry_options(func):
+    """Shared --retry / --no-retry / interval options for launch and start."""
+    func = click.option(
+        "--no-retry",
+        is_flag=True,
+        help="Fail immediately on capacity errors instead of retrying.",
+    )(func)
+    func = click.option(
+        "--retry-timeout",
+        type=int,
+        default=_DEFAULT_RETRY_TIMEOUT,
+        show_default=True,
+        help="Max seconds to keep retrying transient capacity errors (0 disables).",
+    )(func)
+    func = click.option(
+        "--retry-interval",
+        type=int,
+        default=_DEFAULT_RETRY_INTERVAL,
+        show_default=True,
+        help="Seconds to wait between capacity-retry attempts.",
+    )(func)
+    return func
+
+
+def _make_capacity_retry(engine_type: str, no_retry: bool, timeout: int, interval: int):
+    """Build a retry wrapper that echoes status between capacity retries.
+
+    Returns a callable taking a zero-arg `action` and running it with bounded
+    capacity-retry. With `no_retry` (or timeout 0) it runs the action once.
+    """
+    effective_timeout = 0 if no_retry else timeout
+
+    def on_retry(attempt: int, error: BaseException, wait_seconds: float) -> None:
+        click.echo(
+            f"⏳ Attempt {attempt} failed: no {engine_type} capacity available "
+            f"right now (AWS-side). Retrying in {int(wait_seconds)}s… "
+            f"(Ctrl+C to cancel)",
+            err=True,
+        )
+
+    def run(action):
+        return retry_on_capacity(
+            action,
+            timeout=effective_timeout,
+            interval=interval,
+            on_retry=on_retry,
+        )
+
+    return run
+
 
 @click.group()
 def engine_cli():
@@ -44,6 +101,7 @@ def engine_cli():
     default=None,
     help="Environment (dev, sand, prod) - auto-detected if not specified",
 )
+@_retry_options
 def launch_engine(
     name: str,
     engine_type: str,
@@ -53,6 +111,9 @@ def launch_engine(
     no_wait: bool,
     skip_ssh_config: bool,
     env: Optional[str],
+    retry_interval: int,
+    retry_timeout: int,
+    no_retry: bool,
 ):
     """Launch a new engine for the current user (or specified user with --user flag)."""
 
@@ -83,8 +144,13 @@ def launch_engine(
     click.echo(f"🚀 Launching {engine_type} engine '{name}' for {user}...")
 
     try:
-        # Launch the engine
-        engine = client.launch_engine(name=name, user=user, engine_type=engine_type, boot_disk_size=boot_disk_size)
+        # Launch the engine, retrying transient AWS capacity errors by default.
+        retry = _make_capacity_retry(engine_type, no_retry, retry_timeout, retry_interval)
+        engine = retry(
+            lambda: client.launch_engine(
+                name=name, user=user, engine_type=engine_type, boot_disk_size=boot_disk_size
+            )
+        )
 
         engine_id = engine["instance_id"]
         click.echo(f"✓ EC2 instance launched: {engine_id}")
@@ -128,6 +194,10 @@ def launch_engine(
                 if update_ssh_config_silent(client, env):
                     click.echo("✓ SSH config updated")
 
+    except KeyboardInterrupt:
+        click.echo("\n✗ Cancelled while waiting for capacity.", err=True)
+        raise click.Abort()
+
     except Exception as e:
         error_msg = str(e)
 
@@ -197,7 +267,17 @@ def launch_engine(
     default=None,
     help="Environment (dev, sand, prod) - auto-detected if not specified",
 )
-def start_engine(name_or_id: str, no_wait: bool, skip_ssh_config: bool, yes: bool, env: Optional[str]):
+@_retry_options
+def start_engine(
+    name_or_id: str,
+    no_wait: bool,
+    skip_ssh_config: bool,
+    yes: bool,
+    env: Optional[str],
+    retry_interval: int,
+    retry_timeout: int,
+    no_retry: bool,
+):
     """Start a stopped engine."""
 
     # Check AWS auth first to provide clear error messages
@@ -225,7 +305,13 @@ def start_engine(name_or_id: str, no_wait: bool, skip_ssh_config: bool, yes: boo
         engine_id = engine["instance_id"]
         engine_name = engine.get("name", engine_id)
 
-        result = client.start_engine(engine_id)
+        # Start the instance, retrying transient AWS capacity errors by default.
+        # Note: a stopped engine restarts in its ORIGINAL AZ, so retry here is a
+        # time-wait for that one AZ's capacity to return — it cannot fall to
+        # another AZ (unlike launch).
+        engine_type_label = engine.get("engine_type", "engine")
+        retry = _make_capacity_retry(engine_type_label, no_retry, retry_timeout, retry_interval)
+        result = retry(lambda: client.start_engine(engine_id))
 
         if "error" in result:
             click.echo(f"✗ Error: {result['error']}", err=True)
@@ -305,6 +391,10 @@ def start_engine(name_or_id: str, no_wait: bool, skip_ssh_config: bool, yes: boo
                 if update_ssh_config_silent(client, env):
                     click.echo("✓ SSH config updated")
 
+    except KeyboardInterrupt:
+        click.echo("\n✗ Cancelled while waiting for capacity.", err=True)
+        raise click.Abort()
+
     except Exception as e:
         click.echo(f"✗ Error: {e}", err=True)
         raise click.Abort()

dh_cli-0.12.4/src/dh_cli/engines_studios/retry.py

@@ -0,0 +1,79 @@
+"""Bounded capacity-retry for engine launch/start.
+
+AWS periodically has no on-demand G-family capacity in our AZs, surfacing as
+`InsufficientInstanceCapacity` (and, when a subnet is IP-starved,
+`InsufficientFreeAddressesInSubnet`). These are transient: capacity returns
+within minutes. This helper retries such failures within a wall-clock budget
+so users (and agents) don't have to re-run the command by hand.
+
+Quota errors (`VcpuLimitExceeded`), instance-count limits
+(`InstanceLimitExceeded`), and validation errors are NOT capacity problems and
+are never retried — they will not resolve by waiting.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Callable, Optional, TypeVar
+
+T = TypeVar("T")
+
+# Substrings that mark a transient, retryable AWS capacity/IP shortage.
+_CAPACITY_MARKERS = (
+    "InsufficientInstanceCapacity",
+    "InsufficientFreeAddressesInSubnet",
+)
+
+
+def is_capacity_error(error: BaseException) -> bool:
+    """True if `error` is a transient AWS capacity/IP shortage worth retrying."""
+    message = str(error)
+    return any(marker in message for marker in _CAPACITY_MARKERS)
+
+
+def retry_on_capacity(
+    action: Callable[[], T],
+    *,
+    timeout: float,
+    interval: float,
+    on_retry: Optional[Callable[[int, BaseException, float], None]] = None,
+    monotonic: Callable[[], float] = time.monotonic,
+    sleep: Callable[[float], None] = time.sleep,
+) -> T:
+    """Call `action`, retrying transient capacity errors within a budget.
+
+    Args:
+        action: Zero-arg callable performing the launch/start attempt.
+        timeout: Total wall-clock budget in seconds. A new attempt is only
+            started while elapsed time is strictly below this. ``0`` yields a
+            single attempt (no retries).
+        interval: Seconds to wait between attempts.
+        on_retry: Optional callback invoked before each sleep with
+            ``(attempt_number, error, wait_seconds)`` — used to print status.
+        monotonic: Monotonic clock source (injected for testing).
+        sleep: Sleep function (injected for testing).
+
+    Returns:
+        Whatever `action` returns on its first success.
+
+    Raises:
+        The last capacity error if the budget is exhausted, or immediately
+        re-raises any non-capacity error from `action`.
+    """
+    start = monotonic()
+    attempt = 0
+    last_error: Optional[BaseException] = None
+    while True:
+        attempt += 1
+        try:
+            return action()
+        except Exception as error:  # noqa: BLE001 — re-raised below unless retryable
+            if not is_capacity_error(error):
+                raise
+            last_error = error
+            # Stop if the next attempt would not begin within the budget.
+            if (monotonic() - start) + interval >= timeout:
+                raise last_error
+            if on_retry is not None:
+                on_retry(attempt, error, interval)
+            sleep(interval)

{dh_cli-0.12.2 → dh_cli-0.12.4}/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.4/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.4}/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: