monkeybrain-runtime 1.0.0__py3-none-any.whl

services/workorders/routers/work_orders.py

@@ -0,0 +1,257 @@
+from fastapi import APIRouter, HTTPException, Depends, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.db import get_database
+from services.common.auth import require_permission
+from services.workorders.models.work_orders import (
+    WorkOrderCreate,
+    WorkOrderSubtaskCreate,
+    WorkOrderSubtaskUpdate,
+    WorkOrderUpdate,
+    WorkOrderResponse,
+    PaginatedWorkOrderResponse,
+    WorkOrderCountStatsResponse,
+)
+from services.workorders.helpers import work_orders as crud
+
+router = APIRouter()
+
+SUBTASK_CREATOR_ROLES = {
+    "admin",
+    "worker",
+    "project-manager",
+    "project_manager",
+    "project manager",
+}
+
+
+def _ensure_subtask_creator(current_user: dict) -> None:
+    role = str(current_user.get("role", "")).lower()
+    if role not in SUBTASK_CREATOR_ROLES:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only workers and project managers can create linked work orders under a work order",
+        )
+
+
+# ── List ──────────────────────────────────────────────────────────────────────
+
+@router.get("/", response_model=PaginatedWorkOrderResponse)
+async def list_work_orders(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    work_orders, total = await crud.get_all(db, page=page, page_size=page_size)
+    return PaginatedWorkOrderResponse(total=total, page=page, page_size=page_size, results=work_orders)
+
+
+# ── Filters ───────────────────────────────────────────────────────────────────
+
+@router.get("/by-status/{status}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_status(
+    status: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_status(db, status)
+
+
+@router.get("/by-priority/{priority}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_priority(
+    priority: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_priority(db, priority)
+
+
+@router.get("/by-machine/{machine_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_machine(
+    machine_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_machine(db, machine_id)
+
+@router.get("/by-equipment/{equipment_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_equipment(
+    equipment_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_equipment_id(db, equipment_id)
+
+@router.get("/by-line/{line_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_line(
+    line_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_line(db, line_id)
+
+
+@router.get("/by-circuit/{circuit_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_circuit(
+    circuit_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_circuit(db, circuit_id)
+
+
+@router.get("/by-team/{team_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_team(
+    team_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_team(db, team_id)
+
+
+@router.get("/overdue", response_model=list[WorkOrderResponse])
+async def list_overdue_work_orders(
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_overdue(db)
+
+@router.get("/by-user/{user_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_user(
+    user_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_by_user(db, user_id)
+
+
+@router.get("/by-parent/{parent_work_order_id}", response_model=list[WorkOrderResponse])
+async def list_work_orders_by_parent(
+    parent_work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_subtasks(db, parent_work_order_id)
+
+
+@router.get("/stats/counts", response_model=WorkOrderCountStatsResponse)
+async def get_work_order_count_stats(
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    return await crud.get_count_stats(db)
+
+# ── Get one ───────────────────────────────────────────────────────────────────
+
+@router.get("/{work_order_id}", response_model=WorkOrderResponse)
+async def get_work_order(
+    work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    record = await crud.get_by_id(db, work_order_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Work order '{work_order_id}' not found")
+    return record
+
+
+# ── Create ────────────────────────────────────────────────────────────────────
+
+@router.post("/", response_model=WorkOrderResponse, status_code=status.HTTP_201_CREATED)
+async def create_work_order(
+    data: WorkOrderCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-create-tasks")),
+):
+    if await crud.get_by_id(db, data.work_order_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Work order '{data.work_order_id}' already exists")
+    return await crud.create(db, data)
+
+
+# ── Update ────────────────────────────────────────────────────────────────────
+
+@router.patch("/{work_order_id}", response_model=WorkOrderResponse)
+async def update_work_order(
+    work_order_id: str,
+    data: WorkOrderUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-tasks")),
+):
+    updated = await crud.update(db, work_order_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Work order '{work_order_id}' not found")
+    return updated
+
+
+@router.get("/{work_order_id}/subtasks", response_model=list[WorkOrderResponse])
+async def list_work_order_subtasks(
+    work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    if not await crud.get_by_id(db, work_order_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Work order '{work_order_id}' not found")
+    return await crud.get_subtasks(db, work_order_id)
+
+
+@router.post("/{work_order_id}/subtasks", response_model=WorkOrderResponse, status_code=status.HTTP_201_CREATED)
+async def create_work_order_subtask(
+    work_order_id: str,
+    data: WorkOrderSubtaskCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    current_user: dict = Depends(require_permission("perm-update-tasks")),
+):
+    _ensure_subtask_creator(current_user)
+    if await crud.get_by_id(db, data.work_order_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Work order '{data.work_order_id}' already exists")
+    if data.created_by is None:
+        data.created_by = current_user.get("sub")
+    created = await crud.add_subtask(db, work_order_id, data)
+    if not created:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Work order '{work_order_id}' not found")
+    return created
+
+
+@router.patch("/{work_order_id}/subtasks/{subtask_work_order_id}", response_model=WorkOrderResponse)
+async def update_work_order_subtask(
+    work_order_id: str,
+    subtask_work_order_id: str,
+    data: WorkOrderSubtaskUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-tasks")),
+):
+    updated = await crud.update_subtask(db, work_order_id, subtask_work_order_id, data)
+    if not updated:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            detail=f"Linked work order '{subtask_work_order_id}' not found under work order '{work_order_id}'",
+        )
+    return updated
+
+
+@router.delete("/{work_order_id}/subtasks/{subtask_work_order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_work_order_subtask(
+    work_order_id: str,
+    subtask_work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-tasks")),
+):
+    if not await crud.remove_subtask(db, work_order_id, subtask_work_order_id):
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND,
+            detail=f"Linked work order '{subtask_work_order_id}' not found under work order '{work_order_id}'",
+        )
+
+
+# ── Delete ────────────────────────────────────────────────────────────────────
+
+@router.delete("/{work_order_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_work_order(
+    work_order_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-tasks")),
+):
+    if not await crud.delete(db, work_order_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Work order '{work_order_id}' not found")
+    

services/workorders/routers/yield_reconciliation_records.py

@@ -0,0 +1,86 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from services.common.auth import require_permission
+from services.common.db import get_database
+from services.workorders.helpers import yield_reconciliation_records as crud
+from services.workorders.models.yield_reconciliation_records import (
+    PaginatedYieldReconciliationRecordResponse,
+    YieldReconciliationRecordCreate,
+    YieldReconciliationRecordResponse,
+    YieldReconciliationRecordUpdate,
+)
+
+
+router = APIRouter()
+
+
+@router.get("/", response_model=PaginatedYieldReconciliationRecordResponse)
+async def list_yield_reconciliation_records(
+    page: int = Query(1, ge=1),
+    page_size: int = Query(20, ge=1, le=100),
+    batch_execution_record_id: str | None = Query(None),
+    batch_id: str | None = Query(None),
+    status_filter: str | None = Query(None, alias="status"),
+    disposition: str | None = Query(None),
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    records, total = await crud.get_all(
+        db,
+        page=page,
+        page_size=page_size,
+        batch_execution_record_id=batch_execution_record_id,
+        batch_id=batch_id,
+        status=status_filter,
+        disposition=disposition,
+    )
+    return PaginatedYieldReconciliationRecordResponse(total=total, page=page, page_size=page_size, results=records)
+
+
+@router.get("/{yield_reconciliation_id}", response_model=YieldReconciliationRecordResponse)
+async def get_yield_reconciliation_record(
+    yield_reconciliation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-view-tasks")),
+):
+    record = await crud.get_by_id(db, yield_reconciliation_id)
+    if not record:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Yield reconciliation record '{yield_reconciliation_id}' not found")
+    return record
+
+
+@router.post("/", response_model=YieldReconciliationRecordResponse, status_code=status.HTTP_201_CREATED)
+async def create_yield_reconciliation_record(
+    data: YieldReconciliationRecordCreate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    current_user: dict = Depends(require_permission("perm-create-tasks")),
+):
+    if await crud.get_by_id(db, data.yield_reconciliation_id):
+        raise HTTPException(status.HTTP_409_CONFLICT, detail=f"Yield reconciliation record '{data.yield_reconciliation_id}' already exists")
+    if data.created_by is None:
+        data.created_by = current_user.get("sub")
+    return await crud.create(db, data)
+
+
+@router.patch("/{yield_reconciliation_id}", response_model=YieldReconciliationRecordResponse)
+async def update_yield_reconciliation_record(
+    yield_reconciliation_id: str,
+    data: YieldReconciliationRecordUpdate,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-update-tasks")),
+):
+    updated = await crud.update(db, yield_reconciliation_id, data)
+    if not updated:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Yield reconciliation record '{yield_reconciliation_id}' not found")
+    return updated
+
+
+@router.delete("/{yield_reconciliation_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_yield_reconciliation_record(
+    yield_reconciliation_id: str,
+    db: AsyncIOMotorDatabase = Depends(get_database),
+    _: dict = Depends(require_permission("perm-delete-tasks")),
+):
+    if not await crud.delete(db, yield_reconciliation_id):
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"Yield reconciliation record '{yield_reconciliation_id}' not found")

src/broca/__init__.py

@@ -0,0 +1,5 @@
+"""Agent — autonomous query handler with automatic routing."""
+
+from src.broca.agent import Agent, AgentResponse
+
+__all__ = ["Agent", "AgentResponse"]

src/broca/agent.py

@@ -0,0 +1,201 @@
+"""Agent — autonomous query handler with capability discovery.
+
+The Agent:
+1. Discovers available capabilities
+2. Routes to the appropriate capability pipeline
+3. Executes the pipeline
+4. Returns the answer
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.monkey_brain.kernel.pipeline import Pipeline, PipelineStep
+from src.monkey_brain.kernel.execution_state import ExecutionState
+from src.monkey_brain.kernel.rl.policy import BellmanPolicy
+from src.monkey_brain.kernel.observer import Observer
+from src.monkey_brain.kernel.learning import Learning
+from src.monkey_brain.kernel.rl.transition import Transition
+from src.monkey_brain.kernel.intents.intent_router import route_question
+from src.monkey_brain.runtime.runtime import Runtime
+from src.introspection.lemon import Lemon
+from src.cerebellum.fallback_engine import FallbackEngine
+
+
+@dataclass
+class AgentResponse:
+    """Response from the Agent."""
+    
+    question: str = ""
+    answer: str = ""
+    intent: str = ""
+    intent_confidence: float = 0.0
+    supported: bool = False
+    pipeline_id: str = ""
+    capabilities_used: list[str] = field(default_factory=list)
+    latency_ms: float = 0.0
+    success: bool = False
+    fallback_used: bool = False
+    fallback_details: dict[str, Any] = field(default_factory=dict)
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+
+class Agent:
+    """Autonomous query handler with capability discovery.
+    
+    Responsibilities:
+    - Discover available capabilities
+    - Classify intent
+    - Route to capabilities
+    - Execute pipeline
+    - Return answer
+    """
+    
+    def __init__(
+        self,
+        runtime: Runtime,
+        policy: BellmanPolicy | None = None,
+        observer: Observer | None = None,
+        learning: Learning | None = None,
+        lemon: Lemon | None = None,
+    ):
+        self._runtime = runtime
+        self._policy = policy or BellmanPolicy()
+        self._observer = observer or Observer()
+        self._learning = learning or Learning()
+        self._lemon = lemon
+        self._fallback_engine = FallbackEngine(runtime)
+        self._llm_calls = 0
+        self._total_tokens = 0
+    
+    def discover_capabilities(self) -> list[str]:
+        """Discover available capabilities in the runtime."""
+        return list(self._runtime._capabilities.keys())
+    
+    def discover_workflows(self) -> dict[str, list[str]]:
+        """Discover workflow steps for each capability."""
+        workflows = {}
+        for cap_name in self._runtime._capabilities.keys():
+            workflows[cap_name] = [cap_name]
+        return workflows
+    
+    async def handle(self, question: str) -> AgentResponse:
+        """Handle a question end-to-end."""
+        start = time.monotonic()
+        
+        response = AgentResponse(question=question)
+        
+        if self._lemon:
+            self._lemon.start_trace(f"agent:{question[:50]}")
+        
+        try:
+            # 1. Discover capabilities
+            capabilities = self.discover_capabilities()
+            response.metrics['available_capabilities'] = capabilities
+            
+            # 2. Route question using classifier
+            routing = route_question(question)
+            response.intent = routing.get("intent", "unknown")
+            response.intent_confidence = routing.get("confidence", 0)
+            response.supported = routing.get("supported", False)
+            
+            # 3. Create pipeline
+            pipeline = Pipeline(
+                steps=[
+                    PipelineStep(capability_name="resolve_entity"),
+                    PipelineStep(capability_name="retrieve"),
+                    PipelineStep(capability_name="format"),
+                ]
+            )
+            
+            # 4. Policy selects pipeline
+            if self._policy:
+                self._policy.select([pipeline], ExecutionState(question=question))
+            
+            # 5. Execute pipeline
+            state = ExecutionState(question=question)
+            exec_result = await self._runtime.execute(pipeline, state)
+            
+            # 6. Build response
+            response.answer = exec_result.final_state.get("answer", "")
+            response.pipeline_id = pipeline.pipeline_id
+            response.capabilities_used = [s.capability_name for s in exec_result.steps]
+            response.success = exec_result.success
+            response.latency_ms = (time.monotonic() - start) * 1000
+            
+            # 7. Check if answer needs fallback
+            if response.answer == "No records found." or not response.answer:
+                fallback_result = await self._fallback_engine.execute_fallback(
+                    question=question,
+                    original_answer=response.answer,
+                    state=exec_result.final_state,
+                )
+                
+                if fallback_result.enhanced_answer != response.answer:
+                    response.answer = fallback_result.enhanced_answer
+                    response.fallback_used = True
+                    response.fallback_details = {
+                        "documents_found": fallback_result.documents_found,
+                        "web_results_found": fallback_result.web_results_found,
+                        "replanned": fallback_result.replaned,
+                    }
+                    
+                    if fallback_result.documents_found > 0:
+                        response.capabilities_used.append("document_search")
+                    if fallback_result.web_results_found > 0:
+                        response.capabilities_used.append("web_search")
+                    if fallback_result.replaned:
+                        response.capabilities_used.append("replan")
+            
+            # 8. Update policy
+            if self._policy:
+                self._policy.update(Transition(
+                    state=state.to_dict(),
+                    action=pipeline.pipeline_id,
+                    reward=0.95 if exec_result.success else 0.1,
+                    next_state=exec_result.final_state,
+                    done=True,
+                ))
+            
+            # 9. Observe
+            self._observer.observe(
+                capability="agent",
+                action="handle",
+                input_state=state.to_dict(),
+                output_state=exec_result.final_state,
+                reward=0.95 if exec_result.success else 0.1,
+                latency_ms=response.latency_ms,
+            )
+            
+            response.metrics.update({
+                "intent_confidence": response.intent_confidence,
+                "supported": response.supported,
+                "capabilities_count": len(response.capabilities_used),
+                "policy_q_entries": len(self._policy._q_table) if self._policy else 0,
+                "fallback_used": response.fallback_used,
+            })
+            
+        except Exception as e:
+            response.success = False
+            response.answer = f"Error: {e}"
+            response.latency_ms = (time.monotonic() - start) * 1000
+        
+        if self._lemon:
+            self._lemon.finish_trace()
+        
+        return response
+    
+    def summary(self) -> dict:
+        return {
+            "llm_calls": self._llm_calls,
+            "total_tokens": self._total_tokens,
+            "capabilities_discovered": len(self.discover_capabilities()),
+            "observer": self._observer.summary(),
+            "policy": self._policy.summary() if self._policy else None,
+            "learning": self._learning.summary(),
+            "fallback": self._fallback_engine.summary(),
+        }

src/cerebellum/adapter.py

@@ -0,0 +1,84 @@
+"""Adapter — transforms data between capability and peripheral.
+
+Adapters handle:
+- Data format conversion
+- Protocol translation
+- Schema mapping
+- Error transformation
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from src.cerebellum.peripheral import Peripheral
+
+
+@dataclass
+class AdapterSchema:
+    """Schema for adapter data transformation."""
+    
+    name: str = ""
+    fields: list[dict[str, Any]] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class Adapter:
+    """Transforms data between capability and peripheral.
+    
+    Responsibilities:
+    - Read from peripheral and transform
+    - Transform and write to peripheral
+    - Map data schemas
+    
+    The Adapter never:
+    - Makes execution decisions
+    - Manages connections
+    - Owns execution policy
+    """
+    
+    def __init__(
+        self,
+        name: str,
+        peripheral: Peripheral,
+        schema: AdapterSchema | None = None,
+    ):
+        self.name = name
+        self.peripheral = peripheral
+        self.schema = schema or AdapterSchema()
+        self._id = f"adapter-{uuid4().hex[:8]}"
+    
+    @property
+    def id(self) -> str:
+        return self._id
+    
+    async def read(self, query: dict[str, Any]) -> dict[str, Any]:
+        """Read from peripheral and transform.
+        
+        Override this method to implement read logic.
+        """
+        raise NotImplementedError(f"Adapter '{self.name}' must implement read()")
+    
+    async def write(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Transform and write to peripheral.
+        
+        Override this method to implement write logic.
+        """
+        raise NotImplementedError(f"Adapter '{self.name}' must implement write()")
+    
+    async def transform(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Transform data without I/O.
+        
+        Override this method to implement transformation logic.
+        """
+        return data
+    
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self._id,
+            "name": self.name,
+            "peripheral": self.peripheral.name,
+            "schema": self.schema.name,
+        }