Update app.py

app.py

@@ -1,275 +1,191 @@
-import json
 import os
 import gradio as gr
+from typing import List, Tuple, Optional
 
 from src.dataset_client import DatasetAPIClient
-from src.state_machine import StateMachine, State
-from src.command_parser import CommandParser, ParsedCommand
+from src.state_machine import StateMachine, State, CardType
 from src.card_generator import CardGenerator
-from src.yaml_validator import validate_card_yaml
+from src.command_parser import CommandParser
 
 
-# =========================
-# Config
-# =========================
-
-# Optional Space variable (recommended):
-# MIN DSEYE_DATASET = PeacebinfLow/mindseye-lab-ledger
 DATASET_ID = os.getenv("MINDSEYE_DATASET", "PeacebinfLow/mindseye-lab-ledger").strip()
-
-# Optional: config name if you ever introduce configs
 DATASET_CONFIG = os.getenv("MINDSEYE_CONFIG", "default").strip()
 
-# Prevent giant history explosions
-MAX_HISTORY_JSON_CHARS = int(os.getenv("MINDSEYE_MAX_HISTORY_JSON_CHARS", "12000"))
-
-
-# =========================
-# Runtime components
-# =========================
-
-client = DatasetAPIClient(dataset=DATASET_ID)
+client = DatasetAPIClient(dataset=DATASET_ID, config=DATASET_CONFIG)
 sm = StateMachine()
+gen = CardGenerator()
 parser = CommandParser()
-generator = CardGenerator(template_dir="templates")
-
-
-# =========================
-# Helpers
-# =========================
-
-def _bounded_json(obj, max_chars: int = 12000) -> str:
-    """Pretty JSON but truncated."""
-    try:
-        s = json.dumps(obj, indent=2, ensure_ascii=False)
-    except Exception:
-        s = json.dumps({"error": "Could not serialize JSON"}, indent=2)
-    if len(s) > max_chars:
-        return s[:max_chars] + "\n...(truncated)"
-    return s
-
 
-def export_last_card(card_yaml: str):
-    """Write latest YAML into artifacts and return filepath for Gradio File component."""
-    os.makedirs("artifacts", exist_ok=True)
-    path = os.path.join("artifacts", "mindseye_card.yaml")
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(card_yaml or "")
-    return path
 
+HELP_TEXT = (
+    "Commands:\n"
+    "- MODE <STATE> | CARD <TYPE> | RUN <query> | TEST | LEDGER | RESET | STATE | HELP\n\n"
+    "Dataset ops:\n"
+    "- RUN <query> -> search train\n"
+    "- TEST -> first rows\n"
+    "- LEDGER -> rows page\n"
+)
 
-HELP_TEXT = """### Commands
 
-**Core**
-- `MODE <STATE>`: Switch active state  
-- `RESET`: Return to CORE_OS and clear context  
-- `STATE`: Show current state  
-- `HELP`: Show help text  
+def process_command(command: str, history: List[Tuple[str, str]]):
+    history = history or []
+    parsed = parser.parse(command)
 
-**Dataset**
-- `SPLITS`: List dataset splits  
-- `FIRST <split> <limit>`: Get first rows preview  
-- `ROWS <split> <offset> <length>`: Get rows window  
-- `SEARCH <split> <query>`: Full-text search  
-- `FILTER <split> <where>`: SQL-like filter  
-
-**Cards**
-- `CARD <TYPE>`: Force card type (CONCEPT/FLOW/SPEC/TEST/BUILD)  
-- `EXPORT`: Export latest YAML card as a file  
-
-**Examples**
-- `MODE LEDGER_CORE`
-- `SEARCH train WORKFLOW_`
-- `FILTER train event_type = 'WORKFLOW_COMPLETED'`
-- `ROWS train 0 25`
-"""
-
-
-def process_command(command: str, history_md: str, forced_state: str, forced_card_type: str):
-    command = (command or "").strip()
-    history_md = history_md or ""
-
-    # Quick state dropdown override (optional)
-    if forced_state and forced_state in [s.value for s in State]:
-        # set state without adding noisy history unless it truly changes
-        if forced_state != sm.current_state.value:
-            sm.set_state(forced_state)
-
-    parsed: ParsedCommand = parser.parse(command)
+    if not parsed["valid"]:
+        card = gen.generate_error_card(sm.current_state, parsed.get("error", "Invalid command"))
+        history.append((command, card))
+        return card, None, history
 
