foundry-mcp 0.8.22__py3-none-any.whl

foundry_mcp/dashboard/views/overview.py

@@ -0,0 +1,96 @@
+"""Overview page - dashboard home with KPIs and summary."""
+
+import streamlit as st
+
+from foundry_mcp.dashboard.components.cards import kpi_row
+from foundry_mcp.dashboard.data.stores import (
+    get_overview_summary,
+    get_errors,
+    get_error_patterns,
+    get_top_tool_actions,
+)
+
+
+def render():
+    """Render the Overview page."""
+    st.header("Overview")
+
+    # Get summary data
+    summary = get_overview_summary()
+
+    # KPI Cards Row
+    st.subheader("Key Metrics")
+    kpi_row(
+        [
+            {
+                "label": "Total Invocations",
+                "value": summary.get("total_invocations", 0),
+                "help": "Total tool invocations recorded (all time)",
+            },
+            {
+                "label": "Total Errors",
+                "value": summary.get("error_count", 0),
+                "help": "Total errors recorded (all time)",
+            },
+        ],
+        columns=2,
+    )
+
+    st.divider()
+
+    # Bottom Row - Patterns and Recent
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("Top Error Patterns (All Time)")
+        patterns = get_error_patterns(min_count=2)
+        if patterns:
+            for i, p in enumerate(patterns[:5]):
+                with st.container(border=True):
+                    st.markdown(f"**{p.get('tool_name', 'Unknown')}**")
+                    st.caption(f"Count: {p.get('count', 0)} | Code: {p.get('error_code', 'N/A')}")
+                    if p.get("message"):
+                        st.text(p["message"][:100] + "..." if len(p.get("message", "")) > 100 else p.get("message", ""))
+        else:
+            st.info("No recurring error patterns detected")
+
+    with col2:
+        st.subheader("Recent Errors (Last Hour)")
+        errors_df = get_errors(since_hours=1, limit=5)
+
+        # Try fallback to 24h if 1h is empty
+        if errors_df is None or errors_df.empty:
+            errors_df = get_errors(since_hours=24, limit=5)
+            if errors_df is not None and not errors_df.empty:
+                st.caption("No errors in last hour - showing last 24h")
+
+        if errors_df is not None and not errors_df.empty:
+            for _, row in errors_df.iterrows():
+                with st.container(border=True):
+                    st.markdown(f"**{row.get('tool_name', 'Unknown')}**")
+                    st.caption(f"{row.get('timestamp', '')} | {row.get('error_code', 'N/A')}")
+                    msg = row.get("message", "")
+                    st.text(msg[:80] + "..." if len(msg) > 80 else msg)
+        else:
+            st.info("No recent errors")
+
+    st.divider()
+
+    # Tool Usage Breakdown
+    st.subheader("Top Tool Actions (Last 24h)")
+    top_actions = get_top_tool_actions(since_hours=24, top_n=10)
+
+    if top_actions:
+        col1, col2 = st.columns(2)
+        for i, item in enumerate(top_actions):
+            tool = item.get("tool", "unknown")
+            action = item.get("action", "")
+            count = int(item.get("count", 0))
+            display_name = f"{tool}.{action}" if action and action != "(no action)" else tool
+            target_col = col1 if i < 5 else col2
+            with target_col:
+                with st.container(border=True):
+                    st.markdown(f"**{display_name}**")
+                    st.caption(f"Invocations: {count:,}")
+    else:
+        st.info("No tool action data available yet")

foundry_mcp/dashboard/views/providers.py

@@ -0,0 +1,83 @@
+"""Providers page - AI provider status grid."""
+
+import streamlit as st
+
+from foundry_mcp.dashboard.components.cards import status_badge
+from foundry_mcp.dashboard.data.stores import get_providers
+
+
+def render():
+    """Render the Providers page."""
+    st.header("AI Providers")
+
+    providers = get_providers()
+
+    if not providers:
+        st.info("No AI providers configured or providers module not available.")
+        st.caption("Providers are configured in foundry-mcp.toml under [providers]")
+        return
+
+    # Summary
+    available_count = len([p for p in providers if p.get("available")])
+    total_count = len(providers)
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Total Providers", total_count)
+    with col2:
+        st.metric("Available", available_count)
+    with col3:
+        st.metric("Unavailable", total_count - available_count)
+
+    st.divider()
+
+    # Provider grid
+    st.subheader("Provider Status")
+
+    # Create grid layout
+    cols = st.columns(3)
+
+    for i, provider in enumerate(providers):
+        with cols[i % 3]:
+            with st.container(border=True):
+                # Header with status
+                provider_id = provider.get("id", "unknown")
+                is_available = provider.get("available", False)
+
+                status = "available" if is_available else "unavailable"
+                status_badge(status, label=provider_id)
+
+                # Description
+                description = provider.get("description", "")
+                if description:
+                    st.caption(description[:100] + "..." if len(description) > 100 else description)
+
+                # Tags
+                tags = provider.get("tags", [])
+                if tags:
+                    st.markdown(" ".join([f"`{tag}`" for tag in tags[:5]]))
+
+                # Models
+                models = provider.get("models", [])
+                if models:
+                    with st.expander("Models"):
+                        for model in models[:10]:
+                            if isinstance(model, dict):
+                                st.text(f"- {model.get('id', model.get('name', 'unknown'))}")
+                            else:
+                                st.text(f"- {model}")
+                        if len(models) > 10:
+                            st.caption(f"...and {len(models) - 10} more")
+
+                # Metadata
+                metadata = provider.get("metadata", {})
+                if metadata:
+                    with st.expander("Details"):
+                        for key, value in list(metadata.items())[:5]:
+                            st.text(f"{key}: {value}")
+
+    # Refresh button
+    st.divider()
+    if st.button("Refresh Provider Status", use_container_width=True):
+        st.cache_data.clear()
+        st.rerun()

