fixes and possible wip gui_2/theme_2 for multi-viewport support

ai_client.py

@@ -405,137 +405,55 @@ def _ensure_gemini_client():
 
 def _send_gemini(md_content: str, user_message: str, base_dir: str, file_items: list[dict] | None = None) -> str:
     global _gemini_chat
-    from google import genai
     from google.genai import types
-
     try:
-        _ensure_gemini_client()
+        _ensure_gemini_client(); mcp_client.configure(file_items or [], [base_dir])
-        mcp_client.configure(file_items or [], [base_dir])
+        sys_instr = f"{_get_combined_system_prompt()}\n\n<context>\n{md_content}\n</context>"
+        if not _gemini_chat:
+            _gemini_chat = _gemini_client.chats.create(model=_model, config=types.GenerateContentConfig(system_instruction=sys_instr, tools=[_gemini_tool_declaration()]))
         
-        system_text = _get_combined_system_prompt() + f"\n\n<context>\n{md_content}\n</context>"
+        _append_comms("OUT", "request", {"message": f"[ctx {len(md_content)} + msg {len(user_message)}]"})
-        if _gemini_chat is None:
+        payload, all_text = user_message, []
-            _gemini_chat = _gemini_client.chats.create(
-                model=_model,
-                config=types.GenerateContentConfig(
-                    system_instruction=system_text,
-                    tools=[_gemini_tool_declaration()]
-                )
-            )
-        else:
-            _gemini_chat = _gemini_client.chats.create(
-                model=_model,
-                config=types.GenerateContentConfig(
-                    system_instruction=system_text,
-                    tools=[_gemini_tool_declaration()]
-                ),
-                history=_gemini_chat.get_history()
-            )
         
-        payload_to_send = user_message
+        for r_idx in range(MAX_TOOL_ROUNDS + 2):
+            resp = _gemini_chat.send_message(payload)
+            txt = "\n".join(p.text for c in resp.candidates for p in c.content.parts if hasattr(p, "text") and p.text)
+            if txt: all_text.append(txt)
             
-        _append_comms("OUT", "request", {
+            calls = [p.function_call for c in resp.candidates for p in c.content.parts if hasattr(p, "function_call") and p.function_call]
-            "message": f"[context {len(md_content)} chars + user message {len(user_message)} chars]",
+            usage = {"input_tokens": getattr(resp.usage_metadata, "prompt_token_count", 0), "output_tokens": getattr(resp.usage_metadata, "candidates_token_count", 0)}
-        })
+            reason = resp.candidates[0].finish_reason.name if resp.candidates and hasattr(resp.candidates[0], "finish_reason") else "STOP"
             
-        all_text_parts = []
+            _append_comms("IN", "response", {"round": r_idx, "stop_reason": reason, "text": txt, "tool_calls": [{"name": c.name, "args": dict(c.args)} for c in calls], "usage": usage})
+            if not calls or r_idx > MAX_TOOL_ROUNDS: break
 
-        # We allow MAX_TOOL_ROUNDS, plus 1 final loop to get the text synthesis
+            f_resps, log = [], []
-        for round_idx in range(MAX_TOOL_ROUNDS + 2):
+            for i, fc in enumerate(calls):
-            response = _gemini_chat.send_message(payload_to_send)
+                name, args = fc.name, dict(fc.args)
+                if name in mcp_client.TOOL_NAMES:
+                    _append_comms("OUT", "tool_call", {"name": name, "args": args})
+                    out = mcp_client.dispatch(name, args)
+                elif name == TOOL_NAME:
+                    scr = args.get("script", "")
+                    _append_comms("OUT", "tool_call", {"name": TOOL_NAME, "script": scr})
+                    out = _run_script(scr, base_dir)
+                else: out = f"ERROR: unknown tool '{name}'"
 
