path-sync 0.7.4__tar.gz → 0.7.6__tar.gz

{path_sync-0.7.4 → path_sync-0.7.6}/PKG-INFO

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

{path_sync-0.7.4 → path_sync-0.7.6}/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.7.4"
+VERSION = "0.7.6"
 __all__ = [
     "copy",
     "dep_update",

{path_sync-0.7.4 → path_sync-0.7.6}/path_sync/_internal/auto_merge.py

@@ -70,15 +70,16 @@ class PRMergeResult(BaseModel):
         return [c for c in self.checks if c.pending]
 
 
-def enable_auto_merge(repo_path: Path, pr_ref: str, config: AutoMergeConfig) -> None:
+def enable_auto_merge(repo_path: Path, pr_ref: str, config: AutoMergeConfig, dest_name: str = "") -> None:
+    label = dest_name or pr_ref
     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()}")
+        logger.warning(f"  {label}: auto-merge enable failed: {result.stderr.strip()}")
     else:
-        logger.info(f"Enabled auto-merge ({config.method}) for {pr_ref}")
+        logger.info(f"  {label}: enabled auto-merge ({config.method})")
 
 
 def get_pr_checks(repo_path: Path, pr_ref: str) -> list[CheckRun]:
@@ -103,6 +104,7 @@ 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:
+        logger.warning(f"Failed to get PR URL for {pr_ref}: {result.stderr.strip()}")
         return pr_ref
     return result.stdout.strip() or pr_ref
 
@@ -110,21 +112,31 @@ def get_pr_url(repo_path: Path, pr_ref: str) -> str:
 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
+    label = dest_name or pr_ref
+    poll_count = 0
 
     while time.monotonic() < deadline:
         state = get_pr_state(repo_path, pr_ref)
         if state == PRState.MERGED:
+            logger.info(f"{label}: merged ({pr_url})")
             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)
+            logger.warning(f"{label}: PR closed without merging ({pr_url})")
             return PRMergeResult(dest_name=dest_name, pr_url=pr_url, branch=pr_ref, state=PRState.CLOSED, checks=checks)
+        poll_count += 1
+        elapsed = int(config.timeout_seconds - (deadline - time.monotonic()))
+        logger.info(f"{label}: still open (poll #{poll_count}, {elapsed}s elapsed)")
         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")
+    logger.warning(f"Timeout waiting for {label} after {config.timeout_seconds}s ({pr_url})")
     return PRMergeResult(dest_name=dest_name, pr_url=pr_url, branch=pr_ref, state=PRState.OPEN, checks=checks)
 
 
+SEPARATOR_WIDTH = 40
+
+
 def handle_auto_merge(
     pr_refs: list[PRRef],
     config: AutoMergeConfig,
@@ -133,22 +145,27 @@ def handle_auto_merge(
     if not pr_refs:
         return []
 
+    line = "─" * SEPARATOR_WIDTH
+    logger.info(f"\n{line}")
+    logger.info(" Auto-merge")
+    logger.info(line)
+
     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")
+            logger.info(f"  {ref.dest_name}: already merged")
             continue
-        enable_auto_merge(ref.repo_path, ref.branch_or_url, config)
+        enable_auto_merge(ref.repo_path, ref.branch_or_url, config, dest_name=ref.dest_name)
         pending_refs.append(ref)
 
     if no_wait:
-        logger.info("--no-wait: skipping merge polling")
+        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...")
+        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)
 
@@ -160,9 +177,10 @@ 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"
+    max_url = max(len(r.pr_url) for r in results)
+    header = f"{'Repo':<{max_name}}  {'PR':<{max_url}}  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}")
+        logger.info(f"{r.dest_name:<{max_name}}  {r.pr_url:<{max_url}}  {r.state:<8} {failed}")

{path_sync-0.7.4 → path_sync-0.7.6}/path_sync/_internal/cmd_copy.py

@@ -23,6 +23,7 @@ from path_sync._internal.models import (
     pr_already_synced,
     resolve_config_path,
 )
+from path_sync._internal.repo_utils import ensure_repo, resolve_repo_path
 from path_sync._internal.typer_app import app
 from path_sync._internal.verify import StepFailure, VerifyResult, VerifyStatus
 from path_sync._internal.yaml_utils import load_yaml_model
@@ -57,6 +58,7 @@ class CopyOptions(BaseModel):
     skip_verify: bool = False
     no_wait: bool = False
     no_auto_merge: bool = False
