path-sync 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

path_sync/_internal/cmd_dep_update.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import shutil
 import subprocess
 from dataclasses import dataclass, field
 from enum import StrEnum
@@ -9,22 +10,20 @@ 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 import cmd_options, git_ops, prompt_utils, verify
+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 (
     DepConfig,
-    OnFailStrategy,
     UpdateEntry,
-    VerifyConfig,
     resolve_dep_config_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
 
 logger = logging.getLogger(__name__)
 
-MAX_STDERR_LINES = 20
-
 
 class Status(StrEnum):
     PASSED = "passed"
@@ -33,18 +32,9 @@ class Status(StrEnum):
     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)
+    def from_verify_status(cls, vs: VerifyStatus) -> Status:
+        return cls(vs.value)
 
 
 @dataclass
@@ -53,24 +43,27 @@ class RepoResult:
     repo_path: Path
     status: Status
     failures: list[StepFailure] = field(default_factory=list)
+    log_content: str = ""
 
 
-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:])
+@dataclass
+class DepUpdateOptions:
+    dry_run: bool = False
+    skip_verify: bool = False
+    reviewers: list[str] | None = None
+    assignees: list[str] | None = None
 
 
 @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"),
+    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"),
     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(),
 ) -> None:
     """Run dependency updates across repositories."""
     src_root = Path(src_root_opt) if src_root_opt else find_repo_root(Path.cwd())
@@ -86,8 +79,15 @@ def dep_update(
         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)
+    opts = DepUpdateOptions(
+        dry_run=dry_run,
+        skip_verify=skip_verify,
+        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)
 
     if any(r.status == Status.SKIPPED for r in results):
         raise typer.Exit(1)
@@ -98,12 +98,12 @@ def _update_and_validate(
     destinations: list[Destination],
     src_root: Path,
     work_dir: str,
-    skip_verify: bool,
+    opts: DepUpdateOptions,
 ) -> list[RepoResult]:
     results: list[RepoResult] = []
 
     for dest in destinations:
-        result = _process_single_repo(config, dest, src_root, work_dir, skip_verify)
+        result = _process_single_repo(config, dest, src_root, work_dir, opts)
 
         if result.status == Status.FAILED:
             logger.error(f"{dest.name}: Verification failed, stopping")
@@ -120,131 +120,116 @@ def _process_single_repo(
     dest: Destination,
     src_root: Path,
     work_dir: str,
-    skip_verify: bool,
+    opts: DepUpdateOptions,
+) -> RepoResult:
+    with capture_log(dest.name) as read_log:
+        result = _process_single_repo_inner(config, dest, src_root, work_dir, opts)
+        result.log_content = read_log()
+    return result
+
+
+def _process_single_repo_inner(
+    config: DepConfig,
+    dest: Destination,
+    src_root: Path,
+    work_dir: str,
+    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)
+    repo = _ensure_repo(dest, repo_path, dest.default_branch)
     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])
+        return RepoResult(dest=dest, repo_path=repo_path, status=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)
+        return RepoResult(dest=dest, repo_path=repo_path, status=Status.NO_CHANGES)
 
     git_ops.commit_changes(repo, config.pr.title)
 
-    if skip_verify:
-        return RepoResult(dest, repo_path, Status.PASSED)
+    if opts.skip_verify:
+        return RepoResult(dest=dest, repo_path=repo_path, status=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)
+            verify.run_command(update.command, repo_path / update.workdir)
         return None
     except subprocess.CalledProcessError as e:
-        return StepFailure.from_error(e.cmd, e, OnFailStrategy.SKIP)
+        return StepFailure(step=e.cmd, returncode=e.returncode, on_fail=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 _verify_repo(repo: Repo, repo_path: Path, fallback_verify: verify.VerifyConfig, dest: Destination) -> RepoResult:
+    effective_verify = dest.resolve_verify(fallback_verify)
+    result = verify.run_verify_steps(repo, repo_path, effective_verify)
+    status = Status.from_verify_status(result.status)
+    return RepoResult(dest=dest, repo_path=repo_path, status=status, failures=result.failures)
 
 
-def _create_prs(config: DepConfig, results: list[RepoResult], dry_run: bool) -> None:
+def _create_prs(config: DepConfig, results: list[RepoResult], opts: DepUpdateOptions) -> None:
     for result in results:
         if result.status == Status.SKIPPED:
             continue
 
-        if dry_run:
+        if opts.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)
+        body = _build_pr_body(result.log_content, result.failures)
         git_ops.create_or_update_pr(
             result.repo_path,
             config.pr.branch,
             config.pr.title,
             body,
             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")
 
 
 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()
-    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)
+    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 _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)
+def _build_pr_body(log_content: str, failures: list[StepFailure]) -> str:
+    body = "Automated dependency update."
 
