replico 0.2.0__tar.gz → 0.2.3__tar.gz

{replico-0.2.0 → replico-0.2.3}/.github/workflows/ci.yml

@@ -28,9 +28,10 @@ jobs:
       - name: Test (offline suite, mocked GitHub)
         run: python -m pytest -q
         env:
-          # Never reach out to the network during tests.
+          # Never reach out to the network during tests. GitHub Actions env
+          # names are case-insensitive, so a lowercase `no_proxy` twin of
+          # `NO_PROXY` would be rejected as a duplicate key.
           NO_PROXY: "*"
-          no_proxy: "*"
 
   quality:
     name: lint + types

{replico-0.2.0 → replico-0.2.3}/.gitignore

@@ -34,3 +34,6 @@ Thumbs.db
 
 # Scratch / probe files
 _probe_*.py
+
+# Agent tooling state
+.freebuff/

{replico-0.2.0 → replico-0.2.3}/CHANGELOG.md

@@ -4,6 +4,56 @@ All notable changes to Replico are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and semantic
 versioning (see [pyproject.toml](pyproject.toml)).
 
+## [0.2.3] - 2026-09-05
+
+Cross-platform fixes found by running Replico's own CI (the v0.2.1 CI
+matrix shook out three real bugs that only appear on Linux runners).
+
+### Fixed
+
+- **Python `'3'` requests now match any Python 3.x** — a workflow with
+  `python-version: '3'` (or `'3.x'`) reported `matches_request=False` for
+  every local interpreter, which made `_pick_isolation` wrongly force
+  Docker when Docker was available (e.g. on Ubuntu runners) and skip the
+  local venv + WhyFail diagnosis. Requests are now matched like
+  setup-python: a bare major matches any same-major version.
+- **`replico reproduce` no longer targets `$GITHUB_RUN_ID`** — when run
+  inside GitHub Actions (where `GITHUB_RUN_ID` is set), a bare
+  `replico reproduce` silently reproduced the ambient CI run instead of
+  reporting "missing run". Only the explicit `replico run` command reads
+  the environment fallback now.
+- **Regression tests** for both, plus the `rep` alias test from 0.2.2
+  upstreamed into the CLI suite.
+
+## [0.2.2] - 2026-09-05
+
+### Added
+
+- **`rep` console-script alias** — `rep` is now installed as a real
+  binary next to `replico` and accepts exactly the same commands
+  (`rep <run-url>`, `rep diagnose`, `rep rerun`, …). Zero behavior
+  differences; only a shorter command name.
+
+## [0.2.1] - 2026-09-05
+
+Bug fixes discovered by dogfooding Replico end to end and by running
+Replico's own CI.
+
+### Fixed
+
+- **`replico rerun` verdict** — the previously reproduced failure was
+  misreported as "a different failure now occurs locally" when CI logs
+  were not accessible (no token) and the workflow had no pytest tests.
+  Rerun now compares the fresh WhyFail diagnosis against the saved one
+  (exception type + message or file/function location) and reports
+  `REPRODUCED` with the matching failure signature (`KeyError at
+  failure.py in load`) when they agree.
+- **Replico's own CI workflow** — GitHub Actions rejects duplicate env
+  names case-insensitively, so `NO_PROXY` + `no_proxy` made the whole
+  workflow fail validation with zero jobs started. Removed the lowercase
+  duplicate. This is the first real self-dogfooding fix: our CI failed,
+  and the failure was found by inspecting the failed run.
+
 ## [0.2.0] - 2026-09-04
 
 WhyFail integration: reproduced Python failures are now diagnosed locally

