path-sync 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

path_sync/__init__.py

@@ -3,7 +3,7 @@
 from path_sync import copy
 from path_sync import config
 
-VERSION = "0.3.0"
+VERSION = "0.3.1"
 __all__ = [
     "copy",
     "config",

path_sync/_internal/__init__.py

@@ -0,0 +1 @@
+"""Internal implementation - not part of public API."""

path_sync/_internal/cmd_boot.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from path_sync._internal import git_ops
+from path_sync._internal.file_utils import ensure_parents_write_text
+from path_sync._internal.models import (
+    Destination,
+    PathMapping,
+    SrcConfig,
+    find_repo_root,
+    resolve_config_path,
+)
+from path_sync._internal.typer_app import app
+from path_sync._internal.yaml_utils import dump_yaml_model, load_yaml_model
+
+logger = logging.getLogger(__name__)
+
+
+@app.command()
+def boot(
+    name: str = typer.Option(..., "-n", "--name", help="Config name"),
+    dest_paths: Annotated[list[str], typer.Option("-d", "--dest", help="Destination relative paths")] = [],
+    sync_paths: Annotated[list[str], typer.Option("-p", "--path", help="Paths to sync (glob patterns)")] = [],
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview without writing"),
+    regen: bool = typer.Option(False, "--regen", help="Regenerate config"),
+) -> None:
+    """Initialize or update SRC repo config."""
+    repo_root = find_repo_root(Path.cwd())
+    config_path = resolve_config_path(repo_root, name)
+
+    if config_path.exists() and not regen:
+        load_yaml_model(config_path, SrcConfig)
+        logger.info(f"Using existing config: {config_path}")
+    else:
+        src_repo = git_ops.get_repo(repo_root)
+        src_repo_url = git_ops.get_remote_url(src_repo, "origin")
+
+        destinations = _build_destinations(repo_root, dest_paths)
+        path_mappings = [PathMapping(src_path=p) for p in sync_paths]
+
+        config = SrcConfig(
+            name=name,
+            src_repo_url=src_repo_url,
+            paths=path_mappings,
+            destinations=destinations,
+        )
+        config_content = dump_yaml_model(config)
+        _write_file(config_path, config_content, dry_run, "config")
+
+    if dry_run:
+        logger.info("Dry run complete - no files written")
+    else:
+        logger.info("Boot complete")
+
+
+def _build_destinations(repo_root: Path, dest_paths: list[str]) -> list[Destination]:
+    destinations = []
+    for rel_path in dest_paths:
+        dest_dir = (repo_root / rel_path).resolve()
+        dest_name = dest_dir.name
+
+        dest = Destination(name=dest_name, dest_path_relative=rel_path)
+
+        if git_ops.is_git_repo(dest_dir):
+            dest_repo = git_ops.get_repo(dest_dir)
+            dest.repo_url = git_ops.get_remote_url(dest_repo, "origin")
+            dest.default_branch = git_ops.get_default_branch(dest_repo)
+            logger.info(f"Found git repo at {dest_dir}: {dest.repo_url}")
+
+        destinations.append(dest)
+
+    return destinations
+
+
+def _write_file(path: Path, content: str, dry_run: bool, desc: str) -> None:
+    if dry_run:
+        logger.info(f"[DRY RUN] Would write {desc}: {path}")
+        return
+    ensure_parents_write_text(path, content)
+    logger.info(f"Wrote {desc}: {path}")

path_sync/_internal/cmd_copy.py

@@ -0,0 +1,546 @@
+from __future__ import annotations
+
+import glob
+import logging
+import tempfile
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import typer
+
+from path_sync import sections
+from path_sync._internal import git_ops, header
+from path_sync._internal.file_utils import ensure_parents_write_text
+from path_sync._internal.models import (
+    LOG_FORMAT,
+    Destination,
+    PathMapping,
+    SrcConfig,
+    SyncMode,
+    find_repo_root,
+    resolve_config_path,
+)
+from path_sync._internal.typer_app import app
+from path_sync._internal.yaml_utils import load_yaml_model
+
+logger = logging.getLogger(__name__)
+
+EXIT_NO_CHANGES = 0
+EXIT_CHANGES = 1
+EXIT_ERROR = 2
+
+
+def _prompt(message: str, no_prompt: bool) -> bool:
+    if no_prompt:
+        return True
+    try:
+        response = input(f"{message} [y/n]: ").strip().lower()
+        return response == "y"
+    except (EOFError, KeyboardInterrupt):
+        return False
+
+
+@dataclass
+class SyncResult:
+    content_changes: int = 0
+    orphans_deleted: int = 0
+    synced_paths: set[Path] = field(default_factory=set)
+
+    @property
+    def total(self) -> int:
+        return self.content_changes + self.orphans_deleted
+
+
+@contextmanager
+def capture_sync_log(dest_name: str):
+    with tempfile.TemporaryDirectory(prefix="path-sync-") as tmpdir:
+        log_path = Path(tmpdir) / f"{dest_name}.log"
+        file_handler = logging.FileHandler(log_path, mode="w")
+        file_handler.setLevel(logging.INFO)
+        file_handler.setFormatter(logging.Formatter(LOG_FORMAT))
+        root_logger = logging.getLogger("path_sync")
+        root_logger.addHandler(file_handler)
+        try:
+            yield log_path
+        finally:
+            file_handler.close()
+            root_logger.removeHandler(file_handler)
+
+
+@dataclass
+class CopyOptions:
+    dry_run: bool = False
+    force_overwrite: bool = False
+    no_checkout: bool = False
+    checkout_from_default: bool = False
+    local: bool = False
+    no_prompt: bool = False
+    no_pr: bool = False
+    skip_orphan_cleanup: bool = False
+    pr_title: str = ""
+    pr_labels: str = ""
+    pr_reviewers: str = ""
+    pr_assignees: str = ""
+
+
+@app.command()
+def copy(
+    name: str = typer.Option(..., "-n", "--name", help="Config name"),
+    dest_filter: str = typer.Option("", "-d", "--dest", help="Filter destinations (comma-separated)"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview without writing"),
+    force_overwrite: bool = typer.Option(
+        False,
+        "--force-overwrite",
+        help="Overwrite files even if header removed (opted out)",
+    ),
+    detailed_exit_code: bool = typer.Option(
+        False,
+        "--detailed-exit-code",
+        help="Exit 0=no changes, 1=changes, 2=error",
+    ),
+    no_checkout: bool = typer.Option(
+        False,
+        "--no-checkout",
+        help="Skip branch switching before sync",
+    ),
+    checkout_from_default: bool = typer.Option(
+        False,
+        "--checkout-from-default",
+        help="Reset to origin/default before sync (for CI)",
+    ),
+    local: bool = typer.Option(
+        False,
+        "--local",
+        help="No git operations after sync (no commit/push/PR)",
+    ),
+    no_prompt: bool = typer.Option(
+        False,
+        "-y",
+        "--no-prompt",
+        help="Skip confirmations (for CI)",
+    ),
+    no_pr: bool = typer.Option(
+        False,
+        "--no-pr",
+        help="Push but skip PR creation",
+    ),
+    pr_title: str = typer.Option(
+        "",
+        "--pr-title",
+        help="Override PR title (supports {name}, {dest_name})",
+    ),
+    pr_labels: str = typer.Option(
+        "",
+        "--pr-labels",
+        help="Comma-separated PR labels",
+    ),
+    pr_reviewers: str = typer.Option(
+        "",
+        "--pr-reviewers",
+        help="Comma-separated PR reviewers",
+    ),
+    pr_assignees: str = typer.Option(
+        "",
+        "--pr-assignees",
+        help="Comma-separated PR assignees",
+    ),
+    skip_orphan_cleanup: bool = typer.Option(
+        False,
+        "--skip-orphan-cleanup",
+        help="Skip deletion of orphaned synced files",
+    ),
+) -> None:
+    """Copy files from SRC to DEST repositories."""
+    src_root = find_repo_root(Path.cwd())
+    config_path = resolve_config_path(src_root, name)
+
+    if not config_path.exists():
+        logger.error(f"Config not found: {config_path}")
+        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,
+        force_overwrite=force_overwrite,
+        no_checkout=no_checkout,
+        checkout_from_default=checkout_from_default,
+        local=local,
+        no_prompt=no_prompt,
+        no_pr=no_pr,
+        skip_orphan_cleanup=skip_orphan_cleanup,
+        pr_title=pr_title or config.pr_defaults.title,
+        pr_labels=pr_labels or ",".join(config.pr_defaults.labels),
+        pr_reviewers=pr_reviewers or ",".join(config.pr_defaults.reviewers),
+        pr_assignees=pr_assignees or ",".join(config.pr_defaults.assignees),
+    )
+
+    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
+    for dest in destinations:
+        try:
+            with capture_sync_log(dest.name) as log_path:
+                changes = _sync_destination(config, dest, src_root, current_sha, src_repo_url, opts, log_path)
+            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
+
+    if detailed_exit_code:
+        raise typer.Exit(EXIT_CHANGES if total_changes > 0 else EXIT_NO_CHANGES)
+
+
+def _sync_destination(
+    config: SrcConfig,
+    dest: Destination,
+    src_root: Path,
+    current_sha: str,
+    src_repo_url: str,
+    opts: CopyOptions,
+    log_path: Path,
+) -> int:
+    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)
+    copy_branch = dest.resolved_copy_branch(config.name)
+
+    # --no-checkout means "I'm already on the right branch"
+    # Prompt decline means "skip git operations for this run"
+    if opts.no_checkout:
+        skip_git_ops = False
+    elif opts.dry_run:
+        skip_git_ops = True
+    elif _prompt(f"Switch {dest.name} to {copy_branch}?", opts.no_prompt):
+        git_ops.prepare_copy_branch(
+            repo=dest_repo,
+            default_branch=dest.default_branch,
+            copy_branch=copy_branch,
+            from_default=opts.checkout_from_default,
+        )
+        skip_git_ops = False
+    else:
+        skip_git_ops = True
+
+    result = _sync_paths(config, dest, src_root, dest_root, opts)
+    _print_sync_summary(dest, result)
+
+    if result.total == 0:
+        logger.info(f"{dest.name}: No changes")
+        return 0
+
+    if skip_git_ops:
+        return result.total
+
+    _commit_and_pr(config, dest_repo, dest_root, dest, current_sha, src_repo_url, opts, log_path)
+    return result.total
+
+
+def _print_sync_summary(dest: Destination, result: SyncResult) -> None:
+    typer.echo(f"\nSyncing to {dest.name}...", err=True)
+    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)
+
+
+def _sync_paths(
+    config: SrcConfig,
+    dest: Destination,
+    src_root: Path,
+    dest_root: Path,
+    opts: CopyOptions,
+) -> SyncResult:
+    result = SyncResult()
+    for mapping in config.paths:
+        changes, paths = _sync_path(
+            mapping,
+            src_root,
+            dest_root,
+            dest,
+            config.name,
+            opts.dry_run,
+            opts.force_overwrite,
+        )
+        result.content_changes += changes
+        result.synced_paths.update(paths)
+
+    if not opts.skip_orphan_cleanup:
+        result.orphans_deleted = _cleanup_orphans(dest_root, config.name, result.synced_paths, opts.dry_run)
+    return result
+
+
+def _sync_path(
+    mapping: PathMapping,
+    src_root: Path,
+    dest_root: Path,
+    dest: Destination,
+    config_name: str,
+    dry_run: bool,
+    force_overwrite: bool,
+) -> tuple[int, set[Path]]:
+    src_pattern = src_root / mapping.src_path
+    changes = 0
+    synced: set[Path] = set()
+    sync_mode = mapping.sync_mode
+
+    if "*" in mapping.src_path:
+        glob_prefix = mapping.src_path.split("*")[0].rstrip("/")
+        dest_base = mapping.dest_path or glob_prefix
+        matches = glob.glob(str(src_pattern), recursive=True)
+        if not matches:
+            logger.warning(f"Glob matched no files: {mapping.src_path}")
+        for src_file in matches:
+            src_path = Path(src_file)
+            if src_path.is_file():
+                rel = src_path.relative_to(src_root / glob_prefix)
+                dest_path = dest_root / dest_base / rel
+                dest_key = str(Path(dest_base) / rel)
+                changes += _copy_file(
+                    src_path,
+                    dest_path,
+                    dest,
+                    dest_key,
+                    config_name,
+                    sync_mode,
+                    dry_run,
+                    force_overwrite,
+                )
+                synced.add(dest_path)
+    elif src_pattern.is_dir():
+        dest_base = mapping.resolved_dest_path()
+        for src_file in src_pattern.rglob("*"):
+            if src_file.is_file():
+                rel = src_file.relative_to(src_pattern)
+                dest_path = dest_root / dest_base / rel
+                dest_key = str(Path(dest_base) / rel)
+                changes += _copy_file(
+                    src_file,
+                    dest_path,
+                    dest,
+                    dest_key,
+                    config_name,
+                    sync_mode,
+                    dry_run,
+                    force_overwrite,
+                )
+                synced.add(dest_path)
+    elif src_pattern.is_file():
+        dest_base = mapping.resolved_dest_path()
+        dest_path = dest_root / dest_base
+        changes += _copy_file(
+            src_pattern,
+            dest_path,
+            dest,
+            dest_base,
+            config_name,
+            sync_mode,
+            dry_run,
+            force_overwrite,
+        )
+        synced.add(dest_path)
+    else:
+        logger.warning(f"Source not found: {mapping.src_path}")
+
+    return changes, synced
+
+
+def _copy_file(
+    src: Path,
+    dest_path: Path,
+    dest: Destination,
+    dest_key: str,
+    config_name: str,
+    sync_mode: SyncMode,
+    dry_run: bool,
+    force_overwrite: bool = False,
+) -> int:
+    src_content = header.remove_header(src.read_text())
+
+    match sync_mode:
+        case SyncMode.SCAFFOLD:
+            return _handle_scaffold(src_content, dest_path, dry_run)
+        case SyncMode.REPLACE:
+            return _handle_replace(src_content, dest_path, dry_run)
+        case SyncMode.SYNC:
+            skip_list = dest.skip_sections.get(dest_key, [])
+            return _handle_sync(src_content, dest_path, skip_list, config_name, dry_run, force_overwrite)
+
+
+def _handle_scaffold(content: str, dest_path: Path, dry_run: bool) -> int:
+    if dest_path.exists():
+        return 0
+    return _write_file(dest_path, content, dry_run)
+
+
+def _handle_replace(content: str, dest_path: Path, dry_run: bool) -> int:
+    if dest_path.exists() and dest_path.read_text() == content:
+        return 0
+    return _write_file(dest_path, content, dry_run)
+
+
+def _handle_sync(
+    src_content: str,
+    dest_path: Path,
+    skip_list: list[str],
+    config_name: str,
+    dry_run: bool,
+    force_overwrite: bool,
+) -> int:
+    if sections.has_sections(src_content, dest_path):
+        return _handle_sync_sections(src_content, dest_path, skip_list, config_name, dry_run, force_overwrite)
+
+    if dest_path.exists():
+        existing = dest_path.read_text()
+        has_hdr = header.has_header(existing)
+        if not has_hdr and not force_overwrite:
+            logger.info(f"Skipping {dest_path} (header removed - opted out)")
+            return 0
+        if header.remove_header(existing) == src_content and has_hdr:
+            return 0
+
+    new_content = header.add_header(src_content, dest_path, config_name)
+    return _write_file(dest_path, new_content, dry_run)
+
+
+def _write_file(dest_path: Path, content: str, dry_run: bool) -> int:
+    if dry_run:
+        logger.info(f"[DRY RUN] Would write: {dest_path}")
+        return 1
+    ensure_parents_write_text(dest_path, content)
+    logger.info(f"Wrote: {dest_path}")
+    return 1
+
+
+def _handle_sync_sections(
+    src_content: str,
+    dest_path: Path,
+    skip_list: list[str],
+    config_name: str,
+    dry_run: bool,
+    force_overwrite: bool,
+) -> int:
+    src_sections = sections.extract_sections(src_content, dest_path)
+
+    if dest_path.exists():
+        existing = dest_path.read_text()
+        if not header.has_header(existing) and not force_overwrite:
+            logger.info(f"Skipping {dest_path} (header removed - opted out)")
+            return 0
+        dest_body = header.remove_header(existing)
+        new_body = sections.replace_sections(dest_body, src_sections, dest_path, skip_list)
+    else:
+        new_body = src_content
+
+    new_content = header.add_header(new_body, dest_path, config_name)
+
+    if dest_path.exists() and dest_path.read_text() == new_content:
+        return 0
+
+    return _write_file(dest_path, new_content, dry_run)
+
+
+def _cleanup_orphans(
+    dest_root: Path,
+    config_name: str,
+    synced_paths: set[Path],
+    dry_run: bool,
+) -> int:
+    deleted = 0
+    for path in _find_files_with_config(dest_root, config_name):
+        if path not in synced_paths:
+            if dry_run:
+                logger.info(f"[DRY RUN] Would delete orphan: {path}")
+            else:
+                path.unlink()
+                logger.info(f"Deleted orphan: {path}")
+            deleted += 1
+    return deleted
+
+
+def _find_files_with_config(dest_root: Path, config_name: str) -> list[Path]:
+    result = []
+    for path in dest_root.rglob("*"):
+        if ".git" in path.parts:
+            continue
+        if header.file_get_config_name(path) == config_name:
+            result.append(path)
+    return result
+
+
+def _commit_and_pr(
+    config: SrcConfig,
+    repo,
+    dest_root: Path,
+    dest: Destination,
+    sha: str,
+    src_repo_url: str,
+    opts: CopyOptions,
+    log_path: Path,
+) -> None:
+    if opts.local:
+        logger.info("Local mode: skipping commit/push/PR")
+        return
+
+    copy_branch = dest.resolved_copy_branch(config.name)
+
+    if not _prompt(f"Commit changes to {dest.name}?", opts.no_prompt):
+        return
+
+    commit_msg = f"chore: sync {config.name} from {sha[:8]}"
+    git_ops.commit_changes(repo, commit_msg)
+    typer.echo(f"  Committed: {commit_msg}", err=True)
+
+    if not _prompt(f"Push {dest.name} to origin?", opts.no_prompt):
+        return
+
+    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(f"Create PR for {dest.name}?", opts.no_prompt):
+        return
+
+    sync_log = log_path.read_text() if log_path.exists() else ""
+    pr_body = config.pr_defaults.format_body(
+        src_repo_url=src_repo_url,
+        src_sha=sha,
+        sync_log=sync_log,
+        dest_name=dest.name,
+    )
+
+    title = opts.pr_title.format(name=config.name, dest_name=dest.name)
+    pr_url = git_ops.create_or_update_pr(
+        dest_root,
+        copy_branch,
+        title,
+        pr_body,
+        opts.pr_labels.split(",") if opts.pr_labels else None,
+        opts.pr_reviewers.split(",") if opts.pr_reviewers else None,
+        opts.pr_assignees.split(",") if opts.pr_assignees else None,
+    )
+    if pr_url:
+        typer.echo(f"  Created PR: {pr_url}", err=True)