-    return (Status.WARN if failures else Status.PASSED, failures)
+    if log_content.strip():
+        body += "\n\n## Command Output\n\n```\n" + log_content.strip() + "\n```"
 
+    if failures:
+        body += "\n\n---\n## Verification Issues\n"
+        for f in failures:
+            body += f"\n- `{f.step}` failed (exit code {f.returncode}, strategy: {f.on_fail})"
 
-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_options.py

@@ -0,0 +1,22 @@
+"""Shared CLI options for commands."""
+
+from __future__ import annotations
+
+import typer
+
+
+def pr_reviewers_option() -> str:
+    return typer.Option("", "--pr-reviewers", help="Comma-separated PR reviewers")
+
+
+def pr_assignees_option() -> str:
+    return typer.Option("", "--pr-assignees", help="Comma-separated PR assignees")
+
+
+def pr_labels_option() -> str:
+    return typer.Option("", "--pr-labels", help="Comma-separated PR labels")
+
+
+def split_csv(value: str) -> list[str] | None:
+    """Split comma-separated string, returns None if empty."""
+    return [v.strip() for v in value.split(",")] if value else None

path_sync/_internal/git_ops.py

@@ -41,6 +41,15 @@ def get_default_branch(repo: Repo) -> str:
     return "main"
 
 
+def fetch_and_reset_to_default(repo: Repo, default_branch: str) -> None:
+    """Fetch latest from remote and reset to default branch."""
+    logger.info(f"Fetching origin and resetting to {default_branch}")
+    repo.remotes.origin.fetch()
+    if repo.head.is_detached or repo.active_branch.name != default_branch:
+        repo.git.checkout(default_branch)
+    repo.git.reset("--hard", f"origin/{default_branch}")
+
+
 def clone_repo(url: str, dest: Path) -> Repo:
     logger.info(f"Cloning {url} to {dest}")
     dest.parent.mkdir(parents=True, exist_ok=True)

path_sync/_internal/log_capture.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import logging
+import tempfile
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from pathlib import Path
+
+LOG_FORMAT = "%(message)s"
+
+
+@contextmanager
+def capture_log(name: str) -> Generator[Callable[[], str]]:
+    """Capture path_sync logger output to a temp file.
+
+    Args:
+        name: Used for temp file naming (e.g., repo name for debugging).
+
+    Yields:
+        Callable that flushes the handler and returns log content.
+    """
+    with tempfile.TemporaryDirectory(prefix="path-sync-") as tmpdir:
+        log_path = Path(tmpdir) / f"{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:
+
+            def read_log() -> str:
+                file_handler.flush()
+                return log_path.read_text() if log_path.exists() else ""
+
+            yield read_log
+        finally:
+            file_handler.close()
+            root_logger.removeHandler(file_handler)

path_sync/_internal/models.py

@@ -35,12 +35,38 @@ class SyncMode(StrEnum):
     SCAFFOLD = "scaffold"
 
 
+class OnFailStrategy(StrEnum):
+    SKIP = "skip"
+    FAIL = "fail"
+    WARN = "warn"
+
+
+class CommitConfig(BaseModel):
+    message: str
+    add_paths: list[str] = Field(default_factory=lambda: ["."])
+
+
+class VerifyStep(BaseModel):
+    run: str
+    commit: CommitConfig | None = None
+    on_fail: OnFailStrategy | None = None
+
+
+class VerifyConfig(BaseModel):
+    on_fail: OnFailStrategy = OnFailStrategy.WARN
+    steps: list[VerifyStep] = Field(default_factory=list)
+
+
 class PathMapping(BaseModel):
     src_path: str
     dest_path: str = ""
     sync_mode: SyncMode = SyncMode.SYNC
     exclude_dirs: set[str] = Field(default_factory=_default_exclude_dirs)
     exclude_file_patterns: set[str] = Field(default_factory=set)
