apsimo 1.3.0__py3-none-any.whl

apsimo/identity_bootstrap/seeders/memory.py

@@ -0,0 +1,191 @@
+"""Memory seeder — writes foundational memories to Neo4j graph + LanceDB.
+
+Uses ColonyGraph.store_memory() which persists to Neo4j and indexes in
+LanceDB when configured.  Falls back to the API router in-memory dict
+only when the graph is unavailable (e.g. Neo4j offline).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class MemorySeeder:
+    name = "memory"
+
+    def __init__(self, colony_graph: Optional[Any] = None) -> None:
+        self._graph = colony_graph
+
+    async def seed(self, corpus: Any) -> None:
+        colony_id = corpus.colony_id
+        now = _now_iso()
+
+        memories = [
+            {
+                "id": f"mem-bootstrap-identity-{colony_id[:8]}",
+                "type": "episodic",
+                "content": (
+                    f"I am {corpus.colony_name}, a Colony AI agent instance with ID {colony_id}. "
+                    f"I run Colony v{corpus.colony_version} on network {corpus.network_id}. "
+                    "I was bootstrapped with full self-knowledge at first boot."
+                ),
+                "tags": ["self", "identity", "bootstrap", "core"],
+                "source": "identity_bootstrap",
+                "entities": [corpus.colony_name, "Colony"],
+                "metadata": {
+                    "bootstrap_id": f"mem-bootstrap-identity-{colony_id[:8]}",
+                    "colony_id": colony_id,
+                    "colony_name": corpus.colony_name,
+                    "colony_version": corpus.colony_version,
+                    "network_id": corpus.network_id,
+                    "corpus_version": corpus.corpus_version,
+                    "tags": ["self", "identity", "bootstrap", "core"],
+                    "source": "identity_bootstrap",
+                    "created_at": now,
+                },
+                "importance": 0.95,
+            },
+            {
+                "id": f"mem-bootstrap-architecture-{colony_id[:8]}",
+                "type": "semantic",
+                "content": (
+                    "Colony has 10 architectural layers: Gateway, API, Intelligence, Memory, "
+                    "Goals, Skills, TaskQueue, Federation, Safety, and Inference. "
+                    "Each layer is independently optional and fails gracefully."
+                ),
+                "tags": ["architecture", "bootstrap", "core"],
+                "source": "identity_bootstrap",
+                "entities": ["Colony"] + [l.name for l in corpus.layers],
+                "metadata": {
+                    "bootstrap_id": f"mem-bootstrap-architecture-{colony_id[:8]}",
+                    "layer_count": len(corpus.layers),
+                    "layers": [l.name for l in corpus.layers],
+                    "tags": ["architecture", "bootstrap", "core"],
+                    "source": "identity_bootstrap",
+                    "created_at": now,
+                },
+                "importance": 0.85,
+            },
+            {
+                "id": f"mem-bootstrap-safety-{colony_id[:8]}",
+                "type": "semantic",
+                "content": (
+                    "The ResponseGate pipeline has 7 layers: L1 RecipientAllowlist, L2 PIIScrubber, "
+                    "L3 CrossContextGuard, L4 TrustTierGate, L5 InjectionDetector, "
+                    "L6 HumanReview, L7 SendDelay. All outbound content passes through this pipeline."
+                ),
+                "tags": ["safety", "gate", "bootstrap"],
+                "source": "identity_bootstrap",
+                "entities": ["ResponseGate", "Colony"],
+                "metadata": {
+                    "bootstrap_id": f"mem-bootstrap-safety-{colony_id[:8]}",
+                    "gate_layer_count": len(corpus.gate_layers),
+                    "tags": ["safety", "gate", "bootstrap"],
+                    "source": "identity_bootstrap",
+                    "created_at": now,
+                },
+                "importance": 0.90,
+            },
+            {
+                "id": f"mem-bootstrap-cognition-{colony_id[:8]}",
+                "type": "semantic",
+                "content": (
+                    "Colony's cognition pipeline runs 8 phases: MetaLearning, StrategyAdjustment, "
+                    "SelfReflection, SessionContinuity, ToolLearning, PreferenceLearning, "
+                    "TaskPlanning, and ResearchOrchestration."
+                ),
+                "tags": ["cognition", "intelligence", "bootstrap"],
+                "source": "identity_bootstrap",
+                "entities": ["Colony", "CognitionPipeline"],
+                "metadata": {
+                    "bootstrap_id": f"mem-bootstrap-cognition-{colony_id[:8]}",
+                    "phase_count": len(corpus.cognition_phases),
+                    "phases": [p.name for p in corpus.cognition_phases],
+                    "tags": ["cognition", "intelligence", "bootstrap"],
+                    "source": "identity_bootstrap",
+                    "created_at": now,
+                },
+                "importance": 0.80,
+            },
+        ]
+
+        stored_count = 0
+
+        # Primary path: write to Neo4j graph (+ LanceDB via store_memory)
+        if self._graph is not None:
+            for mem in memories:
+                try:
+                    # Check if this bootstrap memory already exists in the graph
+                    exists = await self._memory_exists_in_graph(mem["id"])
+                    if exists:
+                        logger.debug("memory: %s already in graph — skipping", mem["id"])
+                        stored_count += 1
+                        continue
+
+                    memory_id = await self._graph.store_memory(
+                        content=mem["content"],
+                        memory_type=mem["type"],
+                        entities=mem.get("entities", []),
+                        metadata=mem["metadata"],
+                        importance=mem["importance"],
+                    )
+                    logger.debug(
+                        "memory: stored %s as graph node %s", mem["id"], memory_id
+                    )
+                    stored_count += 1
+                except Exception as exc:
+                    logger.warning("memory: failed to store %s in graph: %s", mem["id"], exc)
+        else:
+            # Fallback: write to API router in-memory dict (non-persistent)
+            logger.warning(
+                "memory: no colony_graph available — falling back to ephemeral API dict"
+            )
+            try:
+                import colony.api.routers.memory as memory_mod
+                api_store = getattr(memory_mod, "_store", None)
+                if api_store is not None:
+                    for mem in memories:
+                        mem_id = mem["id"]
+                        if mem_id not in api_store:
+                            api_store[mem_id] = {
+                                "id": mem_id,
+                                "content": mem["content"],
+                                "type": mem["type"],
+                                "tags": mem["tags"],
+                                "source": mem["source"],
+                                "metadata": mem["metadata"],
+                                "strength": 1.0,
+                                "importance": mem["importance"],
+                                "decay_factor": 1.0,
+                                "created_at": now,
+                                "person_id": None,
+                            }
+                            stored_count += 1
+            except ImportError:
+                logger.debug("memory: API router not importable — skipping fallback")
+
+        logger.info("memory: seeded %d foundational memories", stored_count)
+
+    async def _memory_exists_in_graph(self, bootstrap_id: str) -> bool:
+        """Check if a bootstrap memory already exists by searching for its source tag."""
+        try:
+            async with self._graph.driver.session(
+                database=self._graph.database
+            ) as session:
+                result = await session.run(
+                    "MATCH (m:Memory) WHERE m.metadata CONTAINS $tag RETURN count(m) > 0 AS exists",
+                    tag=bootstrap_id,
+                )
+                record = await result.single()
+                return record is not None and record["exists"]
+        except Exception:
+            return False

apsimo/identity_bootstrap/seeders/neo4j_cognition.py

@@ -0,0 +1,79 @@
+"""Neo4j cognition seeder — writes bootstrap metrics and a BootstrapEvent node to Neo4j."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Neo4jCognitionSeeder:
+    name = "neo4j_cognition"
+
+    def __init__(
+        self,
+        colony_graph: Optional[Any] = None,
+        metrics_collector: Optional[Any] = None,
+    ) -> None:
+        self._graph = colony_graph
+        self._metrics = metrics_collector
+
+    async def seed(self, corpus: Any) -> None:
+        colony_id = corpus.colony_id
+        now_iso = datetime.now(timezone.utc).isoformat()
+
+        # Record bootstrap metrics
+        if self._metrics is not None:
+            try:
+                await self._metrics.record(
+                    metric_type="bootstrap_layer_count",
+                    value=float(len(corpus.layers)),
+                    domain="identity",
+                    context={"colony_id": colony_id},
+                )
+                await self._metrics.record(
+                    metric_type="bootstrap_endpoint_count",
+                    value=float(len(corpus.api_endpoints)),
+                    domain="identity",
+                    context={"colony_id": colony_id},
+                )
+                await self._metrics.record(
+                    metric_type="bootstrap_gate_layers",
+                    value=float(len(corpus.gate_layers)),
+                    domain="safety",
+                    context={"colony_id": colony_id},
+                )
+                logger.info("neo4j_cognition: bootstrap metrics recorded")
+            except Exception as exc:
+                logger.warning("neo4j_cognition: metrics recording failed: %s", exc)
+
+        # Write BootstrapEvent node to Neo4j
+        if self._graph is not None:
+            cypher = """
+            MERGE (b:BootstrapEvent {colony_id: $colony_id})
+            SET b.colony_name      = $colony_name,
+                b.colony_version   = $colony_version,
+                b.network_id       = $network_id,
+                b.corpus_version   = $corpus_version,
+                b.bootstrapped_at  = $bootstrapped_at,
+                b.layer_count      = $layer_count,
+                b.endpoint_count   = $endpoint_count
+            RETURN b.colony_id
+            """
+            params = {
+                "colony_id": colony_id,
+                "colony_name": corpus.colony_name,
+                "colony_version": corpus.colony_version,
+                "network_id": corpus.network_id,
+                "corpus_version": corpus.corpus_version,
+                "bootstrapped_at": now_iso,
+                "layer_count": len(corpus.layers),
+                "endpoint_count": len(corpus.api_endpoints),
+            }
+            try:
+                await self._graph.run_query(cypher, params)
+                logger.info("neo4j_cognition: BootstrapEvent node upserted for colony_id=%s", colony_id)
+            except Exception as exc:
+                logger.warning("neo4j_cognition: run_query failed: %s", exc)

