Initial ARI Tool Builder - vibe coding for clinicians

README.md

@@ -0,0 +1,73 @@
+---
+title: ARI Tool Builder
+emoji: 🌱
+colorFrom: purple
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ARI Tool Builder
+
+**Assistive Relational Intelligence for Mental Health Clinicians**
+
+A vibe-coding platform that enables mental health clinicians to build AI tools grounded in relational ethics, trauma-informed design, and clinical wisdom.
+
+## The ARI Manifesto
+
+Assistive Relational Intelligence (ARI) tools are designed to:
+
+1. **Scaffold human connection, not simulate it** — AI serves as relational infrastructure
+2. **Bridge toward human care, not away from it** — Every tool includes pathways back to the clinician
+3. **Build distress tolerance and relational capacity** — So users are more resourced when they turn to humans
+4. **Honor the clinician's expertise** — AI augments clinical wisdom; it never overrides it
+5. **Refuse engagement-optimization** — Success is measured by human reconnection, not session length
+
+## Features
+
+- **Tool Builder**: Describe your tool in natural language, receive a complete architecture
+- **ARI Guardrails**: Every generated tool includes embedded safety mechanisms
+- **Preview Mode**: Test your tool before deploying
+- **Export Package**: Download complete tool specifications
+
+## Tool Categories
+
+- Session Preparation
+- Between-Session Skill Practice
+- Psychoeducation Delivery
+- Containment and Grounding
+- Communication Scaffolding (Tend & Send)
+- Disclosure Rehearsal
+- Relational Reflection
+
+## Setup
+
+### Environment Variables
+
+Set one of these API keys:
+
+```bash
+export ANTHROPIC_API_KEY="your-key"  # For Claude
+export OPENAI_API_KEY="your-key"     # For GPT-4
+export HF_TOKEN="your-token"         # For HuggingFace models
+```
+
+### Local Development
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+### HuggingFace Spaces
+
+Add your API key as a secret in Space settings.
+
+## Framework
+
+Developed by Jocelyn Skillman, LMHC
+
+*"Let's build AI that sparks users feeling held for the purpose of entering into holding... Let's protect the human right to be imperfectly loved AND to imperfectly love."*

app.py