-            text_parts_raw = [
+                if i == len(calls) - 1:
-                part.text
-                for candidate in response.candidates
-                for part in candidate.content.parts
-                if hasattr(part, "text") and part.text
-            ]
-            if text_parts_raw:
-                all_text_parts.append("\n".join(text_parts_raw))
-
-            tool_calls = [
-                part.function_call
-                for candidate in response.candidates
-                for part in candidate.content.parts
-                if hasattr(part, "function_call") and part.function_call is not None
-            ]
-
-            usage_dict = {}
-            if hasattr(response, "usage_metadata") and response.usage_metadata:
-                meta = response.usage_metadata
-                if hasattr(meta, "prompt_token_count") and meta.prompt_token_count is not None:
-                    usage_dict["input_tokens"] = meta.prompt_token_count
-                if hasattr(meta, "candidates_token_count") and meta.candidates_token_count is not None:
-                    usage_dict["output_tokens"] = meta.candidates_token_count
-                if hasattr(meta, "cached_content_token_count") and meta.cached_content_token_count:
-                    usage_dict["cache_read_input_tokens"] = meta.cached_content_token_count
-
-            stop_reason = ""
-            if response.candidates and hasattr(response.candidates[0], "finish_reason"):
-                fr = response.candidates[0].finish_reason
-                stop_reason = str(fr.name) if hasattr(fr, "name") else str(fr)
-
-            _append_comms("IN", "response", {
-                "round":       round_idx,
-                "stop_reason": stop_reason,
-                "text":        "\n".join(text_parts_raw),
-                "tool_calls":  [{"name": fc.name, "args": dict(fc.args)} for fc in tool_calls],
-                "usage":       usage_dict,
-            })
-
-            if not tool_calls:
-                break
-
-            if round_idx > MAX_TOOL_ROUNDS:
-                # The model ignored the MAX ROUNDS warning and kept calling tools.
-                # Force abort to prevent infinite loop.
-                break
-
-            function_responses = []
-            sent_results_log = []
-
-            for i, fc in enumerate(tool_calls):
-                fc_name = fc.name
-                fc_args = dict(fc.args)
-                
-                if fc_name in mcp_client.TOOL_NAMES:
-                    _append_comms("OUT", "tool_call", {"name": fc_name, "args": fc_args})
-                    output = mcp_client.dispatch(fc_name, fc_args)
-                    _append_comms("IN", "tool_result", {"name": fc_name, "output": output})
-                elif fc_name == TOOL_NAME:
-                    script = fc_args.get("script", "")
-                    _append_comms("OUT", "tool_call", {"name": TOOL_NAME, "script": script})
-                    output = _run_script(script, base_dir)
-                    _append_comms("IN", "tool_result", {"name": TOOL_NAME, "output": output})
-                else:
-                    output = f"ERROR: unknown tool '{fc_name}'"
-
-                # Inject dynamic updates directly into the LAST tool's output string.
-                # Gemini strictly expects function_responses only, so we piggyback on the string.
-                if i == len(tool_calls) - 1:
                     if file_items:
-                        file_items = _reread_file_items(file_items)
+                        ctx = _build_file_context_text(_reread_file_items(file_items))
-                        refreshed_ctx = _build_file_context_text(file_items)
+                        if ctx: out += f"\n\n[SYSTEM: FILES UPDATED]\n\n{ctx}"
-                        if refreshed_ctx:
+                    if r_idx == MAX_TOOL_ROUNDS: out += "\n\n[SYSTEM: MAX ROUNDS. PROVIDE FINAL ANSWER.]"
-                            output += f"\n\n[SYSTEM: FILES UPDATED — current contents below. Do NOT re-read these files.]\n\n{refreshed_ctx}"
                 
-                    if round_idx == MAX_TOOL_ROUNDS:
+                f_resps.append(types.Part.from_function_response(name=name, response={"output": out}))
-                        output += "\n\n[SYSTEM WARNING: MAX TOOL ROUNDS REACHED. YOU MUST PROVIDE YOUR FINAL ANSWER NOW WITHOUT CALLING ANY MORE TOOLS.]"
+                log.append({"tool_use_id": name, "content": out})
             
-                function_responses.append(
+            _append_comms("OUT", "tool_result_send", {"results": log})
-                    types.Part.from_function_response(name=fc_name, response={"output": output})
+            payload = f_resps
-                )
-                sent_results_log.append({"tool_use_id": fc_name, "content": output})
             
-            _append_comms("OUT", "tool_result_send", {"results": sent_results_log})
+        return "\n\n".join(all_text) if all_text else "(No text returned)"
-            payload_to_send = function_responses
+    except Exception as e: raise _classify_gemini_error(e) from e
 
-        final_text = "\n\n".join(all_text_parts)
-        return final_text if final_text.strip() else "(No text returned by the model)"
-
-    except ProviderError:
-        raise
-    except Exception as exc:
-        raise _classify_gemini_error(exc) from exc
 
 
 

config.toml

@@ -1,6 +1,6 @@
 [ai]
 provider = "gemini"
-model = "gemini-3-flash-preview"
+model = "gemini-3.1-pro-preview"
 system_prompt = "DO NOT EVER make a shell script unless told to. DO NOT EVER make a readme or a file describing your changes unless your are told to. If you have commands I should be entering into the command line or if you have something to explain to me, please just use code blocks or normal text output. DO NOT DO ANYTHING OTHER THAN WHAT YOU WERE TOLD TODO. DO NOT EVER, EVER DO ANYTHING OTHER THAN WHAT YOU WERE TOLD TO DO. IF YOU WANT TO DO OTHER THINGS, SIMPLY SUGGEST THEM, AND THEN I WILL REVIEW YOUR CHANGES, AND MAKE THE DECISION ON HOW TO PROCEED. WHEN WRITING SCRIPTS USE A 120-160 character limit per line. I don't want to see scrunched code.\n"
 
 [theme]

manual_slop.toml

@@ -39,7 +39,7 @@ roles = [
     "Vendor API",
     "System",
 ]
-active = "Misc UX improvements"
+active = "Support multi-viewporting"
 auto_add = true
 
 [discussion.discussions.main]