+    wrap: bool | None = None
+
+    def should_wrap(self, config_default: bool) -> bool:
+        return self.wrap if self.wrap is not None else config_default
 
     def resolved_dest_path(self) -> str:
         return self.dest_path or self.src_path
@@ -85,14 +111,19 @@ Synced from [{src_repo_name}]({src_repo_url}) @ `{src_sha_short}`
 """
 
 
-class PRDefaults(BaseModel):
-    title: str = "chore: sync {name} files"
-    body_template: str = DEFAULT_BODY_TEMPLATE
-    body_suffix: str = ""
+class PRFieldsBase(BaseModel):
+    """Common PR fields shared by copy and dep-update commands."""
+
     labels: list[str] = Field(default_factory=list)
     reviewers: list[str] = Field(default_factory=list)
     assignees: list[str] = Field(default_factory=list)
 
+
+class PRDefaults(PRFieldsBase):
+    title: str = "chore: sync {name} files"
+    body_template: str = DEFAULT_BODY_TEMPLATE
+    body_suffix: str = ""
+
     def format_body(
         self,
         src_repo_url: str,
@@ -122,6 +153,7 @@ class Destination(BaseModel):
     default_branch: str = "main"
     skip_sections: dict[str, list[str]] = Field(default_factory=dict)
     skip_file_patterns: set[str] = Field(default_factory=set)
+    verify: VerifyConfig | None = None
 
     def resolved_copy_branch(self, config_name: str) -> str:
         return self.copy_branch or f"sync/{config_name}"
@@ -129,6 +161,9 @@ class Destination(BaseModel):
     def is_skipped(self, dest_key: str) -> bool:
         return any(fnmatch.fnmatch(dest_key, pat) for pat in self.skip_file_patterns)
 
+    def resolve_verify(self, fallback: VerifyConfig | None) -> VerifyConfig:
+        return self.verify if self.verify is not None else (fallback or VerifyConfig())
+
 
 class SrcConfig(BaseModel):
     CONFIG_EXT: ClassVar[str] = ".src.yaml"
@@ -141,6 +176,8 @@ class SrcConfig(BaseModel):
     pr_defaults: PRDefaults = Field(default_factory=PRDefaults)
     paths: list[PathMapping] = Field(default_factory=list)
     destinations: list[Destination] = Field(default_factory=list)
+    verify: VerifyConfig | None = None
+    wrap_synced_files: bool = False
 
     def find_destination(self, name: str) -> Destination:
         for dest in self.destinations:

path_sync/_internal/models_dep.py

@@ -1,46 +1,28 @@
 from __future__ import annotations
 
-from enum import StrEnum
 from pathlib import Path
 from typing import ClassVar
 
 from pydantic import BaseModel, Field
 
-from path_sync._internal.models import Destination, SrcConfig, resolve_config_path
+from path_sync._internal.models import (
+    Destination,
+    PRFieldsBase,
+    SrcConfig,
+    VerifyConfig,
+    resolve_config_path,
+)
 from path_sync._internal.yaml_utils import load_yaml_model
 
 
-class OnFailStrategy(StrEnum):
-    SKIP = "skip"
-    FAIL = "fail"
-    WARN = "warn"
-
-
-class CommitConfig(BaseModel):
-    message: str
-    add_paths: list[str] = Field(default_factory=lambda: ["."])
-
-
-class VerifyStep(BaseModel):
-    run: str
-    commit: CommitConfig | None = None
-    on_fail: OnFailStrategy | None = None
-
-
-class VerifyConfig(BaseModel):
-    on_fail: OnFailStrategy = OnFailStrategy.SKIP
-    steps: list[VerifyStep] = Field(default_factory=list)
-
-
 class UpdateEntry(BaseModel):
     workdir: str = "."
     command: str
 
 
-class PRConfig(BaseModel):
+class PRConfig(PRFieldsBase):
     branch: str
     title: str
-    labels: list[str] = Field(default_factory=list)
     auto_merge: bool = False
 
 

path_sync/_internal/prompt_utils.py

@@ -0,0 +1,25 @@
+"""Shared prompt utilities for interactive CLI commands."""
+
+from __future__ import annotations
+
+import sys
+
+
+def prompt_confirm(message: str, no_prompt: bool = False) -> bool:
+    """Prompt user for confirmation.
+
+    Args:
+        message: The prompt message to display
+        no_prompt: If True, auto-confirms without prompting
+
+    Returns:
+        True if confirmed, False otherwise.
+        Auto-confirms in non-interactive mode (CI) or when no_prompt=True.
+    """
+    if no_prompt or not sys.stdin.isatty():
+        return True
+    try:
+        response = input(f"{message} [y/n]: ").strip().lower()
+        return response == "y"
+    except (EOFError, KeyboardInterrupt):
+        return False

path_sync/_internal/verify.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from dataclasses import dataclass, field
+from enum import StrEnum
+from pathlib import Path
+
+from git import Repo
+
+from path_sync._internal import git_ops
+from path_sync._internal.models import OnFailStrategy, VerifyConfig
+
+logger = logging.getLogger(__name__)
+
+
+class VerifyStatus(StrEnum):
+    PASSED = "passed"
+    SKIPPED = "skipped"
+    WARN = "warn"
+    FAILED = "failed"
+
+
+@dataclass
+class StepFailure:
+    step: str
+    returncode: int
+    on_fail: OnFailStrategy
+
+
+@dataclass
+class VerifyResult:
+    status: VerifyStatus = VerifyStatus.PASSED
+    failures: list[StepFailure] = field(default_factory=list)
+
+
+def run_command(cmd: str, cwd: Path, dry_run: bool = False) -> None:
+    if dry_run:
+        logger.info(f"[DRY RUN] Would run: {cmd} from {cwd}")
+        return
+    logger.info(f"Running: {cmd}")
+    result = subprocess.run(cmd, shell=True, cwd=cwd, capture_output=True, text=True)
+    prefix = cmd.split()[0]
+    for line in result.stdout.strip().splitlines():
+        logger.info(f"[{prefix}] {line}")
+    for line in result.stderr.strip().splitlines():
+        if result.returncode != 0:
+            logger.error(f"[{prefix}] {line}")
+        else:
+            logger.info(f"[{prefix}] {line}")
+    if result.returncode != 0:
+        raise subprocess.CalledProcessError(result.returncode, cmd, output=result.stdout, stderr=result.stderr)
+
+
+def run_verify_steps(
+    repo: Repo, repo_path: Path, verify: VerifyConfig, dry_run: bool = False, skip_commit: bool = False
+) -> VerifyResult:
+    if not verify.steps:
+        return VerifyResult()
+
+    failures: list[StepFailure] = []
+
+    for step in verify.steps:
+        on_fail = step.on_fail or verify.on_fail
+
+        try:
+            run_command(step.run, repo_path, dry_run=dry_run)
+        except subprocess.CalledProcessError as e:
+            failure = StepFailure(step=step.run, returncode=e.returncode, on_fail=on_fail)
+            match on_fail:
+                case OnFailStrategy.FAIL:
+                    return VerifyResult(status=VerifyStatus.FAILED, failures=[failure])
+                case OnFailStrategy.SKIP:
+                    return VerifyResult(status=VerifyStatus.SKIPPED, failures=[failure])
+                case OnFailStrategy.WARN:
+                    failures.append(failure)
+                    continue
+
+        if step.commit and not dry_run and not skip_commit:
+            git_ops.stage_and_commit(repo, step.commit.add_paths, step.commit.message)
+
+    status = VerifyStatus.WARN if failures else VerifyStatus.PASSED
+    return VerifyResult(status=status, failures=failures)
+
+
+def log_verify_summary(name: str, result: VerifyResult) -> None:
+    match result.status:
+        case VerifyStatus.PASSED:
+            logger.info(f"Verification passed for {name}")
+        case VerifyStatus.WARN:
+            logger.warning(f"Verification completed with warnings for {name}")
+            for f in result.failures:
+                logger.warning(f"  {f.step} failed (exit {f.returncode})")
+        case VerifyStatus.SKIPPED:
+            logger.warning(f"Verification skipped for {name}")
+        case VerifyStatus.FAILED:
+            logger.error(f"Verification failed for {name}")

path_sync/copy.py

@@ -1,4 +1,6 @@
 # Generated by pkg-ext
 from path_sync._internal.cmd_copy import CopyOptions as _CopyOptions
+from path_sync._internal.cmd_copy import copy as _copy
 
 CopyOptions = _CopyOptions
+copy = _copy