monkeybrain-runtime 1.0.0__py3-none-any.whl

src/monkey_brain/kernel/intents/intent_router.py

@@ -0,0 +1,102 @@
+"""Intent router — maps classified intents to handlers.
+
+Bellman owns execution policy.
+This module provides:
+  - classified_intent_is(): confidence threshold check
+  - query_plan_from_classification(): extract or build query plan
+  - unsupported_intent_answer(): fallback for unmatched intents
+  - route_question(): automatic routing using classifier
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+from src.monkey_brain.kernel.intents.intent_registry import INTENT_REGISTRY, get_intent_definition
+from src.monkey_brain.kernel.classifier.embed_classifier import classify_intent
+
+
+def classified_intent_is(classified_intent: dict, *intents: str, min_confidence: float = 0.58) -> bool:
+    """Check if classified intent matches any of the provided intents."""
+    return (
+        str(classified_intent.get("intent") or "") in intents
+        and float(classified_intent.get("confidence") or 0.0) >= min_confidence
+    )
+
+
+def query_plan_from_classification(classified_intent: dict, question: str) -> dict:
+    """Extract or build query plan from classification."""
+    plan = classified_intent.get("query_plan")
+
+def unsupported_intent_answer(classified_intent: dict) -> str:
+    """Generate fallback answer for unsupported intents."""
+    candidates = classified_intent.get("candidates") or []
+    top = candidates[0] if candidates else {}
+    top_intent = top.get("intent") or "unknown"
+    confidence = top.get("confidence", 0)
+    return (
+        "I do not have a supported intent for that question yet.\n"
+        f"Closest match: {top_intent} ({confidence}).\n"
+        "I logged it so we can add a new intent."
+    )
+
+
+def route_question(question: str) -> dict[str, Any]:
+    """Route a question using the classifier.
+    
+    Returns:
+        {
+            "intent": str,
+            "confidence": float,
+            "question": str,
+            "supported": bool,
+        }
+    """
+    result = classify_intent(question, {"verb": "query", "target": "general"})
+    
+    if not result:
+        return {
+            "intent": "unknown",
+            "confidence": 0.0,
+            "question": question,
+            "supported": False,
+        }
+    
+    intent_name = result.get("intent", "unknown")
+    confidence = result.get("confidence", 0)
+    supported = intent_name in INTENT_REGISTRY
+    
+    return {
+        "intent": intent_name,
+        "confidence": confidence,
+        "question": question,
+        "supported": supported,
+    }
+
+
+def get_pipeline_for_intent(intent_name: str) -> str | None:
+    """Get the pipeline ID for an intent."""
+    route = INTENT_REGISTRY.get(intent_name)
+    if route:
+        return intent_name
+    return None
+
+
+async def execute_intent(
+    mongo_client: Any,
+    question: str,
+    classified_intent: dict,
+    **kwargs: Any,
+) -> tuple[str, list, list, bool] | None:
+    """Execute a classified intent by looking up its handler in the registry."""
+    intent_name = classified_intent.get("intent")
+    if not intent_name:
+        return None
+
+    route = INTENT_REGISTRY.get(intent_name)
+    if not route:
+        return None
+
+    result = await route.handler(mongo_client, question, force=True)
+    return result

src/monkey_brain/kernel/intents/predicates/approval_create.py

@@ -0,0 +1,9 @@
+"""Approval create predicates."""
+
+async def approval_create_question_answer(client, question, force=False):
+    """Generate approval create answer."""
+    return None
+
+def is_approval_create_question(question):
+    """Check if question is about approval creation."""
+    return "approval" in question.lower() and ("create" in question.lower() or "request" in question.lower())

src/monkey_brain/kernel/intents/predicates/approval_decision.py

@@ -0,0 +1,9 @@
+"""approval_decision predicates."""
+
+async def approval_decision_question_answer(client, question, force=False):
+    """Generate approval decision answer."""
+    return None
+
+def is_approval_decision_question(question):
+    """Check if question is about approval decision."""
+    return "approval decision" in question.lower()

src/monkey_brain/kernel/intents/predicates/approval_hold.py

@@ -0,0 +1,9 @@
+"""approval_hold predicates."""
+
+async def approval_hold_question_answer(client, question, force=False):
+    """Generate approval hold answer."""
+    return None
+
+def is_approval_hold_question(question):
+    """Check if question is about approval hold."""
+    return "approval hold" in question.lower()

src/monkey_brain/kernel/intents/predicates/approval_query.py

@@ -0,0 +1,9 @@
+"""approval_query predicates."""
+
+async def approval_query_question_answer(client, question, force=False):
+    """Generate approval query answer."""
+    return None
+
+def is_approval_query_question(question):
+    """Check if question is about approval query."""
+    return "approval query" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_close.py

@@ -0,0 +1,9 @@
+"""batch_close predicates."""
+
+async def batch_close_question_answer(client, question, force=False):
+    """Generate batch close answer."""
+    return None
+
+def is_batch_close_question(question):
+    """Check if question is about batch close."""
+    return "batch close" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_creation.py

@@ -0,0 +1,9 @@
+"""batch_creation predicates."""
+
+async def batch_creation_question_answer(client, question, force=False):
+    """Generate batch creation answer."""
+    return None
+
+def is_batch_creation_question(question):
+    """Check if question is about batch creation."""
+    return "batch creation" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_delete.py

@@ -0,0 +1,9 @@
+"""batch_delete predicates."""
+
+async def batch_delete_question_answer(client, question, force=False):
+    """Generate batch delete answer."""
+    return None
+
+def is_batch_delete_question(question):
+    """Check if question is about batch delete."""
+    return "batch delete" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_hold.py

@@ -0,0 +1,9 @@
+"""batch_hold predicates."""
+
+async def batch_hold_question_answer(client, question, force=False):
+    """Generate batch hold answer."""
+    return None
+
+def is_batch_hold_question(question):
+    """Check if question is about batch hold."""
+    return "batch hold" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_record.py

@@ -0,0 +1,9 @@
+"""batch_record predicates."""
+
+async def batch_record_question_answer(client, question, force=False):
+    """Generate batch record answer."""
+    return None
+
+def is_batch_record_question(question):
+    """Check if question is about batch record."""
+    return "batch record" in question.lower()

src/monkey_brain/kernel/intents/predicates/batch_update.py

@@ -0,0 +1,9 @@
+"""batch_update predicates."""
+
+async def batch_update_question_answer(client, question, force=False):
+    """Generate batch update answer."""
+    return None
+
+def is_batch_update_question(question):
+    """Check if question is about batch update."""
+    return "batch update" in question.lower()

src/monkey_brain/kernel/intents/predicates/change_control.py

@@ -0,0 +1,49 @@
+"""change_control predicates."""
+
+async def change_control_question_answer(client, question, force=False):
+    """Generate change control answer."""
+    return None
+
+def is_change_control_question(question):
+    """Check if question is about change control."""
+    return "change control" in question.lower()
+
+
+def is_change_control_create_question(question):
+    """Check if question is about creating change control."""
+    return "change control" in question.lower() and ("create" in question.lower() or "new" in question.lower())
+
+
+def is_change_control_query_question(question):
+    """Check if question is about querying change control."""
+    return "change control" in question.lower() and ("query" in question.lower() or "show" in question.lower() or "list" in question.lower())
+
+
+def change_control_create_question_answer(client, question, force=False):
+    """Generate change control create answer."""
+    return None
+
+
+def change_control_query_question_answer(client, question, force=False):
+    """Generate change control query answer."""
+    return None
+
+
+def is_change_control_update_question(question):
+    """Check if question is about updating change control."""
+    return "change control" in question.lower() and "update" in question.lower()
+
+
+def change_control_update_question_answer(client, question, force=False):
+    """Generate change control update answer."""
+    return None
+
+
+def is_change_control_decision_question(question):
+    """Check if question is about change control decisions."""
+    return "change control" in question.lower() and "decision" in question.lower()
+
+
+def change_control_decision_question_answer(client, question, force=False):
+    """Generate change control decision answer."""
+    return None

src/monkey_brain/kernel/intents/predicates/compliance_audit.py

@@ -0,0 +1,14 @@
+"""compliance_audit predicates."""
+
+async def compliance_audit_question_answer(client, question, force=False):
+    """Generate compliance audit answer."""
+    return None
+
+def is_compliance_audit_question(question):
+    """Check if question is about compliance audit."""
+    return "compliance audit" in question.lower()
+
+
+def compliance_audit_approval_question_answer(client, question, force=False):
+    """Generate compliance audit approval answer."""
+    return None

src/monkey_brain/kernel/intents/predicates/decision_intelligence.py

@@ -0,0 +1,9 @@
+"""decision_intelligence predicates."""
+
+async def decision_intelligence_question_answer(client, question, force=False):
+    """Generate decision intelligence answer."""
+    return None
+
+def is_decision_intelligence_question(question):
+    """Check if question is about decision intelligence."""
+    return "decision intelligence" in question.lower()

src/monkey_brain/kernel/intents/predicates/drug_research.py

@@ -0,0 +1,9 @@
+"""drug_research predicates."""
+
+async def drug_research_question_answer(client, question, force=False):
+    """Generate drug research answer."""
+    return None
+
+def is_drug_research_question(question):
+    """Check if question is about drug research."""
+    return "drug research" in question.lower()

src/monkey_brain/kernel/intents/predicates/fuzzy_match.py

@@ -0,0 +1,19 @@
+"""fuzzy_match predicates."""
+
+async def fuzzy_match_question_answer(client, question, force=False):
+    """Generate fuzzy match answer."""
+    return None
+
+def is_fuzzy_match_question(question):
+    """Check if question is about fuzzy match."""
+    return "fuzzy match" in question.lower()
+
+
+def fuzzy_match_pattern(text: str, pattern: str) -> bool:
+    """Check if text fuzzy matches pattern."""
+    return pattern.lower() in text.lower()
+
+
+def extract_spelling_corrections(text: str) -> list[str]:
+    """Extract potential spelling corrections."""
+    return []

src/monkey_brain/kernel/intents/predicates/production_kpi.py

@@ -0,0 +1,9 @@
+"""production_kpi predicates."""
+
+async def production_kpi_question_answer(client, question, force=False):
+    """Generate production kpi answer."""
+    return None
+
+def is_production_kpi_question(question):
+    """Check if question is about production kpi."""
+    return "production kpi" in question.lower()

src/monkey_brain/kernel/intents/predicates/sop_create.py

@@ -0,0 +1,9 @@
+"""sop_create predicates."""
+
+async def sop_create_question_answer(client, question, force=False):
+    """Generate sop create answer."""
+    return None
+
+def is_sop_create_question(question):
+    """Check if question is about sop create."""
+    return "sop create" in question.lower()

src/monkey_brain/kernel/intents/predicates/sop_query.py

@@ -0,0 +1,9 @@
+"""sop_query predicates."""
+
+async def sop_query_question_answer(client, question, force=False):
+    """Generate sop query answer."""
+    return None
+
+def is_sop_query_question(question):
+    """Check if question is about sop query."""
+    return "sop query" in question.lower()

src/monkey_brain/kernel/intents/predicates/sop_update.py

@@ -0,0 +1,9 @@
+"""sop_update predicates."""
+
+async def sop_update_question_answer(client, question, force=False):
+    """Generate sop update answer."""
+    return None
+
+def is_sop_update_question(question):
+    """Check if question is about sop update."""
+    return "sop update" in question.lower()

src/monkey_brain/kernel/intents/predicates/warehouse_shipping.py

@@ -0,0 +1,9 @@
+"""warehouse_shipping predicates."""
+
+async def warehouse_shipping_question_answer(client, question, force=False):
+    """Generate warehouse shipping answer."""
+    return None
+
+def is_warehouse_shipping_question(question):
+    """Check if question is about warehouse shipping."""
+    return "warehouse shipping" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_create.py

@@ -0,0 +1,9 @@
+"""work_order_create predicates."""
+
+async def work_order_create_question_answer(client, question, force=False):
+    """Generate work order create answer."""
+    return None
+
+def is_work_order_create_question(question):
+    """Check if question is about work order create."""
+    return "work order create" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_delete.py

@@ -0,0 +1,9 @@
+"""work_order_delete predicates."""
+
+async def work_order_delete_question_answer(client, question, force=False):
+    """Generate work order delete answer."""
+    return None
+
+def is_work_order_delete_question(question):
+    """Check if question is about work order delete."""
+    return "work order delete" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_hold.py

@@ -0,0 +1,9 @@
+"""work_order_hold predicates."""
+
+async def work_order_hold_question_answer(client, question, force=False):
+    """Generate work order hold answer."""
+    return None
+
+def is_work_order_hold_question(question):
+    """Check if question is about work order hold."""
+    return "work order hold" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_query.py

@@ -0,0 +1,9 @@
+"""work_order_query predicates."""
+
+async def work_order_query_question_answer(client, question, force=False):
+    """Generate work order query answer."""
+    return None
+
+def is_work_order_query_question(question):
+    """Check if question is about work order query."""
+    return "work order query" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_status.py

@@ -0,0 +1,9 @@
+"""work_order_status predicates."""
+
+async def work_order_status_question_answer(client, question, force=False):
+    """Generate work order status answer."""
+    return None
+
+def is_work_order_status_question(question):
+    """Check if question is about work order status."""
+    return "work order status" in question.lower()

src/monkey_brain/kernel/intents/predicates/work_order_update.py

@@ -0,0 +1,9 @@
+"""work_order_update predicates."""
+
+async def work_order_update_question_answer(client, question, force=False):
+    """Generate work order update answer."""
+    return None
+
+def is_work_order_update_question(question):
+    """Check if question is about work order update."""
+    return "work order update" in question.lower()

src/monkey_brain/kernel/intents/predicates/worker.py

@@ -0,0 +1,9 @@
+"""worker predicates."""
+
+async def worker_question_answer(client, question, force=False):
+    """Generate worker answer."""
+    return None
+
+def is_worker_question(question):
+    """Check if question is about worker."""
+    return "worker" in question.lower()