path-sync 0.4.0__py3-none-any.whl

path_sync/_internal/cmd_dep_update.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from dataclasses import dataclass, field
+from enum import StrEnum
+from pathlib import Path
+
+import typer
+from git import Repo
+
+from path_sync._internal import git_ops
+from path_sync._internal.models import Destination, find_repo_root
+from path_sync._internal.models_dep import (
+    DepConfig,
+    OnFailStrategy,
+    UpdateEntry,
+    VerifyConfig,
+    resolve_dep_config_path,
+)
+from path_sync._internal.typer_app import app
+from path_sync._internal.yaml_utils import load_yaml_model
+
+logger = logging.getLogger(__name__)
+
+MAX_STDERR_LINES = 20
+
+
+class Status(StrEnum):
+    PASSED = "passed"
+    SKIPPED = "skipped"
+    WARN = "warn"
+    NO_CHANGES = "no_changes"
+    FAILED = "failed"
+
+
+@dataclass
+class StepFailure:
+    step: str
+    returncode: int
+    stderr: str
+    on_fail: OnFailStrategy
+
+    @classmethod
+    def from_error(cls, step: str, e: subprocess.CalledProcessError, on_fail: OnFailStrategy) -> StepFailure:
+        stderr = _truncate_stderr(e.stderr or "", MAX_STDERR_LINES)
+        return cls(step=step, returncode=e.returncode, stderr=stderr, on_fail=on_fail)
+
+
+@dataclass
+class RepoResult:
+    dest: Destination
+    repo_path: Path
+    status: Status
+    failures: list[StepFailure] = field(default_factory=list)
+
+
+def _truncate_stderr(text: str, max_lines: int) -> str:
+    lines = text.strip().splitlines()
+    if len(lines) <= max_lines:
+        return text.strip()
+    skipped = len(lines) - max_lines
+    return f"... ({skipped} lines skipped)\n" + "\n".join(lines[-max_lines:])
+
+
+@app.command()
+def dep_update(
+    name: str = typer.Option(..., "-n", "--name", help="Config name"),
+    dest_filter: str = typer.Option("", "-d", "--dest", help="Filter destinations (comma-separated)"),
+    work_dir: str = typer.Option("", "--work-dir", help="Directory for cloning repos"),
+    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"),
+    src_root_opt: str = typer.Option("", "--src-root", help="Source repo root"),
+) -> None:
+    """Run dependency updates across repositories."""
+    src_root = Path(src_root_opt) if src_root_opt else find_repo_root(Path.cwd())
+    config_path = resolve_dep_config_path(src_root, name)
+    if not config_path.exists():
+        logger.error(f"Config not found: {config_path}")
+        raise typer.Exit(1)
+
+    config = load_yaml_model(config_path, DepConfig)
+    destinations = config.load_destinations(src_root)
+
+    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]
+
+    results = _update_and_validate(config, destinations, src_root, work_dir, skip_verify)
+    _create_prs(config, results, dry_run)
+
+    if any(r.status == Status.SKIPPED for r in results):
+        raise typer.Exit(1)
+
+
+def _update_and_validate(
+    config: DepConfig,
+    destinations: list[Destination],
+    src_root: Path,
+    work_dir: str,
+    skip_verify: bool,
+) -> list[RepoResult]:
+    results: list[RepoResult] = []
+
+    for dest in destinations:
+        result = _process_single_repo(config, dest, src_root, work_dir, skip_verify)
+
+        if result.status == Status.FAILED:
+            logger.error(f"{dest.name}: Verification failed, stopping")
+            raise typer.Exit(1)
+
+        if result.status != Status.NO_CHANGES:
+            results.append(result)
+
+    return results
+
+
+def _process_single_repo(
+    config: DepConfig,
+    dest: Destination,
+    src_root: Path,
+    work_dir: str,
+    skip_verify: bool,
+) -> RepoResult:
+    logger.info(f"Processing {dest.name}...")
+    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):
+        logger.warning(f"{dest.name}: Update failed with exit code {failure.returncode}")
+        return RepoResult(dest, repo_path, Status.SKIPPED, failures=[failure])
+
+    if not git_ops.has_changes(repo):
+        logger.info(f"{dest.name}: No changes, skipping")
+        return RepoResult(dest, repo_path, Status.NO_CHANGES)
+
+    git_ops.commit_changes(repo, config.pr.title)
+
+    if skip_verify:
+        return RepoResult(dest, repo_path, Status.PASSED)
+
+    return _verify_repo(repo, repo_path, config.verify, dest)
+
+
+def _run_updates(updates: list[UpdateEntry], repo_path: Path) -> StepFailure | None:
+    """Returns StepFailure on failure, None on success."""
+    try:
+        for update in updates:
+            _run_command(update.command, repo_path / update.workdir)
+        return None
+    except subprocess.CalledProcessError as e:
+        return StepFailure.from_error(e.cmd, e, OnFailStrategy.SKIP)
+
+
+def _verify_repo(repo: Repo, repo_path: Path, verify: VerifyConfig, dest: Destination) -> RepoResult:
+    status, failures = _run_verify_steps(repo, repo_path, verify)
+    return RepoResult(dest, repo_path, status, failures)
+
+
+def _create_prs(config: DepConfig, results: list[RepoResult], dry_run: bool) -> None:
+    for result in results:
+        if result.status == Status.SKIPPED:
+            continue
+
+        if dry_run:
+            logger.info(f"[DRY RUN] Would create PR for {result.dest.name}")
+            continue
+
+        repo = git_ops.get_repo(result.repo_path)
+        git_ops.push_branch(repo, config.pr.branch, force=True)
+
+        body = _build_pr_body(result.failures)
+        git_ops.create_or_update_pr(
+            result.repo_path,
+            config.pr.branch,
+            config.pr.title,
+            body,
+            config.pr.labels or None,
+            auto_merge=config.pr.auto_merge,
+        )
+        logger.info(f"{result.dest.name}: PR created/updated")
+
+
+def _resolve_repo_path(dest: Destination, src_root: Path, work_dir: str) -> Path:
+    if dest.dest_path_relative:
+        return (src_root / dest.dest_path_relative).resolve()
+    if not work_dir:
+        raise typer.BadParameter(f"No dest_path_relative for {dest.name}, --work-dir required")
+    return Path(work_dir) / dest.name
+
+
+def _ensure_repo(dest: Destination, repo_path: Path):
+    if repo_path.exists() and git_ops.is_git_repo(repo_path):
+        return git_ops.get_repo(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 _run_command(cmd: str, cwd: Path) -> None:
+    logger.info(f"Running: {cmd}")
+    result = subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
+    if result.returncode != 0:
+        stderr = result.stderr.strip()
+        logger.error(f"Command failed '{cmd}' in {cwd}: {stderr}")
+        raise subprocess.CalledProcessError(result.returncode, cmd, output=result.stdout, stderr=stderr)
+
+
+def _run_verify_steps(
+    repo: Repo,
+    repo_path: Path,
+    verify: VerifyConfig,
+) -> tuple[Status, list[StepFailure]]:
+    failures: list[StepFailure] = []
+
+    for step in verify.steps:
+        on_fail = step.on_fail or verify.on_fail
+
+        try:
+            _run_command(step.run, repo_path)
+        except subprocess.CalledProcessError as e:
+            failure = StepFailure.from_error(step.run, e, on_fail)
+            match on_fail:
+                case OnFailStrategy.FAIL:
+                    return (Status.FAILED, [failure])
+                case OnFailStrategy.SKIP:
+                    return (Status.SKIPPED, [failure])
+                case OnFailStrategy.WARN:
+                    failures.append(failure)
+                    continue
+
+        if step.commit:
+            git_ops.stage_and_commit(repo, step.commit.add_paths, step.commit.message)
+
+    return (Status.WARN if failures else Status.PASSED, failures)
+
+
+def _build_pr_body(failures: list[StepFailure]) -> str:
+    body = "Automated dependency update."
+    if not failures:
+        return body
+
+    body += "\n\n---\n## Verification Issues\n"
+    for f in failures:
+        body += f"\n### `{f.step}` (strategy: {f.on_fail})\n"
+        body += f"**Exit code:** {f.returncode}\n"
+        if f.stderr:
+            body += f"\n```\n{f.stderr}\n```\n"
+    return body

path_sync/_internal/cmd_validate.py

@@ -0,0 +1,50 @@
+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')",
+    ),
+    src_root_opt: str = typer.Option(
+        "",
+        "--src-root",
+        help="Source repo root (default: find git root from cwd)",
+    ),
+) -> None:
+    """Validate no unauthorized changes to synced files."""
+    repo_root = Path(src_root_opt) if src_root_opt else 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,213 @@
+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 stage_and_commit(repo: Repo, add_paths: list[str], message: str) -> bool:
+    """Stage specified paths and commit if there are changes. Returns True if a commit was made."""
+    include = [p for p in add_paths if not p.startswith("!")]
+    exclude = [p[1:] for p in add_paths if p.startswith("!")]
+    for path in include:
+        repo.git.add(path)
+    for path in exclude:
+        repo.git.reset("HEAD", "--", path)
+    if not repo.is_dirty(index=True):
+        return False
+    _ensure_git_user(repo)
+    repo.git.commit("-m", message)
+    logger.info(f"Committed: {message}")
+    return True
+
+
+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,
+    auto_merge: bool = False,
+) -> 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)
+            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)
+    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