gitacross 2.3.0__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.0
+Version: 2.3.2
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -223,7 +223,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -443,7 +443,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -453,6 +453,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

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

@@ -194,7 +194,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -414,7 +414,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -424,6 +424,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

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

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

{gitacross-2.3.0 → gitacross-2.3.2}/src/gitacross/cli.py

@@ -50,6 +50,11 @@ def main():
         default=DEFAULT_WORK_DIR,
         help="Directory for state.yml and cache/ (default: .gitsync)",
     )
+    _ = parser.add_argument(
+        "--clean-cache",
+        action="store_true",
+        help="Delete mirror caches no longer referenced by the config",
+    )
     _ = parser.add_argument("-v", "--verbose", action="store_true", help="Debug logging")
     args = parser.parse_args()
 
@@ -62,6 +67,7 @@ def main():
     dry_run_flag = cast(bool, args.dry_run)
     reset_flag = cast(bool, args.reset)
     workdir = cast(str, args.workdir)
+    clean_cache_flag = cast(bool, args.clean_cache)
 
     _setup_logging(verbose)
 
@@ -96,6 +102,7 @@ def main():
             dry_run=dry_run_flag,
             reset=reset_flag,
             work_dir=workdir,
+            clean_cache=clean_cache_flag,
         )
     except (FileNotFoundError, ValueError) as exc:
         sys.exit(str(exc))

{gitacross-2.3.0 → gitacross-2.3.2}/src/gitacross/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 import logging
 import os
 from pathlib import Path
@@ -170,6 +171,41 @@ class _EndpointConfig:
         """Filesystem-safe repo identifier (``owner/name`` → ``owner_name``)."""
         return self.repo.replace("/", "_")
 
+    @property
+    def host(self):
+        """Git host for a remote endpoint.
+
+        GitHub's API lives at api.github.com, but its git host is github.com.
+        Gitea's API typically lives on the same host as git, so no transform is
+        needed there. Returns "" when no ``api`` is configured.
+        """
+        if not self.api:
+            return ""
+        raw_host = self.api.split("://")[1].split("/")[0] if "://" in self.api else self.api
+        return "github.com" if raw_host == "api.github.com" else raw_host
+
+    @property
+    def host_slug(self):
+        """Filesystem-safe host identifier for cache paths.
+
+        Keeps dots and hyphens (so e.g. ``my.host.com`` and ``my-host.com`` stay
+        distinct); only the port separator and any slashes become underscores.
+        """
+        return self.host.lower().replace(":", "_").replace("/", "_")
+
+    def mirror_dir_name(self, role):
+        """Deterministic, collision-resistant cache directory name for a remote endpoint.
+
+        Mirrors persist between runs — that is what makes them a cache — so the
+        name must be a pure function of the endpoint identity, never random.
+        Separator-based slugs alone can still collide (e.g. ``a/b_c`` and
+        ``a_b/c`` on the same host), so a short hash of the full identity
+        (role, type, host, repo) is appended to the readable prefix.
+        """
+        identity = "\0".join([role, self.type, self.host.lower(), self.repo])
+        digest = hashlib.sha1(identity.encode("utf-8")).hexdigest()[:10]
+        return f"{role}_{self.type}_{self.host_slug}_{self.repo_slug}_{digest}.git"
+
     @property
     def owner(self):
         return self.repo.split("/")[0] if "/" in self.repo else ""
@@ -179,11 +215,7 @@ class _EndpointConfig:
         """HTTPS clone URL with token embedded for auth."""
         if not self.api or not self.repo:
             return ""
-        raw_host = self.api.split("://")[1].split("/")[0] if "://" in self.api else self.api
-        # GitHub's API lives at api.github.com, but its git host is github.com.
-        # Gitea's API typically lives on the same host as git, so no transform needed.
-        host = "github.com" if raw_host == "api.github.com" else raw_host
-        return f"https://{self.owner}:{self.token}@{host}/{self.repo}.git"
+        return f"https://{self.owner}:{self.token}@{self.host}/{self.repo}.git"
 
 
 @final

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

@@ -196,6 +196,11 @@ class GitRepo:
             )
         p.mkdir(parents=True, exist_ok=True)
         _ = _git("init", str(p))
+        # Give a fresh repo a repo-local identity so commits never depend on
+        # the ambient git config (mirrors get the same treatment in
+        # ensure_mirror). Existing repos are opened as-is and left untouched.
+        _ = _git("-C", str(p), "config", "user.name", "GitAcross")
+        _ = _git("-C", str(p), "config", "user.email", "sync@gitacross")
         logger.info("Initialised git repository at %s", p)
         return cls.local(path)
 

