clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/operations/handle.py

@@ -0,0 +1,197 @@
+"""
+Handle versioning and pruning operations.
+"""
+
+from typing import Any
+
+from clm.layer0.model.card import MCard
+
+from .base import ExampleRunnerMixin
+
+
+def op_handle_version(impl: dict, target: MCard, ctx: dict) -> Any:
+    """Handle versioning builtin: update a handle through multiple versions."""
+    # Check for examples list (batch mode)
+    examples = ctx.get("examples", [])
+    if examples:
+        return _run_version_examples(examples)
+
+    # Single execution mode
+    input_data = ctx.get("input", ctx)
+    handle = input_data.get("handle", ctx.get("handle", ""))
+    versions = input_data.get("versions", ctx.get("versions", []))
+
+    if not handle:
+        return {"success": False, "error": "handle is required"}
+    if not versions:
+        return {"success": False, "error": "versions list is required"}
+
+    return _execute_version_single(handle, versions)
+
+
+def op_handle_prune(impl: dict, target: MCard, ctx: dict) -> Any:
+    """Handle pruning builtin: prune handle history."""
+    # Check for examples list (batch mode)
+    examples = ctx.get("examples", [])
+    if examples:
+        return _run_prune_examples(examples)
+
+    # Single execution mode
+    input_data = ctx.get("input", ctx)
+    handle = input_data.get("handle", ctx.get("handle", ""))
+    versions = input_data.get("versions", ctx.get("versions", []))
+    prune_type = input_data.get("prune_type", ctx.get("prune_type", "all"))
+    older_than_seconds = input_data.get(
+        "older_than_seconds", ctx.get("older_than_seconds")
+    )
+
+    if not handle:
+        return {"success": False, "error": "handle is required"}
+
+    return _execute_prune_single(handle, versions, prune_type, older_than_seconds)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Version Helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def _run_version_examples(examples: list) -> dict[str, Any]:
+    """Run all versioning examples and return aggregated results."""
+
+    def executor(input_data: dict) -> dict[str, Any]:
+        handle = input_data.get("handle", "")
+        versions = input_data.get("versions", [])
+        if not handle or not versions:
+            return {"success": False, "error": "handle and versions required"}
+        return _execute_version_single(handle, versions)
+
+    def validator(result: dict, expected: dict) -> bool:
+        expected_len = expected.get("history_length")
+        if expected_len is not None:
+            return result.get("history_length") == expected_len
+        return result.get("success", False)
+
+    return ExampleRunnerMixin.run_examples(examples, executor, validator)
+
+
+def _execute_version_single(handle: str, versions: list) -> dict[str, Any]:
+    """Execute a single versioning operation."""
+    from clm.layer1.protocols import get_store
+
+    collection = get_store(":memory:")
+
+    try:
+        # Add first version
+        first_content = (
+            versions[0].get("content", "")
+            if isinstance(versions[0], dict)
+            else versions[0]
+        )
+        card = MCard(first_content)
+        collection.add_with_handle(card, handle)
+
+        # Apply subsequent updates
+        for version in versions[1:]:
+            content = (
+                version.get("content", "") if isinstance(version, dict) else version
+            )
+            new_card = MCard(content)
+            collection.update_handle(handle, new_card)
+
+        # Get final state
+        final_card = collection.get_by_handle(handle)
+        history = collection.get_handle_history(handle)
+
+        return {
+            "success": True,
+            "handle": handle,
+            "final_hash": final_card.hash if final_card else None,
+            "final_content": (
+                final_card.get_content(as_text=True) if final_card else None
+            ),
+            "history_length": len(history),
+            "history": history,
+        }
+    except (ValueError, TypeError, KeyError, AttributeError) as e:
+        return {"success": False, "error": str(e)}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Prune Helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def _run_prune_examples(examples: list) -> dict[str, Any]:
+    """Run all pruning examples and return aggregated results."""
+
+    def executor(input_data: dict) -> dict[str, Any]:
+        handle = input_data.get("handle", "")
+        versions = input_data.get("versions", [])
+        prune_type = input_data.get("prune_type", "all")
+        older_than_seconds = input_data.get("older_than_seconds")
+        if not handle:
+            return {"success": False, "error": "handle is required"}
+        return _execute_prune_single(handle, versions, prune_type, older_than_seconds)
+
+    def validator(result: dict, expected: dict) -> bool:
+        expected_after = expected.get("history_after")
+        expected_deleted = expected.get("deleted")
+        if expected_after is not None:
+            return result.get("history_after") == expected_after
+        if expected_deleted is not None:
+            return result.get("deleted") == expected_deleted
+        return result.get("success", False)
+
+    return ExampleRunnerMixin.run_examples(examples, executor, validator)
+
+
+def _execute_prune_single(
+    handle: str, versions: list, prune_type: str, older_than_seconds
+) -> dict[str, Any]:
+    """Execute a single pruning operation."""
+    from clm.layer1.protocols import get_store
+
+    collection = get_store(":memory:")
+
+    try:
+        # Setup handle with versions if provided
+        if versions:
+            first_content = (
+                versions[0].get("content", "")
+                if isinstance(versions[0], dict)
+                else versions[0]
+            )
+            card = MCard(first_content)
+            collection.add_with_handle(card, handle)
+
+            for version in versions[1:]:
+                content = (
+                    version.get("content", "") if isinstance(version, dict) else version
+                )
+                new_card = MCard(content)
+                collection.update_handle(handle, new_card)
+
+        history_before = len(collection.get_handle_history(handle))
+        deleted = 0
+
+        if prune_type == "all":
+            deleted = collection.prune_handle_history(handle, delete_all=True)
+        elif prune_type == "older_than" and older_than_seconds is not None:
+            from datetime import timedelta
+
+            deleted = collection.prune_handle_history(
+                handle, older_than=timedelta(seconds=older_than_seconds)
+            )
+
+        history_after = len(collection.get_handle_history(handle))
+
+        return {
+            "success": True,
+            "handle": handle,
+            "history_before": history_before,
+            "deleted": deleted,
+            "history_after": history_after,
+        }
+    except (ValueError, TypeError, KeyError, AttributeError) as e:
+        return {"success": False, "error": str(e)}