+    work_dir: str = ""
     pr_title: str = ""
     labels: list[str] | None = None
     reviewers: list[str] | None = None
@@ -78,6 +80,7 @@ def copy(
         help="Source repo root (default: find git root from cwd)",
     ),
     dest_filter: str = typer.Option("", "-d", "--dest", help="Filter destinations (comma-separated)"),
+    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 writing"),
     force_overwrite: bool = typer.Option(
         False,
@@ -174,6 +177,7 @@ def copy(
         skip_verify=skip_verify,
         no_wait=no_wait,
         no_auto_merge=no_auto_merge,
+        work_dir=work_dir,
         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,
@@ -251,15 +255,13 @@ def _sync_destination(
     opts: CopyOptions,
     read_log: Callable[[], str],
 ) -> tuple[int, PRRef | None]:
-    dest_root = (src_root / dest.dest_path_relative).resolve()
-
-    if opts.dry_run and not dest_root.exists():
-        raise ValueError(f"Destination repo not found: {dest_root}. Clone it first or run without --dry-run.")
-
-    dest_repo = _ensure_dest_repo(dest, dest_root, opts.dry_run)
+    dest_root = resolve_repo_path(dest, src_root, opts.work_dir)
+    dest_repo = ensure_repo(dest, dest_root, dry_run=opts.dry_run)
     copy_branch = dest.resolved_copy_branch(config.name)
+    _print_dest_header(dest)
 
     if _skip_already_synced(dest.name, dest_root, copy_branch, commit_ts, opts, config):
+        typer.echo("  (already synced, skipped)", err=True)
         return 0, None
 
     if not opts.no_checkout and prompt_utils.prompt_confirm(f"Switch {dest.name} to {copy_branch}?", opts.no_prompt):
@@ -270,10 +272,10 @@ def _sync_destination(
             from_default=opts.checkout_from_default,
         )
     result = _sync_paths(config, dest, src_root, dest_root, opts)
-    _print_sync_summary(dest, result)
+    _print_sync_summary(result)
 
     if result.total == 0:
-        logger.info(f"{dest.name}: No changes")
+        typer.echo("  No changes", err=True)
         _close_stale_pr(dest_root, copy_branch, opts, config)
         return 0, None
 
@@ -304,24 +306,23 @@ def _sync_destination(
     return result.total, pr_ref
 
 
-def _print_sync_summary(dest: Destination, result: SyncResult) -> None:
-    typer.echo(f"\nSyncing to {dest.name}...", err=True)
+SEPARATOR_WIDTH = 40
+
+
+def _print_dest_header(dest: Destination) -> None:
+    line = "─" * SEPARATOR_WIDTH
+    typer.echo(f"\n{line}", err=True)
+    typer.echo(f" {dest.name}", err=True)
+    typer.echo(line, err=True)
+
+
+def _print_sync_summary(result: SyncResult) -> None:
     if result.content_changes > 0:
         typer.echo(f"  [{result.content_changes} files synced]", err=True)
     if result.orphans_deleted > 0:
         typer.echo(f"  [-] {result.orphans_deleted} orphans deleted", err=True)
     if result.total > 0:
-        typer.echo(f"\n{result.total} changes ready.", err=True)
-
-
-def _ensure_dest_repo(dest: Destination, dest_root: Path, dry_run: bool):
-    if not dest_root.exists():
-        if dry_run:
-            raise ValueError(f"Destination repo not found: {dest_root}. Clone it first or run without --dry-run.")
-        if not dest.repo_url:
-            raise ValueError(f"Dest {dest.name} not found and no repo_url configured")
-        git_ops.clone_repo(dest.repo_url, dest_root)
-    return git_ops.get_repo(dest_root)
+        typer.echo(f"  {result.total} changes ready.", err=True)
 
 
 def _sync_paths(

{path_sync-0.7.4 → path_sync-0.7.6}/path_sync/_internal/cmd_dep_update.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-import shutil
 import subprocess
 from dataclasses import dataclass, field
 from enum import StrEnum
@@ -10,7 +9,7 @@ from pathlib import Path
 import typer
 from git import Repo
 
-from path_sync._internal import cmd_options, git_ops, prompt_utils, verify
+from path_sync._internal import cmd_options, git_ops, 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
@@ -19,6 +18,7 @@ from path_sync._internal.models_dep import (
     UpdateEntry,
     resolve_dep_config_path,
 )
+from path_sync._internal.repo_utils import ensure_repo, resolve_repo_path
 from path_sync._internal.typer_app import app
 from path_sync._internal.verify import StepFailure, VerifyStatus
 from path_sync._internal.yaml_utils import load_yaml_model
@@ -154,8 +154,8 @@ def _process_single_repo_inner(
     opts: DepUpdateOptions,
 ) -> RepoResult:
     logger.info(f"Processing {dest.name}...")
-    repo_path = _resolve_repo_path(dest, src_root, work_dir)
-    repo = _ensure_repo(dest, repo_path, dest.default_branch)
+    repo_path = resolve_repo_path(dest, src_root, work_dir)
+    repo = ensure_repo(dest, repo_path)
     git_ops.prepare_copy_branch(repo, dest.default_branch, config.pr.branch, from_default=True)
 
     if failure := _run_updates(config.updates, repo_path):
@@ -219,29 +219,6 @@ def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOpt
     return pr_refs
 
 
-def _resolve_repo_path(dest: Destination, src_root: Path, work_dir: str) -> Path:
-    if work_dir:
-        return Path(work_dir) / dest.name
-    if dest.dest_path_relative:
-        return (src_root / dest.dest_path_relative).resolve()
-    raise typer.BadParameter(f"No dest_path_relative for {dest.name}, --work-dir required")
-
-
-def _ensure_repo(dest: Destination, repo_path: Path, default_branch: str) -> Repo:
-    if repo_path.exists():
-        if git_ops.is_git_repo(repo_path):
-            repo = git_ops.get_repo(repo_path)
-            git_ops.fetch_and_reset_to_default(repo, default_branch)
-            return repo
-        logger.warning(f"Invalid git repo at {repo_path}")
-        if not prompt_utils.prompt_confirm(f"Remove {repo_path} and re-clone?"):
-            raise typer.Abort()
-        shutil.rmtree(repo_path)
-    if not dest.repo_url:
-        raise ValueError(f"Dest {dest.name} not found at {repo_path} and no repo_url configured")
-    return git_ops.clone_repo(dest.repo_url, repo_path)
-
-
 def _build_pr_body(log_content: str, failures: list[StepFailure]) -> str:
     body = "Automated dependency update."
 

{path_sync-0.7.4 → path_sync-0.7.6}/path_sync/_internal/git_ops.py

@@ -202,7 +202,8 @@ def update_pr_body(repo_path: Path, branch: str, body: str) -> bool:
     if result.returncode != 0:
         logger.warning(f"Failed to update PR body: {result.stderr}")
         return False
-    logger.info("Updated PR body")
+    pr_url = f"https://github.com/{repo_full}/pull/{pr_number}"
+    logger.info(f"Updated PR body: {pr_url}")
     return True
 
 

path_sync-0.7.6/path_sync/_internal/repo_utils.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+
+from git import Repo
+
+from path_sync._internal import git_ops, prompt_utils
+from path_sync._internal.models import Destination
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_repo_path(dest: Destination, src_root: Path, work_dir: str) -> Path:
+    if work_dir:
+        return Path(work_dir) / dest.name
+    if dest.dest_path_relative:
+        return (src_root / dest.dest_path_relative).resolve()
+    raise ValueError(f"No dest_path_relative for {dest.name}, use --work-dir")
+
+
+def ensure_repo(dest: Destination, repo_path: Path, dry_run: bool = False) -> Repo:
+    if repo_path.exists():
+        if git_ops.is_git_repo(repo_path):
+            return git_ops.get_repo(repo_path)
+        logger.warning(f"Invalid git repo at {repo_path}")
+        if dry_run:
+            raise ValueError(f"Invalid git repo at {repo_path}, cannot re-clone in dry-run mode")
+        if not prompt_utils.prompt_confirm(f"Remove {repo_path} and re-clone?"):
+            raise ValueError(f"Aborted: user declined to remove invalid repo at {repo_path}")
+        shutil.rmtree(repo_path)
+    if dry_run:
+        raise ValueError(f"Destination repo not found: {repo_path}. Clone it first or run without --dry-run.")
+    if not dest.repo_url:
+        raise ValueError(f"Dest {dest.name} not found at {repo_path} and no repo_url configured")
+    return git_ops.clone_repo(dest.repo_url, repo_path)

{path_sync-0.7.4 → path_sync-0.7.6}/pyproject.toml

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