Merge pull request #7 from itenev/feat/incident-history-queries

feat: implement incident history queries and context assembly

Author: itenev

docs/hermes-implementation-plan.md

@@ -134,12 +134,13 @@
 **Files:**
 - Modify: `src/agentic_node_ops/database.py`
 - Create: `src/agentic_node_ops/context.py`
+- Create: `tests/test_context.py`
 
-**Steps:**
-1. Implement `get_recent_incidents()`, `get_corrections()`, runbook stats queries
-2. Implement `build_hermes_context()` from design doc §6
-3. Write tests
-4. Verify context assembly produces correct prompt text
+[x] Complete — Implemented context assembly and history queries:
+  - `database.py`: Added `get_runbook_stats()` and `get_host_baselines()` methods.
+  - `context.py`: Implemented `build_hermes_context()` combining current state, recent incidents, operator corrections, runbook performance, and host baselines into a single structured prompt.
+  - `test_context.py`: 6 tests covering DB queries and context builder formatting.
+  - All tests passing.
 
 ---
 

src/agentic_node_ops/context.py

@@ -0,0 +1,83 @@
+"""Context assembly for Hermes prompts."""
+
+import json
+
+from .database import Database
+from .types import NotificationPayload
+
+
+def build_hermes_context(payload: NotificationPayload, db: Database) -> str:
+    """
+    Assemble the context prompt for Hermes analysis.
+
+    Combines current state, recent incident history, operator corrections,
+    runbook performance, and host baselines into a single structured prompt.
+    """
+    # Recent incidents
+    recent_incidents = db.get_recent_incidents(
+        alert_type=payload.alert_type, host=payload.host, limit=5
+    )
+    if recent_incidents:
+        incidents_text = "\n".join(
+            f"- {inc['fired_at']}: {inc['outcome'] or 'unresolved'} "
+            f"(severity: {inc['severity']}, analysis: {(inc.get('hermes_analysis') or 'N/A')[:100]}{'...' if len(inc.get('hermes_analysis') or '') > 100 else ''})"
+            for inc in recent_incidents
+        )
+    else:
+        incidents_text = (
+            "- No prior incidents recorded for this alert type on this host."
+        )
+
+    # Operator corrections
+    corrections = db.get_corrections(alert_type=payload.alert_type, host=payload.host)
+    if corrections:
+        corrections_text = "\n".join(f"- {c}" for c in corrections)
+    else:
+        corrections_text = "- No operator corrections recorded."
+
+    # Runbook stats
+    runbook_id = payload.runbook_id or "unknown"
+    stats = db.get_runbook_stats(runbook_id)
+    success_rate_pct = stats["success_rate"] * 100
+    failed_cases_text = "\n".join(f"- {case}" for case in stats["failed_cases"])
+
+    # Host baselines
+    baselines = db.get_host_baselines(host=payload.host)
+    if baselines:
+        baselines_text = "\n".join(
+            f"- {metric}: p50={data['p50']}, p95={data['p95']}"
+            for metric, data in baselines.items()
+        )
+    else:
+        baselines_text = "- No baselines recorded for this host."
+
+    # Diagnostics snapshot
+    diagnostics_text = (
+        json.dumps(payload.diagnostics, indent=2)
+        if payload.diagnostics
+        else "No diagnostics available."
+    )
+
+    prompt = f"""You are analyzing a {payload.alert_type} alert on {payload.host}.
+
+CURRENT STATE:
+{diagnostics_text}
+
+RECENT INCIDENT HISTORY (last 5 similar incidents on this host):
+{incidents_text}
+
+OPERATOR CORRECTIONS FOR THIS ALERT TYPE ON THIS HOST:
+{corrections_text}
+
+RUNBOOK PERFORMANCE:
+Runbook '{runbook_id}' has resolved this alert type {success_rate_pct:.0f}% of the time.
+Known failure cases:
+{failed_cases_text}
+
+HOST BASELINES:
+{baselines_text}
+
+Your job: explain what is likely happening, why, and what the operator should do.
+Be specific. If this matches a pattern from history, say so explicitly.
+"""
+    return prompt