clm/layer1/operations/identity.py

@@ -0,0 +1,139 @@
+import datetime
+import json
+
+from clm.layer0.model.card import MCard
+
+
+def op_provision_genesis_eoa(impl: dict, target: MCard, ctx: dict) -> dict:
+    """
+    Native PTR operation for Phase A.1 Genesis EOA Provisioning.
+    Generates an Ed25519 keypair, derives the W3C did:key, and stores the identity.
+    """
+    import base58
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric import ed25519
+
+    identities_db = ctx.get("identities_db")
+    log_db = ctx.get("log_db")
+
+    if not identities_db or not log_db:
+        raise ValueError("[BOOTSTRAP] Missing topological database in context.")
+
+    # T00.4: Idempotency Check (Tabula Rasa precondition)
+    if identities_db.count() > 0:
+        msg = "[BOOTSTRAP] Double bootstrap rejected: Tabula Rasa precondition violated (cardinality > 0)"
+        log_db.add(MCard(f"Execution Trace: Abort - {msg}"))
+        raise RuntimeError(msg)
+
+    # Generate Ed25519 Keypair
+    private_key = ed25519.Ed25519PrivateKey.generate()
+    public_key = private_key.public_key()
+    public_bytes = public_key.public_bytes(
+        encoding=serialization.Encoding.Raw, format=serialization.PublicFormat.Raw
+    )
+
+    # Derive W3C did:key (Multicodec prefix for Ed25519 is 0xed01)
+    multicodec_pubkey = b"\xed\x01" + public_bytes
+    did = "did:key:z" + base58.b58encode(multicodec_pubkey).decode("utf-8")
+
+    # Construct Genesis EOA
+    payload = {
+        "type": "identity/eoa",
+        "did": did,
+        "public_key": public_bytes.hex(),
+        "algorithm": "Ed25519",
+        "role": "genesis_founder",
+        "delegation_depth": 0,
+        "g_time": {
+            "algorithm": "SHA-256",
+            "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            "locale": did,
+        },
+        "created_by": "self",
+    }
+
+    card = MCard(json.dumps(payload))
+    identities_db.add_with_handle(card, did)
+
+    log_message = f"Execution Trace: Provisioned Genesis EOA {did} | Hash: {card.hash}"
+    log_db.add(MCard(log_message))
+
+    print(f"[BOOTSTRAP] Provisioned Genesis EOA: {did}")
+
+    # Return output
+    return {
+        "status": "success",
+        "target_db": "agent_identities",
+        "card_hash": card.hash,
+        "did": did,
+    }
+
+
+def op_provision_genesis_ca(impl: dict, target: MCard, ctx: dict) -> dict:
+    """
+    Native PTR operation for Phase A.1 Genesis CA Provisioning.
+    Reads governance PCard content, derives CA DID, and stores the identity.
+    """
+    identities_db = ctx.get("identities_db")
+    content_db = ctx.get("content_db")
+    log_db = ctx.get("log_db")
+    # Governance PCard is passed via the previous 'load_file' transition or injected
+    content = ctx.get("content", target.get_content(as_text=True) if target else "")
+
+    if not identities_db or not content_db or not log_db:
+        raise ValueError("[BOOTSTRAP] Missing topological database in context.")
+
+    if not content:
+        raise ValueError("[BOOTSTRAP] Missing Governance PCard content for CA binding.")
+
+    if isinstance(content, bytes):
+        content = content.decode("utf-8")
+
+    governance_card = MCard(content)
+    content_db.add(governance_card)
+
+    ca_did = f"did:pkc:ca:{governance_card.hash}"
+
+    # Fetch the EOA DID to attribute this CA
+    eoa_cards = identities_db.get_all_mcards_raw()
+    eoa_did = "unknown"
+    for c in eoa_cards:
+        parsed = (
+            json.loads(c.content.decode("utf-8"))
+            if isinstance(c.content, bytes)
+            else json.loads(c.content)
+        )
+        if parsed.get("type") == "identity/eoa":
+            eoa_did = parsed.get("did")
+            break
+
+    ca_payload = {
+        "type": "identity/ca",
+        "did": ca_did,
+        "bound_pcard_hash": governance_card.hash,
+        "algorithm": "Ed25519",
+        "role": "genesis_agency",
+        "authorized_by": eoa_did,
+        "g_time": {
+            "algorithm": "SHA-256",
+            "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            "locale": eoa_did,
+        },
+    }
+
+    ca_card = MCard(json.dumps(ca_payload))
+    identities_db.add_with_handle(ca_card, ca_did)
+
+    log_message = (
+        f"Execution Trace: Provisioned Genesis CA {ca_did} | Hash: {ca_card.hash}"
+    )
+    log_db.add(MCard(log_message))
+
+    print(f"[BOOTSTRAP] Provisioned Genesis CA: {ca_did}")
+
+    return {
+        "status": "success",
+        "target_db": "agent_identities",
+        "card_hash": ca_card.hash,
+        "did": ca_did,
+    }