{gitacross-2.3.0 → gitacross-2.3.2}/src/gitacross/main.py

@@ -446,6 +446,7 @@ def run(
     dry_run: bool = False,
     reset: bool = False,
     work_dir: str | Path = DEFAULT_WORK_DIR,
+    clean_cache: bool = False,
 ):
     """Sync releases from a config — the primary Python API entry point.
 
@@ -469,6 +470,14 @@ def run(
             syncing so that all releases are treated as new.
         work_dir:    Directory path for ``state.yml`` and ``cache/``.
             Defaults to ``.gitsync``.
+        clean_cache: When ``True``, delete bare mirror clones under
+            ``work_dir/cache/`` that no endpoint in the config references
+            anymore (e.g. after the config changed hosts or repos). Mirrors are
+            disposable clones, so this only ever costs a re-clone. Skipped in
+            dry-run mode. Note: mirrors are identified per config, so if
+            multiple config files share one ``work_dir``, run them with the
+            same ``clean_cache`` setting to avoid deleting each other's
+            mirrors.
 
     Returns:
         A list of dicts — one per enabled project that was attempted — with
@@ -522,6 +531,9 @@ def run(
     if project_name and not projects:
         raise ValueError(f"Project '{project_name}' not found in config")
 
+    if clean_cache and not dry_run and not reset:
+        _clean_mirror_cache(work_dir, config)
+
     results = []
     for proj in projects:
         if not proj.enabled:
@@ -552,6 +564,42 @@ def run(
     return results
 
 
+def _clean_mirror_cache(work_dir: str | Path, config: Config) -> None:
+    """Delete mirror clones under ``work_dir/cache/`` not referenced by *config*.
+
+    Cache keys are deterministic identity names (role, type, host, repo), so a
+    config edit that changes any of those orphans the previous mirror. Orphans
+    are harmless but waste disk, so this removes them. The reference set is
+    built from *every* project in the config — enabled or not — and remote
+    endpoints only, so running a project subset or re-enabling a disabled
+    project never deletes a mirror it still needs.
+    """
+    cache_dir = Path(work_dir) / "cache"
+    if not cache_dir.is_dir():
+        return
+    referenced = {
+        endpoint.mirror_dir_name(role)
+        for proj in config.projects
+        for endpoint, role in ((proj.source, "source"), (proj.target, "target"))
+        if endpoint.is_remote
+    }
+    removed = []
+    for child in sorted(cache_dir.iterdir()):
+        if (
+            child.is_dir()
+            and child.name.endswith(".git")
+            and child.name not in referenced
+        ):
+            shutil.rmtree(child, ignore_errors=True)
+            removed.append(child.name)
+    if removed:
+        logger.info(
+            "Removed %d stale mirror cache(s): %s",
+            len(removed),
+            ", ".join(removed),
+        )
+
+
 
 
 # Imported at the bottom to avoid a circular import (cli.py imports .main.run).

{gitacross-2.3.0 → gitacross-2.3.2}/src/gitacross/source.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import fnmatch
 import logging
+import re
 from pathlib import Path
 from typing import final
 
@@ -31,20 +32,122 @@ def create_source(config, cache_dir, dry_run=False):
     )
 
 
-def _filter_from_sync_point(releases, sync_from):
-    """Filter to releases at or after the sync_from tag (inclusive).
+# Calendar versions start with a 4-digit year (YYYY[.MM[.DD[...]]], e.g.
+# 2024.05.01 or 2024-05-01). Every dot/dash/underscore-separated numeric
+# field is part of the date sequence.
+_CALENDAR_RE = re.compile(r"[^0-9]*(\d{4}(?:[._-]\d{1,4})*)")
+# SemVer-style cores are dot-separated numbers; a hyphen introduces a
+# prerelease, never another core field.
+_SEMVER_CORE_RE = re.compile(r"(\d+(?:\.\d+)*)")
+
+
+def _version_key(tag):
+    """Parse a version-like tag into a comparable ``(fields, prerelease)`` key.
+
+    Two schemes are supported, parsed separately because they are semantically
+    different:
 
-    Releases must already be sorted oldest-first. If sync_from is empty
-    return all releases. If the tag isn't found, return nothing —
-    better to skip than silently backfill history.
+    * **SemVer** — ``v1.2.3``, ``v1.2.3-rc.1``. Dot-separated core; a hyphen
+      starts a prerelease that sorts before the final release.
+    * **Calendar (CalVer)** — ``2024.05.01``, ``2024-05-01``, ``2024.05``.
+      Date-based: a leading 4-digit year marks it, and every numeric field
+      (dot *or* dash separated) belongs to the (year, month, day, ...)
+      sequence, compared as plain numbers. No major/minor/patch or SemVer
+      prerelease semantics apply to the date fields themselves.
+
+    Returns ``None`` when the tag carries no parseable version.
+    """
+    if not isinstance(tag, str):
+        return None
+    calendar = _CALENDAR_RE.match(tag)
+    if calendar:
+        fields = tuple(int(part) for part in re.split(r"[._-]", calendar.group(1)))
+        rest = tag[calendar.end():].split("+", 1)[0]
+    else:
+        match = _SEMVER_CORE_RE.search(tag)
+        if not match:
+            return None
+        fields = tuple(int(part) for part in match.group(1).split("."))
+        rest = tag[match.end():].split("+", 1)[0]
+    # Anything remaining after the version fields is a prerelease; build
+    # metadata ("+...") is ignored for ordering, per SemVer.
+    ids = tuple(re.findall(r"[0-9A-Za-z]+", rest))
+    return fields, (ids or None)
+
+
+def _cmp_version_key(a, b):
+    """Compare two ``_version_key`` results: -1/0/1 (SemVer-ish ordering)."""
+    (ca, pa), (cb, pb) = a, b
+    width = max(len(ca), len(cb))
+    ca += (0,) * (width - len(ca))
+    cb += (0,) * (width - len(cb))
+    if ca != cb:
+        return 1 if ca > cb else -1
+    # Same core: a final release outranks any prerelease of it
+    if pa is None and pb is None:
+        return 0
+    if pa is None:
+        return 1
+    if pb is None:
+        return -1
+    # Compare prerelease identifiers: numeric < alphanumeric, identifiers
+    # compare numerically when both numeric, lexically when both alphanumeric
+    for x, y in zip(pa, pb):
+        xn, yn = x.isdigit(), y.isdigit()
+        if xn and yn:
+            xi, yi = int(x), int(y)
+            if xi != yi:
+                return 1 if xi > yi else -1
+        elif xn != yn:
+            return -1 if xn else 1
+        elif x != y:
+            return 1 if x > y else -1
+    return 1 if len(pa) > len(pb) else (-1 if len(pa) < len(pb) else 0)
+
+
+def _newer_than_version(tag, cutoff):
+    """True when *tag* parses as a version strictly newer than *cutoff*."""
+    key = _version_key(tag)
+    return key is not None and _cmp_version_key(key, cutoff) > 0
+
+
+def _filter_from_sync_point(releases, sync_from):
+    """Filter to releases at or after the sync_from tag.
+
+    Releases must already be sorted oldest-first. If sync_from is empty return
+    all releases. When the exact tag is present, everything from it onwards is
+    included; when it is missing (renamed, deleted, or never released), releases
+    whose version is strictly newer than sync_from are synced instead. Tags that
+    cannot be compared (no version digits) are skipped rather than silently
+    backfilling history.
     """
     if not sync_from:
         return releases
     for i, rel in enumerate(releases):
         if rel["tag_name"] == sync_from:
             return releases[i:]