path_sync/_internal/cmd_validate.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import typer
+
+from path_sync._internal import git_ops
+from path_sync._internal.models import find_repo_root
+from path_sync._internal.typer_app import app
+from path_sync._internal.validation import parse_skip_sections, validate_no_unauthorized_changes
+
+logger = logging.getLogger(__name__)
+
+
+@app.command("validate-no-changes")
+def validate_no_changes(
+    branch: str = typer.Option("main", "-b", "--branch", help="Default branch to compare against"),
+    skip_sections_opt: str = typer.Option(
+        "",
+        "--skip-sections",
+        help="Comma-separated path:section_id pairs to skip (e.g., 'justfile:coverage,pyproject.toml:default')",
+    ),
+) -> None:
+    """Validate no unauthorized changes to synced files."""
+    repo_root = find_repo_root(Path.cwd())
+    repo = git_ops.get_repo(repo_root)
+
+    current_branch = repo.active_branch.name
+    if current_branch.startswith("sync/"):
+        logger.info(f"On sync branch {current_branch}, validation skipped")
+        return
+    if current_branch == branch:
+        logger.info(f"On default branch {branch}, validation skipped")
+        return
+
+    skip_sections = parse_skip_sections(skip_sections_opt) if skip_sections_opt else None
+    unauthorized = validate_no_unauthorized_changes(repo_root, branch, skip_sections)
+
+    if unauthorized:
+        files_list = "\n  ".join(unauthorized)
+        logger.error(f"Unauthorized changes in {len(unauthorized)} files:\n  {files_list}")
+        raise typer.Exit(1)
+
+    logger.info("Validation passed: no unauthorized changes")