src/agentic_node_ops/database.py

@@ -233,3 +233,58 @@ def get_last_processed(self, alert_type: str, host: str) -> Optional[dict]:
             )
             row = cursor.fetchone()
             return dict(row) if row else None
+
+    def get_runbook_stats(self, runbook_id: str) -> dict:
+        """Get success rate and known failure cases for a runbook."""
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                """
+                SELECT 
+                    COUNT(*) as total,
+                    SUM(CASE WHEN outcome = 'resolved' THEN 1 ELSE 0 END) as resolved
+                FROM runbook_outcomes
+                WHERE runbook_id = ?
+                """,
+                (runbook_id,),
+            )
+            row = cursor.fetchone()
+            total = row["total"] or 0
+            resolved = row["resolved"] or 0
+            success_rate = resolved / total if total > 0 else 0.0
+
+            cursor = conn.execute(
+                """
+                SELECT action_taken, outcome
+                FROM runbook_outcomes
+                WHERE runbook_id = ? AND outcome != 'resolved'
+                LIMIT 3
+                """,
+                (runbook_id,),
+            )
+            failed_cases = [
+                f"{row['action_taken']} ({row['outcome']})" for row in cursor.fetchall()
+            ]
+
+            return {
+                "success_rate": success_rate,
+                "failed_cases": failed_cases if failed_cases else ["None recorded"],
+            }
+
+    def get_host_baselines(self, host: str) -> dict[str, dict]:
+        """Get all baseline p50/p95 metrics for a specific host."""
+        with self._get_connection() as conn:
+            cursor = conn.execute(
+                """
+                SELECT metric, baseline_p50, baseline_p95
+                FROM host_fingerprints
+                WHERE host = ?
+                """,
+                (host,),
+            )
+            return {
+                row["metric"]: {
+                    "p50": row["baseline_p50"],
+                    "p95": row["baseline_p95"],
+                }
+                for row in cursor.fetchall()
+            }

tests/test_context.py

