gitacross 2.2.0__tar.gz → 2.3.0__tar.gz

{gitacross-2.2.0/src/gitacross.egg-info → gitacross-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.2.0
+Version: 2.3.0
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -157,6 +157,13 @@ A config file starts with a `projects` list — each entry is one mirror and nee
 
 Tokens use `${VAR}` syntax — resolved from environment variables.
 
+For local **targets**, the `path` does not have to exist yet: if the directory is
+missing or is not already a git repository, GitAcross creates the directory and
+runs `git init` there before committing. If a repository already exists at that
+path it is opened as-is — existing git metadata is never re-initialised or
+overwritten (bare repositories and broken `.git` markers are refused with an
+error). Local **sources** must point at an existing git repository.
+
 | Option | Description |
 |---|---|
 | [`enabled`](#enabled) | Disable a project without deleting it |

{gitacross-2.2.0 → gitacross-2.3.0}/README.md

@@ -128,6 +128,13 @@ A config file starts with a `projects` list — each entry is one mirror and nee
 
 Tokens use `${VAR}` syntax — resolved from environment variables.
 
+For local **targets**, the `path` does not have to exist yet: if the directory is
+missing or is not already a git repository, GitAcross creates the directory and
+runs `git init` there before committing. If a repository already exists at that
+path it is opened as-is — existing git metadata is never re-initialised or
+overwritten (bare repositories and broken `.git` markers are refused with an
+error). Local **sources** must point at an existing git repository.
+
 | Option | Description |
 |---|---|
 | [`enabled`](#enabled) | Disable a project without deleting it |

{gitacross-2.2.0 → gitacross-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacross"
-version = "2.2.0"
+version = "2.3.0"
 description = "Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines."
 readme = "README.md"
 requires-python = ">=3.8"

{gitacross-2.2.0 → gitacross-2.3.0}/src/gitacross/git.py

@@ -37,9 +37,16 @@ def _log_git_stderr(command, returncode, stderr, level):
         )
 
 
-def _git(*args, check=True, input_data=None, text=True, env=None):
-    cmd = ["git"] + [str(a) for a in args]
-    logger.debug("> git %s", _redact(" ".join(str(a) for a in args)))
+def _git(*args, check=True, input_data=None, text=True, env=None, safe_dir=None):
+    cmd = ["git"]
+    if safe_dir:
+        # Git refuses to operate in a repository owned by another user
+        # ("dubious ownership"). The bare mirrors under the cache dir are
+        # created and managed by gitacross itself, so whitelist exactly that
+        # directory for this one invocation via -c — never written to a config.
+        cmd += ["-c", f"safe.directory={Path(safe_dir).resolve()}"]
+    cmd += [str(a) for a in args]
+    logger.debug("> git %s", _redact(" ".join(str(a) for a in cmd[1:])))
     try:
         result = subprocess.run(
             cmd,
@@ -56,6 +63,12 @@ def _git(*args, check=True, input_data=None, text=True, env=None):
             if isinstance(part, str):
                 e.cmd[i] = _redact(part)
         raise
+    except FileNotFoundError as exc:
+        # subprocess can't find the `git` binary at all — give a clear error
+        # instead of the raw "[Errno 2] No such file or directory: 'git'".
+        raise ValueError(
+            "git executable not found — install Git and make sure it is on PATH."
+        ) from exc
     if result.returncode != 0:
         # check=False path — callers inspect the return code themselves
         _log_git_stderr(args[0], result.returncode, result.stderr, level=logging.DEBUG)
@@ -87,34 +100,117 @@ class GitRepo:
         path = Path(dest)
         if path.exists():
             # Update remote URL *before* fetching so token rotation takes effect
-            current = _git("-C", str(path), "remote", "get-url", "origin", check=False)
+            current = _git(
+                "-C", str(path), "remote", "get-url", "origin",
+                check=False, safe_dir=path,
+            )
             if current.returncode == 0 and current.stdout.strip() != url:
-                _ = _git("-C", str(path), "remote", "set-url", "origin", url)
+                _ = _git(
+                    "-C", str(path), "remote", "set-url", "origin", url,
+                    safe_dir=path,
+                )
                 logger.info("Updated remote URL for mirror at %s", dest)
-            _ = _git("-C", str(path), "fetch", "--tags", "--prune", "origin")
+            _ = _git(
+                "-C", str(path), "fetch", "--tags", "--prune", "origin",
+                safe_dir=path,
+            )
             logger.info("Updated mirror at %s", dest)
         else:
             path.parent.mkdir(parents=True, exist_ok=True)
-            _ = _git("clone", "--mirror", url, str(path))
+            _ = _git("clone", "--mirror", url, str(path), safe_dir=path)
             logger.info("Cloned mirror from %s", _redact(url))
         # Ensure author identity for automated commits
-        _ = _git("-C", str(path), "config", "user.name", "GitAcross")
-        _ = _git("-C", str(path), "config", "user.email", "sync@gitacross")
+        _ = _git("-C", str(path), "config", "user.name", "GitAcross", safe_dir=path)
+        _ = _git("-C", str(path), "config", "user.email", "sync@gitacross", safe_dir=path)
         return cls(path, is_bare=True)
 
     @classmethod
     def local(cls, path):
-        """Open an existing local git repository."""
+        """Open an existing local git repository.
+
+        *path* must be the root of its own git working tree. Git resolves a
+        path that merely lives *inside* a repository to the nearest enclosing
+        repository, so without this check a configured path that is not itself
+        a git repository would silently commit to and reset that enclosing
+        repo — e.g. the directory the tool is being run from — instead of the
+        configured location.
+        """
         p = Path(path)
-        result = _git("-C", str(p), "rev-parse", "--git-dir")
-        git_dir = p / result.stdout.strip()
-        if not git_dir.exists():
+        result = _git("-C", str(p), "rev-parse", "--show-toplevel", check=False)
+        if result.returncode != 0:
             raise ValueError(f"Not a git repository: {path}")
-        return cls(git_dir, is_bare=False)
+        root = Path(result.stdout.strip())
+        if Path(p).resolve() != root.resolve():
+            raise ValueError(
+                f"Not a git repository: {path} — it is inside the git repository "
+                + f"'{root}'. A local endpoint path must point at a repository "
+                + f"root; run 'git init' in {path} or point the path at {root}."
+            )
+        git_dir = _git("-C", str(root), "rev-parse", "--absolute-git-dir")
+        return cls(Path(git_dir.stdout.strip()), is_bare=False)
+
+    @classmethod
+    def ensure_local(cls, path):
+        """Open a local git repository at *path*, creating it if necessary.
+
+        Unlike :meth:`local`, a missing directory or a plain directory that is
+        not yet a git repository is accepted: the directory is created
+        (including parents) and ``git init`` is run there. Used for local
+        *targets*, which receive commits. Local *sources* still go through
+        :meth:`local` so a misconfigured source path is reported instead of
+        silently yielding an empty repository.
+
+        An existing repository is opened as-is and never re-initialised. If
+        *path* already holds git metadata that cannot be used as a working tree
+        (a bare repository, a git-internal directory, or a broken ``.git``
+        marker), a :class:`ValueError` is raised instead of overwriting it.
+        """
+        if not path or not str(path).strip():
+            raise ValueError(
+                "Local target path is empty — set 'path' to the directory where "
+                + "the mirrored repository should live."
+            )
+        try:
+            return cls.local(path)
+        except ValueError:
+            pass
+
+        # Only auto-initialise when the directory is genuinely not a git
+        # repository yet — never run `git init` over existing git metadata
+        # (re-initialising a bare repo pollutes it with a nested .git).
+        p = Path(path)
+        if p.exists() and not p.is_dir():
+            raise ValueError(f"Local target path is not a directory: {path}")
+        if (p / ".git").exists():
+            raise ValueError(
+                f"Not initialising {path}: it already contains a '.git' entry "
+                + "that is not a usable working tree. Refusing to overwrite it — "
+                + "fix or remove that repository, or point the local target at a "
+                + "missing or empty directory."
+            )
+        if (p / "HEAD").is_file() and (p / "objects").is_dir():
+            raise ValueError(
+                f"Not initialising {path}: it is a bare git repository or git's "
+                + "internal directory. Local targets need a working tree, and "
+                + "existing repositories are never re-initialised."
+            )
+        p.mkdir(parents=True, exist_ok=True)
+        _ = _git("init", str(p))
+        logger.info("Initialised git repository at %s", p)
+        return cls.local(path)
 
     def _g(self, *args, text=True, env=None, **kwargs):
         """Run git command with --git-dir set."""
-        return _git("--git-dir", str(self.git_dir), *args, text=text, env=env, **kwargs)
+        return _git(
+            "--git-dir",
+            str(self.git_dir),
+            *args,
+            text=text,
+            env=env,
+            # Mirrors are gitacross-managed; whitelist them for the ownership check.
+            safe_dir=self.git_dir if self.is_bare else None,
+            **kwargs,
+        )
 
     def _gw(self, work_dir, *args, env=None, **kwargs):
         """Run git command with --git-dir and --work-tree set."""
@@ -125,6 +221,8 @@ class GitRepo:
             str(work_dir),
             *args,
             env=env,
+            # Mirrors are gitacross-managed; whitelist them for the ownership check.
+            safe_dir=self.git_dir if self.is_bare else None,
             **kwargs,
         )
 

{gitacross-2.2.0 → gitacross-2.3.0}/src/gitacross/target.py

@@ -120,10 +120,15 @@ class _RemoteTarget:
 
 
 class _LocalTarget:
-    """Target backed by a local git repo — no push, no API release."""
+    """Target backed by a local git repo — no push, no API release.
+
+    The repository at ``config.path`` is created on demand (directory plus
+    ``git init``) if it does not exist yet, so a local target can point at a
+    brand-new backup/mirror location.
+    """
 
     def __init__(self, config, author=None):
-        self._git = GitRepo.local(config.path)
+        self._git = GitRepo.ensure_local(config.path)
         self._author = author
 
     def setup(self, branch):

{gitacross-2.2.0 → gitacross-2.3.0/src/gitacross.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.2.0
+Version: 2.3.0
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -157,6 +157,13 @@ A config file starts with a `projects` list — each entry is one mirror and nee
 
 Tokens use `${VAR}` syntax — resolved from environment variables.
 
+For local **targets**, the `path` does not have to exist yet: if the directory is
+missing or is not already a git repository, GitAcross creates the directory and
+runs `git init` there before committing. If a repository already exists at that
+path it is opened as-is — existing git metadata is never re-initialised or
+overwritten (bare repositories and broken `.git` markers are refused with an
+error). Local **sources** must point at an existing git repository.
+
 | Option | Description |
 |---|---|
 | [`enabled`](#enabled) | Disable a project without deleting it |

{gitacross-2.2.0 → gitacross-2.3.0}/tests/test_git.py

@@ -155,6 +155,23 @@ def test_git_error_redaction_non_str_cmd():
             pass
     print("  ✓ git: _git redacts cmd parts on failure")
 
+
+def test_git_missing_binary_clear_error():
+    """_git raises a clear error when the git executable is not available."""
+    from gitacross.git import _git
+
+    with mock.patch(
+        "gitacross.git.subprocess.run",
+        side_effect=FileNotFoundError("[Errno 2] No such file or directory: 'git'"),
+    ):
+        try:
+            _git("rev-parse", "--git-dir")
+            assert False, "should have raised"
+        except ValueError as e:
+            assert "git executable not found" in str(e)
+            assert "PATH" in str(e)
+    print("  ✓ git: missing git binary produces a clear error")
+
 def test_git_ensure_mirror_same_url_skips_set_url():
     """Re-ensuring a mirror with an unchanged URL skips the remote update."""
     from gitacross.git import GitRepo
@@ -181,6 +198,84 @@ def test_git_ensure_mirror_same_url_skips_set_url():
         assert any("fetch" in args for args in commands)
     print("  ✓ git: ensure_mirror with unchanged URL skips remote update")
 
+
+def test_git_mirror_commands_whitelist_own_directory():
+    """Mirror commands carry a process-scoped safe.directory for the mirror dir.
+
+    Git refuses to operate in repositories owned by another user ("dubious
+    ownership") — a mirror cache created by an earlier run under a different
+    uid (containers/CI/shared volumes) must still be usable. The whitelist is
+    scoped to the gitacross-managed mirror via -c, never written to a config.
+    """
+    from gitacross.git import GitRepo
+    from gitacross.git import subprocess as git_subprocess
+
+    with tempfile.TemporaryDirectory() as tmp:
+        origin = Path(tmp) / "origin"
+        _ = _make_git_repo(origin)
+        _ = _make_file(origin, "f.txt")
+        _git_commit(origin, "c1")
+        mirror = Path(tmp) / "mirror.git"
+        commands = []
+        real_run = git_subprocess.run
+
+        def spy(cmd, *args, **kwargs):
+            commands.append(cmd)
+            return real_run(cmd, *args, **kwargs)
+
+        with mock.patch("gitacross.git.subprocess.run", side_effect=spy):
+            _ = GitRepo.ensure_mirror(str(origin), mirror)
+            _ = GitRepo.ensure_mirror(str(origin), mirror)  # refresh path too
+
+        safe_flag = ["-c", f"safe.directory={mirror.resolve()}"]
+        assert commands, "expected git commands to be issued"
+        for cmd in commands:
+            # Every command run against the mirror dir is whitelisted for it
+            assert any(str(mirror) == str(a) for a in cmd), f"unrelated: {cmd}"
+            assert cmd[1:3] == safe_flag, f"missing safe.directory: {cmd}"
+    print("  ✓ git: mirror commands whitelist their own directory")
+
+
+def test_git_mirror_instance_commands_whitelisted_but_not_local():
+    """Bare mirror instance commands carry safe.directory; local repos do not."""
+    from gitacross.git import GitRepo
+    from gitacross.git import subprocess as git_subprocess
+
+    with tempfile.TemporaryDirectory() as tmp:
+        origin = Path(tmp) / "origin"
+        _ = _make_git_repo(origin)
+        _ = _make_file(origin, "f.txt")
+        _git_commit(origin, "c1")
+        _git_tag(origin, "v1.0")
+        mirror = Path(tmp) / "mirror.git"
+
+        gr = GitRepo.ensure_mirror(str(origin), mirror)
+        local = Path(tmp) / "local"
+        _ = _make_git_repo(local)
+        _ = _make_file(local, "f.txt")
+        _git_commit(local, "c1")
+        _git_tag(local, "v1.0")
+        local_repo = GitRepo.local(local)
+
+        commands = []
+        real_run = git_subprocess.run
+
+        def spy(cmd, *args, **kwargs):
+            commands.append(cmd)
+            return real_run(cmd, *args, **kwargs)
+
+        with mock.patch("gitacross.git.subprocess.run", side_effect=spy):
+            assert "v1.0" in gr.list_tags()  # bare mirror -> whitelisted
+            assert "v1.0" in local_repo.list_tags()  # local -> not whitelisted
+
+        mirror_cmd = commands[0]
+        assert mirror_cmd[1:3] == ["-c", f"safe.directory={mirror.resolve()}"]
+        local_cmd = commands[1]
+        # Local (user-configured) repos are deliberately NOT auto-whitelisted
+        assert local_cmd[1] == "--git-dir"
+        assert not any("safe.directory" in a for a in local_cmd)
+    print("  ✓ git: mirror commands whitelisted, local repos left strict")
+
 def test_git_reset_worktree_bare_noop():
     """reset_worktree is a no-op for bare repos — HEAD must stay untouched."""
     from gitacross.git import GitRepo
@@ -193,6 +288,83 @@ def test_git_reset_worktree_bare_noop():
         assert (bare / "HEAD").read_text() == head_before
     print("  ✓ git: reset_worktree is a no-op for bare repos")
 
+
+def test_git_ensure_local_opens_existing_repo_without_reinit():
+    """ensure_local opens an existing repo as-is — no re-initialisation."""
+    from gitacross.git import GitRepo
+    from gitacross.git import _git as real_git
+
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = Path(tmp) / "repo"
+        _ = _make_git_repo(repo)
+        _ = _make_file(repo, "f.txt")
+        _git_commit(repo, "c1")
+        commands = []
+
+        def spy(*args, **kwargs):
+            commands.append(args)
+            return real_git(*args, **kwargs)
+
+        with mock.patch("gitacross.git._git", side_effect=spy):
+            git = GitRepo.ensure_local(repo)
+
+        assert git.head_sha()
+        # No init/re-init command was ever issued for an existing repo
+        assert not any(args and args[0] == "init" for args in commands)
+    print("  ✓ git: ensure_local opens an existing repo without re-initialising")
+
+
+def test_git_ensure_local_refuses_bare_repo():
+    """ensure_local must not run `git init` over an existing bare repo."""
+    from gitacross.git import GitRepo
+
+    with tempfile.TemporaryDirectory() as tmp:
+        bare = Path(tmp) / "bare.git"
+        subprocess.run(["git", "init", "--bare", "-q", str(bare)], check=True)
+        before = sorted(p.name for p in bare.iterdir())
+        try:
+            _ = GitRepo.ensure_local(bare)
+            assert False, "should have raised"
+        except ValueError as e:
+            assert "bare" in str(e) or "re-initialis" in str(e)
+        # The bare repo must be left exactly as it was (no nested .git, etc.)
+        assert sorted(p.name for p in bare.iterdir()) == before
+        assert not (bare / ".git").exists()
+    print("  ✓ git: ensure_local refuses to re-initialise a bare repo")
+
+
+def test_git_ensure_local_refuses_broken_git_marker():
+    """ensure_local refuses a '.git' entry it cannot use instead of overwriting it."""
+    from gitacross.git import GitRepo
+
+    with tempfile.TemporaryDirectory() as tmp:
+        broken = Path(tmp) / "broken"
+        broken.mkdir()
+        marker = broken / ".git"
+        marker.write_text("gitdir: /does/not/exist\n")
+        try:
+            _ = GitRepo.ensure_local(broken)
+            assert False, "should have raised"
+        except ValueError as e:
+            assert "'.git'" in str(e)
+        assert marker.read_text() == "gitdir: /does/not/exist\n"  # untouched
+    print("  ✓ git: ensure_local refuses a broken .git marker")
+
+
+def test_git_ensure_local_refuses_file_path():
+    """ensure_local rejects a path that is an existing file, not a directory."""
+    from gitacross.git import GitRepo
+
+    with tempfile.TemporaryDirectory() as tmp:
+        a_file = Path(tmp) / "some-file.txt"
+        a_file.write_text("not a dir")
+        try:
+            _ = GitRepo.ensure_local(a_file)
+            assert False, "should have raised"
+        except ValueError as e:
+            assert "not a directory" in str(e)
+    print("  ✓ git: ensure_local rejects a file path")
+
 def test_git_push_non_bare():
     """push from a non-bare repo pushes the branch to the remote."""
     from gitacross.git import GitRepo

{gitacross-2.2.0 → gitacross-2.3.0}/tests/test_integration.py

@@ -146,6 +146,227 @@ def test_e2e_local_to_local():
             os.chdir(old_cwd)
 
 
+def test_e2e_local_target_auto_init_inside_ancestor_repo():
+    """Local target path is created as its own repo — never the enclosing repo.
+
+    Regression: a target path that is not itself a repo but sits inside another
+    repository used to resolve to the enclosing repo, so syncs committed to and
+    hard-reset the directory the tool runs from instead of the configured path.
+    """
+    from gitacross.config import Config
+    from gitacross.main import sync_project
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+
+        # ── Source repo: one tag ──
+        src = tmp / "source"
+        _ = _make_git_repo(src)
+        _ = _make_file(src, "README.md", "# Project")
+        _git_commit(src, "first")
+        _git_tag(src, "v1.0")
+
+        # ── Ancestor repo that must NOT receive the sync ──
+        ancestor = tmp / "ancestor"
+        _ = _make_git_repo(ancestor)
+        _ = _make_file(ancestor, "keep.txt", "untouched")
+        _git_commit(ancestor, "c1")
+        ancestor_head_before = subprocess.run(
+            ["git", "-C", str(ancestor), "rev-parse", "HEAD"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+
+        # ── Target path inside the ancestor repo, not itself a repo ──
+        tgt = ancestor / "test-repo"
+
+        cfg = tmp / "config.yml"
+        _ = cfg.write_text(f"""
+- name: e2e-auto-init
+  source:
+    type: local
+    path: {src}
+    tag_pattern: "v*"
+  target:
+    type: local
+    path: {tgt}
+    branch: main
+""")
+
+        old_cwd = Path.cwd()
+        os.chdir(tmp)
+        try:
+            config = Config(str(cfg))
+            _ = sync_project(config.projects[0], ".", dry_run=False)
+
+            # Synced content lives in the auto-created repo at the configured path
+            assert (tgt / ".git").is_dir()
+            assert (tgt / "README.md").read_text() == "# Project"
+            tags = subprocess.run(
+                ["git", "-C", str(tgt), "tag", "-l"],
+                capture_output=True, check=True, text=True,
+            ).stdout.strip().split()
+            assert "v1.0" in tags
+
+            # The ancestor repo was not touched
+            assert (ancestor / "keep.txt").read_text() == "untouched"
+            assert not (ancestor / "README.md").exists()
+            ancestor_head_after = subprocess.run(
+                ["git", "-C", str(ancestor), "rev-parse", "HEAD"],
+                capture_output=True, check=True, text=True,
+            ).stdout.strip()
+            assert ancestor_head_after == ancestor_head_before
+
+            print("  ✓ e2e: local target auto-initialised inside an ancestor repo")
+        finally:
+            os.chdir(old_cwd)
+
+
+def test_e2e_local_target_existing_repo_on_target_branch_appends():
+    """An existing repo already on the target branch keeps its history: release
+    commits are appended on top and nothing is re-initialised or rewritten.
+    """
+    from gitacross.config import Config
+    from gitacross.main import sync_project
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+
+        # ── Source: two releases ──
+        src = tmp / "source"
+        _ = _make_git_repo(src)
+        for tag, content in (("v1.0", "# v1"), ("v2.0", "# v2")):
+            _ = _make_file(src, "README.md", content)
+            _git_commit(src, f"c-{tag}")
+            _git_tag(src, tag)
+
+        # ── Target: existing repo on main with its own history ──
+        tgt = tmp / "target"
+        subprocess.run(["git", "init", "-q", "-b", "main", str(tgt)], check=True)
+        subprocess.run(["git", "-C", str(tgt), "config", "user.email", "t@test"], check=True)
+        subprocess.run(["git", "-C", str(tgt), "config", "user.name", "Test"], check=True)
+        _ = _make_file(tgt, "notes.txt", "unrelated pre-existing work")
+        _git_commit(tgt, "pre-existing work on main")
+        pre = subprocess.run(
+            ["git", "-C", str(tgt), "rev-parse", "HEAD"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+
+        cfg = tmp / "config.yml"
+        _ = cfg.write_text(f"""
+- name: e2e-existing
+  source:
+    type: local
+    path: {src}
+    tag_pattern: "v*"
+  target:
+    type: local
+    path: {tgt}
+    branch: main
+""")
+        config = Config(str(cfg))
+        _ = sync_project(config.projects[0], work_dir=tmp / "state", dry_run=False)
+
+        # History was appended to, not replaced: pre-existing commit is an ancestor
+        rc = subprocess.run(
+            ["git", "-C", str(tgt), "merge-base", "--is-ancestor", pre, "main"],
+            capture_output=True, check=False,
+        )
+        assert rc.returncode == 0, "existing history should be an ancestor of main"
+        count = subprocess.run(
+            ["git", "-C", str(tgt), "rev-list", "--count", "main"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert count == "3"  # pre-existing + v1.0 + v2.0
+
+        # Branch tip carries the latest release content
+        assert (tgt / "README.md").read_text() == "# v2"
+        tags = subprocess.run(
+            ["git", "-C", str(tgt), "tag", "-l"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip().split()
+        assert "v1.0" in tags and "v2.0" in tags
+
+        # Re-running against the same repo is a no-op (state-driven)
+        _ = sync_project(config.projects[0], work_dir=tmp / "state", dry_run=False)
+        count2 = subprocess.run(
+            ["git", "-C", str(tgt), "rev-list", "--count", "main"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert count2 == count
+
+        print("  ✓ e2e: existing repo on target branch gets releases appended")
+
+
+def test_e2e_local_target_existing_repo_on_other_branch_untouched():
+    """An existing repo whose history lives on another branch (e.g. master) is
+    left untouched: sync builds on its own branch and never touches the other.
+    """
+    from gitacross.config import Config
+    from gitacross.main import sync_project
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+
+        src = tmp / "source"
+        _ = _make_git_repo(src)
+        _ = _make_file(src, "README.md", "# v1")
+        _git_commit(src, "c1")
+        _git_tag(src, "v1.0")
+
+        tgt = tmp / "target"
+        subprocess.run(["git", "init", "-q", "-b", "master", str(tgt)], check=True)
+        subprocess.run(["git", "-C", str(tgt), "config", "user.email", "t@test"], check=True)
+        subprocess.run(["git", "-C", str(tgt), "config", "user.name", "Test"], check=True)
+        _ = _make_file(tgt, "notes.txt", "unrelated work on master")
+        _git_commit(tgt, "pre-existing work on master")
+        master_before = subprocess.run(
+            ["git", "-C", str(tgt), "rev-parse", "master"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+
+        cfg = tmp / "config.yml"
+        _ = cfg.write_text(f"""
+- name: e2e-other-branch
+  source:
+    type: local
+    path: {src}
+    tag_pattern: "v*"
+  target:
+    type: local
+    path: {tgt}
+    branch: main
+""")
+        config = Config(str(cfg))
+        _ = sync_project(config.projects[0], work_dir=tmp / "state", dry_run=False)
+
+        # master (and its content) is untouched
+        master_after = subprocess.run(
+            ["git", "-C", str(tgt), "rev-parse", "master"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert master_after == master_before
+        notes = subprocess.run(
+            ["git", "-C", str(tgt), "ls-tree", "-r", "--name-only", "master"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert notes == "notes.txt"
+
+        # Sync landed on its own new branch with release content
+        head = subprocess.run(
+            ["git", "-C", str(tgt), "symbolic-ref", "--short", "HEAD"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert head == "main"
+        assert (tgt / "README.md").read_text() == "# v1"
+        tags = subprocess.run(
+            ["git", "-C", str(tgt), "tag", "-l"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip().split()
+        assert "v1.0" in tags
+
+        print("  ✓ e2e: existing repo on another branch is left untouched")
+
+
 def test_clean_text():
     from gitacross.main import _clean_text
 

{gitacross-2.2.0 → gitacross-2.3.0}/tests/test_source.py

@@ -484,21 +484,39 @@ def test_git_local_raises_on_non_repo():
         try:
             _ = GitRepo.local(not_a_repo)
             assert False, "should have raised"
-        except subprocess.CalledProcessError:
-            pass  # failing rev-parse surfaces as CalledProcessError
-
-        # When rev-parse resolves a git dir that does not exist → ValueError
-        with mock.patch(
-            "gitacross.git._git", return_value=mock.Mock(stdout="missing_git_dir")
-        ):
-            try:
-                _ = GitRepo.local(not_a_repo)
-                assert False, "should have raised"
-            except ValueError as e:
-                assert "Not a git repository" in str(e)
+        except ValueError as e:
+            assert "Not a git repository" in str(e)
     print("  ✓ git: GitRepo.local raises on a non-repo directory")
 
 
+def test_git_local_rejects_subdir_of_another_repo():
+    """GitRepo.local must not silently resolve to an enclosing repository.
+
+    Regression: git walks up to the nearest enclosing repository, so a path
+    that is not itself a repo but sits inside one used to resolve to the
+    enclosing repo — committing to and hard-resetting *its* working tree
+    (e.g. the directory the tool is run from) instead of the configured path.
+    """
+    from gitacross.git import GitRepo
+
+    with tempfile.TemporaryDirectory() as tmp:
+        outer = Path(tmp) / "outer"
+        _ = _make_git_repo(outer)
+        _ = _make_file(outer, "f.txt")
+        _git_commit(outer, "c1")
+
+        subdir = outer / "not_a_repo_itself"
+        subdir.mkdir()
+        try:
+            _ = GitRepo.local(subdir)
+            assert False, "should have raised"
+        except ValueError as e:
+            msg = str(e)
+            assert "Not a git repository" in msg
+            assert str(outer) in msg  # hint at the actual enclosing repo
+    print("  ✓ git: GitRepo.local rejects a subdirectory of another repo")
+
+
 def test_git_resolve_commit_unknown_returns_empty():
     """resolve_commit returns '' for an unknown ref instead of raising."""
     from gitacross.git import GitRepo

{gitacross-2.2.0 → gitacross-2.3.0}/tests/test_sync_api.py

@@ -340,6 +340,29 @@ def test_run_returns_synced_false_on_failure():
     print("  ✓ run: returns synced=False on failure and continues remaining projects")
 
 
+def test_run_git_missing_reports_clear_error(monkeypatch):
+    """When git is not installed, run() reports a clear, actionable error."""
+    import gitacross
+
+    with tempfile.TemporaryDirectory() as tmp:
+        src = Path(tmp) / "src_repo"
+        _ = _make_git_repo(src)  # created while git is still on PATH
+        cfg = Path(tmp) / "config.yml"
+        _write_local_config(
+            cfg, [{"name": "proj-gitless", "src": str(src), "tgt": str(Path(tmp) / "tgt")}]
+        )
+
+        monkeypatch.setenv("PATH", "/nonexistent")  # hide git from the run
+        results = gitacross.run(str(cfg), work_dir=Path(tmp) / "state")
+
+        assert results[0]["project"] == "proj-gitless"
+        assert results[0]["synced"] is False
+        assert results[0]["releases_synced"] == 0
+        assert results[0]["releases"] == []
+        assert "git executable not found" in results[0]["error"]
+    print("  ✓ run: missing git binary surfaces a clear error message")
+
+
 def test_run_dry_run_passed_through():
     import gitacross
 

{gitacross-2.2.0 → gitacross-2.3.0}/tests/test_target.py

@@ -1,11 +1,13 @@
 """Tests for target endpoints and retry — split from the original single-file suite."""
 from __future__ import annotations
 
+import subprocess
 import tempfile
 from pathlib import Path
 from unittest import mock
 
 from tests.conftest import (
+    _git_commit,
     _make_file,
     _make_git_repo,
 )
@@ -52,6 +54,98 @@ def test_target_local():
         print("  ✓ target: local")
 
 
+def test_target_local_empty_path_raises():
+    """A local target without a path must not default to the current directory."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.target import create_target
+
+    cfg = _EndpointConfig({"type": "local", "path": ""}, is_source=False)
+    try:
+        _ = create_target(cfg, "cache")
+        assert False, "should have raised"
+    except ValueError as e:
+        assert "path" in str(e).lower()
+    print("  ✓ target: local target with empty path is rejected")
+
+
+def test_target_local_auto_init_missing_dir():
+    """A local target whose path does not exist yet is created (mkdir + init)."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.target import create_target
+
+    with tempfile.TemporaryDirectory() as tmp:
+        target_path = Path(tmp) / "nested" / "backup-repo"  # does not exist
+
+        cfg = _EndpointConfig(
+            {"type": "local", "path": str(target_path), "branch": "main"},
+            is_source=False,
+        )
+
+        tgt = create_target(cfg, tmp)
+        tgt.setup("main")
+
+        work = Path(tmp) / "work"
+        work.mkdir()
+        _ = _make_file(work, "artifact.txt", "hello")
+        _ = tgt.commit(work, "Release v1.0")
+
+        # Repo + files exist at the configured path, not elsewhere
+        assert (target_path / ".git").is_dir()
+        assert (target_path / "artifact.txt").read_text() == "hello"
+        assert tgt.head_sha()
+        print("  ✓ target: local auto-initialises a missing target path")
+
+
+def test_target_local_auto_init_inside_ancestor_repo():
+    """A target path inside another repo must get its own repo, not clobber the ancestor.
+
+    Regression: git resolves a non-repo path inside a repository to the
+    enclosing repo, which used to make local targets commit to and hard-reset
+    the repository the tool is run from instead of the configured path.
+    """
+    from gitacross.config import _EndpointConfig
+    from gitacross.target import create_target
+
+    with tempfile.TemporaryDirectory() as tmp:
+        ancestor = Path(tmp) / "ancestor"
+        _ = _make_git_repo(ancestor)
+        _ = _make_file(ancestor, "keep.txt", "must survive")
+        _git_commit(ancestor, "c1")
+        ancestor_head_before = subprocess.run(
+            ["git", "-C", str(ancestor), "rev-parse", "HEAD"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+
+        target_path = ancestor / "test-repo"  # not a repo itself
+
+        cfg = _EndpointConfig(
+            {"type": "local", "path": str(target_path), "branch": "main"},
+            is_source=False,
+        )
+
+        tgt = create_target(cfg, tmp)
+        tgt.setup("main")
+
+        work = Path(tmp) / "work"
+        work.mkdir()
+        _ = _make_file(work, "artifact.txt", "hello")
+        _ = tgt.commit(work, "Release v1.0")
+
+        # The configured path is its own repo with the committed files
+        assert (target_path / ".git").is_dir()
+        assert (target_path / "artifact.txt").read_text() == "hello"
+
+        # The ancestor repo is untouched
+        assert (ancestor / "keep.txt").read_text() == "must survive"
+        ancestor_head_after = subprocess.run(
+            ["git", "-C", str(ancestor), "rev-parse", "HEAD"],
+            capture_output=True, check=True, text=True,
+        ).stdout.strip()
+        assert ancestor_head_after == ancestor_head_before
+        assert not (ancestor / "artifact.txt").exists()
+        print("  ✓ target: local auto-init inside an ancestor repo is isolated")
+
+
 def test_target_remote_push_commit_mode():
     from gitacross.config import _EndpointConfig
     from gitacross.target import create_target