codna 0.1.8__tar.gz → 0.1.10__tar.gz

{codna-0.1.8 → codna-0.1.10}/MANIFEST.in

@@ -1,7 +1,10 @@
 exclude codna/_telys_runtime/libame_kernel.*
+exclude codna/_telys_runtime/lib*.dylib
+exclude codna/_telys_runtime/lib*.so
+exclude codna/_telys_runtime/*.dll
 exclude codna/_telys_runtime/manifest.json
 exclude codna/_telys_runtime/oem-license.jwt
-recursive-exclude codna/_telys_runtime libame_kernel.* manifest.json oem-license.jwt
+recursive-exclude codna/_telys_runtime libame_kernel.* lib*.dylib lib*.so *.dll manifest.json oem-license.jwt
 recursive-exclude .codna *
 recursive-exclude .codna-memory *
 recursive-exclude codna __pycache__ *.py[cod] *.pyo

{codna-0.1.8 → codna-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.8
+Version: 0.1.10
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.8 → codna-0.1.10}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"

{codna-0.1.8 → codna-0.1.10}/codna/local_repository_shims.py

@@ -31,6 +31,20 @@ _LOCAL_SDK_DIRECT_SUFFIX_LANGUAGES = {
     ".xml": "xml",
     ".properties": "properties",
 }
+_GENERATED_DIFF_SKIP_DIRS = frozenset({
+    ".cache",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    "__pycache__",
+})
+_GENERATED_DIFF_SKIP_FILES = frozenset({
+    ".coverage",
+    ".DS_Store",
+    "coverage.xml",
+})
+_GENERATED_DIFF_SKIP_SUFFIXES = (".pyc", ".pyo")
 
 
 def install_precise_patch_changed_files() -> None:
@@ -206,6 +220,8 @@ def git_apply_compatible_unified_diff_from_tree_states(
 ) -> str:
     segments: list[str] = []
     for relative in sorted(set(before) | set(after)):
+        if _is_generated_diff_artifact(relative):
+            continue
         old_text = before.get(relative)
         new_text = after.get(relative)
         if old_text == new_text:
@@ -225,6 +241,15 @@ def git_apply_compatible_unified_diff_from_tree_states(
     return "".join(segments)
 
 
+def _is_generated_diff_artifact(relative: str) -> bool:
+    path = Path(relative)
+    if any(part in _GENERATED_DIFF_SKIP_DIRS for part in path.parts):
+        return True
+    if path.name in _GENERATED_DIFF_SKIP_FILES:
+        return True
+    return path.name.endswith(_GENERATED_DIFF_SKIP_SUFFIXES)
+
+
 def precise_patch_changed_files(patch_diff: str) -> dict[str, list[tuple[int, int]]]:
     changed_lines: dict[str, set[int]] = {}
     current_file: str | None = None

{codna-0.1.8 → codna-0.1.10}/codna/memory.py

@@ -35,15 +35,14 @@ import hashlib
 import json
 import os
 from pathlib import Path
-import platform
 import re
 import shutil
 import subprocess
-import sys
 import time
 
 from .codeunits import FILTER_COLUMNS, UnsupportedLanguageError, extract_repo, resolve_languages
 from .memory_manifest import legacy_manifest_id_belongs_to_repo, manifest_entry, manifest_hash, manifest_scope
+from . import telys_runtime as _runtime_artifacts
 
 COLLECTION = "repo_symbols"
 DEFAULT_DB_DIRNAME = ".codna-memory"
@@ -56,8 +55,6 @@ _KERNEL_ENV_NAMES = ("TELYS_KERNEL", "AME_KERNEL")
 _CODNA_KERNEL_ENV_NAME = "CODNA_TELYS_KERNEL"
 _CODNA_INSTALL_ROOT_ENV_NAME = "CODNA_TELYS_INSTALL_ROOT"
 _PACKAGE_RUNTIME_DIRNAME = "_telys_runtime"
-_PACKAGE_RUNTIME_MANIFEST = "manifest.json"
-_PACKAGE_RUNTIME_SCHEMA_VERSION = 1
 # Codna holds a 100-year OEM Telys entitlement covering every Codna user, so users never obtain their
 # own Telys license. When a release bakes that OEM license here (a companion to the packaged kernel,
 # staged at build time — never committed), base codna activates with zero user configuration.
@@ -74,110 +71,38 @@ class CodeMemoryError(Exception):
 
 
 def _kernel_filename() -> str:
-    if sys.platform == "darwin":
-        return "libame_kernel.dylib"
-    if sys.platform.startswith("win"):
-        return "libame_kernel.dll"
-    return "libame_kernel.so"
+    return _runtime_artifacts.kernel_filename()
 
 
 def _source_checkout_root() -> Path:
-    return Path(__file__).resolve().parents[2]
+    return _runtime_artifacts.source_checkout_root(__file__)
 
 
 def _runtime_platform_tag() -> str:
-    machine = platform.machine().lower() or "unknown"
-    if sys.platform == "darwin":
-        return f"macos-{machine}"
-    if sys.platform.startswith("linux"):
-        return f"linux-{machine}"
-    if sys.platform.startswith("win"):
-        return f"windows-{machine}"
-    return f"{sys.platform}-{machine}"
+    return _runtime_artifacts.runtime_platform_tag()
 
 
 def _sha256_file(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
+    return _runtime_artifacts.sha256_file(path)
 
 
-def _package_runtime_dir() -> Path:
-    return Path(__file__).resolve().parent / _PACKAGE_RUNTIME_DIRNAME
+def _is_native_runtime_library_name(name: str) -> bool:
+    return _runtime_artifacts.is_native_runtime_library_name(name)
 
 
-def _load_package_runtime_manifest(path: Path) -> dict:
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-    except FileNotFoundError as exc:
-        raise CodeMemoryError(f"Codna packaged Telys runtime manifest is missing: {path}") from exc
-    except json.JSONDecodeError as exc:
-        raise CodeMemoryError(f"Codna packaged Telys runtime manifest is invalid JSON: {path}") from exc
-    if not isinstance(payload, dict):
-        raise CodeMemoryError(f"Codna packaged Telys runtime manifest must be a JSON object: {path}")
-    return payload
-
-
-def _validate_package_runtime_manifest(runtime_dir: Path, manifest: dict) -> dict:
-    expected_artifact = _kernel_filename()
-    if manifest.get("schema_version") != _PACKAGE_RUNTIME_SCHEMA_VERSION:
-        raise CodeMemoryError("Codna packaged Telys runtime manifest has unsupported schema_version")
-    if manifest.get("artifact") != expected_artifact:
-        raise CodeMemoryError(
-            f"Codna packaged Telys runtime artifact must be {expected_artifact}; "
-            f"manifest has {manifest.get('artifact')!r}"
-        )
-    if manifest.get("platform") != _runtime_platform_tag():
-        raise CodeMemoryError(
-            f"Codna packaged Telys runtime platform mismatch: {manifest.get('platform')!r}"
-        )
-    for key in ("sha256", "size_bytes", "source_basename"):
-        if key not in manifest:
-            raise CodeMemoryError(f"Codna packaged Telys runtime manifest is missing {key}")
-    if "source_path" in manifest:
-        raise CodeMemoryError("Codna packaged Telys runtime manifest must not store source_path")
-    artifact = runtime_dir / expected_artifact
-    if not artifact.is_file():
-        raise CodeMemoryError(f"Codna packaged Telys runtime kernel is missing: {artifact}")
-    if artifact.stat().st_size != manifest["size_bytes"]:
-        raise CodeMemoryError("Codna packaged Telys runtime kernel size does not match manifest")
-    if _sha256_file(artifact) != manifest["sha256"]:
-        raise CodeMemoryError("Codna packaged Telys runtime kernel sha256 does not match manifest")
-    return {
-        "manifest_path": str((runtime_dir / _PACKAGE_RUNTIME_MANIFEST).resolve()),
-        "sha256": manifest["sha256"],
-        "size_bytes": manifest["size_bytes"],
-        "platform": manifest["platform"],
-    }
+def _package_runtime_dir() -> Path:
+    return _runtime_artifacts.package_runtime_dir(__file__)
 
 
 def _package_runtime_candidate() -> tuple[Path, dict] | None:
-    runtime_dir = _package_runtime_dir()
-    manifest_path = runtime_dir / _PACKAGE_RUNTIME_MANIFEST
-    kernels = sorted(runtime_dir.glob("libame_kernel.*")) if runtime_dir.is_dir() else []
-    if not manifest_path.exists() and not kernels:
-        return None
-    expected = _kernel_filename()
-    unexpected = [path.name for path in kernels if path.name != expected]
-    if unexpected:
-        raise CodeMemoryError(
-            "Codna packaged Telys runtime contains unsupported kernel artifact(s): "
-            + ", ".join(unexpected)
-        )
-    manifest = _load_package_runtime_manifest(manifest_path)
-    metadata = _validate_package_runtime_manifest(runtime_dir, manifest)
-    return runtime_dir / expected, metadata
+    return _runtime_artifacts.package_runtime_candidate(__file__, error_cls=CodeMemoryError)
 
 
 def _candidate_codna_install_roots() -> list[tuple[str, Path]]:
-    roots: list[tuple[str, Path]] = []
-    raw = os.environ.get(_CODNA_INSTALL_ROOT_ENV_NAME)
-    if raw and raw.strip():
-        roots.append((f"env:{_CODNA_INSTALL_ROOT_ENV_NAME}", Path(raw).expanduser()))
-    roots.append(("codna:source-build", _source_checkout_root() / "build" / "local-telys"))
-    return roots
+    return _runtime_artifacts.candidate_codna_install_roots(
+        __file__,
+        install_root_env_name=_CODNA_INSTALL_ROOT_ENV_NAME,
+    )
 
 
 def _candidate_kernel_paths() -> list[tuple[str, Path]]:

codna-0.1.10/codna/telys_runtime.py

@@ -0,0 +1,197 @@
+"""Validated Codna-packaged Telys runtime artifact discovery.
+
+This module is intentionally only about local files: kernel naming, package
+runtime manifests, and native dependency validation. It has no Telys imports and
+does not mutate process environment.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+import platform
+import sys
+
+PACKAGE_RUNTIME_DIRNAME = "_telys_runtime"
+PACKAGE_RUNTIME_MANIFEST = "manifest.json"
+PACKAGE_RUNTIME_SCHEMA_VERSION = 1
+NATIVE_LIBRARY_SUFFIXES = (".dylib", ".so", ".dll")
+
+
+class TelysRuntimeArtifactError(Exception):
+    """Raised when a packaged Telys runtime artifact is incomplete or invalid."""
+
+
+def kernel_filename() -> str:
+    if sys.platform == "darwin":
+        return "libame_kernel.dylib"
+    if sys.platform.startswith("win"):
+        return "libame_kernel.dll"
+    return "libame_kernel.so"
+
+
+def source_checkout_root(package_file: str | Path) -> Path:
+    return Path(package_file).resolve().parents[2]
+
+
+def runtime_platform_tag() -> str:
+    machine = platform.machine().lower() or "unknown"
+    if sys.platform == "darwin":
+        return f"macos-{machine}"
+    if sys.platform.startswith("linux"):
+        return f"linux-{machine}"
+    if sys.platform.startswith("win"):
+        return f"windows-{machine}"
+    return f"{sys.platform}-{machine}"
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def is_native_runtime_library_name(name: str) -> bool:
+    if "/" in name or "\\" in name or name in {".", ".."} or ".." in Path(name).parts:
+        return False
+    return name.startswith("lib") and name.endswith(NATIVE_LIBRARY_SUFFIXES)
+
+
+def package_runtime_dir(package_file: str | Path) -> Path:
+    return Path(package_file).resolve().parent / PACKAGE_RUNTIME_DIRNAME
+
+
+def _fail(error_cls: type[Exception], message: str, cause: Exception | None = None) -> None:
+    if cause is None:
+        raise error_cls(message)
+    raise error_cls(message) from cause
+
+
+def load_package_runtime_manifest(
+    path: Path,
+    *,
+    error_cls: type[Exception] = TelysRuntimeArtifactError,
+) -> dict:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        _fail(error_cls, f"Codna packaged Telys runtime manifest is missing: {path}", exc)
+    except json.JSONDecodeError as exc:
+        _fail(error_cls, f"Codna packaged Telys runtime manifest is invalid JSON: {path}", exc)
+    if not isinstance(payload, dict):
+        _fail(error_cls, f"Codna packaged Telys runtime manifest must be a JSON object: {path}")
+    return payload
+
+
+def validate_package_runtime_manifest(
+    runtime_dir: Path,
+    manifest: dict,
+    *,
+    error_cls: type[Exception] = TelysRuntimeArtifactError,
+) -> dict:
+    expected_artifact = kernel_filename()
+    if manifest.get("schema_version") != PACKAGE_RUNTIME_SCHEMA_VERSION:
+        _fail(error_cls, "Codna packaged Telys runtime manifest has unsupported schema_version")
+    if manifest.get("artifact") != expected_artifact:
+        _fail(
+            error_cls,
+            f"Codna packaged Telys runtime artifact must be {expected_artifact}; "
+            f"manifest has {manifest.get('artifact')!r}",
+        )
+    if manifest.get("platform") != runtime_platform_tag():
+        _fail(error_cls, f"Codna packaged Telys runtime platform mismatch: {manifest.get('platform')!r}")
+    for key in ("sha256", "size_bytes", "source_basename"):
+        if key not in manifest:
+            _fail(error_cls, f"Codna packaged Telys runtime manifest is missing {key}")
+    if "source_path" in manifest:
+        _fail(error_cls, "Codna packaged Telys runtime manifest must not store source_path")
+
+    artifact = runtime_dir / expected_artifact
+    if not artifact.is_file():
+        _fail(error_cls, f"Codna packaged Telys runtime kernel is missing: {artifact}")
+    _validate_artifact_bytes(artifact, manifest, "kernel", error_cls=error_cls)
+    auxiliary_names = _validate_auxiliary_artifacts(runtime_dir, manifest, error_cls=error_cls)
+    return {
+        "manifest_path": str((runtime_dir / PACKAGE_RUNTIME_MANIFEST).resolve()),
+        "sha256": manifest["sha256"],
+        "size_bytes": manifest["size_bytes"],
+        "platform": manifest["platform"],
+        "auxiliary_artifacts": auxiliary_names,
+    }
+
+
+def _validate_artifact_bytes(
+    path: Path,
+    manifest_entry: dict,
+    label: str,
+    *,
+    error_cls: type[Exception],
+) -> None:
+    if path.stat().st_size != manifest_entry["size_bytes"]:
+        _fail(error_cls, f"Codna packaged Telys runtime {label} size does not match manifest")
+    if sha256_file(path) != manifest_entry["sha256"]:
+        _fail(error_cls, f"Codna packaged Telys runtime {label} sha256 does not match manifest")
+
+
+def _validate_auxiliary_artifacts(
+    runtime_dir: Path,
+    manifest: dict,
+    *,
+    error_cls: type[Exception],
+) -> list[str]:
+    auxiliary = manifest.get("auxiliary_artifacts", [])
+    if not isinstance(auxiliary, list):
+        _fail(error_cls, "Codna packaged Telys runtime auxiliary_artifacts must be a list")
+    auxiliary_names: list[str] = []
+    for entry in auxiliary:
+        if not isinstance(entry, dict):
+            _fail(error_cls, "Codna packaged Telys runtime auxiliary artifact entry must be an object")
+        name = entry.get("name")
+        if not isinstance(name, str) or not is_native_runtime_library_name(name):
+            _fail(error_cls, f"Codna packaged Telys runtime auxiliary artifact has invalid name: {name!r}")
+        for key in ("sha256", "size_bytes", "source_basename"):
+            if key not in entry:
+                _fail(error_cls, f"Codna packaged Telys runtime auxiliary artifact {name} is missing {key}")
+        aux_path = runtime_dir / name
+        if not aux_path.is_file():
+            _fail(error_cls, f"Codna packaged Telys runtime auxiliary artifact is missing: {aux_path}")
+        _validate_artifact_bytes(aux_path, entry, f"auxiliary artifact {name}", error_cls=error_cls)
+        auxiliary_names.append(name)
+    return auxiliary_names
+
+
+def package_runtime_candidate(
+    package_file: str | Path,
+    *,
+    error_cls: type[Exception] = TelysRuntimeArtifactError,
+) -> tuple[Path, dict] | None:
+    runtime_dir = package_runtime_dir(package_file)
+    manifest_path = runtime_dir / PACKAGE_RUNTIME_MANIFEST
+    runtime_files = sorted(runtime_dir.glob("lib*")) + sorted(runtime_dir.glob("*.dll")) if runtime_dir.is_dir() else []
+    kernels = [path for path in runtime_files if path.name.startswith("libame_kernel.")]
+    if not manifest_path.exists() and not kernels:
+        return None
+    expected = kernel_filename()
+    unexpected = [path.name for path in kernels if path.name != expected]
+    if unexpected:
+        _fail(
+            error_cls,
+            "Codna packaged Telys runtime contains unsupported kernel artifact(s): "
+            + ", ".join(unexpected),
+        )
+    manifest = load_package_runtime_manifest(manifest_path, error_cls=error_cls)
+    metadata = validate_package_runtime_manifest(runtime_dir, manifest, error_cls=error_cls)
+    return runtime_dir / expected, metadata
+
+
+def candidate_codna_install_roots(package_file: str | Path, *, install_root_env_name: str) -> list[tuple[str, Path]]:
+    roots: list[tuple[str, Path]] = []
+    import os
+
+    raw = os.environ.get(install_root_env_name)
+    if raw and raw.strip():
+        roots.append((f"env:{install_root_env_name}", Path(raw).expanduser()))
+    roots.append(("codna:source-build", source_checkout_root(package_file) / "build" / "local-telys"))
+    return roots

{codna-0.1.8 → codna-0.1.10}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.1.8
+Version: 0.1.10
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.1.8 → codna-0.1.10}/codna.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ codna/secure.py
 codna/status.py
 codna/supervisor.py
 codna/telys_onboarding.py
+codna/telys_runtime.py
 codna/testrun.py
 codna/webhook.py
 codna/webhook_cli.py

{codna-0.1.8 → codna-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.1.8"
+version = "0.1.10"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -110,6 +110,9 @@ packages = ["codna", "codna.runtime", "memengine"]
 [tool.setuptools.package-data]
 codna = [
   "_telys_runtime/libame_kernel.*",
+  "_telys_runtime/lib*.dylib",
+  "_telys_runtime/lib*.so",
+  "_telys_runtime/*.dll",
   "_telys_runtime/manifest.json",
   # Codna's 100-year OEM Telys entitlement, baked in at release time (never committed) so
   # base codna activates with zero user configuration — users never obtain their own license.

{codna-0.1.8 → codna-0.1.10}/tests/test_local_client.py

@@ -634,6 +634,43 @@ def test_verified_agentic_diff_adds_no_newline_marker_for_git_apply(tmp_path) ->
     assert target_path.read_bytes() == restored.encode("utf-8")
 
 
+def test_verified_agentic_diff_filters_generated_test_cache_artifacts(tmp_path) -> None:
+    before = {
+        "roles.py": 'def has_admin_role(roles):\n    return "admin" in roles\n',
+    }
+    after = {
+        **before,
+        ".pytest_cache/.gitignore": "# Created by pytest automatically.\n*\n",
+        ".pytest_cache/v/cache/nodeids": '[\n  "tests/test_roles.py::T::test_case_insensitive_roles"\n]',
+        "__pycache__/roles.cpython-313.pyc": "binary-cache-placeholder",
+        "roles.py": 'def has_admin_role(roles):\n    return "admin" in [role.lower() for role in roles]\n',
+    }
+
+    patch_diff = local_client_module._git_apply_compatible_unified_diff_from_tree_states(before, after)
+
+    assert ".pytest_cache" not in patch_diff
+    assert "__pycache__" not in patch_diff
+    assert "roles.py" in patch_diff
+    assert "role.lower()" in patch_diff
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    target = repo / "roles.py"
+    target.write_text(before["roles.py"], encoding="utf-8")
+    patch_path = repo / ".algenta.patch.diff"
+    patch_path.write_text(patch_diff, encoding="utf-8")
+    subprocess.run(["git", "-C", str(repo), "init", "-q"], check=True)
+    check = subprocess.run(
+        ["git", "-C", str(repo), "apply", "--check", str(patch_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert check.returncode == 0, check.stderr
+    subprocess.run(["git", "-C", str(repo), "apply", str(patch_path)], check=True)
+    assert target.read_text(encoding="utf-8") == after["roles.py"]
+
+
 def test_patch_artifact_read_preserves_crlf_payload_lines(tmp_path) -> None:
     patch_path = tmp_path / "patch.diff"
     patch_bytes = (

{codna-0.1.8 → codna-0.1.10}/tests/test_memory_errors.py

@@ -170,9 +170,45 @@ def test_kernel_resolution_uses_packaged_runtime_candidate(monkeypatch, tmp_path
     assert result["path"] == str(kernel.resolve())
     assert result["manifest_path"] == str((kernel.parent / "manifest.json").resolve())
     assert result["sha256"] == manifest["sha256"]
+    assert result["auxiliary_artifacts"] == []
     assert os.environ["TELYS_KERNEL"] == str(kernel.resolve())
 
 
+def test_kernel_resolution_rejects_packaged_runtime_missing_auxiliary_artifact(
+    monkeypatch,
+    tmp_path,
+):
+    _clear_kernel_env(monkeypatch)
+    package_root = tmp_path / "cli" / "codna"
+    kernel = package_root / "_telys_runtime" / memory_module._kernel_filename()  # noqa: SLF001
+    kernel.parent.mkdir(parents=True)
+    kernel.write_bytes(b"kernel")
+    manifest = {
+        "schema_version": 1,
+        "artifact": kernel.name,
+        "sha256": memory_module._sha256_file(kernel),  # noqa: SLF001
+        "size_bytes": kernel.stat().st_size,
+        "platform": memory_module._runtime_platform_tag(),  # noqa: SLF001
+        "source_basename": kernel.name,
+        "auxiliary_artifacts": [
+            {
+                "name": "libKGENCompilerRTShared.dylib",
+                "sha256": "0" * 64,
+                "size_bytes": 4,
+                "source_basename": "libKGENCompilerRTShared.dylib",
+            }
+        ],
+    }
+    (kernel.parent / "manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
+    monkeypatch.setattr(memory_module, "__file__", str(package_root / "memory.py"))
+
+    with pytest.raises(CodeMemoryError) as excinfo:
+        memory_module._resolve_telys_kernel(configure_env=True)  # noqa: SLF001
+
+    assert "auxiliary artifact is missing" in str(excinfo.value)
+    assert "TELYS_KERNEL" not in os.environ
+
+
 def test_kernel_resolution_rejects_packaged_runtime_without_manifest(monkeypatch, tmp_path):
     _clear_kernel_env(monkeypatch)
     package_root = tmp_path / "cli" / "codna"

{codna-0.1.8 → codna-0.1.10}/tests/test_packaging.py

@@ -37,7 +37,14 @@ def _load_release_builder():
     return module
 
 
-def _write_wheel(path: Path, *, root_is_purelib: bool, tag: str, names: tuple[str, ...] = ()) -> None:
+def _write_wheel(
+    path: Path,
+    *,
+    root_is_purelib: bool,
+    tag: str,
+    names: tuple[str, ...] = (),
+    runtime_manifest: dict | None = None,
+) -> None:
     metadata = "\n".join(
         [
             "Wheel-Version: 1.0",
@@ -50,7 +57,10 @@ def _write_wheel(path: Path, *, root_is_purelib: bool, tag: str, names: tuple[st
     with zipfile.ZipFile(path, "w") as archive:
         archive.writestr("codna-0.1.0.dist-info/WHEEL", metadata)
         for name in names:
-            archive.writestr(name, b"test")
+            if name.endswith("_telys_runtime/manifest.json"):
+                archive.writestr(name, json.dumps(runtime_manifest or {"auxiliary_artifacts": []}))
+            else:
+                archive.writestr(name, b"test")
 
 
 def test_memory_extras_declared():
@@ -185,6 +195,9 @@ def test_telys_package_data_is_manifest_scoped():
     package_data = _data()["tool"]["setuptools"]["package-data"]["codna"]
     assert package_data == [
         "_telys_runtime/libame_kernel.*",
+        "_telys_runtime/lib*.dylib",
+        "_telys_runtime/lib*.so",
+        "_telys_runtime/*.dll",
         "_telys_runtime/manifest.json",
         # Codna's baked-in OEM entitlement (never committed; staged into the wheel at release time).
         "_telys_runtime/oem-license.jwt",
@@ -194,7 +207,7 @@ def test_telys_package_data_is_manifest_scoped():
 
 def test_sdist_manifest_excludes_local_runtime_and_secret_artifacts():
     manifest = (ROOT / "cli" / "MANIFEST.in").read_text(encoding="utf-8")
-    assert "recursive-exclude codna/_telys_runtime libame_kernel.* manifest.json oem-license.jwt" in manifest
+    assert "recursive-exclude codna/_telys_runtime libame_kernel.* lib*.dylib lib*.so *.dll manifest.json oem-license.jwt" in manifest
     # The baked OEM license is a credential-bearing wheel artifact; it must never enter the source sdist.
     assert "exclude codna/_telys_runtime/oem-license.jwt" in manifest
     for pattern in ("keys.txt", ".keys.txt", ".env", ".env.*", "*.log", "*.pem", "*.key", "*.jwt"):
@@ -477,14 +490,45 @@ def test_release_dist_builder_accepts_native_runtime_wheel(tmp_path: Path):
         tag="py3-none-macosx_15_0_arm64",
         names=(
             f"codna/_telys_runtime/{tool.expected_artifact_name('macos-arm64')}",
+            "codna/_telys_runtime/libKGENCompilerRTShared.dylib",
             "codna/_telys_runtime/manifest.json",
             "codna/_telys_runtime/oem-license.jwt",
         ),
+        runtime_manifest={
+            "auxiliary_artifacts": [
+                {"name": "libKGENCompilerRTShared.dylib", "sha256": "0" * 64, "size_bytes": 4}
+            ]
+        },
     )
 
     tool.assert_native_runtime_wheel(tool.inspect_wheel(wheel), target_platform="macos-arm64")
 
 
+def test_release_dist_builder_rejects_missing_auxiliary_runtime_wheel(tmp_path: Path):
+    tool = _load_release_builder()
+    wheel = tmp_path / "codna-0.1.0-py3-none-macosx_15_0_arm64.whl"
+    _write_wheel(
+        wheel,
+        root_is_purelib=False,
+        tag="py3-none-macosx_15_0_arm64",
+        names=(
+            f"codna/_telys_runtime/{tool.expected_artifact_name('macos-arm64')}",
+            "codna/_telys_runtime/manifest.json",
+            "codna/_telys_runtime/oem-license.jwt",
+        ),
+        runtime_manifest={
+            "auxiliary_artifacts": [
+                {"name": "libKGENCompilerRTShared.dylib", "sha256": "0" * 64, "size_bytes": 4}
+            ]
+        },
+    )
+
+    with pytest.raises(tool.ReleaseDistError) as excinfo:
+        tool.assert_native_runtime_wheel(tool.inspect_wheel(wheel), target_platform="macos-arm64")
+
+    assert "missing Telys auxiliary artifacts" in str(excinfo.value)
+
+
 def test_release_dist_builder_rejects_pypi_unsupported_linux_tag(tmp_path: Path):
     tool = _load_release_builder()
     wheel = tmp_path / "codna-0.1.0-py3-none-linux_x86_64.whl"
@@ -520,3 +564,31 @@ def test_release_dist_builder_accepts_manylinux_runtime_wheel(tmp_path: Path):
     )
 
     tool.assert_native_runtime_wheel(tool.inspect_wheel(wheel), target_platform="linux-x86_64")
+
+
+def test_release_dist_builder_removes_universal_wheel_for_native_publish(tmp_path: Path):
+    tool = _load_release_builder()
+    universal = tmp_path / "codna-0.1.0-py3-none-any.whl"
+    native = tmp_path / "codna-0.1.0-py3-none-macosx_15_0_arm64.whl"
+    _write_wheel(
+        universal,
+        root_is_purelib=True,
+        tag="py3-none-any",
+        names=("codna/_telys_runtime/libKGENCompilerRTShared.dylib",),
+    )
+    _write_wheel(
+        native,
+        root_is_purelib=False,
+        tag="py3-none-macosx_15_0_arm64",
+        names=(
+            f"codna/_telys_runtime/{tool.expected_artifact_name('macos-arm64')}",
+            "codna/_telys_runtime/manifest.json",
+            "codna/_telys_runtime/oem-license.jwt",
+        ),
+    )
+
+    removed = tool.remove_universal_wheels_for_native_publish(tmp_path, active_wheel=native)
+
+    assert removed == (universal.name,)
+    assert not universal.exists()
+    assert native.exists()