Add Streamlit-based Content Manager GUI and runner script

Author: DerekGooding

modules/contentManager/app.py

@@ -0,0 +1,133 @@
+import streamlit as st
+import pandas as pd
+from data_io import ContentManager
+import subprocess
+import os
+
+st.set_page_config(page_title="Mythril Content Manager", layout="wide")
+
+if 'manager' not in st.session_state:
+    st.session_state.manager = ContentManager()
+
+manager = st.session_state.manager
+
+st.sidebar.title("💎 Mythril CMS")
+page = st.sidebar.selectbox("Navigate", ["Quests", "Items", "Cadences", "Locations", "Refinements", "Stats"])
+
+if st.sidebar.button("💾 Save All Changes"):
+    manager.save_all()
+    st.sidebar.success("Saved to JSON files (Backup created)")
+
+if st.sidebar.button("🔨 Compile & Verify"):
+    with st.spinner("Compiling content graph..."):
+        res1 = subprocess.run(["python", "scripts/migrate_to_graph.py"], capture_output=True, text=True)
+        res2 = subprocess.run(["python", "scripts/verify_graph.py"], capture_output=True, text=True)
+        
+        if res1.returncode == 0:
+            st.sidebar.success("Compiled successfully")
+        else:
+            st.sidebar.error(f"Migration Error: {res1.stderr}")
+            
+        if res2.returncode == 0:
+            st.sidebar.success("Graph verified")
+        else:
+            st.sidebar.error(f"Verification Failed:\n{res2.stdout}")
+
+def edit_list(data_list, key_prefix):
+    new_list = []
+    for i, item in enumerate(data_list):
+        col1, col2, col3 = st.columns([3, 2, 1])
+        with col1:
+            name = st.selectbox(f"Item {i}", [i["Name"] for i in manager.unified_data["items"]], 
+                               index=[i["Name"] for i in manager.unified_data["items"]].index(item["Item"]) if item["Item"] in [i["Name"] for i in manager.unified_data["items"]] else 0,
+                               key=f"{key_prefix}_name_{i}")
+        with col2:
+            qty = st.number_input(f"Qty {i}", value=item["Quantity"], min_value=1, key=f"{key_prefix}_qty_{i}")
+        with col3:
+            if st.button("🗑️", key=f"{key_prefix}_del_{i}"):
+                continue
+        new_list.append({"Item": name, "Quantity": qty})
+    
+    if st.button("➕ Add Entry", key=f"{key_prefix}_add"):
+        new_list.append({"Item": manager.unified_data["items"][0]["Name"], "Quantity": 1})
+        st.rerun()
+    return new_list
+
+# --- Page Rendering ---
+
+st.title(f"Manage {page}")
+
+data = manager.unified_data[page.lower()]
+df = pd.DataFrame(data)
+
+search = st.text_input(f"Search {page}...", "")
+if search:
+    df = df[df['Name'].str.contains(search, case=False)]
+
+selected_name = st.selectbox(f"Select {page} to Edit", ["-- New --"] + df['Name'].tolist())
+
+if selected_name == "-- New --":
+    if st.button(f"Create New {page}"):
+        new_item = {"Name": "New " + page, "Description": ""}
+        if page == "Quests":
+            new_item.update({"DurationSeconds": 10, "Type": "Single", "Requirements": [], "Rewards": [], "PrimaryStat": "Vitality", "RequiredStats": {}, "StatRewards": {}, "Requires": [], "UnlocksCadences": []})
+        elif page == "Items":
+            new_item.update({"ItemType": "Material", "Augments": []})
+        manager.unified_data[page.lower()].append(new_item)
+        st.rerun()
+
+else:
+    item = next(i for i in data if i["Name"] == selected_name)
+    
+    with st.form(f"edit_{page}_{selected_name}"):
+        st.subheader(f"Editing: {selected_name}")
+        
+        name = st.text_input("Name", item["Name"])
+        description = st.text_area("Description", item.get("Description", ""))
+        
+        if page == "Quests":
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                duration = st.number_input("Duration (s)", value=item["DurationSeconds"])
+            with col2:
+                q_type = st.selectbox("Type", ["Single", "Recurring", "Unlock"], index=["Single", "Recurring", "Unlock"].index(item["Type"]))
+            with col3:
+                stat = st.selectbox("Primary Stat", [s["Name"] for s in manager.unified_data["stats"]], index=[s["Name"] for s in manager.unified_data["stats"]].index(item["PrimaryStat"]))
+            
+            st.write("---")
+            st.subheader("Unlocks & Dependencies")
+            requires = st.multiselect("Prerequisite Quests", [q["Name"] for q in manager.unified_data["quests"] if q["Name"] != name], default=item["Requires"])
+            unlocks_c = st.multiselect("Unlocks Cadences", [c["Name"] for c in manager.unified_data["cadences"]], default=item["UnlocksCadences"])
+            
+            # Complex nested data (Requirements/Rewards) are hard in standard Streamlit forms 
+            # so we'll just show them as JSON for now or implement outside form
+            st.info("Requirements and Rewards are managed below the form for technical reasons.")
+
+        if page == "Items":
+            i_type = st.selectbox("Type", ["Material", "Currency", "Consumable", "Spell", "KeyItem"], index=["Material", "Currency", "Consumable", "Spell", "KeyItem"].index(item["ItemType"]))
+            
+        if st.form_submit_button("Update Basic Info"):
+            item["Name"] = name
+            item["Description"] = description
+            if page == "Quests":
+                item["DurationSeconds"] = duration
+                item["Type"] = q_type
+                item["PrimaryStat"] = stat
+                item["Requires"] = requires
+                item["UnlocksCadences"] = unlocks_c
+            if page == "Items":
+                item["ItemType"] = i_type
+            st.success("Updated basic info in memory.")
+            st.rerun()
+
+    # Nested data management outside the form
+    if page == "Quests":
+        st.subheader("📦 Requirements")
+        item["Requirements"] = edit_list(item["Requirements"], "req")
+        st.subheader("💎 Rewards")
+        item["Rewards"] = edit_list(item["Rewards"], "rew")
+
+    if st.button("🔥 Delete Entity", type="secondary"):
+        manager.unified_data[page.lower()].remove(item)
+        st.warning(f"Deleted {selected_name} from memory.")
+        st.rerun()