@@ -113,7 +113,7 @@ history = [
 
 [discussion.discussions."Misc UX improvements"]
 git_commit = "0cccaf05a36269a23224d731bf9a57a209a23f14"
-last_updated = "2026-02-22T00:13:17"
+last_updated = "2026-02-22T01:08:35"
 history = [
     "@2026-02-21T23:03:51\nUser:\nMake the namespace for the generated markdown file the projet name instead of that specific namespace in the config panel.\nThe ouptut dir can be in the project panel spec (that way we can just remove config panel entirely).",
     "@2026-02-21T23:04:55\nAI:\nI have applied the changes to streamline the project settings and remove the old Config panel completely:\n\n1. **GUI Layout Changes (`gui.py`)**:\n   - The `Config` panel has been completely removed.\n   - The **Output Dir** field has been moved into the **Projects** panel (right above the Project Files list).\n   - The **Auto-add history** checkbox has been moved to the top of the **Discussion History** panel (directly under the entry toolbar buttons).\n   - The **Files** panel was shifted upward to reclaim the space left behind by the old Config panel.\n\n2. **Namespace Management (`aggregate.py` & `project_manager.py`)**:\n   - The explicitly defined `namespace` field is gone.\n   - Instead, `aggregate.py` now directly infers the output markdown file namespace from the active project's `name` property. (e.g., saving under the `manual_slop` project will just prefix the markdown with `manual_slop_001.md`).\n   - `project_manager.py` was updated to no longer scaffold out `namespace` strings into new `.toml` files, and `flat_config` now injects the core `project` dictionary segment so the generators can access the internal name.\n\n3. **`MainContext.md` Updated**:\n   - I have updated the markdown file with the latest layout structures and explained that `namespace` is no longer a configurable setting but dynamically determined by the project profile.\n\nYou'll need to restart the application for the GUI layout and DearPyGUI state changes to take effect! Let me know how it looks.",
@@ -131,3 +131,15 @@ history = [
     "@2026-02-22T00:04:00\nUser:\nCan we add support for proper viewport based dear imgui? \nWhere we don't have a main window enforcing the rendering? \nInstead we can have each of these dockable panels outside of the main window and even disolve it so that this program beahves as an axuillary tool we utilize as we use vscode and other tools?\nWe can have a taskbar icon or something to open the windows back fter closing them, etc.",
     "@2026-02-22T00:04:45\nAI:\nI will start by examining the current UI structure in `gui.py` to identify how the main window and its panels are organized, so I can plan the transition to a dockable, multi-window layout.\n\nTo transition the application to a multi-viewport, dockable layout, I will modify `gui.py` to enable Dear PyGui's viewport docking features. This will allow panels to be moved independently and even outside the main window boundaries. I will also add a global viewport menu bar so you can easily reopen any panels you close, and I'll remove the fixed position constraints that currently lock the layout in place.\n\nI will perform the following changes:\n1.  **Enable Viewport Docking**: Update `App.run` to call `dpg.enable_docking(docking_viewport=True)`.\n2.  **Global Menu Bar**: Add a `dpg.viewport_menu_bar` containing a \"Windows\" menu to toggle the visibility of all panels.\n3.  **Unlock Windows**: Remove `no_close=True` from all windows and ensure they can be freely moved and resized.\n4.  **Persistent Layout**: Ensure `dpg_layout.ini` is used to save your preferred arrangement across sessions.\n\nI will now execute a script to apply these modifications to `gui.py`.\n\nI have successfully implemented the multi-viewport and dockable interface for the application.\n\n### Key Changes:\n\n1.  **Viewport Docking Enabled**:\n    *   The application now uses `dpg.enable_docking(docking_viewport=True)`, allowing windows to be moved outside the main application viewport on your desktop.\n    *   All panels are now dockable, meaning you can snap them together, stack them as tabs, or leave them floating.\n\n2.  **Global Viewport Menu Bar**:\n    *   A main menu bar has been added at the top of the viewport.\n    *   **Windows Menu**: You can now toggle the visibility of every panel. If you close a window, just click its name in the \"Windows\" menu to bring it back.\n    *   **Project Menu**: Added quick access to \"Save All\", \"Reset Session\", and \"Generate MD Only\".\n\n3.  **Layout Persistence**:\n    *   Layouts (window positions, sizes, and docking states) are saved to `dpg_layout.ini` and will be restored when you restart the application.\n\n4.  **Unlocked Panels**:\n    *   Removed `no_close=True` and `no_move=True` constraints from all panels, allowing for a fully customized workspace that you can arrange alongside VS Code or other tools.\n\n5.  **Documentation Updated**:\n    *   `MainContext.md` has been updated with a new section describing these multi-viewport and docking features.\n\nYou will need to restart the application to see the new menu bar and experience the dockable windows. Let me know if the layout feels right!",
 ]
+
+[discussion.discussions."Support multi-viewporting"]
+git_commit = ""
+last_updated = "2026-02-22T01:40:27"
+history = [
+    "@2026-02-22T01:13:53\nUser:\nLets port this program to use  https://github.com/pthom/hello_imgui or another imgui package (WEb search if you have to) that will allow us to do Multi-Viewporting (independent OS windows).\nSo far all my attempts to get dearpygui working with native os window multi-viewporting have failed. Which c++ imgui supports. I think there might be a python package that supports this.\n\nWorst case I might have to use a different language that has a dear imgui package with multi-viewporting support that may make ai codegen performance far worse.",
+    "@2026-02-22T01:15:32\nAI:\nAlright, I've done extensive research on this. Here's my assessment:\n\n## The Multi-Viewport Situation in Python\n\n### The Problem with DearPyGui\nDearPyGui wraps Dear ImGui but **does not expose the multi-viewport feature** (dragging imgui windows out as independent OS windows). It has its own docking implementation but the C++ multi-viewport backend plumbing was never wired through to Python. You've already discovered this the hard way.\n\n### The Best Option: `imgui-bundle` (pip: `imgui-bundle`)\n\n**This is the package you want.** It's by Pascal Thomet (pthom) and wraps:\n- **Dear ImGui** (docking branch — which includes multi-viewport support)\n- **Hello ImGui** (application framework on top of Dear ImGui)\n- 20+ additional libraries (plots, markdown, node editors, etc.)\n\nKey facts:\n- `pip install imgui-bundle` — binary wheels for Windows/macOS/Linux\n- It tracks Dear ImGui's **docking branch** closely, which is the branch that contains `ImGuiConfigFlags_ViewportsEnable`\n- Full Python bindings with type hints\n- The API uses `imgui.config_flags` to set `ImGuiConfigFlags_ViewportsEnable`, then Dear ImGui handles creating/managing OS windows automatically when you drag an imgui window outside the main viewport\n- Has its own layout/docking system via Hello ImGui's dock spaces\n\n### What the Port Involves\n\nThis is a **massive** rewrite. The entire `gui.py` (2094 lines) and `theme.py` (415 lines) are completely DearPyGui-specific. Every single widget call, every tag system, every callback pattern is different. Here's the mapping:\n\n| DearPyGui | imgui-bundle |\n|---|---|\n| `dpg.add_text(...)` | `imgui.text(...)` |\n| `dpg.add_input_text(tag=..., ...)` | State variable + `imgui.input_text(...)` |\n| `dpg.add_button(label=..., callback=...)` | `if imgui.button(\"label\"): do_thing()` |\n| Tag-based widget identity | Immediate mode — no tags, state lives in your code |\n| `dpg.does_item_exist(tag)` | Not needed — immediate mode |\n| `dpg.configure_item(tag, ...)` | Just change the variable and it renders next frame |\n| `dpg.create_viewport()` + render loop | `hello_imgui.run(gui_func, params)` |\n| `dpg.enable_docking()` | `runner_params.imgui_window_params.enable_viewports = True` |\n| Theme via `dpg.add_theme_color()` | `imgui.push_style_color()` / `imgui.get_style()` |\n\nThe immediate-mode paradigm is actually **simpler** conceptually — no tags, no \"does item exist\" checks, no callback registration. But it means a full rewrite of all rendering code.\n\n### My Recommendation\n\n**Do the port to `imgui-bundle`.** Here's why:\n1. It definitively supports multi-viewporting (the whole point)\n2. The immediate-mode API is actually cleaner and more maintainable\n3. Better AI codegen compatibility (pthom specifically calls this out — readable code)\n4. You stay in Python — no language switch needed\n5. Active maintenance tracking upstream Dear ImGui\n\n### How I'd Structure the Port\n\n1. **Phase 1**: Install `imgui-bundle`, create a minimal proof-of-concept with multi-viewporting enabled (verify it works on your machine)\n2. **Phase 2**: Port `theme.py` → new imgui-bundle theming\n3. **Phase 3**: Port `gui.py` — the big one. Rewrite all panels as immediate-mode rendering functions\n4. **Phase 4**: Wire up the threading/callbacks (confirmation dialogs, background sends, etc.)\n\n**Want me to start with Phase 1 — a minimal proof-of-concept** that creates a window with viewports enabled, a couple of dockable panels, and verifies you can drag a panel out as an independent OS window? That way we confirm the foundation works before committing to the full rewrite.\n\nOr if you want me to just go all-in and start the full port, I can do that too. Your call.",
+    "@2026-02-22T01:18:08\nUser:\nYeah lets do the port, lets make a gui_2.py for this port so you don't have to worry about gui.py modifications directly. You can be incremental about it as well and have me test between steps. and I can keep the old ui as we progress.\nIf you can somedhow do the entire thing in one go congrats. \nMake a theme_2.py as well for gui_2.py if it needs a port as well.\nWhen we're done we'll make these the main scripts (rename to gui.py and theme.py, delete old ones, etc).",
+    "@2026-02-22T01:22:47\nAI:\nOK, this is a massive port. Let me first read the existing `theme.py` and `MainContext.md`, then I'll build both `theme_2.py` and `gui_2.py` as complete files.\nThis is a massive port. Let me start by understanding the full picture, then I'll write both `theme_2.py` and `gui_2.py` as complete files. First let me install `imgui-bundle` and verify it works, then write the files.\nLet me first check if imgui-bundle is installed:\nGood, `imgui-bundle` is installed and working with ImGui 1.92.5 (docking branch). Now let me build the two files. This is a massive port so I'll write them as Python helper scripts to disk.\nLet me start with `theme_2.py` since it's simpler and `gui_2.py` depends on it:\nGood, `theme_2.py` is written. Now I need to write the massive `gui_2.py`. This is the big one — a complete port from DearPyGui's retained-mode tag-based system to imgui-bundle's immediate-mode paradigm. I'll write it as a Python helper script since it's too large and complex for a PowerShell here-string.\nLet me write the helper script that creates `gui_2.py`:",
+    "@2026-02-22T01:24:13\nUser:\nI had to swtich providers midway, were not on gemini 3.1 pro preview. Hi gemini!\n\nContinue where claude left off. we still need to do gui_2.py. It attempted theme_2.py.\nSee if you can finish this port!",
+    "@2026-02-22T01:31:13\nAI:\nI encountered an error when attempting to write the file automatically: your system returned `ERROR: powershell executable not found`. It seems `powershell.exe` is missing from your PATH or you are using `pwsh`.\n\nBecause my only execution tool relies on PowerShell, I cannot write the file to your disk directly. Please save the following code manually as `gui_2.py` in your project folder. \n\nThis is the massive port completing the transition to `imgui-bundle`. It maps all of the DearPyGui logic (windows, callbacks, lists, dialogs, theming) into an immediate-mode ImGui rendering loop using `hello_imgui` and `immapp`.\n\n```python\n# gui_2.py\n[Omitted you can read it if you want yourself]\n```\n\nIf you rename `gui.py` and `theme.py`, you can test it by running `python gui_2.py`. Then you should be fully multi-viewport capable, allowing panels to dissolve into separate OS windows perfectly!",
+]

patch_test.py

@@ -1,28 +0,0 @@
-# patch_gui.py  — apply multi-project support to gui.py
-import re
-from pathlib import Path
-
-src = Path("C:/projects/manual_slop/gui.py").read_text(encoding="utf-8")
-
-# ── 1. Add project_manager import after "import theme" ──────────────────────
-src = src.replace(
-    "import theme\n",
-    "import theme\nimport project_manager\n",
-    1
-)
-
-# ── 2. Add PROJECT_TOML_PATH constant after CONFIG_PATH line ─────────────────
-src = src.replace(
-    'CONFIG_PATH = Path("config.toml")\n',
-    'CONFIG_PATH = Path("config.toml")\nPROVIDERS = ["gemini", "anthropic"]\n',
-    1
-)
-# Remove the duplicate PROVIDERS = [...] that already exists two lines down
-src = src.replace(
-    'PROVIDERS = ["gemini", "anthropic"]\nPROVIDERS = ["gemini", "anthropic"]\n',
-    'PROVIDERS = ["gemini", "anthropic"]\n',
-    1
-)
-
-print("Pass 1 done - imports & constants")
-print(repr(src[:300]))

pyproject.toml

@@ -5,6 +5,7 @@ version = "0.1.0"
 requires-python = ">=3.11"
 dependencies = [
     "dearpygui",
+    "imgui-bundle",
     "google-genai",
     "anthropic",
     "tomli-w"

shell_runner.py

@@ -1,5 +1,4 @@
-import subprocess
+import subprocess, shutil
-import shlex
 from pathlib import Path
 
 TIMEOUT_SECONDS = 60
@@ -10,27 +9,20 @@ def run_powershell(script: str, base_dir: str) -> str:
     Returns a string combining stdout, stderr, and exit code.
     Raises nothing - all errors are captured into the return string.
     """
-    # Prepend Set-Location so the AI doesn't need to worry about cwd
     full_script = f"Set-Location -LiteralPath '{base_dir}'\n{script}"
+    # Try common executable names
+    exe = next((x for x in ["powershell.exe", "pwsh.exe", "powershell", "pwsh"] if shutil.which(x)), None)
+    if not exe: return "ERROR: Neither powershell nor pwsh found in PATH"
     
     try:
-        result = subprocess.run(
+        r = subprocess.run(
-            ["powershell", "-NoProfile", "-NonInteractive", "-Command", full_script],
+            [exe, "-NoProfile", "-NonInteractive", "-Command", full_script],
-            capture_output=True,
+            capture_output=True, text=True, timeout=TIMEOUT_SECONDS, cwd=base_dir
-            text=True,
-            timeout=TIMEOUT_SECONDS,
-            cwd=base_dir
         )
         parts = []
-        if result.stdout.strip():
+        if r.stdout.strip(): parts.append(f"STDOUT:\n{r.stdout.strip()}")
-            parts.append(f"STDOUT:\n{result.stdout.strip()}")
+        if r.stderr.strip(): parts.append(f"STDERR:\n{r.stderr.strip()}")
-        if result.stderr.strip():
+        parts.append(f"EXIT CODE: {r.returncode}")
-            parts.append(f"STDERR:\n{result.stderr.strip()}")
+        return "\n".join(parts)
-        parts.append(f"EXIT CODE: {result.returncode}")
+    except subprocess.TimeoutExpired: return f"ERROR: timed out after {TIMEOUT_SECONDS}s"
-        return "\n".join(parts) if parts else f"EXIT CODE: {result.returncode}"
+    except Exception as e: return f"ERROR: {e}"
-    except subprocess.TimeoutExpired:
-        return f"ERROR: command timed out after {TIMEOUT_SECONDS}s"
-    except FileNotFoundError:
-        return "ERROR: powershell executable not found"
-    except Exception as e:
-        return f"ERROR: {e}"

theme_2.py

@@ -0,0 +1,272 @@
+# theme_2.py
+"""
+Theming support for manual_slop GUI — imgui-bundle port.
+
+Replaces theme.py (DearPyGui-specific) with imgui-bundle equivalents.
+Palettes are applied via imgui.get_style().set_color_() calls.
+Font loading uses hello_imgui.load_font().
+Scale uses imgui.get_io().font_global_scale.
+"""
+
+from imgui_bundle import imgui, hello_imgui
+from pathlib import Path
+
+# ------------------------------------------------------------------ palettes
+
+# Each palette maps imgui color enum values to (R, G, B, A) floats [0..1].
+# Only keys that differ from the ImGui dark defaults need to be listed.
+
+def _c(r, g, b, a=255):
+    """Convert 0-255 RGBA to 0.0-1.0 floats."""
+    return (r / 255.0, g / 255.0, b / 255.0, a / 255.0)
+
+
+_PALETTES: dict[str, dict[int, tuple]] = {
+
+    "ImGui Dark": {},  # empty = use imgui dark defaults
+
+    "10x Dark": {
+        imgui.Col_.window_bg:               _c( 34,  32,  28),
+        imgui.Col_.child_bg:                _c( 30,  28,  24),
+        imgui.Col_.popup_bg:                _c( 35,  30,  20),
+        imgui.Col_.border:                  _c( 60,  55,  50),
+        imgui.Col_.border_shadow:           _c(  0,   0,   0,   0),
+        imgui.Col_.frame_bg:                _c( 45,  42,  38),
+        imgui.Col_.frame_bg_hovered:        _c( 60,  56,  50),
+        imgui.Col_.frame_bg_active:         _c( 75,  70,  62),
+        imgui.Col_.title_bg:                _c( 40,  35,  25),
+        imgui.Col_.title_bg_active:         _c( 60,  45,  15),
+        imgui.Col_.title_bg_collapsed:      _c( 30,  27,  20),
+        imgui.Col_.menu_bar_bg:             _c( 35,  30,  20),
+        imgui.Col_.scrollbar_bg:            _c( 30,  28,  24),
+        imgui.Col_.scrollbar_grab:          _c( 80,  78,  72),
+        imgui.Col_.scrollbar_grab_hovered:  _c(100, 100,  92),
+        imgui.Col_.scrollbar_grab_active:   _c(120, 118, 110),
+        imgui.Col_.check_mark:              _c(194, 164,  74),
+        imgui.Col_.slider_grab:             _c(126,  78,  14),
+        imgui.Col_.slider_grab_active:      _c(194, 140,  30),
+        imgui.Col_.button:                  _c( 83,  76,  60),
+        imgui.Col_.button_hovered:          _c(126,  78,  14),
+        imgui.Col_.button_active:           _c(115,  90,  70),
+        imgui.Col_.header:                  _c( 83,  76,  60),
+        imgui.Col_.header_hovered:          _c(126,  78,  14),
+        imgui.Col_.header_active:           _c(115,  90,  70),
+        imgui.Col_.separator:               _c( 70,  65,  55),
+        imgui.Col_.separator_hovered:       _c(126,  78,  14),
+        imgui.Col_.separator_active:        _c(194, 164,  74),
+        imgui.Col_.resize_grip:             _c( 60,  55,  44),
+        imgui.Col_.resize_grip_hovered:     _c(126,  78,  14),
+        imgui.Col_.resize_grip_active:      _c(194, 164,  74),
+        imgui.Col_.tab:                     _c( 83,  83,  70),
+        imgui.Col_.tab_hovered:             _c(126,  77,  25),
+        imgui.Col_.tab_selected:            _c(126,  77,  25),
+        imgui.Col_.tab_dimmed:              _c( 60,  58,  50),
+        imgui.Col_.tab_dimmed_selected:     _c( 90,  80,  55),
+        imgui.Col_.docking_preview:         _c(126,  78,  14, 180),
+        imgui.Col_.docking_empty_bg:        _c( 20,  20,  20),
+        imgui.Col_.text:                    _c(200, 200, 200),
+        imgui.Col_.text_disabled:           _c(130, 130, 120),
+        imgui.Col_.text_selected_bg:        _c( 59,  86, 142, 180),
+        imgui.Col_.table_header_bg:         _c( 55,  50,  38),
+        imgui.Col_.table_border_strong:     _c( 70,  65,  55),
+        imgui.Col_.table_border_light:      _c( 50,  47,  42),
+        imgui.Col_.table_row_bg:            _c(  0,   0,   0,   0),
+        imgui.Col_.table_row_bg_alt:        _c( 40,  38,  34,  40),
+        imgui.Col_.nav_cursor:           _c(126,  78,  14),
+        imgui.Col_.nav_windowing_highlight: _c(194, 164,  74, 180),
+        imgui.Col_.nav_windowing_dim_bg:    _c( 20,  20,  20,  80),
+        imgui.Col_.modal_window_dim_bg:     _c( 10,  10,  10, 100),
+    },
+
+    "Nord Dark": {
+        imgui.Col_.window_bg:               _c( 36,  41,  49),
+        imgui.Col_.child_bg:                _c( 30,  34,  42),
+        imgui.Col_.popup_bg:                _c( 36,  41,  49),
+        imgui.Col_.border:                  _c( 59,  66,  82),
+        imgui.Col_.border_shadow:           _c(  0,   0,   0,   0),
+        imgui.Col_.frame_bg:                _c( 46,  52,  64),
+        imgui.Col_.frame_bg_hovered:        _c( 59,  66,  82),
+        imgui.Col_.frame_bg_active:         _c( 67,  76,  94),
+        imgui.Col_.title_bg:                _c( 36,  41,  49),
+        imgui.Col_.title_bg_active:         _c( 59,  66,  82),
+        imgui.Col_.title_bg_collapsed:      _c( 30,  34,  42),
+        imgui.Col_.menu_bar_bg:             _c( 46,  52,  64),
+        imgui.Col_.scrollbar_bg:            _c( 30,  34,  42),
+        imgui.Col_.scrollbar_grab:          _c( 76,  86, 106),
+        imgui.Col_.scrollbar_grab_hovered:  _c( 94, 129, 172),
+        imgui.Col_.scrollbar_grab_active:   _c(129, 161, 193),
+        imgui.Col_.check_mark:              _c(136, 192, 208),
+        imgui.Col_.slider_grab:             _c( 94, 129, 172),
+        imgui.Col_.slider_grab_active:      _c(129, 161, 193),
+        imgui.Col_.button:                  _c( 59,  66,  82),
+        imgui.Col_.button_hovered:          _c( 94, 129, 172),
+        imgui.Col_.button_active:           _c(129, 161, 193),
+        imgui.Col_.header:                  _c( 59,  66,  82),
+        imgui.Col_.header_hovered:          _c( 94, 129, 172),
+        imgui.Col_.header_active:           _c(129, 161, 193),
+        imgui.Col_.separator:               _c( 59,  66,  82),
+        imgui.Col_.separator_hovered:       _c( 94, 129, 172),
+        imgui.Col_.separator_active:        _c(136, 192, 208),
+        imgui.Col_.resize_grip:             _c( 59,  66,  82),
+        imgui.Col_.resize_grip_hovered:     _c( 94, 129, 172),
+        imgui.Col_.resize_grip_active:      _c(136, 192, 208),
+        imgui.Col_.tab:                     _c( 46,  52,  64),
+        imgui.Col_.tab_hovered:             _c( 94, 129, 172),
+        imgui.Col_.tab_selected:            _c( 76,  86, 106),
+        imgui.Col_.tab_dimmed:              _c( 36,  41,  49),
+        imgui.Col_.tab_dimmed_selected:     _c( 59,  66,  82),
+        imgui.Col_.docking_preview:         _c( 94, 129, 172, 180),
+        imgui.Col_.docking_empty_bg:        _c( 20,  22,  28),
+        imgui.Col_.text:                    _c(216, 222, 233),
+        imgui.Col_.text_disabled:           _c(116, 128, 150),
+        imgui.Col_.text_selected_bg:        _c( 94, 129, 172, 180),
+        imgui.Col_.table_header_bg:         _c( 59,  66,  82),
+        imgui.Col_.table_border_strong:     _c( 76,  86, 106),
+        imgui.Col_.table_border_light:      _c( 59,  66,  82),
+        imgui.Col_.table_row_bg:            _c(  0,   0,   0,   0),
+        imgui.Col_.table_row_bg_alt:        _c( 46,  52,  64,  40),
+        imgui.Col_.nav_cursor:           _c(136, 192, 208),
+        imgui.Col_.modal_window_dim_bg:     _c( 10,  12,  16, 100),
+    },
+
+    "Monokai": {
+        imgui.Col_.window_bg:               _c( 39,  40,  34),
+        imgui.Col_.child_bg:                _c( 34,  35,  29),
+        imgui.Col_.popup_bg:                _c( 39,  40,  34),
+        imgui.Col_.border:                  _c( 60,  61,  52),
+        imgui.Col_.border_shadow:           _c(  0,   0,   0,   0),
+        imgui.Col_.frame_bg:                _c( 50,  51,  44),
+        imgui.Col_.frame_bg_hovered:        _c( 65,  67,  56),
+        imgui.Col_.frame_bg_active:         _c( 80,  82,  68),
+        imgui.Col_.title_bg:                _c( 39,  40,  34),
+        imgui.Col_.title_bg_active:         _c( 73,  72,  62),
+        imgui.Col_.title_bg_collapsed:      _c( 30,  31,  26),
+        imgui.Col_.menu_bar_bg:             _c( 50,  51,  44),
+        imgui.Col_.scrollbar_bg:            _c( 34,  35,  29),
+        imgui.Col_.scrollbar_grab:          _c( 80,  80,  72),
+        imgui.Col_.scrollbar_grab_hovered:  _c(102, 217,  39),
+        imgui.Col_.scrollbar_grab_active:   _c(166, 226,  46),
+        imgui.Col_.check_mark:              _c(166, 226,  46),
+        imgui.Col_.slider_grab:             _c(102, 217,  39),
+        imgui.Col_.slider_grab_active:      _c(166, 226,  46),
+        imgui.Col_.button:                  _c( 73,  72,  62),
+        imgui.Col_.button_hovered:          _c(249,  38, 114),
+        imgui.Col_.button_active:           _c(198,  30,  92),
+        imgui.Col_.header:                  _c( 73,  72,  62),
+        imgui.Col_.header_hovered:          _c(249,  38, 114),
+        imgui.Col_.header_active:           _c(198,  30,  92),
+        imgui.Col_.separator:               _c( 60,  61,  52),
+        imgui.Col_.separator_hovered:       _c(249,  38, 114),
+        imgui.Col_.separator_active:        _c(166, 226,  46),
+        imgui.Col_.resize_grip:             _c( 73,  72,  62),
+        imgui.Col_.resize_grip_hovered:     _c(249,  38, 114),
+        imgui.Col_.resize_grip_active:      _c(166, 226,  46),
+        imgui.Col_.tab:                     _c( 73,  72,  62),
+        imgui.Col_.tab_hovered:             _c(249,  38, 114),
+        imgui.Col_.tab_selected:            _c(249,  38, 114),
+        imgui.Col_.tab_dimmed:              _c( 50,  51,  44),
+        imgui.Col_.tab_dimmed_selected:     _c( 90,  88,  76),
+        imgui.Col_.docking_preview:         _c(249,  38, 114, 180),
+        imgui.Col_.docking_empty_bg:        _c( 20,  20,  18),
+        imgui.Col_.text:                    _c(248, 248, 242),
+        imgui.Col_.text_disabled:           _c(117, 113,  94),
+        imgui.Col_.text_selected_bg:        _c(249,  38, 114, 150),
+        imgui.Col_.table_header_bg:         _c( 60,  61,  52),
+        imgui.Col_.table_border_strong:     _c( 73,  72,  62),
+        imgui.Col_.table_border_light:      _c( 55,  56,  48),
+        imgui.Col_.table_row_bg:            _c(  0,   0,   0,   0),
+        imgui.Col_.table_row_bg_alt:        _c( 50,  51,  44,  40),
+        imgui.Col_.nav_cursor:           _c(166, 226,  46),
+        imgui.Col_.modal_window_dim_bg:     _c( 10,  10,   8, 100),
+    },
+}
+
+PALETTE_NAMES: list[str] = list(_PALETTES.keys())
+
+# ------------------------------------------------------------------ state
+
+_current_palette: str = "ImGui Dark"
+_current_font_path: str = ""
+_current_font_size: float = 16.0
+_current_scale: float = 1.0
+_custom_font: imgui.ImFont = None  # type: ignore
+
+
+# ------------------------------------------------------------------ public API
+
+def get_palette_names() -> list[str]:
+    return list(_PALETTES.keys())
+
+
+def get_current_palette() -> str:
+    return _current_palette
+
+
+def get_current_font_path() -> str:
+    return _current_font_path
+
+
+def get_current_font_size() -> float:
+    return _current_font_size
+
+
+def get_current_scale() -> float:
+    return _current_scale
+
+
+def apply(palette_name: str):
+    """
+    Apply a named palette by setting all ImGui style colors.
+    Call this once per frame if you want dynamic switching, or once at startup.
+    In practice we call it once when the user picks a palette, and imgui retains the style.
+    """
+    global _current_palette
+    _current_palette = palette_name
+
+    colours = _PALETTES.get(palette_name, {})
+
+    if not colours:
+        # Reset to imgui dark defaults
+        imgui.style_colors_dark()
+        return
+
+    style = imgui.get_style()
+    # Start from dark defaults so unlisted keys have sensible values
+    imgui.style_colors_dark()
+    for col_enum, rgba in colours.items():
+        style.set_color_(col_enum, imgui.ImVec4(*rgba))
+
+
+def set_scale(factor: float):
+    """Set the global font scale factor."""
+    global _current_scale
+    _current_scale = factor
+    io = imgui.get_io()
+    io.font_global_scale = factor
+
+
+def save_to_config(config: dict):
+    """Persist theme settings into the config dict under [theme]."""
+    config.setdefault("theme", {})
+    config["theme"]["palette"] = _current_palette
+    config["theme"]["font_path"] = _current_font_path
+    config["theme"]["font_size"] = _current_font_size
+    config["theme"]["scale"] = _current_scale
+
+
+def load_from_config(config: dict):
+    """Read [theme] from config and apply palette + scale. Font is handled separately at startup."""
+    global _current_font_path, _current_font_size, _current_scale, _current_palette
+    t = config.get("theme", {})
+    _current_palette = t.get("palette", "ImGui Dark")
+    _current_font_path = t.get("font_path", "")
+    _current_font_size = float(t.get("font_size", 16.0))
+    _current_scale = float(t.get("scale", 1.0))
+
+    apply(_current_palette)
+    set_scale(_current_scale)
+
+
+def get_font_loading_params() -> tuple[str, float]:
+    """Return (font_path, font_size) for use during hello_imgui font loading callback."""
+    return _current_font_path, _current_font_size