src/tests/engine/test_capability_content.py

from __future__ import annotations

import hashlib
import json
from datetime import UTC, datetime, timedelta
from pathlib import Path

import networkx as nx
import pytest

from ctx.adapters.recommendation_presentation import render_loaded_capability_context
from ctx.core.resolve.engine_content import (
    AuthenticatedCatalogContentSource,
    CatalogContentUnavailable,
)
from ctx.core.graph.graph_store import build_graph_store
from ctx.core.resolve.engine_candidates import IndexedGraphCandidateSource
from ctx.engine.planner import CapabilitySelection, WorkObservation
from ctx.engine.content import (
    AuthorizedMaterial,
    MaterialDescriptor,
    MaterialIdentity,
)
from ctx.engine.lineage import InstalledMaterialLineage
from ctx.engine.planner import CandidateSourceUnavailable
from ctx.engine.protocol import HostAction, ScopeRef


class _AllowExactAuthority:
    def __init__(
        self,
        action: HostAction,
        selection: CapabilitySelection,
        catalog_snapshot_digest: str,
    ) -> None:
        self._action = action
        self._selection = selection
        self._catalog_snapshot_digest = catalog_snapshot_digest

    def authorize_exposure(
        self,
        action: HostAction,
        selection: CapabilitySelection,
        *,
        expected_catalog_snapshot_digest: str,
    ) -> None:
        if (
            action.to_json() != self._action.to_json()
            or selection != self._selection
            or expected_catalog_snapshot_digest != self._catalog_snapshot_digest
        ):
            raise RuntimeError("not authorized")


def _authority(
    action: HostAction,
    selection: CapabilitySelection,
    catalog_snapshot_digest: str = "b" * 64,
) -> _AllowExactAuthority:
    return _AllowExactAuthority(action, selection, catalog_snapshot_digest)


def _record(capability_id: str, path: str, content: bytes) -> dict[str, object]:
    return {
        "capability_id": capability_id,
        "path": path,
        "sha256": hashlib.sha256(content).hexdigest(),
        "size_bytes": len(content),
    }


def _material_descriptor(
    *,
    content_sha256: str,
    provenance_digest: str,
) -> MaterialDescriptor:
    value = {
        "actionability": "load",
        "capability_id": "skill:python-api",
        "content_bytes": 32,
        "content_sha256": content_sha256,
        "estimated_tokens": 8,
        "kind": "skill",
        "material_snapshot_digest": provenance_digest,
        "schema": "ctx.material-descriptor-v1",
    }
    digest = hashlib.sha256(
        json.dumps(
            value,
            ensure_ascii=True,
            allow_nan=False,
            separators=(",", ":"),
            sort_keys=True,
        ).encode("utf-8")
    ).hexdigest()
    return MaterialDescriptor(
        capability_id="skill:python-api",
        kind="skill",
        actionability="load",
        content_sha256=content_sha256,
        content_bytes=32,
        estimated_tokens=8,
        provenance_digest=provenance_digest,
        descriptor_digest=digest,
    )


def _freeze(root: Path) -> None:
    for path in sorted(root.rglob("*"), key=lambda value: len(value.parts), reverse=True):
        path.chmod(0o550 if path.is_dir() else 0o440)
    root.chmod(0o550)


def test_v2_material_identity_and_descriptor_bind_exact_content_and_provenance() -> None:
    identity = MaterialIdentity.create(
        capability_id="skill:python-api",
        kind="skill",
        content_sha256="a" * 64,
        content_bytes=32,
    )
    descriptor = MaterialDescriptor.create(
        capability_id=identity.capability_id,
        kind=identity.kind,
        actionability="load",
        content_sha256=identity.content_sha256,
        content_bytes=identity.content_bytes,
        estimated_tokens=8,
        provenance_digest="b" * 64,
        material_identity_digest=identity.identity_digest,
    )

    assert MaterialIdentity.from_dict(identity.to_dict()) == identity
    assert MaterialDescriptor.from_dict(descriptor.to_dict()) == descriptor
    assert descriptor.schema_version == 2
    assert descriptor.material_identity_digest == identity.identity_digest

    substituted = descriptor.to_dict()
    substituted["material_identity_digest"] = "c" * 64
    with pytest.raises(ValueError, match="material_identity_digest|descriptor_digest"):
        MaterialDescriptor.from_dict(substituted)


