foundry-mcp 0.8.22__py3-none-any.whl

foundry_mcp/dashboard/__init__.py

@@ -0,0 +1,32 @@
+"""Streamlit-based dashboard for foundry-mcp observability.
+
+This module provides a web UI for viewing errors, metrics, provider status,
+and SDD workflow progress.
+
+Public API:
+    launch_dashboard: Start the Streamlit dashboard server
+    stop_dashboard: Stop the running dashboard server
+    get_dashboard_status: Check if dashboard is running
+
+Usage:
+    from foundry_mcp.dashboard import launch_dashboard, stop_dashboard
+
+    # Start dashboard
+    result = launch_dashboard(port=8501, open_browser=True)
+    print(f"Dashboard running at {result['url']}")
+
+    # Stop dashboard
+    stop_dashboard()
+"""
+
+from foundry_mcp.dashboard.launcher import (
+    get_dashboard_status,
+    launch_dashboard,
+    stop_dashboard,
+)
+
+__all__ = [
+    "launch_dashboard",
+    "stop_dashboard",
+    "get_dashboard_status",
+]

foundry_mcp/dashboard/app.py

@@ -0,0 +1,119 @@
+"""Main Streamlit dashboard application.
+
+This is the entry point for the Streamlit dashboard.
+Run with: streamlit run src/foundry_mcp/dashboard/app.py
+"""
+
+import streamlit as st
+
+# Page config must be first Streamlit command
+st.set_page_config(
+    page_title="foundry-mcp Dashboard",
+    page_icon=":chart_with_upwards_trend:",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# Import pages after config
+from foundry_mcp.dashboard.views import overview, errors, metrics, tool_usage
+
+# Custom dark theme CSS
+st.markdown(
+    """
+<style>
+    /* Consistent dark theme styling */
+    .stMetric {
+        background-color: rgba(30, 30, 46, 0.8);
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border: 1px solid rgba(100, 100, 150, 0.3);
+    }
+    .stMetric label {
+        color: #a0a0b0 !important;
+    }
+    .stMetric [data-testid="stMetricValue"] {
+        color: #e0e0f0 !important;
+    }
+    /* Card-like containers */
+    [data-testid="stVerticalBlock"] > [data-testid="stVerticalBlock"] {
+        background-color: rgba(30, 30, 46, 0.5);
+        border-radius: 0.5rem;
+        padding: 0.5rem;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+# Initialize session state
+if "auto_refresh" not in st.session_state:
+    st.session_state.auto_refresh = False
+if "refresh_interval" not in st.session_state:
+    st.session_state.refresh_interval = 5
+
+
+def render_sidebar():
+    """Render navigation sidebar."""
+    with st.sidebar:
+        st.title(":cube: foundry-mcp")
+        st.caption("Observability Dashboard")
+
+        st.divider()
+
+        # Navigation
+        page = st.radio(
+            "Navigate",
+            options=["Overview", "Tool Usage", "Errors", "Metrics"],
+            label_visibility="collapsed",
+        )
+
+        st.divider()
+
+        # Auto-refresh controls
+        st.subheader("Settings")
+        st.session_state.auto_refresh = st.checkbox(
+            "Auto-refresh",
+            value=st.session_state.auto_refresh,
+        )
+        if st.session_state.auto_refresh:
+            st.session_state.refresh_interval = st.slider(
+                "Interval (sec)",
+                min_value=5,
+                max_value=60,
+                value=st.session_state.refresh_interval,
+            )
+
+        # Manual refresh button
+        if st.button("Refresh Now", use_container_width=True):
+            st.rerun()
+
+        return page
+
+
+def main():
+    """Main dashboard entry point."""
+    # Render sidebar and get page selection
+    page = render_sidebar()
+
+    # Route to page
+    page_map = {
+        "Overview": overview.render,
+        "Tool Usage": tool_usage.render,
+        "Errors": errors.render,
+        "Metrics": metrics.render,
+    }
+
+    # Render selected page
+    render_func = page_map.get(page, overview.render)
+    render_func()
+
+    # Auto-refresh logic
+    if st.session_state.auto_refresh:
+        import time
+
+        time.sleep(st.session_state.refresh_interval)
+        st.rerun()
+
+
+if __name__ == "__main__":
+    main()

foundry_mcp/dashboard/components/__init__.py

@@ -0,0 +1,17 @@
+"""Reusable dashboard UI components.
+
+Components:
+    cards: KPI metric card helpers
+    charts: Plotly chart builders
+    filters: Time range and filter widgets
+    tables: Data table configurations
+"""
+
+from foundry_mcp.dashboard.components import cards, charts, filters, tables
+
+__all__ = [
+    "cards",
+    "charts",
+    "filters",
+    "tables",
+]

foundry_mcp/dashboard/components/cards.py

@@ -0,0 +1,88 @@
+"""KPI card components for dashboard."""
+
+from typing import Optional
+
+import streamlit as st
+
+
+def metric_card(
+    label: str,
+    value: str | int | float,
+    delta: Optional[str] = None,
+    delta_color: str = "normal",
+    help_text: Optional[str] = None,
+) -> None:
+    """Render a metric card with optional delta indicator.
+
+    Args:
+        label: Card title/label
+        value: Main value to display
+        delta: Optional change indicator (e.g., "+5%", "-3")
+        delta_color: Color for delta ("normal", "inverse", "off")
+        help_text: Optional tooltip help text
+    """
+    st.metric(
+        label=label,
+        value=value,
+        delta=delta,
+        delta_color=delta_color,
+        help=help_text,
+    )
+
+
+def status_badge(status: str, label: Optional[str] = None) -> None:
+    """Render a status badge with color coding.
+
+    Args:
+        status: Status value ("healthy", "unhealthy", "warning", "unknown")
+        label: Optional label to show before status
+    """
+    colors = {
+        "healthy": ":green_circle:",
+        "unhealthy": ":red_circle:",
+        "warning": ":yellow_circle:",
+        "unknown": ":white_circle:",
+        "available": ":green_circle:",
+        "unavailable": ":red_circle:",
+    }
+
+    emoji = colors.get(status.lower(), ":white_circle:")
+    text = label if label else status.title()
+    st.markdown(f"{emoji} **{text}**")
+
+
+def info_card(title: str, content: str, icon: Optional[str] = None) -> None:
+    """Render an info card with title and content.
+
+    Args:
+        title: Card title
+        content: Card content (markdown supported)
+        icon: Optional emoji icon
+    """
+    with st.container(border=True):
+        header = f"{icon} {title}" if icon else title
+        st.subheader(header)
+        st.markdown(content)
+
+
+def kpi_row(
+    metrics: list[dict],
+    columns: int = 6,
+) -> None:
+    """Render a row of KPI metric cards.
+
+    Args:
+        metrics: List of metric dicts with keys: label, value, delta, help
+        columns: Number of columns (default 6)
+    """
+    cols = st.columns(columns)
+
+    for i, m in enumerate(metrics):
+        with cols[i % columns]:
+            metric_card(
+                label=m.get("label", ""),
+                value=m.get("value", 0),
+                delta=m.get("delta"),
+                delta_color=m.get("delta_color", "normal"),
+                help_text=m.get("help"),
+            )

foundry_mcp/dashboard/components/charts.py

@@ -0,0 +1,177 @@
+"""Plotly chart builders for dashboard."""
+
+from typing import Optional
+
+import streamlit as st
+
+# Try importing plotly - it's an optional dependency
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+
+    PLOTLY_AVAILABLE = True
+except ImportError:
+    PLOTLY_AVAILABLE = False
+    px = None
+    go = None
+
+# Try importing pandas
+try:
+    import pandas as pd
+
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+    pd = None
+
+
+def _check_deps():
+    """Check if required dependencies are available."""
+    if not PLOTLY_AVAILABLE:
+        st.warning("Plotly not installed. Install with: pip install plotly")
+        return False
+    if not PANDAS_AVAILABLE:
+        st.warning("Pandas not installed. Install with: pip install pandas")
+        return False
+    return True
+
+
+def bar_chart(
+    df: "pd.DataFrame",
+    x: str,
+    y: str,
+    title: Optional[str] = None,
+    color: Optional[str] = None,
+    orientation: str = "v",
+    height: int = 400,
+) -> None:
+    """Render an interactive bar chart.
+
+    Args:
+        df: DataFrame with data
+        x: Column name for x-axis (or values if horizontal)
+        y: Column name for y-axis (or categories if horizontal)
+        title: Optional chart title
+        color: Optional column for color grouping
+        orientation: "v" for vertical, "h" for horizontal
+        height: Chart height in pixels
+    """
+    if not _check_deps():
+        return
+
+    if df is None or df.empty:
+        st.info("No data to display")
+        return
+
+    fig = px.bar(
+        df,
+        x=x,
+        y=y,
+        title=title,
+        color=color,
+        orientation=orientation,
+    )
+
+    fig.update_layout(
+        template="plotly_dark",
+        height=height,
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def pie_chart(
+    df: "pd.DataFrame",
+    values: str,
+    names: str,
+    title: Optional[str] = None,
+    hole: float = 0.4,
+    height: int = 400,
+) -> None:
+    """Render an interactive pie/donut chart.
+
+    Args:
+        df: DataFrame with data
+        values: Column name for values
+        names: Column name for category names
+        title: Optional chart title
+        hole: Hole size for donut (0 for pie, 0.4 for donut)
+        height: Chart height in pixels
+    """
+    if not _check_deps():
+        return
+
+    if df is None or df.empty:
+        st.info("No data to display")
+        return
+
+    # Custom colors for status charts
+    color_map = {
+        "completed": "#10b981",
+        "in_progress": "#3b82f6",
+        "pending": "#9ca3af",
+        "blocked": "#ef4444",
+    }
+
+    fig = px.pie(
+        df,
+        values=values,
+        names=names,
+        title=title,
+        hole=hole,
+        color=names,
+        color_discrete_map=color_map,
+    )
+
+    fig.update_layout(
+        template="plotly_dark",
+        height=height,
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def treemap_chart(
+    df: "pd.DataFrame",
+    path: list[str],
+    values: str,
+    title: Optional[str] = None,
+    height: int = 400,
+) -> None:
+    """Render an interactive treemap chart.
+
+    Args:
+        df: DataFrame with data
+        path: List of column names for hierarchy path
+        values: Column name for values
+        title: Optional chart title
+        height: Chart height in pixels
+    """
+    if not _check_deps():
+        return
+
+    if df is None or df.empty:
+        st.info("No data to display")
+        return
+
+    fig = px.treemap(
+        df,
+        path=path,
+        values=values,
+        title=title,
+    )
+
+    fig.update_layout(
+        template="plotly_dark",
+        height=height,
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+
+    st.plotly_chart(fig, use_container_width=True)
+
+
+def empty_chart(message: str = "No data available") -> None:
+    """Display a placeholder for empty charts."""
+    st.info(message)

foundry_mcp/dashboard/components/filters.py

@@ -0,0 +1,136 @@
+"""Filter widget components for dashboard."""
+
+from datetime import datetime, timedelta
+from typing import Optional
+
+import streamlit as st
+
+
+def time_range_filter(
+    key: str = "time_range",
+    default: str = "24h",
+) -> int:
+    """Render a time range selector.
+
+    Args:
+        key: Unique key for the widget
+        default: Default selection
+
+    Returns:
+        Number of hours for the selected range
+    """
+    options = {
+        "1 hour": 1,
+        "6 hours": 6,
+        "24 hours": 24,
+        "7 days": 168,
+        "30 days": 720,
+    }
+
+    # Find default index
+    default_hours = {"1h": 1, "6h": 6, "24h": 24, "7d": 168, "30d": 720}.get(default, 24)
+    default_label = next((k for k, v in options.items() if v == default_hours), "24 hours")
+    default_idx = list(options.keys()).index(default_label)
+
+    selected = st.selectbox(
+        "Time Range",
+        options=list(options.keys()),
+        index=default_idx,
+        key=key,
+    )
+
+    return options[selected]
+
+
+def date_range_filter(
+    key: str = "date_range",
+    default_days: int = 7,
+) -> tuple[datetime, datetime]:
+    """Render a date range picker.
+
+    Args:
+        key: Unique key for the widget
+        default_days: Default number of days back
+
+    Returns:
+        Tuple of (start_date, end_date)
+    """
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=default_days)
+
+    dates = st.date_input(
+        "Date Range",
+        value=(start_date.date(), end_date.date()),
+        key=key,
+    )
+
+    if isinstance(dates, tuple) and len(dates) == 2:
+        return (
+            datetime.combine(dates[0], datetime.min.time()),
+            datetime.combine(dates[1], datetime.max.time()),
+        )
+    else:
+        # Single date selected
+        return (
+            datetime.combine(dates, datetime.min.time()),
+            datetime.combine(dates, datetime.max.time()),
+        )
+
+
+def multi_select_filter(
+    label: str,
+    options: list[str],
+    key: str,
+    default: Optional[list[str]] = None,
+) -> list[str]:
+    """Render a multi-select filter.
+
+    Args:
+        label: Filter label
+        options: List of options to choose from
+        key: Unique key for the widget
+        default: Default selected values
+
+    Returns:
+        List of selected values
+    """
+    return st.multiselect(
+        label,
+        options=options,
+        default=default,
+        key=key,
+    )
+
+
+def text_filter(
+    label: str,
+    key: str,
+    placeholder: Optional[str] = None,
+) -> str:
+    """Render a text input filter.
+
+    Args:
+        label: Filter label
+        key: Unique key for the widget
+        placeholder: Optional placeholder text
+
+    Returns:
+        Input text value
+    """
+    return st.text_input(
+        label,
+        key=key,
+        placeholder=placeholder or f"Filter by {label.lower()}...",
+    )
+
+
+def filter_row(num_cols: int = 4):
+    """Create a row of filter columns.
+
+    Args:
+        num_cols: Number of columns
+
+    Returns:
+        Tuple of column objects
+    """
+    return st.columns(num_cols)