apsimo/identity_bootstrap/seeders/relationship.py

@@ -0,0 +1,152 @@
+"""Relationship / contacts seeder — creates self-contact in the contacts store."""
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+import secrets
+from datetime import datetime, timezone
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _hdl_id() -> str:
+    ts = int(time.time() * 1000)
+    rand = secrets.token_hex(4)
+    return f"hdl-{ts}-{rand}"
+
+
+class RelationshipSeeder:
+    name = "contacts"
+
+    async def seed(self, corpus: Any) -> None:
+        """Seed the self-contact into the contacts store."""
+        colony_id = corpus.colony_id
+        contact_id = f"self:{colony_id}"
+        now = _now_iso()
+
+        try:
+            import colony.api.routers.contacts as contacts_mod
+        except ImportError:
+            logger.debug("contacts: router not importable — skipping")
+            return
+
+        store = getattr(contacts_mod, "_contact_store", None)
+
+        if store is not None:
+            await self._seed_sqlite(store, contact_id, corpus, now)
+        else:
+            self._seed_memory(contacts_mod, contact_id, corpus, now)
+
+    async def _seed_sqlite(self, store: Any, contact_id: str, corpus: Any, now: str) -> None:
+        """Upsert self-contact via the store's aiosqlite connection."""
+        db = getattr(store, "_db", None)
+        if db is None:
+            logger.debug("contacts: store._db is None — falling back to memory")
+            return
+
+        colony_id = corpus.colony_id
+        tags_json = json.dumps(["self", "system", "colony"])
+
+        try:
+            # Use aiosqlite's async execute
+            await db.execute(
+                """
+                INSERT INTO contacts
+                    (contact_id, display_name, given_name, family_name, organization,
+                     relationship_score, trust_tier, interaction_allowed,
+                     tags_json, privacy_level, person_node_id, notes, import_source,
+                     first_seen_at, last_interaction_at, interaction_count,
+                     enrichment_source, enrichment_last_at, deleted_at,
+                     created_at, updated_at)
+                VALUES
+                    (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                ON CONFLICT(contact_id) DO UPDATE SET
+                    updated_at = excluded.updated_at,
+                    trust_tier = excluded.trust_tier
+                """,
+                (
+                    contact_id,
+                    corpus.colony_name,
+                    "Colony",
+                    "Self",
+                    "Colony AI",
+                    1.0,
+                    "inner_circle",
+                    1,
+                    tags_json,
+                    "private",
+                    f"colony-self-{colony_id}",
+                    "Auto-seeded by identity bootstrap",
+                    "identity_bootstrap",
+                    now,
+                    now,
+                    0,
+                    json.dumps(["identity_bootstrap"]),
+                    now,
+                    None,
+                    now,
+                    now,
+                ),
+            )
+            await db.commit()
+        except Exception as exc:
+            logger.warning("contacts: sqlite upsert failed: %s", exc)
+            return
+
+        # Add internal handle
+        hdl_id = f"hdl-self-{colony_id[:8]}"
+        try:
+            await db.execute(
+                """
+                INSERT INTO contact_handles
+                    (handle_id, contact_id, gateway, address,
+                     is_primary, verified, confidence, source, created_at)
+                VALUES (?,?,?,?,?,?,?,?,?)
+                ON CONFLICT(handle_id) DO NOTHING
+                """,
+                (hdl_id, contact_id, "custom", f"colony://{colony_id}", 1, 1, 1.0, "identity_bootstrap", now),
+            )
+            await db.commit()
+        except Exception as exc:
+            logger.debug("contacts: handle upsert failed: %s", exc)
+
+        logger.info("contacts: self-contact seeded (contact_id=%s)", contact_id)
+
+    def _seed_memory(self, contacts_mod: Any, contact_id: str, corpus: Any, now: str) -> None:
+        """Fallback: write to the in-memory _store dict."""
+        in_mem = getattr(contacts_mod, "_store", None)
+        if in_mem is None:
+            logger.debug("contacts: no _store fallback available")
+            return
+
+        in_mem[contact_id] = {
+            "contact_id": contact_id,
+            "display_name": corpus.colony_name,
+            "given_name": "Colony",
+            "family_name": "Self",
+            "organization": "Colony AI",
+            "relationship_score": 1.0,
+            "trust_tier": "inner_circle",
+            "interaction_allowed": True,
+            "tags": ["self", "system", "colony"],
+            "privacy_level": "private",
+            "person_node_id": f"colony-self-{corpus.colony_id}",
+            "notes": "Auto-seeded by identity bootstrap",
+            "import_source": "identity_bootstrap",
+            "first_seen_at": now,
+            "last_interaction_at": now,
+            "interaction_count": 0,
+            "enrichment_source": ["identity_bootstrap"],
+            "enrichment_last_at": now,
+            "deleted_at": None,
+            "created_at": now,
+            "updated_at": now,
+        }
+        logger.info("contacts: self-contact seeded (in-memory, contact_id=%s)", contact_id)

