Update app.py

app.py

@@ -13,6 +13,8 @@ import contextlib
 import signal
 import sys
 import functools
+import csv
+import io
 from collections import deque
 from scipy.stats import beta
 import plotly.graph_objects as go
@@ -270,13 +272,11 @@ class BayesianRiskEngine:
         return lo, hi
 
 # ----------------------------------------------------------------------
-# Policy Engine
+# Policy Engine (uses global thresholds)
 # ----------------------------------------------------------------------
 class PolicyEngine:
-    def __init__(self, thresholds: Dict[str, float] = None):
-        if thresholds is None:
-            thresholds = {"low": LOW_THRESHOLD, "high": HIGH_THRESHOLD}
-        self.thresholds = thresholds
+    def __init__(self):
+        self.thresholds = {"low": LOW_THRESHOLD, "high": HIGH_THRESHOLD}
 
     def evaluate(self, risk):
         if risk < self.thresholds["low"]:
@@ -507,6 +507,22 @@ def generate_action_timeline():
     fig.update_layout(title="Autonomous Actions Timeline", xaxis_title="Time", yaxis_title="Approved (1) / Blocked (0)")
     return fig
 
+@dashboard_cache
+def generate_risk_trend():
+    """Line chart showing risk over time."""
+    with history_lock:
+        if not risk_history:
+            return go.Figure()
+        times = [ts for ts, _ in risk_history]
+        risks = [r for _, r in risk_history]
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=times, y=risks, mode='lines+markers', name='Risk', line=dict(color='red', width=2)))
+    # Add horizontal lines for thresholds
+    fig.add_hline(y=LOW_THRESHOLD, line_dash="dash", line_color="green", annotation_text=f"Low ({LOW_THRESHOLD})")
+    fig.add_hline(y=HIGH_THRESHOLD, line_dash="dash", line_color="orange", annotation_text=f"High ({HIGH_THRESHOLD})")
+    fig.update_layout(title="Risk Trend", xaxis_title="Time", yaxis_title="Risk Score", yaxis_range=[0, 1])
+    return fig
+
 def refresh_dashboard():
     with history_lock:
         total = len(decision_history)
@@ -523,9 +539,86 @@ def refresh_dashboard():
         control_stats,
         generate_risk_gauge(),
         generate_decision_pie(),
-        generate_action_timeline()
+        generate_action_timeline(),
+        generate_risk_trend()
     )
 
+# ----------------------------------------------------------------------
+# Batch simulation
+# ----------------------------------------------------------------------
+def run_batch_simulation(context_window: int):
+    """Run evaluation for all fault types and return a summary table and individual results."""
+    fault_types = ["none", "switch_down", "server_overload", "cascade"]
+    results = []
+    for fault in fault_types:
+        # We'll call handle_infra_with_governance directly
+        # Since it returns (output, state) and we ignore state
+        output, _ = handle_infra_with_governance(fault, context_window, {})
+        if "error" in output:
+            results.append({
+                "Fault Type": fault,
+                "Risk": "Error",
+                "Decision": output["error"],
+                "Risk Level": "N/A",
+                "Confidence Interval": "N/A"
+            })
+        else:
+            results.append({
+                "Fault Type": fault,
+                "Risk": f"{output['risk']:.4f}",
+                "Decision": output["decision"],
+                "Risk Level": output["governance"]["control_plane_decision"]["risk_level"],
+                "Confidence Interval": f"[{output['risk_ci'][0]:.3f}, {output['risk_ci'][1]:.3f}]"
+            })
+    # Convert to DataFrame-like display
+    summary_table = results
+    return summary_table
+
+# ----------------------------------------------------------------------
+# Data export
+# ----------------------------------------------------------------------
+def export_history_to_csv():
+    """Generate CSV of all decisions from database."""
+    try:
+        with contextlib.closing(sqlite3.connect(DB_PATH)) as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT timestamp, decision_json, risk FROM decisions ORDER BY timestamp")
+            rows = cursor.fetchall()
+        if not rows:
+            return "No data to export", None
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(["Timestamp", "Decision", "Risk", "Approved", "Risk Level", "Reason"])
+        for ts, json_str, risk in rows:
+            dec = json.loads(json_str)
+            writer.writerow([
+                ts,
+                json_str,
+                risk,
+                dec.get("approved", False),
+                dec.get("risk_level", ""),
+                dec.get("reason", "")
+            ])
+        output.seek(0)
+        return output.getvalue()
+    except Exception as e:
+        logger.error(f"Export failed: {e}")
+        return f"Export failed: {str(e)}", None
+
+# ----------------------------------------------------------------------
+# Update thresholds (global)
+# ----------------------------------------------------------------------
+def update_thresholds(low: float, high: float):
+    global LOW_THRESHOLD, HIGH_THRESHOLD
+    if 0 <= low < high <= 1:
+        LOW_THRESHOLD = low
+        HIGH_THRESHOLD = high
+        # Also update PolicyEngine thresholds (but PolicyEngine reads from globals, so fine)
+        logger.info(f"Updated thresholds: low={low}, high={high}")
+        return f"Thresholds updated: approve < {low}, escalate {low}-{high}, deny > {high}"
+    else:
+        return f"Invalid thresholds: low={low}, high={high}. Must satisfy 0 ≤ low < high ≤ 1."
+
 # ----------------------------------------------------------------------
 # OSS capabilities (mocked)
 # ----------------------------------------------------------------------