modules/contentManager/data_io.py

@@ -0,0 +1,144 @@
+import json
+import os
+import shutil
+from datetime import datetime
+
+DATA_DIR = "Mythril.Blazor/wwwroot/data"
+
+class ContentManager:
+    def __init__(self, data_dir=DATA_DIR):
+        self.data_dir = data_dir
+        self.raw_data = {}
+        self.unified_data = {
+            "items": [],
+            "quests": [],
+            "cadences": [],
+            "locations": [],
+            "refinements": [],
+            "stats": []
+        }
+        self.load_all()
+
+    def _load_json(self, filename):
+        path = os.path.join(self.data_dir, filename)
+        if not os.path.exists(path):
+            return []
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    def load_all(self):
+        # Load raw files
+        files = [
+            "items.json", "stat_augments.json", "quests.json", 
+            "quest_details.json", "quest_unlocks.json", 
+            "quest_cadence_unlocks.json", "cadences.json", 
+            "locations.json", "refinements.json", "stats.json"
+        ]
+        for f in files:
+            self.raw_data[f] = self._load_json(f)
+
+        self._unify_items()
+        self._unify_quests()
+        self._unify_cadences()
+        self._unify_locations()
+        self._unify_refinements()
+        self._unify_stats()
+
+    def _unify_items(self):
+        augments = { a["Item"]: a["Augments"] for a in self.raw_data["stat_augments.json"] }
+        self.unified_data["items"] = []
+        for item in self.raw_data["items.json"]:
+            item_copy = item.copy()
+            item_copy["Augments"] = augments.get(item["Name"], [])
+            self.unified_data["items"].append(item_copy)
+
+    def _unify_quests(self):
+        details = { d["Quest"]: d for d in self.raw_data["quest_details.json"] }
+        unlocks = { u["Quest"]: u["Requires"] for u in self.raw_data["quest_unlocks.json"] }
+        cadence_unlocks = { q["Quest"]: q["Cadences"] for q in self.raw_data["quest_cadence_unlocks.json"] }
+        
+        self.unified_data["quests"] = []
+        for quest in self.raw_data["quests.json"]:
+            q_name = quest["Name"]
+            q_detail = details.get(q_name, {})
+            
+            unified_q = {
+                "Name": q_name,
+                "Description": quest.get("Description", ""),
+                "DurationSeconds": q_detail.get("DurationSeconds", 10),
+                "Type": q_detail.get("Type", "Single"),
+                "Requirements": q_detail.get("Requirements", []),
+                "Rewards": q_detail.get("Rewards", []),
+                "PrimaryStat": q_detail.get("PrimaryStat", "Vitality"),
+                "RequiredStats": q_detail.get("RequiredStats", {}),
+                "StatRewards": q_detail.get("StatRewards", {}),
+                "Requires": unlocks.get(q_name, []),
+                "UnlocksCadences": cadence_unlocks.get(q_name, [])
+            }
+            self.unified_data["quests"].append(unified_q)
+
+    def _unify_cadences(self):
+        self.unified_data["cadences"] = [c.copy() for c in self.raw_data["cadences.json"]]
+
+    def _unify_locations(self):
+        self.unified_data["locations"] = [l.copy() for l in self.raw_data["locations.json"]]
+
+    def _unify_refinements(self):
+        self.unified_data["refinements"] = [r.copy() for r in self.raw_data["refinements.json"]]
+
+    def _unify_stats(self):
+        self.unified_data["stats"] = [s.copy() for s in self.raw_data["stats.json"]]
+
+    def save_all(self):
+        # Create backup
+        backup_dir = os.path.join(self.data_dir, "backups", datetime.now().strftime("%Y%m%d_%H%M%S"))
+        os.makedirs(backup_dir, exist_ok=True)
+        for f in self.raw_data.keys():
+            src = os.path.join(self.data_dir, f)
+            if os.path.exists(src):
+                shutil.copy(src, os.path.join(backup_dir, f))
+
+        # Split unified data back into files
+        new_items = []
+        new_augments = []
+        for item in self.unified_data["items"]:
+            new_items.append({ "Name": item["Name"], "Description": item["Description"], "ItemType": item["ItemType"] })
+            if item.get("Augments"):
+                new_augments.append({ "Item": item["Name"], "Augments": item["Augments"] })
+
+        new_quests = []
+        new_details = []
+        new_unlocks = []
+        new_cadence_unlocks = []
+        for q in self.unified_data["quests"]:
+            new_quests.append({ "Name": q["Name"], "Description": q["Description"] })
+            new_details.append({
+                "Quest": q["Name"],
+                "DurationSeconds": q["DurationSeconds"],
+                "Type": q["Type"],
+                "Requirements": q["Requirements"],
+                "Rewards": q["Rewards"],
+                "PrimaryStat": q["PrimaryStat"],
+                "RequiredStats": q["RequiredStats"],
+                "StatRewards": q["StatRewards"]
+            })
+            if q.get("Requires"):
+                new_unlocks.append({ "Quest": q["Name"], "Requires": q["Requires"] })
+            if q.get("UnlocksCadences"):
+                new_cadence_unlocks.append({ "Quest": q["Name"], "Cadences": q["UnlocksCadences"] })
+
+        self._save_json("items.json", new_items)
+        self._save_json("stat_augments.json", new_augments)
+        self._save_json("quests.json", new_quests)
+        self._save_json("quest_details.json", new_details)
+        self._save_json("quest_unlocks.json", new_unlocks)
+        self._save_json("quest_cadence_unlocks.json", new_cadence_unlocks)
+        self._save_json("cadences.json", self.unified_data["cadences"])
+        self._save_json("locations.json", self.unified_data["locations"])
+        self._save_json("refinements.json", self.unified_data["refinements"])
+        self._save_json("stats.json", self.unified_data["stats"])
+
+    def _save_json(self, filename, data):
+        path = os.path.join(self.data_dir, filename)
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2)

scripts/run_content_manager.py

@@ -0,0 +1,24 @@
+import subprocess
+import sys
+import os
+
+def run():
+    print("Checking dependencies...")
+    try:
+        import streamlit
+        import pandas
+    except ImportError:
+        print("Missing dependencies. Installing streamlit and pandas...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "streamlit", "pandas"])
+
+    print("Launching Mythril Content Manager...")
+    # Change to the module directory to ensure relative imports in app.py work correctly
+    os.chdir(os.path.join(os.getcwd(), "modules", "contentManager"))
+    
+    try:
+        subprocess.run(["streamlit", "run", "app.py"])
+    except KeyboardInterrupt:
+        print("\nShutting down Content Manager.")
+
+if __name__ == "__main__":
+    run()