clm/layer1/operations/invert.py

@@ -0,0 +1,66 @@
+"""Baldwin Invert Operator (DEL-388-02).
+
+Control Inversion Operator (^-1): f: A -> B => f⁻¹: B -> A.
+Inverts arrows or operational sequences, promoting internal parameters
+to first-class external coordinates via the Curry Adjunction,
+preserving triadic syntactic closure.
+"""
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+import yaml
+
+from clm.layer0.model.card import MCard
+from clm.layer1.operations.split import _parse_manifest, ensure_triadic_closure
+
+
+def op_invert(impl: dict[str, Any], target: MCard, ctx: dict[str, Any]) -> dict[str, Any]:
+    """Execute the Baldwin Invert (^-1) operation.
+
+    Args:
+        impl: Configuration dict for invert.
+        target: Target MCard to invert.
+        ctx: Execution context.
+
+    Returns:
+        Dict containing the inverted manifest, new MCard, and closure proof.
+    """
+    manifest = _parse_manifest(target)
+    updated = copy.deepcopy(manifest)
+
+    # Invert abstract spec input/output interfaces if present
+    spec = updated.get("abstract_spec", {})
+    if isinstance(spec, dict):
+        inp = spec.get("input_type") or spec.get("domain")
+        outp = spec.get("output_type") or spec.get("codomain")
+        if inp and outp:
+            spec["input_type"] = outp
+            spec["output_type"] = inp
+        spec["inverted"] = True
+
+    # Invert concrete implementation steps or direction
+    c_impl = updated.get("concrete_impl", {})
+    if isinstance(c_impl, dict):
+        steps = c_impl.get("steps")
+        if isinstance(steps, list):
+            c_impl["steps"] = list(reversed(steps))
+        c_impl["direction"] = "inverse"
+
+    final_manifest = ensure_triadic_closure(updated)
+    yaml_content = yaml.dump(final_manifest, default_flow_style=False)
+    new_card = MCard(yaml_content)
+
+    return {
+        "success": True,
+        "operator": "invert",
+        "syntactic_closure": True,
+        "manifest": final_manifest,
+        "hash": new_card.hash,
+        "content": yaml_content,
+        "mcard": new_card,
+    }
+
+
+__all__ = ["op_invert"]

clm/layer1/operations/loader.py

