Create app.py

app.py

@@ -0,0 +1,481 @@
+import json
+import textwrap
+import io
+from typing import Dict, Any, List, Tuple
+
+import gradio as gr
+import requests
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+
+
+# -----------------------------
+# LLM CALL HELPERS
+# -----------------------------
+
+def call_chat_completion(
+    api_key: str,
+    base_url: str,
+    model: str,
+    system_prompt: str,
+    user_prompt: str,
+    temperature: float = 0.3,
+    max_tokens: int = 1800,
+) -> str:
+    """
+    Generic OpenAI-compatible chat completion call using HTTP.
+    Supports providers that mimic the /v1/chat/completions API.
+    """
+    if not api_key:
+        raise ValueError("API key is required.")
+
+    if not base_url:
+        base_url = "https://api.openai.com"  # default
+
+    url = base_url.rstrip("/") + "/v1/chat/completions"
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": model,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+    }
+
+    resp = requests.post(url, headers=headers, json=payload, timeout=60)
+    if resp.status_code != 200:
+        raise RuntimeError(
+            f"LLM API error: {resp.status_code} - {resp.text[:400]}"
+        )
+
+    data = resp.json()
+    try:
+        return data["choices"][0]["message"]["content"]
+    except Exception as e:
+        raise RuntimeError(f"Unexpected LLM response format: {e}\n\n{data}")
+
+
+# -----------------------------
+# SOP GENERATION LOGIC
+# -----------------------------
+
+SOP_SYSTEM_PROMPT = """
+You are an expert operations consultant and technical writer.
+
+You generate **clear, professional, and implementation-ready Standard Operating Procedures (SOPs)**.
+
+The user will give:
+- A title or short description of the process
+- Context about the organization or scenario
+- Optional industry, tone, and detail level
+
+You MUST respond **strictly as JSON**, with no extra commentary, using this schema:
+
+{
+  "title": "string",
+  "purpose": "string",
+  "scope": "string",
+  "definitions": ["string", ...],
+  "roles": [
+    {
+      "name": "string",
+      "responsibilities": ["string", ...]
+    }
+  ],
+  "prerequisites": ["string", ...],
+  "steps": [
+    {
+      "step_number": 1,
+      "title": "string",
+      "description": "string",
+      "owner_role": "string",
+      "inputs": ["string", ...],
+      "outputs": ["string", ...]
+    }
+  ],
+  "escalation": ["string", ...],
+  "metrics": ["string", ...],
+  "risks": ["string", ...],
+  "versioning": {
+    "version": "1.0",
+    "owner": "string",
+    "last_updated": "string"
+  }
+}
+
+Constraints:
+- Make steps specific, observable, and sequential.
+- Use inclusive, professional language.
+- Assume this will be used by mid-career professionals.
+- Keep lists between 3 and 8 items unless the user asks for more.
+"""
+
+
+def build_user_prompt(
+    sop_title: str,
+    description: str,
+    industry: str,
+    tone: str,
+    detail_level: str,
+) -> str:
+    pieces = [
+        f"Process title: {sop_title or 'Untitled SOP'}",
+        f"Context / description: {description or 'N/A'}",
+        f"Industry: {industry or 'General'}",
+        f"Tone: {tone or 'Professional'}",
+        f"Detail level: {detail_level or 'Standard'}",
+        "Audience: Mid-career professionals who already understand basic workplace concepts but need clear structure and ownership.",
+    ]
+    return "\n".join(pieces)
+
+
+def parse_sop_json(raw_text: str) -> Dict[str, Any]:
+    """
+    Attempt to parse the LLM output as JSON.
+    Also handles cases where the model wrapped the JSON in code fences.
+    """
+    text = raw_text.strip()
+
+    # Strip markdown fences if present
+    if text.startswith("```"):
+        # Remove leading ```json or ```
+        text = text.split("```", 2)
+        if len(text) == 3:
+            text = text[1] if "{" in text[1] else text[2]
+        else:
+            text = text[-1]
+    text = text.strip()
+
+    # Try to find the first '{' and last '}' to extract JSON
+    first_brace = text.find("{")
+    last_brace = text.rfind("}")
+    if first_brace != -1 and last_brace != -1:
+        text = text[first_brace : last_brace + 1]
+
+    return json.loads(text)
+
+
+def sop_to_markdown(sop: Dict[str, Any]) -> str:
+    """Render the SOP JSON into a readable Markdown document."""
+    def bullet_list(items: List[str]) -> str:
+        if not items:
+            return "_None specified._"
+        return "\n".join(f"- {i}" for i in items)
+
+    md = []
+
+    md.append(f"# {sop.get('title', 'Standard Operating Procedure')}\n")
+
+    md.append("## 1. Purpose")
+    md.append(sop.get("purpose", "_No purpose provided._"))
+
+    md.append("\n## 2. Scope")
+    md.append(sop.get("scope", "_No scope provided._"))
+
+    definitions = sop.get("definitions", [])
+    md.append("\n## 3. Definitions")
+    md.append(bullet_list(definitions))
+
+    roles = sop.get("roles", [])
+    md.append("\n## 4. Roles & Responsibilities")
+    if roles:
+        for role in roles:
+            name = role.get("name", "Role")
+            responsibilities = role.get("responsibilities", [])
+            md.append(f"### {name}")
+            md.append(bullet_list(responsibilities))
+    else:
+        md.append("_No roles specified._")
+
+    prereq = sop.get("prerequisites", [])
+    md.append("\n## 5. Prerequisites")
+    md.append(bullet_list(prereq))
+
+    steps = sop.get("steps", [])
+    md.append("\n## 6. Procedure (Step-by-Step)")
+    if steps:
+        for step in steps:
+            num = step.get("step_number", "?")
+            title = step.get("title", "Step")
+            owner = step.get("owner_role", "Owner")
+            desc = step.get("description", "")
+            inputs = step.get("inputs", [])
+            outputs = step.get("outputs", [])
+            md.append(f"### Step {num}: {title}")
+            md.append(f"**Owner:** {owner}")
+            md.append(desc or "_No description provided._")
+            if inputs:
+                md.append("**Inputs:**")
+                md.append(bullet_list(inputs))
+            if outputs:
+                md.append("**Outputs:**")
+                md.append(bullet_list(outputs))
+    else:
+        md.append("_No steps provided._")
+
+    md.append("\n## 7. Escalation")
+    md.append(bullet_list(sop.get("escalation", [])))
+
+    md.append("\n## 8. Metrics & Success Criteria")
+    md.append(bullet_list(sop.get("metrics", [])))
+
+    md.append("\n## 9. Risks & Controls")
+    md.append(bullet_list(sop.get("risks", [])))
+
+    versioning = sop.get("versioning", {})
+    md.append("\n## 10. Version Control")
+    md.append(f"- Version: {versioning.get('version', '1.0')}")
+    md.append(f"- Owner: {versioning.get('owner', 'Not specified')}")
+    md.append(f"- Last Updated: {versioning.get('last_updated', 'Not specified')}")
+
+    return "\n\n".join(md)
+
+
+# -----------------------------
+# INFOGRAPHIC / DATA VISUAL
+# -----------------------------
+
+def create_sop_steps_figure(sop: Dict[str, Any]) -> Figure:
+    """
+    Create a simple infographic-like matplotlib figure showing the SOP steps
+    as a vertical flow with numbered boxes.
+    """
+    steps = sop.get("steps", [])
+    if not steps:
+        fig, ax = plt.subplots(figsize=(6, 2))
+        ax.text(
+            0.5,
+            0.5,
+            "No steps available to visualize.",
+            ha="center",
+            va="center",
+            fontsize=12,
+            wrap=True,
+        )
+        ax.axis("off")
+        return fig
+
+    n = len(steps)
+    fig_height = max(3, n * 1.0)
+    fig, ax = plt.subplots(figsize=(7, fig_height))
+
+    y_positions = list(reversed(range(n)))  # top to bottom
+
+    for idx, (step, y) in enumerate(zip(steps, y_positions)):
+        num = step.get("step_number", idx + 1)
+        title = step.get("title", f"Step {num}")
+        owner = step.get("owner_role", "")
+        desc = step.get("description", "")
+
+        # Clamp description length
+        desc_short = textwrap.shorten(desc, width=120, placeholder="...")
+
+        # Draw a rounded rectangle as a "card"
+        x0, x1 = 0.05, 0.95
+        y0, y1 = y - 0.3, y + 0.3
+
+        ax.add_patch(
+            plt.Rectangle(
+                (x0, y0),
+                x1 - x0,
+                y1 - y0,
+                fill=False,
+                linewidth=1.5,
+                linestyle="-",
+            )
+        )
+        # Number bubble
+        ax.text(
+            x0 + 0.02,
+            y,
+            f"{num}",
+            va="center",
+            ha="left",
+            fontsize=11,
+            fontweight="bold",
+        )
+
+        # Title & owner
+        ax.text(
+            x0 + 0.12,
+            y + 0.15,
+            title,
+            va="center",
+            ha="left",
+            fontsize=11,
+            fontweight="bold",
+        )
+        if owner:
+            ax.text(
+                x0 + 0.12,
+                y,
+                f"Owner: {owner}",
+                va="center",
+                ha="left",
+                fontsize=9,
+                style="italic",
+            )
+
+        # Description
+        ax.text(
+            x0 + 0.12,
+            y - 0.18,
+            desc_short,
+            va="top",
+            ha="left",
+            fontsize=9,
+            wrap=True,
+        )
+
+    ax.set_ylim(-1, n)
+    ax.axis("off")
+    fig.tight_layout()
+    return fig
+
+
+# -----------------------------
+# SAMPLE PRESETS
+# -----------------------------
+
+SAMPLE_SOPS = {
+    "Volunteer Onboarding Workflow": {
+        "title": "Volunteer Onboarding Workflow",
+        "description": (
+            "Create a clear SOP for onboarding new volunteers at a youth-serving "
+            "nonprofit. Include background checks, orientation, training, and site placement."
+        ),
+        "industry": "Nonprofit / Youth Development",
+    },
+    "New Employee Remote Onboarding": {
+        "title": "Remote Employee Onboarding",
+        "description": (
+            "Design a remote onboarding SOP for new employees in a hybrid org, including "
+            "IT setup, HR paperwork, culture onboarding, and 30-60-90 day milestones."
+        ),
+        "industry": "General / HR",
+    },
+    "Incident Response - IT Outage": {
+        "title": "IT Outage Incident Response",
+        "description": (
+            "An SOP for responding to major IT outages affecting multiple sites, "
+            "including triage, communication, escalation, and post-mortem."
+        ),
+        "industry": "IT / Operations",
+    },
+}
+
+
+def load_sample(sample_name: str) -> Tuple[str, str, str]:
+    if not sample_name or sample_name not in SAMPLE_SOPS:
+        return "", "", "General"
+    sample = SAMPLE_SOPS[sample_name]
+    return (
+        sample.get("title", ""),
+        sample.get("description", ""),
+        sample.get("industry", "General"),
+    )
+
+
+# -----------------------------
+# MAIN GENERATION FUNCTION (UI HOOK)
+# -----------------------------
+
+def generate_sop_ui(
+    api_key_state: str,
+    api_key_input: str,
+    base_url: str,
+    model_name: str,
+    sop_title: str,
+    description: str,
+    industry: str,
+    tone: str,
+    detail_level: str,
+) -> Tuple[str, str, Figure, str]:
+    """
+    Main Gradio handler:
+    - Picks API key (state vs input)
+    - Calls LLM
+    - Parses JSON
+    - Returns Markdown SOP, raw JSON, figure, and updated key state
+    """
+    api_key = api_key_input or api_key_state
+    if not api_key:
+        return (
+            "⚠️ Please enter an API key in the settings panel.",
+            "",
+            create_sop_steps_figure({"steps": []}),
+            api_key_state,
+        )
+
+    if not model_name:
+        model_name = "gpt-4.1-mini"
+
+    user_prompt = build_user_prompt(sop_title, description, industry, tone, detail_level)
+
+    try:
+        raw_response = call_chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model_name,
+            system_prompt=SOP_SYSTEM_PROMPT,
+            user_prompt=user_prompt,
+            temperature=0.25,
+            max_tokens=1800,
+        )
+
+        sop_json = parse_sop_json(raw_response)
+        sop_md = sop_to_markdown(sop_json)
+        fig = create_sop_steps_figure(sop_json)
+        pretty_json = json.dumps(sop_json, indent=2, ensure_ascii=False)
+
+        # Save key in state for this session only
+        return sop_md, pretty_json, fig, api_key
+
+    except Exception as e:
+        error_msg = f"❌ Error generating SOP:\n\n{e}"
+        fig = create_sop_steps_figure({"steps": []})
+        return error_msg, "", fig, api_key_state
+
+
+# -----------------------------
+# BUILD GRADIO APP
+# -----------------------------
+
+with gr.Blocks(title="ZEN Simple SOP Builder") as demo:
+    gr.Markdown(
+        """
+# 🧭 ZEN Simple SOP Builder
+
+Generate clean, professional Standard Operating Procedures (SOPs) from a short description.  
+Perfect for mid-career professionals who need **clarity, structure, and ownership** — fast.
+
+1. Configure your API settings  
+2. Describe the process you want to document  
+3. Generate a full SOP + visual flow of the steps
+
+> Your API key is stored only in your session state and **never logged or saved to disk**.
+"""
+    )
+
+    api_key_state = gr.State("")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Step 1: API & Model Settings")
+
+            api_key_input = gr.Textbox(
+                label="LLM API Key",
+                placeholder="Enter your API key (OpenAI, compatible provider, etc.)",
+                type="password",
+            )
+            base_url = gr.Textbox(
+                label="Base URL (optional)",
+                value="https://api.openai.com",
+                placeholder="e.g. https://api.openai.com or your custom OpenAI