def test_v1_material_descriptor_mapping_and_digest_remain_frozen() -> None:
    descriptor = _material_descriptor(
        content_sha256="a" * 64,
        provenance_digest="b" * 64,
    )

    encoded = json.dumps(
        descriptor.to_dict(),
        ensure_ascii=True,
        allow_nan=False,
        separators=(",", ":"),
        sort_keys=True,
    )

    assert encoded == (
        '{"actionability":"load","capability_id":"skill:python-api",'
        '"content_bytes":32,'
        '"content_sha256":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",'
        '"descriptor_digest":"5ef7c5e2d9df7c983b0f0136271ffb0d7307892d475c02e637f81a53cffce280",'
        '"estimated_tokens":8,"kind":"skill",'
        '"material_snapshot_digest":"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",'
        '"schema":"ctx.material-descriptor-v1"}'
    )
    assert MaterialDescriptor.from_dict(json.loads(encoded)).to_dict() == descriptor.to_dict()

    with_unknown_v2_field = descriptor.to_dict()
    with_unknown_v2_field["material_identity_digest"] = "c" * 64
    with pytest.raises(ValueError, match="missing or unknown"):
        MaterialDescriptor.from_dict(with_unknown_v2_field)


def test_material_identity_rejects_substituted_capability_kind_or_content() -> None:
    identity = MaterialIdentity.create(
        capability_id="skill:python-api",
        kind="skill",
        content_sha256="a" * 64,
        content_bytes=32,
    )

    for field_name, value in (
        ("capability_id", "agent:python-api"),
        ("kind", "agent"),
        ("content_sha256", "b" * 64),
        ("identity_digest", "c" * 64),
    ):
        substituted = identity.to_dict()
        substituted[field_name] = value
        with pytest.raises(ValueError, match="identity|kind"):
            MaterialIdentity.from_dict(substituted)


def test_authorized_material_requires_origin_specific_exact_provenance() -> None:
    catalog_identity = MaterialIdentity.create(
        capability_id="skill:python-api",
        kind="skill",
        content_sha256="f" * 64,
        content_bytes=32,
    )
    catalog_descriptor = MaterialDescriptor.create(
        capability_id=catalog_identity.capability_id,
        kind=catalog_identity.kind,
        actionability="load",
        content_sha256=catalog_identity.content_sha256,
        content_bytes=catalog_identity.content_bytes,
        estimated_tokens=8,
        provenance_digest="9" * 64,
        material_identity_digest=catalog_identity.identity_digest,
    )
    lineage = InstalledMaterialLineage.create(
        capability_id="skill:python-api",
        kind="skill",
        catalog_identity_digest="a" * 64,
        material_identity_digest="b" * 64,
        origin_install_descriptor_digest="c" * 64,
        install_action_content_digest="d" * 64,
        install_receipt_content_digest="e" * 64,
    )
    catalog = AuthorizedMaterial.from_catalog(
        catalog_identity_digest="a" * 64,
        descriptor=catalog_descriptor,
    )
    installed = AuthorizedMaterial.from_installed(lineage)

    assert catalog.installed_material_lineage is None
    assert catalog.catalog_material_descriptor == catalog_descriptor
    assert installed.catalog_material_descriptor is None
    assert installed.installed_material_lineage == lineage
    assert catalog.material_descriptor_digest == catalog_descriptor.descriptor_digest
    assert installed.material_descriptor_digest is None
    assert catalog.origin_proof_digest == catalog_descriptor.descriptor_digest
    assert installed.origin_proof_digest == lineage.lineage_digest
    assert AuthorizedMaterial.from_dict(catalog.to_dict()) == catalog
    assert AuthorizedMaterial.from_dict(installed.to_dict()) == installed

    with pytest.raises(ValueError, match="lineage"):
        AuthorizedMaterial(
            capability_id=installed.capability_id,
            kind=installed.kind,
            catalog_identity_digest=installed.catalog_identity_digest,
            material_identity_digest=installed.material_identity_digest,
            origin="installed",
        )


@pytest.mark.parametrize(
    ("field_name", "value"),
    [
        ("capability_id", "skill:other-api"),
        ("kind", "agent"),
        ("catalog_identity_digest", "f" * 64),
        ("material_identity_digest", "f" * 64),
    ],
)
def test_installed_authorized_material_rejects_lineage_identity_substitution(
    field_name: str,
    value: str,
) -> None:
    lineage = InstalledMaterialLineage.create(
        capability_id="skill:python-api",
        kind="skill",
        catalog_identity_digest="a" * 64,
        material_identity_digest="b" * 64,
        origin_install_descriptor_digest="c" * 64,
        install_action_content_digest="d" * 64,
        install_receipt_content_digest="e" * 64,
    )
    values: dict[str, object] = {
        "capability_id": lineage.capability_id,
        "kind": lineage.kind,
        "catalog_identity_digest": lineage.catalog_identity_digest,
        "material_identity_digest": lineage.material_identity_digest,
        "origin": "installed",
        "installed_material_lineage": lineage,
    }
    values[field_name] = value

    with pytest.raises(ValueError, match="lineage|identity"):
        AuthorizedMaterial(**values)  # type: ignore[arg-type]