+    result = sm.transition(command)
     dataset_result = None
 
-    # Core commands
-    if parsed.kind == "HELP":
-        # Display help but still return a card
-        dataset_result = {"help": HELP_TEXT}
-
-    elif parsed.kind == "STATE":
-        dataset_result = {"state": sm.current_state.value, "history_depth": len(sm.history)}
-
-    elif parsed.kind == "MODE":
-        sm.transition(f"MODE {parsed.arg1 or ''}")
-
-    elif parsed.kind == "RESET":
-        sm.transition("RESET")
-
-    elif parsed.kind == "CARD":
-        # store override
-        sm.context["forced_card_type"] = (parsed.arg1 or "").upper()
-
-    # Dataset operations
-    try:
-        if parsed.kind == "SPLITS":
-            dataset_result = {"splits": client.list_splits()}
-
-        elif parsed.kind == "FIRST":
-            split = parsed.arg1 or "train"
-            limit = int(parsed.arg2 or 100)
-            dataset_result = client.get_first_rows(split=split, limit=limit, config=DATASET_CONFIG)
-
-        elif parsed.kind == "ROWS":
-            split = parsed.arg1 or "train"
-            offset = int(parsed.arg2 or 0)
-            length = int(parsed.arg3 or 25)
-            dataset_result = client.get_rows(split=split, offset=offset, length=length, config=DATASET_CONFIG)
-
-        elif parsed.kind == "SEARCH":
-            split = parsed.arg1 or "train"
-            query = parsed.rest or ""
-            dataset_result = client.search_dataset(query=query, split=split, config=DATASET_CONFIG)
-
-        elif parsed.kind == "FILTER":
-            split = parsed.arg1 or "train"
-            where = parsed.rest or ""
-            dataset_result = client.filter_dataset(where=where, split=split, config=DATASET_CONFIG)
-
-    except Exception as e:
-        dataset_result = {
-            "error": str(e),
-            "dataset": DATASET_ID,
-            "config": DATASET_CONFIG,
-            "parsed": parsed.to_dict(),
-            "state": sm.current_state.value,
-        }
-
-    # Card type resolution
-    if forced_card_type and forced_card_type != "AUTO":
-        card_type = forced_card_type
-    else:
-        card_type = sm.get_output_type()
-
-    # Hard override via CARD command
-    if sm.context.get("forced_card_type"):
-        card_type = sm.context["forced_card_type"]
-
-    # Generate YAML card
-    card_yaml = generator.generate(
-        state=sm.current_state.value,
-        card_type=card_type,
-        dataset_result=dataset_result,
-        lock_on=True,
-        version="1.0.0",
-        card_id="HUGGINGFACE_SPACE_RUNTIME",
-    )
-
-    # Validate YAML shape (non-fatal; annotate)
-    valid, errors = validate_card_yaml(card_yaml)
-    if not valid:
-        card_yaml += "\n\n# VALIDATION_ERRORS:\n"
-        for err in errors:
-            card_yaml += f"# - {err}\n"
-
-    # History
-    new_history = history_md
-    if command:
-        new_history += f"\n\n> `{command}`\n\n```yaml\n{card_yaml}\n```\n"
-        if dataset_result is not None:
-            new_history += (
-                "\n<details><summary>Raw JSON</summary>\n\n```json\n"
-                + _bounded_json(dataset_result, MAX_HISTORY_JSON_CHARS)
-                + "\n```\n</details>\n"
-            )
+    cmd = parsed["command"]
+    arg = parsed.get("argument") or ""
+
+    # Handle HELP/STATE explicitly
+    if cmd == "HELP":
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=CardType.CONCEPT,
+            title="Help",
+            description="Available commands and usage.",
+            content={"HELP": HELP_TEXT, "STATE": sm.current_state.value},
+        )
+        history.append((command, card))
+        return card, {"help": HELP_TEXT}, history
+
+    if cmd == "STATE":
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=CardType.SPEC,
+            title="Runtime State",
+            description="Current runtime state snapshot.",
+            content={"STATE": sm.current_state.value, "HISTORY_DEPTH": len(sm.history)},
+        )
+        history.append((command, card))
+        return card, {"state": sm.current_state.value}, history
+
+    # Dataset query commands
+    if cmd == "RUN":
+        if arg:
+            dataset_result = client.search_dataset(query=arg, split="train")
+        else:
+            dataset_result = {"error": "RUN requires a query string", "rows": []}
+
+    elif cmd == "TEST":
+        dataset_result = client.get_first_rows(split="train", limit=10)
+
+    elif cmd == "LEDGER":
+        dataset_result = client.get_rows(split="train", offset=0, length=25)
+
+    # Card type selection
+    card_type = sm.get_output_card_type()
+
+    # Build card content depending on action
+    if result["action"] == "transition":
+        allowed = [ct.value for ct in sm.STATE_CARD_MAPPING[sm.current_state]]
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=card_type,
+            title=f"{sm.current_state.value} Module",
+            description=f"Entered {sm.current_state.value}",
+            content={"STATE_INFO": sm.current_state.value, "AVAILABLE_CARDS": allowed},
+            dataset_result=dataset_result,
+            context_links=[f"{sm.current_state.value}.overview"],
+            next_actions=["RUN <query>", "TEST", "LEDGER", "RESET"],
+        )
+
+    elif result["action"] == "query":
+        rows = dataset_result.get("rows", []) if isinstance(dataset_result, dict) else []
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=CardType.SPEC,
+            title="Dataset Query Results",
+            description=f"Query executed: {command}",
+            content={"QUERY": command, "RESULTS_COUNT": len(rows), "SAMPLE": rows[:3]},
+            dataset_result=dataset_result,
+            context_links=["LEDGER_CORE.query_engine"],
+            next_actions=["RUN <new-query>", "RESET"],
+        )
+
+    elif result["action"] == "filter":
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=CardType.SPEC,
+            title="Card Filter Set",
+            description=f"Forced card type: {result.get('card_type')}",
+            content={"FILTER": result},
+            next_actions=["RUN <query>", "MODE <state>", "RESET"],
+        )
+
+    elif result["action"] == "reset":
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=CardType.CONCEPT,
+            title="Reset",
+            description="Returned to CORE_OS and cleared runtime context.",
+            content={"RESET": True},
+            next_actions=["MODE LEDGER_CORE", "RUN <query>", "HELP"],
+        )
 
