app.py

"""
Gradio application for SFOSR (Semantic Formal Ontology Structure Representation) System.

Provides an interface to analyze, verify, and construct proofs using the SFOSR framework.
"""

import gradio as gr
import json
import os
from sfosr_core.sfosr_system import SFOSRSystem # Assuming sfosr_system.py is in sfosr_core

# --- Configuration ---
DB_PATH = "sfosr.db" # Assumes the database is in the root directory

# Check if DB exists, otherwise handle appropriately (e.g., log an error)
if not os.path.exists(DB_PATH):
    print(f"Error: Database file not found at {DB_PATH}. Please ensure it exists.")
    # In a real scenario, you might want to exit or provide a way to upload/create it.
    sfosr_instance = None # Indicate that the system is not ready
else:
    # --- Initialize SFOSR System ---
    try:
        sfosr_instance = SFOSRSystem(db_path=DB_PATH)
        print("SFOSR System initialized successfully.")
    except Exception as e:
        print(f"Error initializing SFOSR System: {e}")
        sfosr_instance = None # Indicate that the system failed to initialize

# --- Helper Functions for Gradio ---

def handle_system_unavailable():
    """Returns an error message if the SFOSR system isn't ready."""
    return "SFOSR System is not available. Please check server logs.", "", "", ""

def process_input_json(json_string):
    """Safely parse input JSON string."""
    if not json_string:
        return None, "Input JSON cannot be empty."
    try:
        data = json.loads(json_string)
        if not isinstance(data, dict):
            return None, "Input must be a valid JSON object (dictionary)."
        if "vectors" not in data or not isinstance(data["vectors"], list):
             return None, "Input JSON must contain a 'vectors' key with a list of vectors."
        # Add more validation as needed (e.g., text key)
        return data, None
    except json.JSONDecodeError as e:
        return None, f"Invalid JSON format: {e}"
    except Exception as e:
        return None, f"Error processing input: {e}"

def run_analysis_verification(input_json_str):
    """Gradio function to run analysis and verification."""
    if sfosr_instance is None:
        return handle_system_unavailable()

    input_data, error = process_input_json(input_json_str)
    if error:
        return f"Input Error: {error}", "", "", ""

    try:
        # Use the main process method which handles both analysis and verification
        result = sfosr_instance.process(input_data)

        # Format the output
        analysis_summary = f"**Analysis Status:** {result.get('analysis', {}).get('status', 'N/A')}\n" \
                           f"**Compilable:** {result.get('analysis', {}).get('is_compilable', 'N/A')}\n" \
                           f"**Graph Metrics:** {result.get('analysis', {}).get('graph_metrics', {})}"

        verification_summary = f"**Total Vectors Processed:** {result.get('verification', {}).get('total_vectors', 0)}\n" \
                               f"**Valid Vectors:** {result.get('verification', {}).get('valid_count', 0)}\n" \
                               f"**Compliance Rate:** {result.get('verification', {}).get('compliance_rate', 0.0):.2f}"

        vector_details = result.get('verification', {}).get('vectors_data', {})

        # Optional: Add graph visualization logic here later
        graph_output = "Graph visualization placeholder"

        return analysis_summary, verification_summary, vector_details, graph_output

    except Exception as e:
        print(f"Error during SFOSR processing: {e}") # Log for debugging
        return f"An error occurred: {e}", "", "", ""

def run_proof_construction(input_json_str, source_concept, target_concept):
    """Gradio function to run proof construction."""
    if sfosr_instance is None:
        return handle_system_unavailable()[:1] + ("",) # Only return one value for proof status

    input_data, error = process_input_json(input_json_str)
    if error:
        return f"Input Error: {error}", ""

    if not source_concept or not target_concept:
        return "Source and Target concepts cannot be empty.", ""

    # Add the proof query to the input data
    input_data["proof_query"] = {
        "source": source_concept,
        "target": target_concept
    }

    try:
        # Use the main process method - it includes proof if query exists
        result = sfosr_instance.process(input_data)

        proof_result = result.get("proof")

        if not proof_result:
             # This might happen if the process function structure changes or proof wasn't run
             return "Proof was not attempted or failed silently.", ""

        proof_status = f"**Proof Status:** {proof_result.get('status', 'N/A')}\n" \
                       f"**Is Valid:** {proof_result.get('is_valid', 'N/A')}"
        if proof_result.get('reason'):
            proof_status += f"\n**Reason:** {proof_result.get('reason')}"

        proof_details = proof_result # Return the whole proof structure for now

        return proof_status, proof_details

    except Exception as e:
        print(f"Error during SFOSR proof: {e}") # Log for debugging
        return f"An error occurred: {e}", ""


