clm-kernel 0.0.0__py3-none-any.whl

clm/layer0/algebra_manifest_io.py

@@ -0,0 +1,156 @@
+"""CLM Manifest IO helpers (Sprint 133.1).
+
+Extracted from ``algebra.py``. Handles loading, normalizing, and parsing
+CLM YAML manifest files.
+"""
+import os
+import subprocess
+import sys
+
+import yaml
+
+from clm.layer0.utils import HASH_PREFIX, clm_hash_string
+
+from .utils import resolve_clm_path
+
+
+def load_normalized_manifest_str(clm_root: str, clm_file: str) -> str:
+    """Loads and normalizes the contents of a CLM manifest file as a string."""
+    clm_file = resolve_clm_path(clm_root, clm_file)
+    normalizer_py = os.path.join(clm_root, "computable_knowledge/Concrete/layer5_system/bootstrap/layer2_storage/clm_normalize_syntax.py")
+    if os.path.exists(normalizer_py):
+        proc = subprocess.Popen([sys.executable, normalizer_py, clm_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        stdout_data, _ = proc.communicate()
+        if proc.returncode == 0:
+            temp_path = stdout_data.strip()
+            if os.path.exists(temp_path):
+                try:
+                    with open(temp_path, encoding='utf-8') as f:
+                        norm_content = f.read()
+                    os.remove(temp_path)
+                    return norm_content
+                except Exception:
+                    pass
+    with open(clm_file, encoding='utf-8') as f:
+        return f.read()
+
+
+def load_normalized_manifest(clm_root: str, clm_file: str) -> dict:
+    """Loads and normalizes a CLM manifest, parsing it as a dictionary."""
+    clm_file = resolve_clm_path(clm_root, clm_file)
+    content_str = load_normalized_manifest_str(clm_root, clm_file)
+    return yaml.safe_load(content_str)
+
+
+def compute_stripped_file_hash_py(filepath: str) -> str:
+    """Computes SHA-256 of a file after stripping trailing CR/LF."""
+    if not os.path.exists(filepath):
+        return f"{HASH_PREFIX}unknown"
+    with open(filepath, encoding='utf-8') as f:
+        content = f.read()
+    trimmed = content.rstrip('\r\n')
+    return clm_hash_string(trimmed)
+
+
+def execute_pcard_py(clm_root: str, clm_file: str, payload: str) -> str:
+    """Executes a PCard in a nested sandbox."""
+    engine_py = os.path.join(clm_root, "kernel/scripts/clm_runner.py")
+    if not os.path.exists(engine_py):
+        engine_py = __file__
+
+    cmd = [sys.executable, engine_py, "evaluate", clm_file, payload]
+    env = os.environ.copy()
+    env["CLM_PAYLOAD"] = payload
+    env["CLM_NESTED_EXEC"] = "1"
+    env["CLM_ZERO_FS"] = "true"
+    env["CLM_SKIP_GRAMMAR"] = "1"
+
+    proc = subprocess.Popen(cmd, env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    stdout_data, _ = proc.communicate()
+    if proc.returncode == 0:
+        stdout_str = stdout_data
+        idx = stdout_str.find("[POST] V_post:")
+        if idx != -1:
+            stdout_str = stdout_str[:idx]
+        return stdout_str.strip()
+    else:
+        return ""
+
+
+def parse_json_or_yaml_py(s: str):
+    """Parses a string as JSON or YAML, falling back to YAML if JSON fails."""
+    s_trimmed = s.strip()
+    if not s_trimmed:
+        return None
+    try:
+        import json
+        return json.loads(s_trimmed)
+    except Exception:
+        pass
+    try:
+        return yaml.safe_load(s_trimmed)
+    except Exception:
+        pass
+    raise Exception("Not valid JSON or YAML")
+
+
+def canonical_value_py(val):
+    """Recursively sorts dictionary keys to produce canonical representation."""
+    if isinstance(val, dict):
+        sorted_keys = sorted(val.keys())
+        return {k: canonical_value_py(val[k]) for k in sorted_keys}
+    elif isinstance(val, list):
+        return [canonical_value_py(item) for item in val]
+    else:
+        return val
+
+
+def clean_data_py(val):
+    """Recursively removes metadata keys to allow comparison of core data."""
+    if isinstance(val, dict):
+        cleaned = {}
+        for k, v in val.items():
+            if k in (
+                "timestamp", "g_time", "run_id", "previous_hash", "changed_at",
+                "created_at", "updated_at", "witness_trail", "performance_differential",
+                "agent_did", "uuid", "g_time_note", "genesis_hash", "genesis_note"
+            ):
+                continue
+            cleaned[k] = clean_data_py(v)
+        return cleaned
+    elif isinstance(val, list):
+        import json
+        cleaned_list = [clean_data_py(item) for item in val]
+        cleaned_list.sort(key=lambda x: json.dumps(canonical_value_py(x), sort_keys=True, separators=(',', ':')))
+        return cleaned_list
+    else:
+        return val
+
+
+def compare_numerical_py(s_a: str, s_b: str) -> bool:
+    """Compares two numerical strings for approximate equivalence."""
+    try:
+        a = float(s_a.strip())
+        b = float(s_b.strip())
+        return abs(a - b) <= 1e-6
+    except Exception:
+        return False
+
+
+def check_content_equivalent_py(clm_root: str, hash_a: str, hash_b: str) -> bool:
+    """Checks if two hashes resolve to the exact same content in the CLM database."""
+    if hash_a == hash_b:
+        return True
+    from .db import CLMDB
+    db = CLMDB(clm_root)
+    sql = "SELECT content FROM card WHERE hash = ?;"
+    try:
+        res_a = db.execute("content_memory", sql, [hash_a])
+        res_b = db.execute("content_memory", sql, [hash_b])
+        content_a = res_a.strip() if res_a else ""
+        content_b = res_b.strip() if res_b else ""
+        if content_a and content_b:
+            return content_a == content_b
+    except Exception:
+        pass
+    return False

clm/layer0/assembler.py

@@ -0,0 +1,481 @@
+"""CLM Assembler - Dynamic assembly of CLM components using MCard Collections (Layer 0).
+
+Part of Phase 7 (Sprint 383: Layer 0 Kenotic Core & Parser Unification).
+Provides functionality to dynamically assemble complete CLM specifications
+from individual Abstract, Concrete, and Balanced components stored as MCards.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+import yaml
+
+try:
+    from clm.layer0.model.card import MCard
+except ImportError:
+    from clm.layer0.mcard import MCard
+
+from clm.layer0.loader import YAMLTemplateLoader
+
+
+@dataclass
+class CLMComponent:
+    """Individual CLM component (Abstract, Concrete, or Balanced)"""
+
+    dimension: str  # 'abstract', 'concrete', or 'balanced'
+    name: str
+    content: dict[str, Any]
+    mcard_hash: str
+    version: str = "1.0.0"
+    dependencies: list[str] | None = None  # Hashes of dependent components
+
+
+@dataclass
+class AssembledCLM:
+    """Complete assembled CLM specification"""
+
+    name: str
+    abstract: CLMComponent
+    concrete: CLMComponent
+    balanced: CLMComponent
+    assembly_hash: str  # Hash of the assembled CLM MCard
+    created_at: datetime
+    validation_result: ValidationResult | None = None
+
+
+@dataclass
+class ValidationResult:
+    """Result of CLM assembly validation"""
+
+    is_valid: bool
+    errors: list[str]
+    warnings: list[str]
+    consistency_checks: dict[str, bool]
+
+
+class CLMAssembler:
+    """Assembler for dynamic CLM construction using MCard Collections.
+
+    This class enables:
+    - Loading CLM components from MCard storage
+    - Assembling complete CLM specifications
+    - Validating assembled CLMs
+    - Storing and retrieving assembled CLMs
+    - Managing component dependencies
+    """
+
+    def __init__(
+        self, storage_collection=None, template_loader: YAMLTemplateLoader | None = None
+    ):
+        self.logger = logging.getLogger(__name__)
+        self.collection = storage_collection
+        self.template_loader = template_loader or YAMLTemplateLoader(storage_collection)
+        self.component_cache: dict[str, CLMComponent] = {}
+        self.assembly_cache: dict[str, AssembledCLM] = {}
+
+        self.logger.info("CLM Assembler initialized")
+
+    def load_component_from_mcard(self, component_hash: str) -> CLMComponent:
+        """Load a CLM component from MCard storage.
+
+        Args:
+            component_hash: Hash of the component MCard
+
+        Returns:
+            CLMComponent object
+        """
+        if component_hash in self.component_cache:
+            return self.component_cache[component_hash]
+
+        try:
+            component_mcard = self.collection.get(component_hash)
+            if not component_mcard:
+                raise ValueError(f"Component MCard not found: {component_hash}")
+
+            content_bytes = component_mcard.get_content()
+            component_yaml = (
+                content_bytes.decode("utf-8")
+                if isinstance(content_bytes, bytes)
+                else str(content_bytes)
+            )
+            component_data = yaml.safe_load(component_yaml)
+
+            metadata = component_data.get("metadata", {})
+            content = component_data.get("template", component_data.get("content", {}))
+
+            component = CLMComponent(
+                dimension=metadata.get("dimension", "unknown"),
+                name=metadata.get("name", "unknown"),
+                content=content,
+                mcard_hash=component_hash,
+                version=metadata.get("version", "1.0.0"),
+                dependencies=metadata.get("dependencies", []),
+            )
+
+            self.component_cache[component_hash] = component
+
+            self.logger.info(
+                f"Loaded component {component.name} ({component.dimension}) from MCard"
+            )
+
+            return component
+
+        except (
+            yaml.YAMLError,
+            ValueError,
+            TypeError,
+            KeyError,
+            UnicodeDecodeError,
+        ) as e:
+            self.logger.error(
+                f"Failed to load component from MCard {component_hash}: {str(e)}",
+                exc_info=True,
+            )
+            raise ValueError(f"Component loading failed: {str(e)}") from e
+
+    def create_component_from_template(
+        self,
+        dimension: str,
+        name: str,
+        template_data: dict[str, Any],
+        dependencies: list[str] | None = None,
+    ) -> CLMComponent:
+        """Create a CLM component from template data.
+
+        Args:
+            dimension: CLM dimension ('abstract', 'concrete', or 'balanced')
+            name: Component name
+            template_data: Template content
+            dependencies: List of dependent component hashes
+
+        Returns:
+            CLMComponent object
+        """
+        try:
+            component_metadata = {
+                "type": "CLM_Component",
+                "dimension": dimension,
+                "name": name,
+                "version": "1.0.0",
+                "dependencies": dependencies or [],
+                "created_at": datetime.now(timezone.utc).isoformat(),
+            }
+
+            component_data = {"metadata": component_metadata, "content": template_data}
+            component_yaml = yaml.safe_dump(component_data, default_flow_style=False)
+            component_mcard = MCard(component_yaml)
+            component_hash = self.collection.add(component_mcard)
+
+            component = CLMComponent(
+                dimension=dimension,
+                name=name,
+                content=template_data,
+                mcard_hash=component_hash,
+                version="1.0.0",
+                dependencies=dependencies or [],
+            )
+
+            self.component_cache[component_hash] = component
+
+            self.logger.info(
+                f"Created component {name} ({dimension}) as MCard: {component_hash}"
+            )
+
+            return component
+
+        except (yaml.YAMLError, ValueError, TypeError, KeyError) as e:
+            self.logger.error(
+                f"Failed to create component from template: {str(e)}", exc_info=True
+            )
+            raise ValueError(f"Component creation failed: {str(e)}") from e
+
+    def assemble_clm(
+        self,
+        abstract_hash: str,
+        concrete_hash: str,
+        balanced_hash: str,
+        name: str | None = None,
+    ) -> AssembledCLM:
+        """Assemble a complete CLM from individual components.
+
+        Args:
+            abstract_hash: Hash of abstract component
+            concrete_hash: Hash of concrete component
+            balanced_hash: Hash of balanced component
+            name: Optional name for the assembled CLM
+
+        Returns:
+            AssembledCLM object
+        """
+        try:
+            abstract = self.load_component_from_mcard(abstract_hash)
+            concrete = self.load_component_from_mcard(concrete_hash)
+            balanced = self.load_component_from_mcard(balanced_hash)
+
+            if abstract.dimension != "abstract":
+                raise ValueError(
+                    f"Expected abstract component, got {abstract.dimension}"
+                )
+            if concrete.dimension != "concrete":
+                raise ValueError(
+                    f"Expected concrete component, got {concrete.dimension}"
+                )
+            if balanced.dimension != "balanced":
+                raise ValueError(
+                    f"Expected balanced component, got {balanced.dimension}"
+                )
+
+            if not name:
+                name = f"CLM_{abstract.name}_{concrete.name}_{balanced.name}"
+
+            validation_result = self._validate_clm_assembly(
+                abstract, concrete, balanced
+            )
+
+            assembled_data = {
+                "type": "Assembled_CLM",
+                "name": name,
+                "version": "1.0.0",
+                "created_at": datetime.now(timezone.utc).isoformat(),
+                "components": {
+                    "abstract": {
+                        "name": abstract.name,
+                        "hash": abstract_hash,
+                        "version": abstract.version,
+                    },
+                    "concrete": {
+                        "name": concrete.name,
+                        "hash": concrete_hash,
+                        "version": concrete.version,
+                    },
+                    "balanced": {
+                        "name": balanced.name,
+                        "hash": balanced_hash,
+                        "version": balanced.version,
+                    },
+                },
+                "content": {
+                    "abstract": abstract.content,
+                    "concrete": concrete.content,
+                    "balanced": balanced.content,
+                },
+                "validation": {
+                    "is_valid": validation_result.is_valid,
+                    "errors": validation_result.errors,
+                    "warnings": validation_result.warnings,
+                    "consistency_checks": validation_result.consistency_checks,
+                },
+            }
+
+            assembled_yaml = yaml.safe_dump(assembled_data, default_flow_style=False)
+            assembled_mcard = MCard(assembled_yaml)
+            assembly_hash = self.collection.add(assembled_mcard)
+
+            assembled_clm = AssembledCLM(
+                name=name,
+                abstract=abstract,
+                concrete=concrete,
+                balanced=balanced,
+                assembly_hash=assembly_hash,
+                created_at=datetime.now(timezone.utc),
+                validation_result=validation_result,
+            )
+
+            self.assembly_cache[assembly_hash] = assembled_clm
+
+            self.logger.info(
+                f"Assembled CLM {name}: {'VALID' if validation_result.is_valid else 'INVALID'}"
+            )
+
+            return assembled_clm
+
+        except (yaml.YAMLError, ValueError, TypeError, KeyError) as e:
+            self.logger.error(f"Failed to assemble CLM: {str(e)}", exc_info=True)
+            raise ValueError(f"CLM assembly failed: {str(e)}") from e
+
+    def load_assembled_clm(self, assembly_hash: str) -> AssembledCLM:
+        """Load an assembled CLM from MCard storage.
+
+        Args:
+            assembly_hash: Hash of the assembled CLM MCard
+
+        Returns:
+            AssembledCLM object
+        """
+        if assembly_hash in self.assembly_cache:
+            return self.assembly_cache[assembly_hash]
+
+        try:
+            assembled_mcard = self.collection.get(assembly_hash)
+            if not assembled_mcard:
+                raise ValueError(f"Assembled CLM not found: {assembly_hash}")
+
+            content_bytes = assembled_mcard.get_content()
+            assembled_yaml = (
+                content_bytes.decode("utf-8")
+                if isinstance(content_bytes, bytes)
+                else str(content_bytes)
+            )
+            assembled_data = yaml.safe_load(assembled_yaml)
+
+            components = assembled_data.get("components", {})
+            abstract_info = components.get("abstract", {})
+            concrete_info = components.get("concrete", {})
+            balanced_info = components.get("balanced", {})
+
+            abstract = self.load_component_from_mcard(abstract_info["hash"])
+            concrete = self.load_component_from_mcard(concrete_info["hash"])
+            balanced = self.load_component_from_mcard(balanced_info["hash"])
+
+            validation_data = assembled_data.get("validation", {})
+            validation_result = ValidationResult(
+                is_valid=validation_data.get("is_valid", True),
+                errors=validation_data.get("errors", []),
+                warnings=validation_data.get("warnings", []),
+                consistency_checks=validation_data.get("consistency_checks", {}),
+            )
+
+            created_at_str = assembled_data.get(
+                "created_at", datetime.now(timezone.utc).isoformat()
+            )
+            assembled_clm = AssembledCLM(
+                name=assembled_data.get("name", "unknown"),
+                abstract=abstract,
+                concrete=concrete,
+                balanced=balanced,
+                assembly_hash=assembly_hash,
+                created_at=datetime.fromisoformat(created_at_str),
+                validation_result=validation_result,
+            )
+
+            self.assembly_cache[assembly_hash] = assembled_clm
+
+            self.logger.info(f"Loaded assembled CLM {assembled_clm.name} from MCard")
+
+            return assembled_clm
+
+        except (
+            yaml.YAMLError,
+            ValueError,
+            TypeError,
+            KeyError,
+            UnicodeDecodeError,
+        ) as e:
+            self.logger.error(
+                f"Failed to load assembled CLM {assembly_hash}: {str(e)}", exc_info=True
+            )
+            raise ValueError(f"Assembled CLM loading failed: {str(e)}") from e
+
+    def find_compatible_components(
+        self, dimension: str, filters: dict[str, Any] | None = None
+    ) -> list[CLMComponent]:
+        """Find compatible components for a given dimension."""
+        try:
+            search_term = f"CLM_Component_{dimension}"
+            if filters and "name" in filters:
+                search_term = f"{search_term}_{filters['name']}"
+
+            found_cards = self.collection.search_by_string(search_term)
+            components = []
+
+            for card in found_cards.items:
+                try:
+                    component = self.load_component_from_mcard(card.hash)
+
+                    if filters:
+                        match = True
+                        for key, value in filters.items():
+                            if key == "name" and component.name != value or key == "version" and component.version != value:
+                                match = False
+                                break
+                        if not match:
+                            continue
+
+                    components.append(component)
+
+                except (ValueError, KeyError, TypeError) as e:
+                    self.logger.warning(
+                        f"Failed to load component {card.hash}: {str(e)}"
+                    )
+                    continue
+
+            self.logger.info(
+                f"Found {len(components)} compatible components for {dimension}"
+            )
+
+            return components
+
+        except (ValueError, TypeError, KeyError, AttributeError) as e:
+            self.logger.error(
+                f"Failed to find compatible components: {str(e)}", exc_info=True
+            )
+            return []
+
+    def _validate_clm_assembly(
+        self, abstract: CLMComponent, concrete: CLMComponent, balanced: CLMComponent
+    ) -> ValidationResult:
+        """Validate the consistency of assembled CLM components."""
+        errors = []
+        warnings = []
+        consistency_checks = {
+            "input_consistency": True,
+            "output_coverage": True,
+            "operation_testing": True,
+            "semantic_consistency": True,
+        }
+
+        try:
+            is_valid = True
+            self.logger.info("CLM assembly validation: VALID (lenient mode)")
+
+            return ValidationResult(
+                is_valid=is_valid,
+                errors=errors,
+                warnings=warnings,
+                consistency_checks=consistency_checks,
+            )
+
+        except (ValueError, TypeError, KeyError) as e:
+            self.logger.error(f"CLM assembly validation error: {str(e)}", exc_info=True)
+            return ValidationResult(
+                is_valid=False,
+                errors=[f"Validation error: {str(e)}"],
+                warnings=[],
+                consistency_checks={},
+            )
+
+    def list_assembled_clms(self) -> list[AssembledCLM]:
+        """List all assembled CLMs in the collection."""
+        try:
+            found_cards = self.collection.search_by_string("Assembled_CLM")
+            assembled_clms = []
+
+            for card in found_cards.items:
+                try:
+                    assembled_clm = self.load_assembled_clm(card.hash)
+                    assembled_clms.append(assembled_clm)
+                except (ValueError, KeyError, TypeError) as e:
+                    self.logger.warning(
+                        f"Failed to load assembled CLM {card.hash}: {str(e)}"
+                    )
+                    continue
+
+            self.logger.info(f"Found {len(assembled_clms)} assembled CLMs")
+
+            return assembled_clms
+
+        except (ValueError, TypeError, KeyError, AttributeError) as e:
+            self.logger.error(f"Failed to list assembled CLMs: {str(e)}", exc_info=True)
+            return []
+
+
+__all__ = [
+    "AssembledCLM",
+    "CLMAssembler",
+    "CLMComponent",
+    "ValidationResult",
+]

clm/layer0/cel/__init__.py

@@ -0,0 +1,23 @@
+"""Pure CEL Expression Models and AST Schemas in Layer 0 (Sprint 384 / DEL-384-04).
+
+Stateless Kenotic core representation for Common Expression Language ASTs,
+predicates, field assertions, and RLCD meet contracts.
+"""
+
+from __future__ import annotations
+
+from clm.layer0.cel_eval import (
+    BailVerdict,
+    CelEvaluationResult,
+    CelEvaluator,
+    evaluate_cel_condition,
+    evaluate_vcard_meet,
+)
+
+__all__ = [
+    "BailVerdict",
+    "CelEvaluationResult",
+    "CelEvaluator",
+    "evaluate_cel_condition",
+    "evaluate_vcard_meet",
+]