def test_authorized_material_forbids_the_other_origin_proof() -> None:
    identity = MaterialIdentity.create(
        capability_id="skill:python-api",
        kind="skill",
        content_sha256="f" * 64,
        content_bytes=32,
    )
    descriptor = MaterialDescriptor.create(
        capability_id=identity.capability_id,
        kind=identity.kind,
        actionability="load",
        content_sha256=identity.content_sha256,
        content_bytes=identity.content_bytes,
        estimated_tokens=8,
        provenance_digest="9" * 64,
        material_identity_digest=identity.identity_digest,
    )
    lineage = InstalledMaterialLineage.create(
        capability_id="skill:python-api",
        kind="skill",
        catalog_identity_digest="a" * 64,
        material_identity_digest="b" * 64,
        origin_install_descriptor_digest="c" * 64,
        install_action_content_digest="d" * 64,
        install_receipt_content_digest="e" * 64,
    )

    with pytest.raises(ValueError, match="catalog.*descriptor|lineage"):
        AuthorizedMaterial(
            capability_id=lineage.capability_id,
            kind=lineage.kind,
            catalog_identity_digest=lineage.catalog_identity_digest,
            material_identity_digest=lineage.material_identity_digest,
            origin="catalog",
            catalog_material_descriptor=descriptor,
            installed_material_lineage=lineage,
        )
    with pytest.raises(ValueError, match="installed.*lineage|descriptor"):
        AuthorizedMaterial(
            capability_id=lineage.capability_id,
            kind=lineage.kind,
            catalog_identity_digest=lineage.catalog_identity_digest,
            material_identity_digest=lineage.material_identity_digest,
            origin="installed",
            catalog_material_descriptor=descriptor,
            installed_material_lineage=lineage,
        )


def test_catalog_authorized_material_rejects_descriptor_identity_substitution() -> None:
    identity = MaterialIdentity.create(
        capability_id="skill:python-api",
        kind="skill",
        content_sha256="f" * 64,
        content_bytes=32,
    )
    descriptor = MaterialDescriptor.create(
        capability_id=identity.capability_id,
        kind=identity.kind,
        actionability="load",
        content_sha256=identity.content_sha256,
        content_bytes=identity.content_bytes,
        estimated_tokens=8,
        provenance_digest="9" * 64,
        material_identity_digest=identity.identity_digest,
    )

    with pytest.raises(ValueError, match="descriptor.*identity"):
        AuthorizedMaterial(
            capability_id="skill:other-api",
            kind=descriptor.kind,
            catalog_identity_digest="a" * 64,
            material_identity_digest=descriptor.material_identity_digest or "",
            origin="catalog",
            catalog_material_descriptor=descriptor,
        )


@pytest.mark.parametrize("capability_id", ["skill:python-api:extra", "mcp:legacy"])
def test_content_identities_use_the_shared_authoritative_grammar(capability_id: str) -> None:
    kind = capability_id.split(":", 1)[0]
    with pytest.raises(ValueError, match="kind.*capability_id|canonical identity"):
        MaterialIdentity.create(
            capability_id=capability_id,
            kind=kind,
            content_sha256="a" * 64,
            content_bytes=32,
        )


def _selection(*, source_digest: str = "a" * 64) -> CapabilitySelection:
    return CapabilitySelection(
        capability_id="skill:python-api",
        kind="skill",
        name="python-api",
        source_digest=source_digest,
        normalized_score_ppm=900_000,
        matching_signals=("api", "public"),
        reason_codes=("signal-match",),
        actionability="load",
    )


