odoo-dev 1.2.3__tar.gz → 1.3.0__tar.gz

odoo_dev-1.3.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.3.0"
+}

{odoo_dev-1.2.3 → odoo_dev-1.3.0}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.3.0](https://github.com/bemade/odoo-dev/compare/v1.2.3...v1.3.0) (2026-09-02)
+
+
+### Features
+
+* **git:** add `odoo-dev git` for ref hygiene and honest merge-state answers ([2983595](https://github.com/bemade/odoo-dev/commit/298359576510e4dace6ac0693c8a8f6b31eee8da))
+* **git:** add `odoo-dev git` for ref hygiene and honest merge-state answers ([626f05e](https://github.com/bemade/odoo-dev/commit/626f05ef1a804275fc0a2b2af2696cca5ca2c03a))
+
 ## [1.2.3](https://github.com/bemade/odoo-dev/compare/v1.2.2...v1.2.3) (2026-09-02)
 
 

{odoo_dev-1.2.3 → odoo_dev-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: odoo-dev
-Version: 1.2.3
+Version: 1.3.0
 Summary: Odoo Development Environment Helper
 Project-URL: Homepage, https://github.com/bemade/odoo-dev
 Project-URL: Repository, https://github.com/bemade/odoo-dev

{odoo_dev-1.2.3 → odoo_dev-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "odoo-dev"
-version = "1.2.3"
+version = "1.3.0"
 description = "Odoo Development Environment Helper"
 readme = "README.md"
 requires-python = ">=3.12"

odoo_dev-1.3.0/src/odoo_dev/__init__.py

@@ -0,0 +1,3 @@
+"""Odoo Development Environment Helper."""
+
+__version__ = "1.3.0"  # x-release-please-version

{odoo_dev-1.2.3 → odoo_dev-1.3.0}/src/odoo_dev/cli.py

@@ -7,6 +7,7 @@ import typer
 from odoo_dev import __version__
 from odoo_dev.commands import bump as bump_cmd
 from odoo_dev.commands import db, docker, run, setup
+from odoo_dev.commands import git as git_cmd
 from odoo_dev.commands import vendor as vendor_cmd
 
 
@@ -42,6 +43,7 @@ def _main(
 app.add_typer(db.app, name="db")
 app.add_typer(docker.app, name="docker")
 app.add_typer(vendor_cmd.app, name="vendor")
+app.add_typer(git_cmd.app, name="git")
 
 # Setup commands
 app.command()(setup.setup)

odoo_dev-1.3.0/src/odoo_dev/commands/git.py

@@ -0,0 +1,345 @@
+"""``odoo-dev git`` — ref hygiene and honest "did this ship?" answers.
+
+Three questions this repeatedly gets wrong in a multi-branch Odoo project, and
+the traps behind each:
+
+**"Is this branch merged?"**  ``git branch --no-merged`` reads *local* refs. A
+local branch that is behind its origin counterpart is reported as merged while
+origin's tip is not, so the local form is the optimistic lie. Always fetch and
+ask against remote refs.
+
+**"Did this feature ship?"**  ``--contains`` / ``--no-merged`` answer a question
+about *object identity*, not content. Anything squashed, cherry-picked or
+re-created reads as unmerged forever even when the code is live. The only
+honest answer diffs the files.
+
+**"What are these stale refs?"**  Per-task clone workflows leave orphaned
+remote-tracking refs behind. ``fetch --prune`` cannot clean them, because there
+is no configured remote left to prune against -- they simply persist, and show
+up in every ref listing as branches that do not exist.
+"""
+
+import subprocess
+from typing import Annotated, Optional
+
+import typer
+
+from odoo_dev.utils.console import error, info, success, warning
+
+app = typer.Typer(
+    name="git", help="Git ref hygiene and merge-state answers.", no_args_is_help=True
+)
+
+
+def _git(*args: str, check: bool = True) -> str:
+    """Run a git command and return stripped stdout."""
+    r = subprocess.run(["git", *args], capture_output=True, text=True)
+    if check and r.returncode != 0:
+        raise RuntimeError((r.stderr or r.stdout).strip())
+    return r.stdout.strip()
+
+
+def _ok(*args: str) -> bool:
+    """True when the git command exits 0 (for --is-ancestor and friends)."""
+    return (
+        subprocess.run(["git", *args], capture_output=True, text=True).returncode == 0
+    )
+
+
+def _configured_remotes() -> set[str]:
+    return {ln for ln in _git("remote").splitlines() if ln}
+
+
+@app.command(name="prune-refs")
+def prune_refs(
+    apply: Annotated[
+        bool, typer.Option("--apply", help="Actually delete. Default is a dry run.")
+    ] = False,
+    namespaces: Annotated[
+        Optional[str],
+        typer.Option(
+            "--namespaces",
+            help="Comma-separated extra ref namespaces to sweep, e.g. 'refs/test,refs/wip'.",
+        ),
+    ] = None,
+) -> None:
+    """Delete remote-tracking refs whose remote no longer exists, plus custom namespaces.
+
+    Per-task clone workflows leave refs like
+    ``refs/remotes/task-3629/feature/...`` behind. ``git fetch --prune`` never
+    removes them: pruning happens per configured remote, and that remote is
+    gone, so nothing owns them. They then show up forever in ref listings and
+    in any script that walks ``refs/remotes``.
+
+    Dry-run by default. Deletion of a ref is not recoverable through the reflog
+    once the objects are gc'd, so nothing is removed without ``--apply``.
+    """
+    remotes = _configured_remotes()
+    if not remotes:
+        error("no configured remotes -- refusing to guess what is stale")
+        raise typer.Exit(2)
+
+    info(f"configured remotes: {', '.join(sorted(remotes))}")
+
+    doomed: list[str] = []
+    for ref in _git("for-each-ref", "--format=%(refname)", "refs/remotes").splitlines():
+        # refs/remotes/<remote>/<branch...>
+        parts = ref.split("/", 3)
+        if len(parts) < 4:
+            continue
+        if parts[2] not in remotes:
+            doomed.append(ref)
+
+    for ns in (n.strip() for n in (namespaces or "").split(",") if n.strip()):
+        doomed.extend(
+            r for r in _git("for-each-ref", "--format=%(refname)", ns).splitlines() if r
+        )
+
+    if not doomed:
+        success("nothing stale -- every ref belongs to a configured remote")
+        return
+
+    warning(f"{len(doomed)} stale ref(s):")
+    for r in doomed:
+        info(f"  {r}")
+
+    if not apply:
+        info("\nDRY RUN -- nothing deleted. Re-run with --apply.")
+        return
+
+    # update-ref requires FULLY-QUALIFIED refnames. It deliberately will not
+    # DWIM-shorten the way checkout/log/branch do, because deleting the wrong
+    # ref is unrecoverable -- so it refuses anything that is not already a
+    # valid ref path rather than guessing the namespace.
+    for r in doomed:
+        _git("update-ref", "-d", r)
+        success(f"deleted {r}")
+    info("\nRun `git gc --prune=now` to reclaim the objects.")
+
+
+@app.command()
+def unmerged(
+    target: Annotated[
+        str, typer.Argument(help="Target branch, e.g. 19.0-prod")
+    ] = "19.0-prod",
+    remote: Annotated[str, typer.Option("--remote", help="Remote name")] = "origin",
+    no_fetch: Annotated[
+        bool, typer.Option("--no-fetch", help="Skip the fetch --prune first")
+    ] = False,
+) -> None:
+    """List remote branches not merged into TARGET, using remote refs only.
+
+    This is the form that tells the truth. ``git branch --no-merged`` consults
+    local refs, which are only as good as your last fetch: a local branch
+    sitting behind its origin counterpart is reported as merged while origin's
+    tip is not, and nothing warns you. That discrepancy is how a stale tip gets
+    merged into a release and quietly drops commits.
+
+    Object identity only, so treat the output as candidates. A squashed or
+    cherry-picked branch appears here forever -- confirm with ``git shipped``.
+    """
+    if not no_fetch:
+        info(f"fetching {remote} --prune ...")
+        _git("fetch", "--prune", "--quiet", remote)
+
+    tgt = f"{remote}/{target}"
+    if not _ok("rev-parse", "--verify", tgt):
+        error(f"{tgt} does not exist")
+        raise typer.Exit(2)
+
+    rows: list[tuple[str, str, str]] = []
+    for line in _git(
+        "for-each-ref",
+        "--format=%(refname:short)%09%(committerdate:short)%09%(authorname)",
+        f"refs/remotes/{remote}",
+    ).splitlines():
+        ref, date, author = (line.split("\t") + ["", ""])[:3]
+        short = ref[len(remote) + 1 :]
+        if short in ("HEAD", target):
+            continue
+        if _ok("merge-base", "--is-ancestor", ref, tgt):
+            continue
+        rows.append((short, date, author))
+
+    if not rows:
+        success(f"every {remote} branch is merged into {target}")
+        return
+
+    warning(f"{len(rows)} branch(es) not merged into {target} (by object identity):")
+    for short, date, author in sorted(rows, key=lambda r: r[1], reverse=True):
+        info(f"  {date}  {short:<52} {author}")
+    info(
+        "\nSquashed/cherry-picked work also lands here. Verify with `odoo-dev git shipped`."
+    )
+
+
+@app.command()
+def shipped(
+    ref: Annotated[str, typer.Argument(help="Branch or commit that may have shipped")],
+    paths: Annotated[
+        Optional[list[str]],
+        typer.Argument(
+            help="Files/dirs to compare. Omit to use the files REF itself changed."
+        ),
+    ] = None,
+    target: Annotated[
+        str, typer.Option("--target", help="Where it should have landed")
+    ] = "origin/19.0-prod",
+    grep: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--grep",
+            help="Marker string that must appear in TARGET's copy. Repeatable. "
+            "This is what actually settles 'did it ship' when paths differ.",
+        ),
+    ] = None,
+) -> None:
+    """Did REF's work reach TARGET? Answered by content, never by ancestry.
+
+    ``--contains`` and ``--no-merged`` compare commit objects, so a squashed,
+    cherry-picked or re-created branch reads as unmerged even when its code is
+    live in production -- and as a result people go looking for "missing"
+    features that shipped months ago.
+
+    With no paths given it derives them -- the files REF itself changed -- which
+    is almost always the right set. It then diffs those between REF and TARGET
+    and reports what actually differs. An empty diff means the content is identical. A non-empty diff is
+    not proof of absence either: the target may simply have moved on since,
+    which is why the per-path detail is printed rather than a verdict.
+    """
+    for r in (ref, target):
+        if not _ok("rev-parse", "--verify", r):
+            error(f"{r} does not exist")
+            raise typer.Exit(2)
+
+    # Ancestry is ASYMMETRIC evidence, which is the whole subtlety here.
+    #
+    #   True  -> conclusive. Every commit in REF is reachable from TARGET, so
+    #            the work is there by definition. A content diff can only muddy
+    #            a settled answer, because the target may have moved on and
+    #            "differs" would then read as doubt.
+    #   False -> proves nothing. Squashed, cherry-picked or re-created work is
+    #            never an ancestor even when it is live in production. Fall
+    #            through to content, which is the only honest test.
+    is_ancestor = _ok("merge-base", "--is-ancestor", ref, target)
+
+    if is_ancestor:
+        success(
+            f"{ref} IS an ancestor of {target} -- every commit is reachable, "
+            f"so this work shipped."
+        )
+        if not grep:
+            info("  Ancestry is conclusive in this direction; no content check needed.")
+            return
+        # `--grep` is an explicit content question, so honour it anyway: the
+        # caller may be checking that a marker SURVIVED, not merely that the
+        # commits landed. Reachable does not mean un-reverted.
+        info(
+            "  Ancestry settles reachability; checking your markers anyway, "
+            "since a later commit can still have removed them."
+        )
+    else:
+        info(f"ancestry: {ref} is NOT an ancestor of {target}")
+        info("  (proves nothing on its own -- content below is what counts)")
+
+    # Deriving the paths is almost always what you want: git already knows
+    # which files REF touched, and naming them by hand risks checking the wrong
+    # ones. A whole-tree path such as `.` always differs against a target that
+    # has moved on, which cannot distinguish "did not ship" from "shipped, then
+    # the repo continued".
+    if not paths:
+        if is_ancestor:
+            # merge-base(REF, TARGET) == REF here, so that diff is empty by
+            # construction. What REF *introduced* is the diff against its first
+            # parent -- which for a merge commit is the branch it merged in.
+            spec = (f"{ref}^1", ref)
+        else:
+            base = _git("merge-base", ref, target, check=False)
+            if not base:
+                error(
+                    f"no common ancestor between {ref} and {target} -- pass paths explicitly"
+                )
+                raise typer.Exit(2)
+            spec = (base, ref)
+        paths = [
+            p for p in _git("diff", "--name-only", *spec, check=False).splitlines() if p
+        ]
+        if not paths:
+            success(f"{ref} changes no files -- nothing to compare.")
+            return
+        info(
+            f"comparing the {len(paths)} file(s) {ref} changed "
+            f"(derived; pass paths to override)"
+        )
+    elif any(p in (".", "./", "") for p in paths):
+        warning(
+            "  '.' compares the entire tree and will always differ -- omit the "
+            "path argument to compare only what REF changed."
+        )
+
+    identical, differs, missing = [], [], []
+    for p in paths:
+        in_ref = _ok("cat-file", "-e", f"{ref}:{p}")
+        in_tgt = _ok("cat-file", "-e", f"{target}:{p}")
+        if in_ref and not in_tgt:
+            missing.append(p)
+        elif not _git("diff", "--name-only", ref, target, "--", p, check=False):
+            identical.append(p)
+        else:
+            differs.append(p)
+
+    for p in identical:
+        success(f"  identical   {p}")
+    for p in differs:
+        warning(f"  differs     {p}")
+    for p in missing:
+        error(f"  ABSENT from {target}: {p}")
+
+    # Markers are the decisive test when paths differ. A file that has moved on
+    # still contains the feature's fingerprints if the feature shipped; if the
+    # markers are gone, the work was reverted or never landed.
+    missing_markers: list[str] = []
+    if grep:
+        info("")
+        for pat in grep:
+            hits = 0
+            for p in paths:
+                if not _ok("cat-file", "-e", f"{target}:{p}"):
+                    continue
+                body = _git("show", f"{target}:{p}", check=False)
+                hits += sum(1 for ln in body.splitlines() if pat in ln)
+            if hits:
+                success(f"  marker present in {target}: {pat!r} ({hits} line(s))")
+            else:
+                error(f"  marker ABSENT from {target}: {pat!r}")
+                missing_markers.append(pat)
+
+    if missing:
+        info(
+            "\nPaths absent from the target are the real signal -- that work did not ship."
+        )
+        raise typer.Exit(1)
+    if missing_markers:
+        info(
+            "\nMarkers absent -- this work is NOT in the target, whatever ancestry says."
+        )
+        raise typer.Exit(1)
+    if grep and differs:
+        if is_ancestor:
+            success(
+                "\nPaths differ because the target moved on, but every marker "
+                "survived: the work is reachable AND still present."
+            )
+        else:
+            success(
+                "\nPaths differ but every marker is present: the work SHIPPED and "
+                "the target has since moved on. This is exactly the case ancestry "
+                "reports wrongly."
+            )
+        return
+    if differs:
+        info("\nDiffering paths may just mean the target moved on. Inspect with:")
+        for p in differs:
+            info(f"  git diff {ref} {target} -- {p}")
+    else:
+        success("\nEvery path matches -- this work is present in the target.")

odoo_dev-1.3.0/tests/test_git_hygiene.py

@@ -0,0 +1,279 @@
+"""Tests for ``odoo-dev git``.
+
+These build real throwaway repos rather than mocking git: every bug this
+command exists to prevent is a bug about what git actually reports, so a mock
+would test the assumption instead of the behaviour.
+"""
+
+import subprocess
+
+import pytest
+from typer.testing import CliRunner
+
+from odoo_dev.cli import app
+
+runner = CliRunner()
+
+
+def _run(*args, cwd):
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
+@pytest.fixture()
+def repo(tmp_path, monkeypatch):
+    """An origin plus a clone, with one commit on the default branch."""
+    origin = tmp_path / "origin.git"
+    work = tmp_path / "work"
+    _run("init", "--bare", "-b", "main", str(origin), cwd=tmp_path)
+    _run("clone", str(origin), str(work), cwd=tmp_path)
+    for k, v in (("user.email", "t@example.com"), ("user.name", "T")):
+        _run("config", k, v, cwd=work)
+    (work / "feature.py").write_text("MARKER_ALPHA = 1\n")
+    _run("add", "-A", cwd=work)
+    _run("commit", "-m", "feat: alpha", cwd=work)
+    _run("push", "-u", "origin", "main", cwd=work)
+    monkeypatch.chdir(work)
+    return work
+
+
+def test_prune_refs_is_dry_by_default(repo):
+    """A stale ref is reported but survives without --apply."""
+    _run("update-ref", "refs/remotes/task-999/feature/x", "HEAD", cwd=repo)
+    res = runner.invoke(app, ["git", "prune-refs"])
+    assert res.exit_code == 0
+    assert "task-999" in res.stdout
+    assert "DRY RUN" in res.stdout
+    # still there
+    out = subprocess.run(
+        ["git", "for-each-ref", "--format=%(refname)", "refs/remotes"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout
+    assert "task-999" in out
+
+
+def test_prune_refs_apply_removes_only_orphans(repo):
+    """--apply deletes the orphaned ref and leaves origin's refs untouched."""
+    _run("update-ref", "refs/remotes/task-999/feature/x", "HEAD", cwd=repo)
+    res = runner.invoke(app, ["git", "prune-refs", "--apply"])
+    assert res.exit_code == 0
+    out = subprocess.run(
+        ["git", "for-each-ref", "--format=%(refname)", "refs/remotes"],
+        cwd=repo,
+        capture_output=True,
+        text=True,
+    ).stdout
+    assert "task-999" not in out
+    assert "refs/remotes/origin/main" in out
+
+
+def test_shipped_sees_reapplied_work_that_ancestry_misses(repo):
+    """The whole point: same content, different SHA -> ancestry lies, content does not."""
+    # Branch off and add the feature there.
+    _run("checkout", "-b", "side", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_BETA = 2\n")
+    _run("commit", "-am", "feat: beta", cwd=repo)
+    side = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+
+    # Re-apply the SAME content on main as an independent commit (what a squash
+    # merge or a manual re-application produces), then move main on afterwards
+    # so the two histories genuinely diverge.
+    _run("checkout", "main", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_BETA = 2\n")
+    _run("commit", "-am", "feat: beta (reapplied)", cwd=repo)
+    # main then moves on *within the same file* -- the real-world shape, where
+    # the feature shipped months ago and the file has been edited since.
+    (repo / "feature.py").write_text(
+        "MARKER_ALPHA = 1\nMARKER_BETA = 2\nadded_later = True\n"
+    )
+    _run("commit", "-am", "chore: main moves on", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    # Ancestry says the side commit never landed...
+    assert (
+        subprocess.run(
+            ["git", "merge-base", "--is-ancestor", side, "origin/main"],
+            cwd=repo,
+            capture_output=True,
+        ).returncode
+        != 0
+    )
+    # ...but the marker is present, so shipped() must report SHIPPED.
+    res = runner.invoke(
+        app,
+        [
+            "git",
+            "shipped",
+            side,
+            "feature.py",
+            "--target",
+            "origin/main",
+            "--grep",
+            "MARKER_BETA",
+        ],
+    )
+    assert res.exit_code == 0
+    assert "SHIPPED" in res.stdout
+    assert "differs" in res.stdout
+
+
+def test_shipped_reports_identical_paths_without_needing_markers(repo):
+    """Byte-identical content is a sufficient answer when ancestry does not apply."""
+    _run("checkout", "-b", "twin", cwd=repo)
+    (repo / "note.txt").write_text("unrelated\n")  # diverge without touching feature.py
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "chore: diverge", cwd=repo)
+    twin = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+    _run("checkout", "main", cwd=repo)
+    res = runner.invoke(
+        app, ["git", "shipped", twin, "feature.py", "--target", "origin/main"]
+    )
+    assert res.exit_code == 0
+    assert "identical" in res.stdout
+
+
+def test_shipped_short_circuits_when_ancestry_is_conclusive(repo):
+    """A true ancestry answer is proof; it must not fall through to a diff.
+
+    Regression: comparing HEAD (already an ancestor) against a moved-on target
+    reported "differs", which reads as doubt about something already settled.
+    """
+    _run("checkout", "-b", "later", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nmoved_on = True\n")
+    _run("commit", "-am", "chore: target moves on", cwd=repo)
+    _run("push", "origin", "later", cwd=repo)
+    _run("checkout", "main", cwd=repo)
+
+    res = runner.invoke(
+        app, ["git", "shipped", "HEAD", "feature.py", "--target", "origin/later"]
+    )
+    assert res.exit_code == 0
+    assert "shipped" in res.stdout
+    assert "differs" not in res.stdout
+
+
+def test_shipped_warns_that_a_whole_tree_path_is_uninformative(repo):
+    """'.' always differs against a moved-on target, so say so rather than imply doubt."""
+    _run("checkout", "-b", "side2", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nbeta = 2\n")
+    _run("commit", "-am", "feat: side2", cwd=repo)
+    side = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+    _run("checkout", "main", cwd=repo)
+    (repo / "other.py").write_text("z = 1\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "chore: diverge", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    res = runner.invoke(app, ["git", "shipped", side, ".", "--target", "origin/main"])
+    assert "entire tree" in res.stdout
+
+
+def test_shipped_derives_paths_when_none_are_given(repo):
+    """Omitting paths must compare exactly the files REF changed."""
+    # Pre-existing file on BOTH sides: derivation must ignore it, because REF
+    # does not change it.
+    (repo / "untouched.py").write_text("irrelevant = True\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "chore: unrelated file", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    _run("checkout", "-b", "derive", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_GAMMA = 3\n")
+    _run("commit", "-am", "feat: gamma", cwd=repo)
+    ref = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+    _run("checkout", "main", cwd=repo)
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_GAMMA = 3\nlater = 1\n")
+    _run("commit", "-am", "chore: main moves on", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    res = runner.invoke(
+        app,
+        ["git", "shipped", ref, "--target", "origin/main", "--grep", "MARKER_GAMMA"],
+    )
+    assert res.exit_code == 0
+    assert "derived" in res.stdout
+    assert "comparing the 1 file(s)" in res.stdout
+    assert "feature.py" in res.stdout
+    assert "untouched.py" not in res.stdout
+
+
+def test_shipped_derives_paths_for_an_ancestor_ref(repo):
+    """For an ancestor, merge-base==REF, so paths come from REF's first parent."""
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_DELTA = 4\n")
+    _run("commit", "-am", "feat: delta", cwd=repo)
+    ref = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_DELTA = 4\nafter = 1\n")
+    _run("commit", "-am", "chore: after", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    res = runner.invoke(
+        app,
+        ["git", "shipped", ref, "--target", "origin/main", "--grep", "MARKER_DELTA"],
+    )
+    assert res.exit_code == 0
+    # Derivation must not collapse to "nothing to compare" for an ancestor.
+    assert "nothing to compare" not in res.stdout
+    assert "feature.py" in res.stdout
+
+
+def test_shipped_flags_a_marker_reverted_after_it_landed(repo):
+    """Reachable is not the same as still present -- a later revert must fail."""
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\nMARKER_EPSILON = 5\n")
+    _run("commit", "-am", "feat: epsilon", cwd=repo)
+    ref = subprocess.run(
+        ["git", "rev-parse", "HEAD"], cwd=repo, capture_output=True, text=True
+    ).stdout.strip()
+    (repo / "feature.py").write_text("MARKER_ALPHA = 1\n")  # reverted later
+    _run("commit", "-am", "revert: drop epsilon", cwd=repo)
+    _run("push", "origin", "main", cwd=repo)
+
+    res = runner.invoke(
+        app,
+        ["git", "shipped", ref, "--target", "origin/main", "--grep", "MARKER_EPSILON"],
+    )
+    assert res.exit_code == 1
+    assert "ABSENT" in res.stdout
+
+
+def test_shipped_fails_when_the_marker_never_landed(repo):
+    """A marker absent from the target is a real negative, and exits non-zero."""
+    res = runner.invoke(
+        app,
+        [
+            "git",
+            "shipped",
+            "HEAD",
+            "feature.py",
+            "--target",
+            "origin/main",
+            "--grep",
+            "MARKER_NEVER",
+        ],
+    )
+    assert res.exit_code == 1
+    assert "ABSENT" in res.stdout
+
+
+def test_unmerged_reads_remote_refs_not_stale_local_ones(repo):
+    """The bug this exists for: a stale local ref makes a branch look merged."""
+    _run("checkout", "-b", "wip", cwd=repo)
+    (repo / "other.py").write_text("x = 1\n")
+    _run("add", "-A", cwd=repo)
+    _run("commit", "-m", "feat: wip", cwd=repo)
+    _run("push", "-u", "origin", "wip", cwd=repo)
+    _run("checkout", "main", cwd=repo)
+
+    res = runner.invoke(app, ["git", "unmerged", "main", "--no-fetch"])
+    assert res.exit_code == 0
+    assert "wip" in res.stdout

odoo_dev-1.2.3/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "1.2.3"
-}

odoo_dev-1.2.3/src/odoo_dev/__init__.py

@@ -1,3 +0,0 @@
-"""Odoo Development Environment Helper."""
-
-__version__ = "1.2.3"  # x-release-please-version