-    # Return updated UI state dropdown value too (sync)
-    return card_yaml, dataset_result, new_history, sm.current_state.value
+    else:
+        card = gen.generate(
+            state=sm.current_state,
+            card_type=card_type,
+            title="Command Processed",
+            description=f"Action: {result.get('action')}",
+            content={"RESULT": result},
+            dataset_result=dataset_result,
+            next_actions=["HELP", "RESET"],
+        )
 
+    history.append((command, card))
+    return card, dataset_result, history
 
-# =========================
-# UI
-# =========================
 
-with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# 🧠 MindsEye Lab — Stateful OS Runtime")
+with gr.Blocks(title="MindsEye Lab", theme=gr.themes.Monochrome()) as app:
     gr.Markdown(
+        "# 🧠 MindsEye Lab - Stateful OS Runtime\n"
+        "Deterministic runtime that queries a dataset and emits locked YAML cards.\n\n"
         f"**Dataset:** `{DATASET_ID}`  •  **Config:** `{DATASET_CONFIG}`"
     )
 
     with gr.Row():
-        with gr.Column(scale=2):
+        with gr.Column(scale=3):
             command_input = gr.Textbox(
                 label="Command",
-                placeholder="MODE LEDGER_CORE | SEARCH train WORKFLOW_ | FILTER train event_type = 'WORKFLOW_COMPLETED'",
+                placeholder="MODE LEDGER_CORE | RUN WORKFLOW_ | TEST | LEDGER | RESET",
                 lines=1,
             )