def _prepare_action(
    *,
    selection: CapabilitySelection | None = None,
    catalog_snapshot_digest: str = "b" * 64,
    expires_at: datetime | None = None,
    kind: str = "PrepareExposure",
) -> HostAction:
    selected = selection or _selection()
    expiry = expires_at or datetime.now(UTC) + timedelta(minutes=30)
    return HostAction(
        action_id="action-prepare-python-api",
        kind=kind,
        scope=ScopeRef(
            tenant_id="tenant",
            workspace_id="workspace",
            repository_id="repository",
            session_id="session",
            exposure_id="exposure",
            host_context_id="host",
        ),
        precondition_revision=5,
        entity_id=selected.capability_id,
        source_digest=selected.source_digest,
        plan_id="plan-1",
        catalog_snapshot_id=catalog_snapshot_digest,
        lease_id="lease-1",
        expires_at=expiry.isoformat().replace("+00:00", "Z"),
        required_host_feature="activation",
        verification={"receipt_required": True, "expected_state": "prepared"},
        rollback={"kind": "cleanup-prepared-exposure", "exposure_id": "exposure"},
    )


def _source(tmp_path: Path) -> tuple[AuthenticatedCatalogContentSource, bytes]:
    root = tmp_path / "catalog"
    path = root / "converted" / "python-api" / "SKILL.md"
    path.parent.mkdir(parents=True)
    content = b"# Python API\nPreserve public behavior.\n"
    path.write_bytes(content)
    _freeze(root)
    return (
        AuthenticatedCatalogContentSource(
            root,
            (_record("skill:python-api", "converted/python-api/SKILL.md", content),),
        ),
        content,
    )


def test_prepare_requires_exact_engine_action_selection_and_catalog_binding(
    tmp_path: Path,
) -> None:
    source, content = _source(tmp_path)
    selection = _selection()
    action = _prepare_action(selection=selection)

    descriptor = source.describe("skill:python-api", "skill")
    prepared = source.prepare(
        action,
        selection,
        expected_catalog_snapshot_digest="b" * 64,
        authority=_authority(action, selection),
    )

    assert descriptor.actionability == "load"
    assert descriptor.schema_version == 2
    assert (
        descriptor.material_identity_digest
        == MaterialIdentity.create(
            capability_id="skill:python-api",
            kind="skill",
            content_sha256=hashlib.sha256(content).hexdigest(),
            content_bytes=len(content),
        ).identity_digest
    )
    assert descriptor.content_sha256 == hashlib.sha256(content).hexdigest()
    assert prepared.capability_id == selection.capability_id
    assert prepared.source_digest == selection.source_digest
    assert prepared.catalog_snapshot_digest == "b" * 64
    assert prepared.content == content.decode("utf-8")
    assert prepared.content_sha256 == hashlib.sha256(content).hexdigest()
    assert prepared.content_bytes == len(content)


@pytest.mark.parametrize("failure", ["wrong-source", "wrong-catalog", "expired"])
def test_prepare_rejects_unbound_or_expired_actions_before_content_exposure(
    tmp_path: Path,
    failure: str,
) -> None:
    source, _content = _source(tmp_path)
    selection = _selection()
    action_selection = (
        _selection(source_digest="c" * 64) if failure == "wrong-source" else selection
    )
    action = _prepare_action(
        selection=action_selection,
        catalog_snapshot_digest="c" * 64 if failure == "wrong-catalog" else "b" * 64,
        expires_at=(datetime.now(UTC) - timedelta(seconds=1) if failure == "expired" else None),
    )

    with pytest.raises(CatalogContentUnavailable, match="unavailable"):
        source.prepare(
            action,
            selection,
            expected_catalog_snapshot_digest="b" * 64,
            authority=_authority(action, selection),
        )


def test_content_source_rejects_unsafe_mutable_or_mismatched_content(tmp_path: Path) -> None:
    root = tmp_path / "catalog"
    path = root / "converted" / "python-api" / "SKILL.md"
    path.parent.mkdir(parents=True)
    content = b"# API\n"
    path.write_bytes(content)
    manifest = (_record("skill:python-api", "converted/python-api/SKILL.md", content),)
    selection = _selection()
    action = _prepare_action(selection=selection)

    with pytest.raises(CatalogContentUnavailable, match="unavailable"):
        AuthenticatedCatalogContentSource(root, manifest).prepare(
            action,
            selection,
            expected_catalog_snapshot_digest="b" * 64,
            authority=_authority(action, selection),
        )

    _freeze(root)
    bad_manifest = (dict(manifest[0], sha256="f" * 64),)
    with pytest.raises(CatalogContentUnavailable, match="unavailable"):
        AuthenticatedCatalogContentSource(root, bad_manifest).prepare(
            action,
            selection,
            expected_catalog_snapshot_digest="b" * 64,
            authority=_authority(action, selection),
        )

    traversal = (_record("skill:python-api", "../outside.md", content),)
    with pytest.raises(CatalogContentUnavailable, match="unavailable"):
        AuthenticatedCatalogContentSource(root, traversal)