apsimo/identity_bootstrap/seeders/sessions.py

@@ -0,0 +1,67 @@
+"""Sessions seeder — records the bootstrap system session."""
+
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime, timezone
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+class SessionsSeeder:
+    name = "sessions"
+
+    async def seed(self, corpus: Any) -> None:
+        colony_id = corpus.colony_id
+        contact_id = f"self:{colony_id}"
+        session_id = f"sess-bootstrap-{colony_id[:8]}"
+        now = _now_iso()
+        # 1 year expiry for bootstrap session
+        expires_at_ts = time.time() + 86400 * 365
+
+        try:
+            import colony.api.routers.sessions as sessions_mod
+        except ImportError:
+            logger.debug("sessions: router not importable — skipping")
+            return
+
+        db_backend = getattr(sessions_mod, "_db_backend", None)
+
+        if db_backend is not None:
+            sess_dict = {
+                "session_id": session_id,
+                "contact_id": contact_id,
+                "gateway": "system",
+                "trust_tier": "inner_circle",
+                "status": "active",
+                "created_at": now,
+                "closed_at": None,
+                "expires_at_ts": expires_at_ts,
+            }
+            try:
+                db_backend.save(sess_dict)
+                logger.info("sessions: bootstrap session saved (id=%s)", session_id)
+                return
+            except Exception as exc:
+                logger.warning("sessions: db_backend.save failed: %s", exc)
+
+        # Fallback: in-memory store
+        in_mem = getattr(sessions_mod, "_store", None)
+        if in_mem is not None:
+            in_mem[session_id] = {
+                "session_id": session_id,
+                "contact_id": contact_id,
+                "gateway": "system",
+                "trust_tier": "inner_circle",
+                "status": "active",
+                "created_at": now,
+                "closed_at": None,
+                "expires_at_ts": expires_at_ts,
+            }
+            logger.info("sessions: bootstrap session saved in-memory (id=%s)", session_id)