-    logger.warning("sync_from tag '%s' not found — syncing nothing", sync_from)
-    return []
+
+    # Exact tag not found — fall back to releases with a newer version.
+    cutoff = _version_key(sync_from)
+    if cutoff is None:
+        logger.warning(
+            "sync_from '%s' not found and is not version-like — syncing nothing",
+            sync_from,
+        )
+        return []
+    newer = [r for r in releases if _newer_than_version(r.get("tag_name"), cutoff)]
+    if not newer:
+        logger.warning(
+            "sync_from tag '%s' not found and no releases are newer — syncing nothing",
+            sync_from,
+        )
+    else:
+        logger.info(
+            "sync_from tag '%s' not found — syncing %d release(s) newer than it",
+            sync_from,
+            len(newer),
+        )
+    return newer
 
 
 # ---------------------------------------------------------------------------
@@ -64,7 +167,7 @@ class _RemoteSource:
         self._api.ensure_repo_exists(create=not dry_run)
         self._git = GitRepo.ensure_mirror(
             config.clone_url,
-            Path(cache_dir) / f"source_{config.type}_{config.repo_slug}.git",
+            Path(cache_dir) / config.mirror_dir_name("source"),
         )
         self._include_prereleases = config.include_prereleases
         self._include_drafts = config.include_drafts

{gitacross-2.3.0 → gitacross-2.3.2}/src/gitacross/state.py

@@ -26,11 +26,24 @@ class State:
         return f"State(work_dir={str(self.work_dir)!r})"
 
     def _load(self):
+        data = {}
         if self.path.exists():
             with open(self.path) as f:
