base-pmad-ae 0.1.0__tar.gz

base_pmad_ae-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: base-pmad-ae
+Version: 0.1.0
+Summary: Base Action Engine for pMADs — health, metrics, and autoprompt infrastructure flows
+Requires-Python: >=3.12
+Requires-Dist: langgraph>=0.2.60
+Requires-Dist: langchain-core>=0.3.28
+Requires-Dist: prometheus-client>=0.21.1

base_pmad_ae-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "base-pmad-ae"
+version = "0.1.0"
+description = "Base Action Engine for pMADs — health, metrics, and autoprompt infrastructure flows"
+requires-python = ">=3.12"
+dependencies = [
+    "langgraph>=0.2.60",
+    "langchain-core>=0.3.28",
+    "prometheus-client>=0.21.1",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

base_pmad_ae-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

base_pmad_ae-0.1.0/src/base_pmad_ae/__init__.py

@@ -0,0 +1 @@
+"""Context Broker AE — infrastructure StateGraph package."""

base_pmad_ae-0.1.0/src/base_pmad_ae/autoprompt_dispatcher.py

@@ -0,0 +1,96 @@
+"""
+Autoprompter dispatcher — StateGraph flow for Dkron callbacks.
+
+When Dkron fires a job, it sends an HTTP POST to the langgraph container.
+This flow reads the referenced runbook file and POSTs its contents as a
+prompt to the Imperator's /v1/chat/completions endpoint.
+
+The dispatcher has zero intelligence — it only reads and delivers.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import httpx
+from langgraph.graph import END, StateGraph
+from typing_extensions import TypedDict
+
+_log = logging.getLogger("pmad_template.flows.autoprompt_dispatcher")
+
+RUNBOOK_DIR = Path("/config/runbooks")
+
+
+class DispatcherState(TypedDict):
+    """State for the autoprompter dispatcher flow."""
+
+    job_name: str
+    runbook_path: str
+    target_url: str
+    runbook_content: Optional[str]
+    delivery_status: Optional[str]
+    error: Optional[str]
+
+
+async def load_runbook(state: DispatcherState) -> dict:
+    """Read the runbook file from disk."""
+    runbook_path = state.get("runbook_path", "")
+    if not runbook_path:
+        return {"error": "No runbook_path specified"}
+
+    full_path = RUNBOOK_DIR / runbook_path
+    try:
+        content = full_path.read_text(encoding="utf-8").strip()
+        if not content:
+            return {"error": f"Runbook is empty: {runbook_path}"}
+        _log.info("Loaded runbook: %s (%d chars)", runbook_path, len(content))
+        return {"runbook_content": content}
+    except (FileNotFoundError, OSError) as exc:
+        _log.error("Failed to load runbook %s: %s", runbook_path, exc)
+        return {"error": f"Failed to load runbook: {exc}"}
+
+
+async def deliver_prompt(state: DispatcherState) -> dict:
+    """POST the runbook content to the Imperator's chat endpoint."""
+    if state.get("error"):
+        return {}
+
+    content = state.get("runbook_content", "")
+    target_url = state.get("target_url", "http://pmad-template-langgraph:8000/v1/chat/completions")
+
+    payload = {
+        "model": "pmad-template",
+        "messages": [
+            {"role": "user", "content": content},
+        ],
+        "stream": False,
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            response = await client.post(target_url, json=payload)
+            response.raise_for_status()
+        _log.info(
+            "Autoprompter delivered job '%s' to %s",
+            state.get("job_name", "unknown"),
+            target_url,
+        )
+        return {"delivery_status": "delivered"}
+    except (httpx.HTTPError, OSError) as exc:
+        _log.error(
+            "Autoprompter delivery failed for job '%s': %s",
+            state.get("job_name", "unknown"),
+            exc,
+        )
+        return {"delivery_status": "failed", "error": str(exc)}
+
+
+def build_autoprompt_dispatcher_flow() -> StateGraph:
+    """Build and compile the autoprompter dispatcher StateGraph."""
+    workflow = StateGraph(DispatcherState)
+    workflow.add_node("load_runbook", load_runbook)
+    workflow.add_node("deliver_prompt", deliver_prompt)
+    workflow.set_entry_point("load_runbook")
+    workflow.add_edge("load_runbook", "deliver_prompt")
+    workflow.add_edge("deliver_prompt", END)
+    return workflow.compile()

base_pmad_ae-0.1.0/src/base_pmad_ae/health_flow.py

@@ -0,0 +1,71 @@
+"""
+Health Check — LangGraph StateGraph flow.
+
+Checks connectivity to backing services (PostgreSQL)
+and returns aggregated health status. Invoked by the /health route.
+"""
+
+import logging
+from typing import Optional
+
+from langgraph.graph import END, StateGraph
+from typing_extensions import TypedDict
+
+_log = logging.getLogger("pmad_template.flows.health")
+
+
+class HealthCheckState(TypedDict):
+    """State for the health check flow."""
+
+    config: dict
+
+    postgres_ok: bool
+    all_healthy: bool
+    status_detail: Optional[dict]
+    http_status: int
+
+
+async def check_dependencies(state: HealthCheckState) -> dict:
+    """Check connectivity to all backing services."""
+    from app.database import get_pg_pool
+
+    postgres_ok = False
+    try:
+        pool = get_pg_pool()
+        await pool.fetchval("SELECT 1")
+        postgres_ok = True
+    except (RuntimeError, OSError, Exception) as exc:
+        _log.warning("PostgreSQL health check failed: %s", exc)
+
+    all_healthy = postgres_ok
+
+    if not all_healthy:
+        status_label = "unhealthy"
+        http_status = 503
+    else:
+        status_label = "healthy"
+        http_status = 200
+
+    status_detail = {
+        "status": status_label,
+        "database": "ok" if postgres_ok else "error",
+    }
+
+    if not all_healthy:
+        _log.warning("Health check: unhealthy — %s", status_detail)
+
+    return {
+        "postgres_ok": postgres_ok,
+        "all_healthy": all_healthy,
+        "status_detail": status_detail,
+        "http_status": http_status,
+    }
+
+
+def build_health_check_flow() -> StateGraph:
+    """Build and compile the health check StateGraph."""
+    workflow = StateGraph(HealthCheckState)
+    workflow.add_node("check_dependencies", check_dependencies)
+    workflow.set_entry_point("check_dependencies")
+    workflow.add_edge("check_dependencies", END)
+    return workflow.compile()

base_pmad_ae-0.1.0/src/base_pmad_ae/metrics_flow.py

@@ -0,0 +1,46 @@
+"""
+Metrics collection StateGraph flow.
+
+Collects Prometheus metrics inside a StateGraph node,
+as required by REQ §4.8.
+"""
+
+import logging
+from typing import Optional
+
+from langgraph.graph import END, StateGraph
+from prometheus_client import generate_latest, REGISTRY
+from typing_extensions import TypedDict
+
+_log = logging.getLogger("pmad_template.flows.metrics")
+
+
+class MetricsState(TypedDict):
+    """State for the metrics collection flow."""
+
+    action: str
+    metrics_output: str
+    error: Optional[str]
+
+
+async def collect_metrics_node(state: MetricsState) -> dict:
+    """Collect Prometheus metrics from the registry.
+
+    Produces metrics output inside the StateGraph as required by REQ §4.8.
+    """
+    try:
+        metrics_bytes = generate_latest(REGISTRY)
+        metrics_text = metrics_bytes.decode("utf-8", errors="replace")
+        return {"metrics_output": metrics_text, "error": None}
+    except (ValueError, OSError) as exc:
+        _log.error("Failed to collect metrics: %s", exc)
+        return {"metrics_output": "", "error": str(exc)}
+
+
+def build_metrics_flow() -> StateGraph:
+    """Build and compile the metrics collection StateGraph."""
+    workflow = StateGraph(MetricsState)
+    workflow.add_node("collect_metrics", collect_metrics_node)
+    workflow.set_entry_point("collect_metrics")
+    workflow.add_edge("collect_metrics", END)
+    return workflow.compile()

base_pmad_ae-0.1.0/src/base_pmad_ae/register.py

@@ -0,0 +1,30 @@
+"""
+AE — Package registration entry point.
+
+Called by the bootstrap kernel's stategraph_registry.scan() when this
+package is discovered via entry_points(group="pmad_template.ae").
+
+Returns an AERegistration dict with build type registrations and
+flow builders that the kernel processes to populate its registries.
+"""
+
+
+def register() -> dict:
+    """Register the AE's infrastructure StateGraphs.
+
+    Returns a dict with:
+    - build_types: dict of (assembly_builder, retrieval_builder) pairs
+    - flows: dict of flow_name -> builder callable
+    """
+    from base_pmad_ae.health_flow import build_health_check_flow
+    from base_pmad_ae.metrics_flow import build_metrics_flow
+    from base_pmad_ae.autoprompt_dispatcher import build_autoprompt_dispatcher_flow
+
+    return {
+        "build_types": {},
+        "flows": {
+            "health_check": build_health_check_flow,
+            "metrics": build_metrics_flow,
+            "autoprompt_dispatcher": build_autoprompt_dispatcher_flow,
+        },
+    }

base_pmad_ae-0.1.0/src/base_pmad_ae.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: base-pmad-ae
+Version: 0.1.0
+Summary: Base Action Engine for pMADs — health, metrics, and autoprompt infrastructure flows
+Requires-Python: >=3.12
+Requires-Dist: langgraph>=0.2.60
+Requires-Dist: langchain-core>=0.3.28
+Requires-Dist: prometheus-client>=0.21.1

base_pmad_ae-0.1.0/src/base_pmad_ae.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+src/base_pmad_ae/__init__.py
+src/base_pmad_ae/autoprompt_dispatcher.py
+src/base_pmad_ae/health_flow.py
+src/base_pmad_ae/metrics_flow.py
+src/base_pmad_ae/register.py
+src/base_pmad_ae.egg-info/PKG-INFO
+src/base_pmad_ae.egg-info/SOURCES.txt
+src/base_pmad_ae.egg-info/dependency_links.txt
+src/base_pmad_ae.egg-info/requires.txt
+src/base_pmad_ae.egg-info/top_level.txt

base_pmad_ae-0.1.0/src/base_pmad_ae.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

base_pmad_ae-0.1.0/src/base_pmad_ae.egg-info/requires.txt

@@ -0,0 +1,3 @@
+langgraph>=0.2.60
+langchain-core>=0.3.28
+prometheus-client>=0.21.1

base_pmad_ae-0.1.0/src/base_pmad_ae.egg-info/top_level.txt

@@ -0,0 +1 @@
+base_pmad_ae