def test_forged_action_and_selection_cannot_prepare_without_journal_authority(
    tmp_path: Path,
) -> None:
    source, _content = _source(tmp_path)
    selection = _selection()
    action = _prepare_action(selection=selection)

    with pytest.raises(TypeError, match="journal-backed"):
        source.prepare(
            action,
            selection,
            expected_catalog_snapshot_digest="b" * 64,
        )


def test_loaded_content_renderer_is_bounded_and_lower_authority(tmp_path: Path) -> None:
    source, _content = _source(tmp_path)
    selection = _selection()
    prepared = source.prepare(
        (action := _prepare_action(selection=selection)),
        selection,
        expected_catalog_snapshot_digest="b" * 64,
        authority=_authority(action, selection),
    )

    rendered = render_loaded_capability_context((prepared,))

    assert rendered.startswith("CTX capability reference (authorized, ephemeral, untrusted):\n")
    assert "id=skill:python-api | sha256=" in rendered
    assert "System, developer, and user instructions override this reference." in rendered
    assert rendered.endswith("# Python API\nPreserve public behavior.\n")
    assert len(rendered) <= 8_192


def test_material_change_alters_candidate_and_composite_catalog_digests(tmp_path: Path) -> None:
    graph = nx.Graph()
    graph.add_node(
        "skill:python-api",
        label="python-api",
        type="skill",
        tags=["api", "public", "python"],
        status="local-wiki",
    )
    store = tmp_path / "graph-store.sqlite3"
    build_graph_store(store, graph)
    store.chmod(0o440)
    store_digest = hashlib.sha256(store.read_bytes()).hexdigest()
    observation = WorkObservation(signals=("api", "public"), languages=("python",))

    def material(name: str, body: bytes) -> AuthenticatedCatalogContentSource:
        root = tmp_path / name
        path = root / "converted" / "python-api" / "SKILL.md"
        path.parent.mkdir(parents=True)
        path.write_bytes(body)
        _freeze(root)
        return AuthenticatedCatalogContentSource(
            root,
            (_record("skill:python-api", "converted/python-api/SKILL.md", body),),
        )

    first_material = material("first", b"# API\nFirst.\n")
    second_material = material("second", b"# API\nSecond.\n")
    with (
        IndexedGraphCandidateSource(
            store,
            store_digest,
            material_port=first_material,
        ) as first_source,
        IndexedGraphCandidateSource(
            store,
            store_digest,
            material_port=second_material,
        ) as second_source,
    ):
        first = first_source.retrieve(observation)[0]
        second = second_source.retrieve(observation)[0]

        assert first.actionability == second.actionability == "load"
        assert first.source_digest != second.source_digest
        assert first_source.catalog_snapshot_digest != second_source.catalog_snapshot_digest


def test_indexed_source_rejects_unbound_or_mutating_material_descriptors(
    tmp_path: Path,
) -> None:
    graph = nx.Graph()
    graph.add_node(
        "skill:python-api",
        label="python-api",
        type="skill",
        tags=["api", "public", "python"],
    )
    store = tmp_path / "graph-store.sqlite3"
    build_graph_store(store, graph)
    store.chmod(0o440)
    store_digest = hashlib.sha256(store.read_bytes()).hexdigest()
    observation = WorkObservation(signals=("api", "public"), languages=("python",))
    snapshot_digest = "d" * 64
    first = _material_descriptor(
        content_sha256="a" * 64,
        provenance_digest=snapshot_digest,
    )
    second = _material_descriptor(
        content_sha256="b" * 64,
        provenance_digest=snapshot_digest,
    )

    class MutatingPort:
        material_snapshot_digest = snapshot_digest

        def __init__(self) -> None:
            self.calls = 0

        def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor:
            self.calls += 1
            return first if self.calls == 1 else second

    port = MutatingPort()
    with IndexedGraphCandidateSource(
        store,
        store_digest,
        # This retrieval-only test double intentionally omits prepare().
        material_port=port,  # type: ignore[arg-type]
    ) as source:
        source.retrieve(observation)
        with pytest.raises(CandidateSourceUnavailable, match="changed"):
            source.retrieve(observation)

    class UnboundPort:
        material_snapshot_digest = "e" * 64

        def describe(self, _capability_id: str, _kind: str) -> MaterialDescriptor:
            return first

    with IndexedGraphCandidateSource(
        store,
        store_digest,
        # This retrieval-only test double intentionally omits prepare().
        material_port=UnboundPort(),  # type: ignore[arg-type]
    ) as source:
        assert source.retrieve(observation) == ()