-            with gr.Row():
-                submit_btn = gr.Button("Execute", variant="primary")
-                help_btn = gr.Button("HELP")
-                reset_btn = gr.Button("RESET")
-                export_btn = gr.Button("EXPORT")
-
         with gr.Column(scale=1):
-            state_selector = gr.Dropdown(
-                choices=[s.value for s in State],
-                label="Quick State Switch",
-                value=sm.current_state.value,
-            )
-            card_type_selector = gr.Dropdown(
-                choices=["AUTO", "CONCEPT", "FLOW", "SPEC", "TEST", "BUILD"],
-                label="Card Type",
-                value="AUTO",
-            )
+            submit_btn = gr.Button("Execute", variant="primary")
+
+    gr.Markdown("### Quick Commands")
+    with gr.Row():
+        gr.Button("MODE LEDGER_CORE").click(lambda: "MODE LEDGER_CORE", None, command_input)
+        gr.Button("MODE BUILD_SPACE").click(lambda: "MODE BUILD_SPACE", None, command_input)
+        gr.Button("TEST").click(lambda: "TEST", None, command_input)
+        gr.Button("LEDGER").click(lambda: "LEDGER", None, command_input)
+        gr.Button("RESET").click(lambda: "RESET", None, command_input)
 
-    card_output = gr.Code(label="YAML Card Response", language="yaml", lines=28)
+    card_output = gr.Code(label="YAML Card Response", language="yaml", lines=30)
 
     with gr.Accordion("Dataset Results (Raw JSON)", open=False):
         dataset_output = gr.JSON(label="Query Results")
 
-    history_output = gr.Markdown(label="Session History", value="")
-
-    export_file = gr.File(label="Exported YAML")
+    chat = gr.Chatbot(label="Session History", height=320)
 
-    def _help_click():
-        return process_command("HELP", history_output.value or "", state_selector.value, card_type_selector.value)
-
-    def _reset_click():
-        return process_command("RESET", history_output.value or "", state_selector.value, card_type_selector.value)
-
-    def _export_click(card_yaml: str):
-        return export_last_card(card_yaml)
-
-    # Buttons
     submit_btn.click(
         fn=process_command,
-        inputs=[command_input, history_output, state_selector, card_type_selector],
-        outputs=[card_output, dataset_output, history_output, state_selector],
-    )
-
-    help_btn.click(
-        fn=lambda: process_command("HELP", history_output.value or "", state_selector.value, card_type_selector.value),
-        inputs=[],
-        outputs=[card_output, dataset_output, history_output, state_selector],
-    )
-
-    reset_btn.click(
-        fn=lambda: process_command("RESET", history_output.value or "", state_selector.value, card_type_selector.value),
-        inputs=[],
-        outputs=[card_output, dataset_output, history_output, state_selector],
+        inputs=[command_input, chat],
+        outputs=[card_output, dataset_output, chat],
     )
 
-    export_btn.click(
-        fn=_export_click,
-        inputs=[card_output],
-        outputs=[export_file],
+    command_input.submit(
+        fn=process_command,
+        inputs=[command_input, chat],
+        outputs=[card_output, dataset_output, chat],
     )
 
-demo.launch()
+if __name__ == "__main__":
+    app.launch()