clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/runtimes/factory.py

@@ -0,0 +1,203 @@
+"""
+Runtime Factory for creating runtime executors.
+
+This module provides the factory pattern for creating and caching
+runtime executors based on configuration.
+"""
+
+import logging
+from typing import Any
+
+from .base import RUNTIME_REGISTRY, RuntimeExecutor, RuntimeType, resolve_runtime_alias
+
+_external_executors: dict[Any, Any] = {}
+
+
+def register_external_executor(runtime_key: Any, executor_or_factory: Any) -> None:
+    """Register an external runtime executor class or factory (e.g. from Layer 3)."""
+    _external_executors[runtime_key] = executor_or_factory
+
+
+def get_external_executor(runtime_key: Any) -> Any:
+    """Retrieve an externally registered runtime executor or factory."""
+    return _external_executors.get(runtime_key)
+
+
+class RuntimeFactory:
+    """Factory for creating runtime executors based on configuration."""
+
+    _executors: dict[RuntimeType, RuntimeExecutor] = {}
+    _availability_cache: dict[RuntimeType, bool] = {}  # Cache for availability checks
+    _detailed_status_cache: dict[str, dict[str, Any]] | None = None
+
+    @classmethod
+    def _get_executor_class(cls, runtime_type: RuntimeType) -> type | None:
+        """Dynamically load the executor class from the global registry."""
+
+        if not RUNTIME_REGISTRY:
+            # Trigger module loading to populate registry if empty
+            pass
+
+        return RUNTIME_REGISTRY.get(runtime_type.value)
+
+    @classmethod
+    def clear_cache(cls) -> None:
+        """Clear cached availability data. Useful for testing or env changes."""
+        cls._availability_cache.clear()
+        cls._detailed_status_cache = None
+        cls._executors.clear()
+
+    @classmethod
+    def get_executor(cls, runtime_type: str) -> RuntimeExecutor | None:
+        """Get or create a runtime executor for the specified type."""
+        # Handle LLM runtime specially (dynamic import to avoid circular dependency)
+        if runtime_type.lower() == "llm":
+            return cls._get_llm_executor()
+
+        # Handle Lambda runtime specially (needs CardCollection)
+        if runtime_type.lower() == "lambda":
+            return cls._get_lambda_executor()
+
+        # Resolve aliases from shared runtime_types.json (e.g., 'node' -> 'javascript')
+        runtime_type = resolve_runtime_alias(runtime_type)
+
+        try:
+            rt_type = RuntimeType(runtime_type.lower())
+        except ValueError:
+            logging.error(f"Unsupported runtime type: {runtime_type}")
+            return None
+
+        if rt_type not in cls._executors:
+            executor = cls._create_executor(rt_type)
+            if executor and cls._is_available(rt_type, executor):
+                cls._executors[rt_type] = executor
+            else:
+                logging.warning(f"Runtime {runtime_type} not available or invalid")
+                return None
+
+        return cls._executors.get(rt_type)
+
+    @classmethod
+    def _is_available(cls, rt_type: RuntimeType, executor: RuntimeExecutor) -> bool:
+        """Check if runtime is available, using cache."""
+        if rt_type not in cls._availability_cache:
+            cls._availability_cache[rt_type] = executor.validate_environment()
+        return cls._availability_cache[rt_type]
+
+    @classmethod
+    def _get_llm_executor(cls) -> RuntimeExecutor | None:
+        """Get LLM executor via external registry or registered adapter (INV-383-01 / DEL-383-04)."""
+        if RuntimeType.LLM in cls._executors:
+            return cls._executors[RuntimeType.LLM]
+
+        executor_factory = _external_executors.get(RuntimeType.LLM) or _external_executors.get("llm")
+        if executor_factory is not None:
+            try:
+                executor = (
+                    executor_factory()
+                    if callable(executor_factory) and not isinstance(executor_factory, RuntimeExecutor)
+                    else executor_factory
+                )
+                if executor and executor.validate_environment():
+                    cls._executors[RuntimeType.LLM] = executor
+                    return executor
+                else:
+                    logging.warning("LLM runtime not available (Ollama not running?)")
+                    return None
+            except Exception as e:
+                logging.error(f"Failed to instantiate LLM runtime: {e}")
+                return None
+
+        return None
+
+    @classmethod
+    def _get_lambda_executor(cls) -> RuntimeExecutor | None:
+        """Get Lambda Calculus executor using CardStoreProtocol (INV-383-01)."""
+        if RuntimeType.LAMBDA in cls._executors:
+            return cls._executors[RuntimeType.LAMBDA]
+
+        try:
+            from clm.layer1.protocols import get_store
+
+            from .lambda_calc import LambdaRuntimeExecutor
+
+            # Create an in-memory collection for Lambda terms via protocol
+            collection = get_store(":memory:")
+            executor = LambdaRuntimeExecutor(collection)
+            cls._executors[RuntimeType.LAMBDA] = executor
+            return executor
+        except Exception as e:
+            logging.error(f"Failed to import Lambda runtime: {e}")
+            return None
+
+    @classmethod
+    def _create_executor(cls, runtime_type: RuntimeType) -> RuntimeExecutor | None:
+        """Create a new runtime executor."""
+        # Handle LLM specially via registry
+        if runtime_type == RuntimeType.LLM:
+            executor_factory = _external_executors.get(RuntimeType.LLM) or _external_executors.get("llm")
+            if executor_factory is not None:
+                return (
+                    executor_factory()
+                    if callable(executor_factory) and not isinstance(executor_factory, RuntimeExecutor)
+                    else executor_factory
+                )
+            return None
+
+        executor_class = cls._get_executor_class(runtime_type)
+        return executor_class() if executor_class else None
+
+    @classmethod
+    def list_available_runtimes(cls) -> dict[str, bool]:
+        """List all runtime types and their availability (cached)."""
+        result = {}
+        for rt in RuntimeType:
+            if rt not in cls._availability_cache:
+                executor = cls._create_executor(rt)
+                cls._availability_cache[rt] = (
+                    executor.validate_environment() if executor else False
+                )
+            result[rt.value] = cls._availability_cache[rt]
+        return result
+
+    @classmethod
+    def get_detailed_status(cls) -> dict[str, dict[str, Any]]:
+        """Get detailed status information for all runtimes (cached)."""
+        if cls._detailed_status_cache is not None:
+            return cls._detailed_status_cache
+
+        status = {}
+        for rt in RuntimeType:
+            executor = cls._create_executor(rt)
+            status[rt.value] = (
+                executor.get_runtime_status()
+                if executor
+                else {
+                    "available": False,
+                    "version": None,
+                    "command": rt.value,
+                    "details": "Runtime executor not implemented",
+                }
+            )
+        cls._detailed_status_cache = status
+        return status
+
+    @classmethod
+    def at_least_one_available(cls) -> bool:
+        """Check if at least one runtime is available."""
+        return any(cls.list_available_runtimes().values())
+
+    @classmethod
+    def print_status(cls, verbose: bool = False) -> None:
+        """Print runtime status to console."""
+        print("\n=== Polyglot Runtime Status ===")
+        for name, info in cls.get_detailed_status().items():
+            if info["available"]:
+                ver = f" {info['version']}" if info["version"] else ""
+                detail = f": {info['details']}" if verbose and info["details"] else ""
+                print(f"✓ {name.capitalize()}{ver}{detail}")
+            else:
+                print(f"✗ {name.capitalize()} not found")
+
+        available = sum(1 for i in cls.get_detailed_status().values() if i["available"])
+        print(f"{'=' * 31}\nAvailable: {available}/{len(RuntimeType)} runtimes")