-                data = yaml.safe_load(f) or {}
-        else:
+                data = yaml.safe_load(f)
+        # Tolerate degenerate or hand-edited YAML (e.g. a bare ``projects:``
+        # key with no value, non-map documents, or null entries) so a corrupt
+        # state file can never crash a run — it is simply treated as empty.
+        if not isinstance(data, dict):
             data = {}
+        projects = data.get("projects")
+        if not isinstance(projects, dict):
+            projects = {}
+            data["projects"] = projects
+        for name, project in list(projects.items()):
+            if not isinstance(project, dict):
+                projects[name] = {}
+            elif not isinstance(project.get("releases"), dict):
+                project["releases"] = {}
         return data
 
     def has_release(self, project_name, tag_name):

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

@@ -58,7 +58,7 @@ class _RemoteTarget:
             )
         self._git = GitRepo.ensure_mirror(
             clone_url,
-            Path(cache_dir) / f"target_{config.type}_{config.repo_slug}.git",
+            Path(cache_dir) / config.mirror_dir_name("target"),
         )
         self._retry_max = retry_max
         self._retry_backoff = retry_backoff

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.0
+Version: 2.3.2
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -223,7 +223,7 @@ Stream each asset upload directly from the temporary download directory on disk
 
 ### Source mode: release, tag, or commit
 
-Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced.
+Remote sources sync from the host's **API releases** by default. Two alternatives are available: git tags, or the latest commit of a branch. A `sync_from` key on the source sets the starting point — only releases from that tag onward are synced. If the exact tag no longer exists (renamed or deleted upstream), releases with a **higher version** are synced instead, so an absent anchor never blocks newer releases. Both SemVer tags (`v1.2.3`) and calendar tags (`2024.05.01`, `2024-05-01`) are compared version-wise; the two schemes are never confused with each other.
 
 Synced state is keyed by **tag name**, so switching a repo between `release` and `tag` modes is safe: already-synced tags are skipped regardless of the current mode (older state files keyed by API release id are migrated automatically).
 
@@ -443,7 +443,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -453,6 +453,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

{gitacross-2.3.0 → gitacross-2.3.2}/tests/test_config.py

@@ -73,6 +73,85 @@ projects:
         os.unlink(config_path)
 
 
+def test_endpoint_host_and_host_slug():
+    """host/host_slug identify the git host and stay filesystem-safe."""
+    from gitacross.config import _EndpointConfig
+
+    gitea = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://git.nodebay.top/api/v1"},
+        is_source=True,
+    )
+    assert gitea.host == "git.nodebay.top"
+    assert gitea.host_slug == "git.nodebay.top"
+
+    # GitHub's API host maps to its git host
+    gh = _EndpointConfig(
+        {"type": "github", "repo": "a/b", "api": "https://api.github.com"},
+        is_source=True,
+    )
+    assert gh.host == "github.com"
+    assert gh.host_slug == "github.com"
+
+    # Ports are kept in the slug so hosts differing only by port stay distinct
+    port = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://git.nodebay.top:8443/api/v1"},
+        is_source=True,
+    )
+    assert port.host_slug == "git.nodebay.top_8443"
+
+    # Dots vs hyphens are NOT collapsed into the same slug
+    assert (
+        _EndpointConfig({"api": "https://my.host.com"}, is_source=True).host_slug
+        == "my.host.com"
+    )
+    assert (
+        _EndpointConfig({"api": "https://my-host.com"}, is_source=True).host_slug
+        == "my-host.com"
+    )
+
+    # No api configured -> empty host
+    assert _EndpointConfig({"api": ""}, is_source=True).host == ""
+    print("  ✓ config: endpoint host / host_slug")
+
+
+def test_mirror_dir_name_deterministic_and_unique():
+    """mirror_dir_name is deterministic across runs and collision-resistant."""
+    import re
+
+    from gitacross.config import _EndpointConfig
+
+    def name(repo, api="https://git.nodebay.top/api/v1", kind="gitea", role="source"):
+        raw = {"type": kind, "repo": repo, "api": api}
+        return _EndpointConfig(raw, is_source=True).mirror_dir_name(role)
+
+    # Deterministic: same identity always yields the same cache name
+    assert name("uqkami/Awara") == name("uqkami/Awara")
+
+    # Role is part of the identity (source vs target never share a mirror)
+    assert name("uqkami/Awara", role="target") != name("uqkami/Awara", role="source")
+
+    # Readable prefix + a short hex digest before the .git suffix
+    n = name("uqkami/Awara")
+    assert n.startswith("source_gitea_git.nodebay.top_uqkami_Awara_")
+    digest = n.rsplit("_", 1)[1]
+    assert re.fullmatch(r"[0-9a-f]{10}\.git", digest)
+
+    # Slug-ambiguous owner/repo pairs must never share a mirror
+    assert name("a/b_c") != name("a_b/c")
+
+    # Host case differences resolve to the same host -> same cache (dedup)
+    upper = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://GIT.NODEBAY.TOP/api/v1"},
+        is_source=True,
+    ).mirror_dir_name("source")
+    assert upper == name("a/b")
+
+    # Different hosts or ports stay distinct
+    assert name("a/b", api="https://git.nodebay.top:8443/api/v1") != name("a/b")
+    assert name("a/b", api="https://gitea.example.com/api/v1") != name("a/b")
+    print("  ✓ config: mirror_dir_name is deterministic and collision-resistant")
+
+
 def test_config_local():
     from gitacross.config import Config
 

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