{replico-0.2.0 → replico-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: replico
-Version: 0.2.0
+Version: 0.2.3
 Summary: Turn GitHub Actions CI failures into locally reproducible failures.
 Author: Samarth Chugh (Sam3360)
 License: MIT License
@@ -101,7 +101,7 @@ Developer pushes code        →  CI fails  →  Developer reads logs
 ```text
 GitHub Actions fails
         ↓
-replico <run-url>                    # or: replico run <run-id>
+replico <run-url>                    # or: replico run <run-id>; `rep` works too
         ↓
 Analyze the failed workflow
         ↓

{replico-0.2.0 → replico-0.2.3}/README.md

@@ -44,7 +44,7 @@ Developer pushes code        →  CI fails  →  Developer reads logs
 ```text
 GitHub Actions fails
         ↓
-replico <run-url>                    # or: replico run <run-id>
+replico <run-url>                    # or: replico run <run-id>; `rep` works too
         ↓
 Analyze the failed workflow
         ↓

replico-0.2.3/logs.zip

@@ -0,0 +1,5 @@
+{
+  "message": "Not Found",
+  "documentation_url": "https://docs.github.com/rest/actions/workflow-runs#download-workflow-run-logs",
+  "status": "404"
+}

{replico-0.2.0 → replico-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "replico"
-version = "0.2.0"
+version = "0.2.3"
 description = "Turn GitHub Actions CI failures into locally reproducible failures."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -57,6 +57,7 @@ dev = [
 
 [project.scripts]
 replico = "replico.cli:main"
+rep = "replico.cli:rep_main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/replico"]

{replico-0.2.0 → replico-0.2.3}/src/replico/__init__.py

@@ -4,4 +4,4 @@ Replico turns a failed GitHub Actions run into a locally reproducible
 failure whenever it can reconstruct the relevant conditions.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.3"

{replico-0.2.0 → replico-0.2.3}/src/replico/analysis/whyfail_adapter.py

@@ -146,6 +146,82 @@ def primary_confidence(diagnostics: list[DiagnosisEntry]) -> str | None:
     return cause.get("confidence")
 
 
+# ---------------------------------------------------------------------------
+# Failure signatures (comparing diagnoses across runs)
+# ---------------------------------------------------------------------------
+
+
+def _normalized_diagnostic(raw: Any) -> dict[str, Any] | None:
+    """Accept either a CLI entry ``{"context", "diagnostic"}`` or a bare
+    diagnostic dict and return the inner diagnostic (or None)."""
+    if isinstance(raw, dict) and isinstance(raw.get("diagnostic"), dict):
+        return raw["diagnostic"]
+    return raw if isinstance(raw, dict) else None
+
+
+def failure_signatures(diagnostics: list[Any]) -> list[dict[str, Any]]:
+    """Compact identity of each diagnosed failure: exception type plus
+    message and user-code location. Used to recognize when a re-run hits
+    the *same* failure as a previous diagnosis."""
+    signatures: list[dict[str, Any]] = []
+    for raw in diagnostics or []:
+        diagnostic = _normalized_diagnostic(raw)
+        if diagnostic is None:
+            continue
+        exception_type = diagnostic.get("exception_type")
+        if not exception_type:
+            continue
+        location = diagnostic.get("location") or {}
+        signatures.append(
+            {
+                "exception_type": str(exception_type),
+                "message": diagnostic.get("message"),
+                "filename": location.get("filename"),
+                "function": location.get("function"),
+            }
+        )
+    return signatures
+
+
+def matching_signatures(
+    fresh: list[dict[str, Any]], saved: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """Signatures from ``fresh`` that also occur in ``saved``.
+
+    Two signatures describe the same failure when the exception type matches
+    and either the message or the file+function location agrees — tolerant
+    of small line shifts, but refusing to conflate different failures.
+    """
+    matches: list[dict[str, Any]] = []
+    for sig in fresh:
+        for other in saved:
+            if sig.get("exception_type") != other.get("exception_type"):
+                continue
+            same_message = sig.get("message") is not None and sig.get("message") == other.get(
+                "message"
+            )
+            same_place = (
+                sig.get("filename") is not None
+                and sig.get("filename") == other.get("filename")
+                and sig.get("function") == other.get("function")
+            )
+            if same_message or same_place:
+                matches.append(sig)
+                break
+    return matches
+
+
+def signature_label(sig: dict[str, Any]) -> str:
+    """Human-readable one-liner for a failure signature."""
+    label = str(sig.get("exception_type") or "unknown exception")
+    filename = sig.get("filename")
+    if filename:
+        label += f" at {filename}"
+        if sig.get("function"):
+            label += f" in {sig['function']}"
+    return label
+
+
 # ---------------------------------------------------------------------------
 # Availability
 # ---------------------------------------------------------------------------

{replico-0.2.0 → replico-0.2.3}/src/replico/cli.py

@@ -304,8 +304,11 @@ def _run(argv: list[str]) -> int:
                 outcome = rerun(ctx, options)
             else:
                 target = getattr(args, "target", None)
-                if target is None:
-                    # `replico run` may read the run id from the environment.
+                if target is None and command == "run":
+                    # Only the explicit `replico run` command reads the run id
+                    # from the environment (for reproducing a CI job's own run
+                    # from inside a workflow step). A bare `replico reproduce`
+                    # must never silently target `$GITHUB_RUN_ID`.
                     target = _env_run_id()
                 if target is None:
                     raise InvalidInputError(
@@ -383,5 +386,14 @@ def main(argv: list[str] | None = None) -> int:
         return EXIT_INTERNAL
 
 
+def rep_main(argv: list[str] | None = None) -> int:
+    """Entry point for the ``rep`` console-script alias of ``replico``.
+
+    Identical to :func:`main`; the two are separate entry points only so
+    that both ``replico`` and ``rep`` can be installed as console scripts.
+    """
+    return main(argv)
+
+
 if __name__ == "__main__":
     raise SystemExit(main())

{replico-0.2.0 → replico-0.2.3}/src/replico/environments/python.py

@@ -39,6 +39,31 @@ def parse_python_request(text: str) -> str | None:
     return f"{major}.{minor}" if minor else major
 
 
+def _matches_request(version: tuple[int, int, int], requested: str | None) -> bool:
+    """Whether an installed version satisfies a CI python-version request.
+
+    * ``'3'``/``'3.x'`` matches any Python 3.x (GitHub's setup-python semantics).
+    * ``'3.12'`` matches exactly (major, minor).
+    * ``'>=3.12'`` etc. is treated as a loose floor (best effort).
+    """
+    if requested is None:
+        return False
+    text = requested.strip().lower()
+    op_match = re.match(r"^(>=|~=|==)?\s*(\d+)(?:\.(\d+))?", text)
+    if not op_match:
+        return False
+    op = op_match.group(1) or "=="
+    major = int(op_match.group(2))
+    minor = op_match.group(3)
+    if minor is None or minor.lower() in ("x", "*"):
+        # Major-only request: any same-major satisfies it.
+        return version[0] == major
+    minor_i = int(minor)
+    if op == ">=":
+        return (version[0], version[1]) >= (major, minor_i)
+    return (version[0], version[1]) == (major, minor_i)
+
+
 def probe_python_version(executable: str) -> tuple[int, int, int] | None:
     """Return the version of a python executable, or None on any failure."""
     try:
@@ -95,7 +120,7 @@ def find_python(request: str | None) -> PythonRuntime:
         version = probe_python_version(path)
         if version is None:
             continue
-        match = bool(target and version[:2] == target)
+        match = _matches_request(version, requested)
         if runtime is None or match:
             runtime = PythonRuntime(
                 executable=path, version=version, how=f"found {name} on PATH", matches_request=match
@@ -118,7 +143,7 @@ def find_python(request: str | None) -> PythonRuntime:
                         executable=f"{py_launcher} {flag}",
                         version=version,
                         how=f"py launcher {flag}",
-                        matches_request=bool(target and version[:2] == target),
+                        matches_request=_matches_request(version, requested),
                     )
                     if candidate.matches_request:
                         return candidate

{replico-0.2.0 → replico-0.2.3}/src/replico/flows.py

@@ -16,10 +16,13 @@ from replico.analysis import classifier as clsf
 from replico.analysis.whyfail_adapter import (
     WhyFailResult,
     describe_reason,
+    failure_signatures,
     find_python_invocation,
+    matching_signatures,
     render_diagnosis,
     run_diagnosis,
     should_diagnose,
+    signature_label,
     whyfail_available,
 )
 from replico.config import Config
@@ -444,6 +447,36 @@ def rerun(ctx: AppContext, options: ReproOptions) -> Outcome:
     ci_category = (payload.get("classification") or {}).get("category")
     now_failed = not result.ok
     local_tests = local_evidence.failing_tests
+
+    # -- diagnosis (WhyFail) ---------------------------------------------------
+    # Run before the verdict: for Python failures, comparing the fresh
+    # diagnosis against the saved one is the strongest evidence of whether
+    # the *same* failure still reproduces (test names and CI log categories
+    # are unavailable when CI logs were not accessible).
+    whyfail_result: WhyFailResult | None = None
+    whyfail_reason = ""
+    if now_failed or options.diagnose is True:
+        plan["target_entries"] = [target]
+        plan["cwd"] = _cwd_for(ctx, target)
+        whyfail_result, whyfail_reason = attempt_local_diagnosis(
+            ctx,
+            ecosystems=["python"] if plan.get("venv") else [],
+            plan=plan,
+            local_failed=now_failed,
+            flag=options.diagnose,
+        )
+    else:
+        whyfail_reason = "no_local_failure"
+
+    fresh_signatures: list[dict] = []
+    saved_signatures: list[dict] = []
+    same_diagnosis: list[dict] = []
+    if whyfail_result is not None and whyfail_result.diagnosed:
+        fresh_signatures = failure_signatures(whyfail_result.diagnostics)
+        saved_doc = ctx.store.read_whyfail() or {}
+        saved_signatures = failure_signatures(saved_doc.get("diagnostics") or [])
+        same_diagnosis = matching_signatures(fresh_signatures, saved_signatures)
+
     matched = sorted(set(ci_tests) & set(local_tests))
 
     if not now_failed:
@@ -460,7 +493,14 @@ def rerun(ctx: AppContext, options: ReproOptions) -> Outcome:
         same_category = bool(ci_category) and (
             clsf.classify(local_evidence).category == ci_category
         )
-        if not ci_tests and same_category:
+        if same_diagnosis:
+            verdict = Verdict.REPRODUCED
+            headline = "The reproduced failure still exists locally."
+            reasons = [
+                "the same diagnosed failure still occurs locally: "
+                + ", ".join(signature_label(s) for s in same_diagnosis)
+            ]
+        elif not ci_tests and same_category:
             verdict = Verdict.REPRODUCED
             headline = "A failure matching CI still occurs locally."
             reasons = [f"failure category {ci_category} still reproduces"]
@@ -468,6 +508,14 @@ def rerun(ctx: AppContext, options: ReproOptions) -> Outcome:
             verdict = Verdict.PARTIALLY_REPRODUCED
             headline = "A different failure now occurs locally."
             reasons = ["the previously reproduced failure appears to be gone"]
+            if fresh_signatures and saved_signatures:
+                reasons.append(
+                    "previously diagnosed: "
+                    + ", ".join(signature_label(s) for s in saved_signatures)
+                )
+                reasons.append(
+                    "now diagnosed: " + ", ".join(signature_label(s) for s in fresh_signatures)
+                )
             if local_tests:
                 reasons.append("still failing locally: " + ", ".join(local_tests))
             if ci_tests:
@@ -477,26 +525,11 @@ def rerun(ctx: AppContext, options: ReproOptions) -> Outcome:
     ui.section("Local result")
     _render_local_result(ui, result, local_evidence)
 
-    # -- diagnosis (WhyFail) ---------------------------------------------------
-    whyfail_result: WhyFailResult | None = None
-    whyfail_reason = ""
-    if now_failed or options.diagnose is True:
-        plan["target_entries"] = [target]
-        plan["cwd"] = _cwd_for(ctx, target)
-        whyfail_result, whyfail_reason = attempt_local_diagnosis(
-            ctx,
-            ecosystems=["python"] if plan.get("venv") else [],
-            plan=plan,
-            local_failed=now_failed,
-            flag=options.diagnose,
-        )
-        if whyfail_result is not None:
-            ui.section("WhyFail diagnosis")
-            render_diagnosis(ui, whyfail_result)
-        elif options.diagnose is True:
-            ui.warn(f"WhyFail diagnosis skipped: {describe_reason(whyfail_reason)}")
-    else:
-        whyfail_reason = "no_local_failure"
+    if whyfail_result is not None:
+        ui.section("WhyFail diagnosis")
+        render_diagnosis(ui, whyfail_result)
+    elif options.diagnose is True:
+        ui.warn(f"WhyFail diagnosis skipped: {describe_reason(whyfail_reason)}")
 
     ui.rule()
     ui.out(_result_banner(verdict), style=_style_for(verdict))
@@ -522,6 +555,10 @@ def rerun(ctx: AppContext, options: ReproOptions) -> Outcome:
             "reason": whyfail_result.reason,
             "summary": whyfail_result.summary(),
         }
+        if same_diagnosis:
+            rerun_entry["diagnosis"]["same_as_saved"] = [signature_label(s) for s in same_diagnosis]
+        if same_diagnosis:
+            rerun_entry["diagnosis"]["same_as_saved"] = [signature_label(s) for s in same_diagnosis]
     reruns.append(rerun_entry)
     payload["reruns"] = reruns
     whyfail_doc = _whyfail_payload_doc(whyfail_result, whyfail_reason)

{replico-0.2.0 → replico-0.2.3}/tests/test_cli.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 
-from replico.cli import main
+from replico.cli import main, rep_main
 
 
 def test_version(capsys):
@@ -18,6 +18,14 @@ def test_version_command(capsys):
     assert capsys.readouterr().out.startswith("replico ")
 
 
+def test_rep_alias(capsys):
+    """`rep` is a real console-script alias of `replico`."""
+    assert rep_main(["--version"]) == 0
+    assert capsys.readouterr().out.startswith("replico ")
+    assert rep_main(["version"]) == 0
+    assert capsys.readouterr().out.startswith("replico ")
+
+
 def test_help(capsys):
     assert main(["help"]) == 0
     assert "reproduce" in capsys.readouterr().out
@@ -48,6 +56,19 @@ def test_missing_target_exit_3(capsys):
     assert "missing run" in capsys.readouterr().out
 
 
+def test_reproduce_without_target_ignores_ambient_ci_run(capsys, monkeypatch):
+    """A bare `replico reproduce` must not silently target $GITHUB_RUN_ID.
+
+    Regression for a bug where running inside GitHub Actions (where
+    GITHUB_RUN_ID is set) made `replico reproduce` with no target target the
+    ambient CI run instead of reporting a missing run.
+    """
+    monkeypatch.setenv("GITHUB_REPOSITORY", "octocat/demo")
+    monkeypatch.setenv("GITHUB_RUN_ID", "123456789")
+    assert main(["reproduce"]) == 3
+    assert "missing run" in capsys.readouterr().out
+
+
 def test_invalid_url_exit_3(capsys):
     assert main(["https://example.com/not-a-run"]) == 3
 

replico-0.2.0/.freebuff/project-id

@@ -1 +0,0 @@
-49c8c90f-46e1-4c45-a454-0861ed60b128