app.py

import pandas as pd
import streamlit as st

from core.ai_runtime_graph import generate_runtime_system
from core.cascade_engine import cascade_simulation
from core.coordination_cost_engine import coordination_cost_scores
from core.distortion_engine import reality_distortion_scores
from core.fragility_engine import fragility_scores, simulate_node_failure
from core.governance_engine import admissibility_check
from core.graph_engine import build_graph, graph_summary
from core.history import load_history, save_history
from core.latency_engine import calculate_latency_paths, node_latency_scores
from core.signal_engine import simulate_signal_propagation
from core.visualization import plot_operational_graph

st.set_page_config(page_title="Operational Systems Intelligence", layout="wide")
st.title("🧠 Operational Systems Intelligence")
st.caption("AI-assisted operational coordination and sociotechnical systems modeling.")

with st.sidebar:
    st.header("Runtime Model")
    use_ai = st.toggle("Use OpenAI if API key exists", value=False)
    prompt = st.text_area("Describe the system", "Model Hungary during an energy crisis affecting healthcare and logistics.", height=140)
    run = st.button("Generate / Refresh System")

if run or "system" not in st.session_state:
    st.session_state.system = generate_runtime_system(prompt, use_ai=use_ai)

system = st.session_state.system
graph = build_graph(system)
summary = graph_summary(graph)

cols = st.columns(4)
cols[0].metric("Nodes", summary.get("nodes", 0))
cols[1].metric("Dependencies", summary.get("dependencies", 0))
cols[2].metric("Graph Density", summary.get("density", 0))
cols[3].metric("Top Bottleneck", ", ".join(summary.get("top_bottlenecks", [])[:1]))

tabs = st.tabs(["Graph", "Signal vs Noise", "Decision Latency", "Fragility", "Reality Distortion", "Governance", "Cascade Simulation", "History"])

with tabs[0]:
    st.subheader("Operational Systems Graph")
    st.plotly_chart(plot_operational_graph(graph), use_container_width=True)
    st.subheader("Nodes")
    st.dataframe(pd.DataFrame([vars(n) for n in system.nodes]), use_container_width=True)
    st.subheader("Dependencies")
    st.dataframe(pd.DataFrame([vars(d) for d in system.dependencies]), use_container_width=True)

with tabs[1]:
    st.subheader("Signal Propagation")
    st.dataframe(pd.DataFrame(simulate_signal_propagation(system)), use_container_width=True)

with tabs[2]:
    st.subheader("Node Latency Scores")
    st.dataframe(pd.DataFrame(node_latency_scores(graph)), use_container_width=True)
    node_ids = list(graph.nodes)
    if len(node_ids) >= 2:
        source = st.selectbox("Source", node_ids, index=0)
        target = st.selectbox("Target", node_ids, index=min(1, len(node_ids) - 1))
        st.json(calculate_latency_paths(graph, source, target))

with tabs[3]:
    st.subheader("Fragility Scores")
    st.dataframe(pd.DataFrame(fragility_scores(graph)), use_container_width=True)
    failed_node = st.selectbox("Simulate node failure", list(graph.nodes), key="failed_node")
    st.dataframe(pd.DataFrame(simulate_node_failure(graph, failed_node)), use_container_width=True)

with tabs[4]:
    st.subheader("Reality Distortion Index")
    st.dataframe(pd.DataFrame(reality_distortion_scores(graph)), use_container_width=True)

with tabs[5]:
    st.subheader("Governance Boundary Check")
    actor = st.selectbox("Actor node", list(graph.nodes), key="actor_node")
    action_risk = st.slider("Action risk", 0.0, 1.0, 0.55)
    required_authority = st.slider("Required authority", 0.0, 1.0, 0.70)
    st.json(admissibility_check(graph, actor, action_risk, required_authority))
    st.subheader("Coordination Cost")
    st.dataframe(pd.DataFrame(coordination_cost_scores(graph)), use_container_width=True)

with tabs[6]:
    st.subheader("Cascade Simulation")
    start_node = st.selectbox("Start shock at node", list(graph.nodes), key="cascade_start")
    shock = st.slider("Initial shock", 0.0, 1.0, 0.45)
    decay = st.slider("Propagation decay", 0.1, 1.0, 0.62)
    cascade_rows = cascade_simulation(graph, start_node, initial_shock=shock, decay=decay)
    st.dataframe(pd.DataFrame(cascade_rows), use_container_width=True)
    if st.button("Save scenario to history"):
        save_history({"prompt": prompt, "start_node": start_node, "initial_shock": shock, "decay": decay, "summary": summary})
        st.success("Scenario saved.")

with tabs[7]:
    st.subheader("Scenario History")
    history = load_history()
    if history:
        st.dataframe(pd.DataFrame(history), use_container_width=True)
    else:
        st.info("No saved scenarios yet.")