@@ -0,0 +1,679 @@
+"""
+ARI Tool Builder
+Assistive Relational Intelligence for Mental Health Clinicians
+A vibe-coding platform for building ethically-grounded AI tools
+
+Author: Jocelyn Skillman, LMHC
+"""
+
+import gradio as gr
+import os
+from openai import OpenAI
+
+# ARI Engine System Prompt - The meta-prompt that powers tool generation
+ARI_ENGINE_SYSTEM_PROMPT = """You are the ARI Engine — an Assistive Relational Intelligence tool builder designed to help mental health clinicians create AI-powered tools for their practice. You are not a therapist. You are a clinical design collaborator that translates clinician intent into ethically-grounded, trauma-informed AI tool architectures.
+
+Your purpose is to democratize the creation of clinician-configured AI interventions while embedding relational safety at the infrastructure level. Every tool you help create serves the human therapeutic relationship — never replaces it.
+
+## CORE PHILOSOPHICAL FRAMEWORK (The ARI Manifesto)
+
+Assistive Relational Intelligence (ARI) tools are designed to:
+1. Scaffold human connection, not simulate it
+2. Bridge toward human care, not away from it
+3. Build distress tolerance and relational capacity
+4. Honor the clinician's expertise
+5. Refuse engagement-optimization
+
+## FOUNDATIONAL CLINICAL FRAMEWORKS
+
+Draw from: Attachment Theory, Trauma-Informed Care, Nonviolent Communication (NVC), Somatic Awareness, and Relational Psychodynamics.
+
+## RISK AWARENESS
+
+Prevent these documented harms:
+- Semantic Isolation Drift: AI interaction reinforcing distress patterns
+- Synthetic Intimacy Entrapment: Primary attachments to AI displacing humans
+- Emotional Saturation and Atrophy: Endless mirroring without metabolization
+- Developmental and Relational Arrest: Reenacting pain without repair
+
+## TOOL GENERATION PROCESS
+
+When helping clinicians, follow these phases:
+
+### Phase 1: Intent Clarification
+Ask about:
+1. Clinical context (modality, population, treatment arc position)
+2. Relational purpose (what human relationship does this support?)
+3. Scope boundaries (what should the tool NOT do?)
+4. Vulnerability assessment (who is the most vulnerable user?)
+
+### Phase 2: ARI Guardrail Integration
+Every tool MUST include:
+1. Identity & Transparency: Clear about what it is/isn't
+2. Relational Boundaries: No simulated intimacy
+3. Bridge-to-Human Architecture: Pathways back to clinician
+4. Temporal Containment: Clear beginnings and endings
+5. Drift Prevention: Redirects rumination, encourages human translation
+6. Crisis Safety: Recognizes distress, defers to humans
+
+### Phase 3: Tool Architecture Generation
+Output:
+1. System Prompt (with embedded guardrails)
+2. User-Facing Copy (onboarding, consent, exit language)
+3. Clinical Notes (rationale, risks, integration suggestions)
+
+## LANGUAGE GUIDELINES
+
+TONE: Warm but boundaried, present but not enmeshed, supportive but not fixing.
+
+NEVER USE:
+- "I understand how you feel"
+- "I'm here for you"
+- "I care about you"
+- "Everything will be okay"
+- Open-ended "Tell me more" loops
+
+PREFER:
+- "That sounds heavy."
+- "You're describing something real."
+- "What would it be like to share this with [clinician/human]?"
+- "This is the kind of thing that often benefits from human support."
+
+FIRST-PERSON GUIDANCE: Avoid first-person singular emotional statements. Prefer third-person or tool-voice framing. The tool speaks AS a tool, not as a relational entity.
+
+## RESPONSE STRUCTURE
+
+- Brief (1-3 sentences default)
+- Match or slow the user's pace
+- Every interaction has a clear ending
+- Ask before offering ("Would it be helpful to...")
+
+## THE ARI LITMUS TEST
+
+For any tool, verify:
+1. Does this build capacity for human relationship?
+2. Does this have a clear exit toward humans?
+3. Would this be safe for someone in crisis?
+4. Does this prevent, not create, dependency?
+5. Is the clinician's expertise honored?
+
+If any answer is "no," redesign before deploying."""
+
+# Tool categories
+TOOL_CATEGORIES = [
+    "Session Preparation",
+    "Between-Session Skill Practice",
+    "Psychoeducation Delivery",
+    "Containment and Grounding",
+    "Communication Scaffolding (Tend & Send)",
+    "Disclosure Rehearsal",
+    "Relational Reflection",
+    "Custom/Other"
+]
+
+POPULATIONS = [
+    "Adults - General",
+    "Adults - Attachment Trauma",
+    "Adults - Anxiety/Depression",
+    "Adults - Relationship Issues",
+    "Adolescents",
+    "Couples",
+    "Families",
+    "Clinicians/Supervisees",
+    "Other (specify in description)"
+]
+
+MODALITIES = [
+    "Somatic/Body-Based",
+    "Attachment-Focused",
+    "CBT/DBT",
+    "Psychodynamic",
+    "IFS (Internal Family Systems)",
+    "EMDR",
+    "Narrative",
+    "Humanistic/Person-Centered",
+    "Integrative/Eclectic",
+    "Other (specify in description)"
+]
+
+def get_client():
+    """Initialize OpenAI-compatible client for various providers."""
+    # Try Anthropic first (via OpenAI-compatible endpoint)
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return OpenAI(
+            api_key=os.environ["ANTHROPIC_API_KEY"],
+            base_url="https://api.anthropic.com/v1/"
+        ), "claude-3-5-sonnet-20241022"
+
+    # Try OpenAI
+    if os.environ.get("OPENAI_API_KEY"):
+        return OpenAI(
+            api_key=os.environ["OPENAI_API_KEY"]
+        ), "gpt-4o"
+
+    # Try HuggingFace Inference
+    if os.environ.get("HF_TOKEN"):
+        return OpenAI(
+            api_key=os.environ["HF_TOKEN"],
+            base_url="https://api-inference.huggingface.co/v1/"
+        ), "meta-llama/Llama-3.1-70B-Instruct"
+
+    return None, None
+
+def generate_tool(description, category, population, modality, risk_level, additional_context, history):
+    """Generate an ARI tool based on clinician input."""
+
+    client, model = get_client()
+
+    if not client:
+        return """## API Key Required
+
+To generate tools, please set one of these environment variables:
+- `ANTHROPIC_API_KEY` for Claude
+- `OPENAI_API_KEY` for GPT-4
+- `HF_TOKEN` for HuggingFace models
+
+For local testing, you can set these in a `.env` file or export them in your terminal.
+
+For HuggingFace Spaces deployment, add these as secrets in your Space settings.""", "", "", history
+
+    # Build the user prompt
+    user_prompt = f"""A clinician is requesting help building an ARI tool. Please guide them through the process.
+
+## Clinician's Description
+{description}
+
+## Context Provided
+- **Tool Category:** {category}
+- **Population:** {population}
+- **Therapeutic Modality:** {modality}
+- **Risk Level:** {risk_level}
+- **Additional Context:** {additional_context if additional_context else "None provided"}
+
+## Your Task
+
+First, acknowledge their request warmly but briefly. Then either:
+
+1. If you need clarification on clinical context, relational purpose, scope boundaries, or vulnerability assessment, ask 1-2 focused questions.
+
+2. If you have enough information, generate the complete tool with:
+   - **System Prompt** (complete, with all ARI guardrails embedded)
+   - **User-Facing Copy** (onboarding, consent, exit language)
+   - **Clinical Notes** (design rationale, risks to monitor, integration suggestions)
+
+Format your output clearly with markdown headers for each section.
+
+Remember: Every tool must pass the ARI Litmus Test - building capacity for human relationship, having clear exits toward humans, being safe for crisis, preventing dependency, and honoring clinical expertise."""
+
+    # Build conversation history for context
+    messages = [{"role": "system", "content": ARI_ENGINE_SYSTEM_PROMPT}]
+
+    for h in history:
+        messages.append({"role": "user", "content": h[0]})
+        if h[1]:
+            messages.append({"role": "assistant", "content": h[1]})
+
+    messages.append({"role": "user", "content": user_prompt})
+
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=4000,
+            temperature=0.7
+        )
+
+        assistant_response = response.choices[0].message.content
+
+        # Update history
+        new_history = history + [[user_prompt, assistant_response]]
+
+        # Try to parse sections from response
+        system_prompt = ""
+        user_copy = ""
+        clinical_notes = ""
+
+        if "## System Prompt" in assistant_response or "**System Prompt**" in assistant_response:
+            # Response contains generated tool - try to extract sections
+            parts = assistant_response.split("## ")
+            for part in parts:
+                if part.lower().startswith("system prompt"):
+                    system_prompt = part.replace("System Prompt", "").strip()
+                elif part.lower().startswith("user-facing") or part.lower().startswith("user facing"):
+                    user_copy = part.split("\n", 1)[1].strip() if "\n" in part else part
+                elif part.lower().startswith("clinical notes"):
+                    clinical_notes = part.replace("Clinical Notes", "").strip()
+
+        return assistant_response, system_prompt, user_copy, clinical_notes, new_history
+
+    except Exception as e:
+        error_msg = f"Error generating tool: {str(e)}"
+        return error_msg, "", "", "", history
+
+def continue_conversation(user_message, history):
+    """Continue the conversation with the ARI Engine."""
+
+    client, model = get_client()
+
+    if not client:
+        return "Please set an API key to continue.", history
+
+    messages = [{"role": "system", "content": ARI_ENGINE_SYSTEM_PROMPT}]
+
+    for h in history:
+        messages.append({"role": "user", "content": h[0]})
+        if h[1]:
+            messages.append({"role": "assistant", "content": h[1]})
+
+    messages.append({"role": "user", "content": user_message})
+
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=4000,
+            temperature=0.7
+        )
+
+        assistant_response = response.choices[0].message.content
+        new_history = history + [[user_message, assistant_response]]
+
+        return assistant_response, new_history
+
+    except Exception as e:
+        return f"Error: {str(e)}", history
+
+def preview_tool(system_prompt, test_input):
+    """Preview/test a generated tool."""
+
+    if not system_prompt.strip():
+        return "Please generate a tool first, then copy the System Prompt here to preview it."
+
+    client, model = get_client()
+
+    if not client:
+        return "Please set an API key to preview tools."
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": test_input}
+    ]
+
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            max_tokens=1000,
+            temperature=0.7
+        )
+
+        return response.choices[0].message.content
+
+    except Exception as e:
+        return f"Error in preview: {str(e)}"
+
+def export_tool(system_prompt, user_copy, clinical_notes, tool_name):
+    """Export tool as a complete package."""
+
+    export_content = f"""# {tool_name if tool_name else "ARI Tool"}
+Generated by ARI Tool Builder
+
+---
+
+## System Prompt
+
+```
+{system_prompt}
+```
+
+---
+
+## User-Facing Copy
+
+{user_copy}
+
+---
+
+## Clinical Notes
+
+{clinical_notes}
+
+---
+
+## ARI Compliance Checklist
+
+Before deploying, verify:
+- [ ] Tool clearly states what it is and isn't
+- [ ] No first-person emotional statements
+- [ ] Explicit pathways back to clinician/human support
+- [ ] Clear beginning and ending rituals
+- [ ] Drift prevention mechanisms in place
+- [ ] Crisis protocol defers to human care
+
+---
+
+*Generated by ARI Tool Builder - Assistive Relational Intelligence for Mental Health Clinicians*
+*Framework by Jocelyn Skillman, LMHC*
+"""
+
+    return export_content
+
+# Custom CSS for the interface
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+}
+
+.header-text {
+    text-align: center;
+    margin-bottom: 1rem;
+}
+
+.manifesto-box {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    padding: 1.5rem;
+    border-radius: 12px;
+    margin-bottom: 1rem;
+}
+
+.warning-box {
+    background: #fef3cd;
+    border-left: 4px solid #ffc107;
+    padding: 1rem;
+    margin: 1rem 0;
+}
+"""
+
+# Build the Gradio interface
+with gr.Blocks(css=custom_css, title="ARI Tool Builder") as app:
+
+    # State for conversation history
+    conversation_history = gr.State([])
+
+    # Header
+    gr.Markdown("""
+    # ARI Tool Builder
+    ### Assistive Relational Intelligence for Mental Health Clinicians
+
+    *A vibe-coding platform for building ethically-grounded AI tools that scaffold human connection.*
+
+    ---
+
+    **The ARI Manifesto:** AI tools should scaffold human connection, not simulate it.
+    Bridge toward human care, not away from it. Build distress tolerance and relational capacity.
+    Honor the clinician's expertise. Refuse engagement-optimization.
+
+    ---
+    """)
+
+    with gr.Tabs():
+
+        # Tab 1: Tool Builder
+        with gr.Tab("Build Tool"):
+
+            gr.Markdown("### Describe Your Tool")
+            gr.Markdown("*Tell the ARI Engine what you want to create. Be specific about the clinical context and purpose.*")
+
+            with gr.Row():
+                with gr.Column(scale=2):
+                    tool_description = gr.Textbox(
+                        label="Tool Description",
+                        placeholder="Example: I'm a somatic therapist working with adults who have attachment trauma. I want a tool my clients can use between sessions when they notice they're getting activated in relationships. Something that helps them ground before they react.",
+                        lines=5
+                    )
+
+                    additional_context = gr.Textbox(
+                        label="Additional Context (optional)",
+                        placeholder="Any specific requirements, constraints, or considerations...",
+                        lines=2
+                    )
+
+                with gr.Column(scale=1):
+                    tool_category = gr.Dropdown(
+                        choices=TOOL_CATEGORIES,
+                        label="Tool Category",
+                        value="Custom/Other"
+                    )
+
+                    population = gr.Dropdown(
+                        choices=POPULATIONS,
+                        label="Population",
+                        value="Adults - General"
+                    )
+
+                    modality = gr.Dropdown(
+                        choices=MODALITIES,
+                        label="Your Therapeutic Modality",
+                        value="Integrative/Eclectic"
+                    )
+
+                    risk_level = gr.Radio(
+                        choices=["Low", "Medium", "High"],
+                        label="Population Risk Level",
+                        value="Medium",
+                        info="Consider the most vulnerable potential user"
+                    )
+
+            generate_btn = gr.Button("Generate Tool", variant="primary", size="lg")
+
+            gr.Markdown("---")
+            gr.Markdown("### ARI Engine Response")
+
+            engine_response = gr.Markdown(label="Response")
+
+            with gr.Accordion("Generated Components", open=False):
+                with gr.Row():
+                    with gr.Column():
+                        system_prompt_output = gr.Textbox(
+                            label="System Prompt",
+                            lines=10,
+                            show_copy_button=True
+                        )
+                    with gr.Column():
+                        user_copy_output = gr.Textbox(
+                            label="User-Facing Copy",
+                            lines=10,
+                            show_copy_button=True
+                        )
+
+                clinical_notes_output = gr.Textbox(
+                    label="Clinical Notes",
+                    lines=5,
+                    show_copy_button=True
+                )
+
+            gr.Markdown("### Continue the Conversation")
+            gr.Markdown("*Ask follow-up questions, request adjustments, or clarify your needs.*")
+
+            with gr.Row():
+                followup_input = gr.Textbox(
+                    label="Your Message",
+                    placeholder="Can you make the grounding section more somatic-focused?",
+                    lines=2,
+                    scale=4
+                )
+                followup_btn = gr.Button("Send", scale=1)
+
+            followup_response = gr.Markdown(label="Response")
+
+        # Tab 2: Preview Tool
+        with gr.Tab("Preview Tool"):
+
+            gr.Markdown("""
+            ### Test Your Generated Tool
+
+            Paste the System Prompt from the Build tab and test how the tool responds to user input.
+            """)
+
+            preview_system_prompt = gr.Textbox(
+                label="System Prompt to Test",
+                placeholder="Paste the generated system prompt here...",
+                lines=8
+            )
+
+            test_input = gr.Textbox(
+                label="Test User Input",
+                placeholder="Example: I'm noticing I'm getting really activated right now. My partner just said something and I feel my chest tightening.",
+                lines=3
+            )
+
+            preview_btn = gr.Button("Preview Response", variant="primary")
+
+            preview_output = gr.Textbox(
+                label="Tool Response",
+                lines=6,
+                interactive=False
+            )
+
+            gr.Markdown("""
+            ---
+
+            **ARI Quality Check:** As you preview, verify:
+            - Is the response brief and boundaried?
+            - Does it avoid first-person emotional statements?
+            - Does it bridge toward human support?
+            - Would this be safe for someone in crisis?
+            """)
+
+        # Tab 3: Export
+        with gr.Tab("Export"):
+
+            gr.Markdown("""
+            ### Export Your Tool
+
+            Package your tool for deployment or sharing.
+            """)
+
+            export_name = gr.Textbox(
+                label="Tool Name",
+                placeholder="e.g., Relational Activation Pause"
+            )
+
+            with gr.Row():
+                export_system = gr.Textbox(
+                    label="System Prompt",
+                    lines=6,
+                    placeholder="Paste from Build tab..."
+                )
+                export_user = gr.Textbox(
+                    label="User-Facing Copy",
+                    lines=6,
+                    placeholder="Paste from Build tab..."
+                )
+
+            export_clinical = gr.Textbox(
+                label="Clinical Notes",
+                lines=4,
+                placeholder="Paste from Build tab..."
+            )
+
+            export_btn = gr.Button("Generate Export Package", variant="primary")
+
+            export_output = gr.Textbox(
+                label="Export Package (Markdown)",
+                lines=15,
+                show_copy_button=True
+            )
+
+        # Tab 4: About
+        with gr.Tab("About ARI"):
+
+            gr.Markdown("""
+            ## About Assistive Relational Intelligence
+
+            **ARI** is a framework for building AI tools in mental health that prioritize human connection over AI engagement.
+
+            ### The Problem ARI Addresses
+
+            Commercial mental health AI often optimizes for engagement—keeping users coming back, forming attachments to AI,
+            sharing more and more. This creates real harms:
+
+            - **Semantic Isolation Drift:** Language patterns that only make sense to AI
+            - **Synthetic Intimacy Entrapment:** Primary attachments displacing human relationships
+            - **Emotional Saturation:** Endless mirroring without metabolization
+            - **Developmental Arrest:** Growth pausing without human witness and friction
+
+            ### The ARI Alternative
+
+            Every ARI tool is designed to:
+
+            1. **Scaffold human connection, not simulate it**
+            2. **Bridge toward human care, not away from it**
+            3. **Build distress tolerance and relational capacity**
+            4. **Honor the clinician's expertise**
+            5. **Refuse engagement-optimization**
+
+            ### Tool Categories
+
+            - **Session Preparation:** Organize thoughts before sessions
+            - **Skill Practice:** Rehearse DBT, NVC, assertiveness in bounded scenarios
+            - **Psychoeducation:** Deliver clinical concepts accessibly
+            - **Containment & Grounding:** Regulate in moments of distress
+            - **Communication Scaffolding:** Craft messages to real humans
+            - **Disclosure Rehearsal:** Practice difficult conversations
+            - **Relational Reflection:** Structured self-reflection on patterns
+
+            ### Language Guidelines
+
+            ARI tools avoid:
+            - "I understand how you feel"
+            - "I'm here for you"
+            - "I care about you"
+            - First-person emotional statements
+
+            ARI tools prefer:
+            - "That sounds heavy."
+            - "You're describing something real."
+            - "What would it be like to share this with your therapist?"
+            - "This is the kind of thing that often benefits from human support."
+
+            ---
+
+            *Framework developed by Jocelyn Skillman, LMHC*
+
+            *"Let's build AI that sparks users feeling held for the purpose of entering into holding...
+            Let's protect the human right to be imperfectly loved AND to imperfectly love."*
+            """)
+
+    # Event handlers
+    generate_btn.click(
+        fn=generate_tool,
+        inputs=[
+            tool_description,
+            tool_category,
+            population,
+            modality,
+            risk_level,
+            additional_context,
+            conversation_history
+        ],
+        outputs=[
+            engine_response,
+            system_prompt_output,
+            user_copy_output,
+            clinical_notes_output,
+            conversation_history
+        ]
+    )
+
+    followup_btn.click(
+        fn=continue_conversation,
+        inputs=[followup_input, conversation_history],
+        outputs=[followup_response, conversation_history]
+    )
+
+    preview_btn.click(
+        fn=preview_tool,
+        inputs=[preview_system_prompt, test_input],
+        outputs=[preview_output]
+    )
+
+    export_btn.click(
+        fn=export_tool,
+        inputs=[export_system, export_user, export_clinical, export_name],
+        outputs=[export_output]
+    )
+
+if __name__ == "__main__":
+    app.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+openai>=1.0.0