feat: Add chat analytics dashboard to Cain

- Create app_analytics.py with Gradio.Blocks interface
- Add load_analytics_data() function to read from session-archive.jsonl
- Implement 4 chart types: line (messages/hour), bar (agent responses), pie (sentiment), DataFrame (top sessions)
- Add Analytics tab to main app.py with embedded dashboard
- Use Plotly for interactive charts with minimal functional design

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app.py

@@ -1845,6 +1845,67 @@ def create_agent_office():
                                 label="Session Statistics"
                             )
 
+            # ========== Tab: Analytics Dashboard ==========
+            with gr.Tab("📊 Analytics"):
+                gr.Markdown("## 📊 Chat Analytics Dashboard")
+                gr.Markdown("Visualize conversation patterns and agent performance metrics.")
+
+                # Import analytics functions
+                from app_analytics import load_analytics_data, create_line_chart, create_bar_chart, create_pie_chart
+                import pandas as pd
+
+                # Load initial data
+                initial_analytics = load_analytics_data()
+
+                with gr.Row():
+                    analytics_refresh_btn = gr.Button("🔄 Refresh Analytics", variant="primary")
+
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        analytics_line_plot = gr.Plot(
+                            value=create_line_chart(initial_analytics["messages_per_hour"]),
+                            label="Messages per Hour (Last 24h)"
+                        )
+                    with gr.Column(scale=1):
+                        analytics_bar_plot = gr.Plot(
+                            value=create_bar_chart(initial_analytics["agent_distribution"]),
+                            label="Agent Response Distribution"
+                        )
+
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        analytics_pie_plot = gr.Plot(
+                            value=create_pie_chart(initial_analytics["sentiment_counts"]),
+                            label="Sentiment Analysis"
+                        )
+                    with gr.Column(scale=1):
+                        analytics_df_data = initial_analytics["top_sessions"] if initial_analytics["top_sessions"] else [{
+                            "session": "No data", "activity_count": 0, "last_active": "N/A"
+                        }]
+                        analytics_sessions_df = gr.Dataframe(
+                            value=pd.DataFrame(analytics_df_data),
+                            label="Top 10 Active Sessions",
+                            headers=["Session", "Activity Count", "Last Active"],
+                            interactive=False
+                        )
+
+                # Analytics refresh handler
+                def refresh_analytics_dashboard():
+                    data = load_analytics_data()
+                    line_fig = create_line_chart(data["messages_per_hour"])
+                    bar_fig = create_bar_chart(data["agent_distribution"])
+                    pie_fig = create_pie_chart(data["sentiment_counts"])
+                    df_data = data["top_sessions"] if data["top_sessions"] else [{
+                        "session": "No data", "activity_count": 0, "last_active": "N/A"
+                    }]
+                    df = pd.DataFrame(df_data)
+                    return line_fig, bar_fig, pie_fig, df
+
+                analytics_refresh_btn.click(
+                    fn=refresh_analytics_dashboard,
+                    outputs=[analytics_line_plot, analytics_bar_plot, analytics_pie_plot, analytics_sessions_df]
+                )
+
         # ========== Footer ==========
         gr.Markdown("---")
         with gr.Row():

