monkeybrain-runtime 1.0.0__py3-none-any.whl

src/monkey_brain/kernel/goals/goal_registry.py

@@ -0,0 +1,75 @@
+"""Goal registry — stores registered goal definitions."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from src.monkey_brain.kernel.goals.goal import Goal, GoalType
+
+logger = logging.getLogger(__name__)
+
+
+def build_goal_registry() -> GoalRegistry:
+    """Build the goal registry with all default goals."""
+    from src.monkey_brain.kernel.intents.intent_registry import INTENT_DEFINITIONS
+
+    registry = GoalRegistry()
+
+    for intent_name, intent_def in INTENT_DEFINITIONS.items():
+        goal = Goal(
+            name=intent_def.intent,
+            description=intent_def.description or f"Goal for {intent_def.intent}",
+            goal_type=GoalType.QUERY,
+            required_inputs=list(intent_def.required_inputs),
+            required_outputs=list(intent_def.required_outputs),
+            augmentations=list(intent_def.default_augmentations),
+            constraints=dict(intent_def.constraints),
+        )
+        registry.register_goal(goal)
+
+    return registry
+
+
+class GoalRegistry:
+    """Central registry for goal definitions."""
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            instance = super().__new__(cls)
+            instance._goals = {}
+            cls._instance = instance
+        return cls._instance
+
+    def register_goal(self, goal: Goal) -> None:
+        self._goals[goal.name] = goal
+
+    def get_goal(self, intent_name: str) -> Goal | None:
+        return self._goals.get(intent_name)
+
+    def list_goals(self) -> list[Goal]:
+        return list(self._goals.values())
+
+    def remove_goal(self, intent_name: str) -> bool:
+        if intent_name in self._goals:
+            del self._goals[intent_name]
+            return True
+        return False
+
+    def has_goal(self, intent_name: str) -> bool:
+        return intent_name in self._goals
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "goals": {
+                name: {
+                    "goal_type": goal.goal_type.value,
+                    "required_inputs": goal.required_inputs,
+                    "required_outputs": goal.required_outputs,
+                }
+                for name, goal in self._goals.items()
+            },
+            "count": len(self._goals),
+        }

src/monkey_brain/kernel/intents/__init__.py

@@ -0,0 +1 @@
+"""Intents module."""

src/monkey_brain/kernel/intents/event_adapter.py

@@ -0,0 +1,246 @@
+"""Event Execution Adapter — converts semantic event plans into InfluxDB queries.
+
+Converts operation + entity + time_window + event_table into validated SQL queries.
+Never generates raw Flux. Never hallucinates measurements.
+"""
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.request import Request, urlopen
+from urllib.parse import urlencode
+
+from services.common.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Valid event tables — only these are allowed
+VALID_EVENT_TABLES = frozenset({
+    "maintenance_log", "downtime_log", "calibration_log", "cleaning_log",
+    "rfid_scan", "nfc_scan", "count_event", "event_log",
+})
+
+# Valid operations for this adapter
+VALID_OPERATIONS = frozenset({
+    "event_lookup", "downtime_analysis", "count_aggregation",
+    "audit_reconstruction", "recurrence_analysis", "compliance_timing",
+    "activity_analysis", "anomaly_events",
+})
+
+# Table → SQL measurement mapping
+_TABLE_TO_MEASUREMENT = {
+    "maintenance_log": "maintenance_log",
+    "downtime_log": "downtime_log",
+    "calibration_log": "calibration_log",
+    "cleaning_log": "cleaning_log",
+    "rfid_scan": "rfid_scan",
+    "nfc_scan": "nfc_scan",
+    "count_event": "count_event",
+    "event_log": "event_log",
+}
+
+# Time window → SQL interval mapping
+_TW_TO_INTERVAL = {
+    "last_1_hour": "INTERVAL '1 hour'",
+    "last_1_day": "INTERVAL '1 day'",
+    "last_1_week": "INTERVAL '7 days'",
+    "last_1_month": "INTERVAL '30 days'",
+    "today": "INTERVAL '1 day'",
+    "yesterday": "INTERVAL '1 day'",
+    "current_shift": "INTERVAL '8 hours'",
+    "current_week": "INTERVAL '7 days'",
+    "current_month": "INTERVAL '30 days'",
+}
+
+# Configurable constants
+DEFAULT_TIME_WINDOW = "INTERVAL '90 days'"
+DEFAULT_LIMIT = 100
+MAX_DISPLAY_ROWS = 20
+QUERY_TIMEOUT = 10
+
+
+def _sanitize_sql_string(value: str) -> str:
+    """Escape single quotes for SQL string interpolation."""
+    if not isinstance(value, str):
+        value = str(value)
+    return value.replace("'", "''").replace("\\", "\\\\")
+
+
+def _validate_limit(limit: Any) -> int:
+    """Validate and clamp limit to safe range."""
+    try:
+        limit = int(limit)
+    except (TypeError, ValueError):
+        limit = DEFAULT_LIMIT
+    return max(1, min(limit, 10000))
+
+
+def _build_time_filter(time_window: str) -> str:
+    if not time_window:
+        return f"time >= now() - {DEFAULT_TIME_WINDOW}"
+    interval = _TW_TO_INTERVAL.get(time_window)
+    if not interval:
+        logger.warning("Unknown time_window '%s', using default 7 days", time_window)
+        interval = "INTERVAL '7 days'"
+    return f"time >= now() - {interval}"
+
+
+def _build_entity_filter(entity_id: str, entity_name: str, event_table: str) -> str:
+    filters = []
+    if entity_id and entity_id != "none":
+        eid = _sanitize_sql_string(entity_id)
+        if event_table in ("maintenance_log", "downtime_log", "cleaning_log"):
+            filters.append(f"machine_id = '{eid}'")
+        elif event_table == "calibration_log":
+            name_clean = _sanitize_sql_string(entity_name)
+            filters.append(f"(equipment_name = '{name_clean}' OR machine_id = '{eid}')")
+    return " AND ".join(filters) if filters else "1=1"
+
+
+@dataclass
+class EventQueryPlan:
+    operation: str
+    entity_id: str
+    entity_name: str
+    event_table: str
+    time_window: str = ""
+    filters: dict[str, str] = field(default_factory=dict)
+    limit: int = DEFAULT_LIMIT
+
+
+@dataclass
+class EventQueryResult:
+    plan: EventQueryPlan
+    rows: list[dict[str, Any]]
+    sql: str
+    error: str = ""
+
+
+class EventExecutionAdapter:
+    """Converts semantic event plans into InfluxDB SQL queries."""
+
+    def __init__(self):
+        self.url = settings.INFLUXDB_URL.rstrip("/")
+        self.token = settings.INFLUXDB_TOKEN
+        self.db = settings.INFLUXDB_BUCKET
+
+    def build_plan(self, operation: str, entities: list[dict], event_table: str = "",
+                   time_window: str = "", filters: dict[str, str] = None) -> EventQueryPlan:
+        entity_id = ""
+        entity_name = ""
+        if entities and isinstance(entities[0], dict):
+            entity_id = entities[0].get("id", "")
+            entity_name = entities[0].get("name", "")
+        if event_table and event_table not in VALID_EVENT_TABLES:
+            logger.warning("Invalid event_table '%s', defaulting to maintenance_log", event_table)
+            event_table = "maintenance_log"
+        return EventQueryPlan(
+            operation=operation, entity_id=entity_id, entity_name=entity_name,
+            event_table=event_table or "maintenance_log", time_window=time_window,
+            filters=filters or {}, limit=_validate_limit(DEFAULT_LIMIT),
+        )
+
+    def execute(self, plan: EventQueryPlan) -> EventQueryResult:
+        if not plan.operation or plan.operation not in VALID_OPERATIONS:
+            logger.warning("Unknown operation '%s', falling back to event_lookup", plan.operation)
+            plan.operation = "event_lookup"
+        if plan.operation == "downtime_analysis":
+            return self._execute_downtime(plan)
+        elif plan.operation == "count_aggregation":
+            return self._execute_count(plan)
+        return self._execute_lookup(plan)
+
+    def _execute_lookup(self, plan: EventQueryPlan) -> EventQueryResult:
+        measurement = _TABLE_TO_MEASUREMENT.get(plan.event_table)
+        if not measurement:
+            return EventQueryResult(plan=plan, rows=[], sql="", error=f"Unknown event table: {plan.event_table}")
+
+        time_filter = _build_time_filter(plan.time_window)
+        entity_filter = _build_entity_filter(plan.entity_id, plan.entity_name, plan.event_table)
+        where = f"WHERE {time_filter}"
+        if entity_filter != "1=1":
+            where += f" AND {entity_filter}"
+
+        limit = _validate_limit(plan.limit)
+        sql = f"SELECT payload_json FROM \"{measurement}\" {where} ORDER BY time DESC LIMIT {limit}"
+        rows = self._query(sql)
+        return EventQueryResult(plan=plan, rows=rows, sql=sql)
+
+    def _execute_count(self, plan: EventQueryPlan) -> EventQueryResult:
+        measurement = _TABLE_TO_MEASUREMENT.get(plan.event_table)
+        if not measurement:
+            return EventQueryResult(plan=plan, rows=[], sql="", error=f"Unknown table: {plan.event_table}")
+
+        time_filter = _build_time_filter(plan.time_window)
+        entity_filter = _build_entity_filter(plan.entity_id, plan.entity_name, plan.event_table)
+        where = f"WHERE {time_filter}"
+        if entity_filter != "1=1":
+            where += f" AND {entity_filter}"
+
+        sql = f"SELECT count(*) as cnt FROM \"{measurement}\" {where}"
+        rows = self._query(sql)
+        return EventQueryResult(plan=plan, rows=rows, sql=sql)
+
+    def _execute_downtime(self, plan: EventQueryPlan) -> EventQueryResult:
+        measurement = _TABLE_TO_MEASUREMENT.get(plan.event_table, "downtime_log")
+        if measurement not in VALID_EVENT_TABLES:
+            measurement = "downtime_log"
+
+        time_filter = _build_time_filter(plan.time_window)
+        entity_filter = _build_entity_filter(plan.entity_id, plan.entity_name, measurement)
+        where = f"WHERE {time_filter}"
+        if entity_filter != "1=1":
+            where += f" AND {entity_filter}"
+
+        limit = _validate_limit(plan.limit)
+        sql = f"SELECT payload_json FROM \"{measurement}\" {where} ORDER BY time DESC LIMIT {limit}"
+        rows = self._query(sql)
+        return EventQueryResult(plan=plan, rows=rows, sql=sql)
+
+    def _query(self, sql: str) -> list[dict[str, Any]]:
+        params = urlencode({"db": self.db, "q": sql})
+        url = f"{self.url}/api/v3/query_sql?{params}"
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        req = Request(url, headers=headers, method="GET")
+        try:
+            with urlopen(req, timeout=QUERY_TIMEOUT) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                if isinstance(data, list):
+                    return [self._parse_payload(row) for row in data if row.get("payload_json")]
+                return []
+        except Exception as e:
+            logger.error("InfluxDB query failed: %s", e)
+            return []
+
+    def _parse_payload(self, row: dict) -> dict:
+        payload_str = row.get("payload_json", "")
+        try:
+            payload = json.loads(payload_str) if isinstance(payload_str, str) else payload_str
+            if isinstance(payload, dict):
+                payload["_time"] = str(row.get("time", ""))
+            return payload if isinstance(payload, dict) else {"payload_raw": payload_str}
+        except (json.JSONDecodeError, TypeError):
+            return {"payload_raw": str(payload_str)[:200], "_time": str(row.get("time", ""))}
+
+    def format_answer(self, result: EventQueryResult) -> str:
+        if result.error:
+            return f"Error: {result.error}"
+        if not result.rows:
+            table_name = result.plan.event_table.replace("_", " ")
+            return f"No {table_name} events found."
+        table_name = result.plan.event_table.replace("_", " ").title()
+        lines = [f"{table_name} events:"]
+        for row in result.rows[:MAX_DISPLAY_ROWS]:
+            if "error" in row:
+                lines.append(f"- Error: {row['error'][:80]}")
+                continue
+            event_type = row.get("type", row.get("event_type", "event"))
+            machine = row.get("machine_name", row.get("machine_id", row.get("equipment_name", "")))
+            status = row.get("status", "")
+            date = row.get("date", str(row.get("_time", ""))[:10])
+            parts = [p for p in [f"- {event_type}", machine, status, date] if p]
+            lines.append(" | ".join(parts))
+        if len(result.rows) > MAX_DISPLAY_ROWS:
+            lines.append(f"... and {len(result.rows) - MAX_DISPLAY_ROWS} more events")
+        return "\n".join(lines)

src/monkey_brain/kernel/intents/helpers.py

@@ -0,0 +1,13 @@
+"""Intent helpers."""
+
+def build_graph_query_plan(question: str) -> Any:
+    """Build graph query plan from question."""
+    return type('QueryPlan', (), {'as_dict': lambda self: {'question': question}})()
+
+def clean_user_answer_for_question(answer: str, question: str) -> str:
+    """Clean answer for question."""
+    return answer
+
+def semantic_hit_citation(hit: Any) -> str:
+    """Generate citation for semantic hit."""
+    return f"{hit.get('collection', '')}:{hit.get('document_id', '')}" if isinstance(hit, dict) else ""