sync-template 0.1.0__tar.gz

sync_template-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quaerent
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sync_template-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: sync-template
+Version: 0.1.0
+Summary: A CLI tool to synchronize projects with their templates.
+License-File: LICENSE
+Author: Quaerent
+Author-email: topfyf@qq.com
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: gitpython (>=3.1.46,<4.0.0)
+Requires-Dist: pathspec (>=1.0.4,<2.0.0)
+Requires-Dist: typer (>=0.24.1,<0.25.0)

sync_template-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "sync-template"
+version = "0.1.0"
+description = "A CLI tool to synchronize projects with their templates."
+authors = [
+    {name = "Quaerent", email = "topfyf@qq.com"}
+]
+requires-python = ">=3.13"
+dependencies = [
+    "typer (>=0.24.1,<0.25.0)",
+    "gitpython (>=3.1.46,<4.0.0)",
+    "pathspec (>=1.0.4,<2.0.0)"
+]
+
+[dependency-groups]
+dev = [
+    "ruff (>=0.15.9,<0.16.0)",
+    "pytest (>=9.0.3,<10.0.0)",
+    "pre-commit (>=4.5.1,<5.0.0)"
+]
+
+
+[project.scripts]
+sync-template = "sync_template.main:app"
+
+[tool.ruff]
+line-length = 88
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W", "UP", "N"]
+ignore = []
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

sync_template-0.1.0/sync_template/config.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+import pathspec
+
+
+def get_syncignore_spec(root_dir: Path) -> pathspec.PathSpec:
+    """Read .syncignore file and return a PathSpec object."""
+    ignore_file = root_dir / ".syncignore"
+    if not ignore_file.exists():
+        return pathspec.PathSpec.from_lines("gitignore", [])
+
+    with open(ignore_file) as f:
+        return pathspec.PathSpec.from_lines("gitignore", f.readlines())
+
+
+def is_ignored(path: str, spec: pathspec.PathSpec) -> bool:
+    """Check if a path matches the .syncignore specification."""
+    return spec.match_file(path)

sync_template-0.1.0/sync_template/git.py

