clm-kernel 0.0.0__py3-none-any.whl

clm/__init__.py

@@ -0,0 +1,230 @@
+"""CLM Python Engine Package (Sprint 384 / Layer-Stratified).
+
+Exposes the clean public API of the CLM execution engine.
+New code should import from specific layer packages:
+  from clm.layer0.db import CLMDB
+  from clm.layer1.petri import petri_run_net
+
+The top-level re-exports below are maintained for backward compatibility,
+with higher-strata symbols loaded lazily (PEP 562) to prevent upward import leakage.
+"""
+
+from typing import Any
+
+# -- Layer 0: Kenotic Core ---------------------------------------
+from clm.cross_cutting.mcard import Card
+from clm.cross_cutting.native import (
+    HAS_RUST_ACCELERATION,
+    clm_hash_file_fast,
+    compute_blake3,
+    crdt_merge_fast,
+    evaluate_manifest,
+)
+from clm.cross_cutting.pcard import BalancedRunner, OperationRegistry
+from clm.cross_cutting.telemetry import jsonl_emit
+from clm.cross_cutting.vcard import Marking, VCardSandwich, vcard_sandwich
+from clm.layer0.context import CLMContext
+from clm.layer0.exceptions import (
+    AlgebraError,
+    CLMError,
+    DatabaseError,
+    ExecutionError,
+    GatewayError,
+    TypeValidationError,
+)
+from clm.layer0.math_utils import math_gcd, math_lcm, solve_nullspace
+from clm.layer0.type_registry import TypeRegistry
+from clm.layer0.utils import (
+    clm_hash_file,
+    clm_hash_string,
+    detect_host_os,
+    extract_python_script_from_yaml,
+    get_bash_command,
+    is_docker_live,
+    normalize_line_endings_bytes,
+    normalize_line_endings_str,
+    resolve_clm_path,
+    verify_file_hash,
+)
+
+# -- Lazy Higher-Strata Symbols (PEP 562) -------------------------
+_LAZY_HIGHER_STRATA = {
+    # Layer 1: CPN VM & Verifiers
+    "ColoredPetriVM": ("clm.layer1.petri", "ColoredPetriVM"),
+    "petri_run_net": ("clm.layer1.petri", "petri_run_net"),
+    "compose_conditions_cmd": ("clm.layer1.gate_composer", "compose_conditions_cmd"),
+    "run_nested_evaluate": ("clm.layer1.gate_composer", "run_nested_evaluate"),
+    "evaluate_compose": ("clm.layer1.runtime_adapter", "evaluate_compose"),
+    "evaluate_polyglot": ("clm.layer1.runtime_adapter", "evaluate_polyglot"),
+    "run_internal_reference_test": ("clm.layer1.runtime_adapter", "run_internal_reference_test"),
+    "run_algebra_op": ("clm.layer1.test_runner", "run_algebra_op"),
+    "test_baldwin_operators": ("clm.layer1.test_runner", "test_baldwin_operators"),
+    "check_precondition_py": ("clm.layer1.verifier", "check_precondition_py"),
+    "emit_exec_mcard_py": ("clm.layer1.verifier", "emit_exec_mcard_py"),
+    "get_load_manifest": ("clm.layer1.verifier", "get_load_manifest"),
+    "get_load_manifest_str": ("clm.layer1.verifier", "get_load_manifest_str"),
+    "normalize_output_py": ("clm.layer1.verifier", "normalize_output_py"),
+    "resolve_active_hashes_py": ("clm.layer1.verifier", "resolve_active_hashes_py"),
+    "validate_postcondition": ("clm.layer1.verifier", "validate_postcondition"),
+    "verify_precondition": ("clm.layer1.verifier", "verify_precondition"),
+    # Layer 0 & Storage Substrate: Kenotic Core & Persistence (Loaded lazily)
+    "assess_equivalence_py": ("clm.layer0.algebra", "assess_equivalence_py"),
+    "directory_fs_scan_py": ("clm.layer0.algebra", "directory_fs_scan_py"),
+    "directory_to_db_py": ("clm.layer0.algebra", "directory_to_db_py"),
+    "load_normalized_manifest": ("clm.layer0.algebra", "load_normalized_manifest"),
+    "CLMDB": ("clm.layer2.storage", "CLMDB"),
+    "CLMRepository": ("clm.layer2.storage", "CLMRepository"),
+    "init_tridb": ("clm.layer2.storage", "init_tridb"),
+    "memorize_mcard": ("clm.layer2.storage", "memorize_mcard"),
+    "register_handle": ("clm.layer2.storage", "register_handle"),
+    "resolve_handle_content": ("clm.layer2.storage", "resolve_handle_content"),
+    "resolve_handle_hash": ("clm.layer2.storage", "resolve_handle_hash"),
+    # Layer 2: Storage Adapters & Classifiers
+    "classify_clm": ("clm.layer2.classifier", "classify_clm"),
+    "detect_dialect": ("clm.layer2.classifier", "detect_dialect"),
+    "register_file_mcard_py": ("clm.layer2.file_registrar", "register_file_mcard_py"),
+    "detect_encoding": ("clm.layer2.mime", "detect_encoding"),
+    "detect_mime": ("clm.layer2.mime", "detect_mime"),
+    "get_magic_rules": ("clm.layer2.mime", "get_magic_rules"),
+    "is_binary": ("clm.layer2.mime", "is_binary"),
+    "is_text": ("clm.layer2.mime", "is_text"),
+    "validate": ("clm.layer2.mime", "validate"),
+    # Layer 3: Network Gateway
+    "remote_handle_resolver": ("clm.layer3.gateway", "remote_handle_resolver"),
+    "route_handle": ("clm.layer3.gateway", "route_handle"),
+    # Layer 4: CLI & Sovereign Execution
+    "evaluate_cmd": ("clm.layer4.cli", "evaluate_cmd"),
+    "main": ("clm.layer4._sovereign_executor", "main"),
+    # Layer 5: Continuous Learning Stratum (Sprint 386)
+    "ContinuousLearningEngine": ("clm.layer5.learning", "ContinuousLearningEngine"),
+    "evaluate_epistemic_fitness": ("clm.layer5.learning", "evaluate_epistemic_fitness"),
+    "compute_delta_e": ("clm.layer5.learning", "compute_delta_e"),
+    "seal_epoch": ("clm.layer5.learning", "seal_epoch"),
+    "advance_boundary": ("clm.layer5.learning", "advance_boundary"),
+    "close_gamma_loop": ("clm.layer5.learning", "close_gamma_loop"),
+    "extract_type_lattice": ("clm.layer5.type_lattice", "extract_type_lattice"),
+    "generate_lattice_html": ("clm.layer5.type_lattice", "generate_lattice_html"),
+    "verify_type_univalence": ("clm.layer5.type_lattice", "verify_type_univalence"),
+}
+
+# Wire cross-cutting dependency inversion resolvers lazily
+from clm.cross_cutting.cel_builder import register_store_builder_resolver
+from clm.cross_cutting.native import register_manifest_evaluator_resolver
+from clm.cross_cutting.pcard import register_classifier_hook_resolver
+
+register_store_builder_resolver(
+    lambda: getattr(__import__("clm.layer1.cel.builder", fromlist=["build_store"]), "build_store", None)
+)
+register_manifest_evaluator_resolver(
+    lambda: getattr(__import__("clm.layer1.verifier", fromlist=["run_nested_evaluate"]), "run_nested_evaluate", None)
+)
+register_classifier_hook_resolver(
+    lambda: (
+        getattr(__import__("clm.layer2.classifier", fromlist=["classify_clm"]), "classify_clm", None),
+        getattr(__import__("clm.layer2.classifier", fromlist=["detect_dialect"]), "detect_dialect", None),
+    )
+)
+
+
+def __getattr__(name: str) -> Any:
+    if name in _LAZY_HIGHER_STRATA:
+        module_path, attr_name = _LAZY_HIGHER_STRATA[name]
+        import importlib
+
+        try:
+            mod = importlib.import_module(module_path)
+            val = getattr(mod, attr_name)
+        except (ImportError, AttributeError):
+            val = None
+        globals()[name] = val
+        return val
+    raise AttributeError(f"module 'clm' has no attribute '{name}'")
+
+
+__all__ = [
+    "CLMError",
+    "TypeValidationError",
+    "DatabaseError",
+    "ExecutionError",
+    "AlgebraError",
+    "GatewayError",
+    "resolve_clm_path",
+    "clm_hash_file",
+    "clm_hash_string",
+    "detect_host_os",
+    "is_docker_live",
+    "get_bash_command",
+    "normalize_line_endings_bytes",
+    "normalize_line_endings_str",
+    "verify_file_hash",
+    "extract_python_script_from_yaml",
+    "CLMDB",
+    "CLMRepository",
+    "init_tridb",
+    "memorize_mcard",
+    "resolve_handle_content",
+    "resolve_handle_hash",
+    "register_handle",
+    "math_gcd",
+    "math_lcm",
+    "solve_nullspace",
+    "TypeRegistry",
+    "CLMContext",
+    "load_normalized_manifest",
+    "assess_equivalence_py",
+    "directory_fs_scan_py",
+    "directory_to_db_py",
+    "petri_run_net",
+    "ColoredPetriVM",
+    "compose_conditions_cmd",
+    "run_nested_evaluate",
+    "run_internal_reference_test",
+    "evaluate_polyglot",
+    "evaluate_compose",
+    "get_load_manifest_str",
+    "get_load_manifest",
+    "verify_precondition",
+    "validate_postcondition",
+    "emit_exec_mcard_py",
+    "resolve_active_hashes_py",
+    "check_precondition_py",
+    "normalize_output_py",
+    "run_algebra_op",
+    "test_baldwin_operators",
+    "classify_clm",
+    "detect_dialect",
+    "register_file_mcard_py",
+    "detect_encoding",
+    "is_binary",
+    "is_text",
+    "get_magic_rules",
+    "detect_mime",
+    "validate",
+    "route_handle",
+    "remote_handle_resolver",
+    "evaluate_cmd",
+    "main",
+    "jsonl_emit",
+    "VCardSandwich",
+    "vcard_sandwich",
+    "Card",
+    "Marking",
+    "BalancedRunner",
+    "OperationRegistry",
+    "HAS_RUST_ACCELERATION",
+    "compute_blake3",
+    "clm_hash_file_fast",
+    "crdt_merge_fast",
+    "evaluate_manifest",
+    "ContinuousLearningEngine",
+    "evaluate_epistemic_fitness",
+    "compute_delta_e",
+    "seal_epoch",
+    "advance_boundary",
+    "close_gamma_loop",
+    "extract_type_lattice",
+    "generate_lattice_html",
+    "verify_type_univalence",
+]
+
+__version__ = "0.2.0"

