conceptkernel 1.1.0__tar.gz → 1.2.0__tar.gz

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conceptkernel
-Version: 1.1.0
+Version: 1.2.0
 Summary: CKP v3.5 Python runtime — kernel processor, provenance, execution proofs
 Author-email: Peter Styk <peter@conceptkernel.org>
 License: MIT

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/cklib/actions.py

@@ -108,27 +108,51 @@ def _get_actions_from_spec(data):
 
 
 def _find_ck_dir_by_name(target_name, concepts_dir):
-    """Find a CK directory by its metadata.name."""
+    """Find a CK directory by its metadata.name.
+
+    Searches two levels: direct child (flat layout) and one level deeper
+    (GUID subdirectory layout).
+    """
     if not os.path.isdir(concepts_dir):
         return None
     for entry in os.listdir(concepts_dir):
         candidate = os.path.join(concepts_dir, entry)
         if not os.path.isdir(candidate):
             continue
+        # Level 1: conceptkernel.yaml at kernel root (flat layout)
         yaml_path = os.path.join(candidate, "conceptkernel.yaml")
-        if not os.path.isfile(yaml_path):
-            continue
-        try:
-            with open(yaml_path) as f:
-                d = yaml.safe_load(f)
-            if isinstance(d, dict) and d.get("metadata", {}).get("name") == target_name:
-                return candidate
-        except Exception:
+        if os.path.isfile(yaml_path):
+            try:
+                with open(yaml_path) as f:
+                    d = yaml.safe_load(f)
+                if isinstance(d, dict) and d.get("metadata", {}).get("name") == target_name:
+                    return candidate
+                # Also check kernel_class field
+                if isinstance(d, dict) and d.get("kernel_class") == target_name:
+                    return candidate
+            except Exception:
+                pass
             continue
+        # Level 2: conceptkernel.yaml inside a subdirectory (GUID layout)
+        for sub in os.listdir(candidate):
+            sub_path = os.path.join(candidate, sub)
+            if not os.path.isdir(sub_path):
+                continue
+            yaml_path = os.path.join(sub_path, "conceptkernel.yaml")
+            if os.path.isfile(yaml_path):
+                try:
+                    with open(yaml_path) as f:
+                        d = yaml.safe_load(f)
+                    if isinstance(d, dict) and d.get("metadata", {}).get("name") == target_name:
+                        return sub_path
+                    if isinstance(d, dict) and d.get("kernel_class") == target_name:
+                        return sub_path
+                except Exception:
+                    pass
     return None
 
 