path_sync/_internal/file_utils.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+
+def ensure_parents_write_text(path: Path | str, text: str) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text)

path_sync/_internal/git_ops.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+from contextlib import suppress
+from pathlib import Path
+
+from git import GitCommandError, InvalidGitRepositoryError, NoSuchPathError, Repo
+
+logger = logging.getLogger(__name__)
+
+
+def _auth_url(url: str) -> str:
+    """Inject GH_TOKEN into HTTPS URL for authentication."""
+    token = os.environ.get("GH_TOKEN", "")
+    if not token:
+        return url
+    if url.startswith("https://github.com/"):
+        return url.replace("https://", f"https://x-access-token:{token}@")
+    return url
+
+
+def get_repo(path: Path) -> Repo:
+    try:
+        return Repo(path)
+    except InvalidGitRepositoryError as e:
+        raise ValueError(f"Not a git repository: {path}") from e
+
+
+def is_git_repo(path: Path) -> bool:
+    with suppress(InvalidGitRepositoryError, NoSuchPathError):
+        Repo(path)
+        return True
+    return False
+
+
+def get_default_branch(repo: Repo) -> str:
+    with suppress(GitCommandError):
+        return repo.git.symbolic_ref("refs/remotes/origin/HEAD", short=True).replace("origin/", "")
+    return "main"
+
+
+def clone_repo(url: str, dest: Path) -> Repo:
+    logger.info(f"Cloning {url} to {dest}")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    return Repo.clone_from(_auth_url(url), str(dest))
+
+
+def checkout_branch(repo: Repo, branch: str) -> None:
+    current = repo.active_branch.name
+    if current == branch:
+        return
+    logger.info(f"Checking out {branch}")
+    try:
+        repo.git.checkout(branch)
+    except GitCommandError:
+        repo.git.checkout("-b", branch)
+
+
+def prepare_copy_branch(repo: Repo, default_branch: str, copy_branch: str, from_default: bool = False) -> None:
+    """Prepare copy_branch for syncing.
+
+    Args:
+        from_default: If True, fetch origin and reset to origin/default_branch
+                      before creating copy_branch. Use in CI for clean state.
+                      If False, just switch to or create copy_branch from current HEAD.
+    """
+    if from_default:
+        logger.info("Fetching origin")
+        repo.git.fetch("origin")
+
+        logger.info(f"Checking out {default_branch}")
+        repo.git.checkout(default_branch)
+        repo.git.reset("--hard", f"origin/{default_branch}")
+
+        with suppress(GitCommandError):
+            repo.git.branch("-D", copy_branch)
+            logger.info(f"Deleted existing local branch: {copy_branch}")
+
+        logger.info(f"Creating fresh branch: {copy_branch}")
+        repo.git.checkout("-b", copy_branch)
+    else:
+        checkout_branch(repo, copy_branch)
+
+
+def get_current_sha(repo: Repo) -> str:
+    return repo.head.commit.hexsha
+
+
+def get_remote_url(repo: Repo, remote_name: str = "origin") -> str:
+    try:
+        return repo.remote(remote_name).url
+    except ValueError:
+        return ""
+
+
+def has_changes(repo: Repo) -> bool:
+    return repo.is_dirty() or len(repo.untracked_files) > 0
+
+
+def commit_changes(repo: Repo, message: str) -> None:
+    repo.git.add("-A")
+    if repo.is_dirty():
+        _ensure_git_user(repo)
+        repo.git.commit("-m", message)
+        logger.info(f"Committed: {message}")
+
+
+def _ensure_git_user(repo: Repo) -> None:
+    """Configure git user if not already set."""
+    try:
+        repo.config_reader().get_value("user", "name")
+    except Exception:
+        repo.config_writer().set_value("user", "name", "path-sync[bot]").release()
+        repo.config_writer().set_value("user", "email", "path-sync[bot]@users.noreply.github.com").release()
+
+
+def push_branch(repo: Repo, branch: str, force: bool = True) -> None:
+    logger.info(f"Pushing {branch}" + (" (force)" if force else ""))
+    args = ["--force", "-u", "origin", branch] if force else ["-u", "origin", branch]
+    repo.git.push(*args)
+
+
+def update_pr_body(repo_path: Path, branch: str, body: str) -> bool:
+    cmd = ["gh", "pr", "edit", branch, "--body", body]
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.warning(f"Failed to update PR body: {result.stderr}")
+        return False
+    logger.info("Updated PR body")
+    return True
+
+
+def create_or_update_pr(
+    repo_path: Path,
+    branch: str,
+    title: str,
+    body: str = "",
+    labels: list[str] | None = None,
+    reviewers: list[str] | None = None,
+    assignees: list[str] | None = None,
+) -> str:
+    cmd = ["gh", "pr", "create", "--head", branch, "--title", title]
+    cmd.extend(["--body", body or ""])
+    if labels:
+        cmd.extend(["--label", ",".join(labels)])
+    if reviewers:
+        cmd.extend(["--reviewer", ",".join(reviewers)])
+    if assignees:
+        cmd.extend(["--assignee", ",".join(assignees)])
+
+    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+    if result.returncode != 0:
+        if "already exists" in result.stderr:
+            logger.info("PR already exists, updating body")
+            update_pr_body(repo_path, branch, body)
+            return ""
+        raise RuntimeError(f"Failed to create PR: {result.stderr}")
+    logger.info(f"Created PR: {result.stdout.strip()}")
+    return result.stdout.strip()
+
+
+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)
+    return bool(diff.strip())
+
+
+def get_changed_files(repo: Repo, base_ref: str = "HEAD") -> list[Path]:
+    diff = repo.git.diff("--name-only", base_ref)
+    if not diff.strip():
+        return []
+    repo_root = Path(repo.working_dir)
+    return [repo_root / p for p in diff.strip().split("\n")]
+
+
+def get_file_content_at_ref(repo: Repo, file_path: Path, ref: str) -> str | None:
+    rel_path = str(file_path.relative_to(repo.working_dir))
+    with suppress(GitCommandError):
+        return repo.git.show(f"{ref}:{rel_path}")
+    return None