@@ -0,0 +1,146 @@
+"""Tests for context assembly and database history queries."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from agentic_node_ops.context import build_hermes_context
+from agentic_node_ops.database import Database
+from agentic_node_ops.types import NotificationPayload, Severity
+
+
+@pytest.fixture
+def temp_db():
+    """Provide a temporary SQLite database for testing."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test_incidents.db"
+        db = Database(db_path=str(db_path))
+        yield db
+
+
+def test_get_runbook_stats_empty(temp_db: Database):
+    """Test get_runbook_stats returns 0.0 success rate when no data exists."""
+    stats = temp_db.get_runbook_stats("test_runbook")
+    assert stats["success_rate"] == 0.0
+    assert stats["failed_cases"] == ["None recorded"]
+
+
+def test_get_runbook_stats_with_data(temp_db: Database):
+    """Test get_runbook_stats calculates success rate correctly."""
+    with temp_db._get_connection() as conn:
+        conn.execute(
+            """
+            INSERT INTO runbook_outcomes (id, runbook_id, host, action_taken, outcome, time_to_resolve)
+            VALUES ('1', 'rb1', 'host1', 'restart', 'resolved', 60),
+                   ('2', 'rb1', 'host1', 'restart', 'did_not_help', 30),
+                   ('3', 'rb1', 'host2', 'wipe', 'resolved', 120)
+            """
+        )
+        conn.commit()
+
+    stats = temp_db.get_runbook_stats("rb1")
+    assert stats["success_rate"] == pytest.approx(2 / 3)
+    assert len(stats["failed_cases"]) == 1
+    assert "restart (did_not_help)" in stats["failed_cases"][0]
+
+
+def test_get_host_baselines_empty(temp_db: Database):
+    """Test get_host_baselines returns empty dict when no data exists."""
+    baselines = temp_db.get_host_baselines("host1")
+    assert baselines == {}
+
+
+def test_get_host_baselines_with_data(temp_db: Database):
+    """Test get_host_baselines returns correct metrics."""
+    with temp_db._get_connection() as conn:
+        conn.execute(
+            """
+            INSERT INTO host_fingerprints (host, metric, baseline_p50, baseline_p95, last_updated)
+            VALUES ('host1', 'peer_count', 45.0, 60.0, '2024-01-01'),
+                   ('host1', 'validator_count', 10.0, 12.0, '2024-01-01')
+            """
+        )
+        conn.commit()
+
+    baselines = temp_db.get_host_baselines("host1")
+    assert len(baselines) == 2
+    assert baselines["peer_count"]["p50"] == 45.0
+    assert baselines["peer_count"]["p95"] == 60.0
+    assert baselines["validator_count"]["p50"] == 10.0
+
+
+def test_build_hermes_context_no_history(temp_db: Database):
+    """Test build_hermes_context formats correctly with no history."""
+    payload = NotificationPayload(
+        incident_id="inc-1",
+        alert_type="consensus_desync",
+        severity=Severity.HIGH,
+        host="node-1",
+        title="Consensus Desync on node-1",
+        summary="Node is out of sync",
+        diagnostics={"peer_count": "2", "syncing": "true"},
+        runbook_id="consensus_desync",
+    )
+
+    context = build_hermes_context(payload, temp_db)
+
+    assert "consensus_desync" in context
+    assert "node-1" in context
+    assert "No prior incidents recorded" in context
+    assert "No operator corrections recorded" in context
+    assert "0% of the time" in context
+    assert "No baselines recorded" in context
+    assert '"peer_count": "2"' in context
+
+
+def test_build_hermes_context_with_history(temp_db: Database):
+    """Test build_hermes_context includes history and baselines when present."""
+    # Insert incident
+    with temp_db._get_connection() as conn:
+        conn.execute(
+            """
+            INSERT INTO incidents (id, alert_type, host, severity, fired_at, outcome, hermes_analysis)
+            VALUES ('inc-0', 'consensus_desync', 'node-1', 'high', '2024-01-01 10:00:00', 'resolved', 'Restarted peer')
+            """
+        )
+        # Insert correction
+        conn.execute(
+            """
+            INSERT INTO operator_corrections (id, incident_id, alert_type, host, correction)
+            VALUES ('corr-1', 'inc-0', 'consensus_desync', 'node-1', 'Always check peer count first')
+            """
+        )
+        # Insert runbook outcome
+        conn.execute(
+            """
+            INSERT INTO runbook_outcomes (id, runbook_id, host, action_taken, outcome, time_to_resolve)
+            VALUES ('out-1', 'consensus_desync', 'node-1', 'restart_consensus_client', 'resolved', 60)
+            """
+        )
+        # Insert baseline
+        conn.execute(
+            """
+            INSERT INTO host_fingerprints (host, metric, baseline_p50, baseline_p95, last_updated)
+            VALUES ('node-1', 'peer_count', 50.0, 80.0, '2024-01-01')
+            """
+        )
+        conn.commit()
+
+    payload = NotificationPayload(
+        incident_id="inc-1",
+        alert_type="consensus_desync",
+        severity=Severity.HIGH,
+        host="node-1",
+        title="Consensus Desync on node-1",
+        summary="Node is out of sync",
+        diagnostics={"peer_count": "2"},
+        runbook_id="consensus_desync",
+    )
+
+    context = build_hermes_context(payload, temp_db)
+
+    assert "resolved (severity: high, analysis: Restarted peer)" in context
+    assert "Always check peer count first" in context
+    assert "100% of the time" in context
+    assert "peer_count: p50=50.0, p95=80.0" in context