app_analytics.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""
+Chat Analytics Dashboard for HuggingClaw Cain
+
+Visualizes conversation patterns and agent performance metrics.
+"""
+import os
+import json
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+from collections import defaultdict, Counter
+
+import gradio as gr
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+
+# ========== Path Constants ==========
+BASE_DIR = Path(__file__).resolve().parent
+SESSION_ARCHIVE_PATH = BASE_DIR / ".openclaw" / "agents" / "logs" / "session-archive.jsonl"
+
+
+def load_analytics_data() -> Dict[str, Any]:
+    """
+    Load and parse analytics data from session-archive.jsonl.
+
+    Returns:
+        Dictionary containing aggregated statistics:
+        - messages_per_hour: List of (hour, count) tuples for last 24h
+        - agent_distribution: Dict of agent names to response counts
+        - sentiment_counts: Dict of sentiment (positive/negative/neutral) to counts
+        - top_sessions: List of top 10 active session dicts
+    """
+    default_result = {
+        "messages_per_hour": [],
+        "agent_distribution": {},
+        "sentiment_counts": {"positive": 0, "negative": 0, "neutral": 0},
+        "top_sessions": []
+    }
+
+    if not SESSION_ARCHIVE_PATH.exists():
+        return default_result
+
+    # Parse all records
+    records = []
+    try:
+        with open(SESSION_ARCHIVE_PATH, 'r') as f:
+            for line in f:
+                if line.strip():
+                    try:
+                        records.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        continue
+    except Exception:
+        return default_result
+
+    if not records:
+        return default_result
+
+    # Parse timestamps and filter for last 24 hours
+    now = datetime.utcnow()
+    cutoff = now - timedelta(hours=24)
+
+    parsed_records = []
+    for r in records:
+        ts_str = r.get("timestamp")
+        if not ts_str:
+            continue
+        try:
+            # Handle ISO format with timezone
+            if ts_str.endswith("+00:00"):
+                ts_str = ts_str.replace("+00:00", "").replace("Z", "")
+            ts = datetime.fromisoformat(ts_str.replace("Z", ""))
+            parsed_records.append({
+                "timestamp": ts,
+                "agent": r.get("agent", "unknown"),
+                "state": r.get("state", "unknown"),
+                "action": r.get("action", "state_change"),
+                "type": r.get("type", "state_change")
+            })
+        except (ValueError, AttributeError):
+            continue
+
+    # Filter for last 24 hours for hourly chart
+    recent_records = [r for r in parsed_records if r["timestamp"] >= cutoff]
+
+    # 1. Messages per hour (last 24h)
+    hour_counts = defaultdict(int)
+    for r in recent_records:
+        hour_key = r["timestamp"].strftime("%Y-%m-%d %H:00")
+        hour_counts[hour_key] += 1
+
+    # Fill missing hours with 0
+    messages_per_hour = []
+    for i in range(24):
+        hour_time = now - timedelta(hours=23-i)
+        hour_key = hour_time.strftime("%Y-%m-%d %H:00")
+        messages_per_hour.append({
+            "hour": hour_time.strftime("%H:00"),
+            "count": hour_counts.get(hour_key, 0)
+        })
+
+    # 2. Agent response distribution (state changes by agent)
+    agent_counts = Counter(r["agent"] for r in parsed_records if r["agent"] != "unknown")
+    agent_distribution = dict(agent_counts.most_common())
+
+    # 3. Sentiment analysis (based on state: success/error/other)
+    sentiment_counts = {"positive": 0, "negative": 0, "neutral": 0}
+    for r in parsed_records:
+        state = r.get("state", "").lower()
+        if state == "success":
+            sentiment_counts["positive"] += 1
+        elif state in ("error", "failed"):
+            sentiment_counts["negative"] += 1
+        else:
+            sentiment_counts["neutral"] += 1
+
+    # 4. Top 10 active sessions (by agent activity)
+    session_activity = defaultdict(lambda: {"count": 0, "last_active": None})
+    for r in parsed_records:
+        agent = r["agent"]
+        session_activity[agent]["count"] += 1
+        if session_activity[agent]["last_active"] is None or r["timestamp"] > session_activity[agent]["last_active"]:
+            session_activity[agent]["last_active"] = r["timestamp"]
+
+    top_sessions = [
+        {
+            "session": agent,
+            "activity_count": data["count"],
+            "last_active": data["last_active"].strftime("%Y-%m-%d %H:%M:%S") if data["last_active"] else "N/A"
+        }
+        for agent, data in sorted(session_activity.items(), key=lambda x: x[1]["count"], reverse=True)[:10]
+    ]
+
+    return {
+        "messages_per_hour": messages_per_hour,
+        "agent_distribution": agent_distribution,
+        "sentiment_counts": sentiment_counts,
+        "top_sessions": top_sessions
+    }
+
+
+def create_line_chart(data: List[Dict]) -> go.Figure:
+    """Create line chart for messages per hour."""
+    hours = [d["hour"] for d in data]
+    counts = [d["count"] for d in data]
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(
+        x=hours,
+        y=counts,
+        mode="lines+markers",
+        name="Messages",
+        line=dict(color="#3b82f6", width=2),
+        marker=dict(size=6)
+    ))
+
+    fig.update_layout(
+        title="Messages per Hour (Last 24h)",
+        xaxis_title="Hour",
+        yaxis_title="Message Count",
+        hovermode="x unified",
+        height=300,
+        margin=dict(l=10, r=10, t=40, b=40)
+    )
+    return fig
+
+
+def create_bar_chart(data: Dict[str, int]) -> go.Figure:
+    """Create bar chart for agent response distribution."""
+    agents = list(data.keys())
+    counts = list(data.values())
+
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=agents,
+        y=counts,
+        marker_color="#10b981"
+    ))
+
+    fig.update_layout(
+        title="Agent Response Distribution",
+        xaxis_title="Agent",
+        yaxis_title="Response Count",
+        height=300,
+        margin=dict(l=10, r=10, t=40, b=40)
+    )
+    return fig
+
+
+def create_pie_chart(data: Dict[str, int]) -> go.Figure:
+    """Create pie chart for sentiment analysis."""
+    labels = list(data.keys())
+    values = list(data.values())
+    colors = ["#10b981", "#ef4444", "#6b7280"]
+
+    fig = go.Figure()
+    fig.add_trace(go.Pie(
+        labels=labels,
+        values=values,
+        marker=dict(colors=colors),
+        textinfo="label+percent"
+    ))
+
+    fig.update_layout(
+        title="Sentiment Analysis",
+        height=300,
+        margin=dict(l=10, r=10, t=40, b=40)
+    )
+    return fig
+
+
+def refresh_analytics():
+    """Refresh all analytics data and charts."""
+    data = load_analytics_data()
+
+    # Update charts
+    line_fig = create_line_chart(data["messages_per_hour"])
+    bar_fig = create_bar_chart(data["agent_distribution"])
+    pie_fig = create_pie_chart(data["sentiment_counts"])
+
+    # Update dataframe
+    df_data = data["top_sessions"] if data["top_sessions"] else [{
+        "session": "No data", "activity_count": 0, "last_active": "N/A"
+    }]
+    df = pd.DataFrame(df_data)
+
+    return line_fig, bar_fig, pie_fig, df
+
+
+def create_analytics_interface():
+    """Create the Gradio analytics dashboard interface."""
+    # Load initial data
+    initial_data = load_analytics_data()
+
+    # Create initial charts
+    initial_line = create_line_chart(initial_data["messages_per_hour"])
+    initial_bar = create_bar_chart(initial_data["agent_distribution"])
+    initial_pie = create_pie_chart(initial_data["sentiment_counts"])
+
+    # Create initial dataframe
+    df_data = initial_data["top_sessions"] if initial_data["top_sessions"] else [{
+        "session": "No data", "activity_count": 0, "last_active": "N/A"
+    }]
+    initial_df = pd.DataFrame(df_data)
+
+    with gr.Blocks(title="Cain Analytics Dashboard", theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 📊 Cain Chat Analytics Dashboard")
+
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh", variant="primary")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                line_plot = gr.Plot(value=initial_line)
+            with gr.Column(scale=1):
+                bar_plot = gr.Plot(value=initial_bar)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                pie_plot = gr.Plot(value=initial_pie)
+            with gr.Column(scale=1):
+                sessions_df = gr.Dataframe(
+                    value=initial_df,
+                    label="Top 10 Active Sessions",
+                    headers=["Session", "Activity Count", "Last Active"]
+                )
+
+        # Bind refresh button
+        refresh_btn.click(
+            refresh_analytics,
+            outputs=[line_plot, bar_plot, pie_plot, sessions_df]
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    app = create_analytics_interface()
+    app.launch(server_name="0.0.0.0", server_port=7861, share=False)