foundry_mcp/dashboard/views/sdd_workflow.py

@@ -0,0 +1,255 @@
+"""SDD Workflow page - spec progress, phase burndown, task tracking."""
+
+import streamlit as st
+
+from foundry_mcp.dashboard.components.cards import kpi_row
+from foundry_mcp.dashboard.components.charts import pie_chart, bar_chart, empty_chart
+
+# Try importing pandas
+try:
+    import pandas as pd
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+    pd = None
+
+
+def _get_specs():
+    """Get list of specifications."""
+    try:
+        from foundry_mcp.core.spec import list_specs
+        from foundry_mcp.config import get_config
+
+        config = get_config()
+        specs_dir = config.specs_dir
+        return list_specs(specs_dir)
+    except ImportError:
+        return []
+    except Exception:
+        return []
+
+
+def _get_spec_data(spec_id: str):
+    """Get detailed spec data."""
+    try:
+        from foundry_mcp.core.spec import load_spec
+        from foundry_mcp.config import get_config
+
+        config = get_config()
+        return load_spec(config.specs_dir, spec_id)
+    except Exception:
+        return None
+
+
+def _calculate_progress(spec_data: dict) -> dict:
+    """Calculate progress metrics from spec data."""
+    if not spec_data:
+        return {"total": 0, "completed": 0, "in_progress": 0, "pending": 0, "blocked": 0, "percentage": 0}
+
+    tasks = spec_data.get("tasks", {})
+    status_counts = {"completed": 0, "in_progress": 0, "pending": 0, "blocked": 0}
+
+    for task_id, task in tasks.items():
+        status = task.get("status", "pending")
+        if status in status_counts:
+            status_counts[status] += 1
+        else:
+            status_counts["pending"] += 1
+
+    total = sum(status_counts.values())
+    percentage = (status_counts["completed"] / total * 100) if total > 0 else 0
+
+    return {
+        "total": total,
+        **status_counts,
+        "percentage": percentage,
+    }
+
+
+def render():
+    """Render the SDD Workflow page."""
+    st.header("SDD Workflow")
+
+    # Get specs
+    specs = _get_specs()
+
+    if not specs:
+        st.info("No specifications found.")
+        st.caption("Create specs using `foundry-cli spec create` or the MCP spec-create tool.")
+        return
+
+    # Spec selector
+    spec_options = {s.get("title", s.get("id", "unknown")): s.get("id") for s in specs if isinstance(s, dict)}
+
+    if not spec_options:
+        st.warning("Could not parse specification list")
+        return
+
+    selected_title = st.selectbox(
+        "Select Specification",
+        options=list(spec_options.keys()),
+        key="sdd_spec_selector",
+    )
+
+    selected_id = spec_options.get(selected_title)
+    if not selected_id:
+        return
+
+    # Load spec data
+    spec_data = _get_spec_data(selected_id)
+    if not spec_data:
+        st.warning(f"Could not load spec: {selected_id}")
+        return
+
+    # Calculate progress
+    progress = _calculate_progress(spec_data)
+
+    st.divider()
+
+    # Progress overview
+    st.subheader("Progress Overview")
+
+    # Progress bar
+    st.progress(progress["percentage"] / 100, text=f"Overall Progress: {progress['percentage']:.1f}%")
+
+    # KPI cards
+    kpi_row(
+        [
+            {"label": "Total Tasks", "value": progress["total"]},
+            {"label": "Completed", "value": progress["completed"]},
+            {"label": "In Progress", "value": progress["in_progress"]},
+            {"label": "Pending", "value": progress["pending"]},
+            {"label": "Blocked", "value": progress["blocked"]},
+        ],
+        columns=5,
+    )
+
+    st.divider()
+
+    # Charts row
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("Task Status Distribution")
+        if PANDAS_AVAILABLE and progress["total"] > 0:
+            status_df = pd.DataFrame([
+                {"status": "completed", "count": progress["completed"]},
+                {"status": "in_progress", "count": progress["in_progress"]},
+                {"status": "pending", "count": progress["pending"]},
+                {"status": "blocked", "count": progress["blocked"]},
+            ])
+            status_df = status_df[status_df["count"] > 0]  # Filter zero counts
+
+            pie_chart(
+                status_df,
+                values="count",
+                names="status",
+                title=None,
+                height=300,
+            )
+        else:
+            empty_chart("No task data")
+
+    with col2:
+        st.subheader("Phase Progress")
+        phases = spec_data.get("phases", [])
+        if PANDAS_AVAILABLE and phases:
+            phase_data = []
+            for phase in phases:
+                if isinstance(phase, dict):
+                    phase_tasks = phase.get("tasks", [])
+                    completed = len([t for t in phase_tasks if isinstance(t, dict) and t.get("status") == "completed"])
+                    total = len(phase_tasks)
+                    phase_data.append({
+                        "phase": phase.get("title", phase.get("id", "unknown"))[:20],
+                        "completed": completed,
+                        "total": total,
+                        "percentage": (completed / total * 100) if total > 0 else 0,
+                    })
+
+            if phase_data:
+                phase_df = pd.DataFrame(phase_data)
+                bar_chart(
+                    phase_df,
+                    x="phase",
+                    y="percentage",
+                    title=None,
+                    height=300,
+                )
+            else:
+                empty_chart("No phase data")
+        else:
+            empty_chart("No phase data")
+
+    st.divider()
+
+    # Task list
+    st.subheader("Tasks")
+    tasks = spec_data.get("tasks", {})
+
+    if tasks:
+        # Status filter
+        status_filter = st.multiselect(
+            "Filter by Status",
+            options=["completed", "in_progress", "pending", "blocked"],
+            default=["in_progress", "pending", "blocked"],
+            key="task_status_filter",
+        )
+
+        # Build task list
+        task_list = []
+        for task_id, task in tasks.items():
+            if isinstance(task, dict):
+                status = task.get("status", "pending")
+                if status in status_filter:
+                    task_list.append({
+                        "id": task_id,
+                        "title": task.get("title", "Untitled"),
+                        "status": status,
+                        "estimated_hours": task.get("estimated_hours", 0),
+                        "actual_hours": task.get("actual_hours", 0),
+                    })
+
+        if task_list and PANDAS_AVAILABLE:
+            task_df = pd.DataFrame(task_list)
+            st.dataframe(
+                task_df,
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "id": st.column_config.TextColumn("ID", width="small"),
+                    "title": st.column_config.TextColumn("Title", width="large"),
+                    "status": st.column_config.TextColumn("Status", width="small"),
+                    "estimated_hours": st.column_config.NumberColumn("Est. Hours", format="%.1f", width="small"),
+                    "actual_hours": st.column_config.NumberColumn("Act. Hours", format="%.1f", width="small"),
+                },
+            )
+        elif task_list:
+            for t in task_list:
+                st.text(f"- [{t['status']}] {t['title']}")
+        else:
+            st.info("No tasks matching filter")
+    else:
+        st.info("No tasks defined in this spec")
+
+    # Time tracking summary
+    st.divider()
+    st.subheader("Time Tracking")
+
+    total_estimated = sum(t.get("estimated_hours", 0) for t in tasks.values() if isinstance(t, dict))
+    total_actual = sum(t.get("actual_hours", 0) for t in tasks.values() if isinstance(t, dict))
+    variance = total_actual - total_estimated
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Estimated Hours", f"{total_estimated:.1f}h")
+    with col2:
+        st.metric("Actual Hours", f"{total_actual:.1f}h")
+    with col3:
+        delta_color = "inverse" if variance > 0 else "normal"
+        st.metric(
+            "Variance",
+            f"{variance:+.1f}h",
+            delta=f"{(variance / total_estimated * 100):+.1f}%" if total_estimated > 0 else "N/A",
+            delta_color=delta_color,
+        )

