clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/runtimes/lambda_calc.py

@@ -0,0 +1,126 @@
+"""
+Lambda Calculus runtime executor.
+
+Executes λ-calculus operations (α-β-η conversions) on MCard-stored terms.
+"""
+
+from typing import Any
+
+from clm.layer0.model.card import MCard
+
+from .base import RuntimeExecutor, register_runtime
+
+
+@register_runtime("lambda")
+class LambdaRuntimeExecutor(RuntimeExecutor):
+    """Lambda Calculus runtime executor.
+
+    Executes λ-calculus operations (α-β-η conversions) on MCard-stored terms.
+    """
+
+    def __init__(self, collection=None):
+        super().__init__()
+        self.collection = collection
+        self._lambda_runtime = None
+
+    def _get_runtime(self):
+        """Lazy initialization of LambdaRuntime."""
+        if self._lambda_runtime is None:
+            from clm.layer1.protocols import get_store
+            from clm.layer1.runtimes.factory import get_external_executor
+
+            if self.collection is None:
+                self.collection = get_store(":memory:")
+
+            lambda_cls = get_external_executor("lambda")
+            if lambda_cls is not None:
+                self._lambda_runtime = lambda_cls(self.collection)
+        return self._lambda_runtime
+
+    def execute(self, impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> Any:
+        """Execute Lambda Calculus operation."""
+        runtime = self._get_runtime()
+
+        # Build context from concrete implementation and context
+        # Prioritize ctx override, then 'process', then 'action', then 'operation'
+        operation = ctx.get(
+            "operation",
+            impl.get("process", impl.get("action", impl.get("operation", "normalize"))),
+        )
+        strategy = ctx.get("strategy", impl.get("strategy", "normal"))
+        max_steps = ctx.get(
+            "max_steps",
+            ctx.get("maxSteps", impl.get("max_steps", impl.get("maxSteps", 100))),
+        )
+
+        # Get expression from context or target
+        expression = ctx.get("expression")
+        if not expression:
+            # Try to get from balanced input arguments
+            balanced = ctx.get("balanced", {})
+            input_args = balanced.get("input_arguments", {})
+            expression = input_args.get("expression") or input_args.get("numeral")
+
+        if not expression or expression == "dummy_target":
+            # Check if target content looks like a Lambda expression
+            target_content = target.get_content().decode("utf-8", errors="ignore")
+            if target_content and ("λ" in target_content or "\\" in target_content):
+                expression = target_content
+            elif operation in (
+                "check-readiness",
+                "num-add",
+                "num-sub",
+                "num-mul",
+                "num-div",
+                "http-request",
+            ):
+                expression = "builtin"  # Placeholder
+            else:
+                return "Error: No Lambda expression provided"
+
+        # Execute through LambdaRuntime
+        # Create a full context by merging ctx and any other needed fields
+        full_ctx = ctx.copy()
+        full_ctx["expression"] = expression
+
+        # Get io_effects from context (override) or concrete implementation config
+        io_effects = impl.get("io_effects", {}).copy()
+        if isinstance(ctx.get("io_effects"), dict):
+            io_effects.update(ctx.get("io_effects"))
+
+        result = runtime.execute(
+            expression,
+            full_ctx,
+            {
+                "operation": operation,
+                "strategy": strategy,
+                "max_steps": max_steps,
+                "io_effects": io_effects,
+            },
+            "",
+        )
+
+        if result.success:
+            # Return appropriate result based on operation
+            if result.pretty_print:
+                return result.pretty_print
+            elif result.is_closed is not None:
+                return result.is_closed
+            elif result.free_variables is not None:
+                return result.free_variables
+            else:
+                return result.term_hash
+        else:
+            return f"Error: {result.error}"
+
+    def validate_environment(self) -> bool:
+        """Lambda runtime is always available (pure Python)."""
+        return True
+
+    def get_runtime_status(self) -> dict[str, Any]:
+        return {
+            "available": True,
+            "version": "1.0.0",
+            "command": "lambda",
+            "details": "Lambda Calculus α-β-η converter",
+        }

clm/layer1/runtimes/python.py

@@ -0,0 +1,288 @@
+"""
+Python runtime executor.
+
+Executes Python code directly in-process with sandboxing.
+"""
+
+import functools
+import importlib
+from collections.abc import Callable
+from typing import Any
+
+from clm.layer0.model.card import MCard
+
+from .base import RUNTIME_CONFIG, RuntimeExecutor, register_runtime
+
+# Module URI prefix for dynamic module imports
+MODULE_URI_PREFIX = "module://"
+
+# Import sandbox configuration
+try:
+    from clm.cross_cutting.config.settings import settings as _settings
+
+    ALLOWED_IMPORTS = _settings.ptr.allowed_imports
+    SAFE_BUILTINS = _settings.ptr.safe_builtins
+except ImportError:
+    ALLOWED_IMPORTS = {}
+    SAFE_BUILTINS = set()
+
+
+@register_runtime("python")
+class PythonRuntime(RuntimeExecutor):
+    """Python runtime executor - executes Python code directly in-process."""
+
+    # Operation handlers mapping
+    OPERATIONS: dict[str, Callable] = {}
+
+    # Operation handlers mapping
+    OPERATIONS: dict[str, Callable] = {}
+
+    def __init__(self):
+        super().__init__()
+        # Import operations from the extracted operations module
+        from ..operations import DEFAULT_OPERATIONS
+
+        # Register built-in operations from module
+        self.OPERATIONS = DEFAULT_OPERATIONS.copy()
+
+        # Add custom operation handler (requires self reference for sandboxing)
+        self.OPERATIONS["custom"] = self._op_custom
+
+    def execute(
+        self, concrete_impl: dict[str, Any], target: MCard, context: dict[str, Any]
+    ) -> Any:
+        # Check for module:// syntax first
+        code_file = concrete_impl.get("code_file", "")
+        if code_file.startswith(MODULE_URI_PREFIX):
+            return self._execute_module_logic(code_file, concrete_impl, target, context)
+
+        # Determine operation robustly without letting dicts/lists cause key errors
+        operation = concrete_impl.get("operation")
+        if not operation:
+            operation = concrete_impl.get("builtin")
+        if not operation:
+            op_cand = concrete_impl.get("process")
+            if isinstance(op_cand, str):
+                operation = op_cand
+            else:
+                op_cand = concrete_impl.get("action")
+                if isinstance(op_cand, str):
+                    operation = op_cand
+
+        if not operation:
+            # Auto-detect custom operation if code or process-script is present
+            has_proc_script = False
+            proc = concrete_impl.get("process")
+            if isinstance(proc, dict) and "script" in proc:
+                has_proc_script = True
+            elif isinstance(proc, list):
+                for p in proc:
+                    if (
+                        isinstance(p, dict)
+                        and p.get("type") == "python"
+                        and "script" in p
+                    ):
+                        has_proc_script = True
+                        break
+
+            if (
+                "code_file" in concrete_impl
+                or "code" in concrete_impl
+                or has_proc_script
+            ):
+                operation = "custom"
+            else:
+                operation = "identity"
+
+        handler = self.OPERATIONS.get(operation)
+
+        if handler:
+            return handler(concrete_impl, target, context)
+
+        # Fallback to custom operation if custom script/code is provided, even with a custom operation name
+        has_proc_script = False
+        proc = concrete_impl.get("process")
+        if isinstance(proc, dict) and "script" in proc:
+            has_proc_script = True
+        elif isinstance(proc, list):
+            for p in proc:
+                if isinstance(p, dict) and p.get("type") == "python" and "script" in p:
+                    has_proc_script = True
+                    break
+
+        if "code_file" in concrete_impl or "code" in concrete_impl or has_proc_script:
+            return self._op_custom(concrete_impl, target, context)
+
+        return f"Executed {operation} on {target.hash}"
+
+    # ─── Custom Operation ──────────────────────────────────────────────────────
+
+    def _op_custom(self, impl: dict, target: MCard, ctx: dict) -> Any:
+        code_file = impl.get("code_file", "")
+        if code_file.startswith(MODULE_URI_PREFIX):
+            return self._execute_module_logic(code_file, impl, target, ctx)
+
+        code = impl.get("code", "")
+        if not code:
+            proc = impl.get("process")
+            if isinstance(proc, dict):
+                code = proc.get("script", "")
+            elif isinstance(proc, list):
+                for p in proc:
+                    if isinstance(p, dict) and p.get("type") == "python":
+                        code = p.get("script", "")
+                        break
+        if not code:
+            return "Error: No code provided"
+
+        return self._exec_sandboxed(code, impl, target, ctx)
+
+    # ─── Sandboxed Execution ───────────────────────────────────────────────────
+
+    def _make_safe_import(self) -> Callable:
+        """Create a safe import function."""
+
+        def safe_import(name, _globals=None, _locals=None, _fromlist=(), _level=0):
+            if name in ALLOWED_IMPORTS:
+                return importlib.import_module(name)
+            raise ImportError(f"Import of '{name}' is not allowed")
+
+        return safe_import
+
+    def _make_namespace(self, target: MCard, context: dict) -> dict:
+        """Create a sandboxed namespace for code execution."""
+        import builtins as builtins_module
+        import math
+
+        # Build safe builtins dict from the builtins module
+        safe_builtins = {}
+        for name in SAFE_BUILTINS:
+            if hasattr(builtins_module, name):
+                safe_builtins[name] = getattr(builtins_module, name)
+
+        safe_builtins["__import__"] = self._make_safe_import()
+        safe_builtins["__build_class__"] = builtins_module.__build_class__
+
+        return {
+            "__builtins__": safe_builtins,
+            "target": target.get_content(),
+            "context": context,
+            "result": None,
+            "math": math,
+            "__name__": "__clm_runtime__",
+        }
+
+    @staticmethod
+    @functools.lru_cache(maxsize=1024)
+    def _compile_code(code: str) -> Any:
+        """Compile Python code with an LRU cache to prevent memory leaks."""
+        return compile(code, "<string>", "exec")
+
+    def _exec_sandboxed(self, code: str, impl: dict, target: MCard, ctx: dict) -> Any:
+        """Execute code in a sandboxed namespace with compilation caching."""
+        namespace = self._make_namespace(target, ctx)
+
+        try:
+            compiled_code = self._compile_code(code)
+            exec(compiled_code, namespace)  # nosec B102
+
+            entry_point = impl.get("entry_point")
+            if entry_point:
+                return self._call_entry_point(namespace, entry_point, impl, target, ctx)
+            return namespace.get("result")
+        except Exception as e:
+            return f"Error executing Python code: {e}"
+
+    def _call_entry_point(
+        self, ns: dict, entry: str, impl: dict, target: MCard, ctx: dict
+    ) -> Any:
+        """Call a function defined in namespace."""
+        if entry not in ns or not callable(ns[entry]):
+            return f"Error: Entry point '{entry}' not found or not callable. Keys: {list(ns.keys())}"
+
+        func = ns[entry]
+        arg = self._prepare_argument(impl, target, ctx)
+        return func(arg)
+
+    def _prepare_argument(self, impl: dict, target: MCard, ctx: dict) -> Any:
+        """Prepare argument for entry point function."""
+        inputs_def = impl.get("implementation", {}).get("inputs", {})
+
+        # If context has operation or params keys, the entry point likely expects context
+        if ctx.get("operation") or ctx.get("params") or ctx.get("op"):
+            combined = ctx.copy()
+            content = target.get_content()
+            if isinstance(content, bytes):
+                try:
+                    content = content.decode("utf-8")
+                except (UnicodeDecodeError, AttributeError):
+                    pass
+            combined["value"] = content
+            combined["__input_content__"] = content
+            return combined
+
+        if not inputs_def:
+            return target.get_content()
+
+        input_name = list(inputs_def.keys())[0]
+        input_type = inputs_def[input_name]
+
+        if input_name == "context":
+            return ctx
+
+        raw = target.get_content()
+        converters = {
+            "float": lambda: float(raw.decode("utf-8")),
+            "int": lambda: int(raw.decode("utf-8")),
+            "str": lambda: raw.decode("utf-8"),
+        }
+
+        try:
+            return converters.get(input_type, lambda: raw)()
+        except (ValueError, TypeError, UnicodeDecodeError):
+            return raw
+
+    # ─── Module Logic ──────────────────────────────────────────────────────────
+
+    def _execute_module_logic(
+        self, uri: str, impl: dict, target: MCard, ctx: dict
+    ) -> Any:
+        """Execute logic imported from a Python module."""
+        path = uri.replace(MODULE_URI_PREFIX, "")
+        module_name, func_name = (
+            path.split(":", 1)
+            if ":" in path
+            else (path, impl.get("entry_point", "logic"))
+        )
+
+        try:
+            module = importlib.import_module(module_name)
+            func = getattr(module, func_name)
+            if not callable(func):
+                return f"Error: {func_name} in {module_name} is not callable"
+
+            arg = (
+                target.get_content().decode("utf-8")
+                if hasattr(target, "get_content")
+                else target
+            )
+            return func(arg)
+        except ImportError as e:
+            return f"Error importing module {module_name}: {e}"
+        except AttributeError:
+            return f"Error: Function {func_name} not found in {module_name}"
+        except (ValueError, TypeError, RuntimeError, OSError) as e:
+            return f"Error executing module logic: {e}"
+
+    def validate_environment(self) -> bool:
+        return True
+
+    def get_runtime_status(self) -> dict[str, Any]:
+        import sys
+
+        return {
+            "available": True,
+            "version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            "command": RUNTIME_CONFIG.get("python", {}).get("command", "python3"),
+            "details": f"Python {sys.version}",
+        }

clm/layer1/runtimes/python_runtime.py

@@ -0,0 +1,41 @@
+"""
+Python Native Sandbox Evaluator
+
+Invoked by the Meta Circular Evaluator to execute Python dynamically.
+Expects input as JSON on stdin.
+"""
+
+import json
+import sys
+import traceback
+
+
+def main():
+    try:
+        input_data = sys.stdin.read()
+        payload = json.loads(input_data)
+
+        target = payload.get("target")
+        context = payload.get("context", {})
+        code = payload.get("code", "")
+
+        # Execute securely in a restricted dictionary namespace
+        safe_globals = context.copy()
+
+        # Pass the target variable inside for script evaluation
+        safe_globals["target"] = target
+        safe_globals["context"] = context
+
+        exec(code, safe_globals)
+
+        # Scripts must place their output into `result` variable
+        output = safe_globals.get("result", None)
+
+        print(json.dumps(output))
+    except Exception as e:
+        print(f"Compilation error: {e}\\n{traceback.format_exc()}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

clm/layer1/runtimes/script.py

@@ -0,0 +1,114 @@
+"""
+Script-based runtimes (Lean, R, Julia).
+
+These runtimes execute script files via interpreter subprocess.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+from clm.cross_cutting.config.config_constants import PTR_LEAN_VALIDATE_TIMEOUT_SECS
+from clm.layer0.model.card import MCard
+
+from .base import (
+    JULIA_TIMEOUT,
+    LEAN_TIMEOUT,
+    R_TIMEOUT,
+    RUNTIME_CONFIG,
+    SubprocessRuntime,
+    register_runtime,
+)
+
+
+class ScriptRuntime(SubprocessRuntime):
+    """Base class for runtimes that execute script files."""
+
+    file_key = "code_file"
+    run_args: list[str] = []
+
+    def execute(self, impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> Any:
+        code_file = impl.get(self.file_key)
+        if not code_file:
+            return f"Error: No {self.runtime_name} code file provided"
+
+        # Normalize command to list
+        base_cmd = self.command if isinstance(self.command, list) else [self.command]
+
+        cmd = base_cmd + self.run_args + [code_file, json.dumps(ctx)]
+        return self._run_subprocess(cmd, target, ctx, self.timeout)
+
+
+@register_runtime("lean")
+class LeanRuntime(ScriptRuntime):
+    """Lean 4 runtime executor."""
+
+    runtime_name = "Lean"
+    run_args = ["--run"]
+    timeout = LEAN_TIMEOUT
+
+    def __init__(self):
+        super().__init__()
+        # Dynamic check for elan to support specific toolchains (e.g. v4.25.2)
+        # Matches JS implementation in mcard-js/src/ptr/node/runtimes/lean.ts
+        elan_path = Path.home() / ".elan" / "bin" / "elan"
+
+        # Check explicit environment variable first
+        env_lean_cmd = RUNTIME_CONFIG.get("lean", {}).get("command")
+
+        if env_lean_cmd and env_lean_cmd != "lean":
+            # Use configured command if it's specific
+            self.command = env_lean_cmd
+        elif elan_path.exists():
+            # Use elan to ensure we use the same version as JS tests
+            # 'elan run' avoids downloading 'stable' if we pin to v4.25.2 match JS
+            self.command = [str(elan_path), "run", "leanprover/lean4:v4.25.2", "lean"]
+        else:
+            # Fallback to system lean (subject to lean-toolchain file)
+            self.command = "lean"
+
+    def validate_environment(self) -> bool:
+        # Lean 4 takes longer to initialize, use extended timeout
+        return self._check_command(
+            self.command, self.version_flag, timeout=PTR_LEAN_VALIDATE_TIMEOUT_SECS
+        )
+
+    def execute(self, impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> Any:
+        """Execute Lean script, passing input as the argument."""
+        code_file = impl.get(self.file_key)
+        if not code_file:
+            return f"Error: No {self.runtime_name} code file provided"
+
+        # Determine what to pass as the argument:
+        # 1. If context has 'op', 'a', 'b' keys (polyglot mode), use context as JSON
+        # 2. Otherwise, use target content (standalone CLM mode)
+        if ctx and ("op" in ctx or "a" in ctx or "n" in ctx):
+            # Polyglot/advanced mode - context contains the actual input data
+            input_data = json.dumps(ctx)
+        else:
+            # Standalone CLM mode - target content is the JSON input
+            input_data = target.get_content().decode("utf-8", errors="ignore")
+
+        # Normalize command to list
+        base_cmd = self.command if isinstance(self.command, list) else [self.command]
+
+        cmd = base_cmd + self.run_args + [code_file, input_data]
+        return self._run_subprocess(cmd, target, ctx, self.timeout)
+
+
+@register_runtime("r")
+class RRuntime(ScriptRuntime):
+    """R runtime executor."""
+
+    runtime_name = "R"
+    command = RUNTIME_CONFIG.get("r", {}).get("command") or "Rscript"
+    timeout = R_TIMEOUT
+
+
+@register_runtime("julia")
+class JuliaRuntime(ScriptRuntime):
+    """Julia runtime executor."""
+
+    runtime_name = "Julia"
+    command = RUNTIME_CONFIG.get("julia", {}).get("command") or "julia"
+    timeout = JULIA_TIMEOUT