clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/cel/builder.py

@@ -0,0 +1,173 @@
+"""CelStore middleware factories and store builder in Layer 1 (Sprint 384 / DEL-384-04).
+
+Relocated from cross_cutting/cel_builder.py to conform to the Type Lattice invariant:
+runtime CEL state-matching and evaluation reside in Layer 1.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import io as _io
+import json as _json
+import os
+import shutil as _shutil
+import sys
+import time
+from collections.abc import Callable
+from contextlib import redirect_stderr, redirect_stdout
+from typing import TYPE_CHECKING, Any
+
+from clm.cross_cutting.cel_slices import EnvSlice, ServiceSlice, StateSlice
+from clm.cross_cutting.effects import EffectRegistry, register_default_effects
+from clm.cross_cutting.mcard import make_mcard_content
+from clm.layer0.algebra import (
+    compute_stripped_file_hash_py,
+    load_normalized_manifest,
+)
+from clm.layer0.utils import clm_hash_string
+from clm.layer1.runtime_adapter import (
+    _polyglot_runtime_execute,
+    evaluate_compose,
+    evaluate_polyglot,
+)
+from clm.layer1.verifier import (
+    get_load_manifest,
+    get_load_manifest_str,
+    resolve_active_hashes_py,
+)
+
+if TYPE_CHECKING:
+    from clm.cross_cutting.cel_store import CelStore
+
+PreMiddleware = Callable[["CelStore", dict], dict | None]
+PostMiddleware = Callable[["CelStore", dict, Any], None]
+Listener = Callable[["CelStore", dict, Any], None]
+
+
+def action_log_middleware() -> PostMiddleware:
+    """Post-middleware that records every dispatched action with timestamp."""
+    def middleware(store: CelStore, action: dict, result: Any) -> None:
+        pass
+    return middleware
+
+
+def vcard_pre_middleware(gate_items: list[dict], suite: Any) -> PreMiddleware:
+    """Create a pre-middleware that evaluates all vcard_pre gates."""
+    def middleware(store: CelStore, action: dict) -> dict | None:
+        from clm.cross_cutting.vcard import GateEvaluator
+
+        gates = GateEvaluator()
+        ctx = store.to_dict()
+        for item in gate_items:
+            if not gates.evaluate_pre(item, ctx, suite):
+                return None
+        return action
+    return middleware
+
+
+def vcard_post_middleware(gate_items: list[dict], suite: Any) -> PostMiddleware:
+    """Create a post-middleware that evaluates all vcard_post gates."""
+    def middleware(store: CelStore, action: dict, result: Any) -> None:
+        from clm.cross_cutting.vcard import GateEvaluator
+
+        gates = GateEvaluator()
+        ctx = store.to_dict()
+        for item in gate_items:
+            gates.evaluate_post(item, ctx, suite)
+    return middleware
+
+
+def _build_write_file_fn() -> Callable[[str, str], bool]:
+    """Build the write_file helper function for the store."""
+    def write_file(filepath: str, content: str) -> bool:
+        try:
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+            with open(filepath, "w", encoding="utf-8") as fw:
+                fw.write(content)
+            return True
+        except Exception:
+            return False
+    return write_file
+
+
+def build_store(
+    inputs: dict,
+    outputs: dict,
+    rc: int,
+    tmp_dir: str,
+    db: Any,
+    ctx: Any,
+    repo: Any,
+    classify_clm: Callable,
+    detect_dialect: Callable,
+    clm_root: str = "",
+    register_file_mcard_py: Callable | None = None,
+) -> "CelStore":
+    """Build a CelStore for a test case (replaces _build_post_context)."""
+    from clm.cross_cutting.cel_store import CelStore
+
+    if register_file_mcard_py is None:
+        from clm.layer1.protocols import get_file_registrar_hook
+
+        register_file_mcard_py = get_file_registrar_hook()
+
+    a_hash = os.environ.get("CLM_TRIAD_ABSTRACT_HASH", "")
+    c_hash = os.environ.get("CLM_TRIAD_CONCRETE_HASH", "")
+    if a_hash:
+        inputs["abstract_hash"] = a_hash
+    if c_hash:
+        inputs["concrete_hash"] = c_hash
+
+    state = StateSlice(inputs=inputs, outputs=outputs, rc=rc)
+    services = ServiceSlice(
+        db=db,
+        ctx=ctx,
+        repo=repo,
+        classify_clm=classify_clm,
+        detect_dialect=detect_dialect,
+        modules={
+            "write_file": _build_write_file_fn(),
+            "make_mcard_content": make_mcard_content,
+            "json": _json,
+            "io": _io,
+            "shutil": _shutil,
+            "redirect_stdout": redirect_stdout,
+            "redirect_stderr": redirect_stderr,
+            "clm_hash_string": clm_hash_string,
+            "compute_stripped_file_hash_py": compute_stripped_file_hash_py,
+            "resolve_active_hashes_py": resolve_active_hashes_py,
+            "register_file_mcard_py": register_file_mcard_py,
+            "get_load_manifest": get_load_manifest,
+            "get_load_manifest_str": get_load_manifest_str,
+            "evaluate_compose": evaluate_compose,
+            "_polyglot_runtime_execute": _polyglot_runtime_execute,
+            "evaluate_polyglot": evaluate_polyglot,
+            "load_normalized_manifest": load_normalized_manifest,
+        },
+    )
+    env = EnvSlice(
+        clm_root=clm_root,
+        tmp_dir=tmp_dir,
+        os=os,
+        sys=sys,
+        time=time,
+        hashlib=hashlib,
+        str=str,
+    )
+
+    store = CelStore(state=state, services=services, env=env)
+
+    effects = EffectRegistry()
+    register_default_effects(effects)
+    store.effects = effects
+
+    return store
+
+
+# Register store builder with cross_cutting (Dependency Inversion)
+try:
+    from clm.cross_cutting.cel_builder import register_store_builder
+
+    register_store_builder(build_store)
+except ImportError:
+    pass