clm/__main__.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""CLM Runner entry-point — invoked via `python -m clm` or `clm_runner.py`."""
+
+import os
+import sys
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except AttributeError:
+        pass
+    git_bin = r"C:\Program Files\Git\bin"
+    if os.path.exists(git_bin) and git_bin not in os.environ.get("PATH", ""):
+        os.environ["PATH"] = git_bin + os.pathsep + os.environ.get("PATH", "")
+
+# Ensure the scripts directory is in sys.path so `clm` package is importable
+_scripts_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _scripts_dir not in sys.path:
+    sys.path.insert(0, _scripts_dir)
+
+from clm.layer4._sovereign_executor import main  # noqa: E402
+
+if __name__ == "__main__":
+    main()

clm/cross_cutting/__init__.py

@@ -0,0 +1,50 @@
+"""CLM cross_cutting layer package (Sprint 384 / DEL-384-03).
+
+MVP Cards triad modules:
+    * mcard  — Data Plane (Σ-type / Carrier / Noun Phrase)
+    * pcard  — Control Plane (Π-type / Lens / Verb Phrase)
+    * vcard  — Application Plane (Id-type / Arena + Action / Sentence)
+
+Contains horizontal, stateless utilities and Card Triad models. Zero upward imports
+into layer1, layer2, layer3, or layer4.
+"""
+
+from clm.cross_cutting.mcard import Card
+from clm.cross_cutting.pcard import (
+    BalancedRunner,
+    OperationRegistry,
+    run_balanced_expectations,
+)
+from clm.cross_cutting.telemetry import jsonl_emit, jsonl_emit_typed, reset_telemetry_cache
+from clm.cross_cutting.vcard import (
+    GateEvaluator,
+    Marking,
+    VCardSandwich,
+    vcard_post_gate,
+    vcard_pre_gate,
+    vcard_sandwich,
+)
+from clm.layer0.algebra_baldwin import exclude_clm_py  # noqa: F401
+from clm.layer0.model.card_triad import MCard, PCard, VCard
+from clm.layer0.utils import clm_hash_file  # noqa: F401
+
+__all__ = [
+    "jsonl_emit",
+    "jsonl_emit_typed",
+    "reset_telemetry_cache",
+    "Card",
+    "MCard",
+    "PCard",
+    "VCard",
+    "Marking",
+    "VCardSandwich",
+    "vcard_sandwich",
+    "vcard_pre_gate",
+    "vcard_post_gate",
+    "GateEvaluator",
+    "OperationRegistry",
+    "BalancedRunner",
+    "run_balanced_expectations",
+    "clm_hash_file",
+    "exclude_clm_py",
+]

clm/cross_cutting/_test_runner.py

@@ -0,0 +1,36 @@
+"""Shared test-runner command builder (Sprint 132.3 DRY consolidation).
+
+Extracted from the byte-identical duplicate in ``cel_ops.op_run_test_suite``
+and ``effects.register_default_effects._run_test_suite_effect``.
+Single source of truth for .py/.sh/.rs interpreter selection.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def build_test_command(test_path: str, clm_root: str) -> list[str]:
+    """Build the interpreter command for a test file.
+
+    Args:
+        test_path: Path to the test file.
+        clm_root: CLM workspace root (for .venv lookup).
+
+    Returns:
+        The command list to pass to subprocess.run.
+
+    Raises:
+        ValueError: If the test file extension is not .py, .sh, or .rs.
+    """
+    ext = os.path.splitext(test_path)[1].lower()
+    if ext == ".py":
+        interpreter = os.path.join(clm_root, ".venv", "bin", "python3")
+        if not os.path.exists(interpreter):
+            interpreter = "python3"
+        return [interpreter, test_path]
+    if ext == ".sh":
+        return ["bash", test_path]
+    if ext == ".rs":
+        return ["cargo", "test", "--manifest-path", test_path]
+    raise ValueError(f"run_test_suite: unknown extension '{ext}' for {test_path}")