apsimo/identity_bootstrap/seeders/skills.py

@@ -0,0 +1,92 @@
+"""Skills seeder — registers the bootstrap_self_check skill in the skill registry."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SkillsSeeder:
+    name = "skills"
+
+    def __init__(self, skill_registry: Optional[Any] = None) -> None:
+        self._registry = skill_registry
+
+    async def seed(self, corpus: Any) -> None:
+        registry = self._registry
+        if registry is None:
+            logger.debug("skills: no registry — skipping")
+            return
+
+        try:
+            from apsimo.skills.models import (
+                SkillManifest,
+                SkillStatus,
+                SkillPermissions,
+                SkillCapability,
+            )
+        except ImportError as exc:
+            logger.debug("skills: import failed — skipping: %s", exc)
+            return
+
+        colony_id = corpus.colony_id
+        skill_id = "bootstrap-self-check"
+        now = datetime.now(timezone.utc)
+
+        # Check idempotency
+        try:
+            existing = await registry.get(skill_id)
+            if existing is not None:
+                logger.debug("skills: bootstrap_self_check already registered — skipping")
+                return
+        except Exception:
+            pass
+
+        manifest = SkillManifest(
+            skill_id=skill_id,
+            name="bootstrap_self_check",
+            version="1.0.0",
+            description=(
+                "Runs the Colony Identity Bootstrap self-check matrix (16 checks). "
+                "Returns a verification report showing which systems are healthy."
+            ),
+            author_colony_id=colony_id,
+            created_at=now,
+            updated_at=now,
+            status=SkillStatus.ACTIVE,
+            entry_point="colony.identity_bootstrap.skill:run",
+            permissions=SkillPermissions(
+                capabilities=[SkillCapability.FILESYSTEM_READ],
+                max_duration_secs=30,
+                max_memory_mb=64,
+            ),
+            tags=["system", "bootstrap", "self-check", "health"],
+            dependencies=[],
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "colony_id": {"type": "string"},
+                    "mode": {"type": "string", "enum": ["full", "quick"], "default": "full"},
+                },
+            },
+            output_schema={
+                "type": "object",
+                "properties": {
+                    "verified_systems": {"type": "array", "items": {"type": "string"}},
+                    "failed_systems": {"type": "array", "items": {"type": "string"}},
+                    "anomalies": {"type": "array"},
+                    "success": {"type": "boolean"},
+                },
+            },
+            checksum_sha256="bootstrap-internal",
+            trust_score=1.0,
+        )
+
+        try:
+            await registry.register(manifest, skill_dir=None)
+            logger.info("skills: bootstrap_self_check skill registered")
+        except Exception as exc:
+            logger.warning("skills: registry.register failed: %s", exc)

apsimo/identity_bootstrap/seeders/task_queue.py

@@ -0,0 +1,72 @@
+"""Task queue seeder — registers bootstrap worker capabilities and posts a self-check job."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class TaskQueueSeeder:
+    name = "task_queue"
+
+    def __init__(self, queue_manager: Optional[Any] = None) -> None:
+        self._queue_manager = queue_manager
+
+    async def seed(self, corpus: Any) -> None:
+        queue = self._queue_manager
+        if queue is None:
+            logger.debug("task_queue: no queue_manager — skipping")
+            return
+
+        try:
+            from apsimo.task_queue.models import (
+                Job,
+                JobType,
+                JobPriority,
+                WorkerCapabilities,
+            )
+        except ImportError as exc:
+            logger.debug("task_queue: import failed — skipping: %s", exc)
+            return
+
+        colony_id = corpus.colony_id
+
+        # Register bootstrap worker capabilities
+        caps = WorkerCapabilities(
+            node_id=f"bootstrap-{colony_id[:8]}",
+            capabilities={"bootstrap", "self_check", "identity"},
+            capacity={"cpu": 1.0},
+            max_concurrent=1,
+            job_types={JobType.SYSTEM_MAINTENANCE, JobType.MONITORING},
+            available=True,
+            load=0.0,
+            registered_at=datetime.now(timezone.utc),
+        )
+        try:
+            await queue.register_worker(caps)
+        except Exception as exc:
+            logger.debug("task_queue: register_worker failed: %s", exc)
+
+        # Post the initial self-check job
+        job_id = f"job-bootstrap-selfcheck-{colony_id[:8]}"
+        job = Job(
+            job_id=job_id,
+            job_type=JobType.SYSTEM_MAINTENANCE,
+            payload={
+                "action": "identity_self_check",
+                "colony_id": colony_id,
+                "corpus_version": corpus.corpus_version,
+                "triggered_by": "identity_bootstrap",
+            },
+            priority=JobPriority.LOW,
+            posted_by=f"bootstrap-{colony_id[:8]}",
+            tags={"type": "bootstrap", "colony_id": colony_id[:8]},
+        )
+        try:
+            await queue.post(job)
+            logger.info("task_queue: self-check job posted (id=%s)", job_id)
+        except Exception as exc:
+            logger.debug("task_queue: post job failed: %s", exc)