@@ -276,6 +276,41 @@ def test_git_mirror_instance_commands_whitelisted_but_not_local():
         assert not any("safe.directory" in a for a in local_cmd)
     print("  ✓ git: mirror commands whitelisted, local repos left strict")
 
+
+def test_git_ensure_local_new_repo_commits_without_ambient_identity(monkeypatch):
+    """Auto-initialised repos carry a repo-local identity, so commits never
+    depend on the ambient git config.
+
+    Regression: fresh ensure_local repos had no identity configured, so commits
+    failed with exit 128 ("Please tell me who you are") on machines without a
+    global git user.name/email.
+    """
+    from gitacross.git import GitRepo
+
+    # Strip all ambient identity: only repo-local config may be used
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", "/dev/null")
+    monkeypatch.setenv("GIT_CONFIG_SYSTEM", "/dev/null")
+    for var in (
+        "GIT_AUTHOR_NAME",
+        "GIT_AUTHOR_EMAIL",
+        "GIT_COMMITTER_NAME",
+        "GIT_COMMITTER_EMAIL",
+    ):
+        monkeypatch.delenv(var, raising=False)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = Path(tmp) / "repo"
+        git = GitRepo.ensure_local(repo)
+        git.ensure_branch("main")
+
+        work = Path(tmp) / "work"
+        work.mkdir()
+        _ = _make_file(work, "f.txt", "hello")
+        result = git.commit(work, "Release v1.0")
+        assert result.returncode in (0, 1)
+        assert git.head_sha()
+    print("  ✓ git: auto-initialised repos commit without ambient identity")
+
 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

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

@@ -103,9 +103,172 @@ def test_source_local_sync_from():
         releases2 = src2.fetch_releases()
         assert releases2 == []
 
+        # sync_from = missing tag but with newer releases present — the newer
+        # releases are synced instead of syncing nothing
+        cfg3 = _EndpointConfig(
+            {
+                "type": "local",
+                "path": str(repo),
+                "tag_pattern": "v*",
+                "sync_from": "v1.5",
+            },
+            is_source=True,
+        )
+        src3 = create_source(cfg3, tmp)
+        tags3 = [r["tag_name"] for r in src3.fetch_releases()]
+        assert tags3 == ["v2.0", "v3.0"]
+
         print("  ✓ source: local sync_from")
 
 