clm/layer1/runtimes/javascript.py

@@ -0,0 +1,321 @@
+"""
+JavaScript runtime executor.
+
+Executes JavaScript code via Node.js or Deno subprocess.
+"""
+
+import json
+import os
+import subprocess
+from typing import Any
+
+from clm.cross_cutting.config.config_constants import PTR_JAVASCRIPT_TIMEOUT_SECS
+from clm.layer0.model.card import MCard
+
+from ..operations import DEFAULT_OPERATIONS
+from .base import DEFAULT_TIMEOUT, RUNTIME_CONFIG, SubprocessRuntime, register_runtime
+
+
+@register_runtime("javascript")
+class JavaScriptRuntime(SubprocessRuntime):
+    """JavaScript runtime executor - executes via Node.js or Deno."""
+
+    runtime_name = "JavaScript"
+    timeout = DEFAULT_TIMEOUT
+
+    def __init__(self, use_deno: bool = False):
+        super().__init__()
+        runtime_key = "deno" if use_deno else "javascript"
+        config = RUNTIME_CONFIG.get(runtime_key, RUNTIME_CONFIG.get("javascript", {}))
+        self.command = config.get("command") or "node"
+        self.eval_flag = config.get("eval_flag") or "--eval"
+        self.use_deno = use_deno
+
+    def execute(self, impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> Any:
+        # Handle run_command builtin
+        if impl.get("builtin") == "run_command":
+            config = impl.get("config", {})
+            cmd = config.get("command")
+            if not cmd:
+                return "Error: No command provided"
+
+            try:
+                res = subprocess.run(
+                    cmd,
+                    shell=True,  # nosec B602
+                    capture_output=True,
+                    text=True,
+                    timeout=self.timeout,
+                )
+                if res.returncode != 0:
+                    return f"Error: Command failed: {res.stderr}"
+                return res.stdout.strip()
+            except (OSError, subprocess.SubprocessError) as e:
+                return f"Error executing command: {e}"
+
+        # Handle loader builtin via Node.js
+        if impl.get("builtin") == "loader":
+            return self._execute_loader_builtin(impl, ctx)
+
+        # Handle isomorphism builtins via Node.js
+        if impl.get("builtin") in (
+            "isomorphism_pre",
+            "isomorphism_transition",
+            "isomorphism_post",
+        ):
+            return self._execute_isomorphism_builtin(impl, ctx)
+
+        # Handle static_server builtin
+        # Reuse shared Python implementation for consistency
+        if impl.get("builtin") == "static_server":
+            return DEFAULT_OPERATIONS["static_server"](impl, target, ctx)
+
+        if impl.get("process") == "invoke_library":
+            module_name = impl.get("module")
+            func_name = impl.get("function")
+            if not func_name:
+                return "Error: No function specified in invoke_library"
+
+            code = f"""
+            let mod = globalThis;
+            const modName = "{module_name or ''}";
+            if (modName && modName !== "None") {{
+                mod = await import(modName);
+                if (mod.default && typeof mod["{func_name}"] === 'undefined') {{
+                    mod = mod.default;
+                }}
+            }}
+            let func = mod;
+            for (const part of "{func_name}".split('.')) {{
+                func = func[part];
+            }}
+
+            if (!func || typeof func !== 'function') {{
+                throw new Error(`Function {func_name} not found in ${{modName || 'globalThis'}}`);
+            }}
+
+            const inputs_def = {json.dumps(impl.get("inputs", {}))};
+            let args = [];
+            let input_keys = Array.isArray(inputs_def) ? inputs_def : Object.keys(inputs_def || {{}});
+
+            if (input_keys.length === 0) {{
+                let val = target;
+                if (!isNaN(val) && String(val).trim() !== '') val = Number(val);
+                args.push(val);
+            }} else {{
+                for (let key of input_keys) {{
+                    let val = context[key];
+                    if (val === undefined && key === 'target') {{
+                        val = target;
+                        if (!isNaN(val) && String(val).trim() !== '') val = Number(val);
+                    }}
+                    args.push(val);
+                }}
+            }}
+
+            result = await func(...args);
+            """
+        else:
+            code = impl.get("code", "")
+            if not code and not impl.get("entry_point", {}).get("file"):
+                return "Error: No JavaScript code or file provided"
+
+        input_data = {
+            "target": target.get_content().decode("utf-8", errors="ignore"),
+            "context": ctx,
+        }
+
+        # Safe serialization function to handle Python native objects passed from pyCubed
+        def safe_serialize(obj):
+            if callable(obj) or hasattr(obj, "__class__"):
+                return str(obj)
+            raise TypeError(f"Type {type(obj)} not serializable")
+
+        # Use IIFE pattern to isolate user code's variable declarations
+        # User code can use 'var result', 'let result', or 'const result'
+        # The wrapper captures 'result' from the user's scope
+        js_code = f"""
+        (async () => {{
+            const __input__ = {json.dumps(input_data, default=safe_serialize)};
+            const target = __input__.target;
+            const context = __input__.context;
+            let __result__;
+            try {{
+                // Execute user code in IIFE to capture 'result'
+                __result__ = (() => {{
+                    {code}
+                    return (typeof result !== 'undefined') ? result : undefined;
+                }})();
+            }} catch (e) {{
+                __result__ = {{ error: e.message, stack: e.stack }};
+                process.exitCode = 1;
+            }}
+            console.log(JSON.stringify(__result__));
+        }})();
+        """
+
+        try:
+            cmd = self.command
+            if isinstance(cmd, str):
+                cmd_list = [cmd]
+            else:
+                cmd_list = list(cmd)
+
+            env = os.environ.copy()
+            env["NODE_OPTIONS"] = "--experimental-wasm-modules"
+
+            result = subprocess.run(
+                cmd_list + [self.eval_flag, js_code],  # nosec B603
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                env=env,
+            )
+            if result.returncode != 0:
+                return f"Error: JavaScript execution failed: {result.stderr}"
+            output = result.stdout.strip()
+            if not output:
+                return None
+            return json.loads(output)
+        except subprocess.TimeoutExpired:
+            return "Error: JavaScript execution timed out"
+        except json.JSONDecodeError as e:
+            # If JSON parsing fails, return the raw output
+            return (
+                result.stdout.strip()
+                if result.stdout
+                else f"Error: Invalid JSON output: {e}"
+            )
+        except (OSError, subprocess.SubprocessError) as e:
+            return f"Error executing JavaScript: {e}"
+
+    def _execute_loader_builtin(self, impl: dict[str, Any], ctx: dict[str, Any]) -> Any:
+        """Execute JS loader builtin via Node.js using mcard-js."""
+        # Get parameters
+        input_args = impl.get("input_arguments", {})
+        source_dir = input_args.get("source_dir") or ctx.get("source_dir", "docs")
+        db_path = input_args.get("db_path") or ctx.get("db_path", "data/loader_js.db")
+        recursive = input_args.get("recursive", True)
+
+        # Find paths
+        import pathlib
+
+        module_dir = pathlib.Path(__file__).resolve().parent
+        project_root = module_dir.parents[3]
+        mcard_js_path = project_root / "mcard-js"
+        script_path = module_dir / "js_scripts" / "loader.mjs"
+
+        try:
+            env = os.environ.copy()
+            env["NODE_OPTIONS"] = "--experimental-wasm-modules"
+
+            result = subprocess.run(
+                [
+                    "npx",
+                    "tsx",
+                    str(script_path),
+                    str(source_dir),
+                    str(db_path),
+                    str(project_root),
+                    str(recursive).lower(),
+                ],  # nosec B603, B607
+                capture_output=True,
+                text=True,
+                timeout=PTR_JAVASCRIPT_TIMEOUT_SECS,
+                cwd=str(mcard_js_path),
+                env=env,
+            )
+            if result.returncode != 0:
+                stderr = result.stderr or ""
+                return {"success": False, "error": f"JS loader failed: {stderr}"}
+            try:
+                # Parse last line that contains JSON (skip debug output)
+                stdout = result.stdout.strip()
+                lines = stdout.split("\n")
+                for line in reversed(lines):
+                    line = line.strip()
+                    if line.startswith("{") and line.endswith("}"):
+                        return json.loads(line)
+                return {
+                    "success": False,
+                    "error": f"No JSON found in output. Stdout: {stdout[:200]}",
+                }
+            except json.JSONDecodeError as e:
+                return {
+                    "success": False,
+                    "error": f"JSON parse error: {e}. Stdout: {result.stdout[:500]}",
+                }
+        except subprocess.TimeoutExpired:
+            return {"success": False, "error": "JS loader timed out"}
+        except (OSError, subprocess.SubprocessError) as e:
+            return {"success": False, "error": str(e)}
+
+    def _execute_isomorphism_builtin(
+        self, impl: dict[str, Any], ctx: dict[str, Any]
+    ) -> Any:
+        """Execute JS isomorphism builtins via Node.js using mcard-js."""
+        builtin_type = impl.get("builtin")
+        input_args = impl.get("input_arguments", {})
+
+        import pathlib
+
+        module_dir = pathlib.Path(__file__).resolve().parent
+        project_root = module_dir.parents[3]
+        mcard_js_path = project_root / "mcard-js"
+        script_path = module_dir / "js_scripts" / "isomorphism.mjs"
+
+        source_dir = input_args.get("source_dir") or ctx.get("source_dir", "")
+        db_path = input_args.get("db_path") or ctx.get("db_path", "")
+        dest_dir = input_args.get("dest_dir") or ctx.get("dest_dir", "")
+        source_hashes = input_args.get("source_hashes", {})
+
+        js_data = json.dumps(
+            {
+                "source_dir": source_dir,
+                "db_path": db_path,
+                "dest_dir": dest_dir,
+                "source_hashes": source_hashes,
+            }
+        )
+
+        try:
+            env = os.environ.copy()
+            env["NODE_OPTIONS"] = "--experimental-wasm-modules"
+
+            result = subprocess.run(
+                [
+                    "npx",
+                    "tsx",
+                    str(script_path),
+                    str(builtin_type),
+                    js_data,
+                ],  # nosec B603, B607
+                capture_output=True,
+                text=True,
+                timeout=PTR_JAVASCRIPT_TIMEOUT_SECS,
+                cwd=str(mcard_js_path),
+                env=env,
+            )
+            if result.returncode != 0:
+                stderr = result.stderr or ""
+                return {"success": False, "error": f"JS isomorphism failed: {stderr}"}
+            try:
+                stdout = result.stdout.strip()
+                lines = stdout.split("\n")
+                for line in reversed(lines):
+                    line = line.strip()
+                    if line.startswith("{") and line.endswith("}"):
+                        return json.loads(line)
+                return {
+                    "success": False,
+                    "error": f"No JSON found. Stdout: {stdout[:200]}",
+                }
+            except json.JSONDecodeError as e:
+                return {
+                    "success": False,
+                    "error": f"JSON parse error: {e}. Stdout: {result.stdout[:500]}",
+                }
+        except subprocess.TimeoutExpired:
+            return {"success": False, "error": "JS isomorphism timed out"}
+        except (OSError, subprocess.SubprocessError) as e:
+            return {"success": False, "error": str(e)}

clm/layer1/runtimes/javascript_runtime.js

@@ -0,0 +1,33 @@
+/**
+ * JavaScript Native Sandbox Evaluator
+ *
+ * Invoked by the Meta Circular Evaluator to execute Javascript dynamically natively.
+ * Input format expects { target: "string", context: { ... } } pushed in payload.
+ */
+
+const fs = require('fs');
+
+(async () => {
+    try {
+        // Assume STDIN provides the execution payload.
+        const inputData = fs.readFileSync(0, 'utf-8');
+        const __input__ = JSON.parse(inputData);
+
+        const target = __input__.target;
+        const context = __input__.context;
+        const code = __input__.code;
+
+        let __result__;
+
+        // Execute user code in IIFE to capture 'result' globally securely
+        __result__ = (() => {
+            eval(code);
+            return (typeof result !== 'undefined') ? result : undefined;
+        })();
+
+        console.log(JSON.stringify(__result__));
+    } catch (e) {
+        process.exitCode = 1;
+        console.log(JSON.stringify({ error: e.message, stack: e.stack }));
+    }
+})();

clm/layer1/runtimes/js_scripts/isomorphism.mjs

@@ -0,0 +1,22 @@
+import { executeIsomorphismPre, executeIsomorphismTransition, executeIsomorphismPost } from './src/ptr/node/core/operations/isomorphism.js';
+
+const builtin_type = process.argv[2];
+const data = JSON.parse(process.argv[3]);
+
+(async () => {
+    let result;
+    try {
+        if (builtin_type === 'isomorphism_pre') {
+            result = await executeIsomorphismPre(data);
+        } else if (builtin_type === 'isomorphism_transition') {
+            result = await executeIsomorphismTransition(data);
+        } else if (builtin_type === 'isomorphism_post') {
+            result = await executeIsomorphismPost(data);
+        }
+        console.log(JSON.stringify(result));
+        process.exit(0);
+    } catch (err) {
+        console.error(JSON.stringify({ success: false, error: err.message }));
+        process.exit(1);
+    }
+})();

clm/layer1/runtimes/js_scripts/loader.mjs

@@ -0,0 +1,52 @@
+import { SqliteNodeEngine } from './src/storage/SqliteNodeEngine.js';
+import { CardCollection } from './src/model/CardCollection.js';
+import { loadFileToCollection } from './src/Loader.js';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const sourceDir = process.argv[2];
+const dbPath = process.argv[3];
+const projectRoot = process.argv[4];
+const recursive = process.argv[5] === 'true';
+
+const sourcePath = path.isAbsolute(sourceDir) ? sourceDir : path.join(projectRoot, sourceDir);
+const resolvedDbPath = path.isAbsolute(dbPath) ? dbPath : path.join(projectRoot, dbPath);
+
+// Ensure directory
+const dbDir = path.dirname(resolvedDbPath);
+if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+
+// Remove existing DB and WAL/SHM files
+if (fs.existsSync(resolvedDbPath)) fs.unlinkSync(resolvedDbPath);
+const walPath = resolvedDbPath + '-wal';
+const shmPath = resolvedDbPath + '-shm';
+if (fs.existsSync(walPath)) fs.unlinkSync(walPath);
+if (fs.existsSync(shmPath)) fs.unlinkSync(shmPath);
+
+(async () => {
+  try {
+    const engine = await SqliteNodeEngine.create(resolvedDbPath);
+    const collection = new CardCollection(engine);
+
+    const result = await loadFileToCollection(sourcePath, collection, { recursive, includeProblematic: false });
+    console.log(JSON.stringify({
+      success: true,
+      metrics: {
+        total_files: result.metrics.filesCount,
+        total_directories: result.metrics.directoriesCount,
+        directory_levels: result.metrics.directoryLevels,
+        total_size_bytes: result.results.reduce((a, r) => a + (r.size || 0), 0)
+      },
+      files: result.results.slice(0, 10).map(r => ({
+        hash: r.hash.substring(0, 8),
+        filename: r.filename,
+        content_type: r.contentType
+      }))
+    }));
+    await engine.close();
+    process.exit(0);
+  } catch (err) {
+    console.error(JSON.stringify({ success: false, error: err.message }));
+    process.exit(1);
+  }
+})();