-def resolve_composed_actions(ck_dir):
+def resolve_composed_actions(ck_dir, concepts_dir=None):
     """Walk COMPOSES/EXTENDS edges, collect target kernel actions.
 
     Returns dict: {action_name: target_kernel_name}
@@ -139,8 +163,17 @@ def resolve_composed_actions(ck_dir):
     if err:
         return {}
 
-    # Derive concepts_dir
-    concepts_dir = os.path.dirname(ck_dir)
+    # Derive concepts_dir — walk up until we find a dir containing OTHER kernels
+    if concepts_dir is None:
+        concepts_dir = os.path.dirname(ck_dir)
+        # Check if parent has OTHER kernel directories (not just our own GUID subdir)
+        ck_basename = os.path.basename(ck_dir)
+        siblings = [d for d in os.listdir(concepts_dir)
+                    if d != ck_basename
+                    and os.path.isdir(os.path.join(concepts_dir, d))
+                    and os.path.isfile(os.path.join(concepts_dir, d, "conceptkernel.yaml"))]
+        if not siblings:
+            concepts_dir = os.path.dirname(concepts_dir)
 
     edges_section = data.get("spec", {}).get("edges", data.get("edges", {}))
     outbound = edges_section.get("outbound", [])

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/cklib/dispatch.py

@@ -27,9 +27,36 @@ CONCEPTS_DIR = None
 def _init_paths():
     global PROJECT_ROOT, CONCEPTS_DIR
     if PROJECT_ROOT is None:
-        PROJECT_ROOT = os.path.abspath(
-            os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
-        CONCEPTS_DIR = os.path.join(PROJECT_ROOT, "concepts")
+        # Prefer env vars (set by CK.Operator boot or delvinator.sh)
+        if os.environ.get("CK_CONCEPTS_DIR"):
+            CONCEPTS_DIR = os.environ["CK_CONCEPTS_DIR"]
+            PROJECT_ROOT = os.path.dirname(CONCEPTS_DIR)
+        elif os.environ.get("PROJECT_ROOT"):
+            PROJECT_ROOT = os.environ["PROJECT_ROOT"]
+            CONCEPTS_DIR = os.path.join(PROJECT_ROOT, "concepts")
+        else:
+            # Fallback: walk up from cklib to find concepts/ dir containing kernel dirs
+            candidate = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+            for _ in range(5):
+                concepts_candidate = os.path.join(candidate, "concepts")
+                if os.path.isdir(concepts_candidate):
+                    # Verify it has actual kernel directories (not just a stray concepts/ folder)
+                    has_kernels = any(
+                        os.path.isfile(os.path.join(concepts_candidate, d, "conceptkernel.yaml"))
+                        or any(os.path.isfile(os.path.join(concepts_candidate, d, sub, "conceptkernel.yaml"))
+                               for sub in os.listdir(os.path.join(concepts_candidate, d))
+                               if os.path.isdir(os.path.join(concepts_candidate, d, sub)))
+                        for d in os.listdir(concepts_candidate)
+                        if os.path.isdir(os.path.join(concepts_candidate, d))
+                    )
+                    if has_kernels:
+                        PROJECT_ROOT = candidate
+                        CONCEPTS_DIR = concepts_candidate
+                        break
+                candidate = os.path.dirname(candidate)
+            else:
+                PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
+                CONCEPTS_DIR = os.path.join(PROJECT_ROOT, "concepts")
 
 
 def resolve_kernel(name):

conceptkernel-1.2.0/cklib/nats.py

@@ -0,0 +1,183 @@
+"""
+nats_kernel.py — shared NATS kernel loop for Concept Kernels.
+
+Not a standalone CK — a library that any CK's processor.py imports to become
+a NATS listener following the CK processing cycle:
+
+    Receive → Validate → Process (primary tool) → Create Instance → Publish Result → Notify
+
+Usage:
+    from nats_kernel import NatsKernelLoop
+
+    def handle_message(msg):
+        return {"status": "ok", "echo": msg}
+
+    loop = NatsKernelLoop(CK_DIR, handle_message)
+    asyncio.run(loop.run())
+"""
+import asyncio
+import json
+import os
+import time
+import uuid
+
+import yaml
+import nats
+
+
+class NatsKernelLoop:
+    """NATS listener that implements the CK processing cycle."""
+
+    # nats:// — native TCP (server processors in cluster)
+    # wss://  — WebSocket (Python CLI from local machine, needs aiohttp)
+    # Set NATS_URL env var to override
+    DEFAULT_ENDPOINT = "nats://localhost:4222"
+
+    def __init__(self, ck_dir, handler_fn):
+        self.ck_dir = os.path.abspath(ck_dir)
+        self.handler_fn = handler_fn
+        self.instance_dir = os.path.join(self.ck_dir, "storage", "instances")
+
+        # NATS endpoint: env var > .ckproject > default
+        self.endpoint = os.environ.get("NATS_URL", self.DEFAULT_ENDPOINT)
+
+        # Load identity from conceptkernel.yaml
+        ck_yaml_path = os.path.join(self.ck_dir, "conceptkernel.yaml")
+        with open(ck_yaml_path) as f:
+            self.ck = yaml.safe_load(f)
+
+        meta = self.ck["metadata"]
+        spec = self.ck["spec"]
+        nats_cfg = spec.get("nats", {})
+
+        self.kernel_name = meta["name"]
+        self.kernel_urn = meta["urn"]
+        self.input_topic = nats_cfg.get("input_topic", f"input.{self.kernel_name}")
+        self.result_topic = nats_cfg.get("result_topic", f"result.{self.kernel_name}")
+        self.event_topic = nats_cfg.get("event_topic", f"event.{self.kernel_name}")
+
+        self.nc = None
+
+    async def run(self):
+        """Connect to NATS and listen on input topic."""
+        print(f"[nats]  connecting to {self.endpoint}...")
+        self.nc = await nats.connect(self.endpoint)
+        print(f"[nats]  connected as {self.kernel_urn}")
+        print(f"[sub]   {self.input_topic}")
+        print(f"[ready] Listening on {self.input_topic}...")
+        print()
+
+        sub = await self.nc.subscribe(self.input_topic)
+
+        try:
+            async for msg in sub.messages:
+                await self._handle(msg)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            await self.nc.drain()
+
+    async def _handle(self, msg):
+        """Process a single incoming message through the CK cycle."""
+        ts = int(time.time())
+
+        # Parse headers from NATS-level headers
+        headers = {}
+        if msg.headers:
+            for key in ("Trace-Id", "Nats-Msg-Id", "X-Kernel-ID", "X-User-ID", "X-Anonymous"):
+                val = msg.headers.get(key)
+                if val:
+                    headers[key] = val
+
+        trace_id = headers.get("Trace-Id", f"tx-{uuid.uuid4().hex[:6]}")
+        sender_kernel = headers.get("X-Kernel-ID", "unknown")
+        user_id = headers.get("X-User-ID", "anonymous")
+
+        # Parse body (pure data — no control attributes)
+        try:
+            body = json.loads(msg.data.decode()) if msg.data else {}
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            body = {"raw": msg.data.decode("utf-8", errors="replace")}
+
+        print(f"[rx]    {trace_id} {msg.subject} {json.dumps(body, separators=(',', ':'))}")
+
+        # Process via primary tool (handler_fn)
+        # Pass nc + trace_id for streaming. Supports both sync and async handlers.
+        try:
+            import inspect
+            try:
+                raw = self.handler_fn(body, nc=self.nc, trace_id=trace_id)
+            except TypeError:
+                raw = self.handler_fn(body)
+
+            # If handler returned a coroutine, await it
+            if inspect.isawaitable(raw):
+                result = await raw
+            else:
+                result = raw
+            status = "ok"
+        except Exception as e:
+            result = {"error": str(e)}
+            status = "error"
+
+        # Create instance record
+        instance_id = f"i-{trace_id}-{ts}"
+        instance_path = os.path.join(self.instance_dir, instance_id)
+        os.makedirs(instance_path, exist_ok=True)
+
+        record = {
+            "instance_id": instance_id,
+            "kernel_urn": self.kernel_urn,
+            "trace_id": trace_id,
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts)),
+            "input": {
+                "subject": msg.subject,
+                "headers": headers,
+                "body": body,
+            },
+            "output": result,
+            "status": status,
+            "sender": sender_kernel,
+            "user_id": user_id,
+        }
+
+        record_path = os.path.join(instance_path, "message.json")
+        with open(record_path, "w") as f:
+            json.dump(record, f, indent=2)
+
+        # Publish result
+        result_envelope = {
+            "trace_id": trace_id,
+            "kernel_urn": self.kernel_urn,
+            "timestamp": record["timestamp"],
+            "status": status,
+            "data": result,
+        }
+
+        result_headers = {
+            "Trace-Id": trace_id,
+            "X-Kernel-ID": self.kernel_urn,
+            "Nats-Msg-Id": str(uuid.uuid4()),
+        }
+
+        await self.nc.publish(
+            self.result_topic,
+            json.dumps(result_envelope).encode(),
+            headers=result_headers,
+        )
+        print(f"[tx]    {trace_id} {self.result_topic}")
+
+        # Publish event notification
+        event = {
+            "type": "instance_created",
+            "instance_id": instance_id,
+            "trace_id": trace_id,
+            "kernel_urn": self.kernel_urn,
+            "timestamp": record["timestamp"],
+        }
+
+        await self.nc.publish(
+            self.event_topic,
+            json.dumps(event).encode(),
+            headers={"Trace-Id": trace_id, "X-Kernel-ID": self.kernel_urn},
+        )

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/cklib/processor.py

@@ -168,8 +168,7 @@ class KernelProcessor:
 
     def listen(self):
         """Start NATS listener using NatsKernelLoop."""
-        sys.path.insert(0, os.path.join(self.concepts_dir, "CK.Lib", "tool"))
-        from nats_kernel import NatsKernelLoop
+        from cklib.nats import NatsKernelLoop
         loop = NatsKernelLoop(self.ck_dir, self.handle_message)
         asyncio.run(loop.run())
 

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/conceptkernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conceptkernel
-Version: 1.1.0
+Version: 1.2.0
 Summary: CKP v3.5 Python runtime — kernel processor, provenance, execution proofs
 Author-email: Peter Styk <peter@conceptkernel.org>
 License: MIT

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/conceptkernel.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ cklib/events.py
 cklib/execution.py
 cklib/instance.py
 cklib/ledger.py
+cklib/nats.py
 cklib/processor.py
 cklib/prov.py
 cklib/schema.py

{conceptkernel-1.1.0 → conceptkernel-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conceptkernel"
-version = "1.1.0"
+version = "1.2.0"
 description = "CKP v3.5 Python runtime — kernel processor, provenance, execution proofs"
 readme = "README.md"
 license = {text = "MIT"}