path_sync/_internal/header.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from zero_3rdparty.sections import CommentConfig, get_comment_config
+
+from path_sync._internal.models import HEADER_TEMPLATE, HeaderConfig
+
+HEADER_PATTERN = re.compile(r"path-sync copy -n (?P<config_name>[\w-]+)")
+
+
+def _resolve_comment_config(path: Path, config: HeaderConfig | None) -> CommentConfig:
+    if config:
+        ext = path.suffix
+        prefix = config.comment_prefixes.get(ext)
+        suffix = config.comment_suffixes.get(ext, "")
+        if prefix:
+            return CommentConfig(prefix, suffix)
+    return get_comment_config(path)
+
+
+def get_comment_prefix(path: Path, config: HeaderConfig | None = None) -> str:
+    return _resolve_comment_config(path, config).prefix
+
+
+def get_comment_suffix(path: Path, config: HeaderConfig | None = None) -> str:
+    return _resolve_comment_config(path, config).suffix
+
+
+def get_header_line(path: Path, config_name: str, config: HeaderConfig | None = None) -> str:
+    cc = _resolve_comment_config(path, config)
+    header_text = HEADER_TEMPLATE.format(config_name=config_name)
+    return f"{cc.prefix} {header_text}{cc.suffix}"
+
+
+def has_header(content: str) -> bool:
+    first_line = content.split("\n", 1)[0] if content else ""
+    return bool(HEADER_PATTERN.search(first_line))
+
+
+def get_config_name(content: str) -> str | None:
+    first_line = content.split("\n", 1)[0] if content else ""
+    if match := HEADER_PATTERN.search(first_line):
+        return match.group("config_name")
+    return None
+
+
+def add_header(content: str, path: Path, config_name: str, config: HeaderConfig | None = None) -> str:
+    header = get_header_line(path, config_name, config)
+    return f"{header}\n{content}"
+
+
+def remove_header(content: str) -> str:
+    if not has_header(content):
+        return content
+    lines = content.split("\n", 1)
+    return lines[1] if len(lines) > 1 else ""
+
+
+def has_known_comment_prefix(path: Path) -> bool:
+    try:
+        get_comment_config(path)
+        return True
+    except ValueError:
+        return False
+
+
+def file_get_config_name(path: Path) -> str | None:
+    if not path.exists() or not has_known_comment_prefix(path):
+        return None
+    try:
+        with path.open() as f:
+            first_line = f.readline()
+    except (UnicodeDecodeError, OSError):
+        return None
+    return get_config_name(first_line)
+
+
+def file_has_header(path: Path, config: HeaderConfig | None = None) -> bool:
+    if config and path.suffix not in config.comment_prefixes:
+        return False
+    return file_get_config_name(path) is not None