+def test_filter_from_sync_point_fallback_newer_versions():
+    """A missing sync_from tag falls back to releases with a newer version."""
+    from gitacross.source import _filter_from_sync_point
+
+    def rel(tag):
+        return {"tag_name": tag}
+
+    all_rel = [rel("v0.8.0"), rel("v0.9.0"), rel("v1.0.0"), rel("v1.2.0"), rel("v2.0.0")]
+
+    # Exact match: everything from the tag onwards (unchanged behaviour)
+    assert [r["tag_name"] for r in _filter_from_sync_point(all_rel, "v0.9.0")] == [
+        "v0.9.0", "v1.0.0", "v1.2.0", "v2.0.0",
+    ]
+
+    # Missing tag: only strictly-newer versions are kept (v0.8.0 < v0.9.0)
+    assert [r["tag_name"] for r in _filter_from_sync_point(all_rel, "v0.9.1")] == [
+        "v1.0.0", "v1.2.0", "v2.0.0",
+    ]
+
+    # Numeric (not lexicographic) comparison: v0.10.0 > v0.9.9
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v0.10.0"), rel("v0.9.0")], "v0.9.9")
+    ] == ["v0.10.0"]
+
+    # Zero-padding: v1.2 == v1.2.0, so it is NOT counted as newer
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2"), rel("v1.3")], "v1.2.0")
+    ] == ["v1.3"]
+
+    # No newer release and nothing comparable -> nothing synced
+    assert _filter_from_sync_point([rel("v0.5.0")], "v0.9.0") == []
+    assert _filter_from_sync_point([rel("v0.9.0"), rel("latest")], "v0.9.1") == []
+
+    # A non-version sync_from cannot be compared -> nothing synced
+    assert _filter_from_sync_point(all_rel, "alpha") == []
+
+    # Unversioned / non-string release tags are never counted as newer
+    assert _filter_from_sync_point(
+        [rel("latest"), {"tag_name": None}, rel("v1.0.0")], "v0.9.0"
+    ) == [rel("v1.0.0")]
+
+    # SemVer: a prerelease of a version is OLDER than its final release, so a
+    # missing v1.2.3 never pulls in v1.2.3-rc.1 — only truly newer versions do
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2.3-rc.1"), rel("v1.2.4")], "v1.2.3")
+    ] == ["v1.2.4"]
+
+    # Prerelease identifier ordering: numeric pre identifiers compare
+    # numerically, and a final release outranks any prerelease of its version
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.2.3-rc.2"), rel("v1.2.3")], "v1.2.3-rc.1"
+        )
+    ] == ["v1.2.3-rc.2", "v1.2.3"]
+
+    # SemVer: numeric prerelease identifiers sort BEFORE alphanumeric ones, and
+    # a final release outranks every prerelease of its version
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.0.0-1"), rel("v1.0.0-10"), rel("v1.0.0-beta"), rel("v1.0.0")],
+            "v1.0.0-2",
+        )
+    ] == ["v1.0.0-10", "v1.0.0-beta", "v1.0.0"]
+
+    # Build metadata is ignored for ordering
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v1.2.3+meta"), rel("v1.2.4")], "v1.2.3")
+    ] == ["v1.2.4"]
+
+    # Alphanumeric prerelease identifiers compare lexically (beta > alpha), and
+    # longer identifier lists after an equal prefix sort later
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("v1.0.0-alpha.1"), rel("v1.0.0-beta"), rel("v1.0.0")],
+            "v1.0.0-alpha",
+        )
+    ] == ["v1.0.0-alpha.1", "v1.0.0-beta", "v1.0.0"]
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [
+                rel("v1.0.0-alpha"),
+                rel("v1.0.0-beta"),
+                rel("v1.0.0-alpha.2"),
+                rel("v1.0.0-alpha.1.beta"),
+            ],
+            "v1.0.0-alpha.1",
+        )
+    ] == ["v1.0.0-beta", "v1.0.0-alpha.2", "v1.0.0-alpha.1.beta"]
+
+    # ── Calendar versions (CalVer) are date-based, not SemVer ──
+    # Dot-shaped dates compare as plain (year, month, day) numbers
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.01.15"), rel("2024.04.30"), rel("2024.05.01")], "2024.04.01"
+        )
+    ] == ["2024.04.30", "2024.05.01"]
+
+    # Dash-separated dates: '-' joins date fields; it is NOT a prerelease
+    # marker, so 2024-06-01 is newer than 2024-05-01
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024-04-15"), rel("2024-06-01")], "2024-05-01"
+        )
+    ] == ["2024-06-01"]
+
+    # Month-only anchor (2024.05 = May) vs day releases
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("2024.04"), rel("2024.05.10")], "2024.05")
+    ] == ["2024.05.10"]
+
+    # A prerelease of the same calendar date is not newer than the date itself
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.05.01-rc.1"), rel("2024.05.02")], "2024.05.01"
+        )
+    ] == ["2024.05.02"]
+
+    # Scheme switch on one repo: a 2024.x calendar tag clears a v2-era SemVer
+    # anchor, while a v9.x tag never clears a 2024 calendar anchor
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point([rel("v2.9.0"), rel("2024.01.15")], "v2.9.9")
+    ] == ["2024.01.15"]
+    assert [
+        r["tag_name"]
+        for r in _filter_from_sync_point(
+            [rel("2024.02.01"), rel("v9.9.9")], "2024.01.15"
+        )
+    ] == ["2024.02.01"]
+
+    # No sync_from -> everything
+    assert len(_filter_from_sync_point(all_rel, "")) == 5
+
+    print("  ✓ source: missing sync_from falls back to newer versions")
+
+
 def test_source_remote_mode_tag_sync_from():
     """mode: tag reads releases straight from git tags, no API involved."""
     from unittest import mock
@@ -718,6 +881,95 @@ def test_remote_source_duck_typed_helpers():
     mock_api.list_release_assets.assert_called_with(7)
     print("  ✓ source: remote passthrough helpers delegate correctly")
 