@@ -0,0 +1,116 @@
+"""
+File loader operation for ingesting files into CardCollection.
+"""
+
+import time
+from pathlib import Path
+from typing import Any
+
+from clm.layer0.model.card import MCard
+
+
+def op_loader(impl: dict, target: MCard, ctx: dict) -> Any:
+    """Built-in loader operation using mcard.loader.
+
+    Loads files from a directory into a CardCollection.
+
+    Context params:
+        source_dir: Directory path to load files from
+        db_path: Database path for storage
+        recursive: Whether to recursively scan directories (default: True)
+        include_problematic: Whether to include problematic files (default: False)
+    """
+    from clm.layer1.protocols import get_file_loader, get_store
+
+    load_file_to_collection = get_file_loader()
+    if load_file_to_collection is None:
+        raise RuntimeError(
+            "No file loader registered with Layer 1 protocols. "
+            "Layer 4 must register load_file_to_collection."
+        )
+
+    # Extract parameters from context (merged balanced + test context)
+    params = ctx.get("params", {})
+    bal = ctx.get("balanced", {})
+
+    # Get input/output args from balanced or context
+    input_args = {**bal.get("input_arguments", {}), **ctx.get("input_arguments", {})}
+    output_args = {**bal.get("output_arguments", {}), **ctx.get("output_arguments", {})}
+
+    # Merge all parameter sources
+    all_params = {**input_args, **output_args, **params}
+
+    source_dir = all_params.get("source_dir", "test_data")
+    db_path = all_params.get("db_path", "data/ingestion/loader.db")
+    recursive = all_params.get("recursive", True)
+    include_problematic = all_params.get("include_problematic", False)
+
+    # Resolve source_dir relative to project root if needed
+    source_path = Path(source_dir)
+    if not source_path.exists():
+        cwd = Path(os.getcwd())
+        source_path = cwd / source_dir
+        if not source_path.exists():
+            return {
+                "success": False,
+                "error": f"Source directory not found: {source_dir}",
+            }
+
+    # Ensure db directory exists
+    db_file = Path(db_path)
+    db_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Clean slate - remove existing db and any SQLite auxiliary files
+    for suffix in ["", "-wal", "-shm", "-journal"]:
+        f = db_file.with_name(db_file.name + suffix)
+        if f.exists():
+            try:
+                os.remove(f)
+            except OSError:
+                pass
+
+    try:
+        # Initialize collection
+        collection = get_store(str(db_path))
+
+        # Load files using built-in loader
+        t0 = time.time()
+        loader_response = load_file_to_collection(
+            source_path,
+            collection,
+            recursive=recursive,
+            include_problematic=include_problematic,
+        )
+        load_time = time.time() - t0
+
+        # Unpack response
+        if isinstance(loader_response, dict) and "results" in loader_response:
+            results = loader_response["results"]
+            metrics = loader_response.get("metrics", {})
+        else:
+            results = loader_response
+            metrics = {"files_count": len(results)}
+
+        # Calculate metrics
+        total_size = sum(r.get("size", 0) for r in results)
+
+        return {
+            "success": True,
+            "metrics": {
+                "total_files": metrics.get("files_count", len(results)),
+                "total_directories": metrics.get("directories_count", 0),
+                "directory_levels": metrics.get("directory_levels", 0),
+                "total_size_bytes": total_size,
+                "duration_ms": round(load_time * 1000, 2),
+            },
+            "files": [
+                {
+                    "hash": r.get("hash", "")[:8],
+                    "filename": r.get("filename", ""),
+                    "content_type": r.get("content_type", ""),
+                }
+                for r in results[:10]
+            ],  # Return first 10 for preview
+        }
+    except (OSError, ValueError, TypeError, KeyError) as e:
+        return {"success": False, "error": str(e)}

clm/layer1/operations/manipulators/__init__.py

@@ -0,0 +1,23 @@
+"""Multi-Modal Baldwin Modularity Manipulators (Sprint 393 / DEL-393-02).
+
+Exports domain-aware algebraic manipulators across four modalities:
+- Tabular (CSV, Parquet, dataframes)
+- Document (Markdown, structured text)
+- Structured (JSON, YAML)
+- Media (images, audio, binary assets)
+
+All manipulators adhere to the Six Baldwin Modularity Operators:
+split, substitute, augment, exclude, invert, port.
+"""
+
+from .document import DocumentManipulator
+from .media import MediaManipulator
+from .structured import StructuredManipulator
+from .tabular import TabularManipulator
+
+__all__ = [
+    "TabularManipulator",
+    "DocumentManipulator",
+    "StructuredManipulator",
+    "MediaManipulator",
+]