codeclone 1.4.2__tar.gz → 1.4.3__tar.gz

{codeclone-1.4.2 → codeclone-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeclone
-Version: 1.4.2
+Version: 1.4.3
 Summary: AST and CFG-based code clone detector for Python focused on architectural duplication
 Author-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
 Maintainer-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
@@ -158,12 +158,12 @@ Full contract details: [`docs/book/06-baseline.md`](docs/book/06-baseline.md)
 
 CodeClone uses a deterministic exit code contract:
 
-| Code | Meaning                                                                     |
-|------|-----------------------------------------------------------------------------|
-| `0`  | Success — run completed without gating failures                             |
+| Code | Meaning                                                                                                                             |
+|------|-------------------------------------------------------------------------------------------------------------------------------------|
+| `0`  | Success — run completed without gating failures                                                                                     |
 | `2`  | Contract error — baseline missing/untrusted, invalid output extensions, incompatible versions, unreadable source files in CI/gating |
-| `3`  | Gating failure — new clones detected or threshold exceeded                  |
-| `5`  | Internal error — unexpected exception                                       |
+| `3`  | Gating failure — new clones detected or threshold exceeded                                                                          |
+| `5`  | Internal error — unexpected exception                                                                                               |
 
 **Priority:** Contract errors (`2`) override gating failures (`3`) when both occur.
 
@@ -223,7 +223,7 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
     "cache_path": "/path/to/.cache/codeclone/cache.json",
     "cache_used": true,
     "cache_status": "ok",
-    "cache_schema_version": "1.2",
+    "cache_schema_version": "1.3",
     "files_skipped_source_io": 0,
     "groups_counts": {
       "functions": {
@@ -304,7 +304,8 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
 Cache is an optimization layer only and is never a source of truth.
 
 - Default path: `<root>/.cache/codeclone/cache.json`
-- Schema version: **v1.2**
+- Schema version: **v1.3**
+- Compatibility includes analysis profile (`min_loc`, `min_stmt`)
 - Invalid or oversized cache is ignored with warning and rebuilt (fail-open)
 
 Full contract details: [`docs/book/07-cache.md`](docs/book/07-cache.md)

{codeclone-1.4.2 → codeclone-1.4.3}/README.md

@@ -117,12 +117,12 @@ Full contract details: [`docs/book/06-baseline.md`](docs/book/06-baseline.md)
 
 CodeClone uses a deterministic exit code contract:
 
-| Code | Meaning                                                                     |
-|------|-----------------------------------------------------------------------------|
-| `0`  | Success — run completed without gating failures                             |
+| Code | Meaning                                                                                                                             |
+|------|-------------------------------------------------------------------------------------------------------------------------------------|
+| `0`  | Success — run completed without gating failures                                                                                     |
 | `2`  | Contract error — baseline missing/untrusted, invalid output extensions, incompatible versions, unreadable source files in CI/gating |
-| `3`  | Gating failure — new clones detected or threshold exceeded                  |
-| `5`  | Internal error — unexpected exception                                       |
+| `3`  | Gating failure — new clones detected or threshold exceeded                                                                          |
+| `5`  | Internal error — unexpected exception                                                                                               |
 
 **Priority:** Contract errors (`2`) override gating failures (`3`) when both occur.
 
@@ -182,7 +182,7 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
     "cache_path": "/path/to/.cache/codeclone/cache.json",
     "cache_used": true,
     "cache_status": "ok",
-    "cache_schema_version": "1.2",
+    "cache_schema_version": "1.3",
     "files_skipped_source_io": 0,
     "groups_counts": {
       "functions": {
@@ -263,7 +263,8 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
 Cache is an optimization layer only and is never a source of truth.
 
 - Default path: `<root>/.cache/codeclone/cache.json`
-- Schema version: **v1.2**
+- Schema version: **v1.3**
+- Compatibility includes analysis profile (`min_loc`, `min_stmt`)
 - Invalid or oversized cache is ignored with warning and rebuilt (fail-open)
 
 Full contract details: [`docs/book/07-cache.md`](docs/book/07-cache.md)

{codeclone-1.4.2 → codeclone-1.4.3}/codeclone/cache.py

@@ -39,6 +39,7 @@ class CacheStatus(str, Enum):
     VERSION_MISMATCH = "version_mismatch"
     PYTHON_TAG_MISMATCH = "python_tag_mismatch"
     FINGERPRINT_MISMATCH = "mismatch_fingerprint_version"
+    ANALYSIS_PROFILE_MISMATCH = "analysis_profile_mismatch"
     INTEGRITY_FAILED = "integrity_failed"
 
 
@@ -84,15 +85,22 @@ class CacheEntry(TypedDict):
     segments: list[SegmentDict]
 
 
+class AnalysisProfile(TypedDict):
+    min_loc: int
+    min_stmt: int
+
+
 class CacheData(TypedDict):
     version: str
     python_tag: str
     fingerprint_version: str
+    analysis_profile: AnalysisProfile
     files: dict[str, CacheEntry]
 
 
 class Cache:
     __slots__ = (
+        "analysis_profile",
         "cache_schema_version",
         "data",
         "fingerprint_version",
@@ -112,14 +120,21 @@ class Cache:
         *,
         root: str | Path | None = None,
         max_size_bytes: int | None = None,
+        min_loc: int = 15,
+        min_stmt: int = 6,
     ):
         self.path = Path(path)
         self.root = _resolve_root(root)
         self.fingerprint_version = BASELINE_FINGERPRINT_VERSION
+        self.analysis_profile: AnalysisProfile = {
+            "min_loc": min_loc,
+            "min_stmt": min_stmt,
+        }
         self.data: CacheData = _empty_cache_data(
             version=self._CACHE_VERSION,
             python_tag=current_python_tag(),
             fingerprint_version=self.fingerprint_version,
+            analysis_profile=self.analysis_profile,
         )
         self.legacy_secret_warning = self._detect_legacy_secret_warning()
         self.cache_schema_version: str | None = None
@@ -164,6 +179,7 @@ class Cache:
             version=self._CACHE_VERSION,
             python_tag=current_python_tag(),
             fingerprint_version=self.fingerprint_version,
+            analysis_profile=self.analysis_profile,
         )
 
     def _sign_data(self, data: Mapping[str, object]) -> str:
@@ -309,6 +325,28 @@ class Cache:
             )
             return None
 
+        analysis_profile = _as_analysis_profile(payload.get("ap"))
+        if analysis_profile is None:
+            self._ignore_cache(
+                "Cache format invalid; ignoring cache.",
+                status=CacheStatus.INVALID_TYPE,
+                schema_version=version,
+            )
+            return None
+
+        if analysis_profile != self.analysis_profile:
+            self._ignore_cache(
+                "Cache analysis profile mismatch "
+                f"(found min_loc={analysis_profile['min_loc']}, "
+                f"min_stmt={analysis_profile['min_stmt']}; "
+                f"expected min_loc={self.analysis_profile['min_loc']}, "
+                f"min_stmt={self.analysis_profile['min_stmt']}); "
+                "ignoring cache.",
+                status=CacheStatus.ANALYSIS_PROFILE_MISMATCH,
+                schema_version=version,
+            )
+            return None
+
         files_obj = payload.get("files")
         files_dict = _as_str_dict(files_obj)
         if files_dict is None:
@@ -337,6 +375,7 @@ class Cache:
             "version": self._CACHE_VERSION,
             "python_tag": runtime_tag,
             "fingerprint_version": self.fingerprint_version,
+            "analysis_profile": self.analysis_profile,
             "files": parsed_files,
         }
 
@@ -356,6 +395,7 @@ class Cache:
             payload: dict[str, object] = {
                 "py": current_python_tag(),
                 "fp": self.fingerprint_version,
+                "ap": self.analysis_profile,
                 "files": wire_files,
             }
             signed_doc = {
@@ -371,6 +411,7 @@ class Cache:
             self.data["version"] = self._CACHE_VERSION
             self.data["python_tag"] = current_python_tag()
             self.data["fingerprint_version"] = self.fingerprint_version
+            self.data["analysis_profile"] = self.analysis_profile
 
         except OSError as e:
             raise CacheError(f"Failed to save cache: {e}") from e
@@ -508,11 +549,13 @@ def _empty_cache_data(
     version: str,
     python_tag: str,
     fingerprint_version: str,
+    analysis_profile: AnalysisProfile,
 ) -> CacheData:
     return {
         "version": version,
         "python_tag": python_tag,
         "fingerprint_version": fingerprint_version,
+        "analysis_profile": analysis_profile,
         "files": {},
     }
 
@@ -542,6 +585,22 @@ def _as_str_dict(value: object) -> dict[str, object] | None:
     return value
 
 
+def _as_analysis_profile(value: object) -> AnalysisProfile | None:
+    obj = _as_str_dict(value)
+    if obj is None:
+        return None
+
+    if set(obj.keys()) != {"min_loc", "min_stmt"}:
+        return None
+
+    min_loc = _as_int(obj.get("min_loc"))
+    min_stmt = _as_int(obj.get("min_stmt"))
+    if min_loc is None or min_stmt is None:
+        return None
+
+    return {"min_loc": min_loc, "min_stmt": min_stmt}
+
+
 def _decode_wire_file_entry(value: object, filepath: str) -> CacheEntry | None:
     obj = _as_str_dict(value)
     if obj is None:

{codeclone-1.4.2 → codeclone-1.4.3}/codeclone/cli.py

@@ -310,6 +310,8 @@ def _main_impl() -> None:
         cache_path,
         root=root_path,
         max_size_bytes=args.max_cache_size_mb * 1024 * 1024,
+        min_loc=args.min_loc,
+        min_stmt=args.min_stmt,
     )
     cache.load()
     if cache.load_warning:

{codeclone-1.4.2 → codeclone-1.4.3}/codeclone/contracts.py

@@ -14,7 +14,7 @@ from typing import Final
 BASELINE_SCHEMA_VERSION: Final = "1.0"
 BASELINE_FINGERPRINT_VERSION: Final = "1"
 
-CACHE_VERSION: Final = "1.2"
+CACHE_VERSION: Final = "1.3"
 REPORT_SCHEMA_VERSION: Final = "1.1"
 
 

{codeclone-1.4.2 → codeclone-1.4.3}/codeclone.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeclone
-Version: 1.4.2
+Version: 1.4.3
 Summary: AST and CFG-based code clone detector for Python focused on architectural duplication
 Author-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
 Maintainer-email: Den Rozhnovskiy <pytelemonbot@mail.ru>
@@ -158,12 +158,12 @@ Full contract details: [`docs/book/06-baseline.md`](docs/book/06-baseline.md)
 
 CodeClone uses a deterministic exit code contract:
 
-| Code | Meaning                                                                     |
-|------|-----------------------------------------------------------------------------|
-| `0`  | Success — run completed without gating failures                             |
+| Code | Meaning                                                                                                                             |
+|------|-------------------------------------------------------------------------------------------------------------------------------------|
+| `0`  | Success — run completed without gating failures                                                                                     |
 | `2`  | Contract error — baseline missing/untrusted, invalid output extensions, incompatible versions, unreadable source files in CI/gating |
-| `3`  | Gating failure — new clones detected or threshold exceeded                  |
-| `5`  | Internal error — unexpected exception                                       |
+| `3`  | Gating failure — new clones detected or threshold exceeded                                                                          |
+| `5`  | Internal error — unexpected exception                                                                                               |
 
 **Priority:** Contract errors (`2`) override gating failures (`3`) when both occur.
 
@@ -223,7 +223,7 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
     "cache_path": "/path/to/.cache/codeclone/cache.json",
     "cache_used": true,
     "cache_status": "ok",
-    "cache_schema_version": "1.2",
+    "cache_schema_version": "1.3",
     "files_skipped_source_io": 0,
     "groups_counts": {
       "functions": {
@@ -304,7 +304,8 @@ Canonical report contract: [`docs/book/08-report.md`](docs/book/08-report.md)
 Cache is an optimization layer only and is never a source of truth.
 
 - Default path: `<root>/.cache/codeclone/cache.json`
-- Schema version: **v1.2**
+- Schema version: **v1.3**
+- Compatibility includes analysis profile (`min_loc`, `min_stmt`)
 - Invalid or oversized cache is ignored with warning and rebuilt (fail-open)
 
 Full contract details: [`docs/book/07-cache.md`](docs/book/07-cache.md)

{codeclone-1.4.2 → codeclone-1.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeclone"
-version = "1.4.2"
+version = "1.4.3"
 description = "AST and CFG-based code clone detector for Python focused on architectural duplication"
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { text = "MIT" }

{codeclone-1.4.2 → codeclone-1.4.3}/tests/test_cache.py

@@ -50,6 +50,15 @@ def _make_segment(filepath: str) -> SegmentUnit:
     )
 
 
+def _analysis_payload(cache: Cache, *, files: object) -> dict[str, object]:
+    return {
+        "py": cache.data["python_tag"],
+        "fp": cache.data["fingerprint_version"],
+        "ap": cache.data["analysis_profile"],
+        "files": files,
+    }
+
+
 def test_cache_roundtrip(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
@@ -97,7 +106,7 @@ def test_get_file_entry_missing_after_fallback_returns_none(tmp_path: Path) -> N
     assert cache.get_file_entry(str(root / "pkg" / "missing.py")) is None
 
 
-def test_cache_v12_uses_relpaths_when_root_set(tmp_path: Path) -> None:
+def test_cache_v13_uses_relpaths_when_root_set(tmp_path: Path) -> None:
     project_root = tmp_path / "project"
     target = project_root / "pkg" / "module.py"
     target.parent.mkdir(parents=True, exist_ok=True)
@@ -121,14 +130,10 @@ def test_cache_v12_uses_relpaths_when_root_set(tmp_path: Path) -> None:
     assert str(target) not in files
 
 
-def test_cache_v12_missing_optional_sections_default_empty(tmp_path: Path) -> None:
+def test_cache_v13_missing_optional_sections_default_empty(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {
-        "py": cache.data["python_tag"],
-        "fp": cache.data["fingerprint_version"],
-        "files": {"x.py": {"st": [1, 2]}},
-    }
+    payload = _analysis_payload(cache, files={"x.py": {"st": [1, 2]}})
     signature = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": signature}),
@@ -201,11 +206,7 @@ def test_cache_version_mismatch_warns(tmp_path: Path) -> None:
 def test_cache_v_field_version_mismatch_warns(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {
-        "py": cache.data["python_tag"],
-        "fp": cache.data["fingerprint_version"],
-        "files": {},
-    }
+    payload = _analysis_payload(cache, files={})
     signature = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": "0.0", "payload": payload, "sig": signature}), "utf-8"
@@ -527,11 +528,7 @@ def test_cache_load_unreadable_read_graceful_ignore(
 def test_cache_load_invalid_files_type(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {
-        "py": cache.data["python_tag"],
-        "fp": cache.data["fingerprint_version"],
-        "files": [],
-    }
+    payload = _analysis_payload(cache, files=[])
     signature = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": signature}),
@@ -644,11 +641,7 @@ def test_cache_load_invalid_top_level_type(tmp_path: Path) -> None:
 def test_cache_load_missing_v_field(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {
-        "py": cache.data["python_tag"],
-        "fp": cache.data["fingerprint_version"],
-        "files": {},
-    }
+    payload = _analysis_payload(cache, files={})
     sig = cache._sign_data(payload)
     cache_path.write_text(json.dumps({"payload": payload, "sig": sig}), "utf-8")
     cache.load()
@@ -683,7 +676,12 @@ def test_cache_load_missing_python_tag_in_payload(tmp_path: Path) -> None:
 def test_cache_load_python_tag_mismatch(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {"py": "cp999", "fp": cache.data["fingerprint_version"], "files": {}}
+    payload = {
+        "py": "cp999",
+        "fp": cache.data["fingerprint_version"],
+        "ap": cache.data["analysis_profile"],
+        "files": {},
+    }
     sig = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": sig}), "utf-8"
@@ -709,7 +707,12 @@ def test_cache_load_missing_fingerprint_version(tmp_path: Path) -> None:
 def test_cache_load_fingerprint_version_mismatch(tmp_path: Path) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
-    payload = {"py": cache.data["python_tag"], "fp": "old", "files": {}}
+    payload = {
+        "py": cache.data["python_tag"],
+        "fp": "old",
+        "ap": cache.data["analysis_profile"],
+        "files": {},
+    }
     sig = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": sig}), "utf-8"
@@ -719,18 +722,82 @@ def test_cache_load_fingerprint_version_mismatch(tmp_path: Path) -> None:
     assert "fingerprint version mismatch" in cache.load_warning
 
 
-def test_cache_load_invalid_wire_file_entry(tmp_path: Path) -> None:
+def test_cache_load_analysis_profile_mismatch(tmp_path: Path) -> None:
+    cache_path = tmp_path / "cache.json"
+    cache = Cache(cache_path, min_loc=1, min_stmt=1)
+    cache.put_file_entry("x.py", {"mtime_ns": 1, "size": 10}, [], [], [])
+    cache.save()
+
+    loaded = Cache(cache_path, min_loc=15, min_stmt=6)
+    loaded.load()
+
+    assert loaded.load_warning is not None
+    assert "analysis profile mismatch" in loaded.load_warning
+    assert loaded.data["files"] == {}
+    assert loaded.load_status == CacheStatus.ANALYSIS_PROFILE_MISMATCH
+    assert loaded.cache_schema_version == Cache._CACHE_VERSION
+
+
+def test_cache_load_missing_analysis_profile_in_payload(tmp_path: Path) -> None:
+    cache_path = tmp_path / "cache.json"
+    cache = Cache(cache_path)
+    payload = {
+        "py": cache.data["python_tag"],
+        "fp": cache.data["fingerprint_version"],
+        "files": {},
+    }
+    sig = cache._sign_data(payload)
+    cache_path.write_text(
+        json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": sig}), "utf-8"
+    )
+
+    cache.load()
+    assert cache.load_warning is not None
+    assert "format invalid" in cache.load_warning
+    assert cache.load_status == CacheStatus.INVALID_TYPE
+    assert cache.cache_schema_version == Cache._CACHE_VERSION
+    assert cache.data["files"] == {}
+
+
+@pytest.mark.parametrize(
+    "bad_analysis_profile",
+    [
+        {"min_loc": 15},
+        {"min_loc": "15", "min_stmt": 6},
+    ],
+)
+def test_cache_load_invalid_analysis_profile_payload(
+    tmp_path: Path, bad_analysis_profile: object
+) -> None:
     cache_path = tmp_path / "cache.json"
     cache = Cache(cache_path)
     payload = {
         "py": cache.data["python_tag"],
         "fp": cache.data["fingerprint_version"],
-        "files": {"x.py": {"st": "bad"}},
+        "ap": bad_analysis_profile,
+        "files": {},
     }
     sig = cache._sign_data(payload)
     cache_path.write_text(
         json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": sig}), "utf-8"
     )
+
+    cache.load()
+    assert cache.load_warning is not None
+    assert "format invalid" in cache.load_warning
+    assert cache.load_status == CacheStatus.INVALID_TYPE
+    assert cache.cache_schema_version == Cache._CACHE_VERSION
+    assert cache.data["files"] == {}
+
+
+def test_cache_load_invalid_wire_file_entry(tmp_path: Path) -> None:
+    cache_path = tmp_path / "cache.json"
+    cache = Cache(cache_path)
+    payload = _analysis_payload(cache, files={"x.py": {"st": "bad"}})
+    sig = cache._sign_data(payload)
+    cache_path.write_text(
+        json.dumps({"v": cache._CACHE_VERSION, "payload": payload, "sig": sig}), "utf-8"
+    )
     cache.load()
     assert cache.load_warning is not None
     assert "format invalid" in cache.load_warning

{codeclone-1.4.2 → codeclone-1.4.3}/tests/test_cli_inprocess.py

@@ -708,7 +708,7 @@ def test_cli_cache_status_string_fallback(
         def __init__(self, _path: Path, **_kwargs: object) -> None:
             self.load_warning = load_warning
             self.load_status = "not-a-cache-status"
-            self.cache_schema_version = "1.2"
+            self.cache_schema_version = CACHE_VERSION
 
         def load(self) -> None:
             return None
@@ -1716,6 +1716,122 @@ def test_cli_reports_cache_meta_when_cache_missing(
     assert meta["cache_schema_version"] is None
 
 
+@pytest.mark.parametrize(
+    (
+        "first_min_loc",
+        "first_min_stmt",
+        "second_min_loc",
+        "second_min_stmt",
+        "expected_cache_used",
+        "expected_cache_status",
+        "expected_functions_total",
+        "expected_warning",
+    ),
+    [
+        (
+            1,
+            1,
+            15,
+            6,
+            False,
+            "analysis_profile_mismatch",
+            0,
+            "analysis profile mismatch",
+        ),
+        (
+            15,
+            6,
+            1,
+            1,
+            False,
+            "analysis_profile_mismatch",
+            1,
+            "analysis profile mismatch",
+        ),
+        (1, 1, 1, 1, True, "ok", 1, None),
+    ],
+)
+def test_cli_cache_analysis_profile_compatibility(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    first_min_loc: int,
+    first_min_stmt: int,
+    second_min_loc: int,
+    second_min_stmt: int,
+    expected_cache_used: bool,
+    expected_cache_status: str,
+    expected_functions_total: int,
+    expected_warning: str | None,
+) -> None:
+    src = tmp_path / "a.py"
+    src.write_text(
+        """
+def f1():
+    x = 1
+    return x
+
+def f2():
+    y = 1
+    return y
+""",
+        "utf-8",
+    )
+    baseline_path = _write_baseline(
+        tmp_path / "baseline.json",
+        python_version=f"{sys.version_info.major}.{sys.version_info.minor}",
+    )
+    cache_path = tmp_path / "cache.json"
+    json_first = tmp_path / "report-first.json"
+    json_second = tmp_path / "report-second.json"
+    _patch_parallel(monkeypatch)
+
+    _run_main(
+        monkeypatch,
+        [
+            str(tmp_path),
+            "--baseline",
+            str(baseline_path),
+            "--cache-path",
+            str(cache_path),
+            "--json",
+            str(json_first),
+            "--min-loc",
+            str(first_min_loc),
+            "--min-stmt",
+            str(first_min_stmt),
+            "--no-progress",
+        ],
+    )
+    capsys.readouterr()
+
+    _run_main(
+        monkeypatch,
+        [
+            str(tmp_path),
+            "--baseline",
+            str(baseline_path),
+            "--cache-path",
+            str(cache_path),
+            "--json",
+            str(json_second),
+            "--min-loc",
+            str(second_min_loc),
+            "--min-stmt",
+            str(second_min_stmt),
+            "--no-progress",
+        ],
+    )
+    out = capsys.readouterr().out
+    payload = json.loads(json_second.read_text("utf-8"))
+    meta = payload["meta"]
+    if expected_warning is not None:
+        assert expected_warning in out
+    assert meta["cache_used"] is expected_cache_used
+    assert meta["cache_status"] == expected_cache_status
+    assert meta["groups_counts"]["functions"]["total"] == expected_functions_total
+
+
 @pytest.mark.parametrize(
     ("flag", "bad_name", "label", "expected"),
     [

{codeclone-1.4.2 → codeclone-1.4.3}/tests/test_html_report.py

@@ -6,7 +6,7 @@ from typing import Any
 
 import pytest
 
-from codeclone.contracts import DOCS_URL, ISSUES_URL, REPOSITORY_URL
+from codeclone.contracts import CACHE_VERSION, DOCS_URL, ISSUES_URL, REPOSITORY_URL
 from codeclone.errors import FileProcessingError
 from codeclone.html_report import (
     _FileCache,
@@ -507,7 +507,7 @@ def test_html_report_includes_provenance_metadata(
         'data-cache-used="true"',
         "Cache schema",
         "Cache status",
-        'data-cache-schema-version="1.2"',
+        f'data-cache-schema-version="{CACHE_VERSION}"',
         'data-cache-status="ok"',
         'data-files-skipped-source-io="0"',
         "Source IO skipped",

{codeclone-1.4.2 → codeclone-1.4.3}/tests/test_report.py

@@ -7,7 +7,7 @@ from typing import cast
 import pytest
 
 import codeclone.report as report_mod
-from codeclone.contracts import REPORT_SCHEMA_VERSION
+from codeclone.contracts import CACHE_VERSION, REPORT_SCHEMA_VERSION
 from codeclone.report import (
     GroupMap,
     build_block_group_facts,
@@ -276,7 +276,7 @@ def test_report_output_formats(
         '"baseline_schema_version": 1',
         f'"baseline_payload_sha256": "{"a" * 64}"',
         '"baseline_payload_sha256_verified": true',
-        '"cache_schema_version": "1.2"',
+        f'"cache_schema_version": "{CACHE_VERSION}"',
         '"cache_status": "ok"',
         '"files_skipped_source_io": 0',
     ]
@@ -288,7 +288,7 @@ def test_report_output_formats(
         "Baseline generator name: codeclone",
         f"Baseline payload sha256: {'a' * 64}",
         "Baseline payload verified: true",
-        "Cache schema version: 1.2",
+        f"Cache schema version: {CACHE_VERSION}",
         "Cache status: ok",
         "Source IO skipped: 0",
         "FUNCTION CLONES (NEW) (groups=2)",