clm/cross_cutting/async_utils.py

@@ -0,0 +1,25 @@
+"""Async Task Isolation and Event Loop Re-Entrancy Utilities (Sprint 178).
+
+Prevents event loop deadlocks and RuntimeError when CLM is embedded inside
+async servers (Satori WebSocket bridge, FastAPI, Jupyter).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+from typing import Any, Coroutine
+
+
+def run_async_safe(coro: Coroutine[Any, Any, Any]) -> Any:
+    """Run an async coroutine safely, supporting both standalone and embedded event loops."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
+
+    if loop and loop.is_running():
+        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+            return pool.submit(asyncio.run, coro).result()
+    else:
+        return asyncio.run(coro)

clm/cross_cutting/cel_builder.py

@@ -0,0 +1,123 @@
+"""CelStore middleware factories and store builder facade (Sprint 133.2 / Sprint 384).
+
+Extracted from ``cel_store.py``. Middleware factories for action logging
+and VCard gate evaluation, plus backward-compatible facade for ``build_store()``
+delegating to Stratum 1 ``clm.layer1.cel.builder`` (DEL-384-04).
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from clm.cross_cutting.cel_slices import EnvSlice, ServiceSlice, StateSlice  # noqa: F401
+from clm.cross_cutting.effects import EffectRegistry, register_default_effects  # noqa: F401
+
+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."""
+    import os
+
+    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
+
+
+_store_builder_fn: Callable | None = None
+_store_builder_resolver: Callable[[], Callable | None] | None = None
+
+
+def register_store_builder(fn: Callable) -> None:
+    """Register the canonical CelStore builder from Layer 1."""
+    global _store_builder_fn
+    _store_builder_fn = fn
+
+
+def register_store_builder_resolver(resolver: Callable[[], Callable | None]) -> None:
+    """Register a lazy resolver for the CelStore builder."""
+    global _store_builder_resolver
+    _store_builder_resolver = resolver
+
+
+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 delegating to Layer 1 builder."""
+    builder = _store_builder_fn
+    if builder is None and _store_builder_resolver is not None:
+        builder = _store_builder_resolver()
+
+    if builder is None:
+        raise RuntimeError(
+            "No CelStore builder registered with cross_cutting. "
+            "Initialize Layer 1 (clm.layer1.cel.builder) before building stores."
+        )
+
+    return builder(
+        inputs=inputs,
+        outputs=outputs,
+        rc=rc,
+        tmp_dir=tmp_dir,
+        db=db,
+        ctx=ctx,
+        repo=repo,
+        classify_clm=classify_clm,
+        detect_dialect=detect_dialect,
+        clm_root=clm_root,
+        register_file_mcard_py=register_file_mcard_py,
+    )