path-sync 0.6.2__tar.gz → 0.7.0__tar.gz

{path_sync-0.6.2 → path_sync-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: path-sync
-Version: 0.6.2
+Version: 0.7.0
 Summary: Sync files from a source repo to multiple destination repos
 Author-email: EspenAlbert <espen.albert1@gmail.com>
 License-Expression: MIT

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/__init__.py

@@ -5,7 +5,7 @@ from path_sync import dep_update
 from path_sync import validate_no_changes
 from path_sync import config
 
-VERSION = "0.6.2"
+VERSION = "0.7.0"
 __all__ = [
     "copy",
     "dep_update",

path_sync-0.7.0/path_sync/_internal/auto_merge.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import time
+from enum import StrEnum
+from pathlib import Path
+from typing import NamedTuple
+
+from pydantic import BaseModel, Field
+
+from path_sync._internal.models import AutoMergeConfig
+
+logger = logging.getLogger(__name__)
+
+
+class PRState(StrEnum):
+    MERGED = "MERGED"
+    OPEN = "OPEN"
+    CLOSED = "CLOSED"
+
+
+FAILED_CHECK_STATES: frozenset[str] = frozenset(
+    {
+        "FAILURE",
+        "ERROR",
+        "TIMED_OUT",
+        "STARTUP_FAILURE",
+        "STALE",
+        "ACTION_REQUIRED",
+    }
+)
+
+COMPLETED_CHECK_STATES: frozenset[str] = frozenset(FAILED_CHECK_STATES | {"SUCCESS", "NEUTRAL", "SKIPPED", "CANCELLED"})
+
+
+class CheckRun(BaseModel):
+    name: str
+    state: str
+
+    @property
+    def failed(self) -> bool:
+        return self.state in FAILED_CHECK_STATES
+
+    @property
+    def pending(self) -> bool:
+        return self.state not in COMPLETED_CHECK_STATES
+
+
+class PRRef(NamedTuple):
+    dest_name: str
+    repo_path: Path
+    branch_or_url: str
+
+
+class PRMergeResult(BaseModel):
+    dest_name: str
+    pr_url: str
+    branch: str
+    state: PRState
+    checks: list[CheckRun] = Field(default_factory=list)
+
+    @property
+    def failed_checks(self) -> list[CheckRun]:
+        return [c for c in self.checks if c.failed]
+
+    @property
+    def pending_checks(self) -> list[CheckRun]:
+        return [c for c in self.checks if c.pending]
+
+
+def enable_auto_merge(repo_path: Path, pr_ref: str, config: AutoMergeConfig) -> None:
+    cmd = ["gh", "pr", "merge", "--auto", f"--{config.method}", pr_ref]
+    if config.delete_branch:
+        cmd.append("--delete-branch")
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.warning(f"Auto-merge enable failed for {pr_ref}: {result.stderr.strip()}")
+    else:
+        logger.info(f"Enabled auto-merge ({config.method}) for {pr_ref}")
+
+
+def get_pr_checks(repo_path: Path, pr_ref: str) -> list[CheckRun]:
+    cmd = ["gh", "pr", "checks", pr_ref, "--json", "name,state"]
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.warning(f"Failed to get checks for {pr_ref}: {result.stderr.strip()}")
+        return []
+    return [CheckRun.model_validate(c) for c in json.loads(result.stdout)]
+
+
+def get_pr_state(repo_path: Path, pr_ref: str) -> PRState:
+    cmd = ["gh", "pr", "view", pr_ref, "--json", "state", "-q", ".state"]
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.warning(f"Failed to get PR state for {pr_ref}: {result.stderr.strip()}")
+        return PRState.OPEN
+    return PRState(result.stdout.strip())
+
+
+def get_pr_url(repo_path: Path, pr_ref: str) -> str:
+    cmd = ["gh", "pr", "view", pr_ref, "--json", "url", "-q", ".url"]
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        return pr_ref
+    return result.stdout.strip() or pr_ref
+
+
+def wait_for_merge(repo_path: Path, pr_ref: str, config: AutoMergeConfig, dest_name: str = "") -> PRMergeResult:
+    pr_url = get_pr_url(repo_path, pr_ref)
+    deadline = time.monotonic() + config.timeout_seconds
+
+    while time.monotonic() < deadline:
+        state = get_pr_state(repo_path, pr_ref)
+        if state == PRState.MERGED:
+            return PRMergeResult(dest_name=dest_name, pr_url=pr_url, branch=pr_ref, state=PRState.MERGED)
+        if state == PRState.CLOSED:
+            checks = get_pr_checks(repo_path, pr_ref)
+            return PRMergeResult(dest_name=dest_name, pr_url=pr_url, branch=pr_ref, state=PRState.CLOSED, checks=checks)
+        time.sleep(config.poll_interval_seconds)
+
+    checks = get_pr_checks(repo_path, pr_ref)
+    logger.warning(f"Timeout waiting for {pr_ref} after {config.timeout_seconds}s")
+    return PRMergeResult(dest_name=dest_name, pr_url=pr_url, branch=pr_ref, state=PRState.OPEN, checks=checks)
+
+
+def handle_auto_merge(
+    pr_refs: list[PRRef],
+    config: AutoMergeConfig,
+    no_wait: bool = False,
+) -> list[PRMergeResult]:
+    if not pr_refs:
+        return []
+
+    pending_refs: list[PRRef] = []
+    for ref in pr_refs:
+        state = get_pr_state(ref.repo_path, ref.branch_or_url)
+        if state == PRState.MERGED:
+            logger.info(f"{ref.dest_name}: already merged")
+            continue
+        enable_auto_merge(ref.repo_path, ref.branch_or_url, config)
+        pending_refs.append(ref)
+
+    if no_wait:
+        logger.info("--no-wait: skipping merge polling")
+        return []
+
+    results: list[PRMergeResult] = []
+    for ref in pending_refs:
+        logger.info(f"Waiting for {ref.dest_name} to merge...")
+        result = wait_for_merge(ref.repo_path, ref.branch_or_url, config, dest_name=ref.dest_name)
+        results.append(result)
+
+    _log_summary(results)
+    return results
+
+
+def _log_summary(results: list[PRMergeResult]) -> None:
+    if not results:
+        return
+    max_name = max(len(r.dest_name) for r in results)
+    header = f"{'Repo':<{max_name}}  State    Failed Checks"
+    logger.info(header)
+    logger.info("-" * len(header))
+    for r in results:
+        failed = ", ".join(c.name for c in r.failed_checks)
+        logger.info(f"{r.dest_name:<{max_name}}  {r.state:<8} {failed}")

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/_internal/cmd_copy.py

@@ -11,6 +11,7 @@ from pydantic import BaseModel
 
 from path_sync import sections
 from path_sync._internal import cmd_options, git_ops, header, prompt_utils, verify
+from path_sync._internal.auto_merge import PRRef, handle_auto_merge
 from path_sync._internal.file_utils import ensure_parents_write_text
 from path_sync._internal.log_capture import capture_log
 from path_sync._internal.models import (
@@ -53,6 +54,8 @@ class CopyOptions(BaseModel):
     no_pr: bool = False
     skip_orphan_cleanup: bool = False
     skip_verify: bool = False
+    no_wait: bool = False
+    no_auto_merge: bool = False
     pr_title: str = ""
     labels: list[str] | None = None
     reviewers: list[str] | None = None
@@ -130,6 +133,16 @@ def copy(
         "--skip-verify",
         help="Skip verification steps after syncing",
     ),
+    no_wait: bool = typer.Option(
+        False,
+        "--no-wait",
+        help="Enable auto-merge but skip polling for merge completion",
+    ),
+    no_auto_merge: bool = typer.Option(
+        False,
+        "--no-auto-merge",
+        help="Skip auto-merge even when configured",
+    ),
 ) -> None:
     """Copy files from SRC to DEST repositories."""
     if name and config_path_opt:
@@ -147,9 +160,6 @@ def copy(
         raise typer.Exit(EXIT_ERROR if detailed_exit_code else 1)
 
     config = load_yaml_model(config_path, SrcConfig)
-    src_repo = git_ops.get_repo(src_root)
-    current_sha = git_ops.get_current_sha(src_repo)
-    src_repo_url = git_ops.get_remote_url(src_repo, config.git_remote)
 
     opts = CopyOptions(
         dry_run=dry_run,
@@ -161,31 +171,49 @@ def copy(
         no_pr=no_pr,
         skip_orphan_cleanup=skip_orphan_cleanup,
         skip_verify=skip_verify,
+        no_wait=no_wait,
+        no_auto_merge=no_auto_merge,
         pr_title=pr_title or config.pr_defaults.title,
         labels=cmd_options.split_csv(pr_labels) or config.pr_defaults.labels,
         reviewers=cmd_options.split_csv(pr_reviewers) or config.pr_defaults.reviewers,
         assignees=cmd_options.split_csv(pr_assignees) or config.pr_defaults.assignees,
     )
 
+    try:
+        total_changes = _run_copy(config, src_root, dest_filter, opts)
+    except Exception as e:
+        if detailed_exit_code:
+            logger.error(f"Copy failed: {e}")
+            raise typer.Exit(EXIT_ERROR)
+        raise
+
+    if detailed_exit_code:
+        raise typer.Exit(EXIT_CHANGES if total_changes > 0 else EXIT_NO_CHANGES)
+
+
+def _run_copy(config: SrcConfig, src_root: Path, dest_filter: str, opts: CopyOptions) -> int:
+    src_repo = git_ops.get_repo(src_root)
+    current_sha = git_ops.get_current_sha(src_repo)
+    src_repo_url = git_ops.get_remote_url(src_repo, config.git_remote)
+
     destinations = config.destinations
     if dest_filter:
         filter_names = [n.strip() for n in dest_filter.split(",")]
         destinations = [d for d in destinations if d.name in filter_names]
 
     total_changes = 0
+    pr_refs: list[PRRef] = []
     for dest in destinations:
-        try:
-            with capture_log(dest.name) as read_log:
-                changes = _sync_destination(config, dest, src_root, current_sha, src_repo_url, opts, read_log)
-            total_changes += changes
-        except Exception as e:
-            logger.error(f"Failed to sync {dest.name}: {e}")
-            if detailed_exit_code:
-                raise typer.Exit(EXIT_ERROR)
-            raise
+        with capture_log(dest.name) as read_log:
+            changes, pr_ref = _sync_destination(config, dest, src_root, current_sha, src_repo_url, opts, read_log)
+        total_changes += changes
+        if pr_ref:
+            pr_refs.append(pr_ref)
 
-    if detailed_exit_code:
-        raise typer.Exit(EXIT_CHANGES if total_changes > 0 else EXIT_NO_CHANGES)
+    if config.auto_merge and pr_refs and not opts.no_auto_merge:
+        handle_auto_merge(pr_refs, config.auto_merge, no_wait=opts.no_wait)
+
+    return total_changes
 
 
 def _sync_destination(
@@ -196,7 +224,7 @@ def _sync_destination(
     src_repo_url: str,
     opts: CopyOptions,
     read_log: Callable[[], str],
-) -> int:
+) -> tuple[int, PRRef | None]:
     dest_root = (src_root / dest.dest_path_relative).resolve()
 
     if opts.dry_run and not dest_root.exists():
@@ -205,7 +233,6 @@ def _sync_destination(
     dest_repo = _ensure_dest_repo(dest, dest_root, opts.dry_run)
     copy_branch = dest.resolved_copy_branch(config.name)
 
-    # --no-checkout skips branch switching (assumes already on correct branch)
     if not opts.no_checkout and prompt_utils.prompt_confirm(f"Switch {dest.name} to {copy_branch}?", opts.no_prompt):
         git_ops.prepare_copy_branch(
             repo=dest_repo,
@@ -218,9 +245,8 @@ def _sync_destination(
 
     if result.total == 0:
         logger.info(f"{dest.name}: No changes")
-        return 0
+        return 0, None
 
-    # --skip-commit and --dry-run skip commit; otherwise prompt
     should_skip_commit = opts.skip_commit or opts.dry_run
     if not should_skip_commit and prompt_utils.prompt_confirm(f"Commit changes to {dest.name}?", opts.no_prompt):
         sync_commit_msg = f"chore: sync {config.name} from {current_sha[:8]}"
@@ -240,10 +266,10 @@ def _sync_destination(
 
         if verify_result.status == VerifyStatus.SKIPPED:
             logger.warning(f"{dest.name}: Verification skipped due to failure")
-            return result.total
+            return result.total, None
 
-    _push_and_pr(config, dest_repo, dest_root, dest, current_sha, src_repo_url, opts, read_log, verify_result)
-    return result.total
+    pr_ref = _push_and_pr(config, dest_repo, dest_root, dest, current_sha, src_repo_url, opts, read_log, verify_result)
+    return result.total, pr_ref
 
 
 def _print_sync_summary(dest: Destination, result: SyncResult) -> None:
@@ -526,29 +552,28 @@ def _push_and_pr(
     opts: CopyOptions,
     read_log: Callable[[], str],
     verify_result: VerifyResult,
-) -> None:
+) -> PRRef | None:
     if opts.skip_commit or opts.dry_run:
         logger.info("Skipping push/PR (--skip-commit or --dry-run)")
-        return
+        return None
 
     copy_branch = dest.resolved_copy_branch(config.name)
 
-    # Commit any remaining changes from verify steps without their own commit config
     if git_ops.has_changes(repo):
         if not prompt_utils.prompt_confirm(f"Commit remaining changes to {dest.name}?", opts.no_prompt):
-            return
+            return None
         commit_msg = f"chore: post-sync changes for {config.name}"
         git_ops.commit_changes(repo, commit_msg)
         typer.echo(f"  Committed: {commit_msg}", err=True)
 
     if not prompt_utils.prompt_confirm(f"Push {dest.name} to origin?", opts.no_prompt):
-        return
+        return None
 
     git_ops.push_branch(repo, copy_branch, force=True)
     typer.echo(f"  Pushed: {copy_branch} (force)", err=True)
 
     if opts.no_pr or not prompt_utils.prompt_confirm(f"Create PR for {dest.name}?", opts.no_prompt):
-        return
+        return None
 
     sync_log = read_log()
     pr_body = config.pr_defaults.format_body(
@@ -574,6 +599,9 @@ def _push_and_pr(
     if pr_url:
         typer.echo(f"  Created PR: {pr_url}", err=True)
 
+    branch_or_url = pr_url or copy_branch
+    return PRRef(dest_name=dest.name, repo_path=dest_root, branch_or_url=branch_or_url)
+
 
 def _append_verify_warnings(body: str, failures: list[StepFailure]) -> str:
     body += "\n\n---\n## Verification Warnings\n"

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/_internal/cmd_dep_update.py

@@ -11,6 +11,7 @@ import typer
 from git import Repo
 
 from path_sync._internal import cmd_options, git_ops, prompt_utils, verify
+from path_sync._internal.auto_merge import PRRef, handle_auto_merge
 from path_sync._internal.log_capture import capture_log
 from path_sync._internal.models import Destination, OnFailStrategy, find_repo_root
 from path_sync._internal.models_dep import (
@@ -50,6 +51,8 @@ class RepoResult:
 class DepUpdateOptions:
     dry_run: bool = False
     skip_verify: bool = False
+    no_wait: bool = False
+    no_auto_merge: bool = False
     reviewers: list[str] | None = None
     assignees: list[str] | None = None
 
@@ -61,6 +64,8 @@ def dep_update(
     work_dir: str = typer.Option("", "--work-dir", help="Clone repos here (overrides dest_path_relative)"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Preview without creating PRs"),
     skip_verify: bool = typer.Option(False, "--skip-verify", help="Skip verification steps"),
+    no_wait: bool = typer.Option(False, "--no-wait", help="Enable auto-merge but skip polling for merge completion"),
+    no_auto_merge: bool = typer.Option(False, "--no-auto-merge", help="Skip auto-merge even when configured"),
     src_root_opt: str = typer.Option("", "--src-root", help="Source repo root"),
     pr_reviewers: str = cmd_options.pr_reviewers_option(),
     pr_assignees: str = cmd_options.pr_assignees_option(),
@@ -82,12 +87,17 @@ def dep_update(
     opts = DepUpdateOptions(
         dry_run=dry_run,
         skip_verify=skip_verify,
+        no_wait=no_wait,
+        no_auto_merge=no_auto_merge,
         reviewers=cmd_options.split_csv(pr_reviewers) or config.pr.reviewers,
         assignees=cmd_options.split_csv(pr_assignees) or config.pr.assignees,
     )
 
     results = _update_and_validate(config, destinations, src_root, work_dir, opts)
-    _create_prs(config, results, opts)
+    pr_refs = _create_prs(config, results, opts)
+
+    if config.auto_merge and pr_refs and not opts.no_auto_merge:
+        handle_auto_merge(pr_refs, config.auto_merge, no_wait=opts.no_wait)
 
     if any(r.status == Status.SKIPPED for r in results):
         raise typer.Exit(1)
@@ -172,7 +182,8 @@ def _verify_repo(repo: Repo, repo_path: Path, fallback_verify: verify.VerifyConf
     return RepoResult(dest=dest, repo_path=repo_path, status=status, failures=result.failures)
 
 
-def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOptions) -> None:
+def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOptions) -> list[PRRef]:
+    pr_refs: list[PRRef] = []
     for result in results:
         if result.status == Status.SKIPPED:
             continue
@@ -185,7 +196,7 @@ def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOpt
         git_ops.push_branch(repo, config.pr.branch, force=True)
 
         body = _build_pr_body(result.log_content, result.failures)
-        git_ops.create_or_update_pr(
+        pr_url = git_ops.create_or_update_pr(
             result.repo_path,
             config.pr.branch,
             config.pr.title,
@@ -193,9 +204,11 @@ def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOpt
             config.pr.labels or None,
             reviewers=opts.reviewers,
             assignees=opts.assignees,
-            auto_merge=config.pr.auto_merge,
         )
         logger.info(f"{result.dest.name}: PR created/updated")
+        branch_or_url = pr_url or config.pr.branch
+        pr_refs.append(PRRef(dest_name=result.dest.name, repo_path=result.repo_path, branch_or_url=branch_or_url))
+    return pr_refs
 
 
 def _resolve_repo_path(dest: Destination, src_root: Path, work_dir: str) -> Path:

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/_internal/git_ops.py

@@ -210,7 +210,6 @@ def create_or_update_pr(
     labels: list[str] | None = None,
     reviewers: list[str] | None = None,
     assignees: list[str] | None = None,
-    auto_merge: bool = False,
 ) -> str:
     cmd = ["gh", "pr", "create", "--head", branch, "--title", title]
     cmd.extend(["--body", body or ""])
@@ -226,26 +225,13 @@ def create_or_update_pr(
         if "already exists" in result.stderr:
             logger.info("PR already exists, updating body")
             update_pr_body(repo_path, branch, body)
-            if auto_merge:
-                _enable_auto_merge(repo_path, branch)
             return ""
         raise RuntimeError(f"Failed to create PR: {result.stderr}")
     pr_url = result.stdout.strip()
     logger.info(f"Created PR: {pr_url}")
-    if auto_merge:
-        _enable_auto_merge(repo_path, pr_url)
     return pr_url
 
 
-def _enable_auto_merge(repo_path: Path, pr_ref: str) -> None:
-    cmd = ["gh", "pr", "merge", "--auto", "--squash", pr_ref]
-    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
-    if result.returncode != 0:
-        logger.warning(f"Auto-merge failed (branch protection may not be configured): {result.stderr}")
-    else:
-        logger.info(f"Enabled auto-merge for {pr_ref}")
-
-
 def file_has_git_changes(repo: Repo, file_path: Path, base_ref: str = "HEAD") -> bool:
     rel_path = str(file_path.relative_to(repo.working_dir))
     diff = repo.git.diff("--name-only", base_ref, "--", rel_path)

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/_internal/models.py

@@ -29,6 +29,19 @@ def _default_exclude_dirs() -> set[str]:
     return set(DEFAULT_EXCLUDE_DIRS)
 
 
+class MergeMethod(StrEnum):
+    SQUASH = "squash"
+    MERGE = "merge"
+    REBASE = "rebase"
+
+
+class AutoMergeConfig(BaseModel):
+    method: MergeMethod = MergeMethod.MERGE
+    delete_branch: bool = True
+    poll_interval_seconds: int = 30
+    timeout_seconds: int = 900
+
+
 class SyncMode(StrEnum):
     SYNC = "sync"
     REPLACE = "replace"
@@ -178,6 +191,7 @@ class SrcConfig(BaseModel):
     destinations: list[Destination] = Field(default_factory=list)
     verify: VerifyConfig | None = None
     wrap_synced_files: bool = False
+    auto_merge: AutoMergeConfig | None = None
 
     def find_destination(self, name: str) -> Destination:
         for dest in self.destinations:

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/_internal/models_dep.py

@@ -6,6 +6,7 @@ from typing import ClassVar
 from pydantic import BaseModel, Field
 
 from path_sync._internal.models import (
+    AutoMergeConfig,
     Destination,
     PRFieldsBase,
     SrcConfig,
@@ -23,7 +24,6 @@ class UpdateEntry(BaseModel):
 class PRConfig(PRFieldsBase):
     branch: str
     title: str
-    auto_merge: bool = False
 
 
 class DepConfig(BaseModel):
@@ -36,6 +36,7 @@ class DepConfig(BaseModel):
     updates: list[UpdateEntry]
     verify: VerifyConfig = Field(default_factory=VerifyConfig)
     pr: PRConfig
+    auto_merge: AutoMergeConfig | None = None
 
     def load_destinations(self, repo_root: Path) -> list[Destination]:
         src_config_path = resolve_config_path(repo_root, self.from_config)

{path_sync-0.6.2 → path_sync-0.7.0}/path_sync/config.py

@@ -1,13 +1,17 @@
 # Generated by pkg-ext
+from path_sync._internal.models import AutoMergeConfig as _AutoMergeConfig
 from path_sync._internal.models import Destination as _Destination
 from path_sync._internal.models import HeaderConfig as _HeaderConfig
+from path_sync._internal.models import MergeMethod as _MergeMethod
 from path_sync._internal.models import PathMapping as _PathMapping
 from path_sync._internal.models import PRDefaults as _PRDefaults
 from path_sync._internal.models import SrcConfig as _SrcConfig
 from path_sync._internal.models import SyncMode as _SyncMode
 
+AutoMergeConfig = _AutoMergeConfig
 Destination = _Destination
 HeaderConfig = _HeaderConfig
+MergeMethod = _MergeMethod
 PRDefaults = _PRDefaults
 PathMapping = _PathMapping
 SrcConfig = _SrcConfig

{path_sync-0.6.2 → path_sync-0.7.0}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [project]
 name = "path-sync"
-version = "0.6.2"
+version = "0.7.0"
 description = "Sync files from a source repo to multiple destination repos"
 requires-python = ">=3.13"
 license = "MIT"