foundry_mcp/dashboard/views/tool_usage.py

@@ -0,0 +1,139 @@
+"""Tool Usage page - detailed breakdown of tool and action invocations."""
+
+import streamlit as st
+
+from foundry_mcp.dashboard.components.filters import time_range_filter
+from foundry_mcp.dashboard.components.charts import bar_chart, pie_chart, empty_chart
+from foundry_mcp.dashboard.components.cards import kpi_row
+from foundry_mcp.dashboard.data.stores import (
+    get_tool_action_breakdown,
+    get_top_tool_actions,
+)
+
+# Try importing pandas
+try:
+    import pandas as pd
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+    pd = None
+
+
+def render():
+    """Render the Tool Usage page."""
+    st.header("Tool Usage")
+
+    # Time range filter
+    col1, col2 = st.columns([3, 1])
+    with col2:
+        hours = time_range_filter(key="tool_usage_time_range", default="24h")
+
+    st.divider()
+
+    # Get breakdown data
+    breakdown_df = get_tool_action_breakdown(since_hours=hours)
+
+    if breakdown_df is None or breakdown_df.empty:
+        st.warning("No tool usage data available. Data will appear once tools are invoked.")
+        st.info("Tool invocations are recorded when MCP tools are called.")
+        return
+
+    # KPI Summary
+    total_invocations = int(breakdown_df["count"].sum())
+    unique_tools = breakdown_df["tool"].nunique()
+    unique_actions = breakdown_df[breakdown_df["action"] != "(no action)"]["action"].nunique()
+    success_count = int(breakdown_df[breakdown_df["status"] == "success"]["count"].sum())
+    success_rate = (success_count / total_invocations * 100) if total_invocations > 0 else 0
+
+    kpi_row(
+        [
+            {"label": "Total Invocations", "value": f"{total_invocations:,}"},
+            {"label": "Unique Tools", "value": unique_tools},
+            {"label": "Unique Actions", "value": unique_actions},
+            {"label": "Success Rate", "value": f"{success_rate:.1f}%"},
+        ],
+        columns=4,
+    )
+
+    st.divider()
+
+    # Charts Row
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.subheader("Top Tools")
+        tool_totals = breakdown_df.groupby("tool")["count"].sum().reset_index()
+        tool_totals = tool_totals.sort_values("count", ascending=True).tail(10)
+        if not tool_totals.empty:
+            bar_chart(tool_totals, x="count", y="tool", orientation="h", height=350)
+        else:
+            empty_chart("No tool data")
+
+    with col2:
+        st.subheader("Status Distribution")
+        status_totals = breakdown_df.groupby("status")["count"].sum().reset_index()
+        if not status_totals.empty:
+            pie_chart(status_totals, values="count", names="status", height=350)
+        else:
+            empty_chart("No status data")
+
+    st.divider()
+
+    # Detailed Action Breakdown
+    st.subheader("Action Breakdown by Tool")
+
+    # Tool selector
+    tools = sorted(breakdown_df["tool"].unique())
+    selected_tool = st.selectbox(
+        "Select Tool",
+        options=["All Tools"] + tools,
+        key="tool_usage_tool_selector",
+    )
+
+    if selected_tool == "All Tools":
+        filtered_df = breakdown_df
+    else:
+        filtered_df = breakdown_df[breakdown_df["tool"] == selected_tool]
+
+    if not filtered_df.empty and PANDAS_AVAILABLE:
+        # Create display name column
+        action_df = filtered_df.groupby(["tool", "action", "status"])["count"].sum().reset_index()
+        action_df["display_name"] = action_df.apply(
+            lambda r: f"{r['tool']}.{r['action']}" if r["action"] != "(no action)" else r["tool"],
+            axis=1
+        )
+
+        # Detailed table
+        st.subheader("Detailed Data")
+        display_df = action_df[["display_name", "status", "count"]].sort_values("count", ascending=False)
+        st.dataframe(
+            display_df,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "display_name": st.column_config.TextColumn("Tool.Action", width="medium"),
+                "status": st.column_config.TextColumn("Status", width="small"),
+                "count": st.column_config.NumberColumn("Invocations", width="small"),
+            },
+        )
+
+        # Export options
+        col1, col2 = st.columns(2)
+        with col1:
+            csv = display_df.to_csv(index=False)
+            st.download_button(
+                label="Download CSV",
+                data=csv,
+                file_name="tool_usage_export.csv",
+                mime="text/csv",
+            )
+        with col2:
+            json_data = display_df.to_json(orient="records")
+            st.download_button(
+                label="Download JSON",
+                data=json_data,
+                file_name="tool_usage_export.json",
+                mime="application/json",
+            )
+    else:
+        empty_chart("No data for selected filter")

foundry_mcp/prompts/__init__.py

@@ -0,0 +1,9 @@
+"""
+MCP prompts for foundry-mcp.
+
+Provides prompt templates for common SDD workflows.
+"""
+
+from foundry_mcp.prompts.workflows import register_workflow_prompts
+
+__all__ = ["register_workflow_prompts"]