path_sync/_internal/models.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import glob as glob_mod
+from enum import StrEnum
+from pathlib import Path
+from typing import ClassVar
+
+from pydantic import BaseModel, Field
+
+LOG_FORMAT = "%(asctime)s %(levelname)s %(message)s"
+
+
+class SyncMode(StrEnum):
+    SYNC = "sync"
+    REPLACE = "replace"
+    SCAFFOLD = "scaffold"
+
+
+class PathMapping(BaseModel):
+    src_path: str
+    dest_path: str = ""
+    sync_mode: SyncMode = SyncMode.SYNC
+
+    def resolved_dest_path(self) -> str:
+        return self.dest_path or self.src_path
+
+    def expand_dest_paths(self, repo_root: Path) -> list[Path]:
+        dest_path = self.resolved_dest_path()
+        pattern = repo_root / dest_path
+
+        if "*" in dest_path:
+            return [Path(p) for p in glob_mod.glob(str(pattern), recursive=True)]
+        if pattern.is_dir():
+            return [p for p in pattern.rglob("*") if p.is_file()]
+        if pattern.exists():
+            return [pattern]
+        return []
+
+
+HEADER_TEMPLATE = "path-sync copy -n {config_name}"
+
+
+class HeaderConfig(BaseModel):
+    comment_prefixes: dict[str, str] = Field(default_factory=dict)
+    comment_suffixes: dict[str, str] = Field(default_factory=dict)
+
+
+DEFAULT_BODY_TEMPLATE = """\
+Synced from [{src_repo_name}]({src_repo_url}) @ `{src_sha_short}`
+
+<details>
+<summary>Sync Log</summary>
+
+```
+{sync_log}
+```
+
+</details>
+"""
+
+
+class PRDefaults(BaseModel):
+    title: str = "chore: sync {name} files"
+    body_template: str = DEFAULT_BODY_TEMPLATE
+    body_suffix: str = ""
+    labels: list[str] = Field(default_factory=list)
+    reviewers: list[str] = Field(default_factory=list)
+    assignees: list[str] = Field(default_factory=list)
+
+    def format_body(
+        self,
+        src_repo_url: str,
+        src_sha: str,
+        sync_log: str,
+        dest_name: str,
+    ) -> str:
+        src_repo_name = src_repo_url.rstrip("/").rsplit("/", 1)[-1].removesuffix(".git")
+        body = self.body_template.format(
+            src_repo_url=src_repo_url,
+            src_repo_name=src_repo_name,
+            src_sha=src_sha,
+            src_sha_short=src_sha[:8],
+            sync_log=sync_log,
+            dest_name=dest_name,
+        )
+        if self.body_suffix:
+            body = f"{body}\n---\n{self.body_suffix}"
+        return body
+
+
+class Destination(BaseModel):
+    name: str
+    repo_url: str = ""
+    dest_path_relative: str
+    copy_branch: str = ""
+    default_branch: str = "main"
+    skip_sections: dict[str, list[str]] = Field(default_factory=dict)
+
+    def resolved_copy_branch(self, config_name: str) -> str:
+        """Returns branch name, defaulting to sync/{config_name} if not set."""
+        return self.copy_branch or f"sync/{config_name}"
+
+
+class SrcConfig(BaseModel):
+    CONFIG_EXT: ClassVar[str] = ".src.yaml"
+
+    name: str
+    git_remote: str = "origin"
+    src_repo_url: str = ""
+    schedule: str = "0 6 * * *"
+    header_config: HeaderConfig = Field(default_factory=HeaderConfig)
+    pr_defaults: PRDefaults = Field(default_factory=PRDefaults)
+    paths: list[PathMapping] = Field(default_factory=list)
+    destinations: list[Destination] = Field(default_factory=list)
+
+    def find_destination(self, name: str) -> Destination:
+        for dest in self.destinations:
+            if dest.name == name:
+                return dest
+        raise ValueError(f"Destination not found: {name}")
+
+
+def resolve_config_path(repo_root: Path, name: str) -> Path:
+    return repo_root / ".github" / f"{name}{SrcConfig.CONFIG_EXT}"
+
+
+def find_repo_root(start_path: Path) -> Path:
+    current = start_path.resolve()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+    raise ValueError(f"No git repository found from {start_path}")