+
+def test_remote_source_cache_separates_hosts():
+    """Same-named repos on different hosts must not share a mirror cache dir.
+
+    Regression: mirror names only encoded type + owner/repo, so two hosts with
+    the same repo slug collided — the shared mirror flipped origin and re-fetched
+    between projects, dirtying each other's cache.
+    """
+    from gitacross.config import _EndpointConfig
+    from gitacross.source import create_source
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    host_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "t"},
+        is_source=True,
+    )
+    host_b = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://gitea.example.com/api/v1", "token": "t"},
+        is_source=True,
+    )
+    same_as_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "other-token"},
+        is_source=True,
+    )
+
+    mock_apis = [mock.MagicMock() for _ in range(3)]
+    with mock.patch(
+        "gitacross.source.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_source(host_a, "cache")
+        _ = create_source(host_b, "cache")
+        _ = create_source(same_as_a, "cache")
+
+    dest_a, dest_b, dest_same = (Path(d) for _, d in calls)
+    for d in (dest_a, dest_b):
+        assert str(d).endswith(".git")
+    assert "source_gitea_git.nodebay.top_uqkami_Awara_" in str(dest_a)
+    assert "source_gitea_gitea.example.com_uqkami_Awara_" in str(dest_b)
+    # Different hosts -> separate mirrors; same host (any token) -> shared mirror
+    assert dest_a != dest_b
+    assert dest_a == dest_same
+    print("  ✓ source: remote source cache dirs are separated per host")
+
+
+def test_remote_source_cache_hash_kills_slug_collisions():
+    """Slug-ambiguous repos (a/b_c vs a_b/c) on one host never share a mirror."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.source import create_source
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    def cfg(repo):
+        return _EndpointConfig(
+            {"type": "gitea", "repo": repo,
+             "api": "https://git.nodebay.top/api/v1", "token": "t"},
+            is_source=True,
+        )
+
+    mock_apis = [mock.MagicMock() for _ in range(2)]
+    with mock.patch(
+        "gitacross.source.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_source(cfg("a/b_c"), "cache")
+        _ = create_source(cfg("a_b/c"), "cache")
+
+    dest1, dest2 = (Path(d) for _, d in calls)
+    # Both have the same readable slug prefix (a_b_c), but the identity hashes
+    # differ, so they resolve to distinct mirror dirs
+    assert dest1 != dest2
+    assert "a_b_c_" in str(dest1)
+    assert "a_b_c_" in str(dest2)
+    print("  ✓ source: slug collisions resolve to distinct cache dirs")
+
 def test_local_source_duck_typed_helpers():
     from gitacross.config import _EndpointConfig
     from gitacross.source import create_source

{gitacross-2.3.0 → gitacross-2.3.2}/tests/test_state.py

@@ -74,4 +74,37 @@ def test_state():
         print("  ✓ state persistence")
 
 
+def test_state_tolerates_degenerate_yaml():
+    """A corrupt or hand-edited state file must never crash a run.
+
+    Regression: a state.yml containing only ``projects:`` parses to
+    ``{"projects": None}``, which crashed has_release with an AttributeError.
+    """
+    from gitacross.state import State
+
+    degenerate = [
+        "projects:\n",  # bare key, no value (the reported crash)
+        "projects: []\n",  # list instead of map
+        "[]\n",  # scalar document
+        "projects:\n  myapp:\n",  # null project entry
+        "projects:\n  myapp:\n    releases:\n",  # null releases entry
+        "",  # empty file
+    ]
+    for i, content in enumerate(degenerate):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "state.yml"
+            _ = path.write_text(content)
+            state = State(tmp)
+            assert not state.has_release("myapp", "v1.0"), f"case {i}: {content!r}"
+            state.add_release(
+                "myapp",
+                "v1.0",
+                {"tag": "v1.0", "target_commit": "x"},
+            )
+            state.save()
+            # Round-trip: the release is now visible and nothing else crashes
+            assert State(tmp).has_release("myapp", "v1.0"), f"case {i}: {content!r}"
+    print("  ✓ state: degenerate state.yml is treated as empty, never crashes")
+
+
 

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

@@ -363,6 +363,106 @@ def test_run_git_missing_reports_clear_error(monkeypatch):
     print("  ✓ run: missing git binary surfaces a clear error message")
 
 
+def test_run_clean_cache_removes_orphaned_mirrors():
+    """clean_cache deletes mirrors no config endpoint references — nothing else."""
+    import gitacross
+
+    from gitacross.config import Config
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        cfg_path = tmp / "config.yml"
+        _ = cfg_path.write_text("""
+projects:
+  - name: proj-a
+    source:
+      type: gitea
+      repo: owner/repo
+      api: https://git.nodebay.top/api/v1
+      token: t
+    target:
+      type: local
+      path: /tmp/tgt-a
+  - name: proj-disabled
+    enabled: false
+    source:
+      type: gitea
+      repo: owner/old
+      api: https://gitea.example.com/api/v1
+      token: t
+    target:
+      type: local
+      path: /tmp/tgt-b
+""")
+        cfg = Config(str(cfg_path))
+        referenced = cfg.projects[0].source.mirror_dir_name("source")
+        disabled_ref = cfg.projects[1].source.mirror_dir_name("source")
+        wd = tmp / "workdir"
+
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            # (a) no cache dir yet -> clean-cache is a safe no-op
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+
+            # Build a cache with referenced + orphaned mirrors and junk
+            cache = wd / "cache"
+            (cache / referenced).mkdir(parents=True)
+            (cache / disabled_ref).mkdir()
+            orphan1 = cache / "source_gitea_git.nodebay.top_owner_old_aaaa.git"
+            orphan2 = cache / "target_github_github.com_owner_repo_bbbb.git"
+            orphan1.mkdir()
+            orphan2.mkdir()
+            (cache / "notes.txt").write_text("junk")
+            (cache / "not-a-mirror").mkdir()
+
+            # (b) orphans removed; referenced / disabled-project / junk survive
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+
+        assert not orphan1.exists()
+        assert not orphan2.exists()
+        assert (cache / referenced).is_dir()
+        assert (cache / disabled_ref).is_dir()
+        assert (cache / "notes.txt").read_text() == "junk"
+        assert (cache / "not-a-mirror").is_dir()
+
+        # (c) dry-run never deletes anything
+        (cache / "fresh_orphan_cccc.git").mkdir()
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True, dry_run=True)
+        assert (cache / "fresh_orphan_cccc.git").is_dir()
+
+        # (d) a second clean run removes it; (e) a third has nothing left to do
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+        assert not (cache / "fresh_orphan_cccc.git").exists()
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+    print("  ✓ run: clean_cache removes only unreferenced mirrors")
+
+
+def test_main_clean_cache_flag_passed_to_run():
+    """CLI --clean-cache is forwarded to run()."""
+    from gitacross.cli import main
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cfg = Path(tmp) / "config.yml"
+        _write_local_config(cfg, [{"name": "proj-cli"}])
+        captured = {}
+
+        def _fake_run(*args, **kwargs):
+            captured.update(kwargs)
+            return []
+
+        with mock.patch("gitacross.main.run", side_effect=_fake_run), mock.patch(
+            "sys.argv", ["gitacross", "--config", str(cfg), "--clean-cache"]
+        ):
+            try:
+                main()
+            except SystemExit as e:
+                assert e.code in (0, None), f"expected exit 0, got {e.code}"
+        assert captured.get("clean_cache") is True
+    print("  ✓ cli: --clean-cache flag is forwarded to run()")
+
+
 def test_run_dry_run_passed_through():
     import gitacross
 

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

@@ -248,6 +248,60 @@ def test_create_target_unknown_type():
         assert "Unknown target type" in str(e)
     print("  ✓ target: unknown type rejected")
 
+def test_remote_target_cache_separates_hosts():
+    """Same-named target repos on different hosts get separate mirror caches."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.target import create_target
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    host_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "t"},
+        is_source=False,
+    )
+    host_b = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://gitea.example.com/api/v1", "token": "t"},
+        is_source=False,
+    )
+    same_as_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "other"},
+        is_source=False,
+    )
+
+    mock_apis = []
+    for _cfg in (host_a, host_b, same_as_a):
+        api = mock.MagicMock()
+        api.ensure_repo_exists.return_value = {
+            "clone_url": f"https://{_cfg.host}/{_cfg.repo}.git"
+        }
+        mock_apis.append(api)
+
+    with mock.patch(
+        "gitacross.target.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_target(host_a, "cache")
+        _ = create_target(host_b, "cache")
+        _ = create_target(same_as_a, "cache")
+
+    dest_a, dest_b, dest_same = (Path(d) for _, d in calls)
+    assert "target_gitea_git.nodebay.top_uqkami_Awara_" in str(dest_a)
+    assert "target_gitea_gitea.example.com_uqkami_Awara_" in str(dest_b)
+    for d in (dest_a, dest_b):
+        assert str(d).endswith(".git")
+    assert dest_a != dest_b
+    assert dest_a == dest_same  # same host + repo shares one mirror (dedup)
+    print("  ✓ target: remote target cache dirs are separated per host")
+
+
 def test_remote_target_no_clone_url_raises():
     """A remote target without any clone URL raises a clear error."""
     from gitacross.config import _EndpointConfig