# --- Gradio Interface Definition ---

with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown(
        """
        # SFOSR: Semantic Formal Ontology Structure Representation
        Interact with the SFOSR system to analyze, verify semantic structures,
        and construct formal proofs based on input vectors.
        Provide input data in the specified JSON format.
        [Link to GitHub Repo - Placeholder]
        """
    )

    with gr.Tabs():
        with gr.TabItem("Analyze & Verify"):
            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### Input Data (JSON)")
                    input_json_av = gr.Textbox(
                        lines=15,
                        label="SFOSR JSON Input",
                        info="Paste the JSON containing 'text' (optional) and 'vectors' (required list).",
                        placeholder='{\n  "text": "Example context...",\n  "vectors": [\n    {\n      "id": "V1",\n      "source": "ConceptA",\n      "target": "ConceptB",\n      "type": "Causality",\n      "axis": "relationship",\n      "justification": "A causes B based on evidence X."\n    }\n    // ... more vectors\n  ],\n "instance_definitions": {\n    "Inst1": {"is_a": "ConceptA", "label": "My Instance"}\n }\n}'
                    )
                    av_button = gr.Button("Run Analysis & Verification", variant="primary")
                with gr.Column(scale=1):
                    gr.Markdown("### Analysis Summary")
                    analysis_output = gr.Markdown()
                    gr.Markdown("### Verification Summary")
                    verification_output = gr.Markdown()
                    gr.Markdown("### Vector Verification Details")
                    vector_details_output = gr.JSON(label="Vector Details")
                    gr.Markdown("### Concept Graph (Placeholder)")
                    graph_placeholder_output = gr.Textbox(label="Graph Info") # Placeholder

            # Add examples later using gr.Examples
            # gr.Examples(
            #     examples=[
            #         [sample_json_1],
            #         [sample_json_2]
            #      ],
            #     inputs=input_json_av
            # )

        with gr.TabItem("Construct Proof"):
            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### Input Data & Query (JSON)")
                    input_json_p = gr.Textbox(
                        lines=10,
                        label="SFOSR JSON Context",
                        info="Paste the JSON containing 'vectors' to be used as premises.",
                         placeholder='{\n  "vectors": [\n    {\n      "id": "V1", "source": "A", "target": "B", "type": "Implication", "axis": "logic", "is_valid": true \n    },\n    {\n      "id": "V2", "source": "B", "target": "C", "type": "Implication", "axis": "logic", "is_valid": true \n    }\n  ]\n}'
                    )
                    source_concept_input = gr.Textbox(label="Source Concept", info="The starting concept for the proof.")
                    target_concept_input = gr.Textbox(label="Target Concept", info="The concept to prove reachability for.")
                    p_button = gr.Button("Find Proof", variant="primary")
                with gr.Column(scale=1):
                     gr.Markdown("### Proof Result")
                     proof_status_output = gr.Markdown()
                     gr.Markdown("### Proof Details / Path")
                     proof_details_output = gr.JSON(label="Proof Structure")

            # Add examples later using gr.Examples

    # --- Event Handlers ---
    if sfosr_instance: # Only wire up buttons if the system initialized
        av_button.click(
            fn=run_analysis_verification,
            inputs=[input_json_av],
            outputs=[analysis_output, verification_output, vector_details_output, graph_placeholder_output]
        )

        p_button.click(
            fn=run_proof_construction,
            inputs=[input_json_p, source_concept_input, target_concept_input],
            outputs=[proof_status_output, proof_details_output]
        )
    else:
         # Display a persistent error if the system couldn't load
         gr.Markdown("**Error: SFOSR System failed to initialize. Cannot run operations. Check logs.**")


# --- Launch the App ---
if __name__ == "__main__":
    demo.launch() # Share=True for public link if needed