path_sync/_internal/typer_app.py

@@ -0,0 +1,8 @@
+import typer
+
+app = typer.Typer(
+    name="path-sync",
+    help="Sync files across repositories",
+    pretty_exceptions_enable=False,
+    pretty_exceptions_show_locals=False,
+)

path_sync/_internal/validation.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from path_sync import sections
+from path_sync._internal import git_ops, header
+
+logger = logging.getLogger(__name__)
+
+
+def parse_skip_sections(value: str) -> dict[str, set[str]]:
+    """Parse 'path:section_id,path:section_id' into {path: {section_ids}}."""
+    result: dict[str, set[str]] = {}
+    for item in value.split(","):
+        item = item.strip()
+        if not item:
+            continue
+        if ":" not in item:
+            raise ValueError(f"Invalid format '{item}', expected 'path:section_id'")
+        path, section_id = item.rsplit(":", 1)
+        result.setdefault(path, set()).add(section_id)
+    return result
+
+
+def validate_no_unauthorized_changes(
+    repo_root: Path,
+    default_branch: str = "main",
+    skip_sections: dict[str, set[str]] | None = None,
+) -> list[str]:
+    """Find files with unauthorized changes in DO_NOT_EDIT sections.
+
+    Returns 'path:section_id' for section changes or 'path' for full-file.
+    """
+    repo = git_ops.get_repo(repo_root)
+    base_ref = f"origin/{default_branch}"
+    skip = skip_sections or {}
+    unauthorized: list[str] = []
+
+    for path in git_ops.get_changed_files(repo, base_ref):
+        if not path.exists():
+            continue
+        if not header.file_has_header(path):
+            continue
+
+        rel_path = str(path.relative_to(repo_root))
+        current_content = path.read_text()
+        baseline_content = git_ops.get_file_content_at_ref(repo, path, base_ref)
+
+        if baseline_content is None:
+            continue
+
+        baseline_has_sections = sections.has_sections(baseline_content, path)
+        current_has_sections = sections.has_sections(current_content, path)
+
+        if baseline_has_sections:
+            file_skip = skip.get(rel_path, set())
+            changed_ids = sections.compare_sections(baseline_content, current_content, path, file_skip)
+            unauthorized.extend(f"{rel_path}:{sid}" for sid in changed_ids)
+        elif current_has_sections:
+            unauthorized.append(rel_path)
+        else:
+            if baseline_content != current_content:
+                unauthorized.append(rel_path)
+
+    return sorted(unauthorized)