@@ -551,7 +644,6 @@ oss_caps = {
 def shutdown_handler(signum, frame):
     logger.info("Received shutdown signal, cleaning up...")
     shutdown_event.set()
-    # Wait a moment for threads to finish
     time.sleep(2)
     logger.info("Shutdown complete")
     sys.exit(0)
@@ -562,18 +654,15 @@ signal.signal(signal.SIGINT, shutdown_handler)
 # ----------------------------------------------------------------------
 # Startup
 # ----------------------------------------------------------------------
-# Ensure data directory exists and DB has secure permissions
 init_db()
 refresh_history_from_db()
 
-# Start memory monitor daemon thread
 mem_thread = threading.Thread(target=memory_monitor_loop, daemon=True)
 mem_thread.start()
 
-# Start periodic vacuum (once a day)
 def vacuum_scheduler():
     while not shutdown_event.is_set():
-        time.sleep(86400)  # 24 hours
+        time.sleep(86400)
         if not shutdown_event.is_set():
             vacuum_db()
 vacuum_thread = threading.Thread(target=vacuum_scheduler, daemon=True)
@@ -582,7 +671,7 @@ vacuum_thread.start()
 # ----------------------------------------------------------------------
 # Gradio UI
 # ----------------------------------------------------------------------
-with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
+with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo", theme=gr.themes.Soft()) as demo:
     gr.Markdown(f"""
     # 🧠 ARF v{VERSION} – Bayesian Risk Scoring for AI Reliability (Demo)
     **Mathematically rigorous risk estimation using conjugate priors and MCMC**
@@ -594,6 +683,9 @@ with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
     All components are implemented with only `numpy`, `scipy`, and standard libraries.
     """)
 
+    # ------------------------------------------------------------------
+    # Control Plane Dashboard with auto-refresh
+    # ------------------------------------------------------------------
     with gr.Tabs():
         with gr.TabItem("Control Plane Dashboard"):
             gr.Markdown("### 🎮 Control Plane")
@@ -619,12 +711,28 @@ with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
                 decision_pie = gr.Plot(label="Policy Decisions")
             with gr.Row():
                 action_timeline = gr.Plot(label="Autonomous Actions Timeline")
-            refresh_dash_btn = gr.Button("Refresh Dashboard")
-            refresh_dash_btn.click(
+                risk_trend = gr.Plot(label="Risk Trend")
+            with gr.Row():
+                auto_refresh = gr.Checkbox(label="Auto-refresh (3s)", value=False)
+                refresh_btn = gr.Button("Refresh Now")
+            # Auto-refresh timer
+            timer = gr.Timer(value=3, active=False)  # will be toggled
+            def refresh_if_enabled(auto):
+                if auto:
+                    return refresh_dashboard()
+                else:
+                    return [gr.update() for _ in range(5)]  # no update
+            timer.tick(refresh_if_enabled, inputs=[auto_refresh], outputs=[control_stats, risk_gauge, decision_pie, action_timeline, risk_trend])
+            refresh_btn.click(
                 fn=refresh_dashboard,
-                outputs=[control_stats, risk_gauge, decision_pie, action_timeline]
+                outputs=[control_stats, risk_gauge, decision_pie, action_timeline, risk_trend]
             )
+            # Start/stop timer based on checkbox
+            auto_refresh.change(lambda v: gr.Timer(active=v), inputs=[auto_refresh], outputs=[timer])
 
+        # ------------------------------------------------------------------
+        # Infrastructure Reliability (with batch simulation)
+        # ------------------------------------------------------------------
         with gr.TabItem("Infrastructure Reliability"):
             gr.Markdown("### 🏗️ Infrastructure Intent Evaluation with Bayesian Risk")
             infra_state = gr.State(value={})
@@ -633,21 +741,40 @@ with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
                     infra_fault = gr.Dropdown(
                         ["none", "switch_down", "server_overload", "cascade"],
                         value="none",
-                        label="Inject Fault"
+                        label="Inject Fault",
+                        info="Select a fault type to simulate infrastructure issues."
                     )
-                    # Use a Number component to allow user to set context window
                     context_window_input = gr.Number(
                         value=50,
                         label="Context Window (number of recent events)",
-                        minimum=1,
+                        minimum=0,
                         maximum=1000,
                         step=1,
                         info="How many past incidents to consider for risk calculation (0 = unlimited)"
                     )
-                    infra_btn = gr.Button("Evaluate Intent")
+                    with gr.Row():
+                        infra_btn = gr.Button("Evaluate Intent")
+                        batch_btn = gr.Button("Run Batch Simulation", variant="secondary")
                 with gr.Column():
                     infra_output = gr.JSON(label="Analysis Result")
+            batch_results = gr.Dataframe(
+                headers=["Fault Type", "Risk", "Decision", "Risk Level", "Confidence Interval"],
+                label="Batch Simulation Results"
+            )
+            infra_btn.click(
+                fn=handle_infra_with_governance,
+                inputs=[infra_fault, context_window_input, infra_state],
+                outputs=[infra_output, infra_state]
+            )
+            batch_btn.click(
+                fn=run_batch_simulation,
+                inputs=[context_window_input],
+                outputs=[batch_results]
+            )
 
+        # ------------------------------------------------------------------
+        # Deep Analysis (MCMC)
+        # ------------------------------------------------------------------
         with gr.TabItem("Deep Analysis (MCMC)"):
             gr.Markdown("### Markov Chain Monte Carlo (Metropolis‑Hastings)")
             with gr.Row():
@@ -660,17 +787,46 @@ with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
             with gr.Row():
                 hmc_trace_plot = gr.Plot(label="Trace Plot")
                 hmc_pair_plot = gr.Plot(label="Posterior Histogram")
+            hmc_run_btn.click(
+                fn=run_hmc_mcmc,
+                inputs=[hmc_samples, hmc_warmup],
+                outputs=[hmc_summary, hmc_trace_plot, hmc_pair_plot]
+            )
 
+        # ------------------------------------------------------------------
+        # Policy Management (with interactive sliders)
+        # ------------------------------------------------------------------
         with gr.TabItem("Policy Management"):
             gr.Markdown("### 📋 Execution Policies")
+            with gr.Row():
+                low_slider = gr.Slider(0, 1, value=LOW_THRESHOLD, step=0.01, label="Low Threshold (Approve <)")
+                high_slider = gr.Slider(0, 1, value=HIGH_THRESHOLD, step=0.01, label="High Threshold (Deny >)")
+                update_thresh_btn = gr.Button("Update Thresholds")
+            thresh_status = gr.Markdown(f"Current: approve < {LOW_THRESHOLD}, escalate {LOW_THRESHOLD}-{HIGH_THRESHOLD}, deny > {HIGH_THRESHOLD}")
             policies_json = [
                 {"name": "Low Risk Policy", "conditions": [f"risk < {LOW_THRESHOLD}"], "action": "approve", "priority": 1},
                 {"name": "Medium Risk Policy", "conditions": [f"{LOW_THRESHOLD} ≤ risk ≤ {HIGH_THRESHOLD}"], "action": "escalate", "priority": 2},
                 {"name": "High Risk Policy", "conditions": [f"risk > {HIGH_THRESHOLD}"], "action": "deny", "priority": 3}
             ]
-            gr.JSON(label="Active Policies", value=policies_json)
+            policy_display = gr.JSON(label="Active Policies", value=policies_json)
+            update_thresh_btn.click(
+                fn=update_thresholds,
+                inputs=[low_slider, high_slider],
+                outputs=[thresh_status]
+            ).then(
+                fn=lambda: [
+                    [
+                        {"name": "Low Risk Policy", "conditions": [f"risk < {LOW_THRESHOLD}"], "action": "approve", "priority": 1},
+                        {"name": "Medium Risk Policy", "conditions": [f"{LOW_THRESHOLD} ≤ risk ≤ {HIGH_THRESHOLD}"], "action": "escalate", "priority": 2},
+                        {"name": "High Risk Policy", "conditions": [f"risk > {HIGH_THRESHOLD}"], "action": "deny", "priority": 3}
+                    ]
+                ],
+                outputs=[policy_display]
+            )
 
-        # Sales-driven Enterprise / OSS tab
+        # ------------------------------------------------------------------
+        # Enterprise / OSS (with data export)
+        # ------------------------------------------------------------------
         with gr.TabItem("Enterprise / OSS"):
             gr.Markdown(f"""
             <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 2rem; border-radius: 12px; margin-bottom: 2rem; text-align: center; color: white;">
@@ -716,22 +872,37 @@ with gr.Blocks(title=f"ARF v{VERSION} – Bayesian Risk Scoring Demo") as demo:
 
             <div style="text-align: center; margin-top: 2rem;">
                 <a href="https://calendly.com/petter2025us/30min" target="_blank" style="background: #764ba2; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; font-weight: bold; margin-right: 1rem;">📅 Book a Demo</a>
-                <a href="mailto:petter2025us@outlook.com" style="background: #667eea; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; font-weight: bold;">📧 Email me</a>
+                <a href="mailto:petter2025us@outlook.com" style="background: #667eea; color: white; padding: 12px 24px; text-decoration: none; border-radius: 8px; font-weight: bold;">📧 Contact Sales</a>
             </div>
             """)
+            # Data export section
+            gr.Markdown("### 📥 Export Decision History")
+            with gr.Row():
+                export_btn = gr.DownloadButton("Download CSV", variant="primary")
+                export_btn.click(
+                    fn=export_history_to_csv,
+                    outputs=[gr.File(label="decision_history.csv", visible=False)]  # hidden, but we need a file component
+                )
+            # Note: gradio DownloadButton works with a function that returns a file path or bytes.
+            # We'll create a temporary file.
+            def export_and_return_file():
+                csv_data = export_history_to_csv()
+                if csv_data and not csv_data.startswith("Export failed"):
+                    # Write to a temporary file
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+                        f.write(csv_data)
+                        return f.name
+                else:
+                    return None
+            export_btn.click(
+                fn=export_and_return_file,
+                outputs=[gr.File(label="decision_history.csv")]
+            )
 
-    # Wire events
-    infra_btn.click(
-        fn=handle_infra_with_governance,
-        inputs=[infra_fault, context_window_input, infra_state],
-        outputs=[infra_output, infra_state]
-    )
-
-    hmc_run_btn.click(
-        fn=run_hmc_mcmc,
-        inputs=[hmc_samples, hmc_warmup],
-        outputs=[hmc_summary, hmc_trace_plot, hmc_pair_plot]
-    )
+    # ------------------------------------------------------------------
+    # Wire events for infra and MCMC (already done above)
+    # ------------------------------------------------------------------
 
 # ----------------------------------------------------------------------
 # Launch