@@ -0,0 +1,122 @@
+import os
+import shutil
+from pathlib import Path
+
+import typer
+from git import Repo
+
+from .config import get_syncignore_spec
+
+
+class GitManager:
+    def __init__(self, path: Path):
+        self.repo = Repo(path)
+
+    @classmethod
+    def clone(cls, url: str, dest: Path) -> "GitManager":
+        """Clone a template repository as a new project."""
+        repo = Repo.clone_from(url, dest, depth=1)
+        # Rename origin to template for clarity
+        repo.delete_remote("origin")
+        repo.create_remote("template", url)
+        return cls(dest)
+
+    def fetch_template(self):
+        """Fetch updates from the template remote."""
+        template_remote = self.repo.remote("template")
+        template_remote.fetch()
+
+    def merge_with_ignore(self, branch: str = "main"):
+        """Merge updates from template and apply .syncignore."""
+        template_ref = f"template/{branch}"
+
+        if self.repo.is_dirty(untracked_files=True):
+            raise typer.BadParameter(
+                "Working directory is not clean. Commit, stash, "
+                "or remove untracked files first."
+            )
+
+        # 2. Try to merge without committing
+        typer.echo(f"Merging from {template_ref}...")
+        try:
+            self.repo.git.merge(template_ref, "--no-commit", "--no-ff")
+        except Exception as e:
+            if "CONFLICT" not in str(e):
+                raise e
+            typer.echo(
+                "Merge resulted in conflicts. Will apply .syncignore "
+                "and let user resolve others."
+            )
+
+        # 3. Apply .syncignore logic
+        spec = get_syncignore_spec(Path(self.repo.working_dir))
+
+        # Get all files currently in the index (post-merge state)
+        # and all files in HEAD (pre-merge state)
+        # We need to check both to handle additions and deletions/modifications
+
+        all_potential_paths = set()
+        # Paths in the current merged index
+        for path, _ in self.repo.index.entries.keys():
+            all_potential_paths.add(path)
+        # Paths in the HEAD (before merge)
+        for entry in self.repo.tree("HEAD").traverse():
+            if entry.type == "blob":
+                all_potential_paths.add(entry.path)
+
+        ignored_count = 0
+        for path in all_potential_paths:
+            if spec.match_file(path):
+                # Check if file existed in HEAD
+                exists_in_head = False
+                try:
+                    self.repo.tree("HEAD")[path]
+                    exists_in_head = True
+                except KeyError:
+                    exists_in_head = False
+
+                if exists_in_head:
+                    # Case: Modified or Deleted by template -> Restore from HEAD
+                    typer.echo(f"Restoring ignored path: {path}")
+                    self.repo.git.checkout("HEAD", "--", path)
+                    ignored_count += 1
+                else:
+                    # Case: Added by template -> Remove completely
+                    typer.echo(f"Removing new ignored path: {path}")
+                    full_path = os.path.join(self.repo.working_dir, path)
+                    if os.path.exists(full_path):
+                        if os.path.isdir(full_path):
+                            shutil.rmtree(full_path)
+                        else:
+                            os.remove(full_path)
+
+                    # Remove from git index
+                    try:
+                        self.repo.git.rm("-rf", "--cached", path)
+                    except Exception:
+                        pass
+                    ignored_count += 1
+
+        # 4. Cleanup empty directories left by removed files (if they match .syncignore)
+        # We walk the tree and remove empty dirs that match the spec
+        for root, dirs, _files in os.walk(self.repo.working_dir, topdown=False):
+            # Skip .git
+            if ".git" in root:
+                continue
+
+            for d in dirs:
+                dir_path = os.path.join(root, d)
+                rel_dir_path = os.path.relpath(dir_path, self.repo.working_dir)
+
+                # If this dir matches syncignore AND is empty, remove it
+                if spec.match_file(rel_dir_path + "/") or spec.match_file(rel_dir_path):
+                    try:
+                        if not os.listdir(dir_path):
+                            os.rmdir(dir_path)
+                    except OSError:
+                        pass
+
+        if ignored_count > 0:
+            typer.echo(f"Successfully processed {ignored_count} ignored paths.")
+
+        typer.echo("Sync complete. Please review changes and commit.")

sync_template-0.1.0/sync_template/main.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import typer
+
+from .git import GitManager
+
+app = typer.Typer(help="CLI tool to synchronize projects with their templates.")
+
+
+@app.command()
+def init(
+    url: str = typer.Argument(
+        ..., help="Template repository URL or shortcut (gh:, glab:)"
+    ),
+    dest: Path | None = typer.Argument(
+        None, help="Destination directory (defaults to repo name)"
+    ),
+):
+    """Initialize a new project from a template."""
+    # Transform shortcuts
+    if url.startswith("gh:"):
+        repo_path = url.split("gh:")[1]
+        url = f"https://github.com/{repo_path}.git"
+    elif url.startswith("glab:"):
+        repo_path = url.split("glab:")[1]
+        url = f"https://gitlab.com/{repo_path}.git"
+
+    if dest is None:
+        # Extract name from URL, handling potential .git suffix
+        repo_name = url.split("/")[-1].replace(".git", "")
+        dest = Path(repo_name)
+
+    if dest.exists() and any(dest.iterdir()):
+        typer.echo(f"Error: Directory {dest} already exists and is not empty.")
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Creating project from {url} in {dest}...")
+    GitManager.clone(url, dest)
+    typer.echo("Project initialized successfully.")
+
+
+@app.command()
+def sync(
+    branch: str = typer.Option("main", help="Branch from template to sync from"),
+):
+    """Sync updates from the template repository."""
+    current_dir = Path.cwd()
+    if not (current_dir / ".git").exists():
+        typer.echo("Error: Current directory is not a Git repository.")
+        raise typer.Exit(code=1)
+
+    try:
+        git_manager = GitManager(current_dir)
+        git_manager.fetch_template()
+        git_manager.merge_with_ignore(branch)
+    except Exception as e:
+        typer.echo(f"Error: {e}")
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()