path_sync/_internal/yaml_utils.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TypeVar
+
+import yaml
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def load_yaml_model(path: Path, model_type: type[T]) -> T:
+    data = yaml.safe_load(path.read_text())
+    return model_type.model_validate(data)
+
+
+def dump_yaml_model(model: BaseModel) -> str:
+    data = model.model_dump(mode="json", exclude_none=True)
+    return yaml.safe_dump(data, default_flow_style=False, sort_keys=False)

{path_sync-0.3.0.dist-info → path_sync-0.3.1.dist-info}/METADATA

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

path_sync-0.3.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+path_sync/__init__.py,sha256=S6tn88icmaqW7h_DeyDXb_Koaq9rIeUUuIyQVf31VF4,153
+path_sync/__main__.py,sha256=HDj3qgijDcK8k976qsAvKMvUq9fZEJTK-dZldUc5-no,326
+path_sync/config.py,sha256=XYuEK_bjSpAk_nZN0oxpEA-S3t9F6Qn0yznYLoQHIw8,568
+path_sync/copy.py,sha256=BpflW4086XJFSHHK4taYPgXtF07xHB8qrgm8TYqdM4E,120
+path_sync/sections.py,sha256=dMEux8wT6nu9fcPgqgoWCc7QFNOxGVx5RVwcHhEK_lw,1894
+path_sync/_internal/__init__.py,sha256=iPkMhrpiyXBijo2Hp-y_2zEYxAXnHLnStKM0X0HHd4U,56
+path_sync/_internal/cmd_boot.py,sha256=44IUnemVzYO_qcZsHnCG1oeQHoGIavLy-9BNKIV8Tlo,2918
+path_sync/_internal/cmd_copy.py,sha256=Cl81112qBKRWU-99a8aaVHjl3RD4GCBYlHRNj39wems,16896
+path_sync/_internal/cmd_validate.py,sha256=L84W5iCUxCbM04muiOvDOTdvN3HA0Ubxy8Fk_XMQf1E,1612
+path_sync/_internal/file_utils.py,sha256=5C33qzKFQdwChi5YwUWBujj126t0P6dbGSU_5hWExpE,194
+path_sync/_internal/git_ops.py,sha256=rpG_r7VNH1KlBgqM9mz7xop0mpdy76Vs3rzCoxE1dIQ,5895
+path_sync/_internal/header.py,sha256=evgY2q_gfDdEytEt_jyJ7M_KdGzCpfdKBUnoh3v-0Go,2593
+path_sync/_internal/models.py,sha256=D4qGXh4NnT01xf2odeLYULtgr245TkdjaqW26BPnxP4,3767
+path_sync/_internal/typer_app.py,sha256=lEGMRXql3Se3VbmwAohvpUaL2cbY-RwhPUq8kL7bPbc,177
+path_sync/_internal/validation.py,sha256=qhEha-pJiM5zkZlr4sj2I4ZqvqcWMEfL4IZu_LGatLI,2226
+path_sync/_internal/yaml_utils.py,sha256=yj6Bl54EltjLEcVKaiA5Ahb9byT6OUMh0xIEzTsrvnQ,498
+path_sync-0.3.1.dist-info/METADATA,sha256=dkhwUJMoG5BDWpZkZpY1rBm1qm4hBzo_rQwkqS1um_8,8231
+path_sync-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+path_sync-0.3.1.dist-info/entry_points.txt,sha256=jTsL0c-9gP-4_Jt3EPgihtpLcwQR0AFAf1AUpD50AlI,54
+path_sync-0.3.1.dist-info/licenses/LICENSE,sha256=OphKV48tcMv6ep-7j-8T6nycykPT0g8ZlMJ9zbGvdPs,1066
+path_sync-0.3.1.dist-info/RECORD,,

path_sync-0.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-path_sync/__init__.py,sha256=GxwE45z99FV9EG57V7d0ld557zw2SzYk_83nEbBGtRk,153
-path_sync/__main__.py,sha256=HDj3qgijDcK8k976qsAvKMvUq9fZEJTK-dZldUc5-no,326
-path_sync/config.py,sha256=XYuEK_bjSpAk_nZN0oxpEA-S3t9F6Qn0yznYLoQHIw8,568
-path_sync/copy.py,sha256=BpflW4086XJFSHHK4taYPgXtF07xHB8qrgm8TYqdM4E,120
-path_sync/sections.py,sha256=dMEux8wT6nu9fcPgqgoWCc7QFNOxGVx5RVwcHhEK_lw,1894
-path_sync-0.3.0.dist-info/METADATA,sha256=8oFXF5R7ULoTo2CFdDRcsXjpRW6G0yZ-aGFjDHh1iJk,8231
-path_sync-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-path_sync-0.3.0.dist-info/entry_points.txt,sha256=jTsL0c-9gP-4_Jt3EPgihtpLcwQR0AFAf1AUpD50AlI,54
-path_sync-0.3.0.dist-info/licenses/LICENSE,sha256=OphKV48tcMv6ep-7j-8T6nycykPT0g8ZlMJ9zbGvdPs,1066
-path_sync-0.3.0.dist-info/RECORD,,