meltygui 0.1.0__py3-none-any.whl

meltygui/core/automation/action_core.py

@@ -0,0 +1,153 @@
+"""Actions window — renders Toggles' sibling Actions class (toggles.py), the
+general-purpose stash for app triggers ("New file", "New Render Function").
+
+Also registers the "Actions" global-search category: every function on the
+Actions class is a hit, and activating one pops up the ActionRunner window —
+its parameters (seeded from the function signature) as editable rows plus a
+Run button that calls the function."""
+
+import inspect
+import types
+from pathlib import Path
+
+import meltygui_imgui as imgui
+
+from meltygui.core.melty import Melty
+from meltygui.core.rendering.modes import Modes
+from meltygui.core.diagnostics.notifications import notify
+from meltygui.core.runtime.toggles import Actions
+from meltygui.core.windowing.glfw_utils import request_render
+from meltygui.core.core_render import render_func
+from meltygui.core.rendering.core_decoration import Core
+from meltygui.core.rendering.core_decoration import defaults
+from meltygui.core.rendering.window_decoration import window
+from meltygui.editor.source_ui import SearchHit
+from meltygui.editor.source_ui import _category_tint
+from meltygui.core.runtime.extensions import jump_to_symbol as _jump_to_symbol_def
+from meltygui.core.rendering.render_dispatch import draw_any
+
+
+def _action_funcs():
+    """(name, function, icon) for every public function on Actions, definition
+    order. Reads vars() live each call so a hotswapped/added action shows up
+    without any cache to invalidate. The icon is the @defaults(icon=...)
+    registration — keyed by whatever object @defaults decorated, which is the
+    staticmethod wrapper when it sits outside @staticmethod and the raw
+    function when inside, so both keys are tried."""
+    out = []
+    for name, member in vars(Actions).items():
+        if name.startswith("_"):
+            continue
+        fn = member.__func__ if isinstance(member, (staticmethod, classmethod)) else member
+        if not isinstance(fn, types.FunctionType):
+            continue
+        icon = None
+        for key in (member, fn):
+            icon = Melty.default_kwargs_by_type.get(key, {}).get("icon")
+            if icon:
+                break
+        out.append((name, fn, icon))
+    return out
+
+
+def _sig_label(name, fn):
+    """`new_render_func(name='draw_other')` — the search-row label, so a hit
+    shows what inputs the runner will ask for."""
+    parts = []
+    for pname, p in inspect.signature(fn).parameters.items():
+        if p.default is not inspect.Parameter.empty:
+            parts.append(f"{pname}={p.default!r}")
+        else:
+            parts.append(pname)
+    return f"{name}({', '.join(parts)})"
+
+
+def _seed_params(fn):
+    """Initial editable values for a function's parameters: the signature
+    default where there is one, a fresh instance of the annotation type
+    otherwise (str -> "", int -> 0, ...), else an empty string."""
+    params = {}
+    for pname, p in inspect.signature(fn).parameters.items():
+        if p.default is not inspect.Parameter.empty:
+            params[pname] = p.default
+        elif isinstance(p.annotation, type):
+            try:
+                params[pname] = p.annotation()
+            except Exception:
+                params[pname] = ""
+        else:
+            params[pname] = ""
+    return params
+
+
+def activate_action(fn):
+    """A search hit's activation: an action with parameters opens the
+    ActionRunner to fill them in; a parameterless one (screenshot,
+    claude_terminal) just RUNS — there is nothing to ask, and a popup with
+    only a Run button was a dead click."""
+    if not inspect.signature(fn).parameters:
+        try:
+            result = fn()
+        except Exception as e:
+            notify(f"Actions.{fn.__name__} failed: {e}", tag="actions")
+        else:
+            notify(f"Actions.{fn.__name__} -> {result!r}" if result is not None
+                   else f"Actions.{fn.__name__} ran", tag="actions")
+        request_render()
+        return
+    open_action_runner(fn)
+
+
+def open_action_runner(fn):
+    """Point the ActionRunner window at `fn` and summon it next to the search
+    window (the same come-to-you placement window hits use)."""
+    ActionRunner.action = fn
+    ActionRunner.params = _seed_params(fn)
+    ActionRunner._focus_requested = True
+    ds = Core.melty.open_window("ActionRunner")
+    if ds is not None:
+        gs = Core.melty.find_window("GlobalSearch")
+        if gs is not None and gs.abs_left is not None:
+            Core.melty.summon_window(ds, gs.abs_left, gs.abs_top)
+        Core.melty.focused_ds = ds
+        # The action and params changed outside the window's body - a cached
+        # blit would keep showing the previous action.
+        ds.invalidate()
+    request_render()
+
+
+def _close_action_runner():
+    """Close the runner and release any text focus a param field holds — the
+    shared exit for the title-row X, Esc (draw_main's root handler) and a
+    successful run."""
+    win = Core.melty.find_window("ActionRunner")
+    if win is not None:
+        win.closed = True
+    Core.melty.text_focused_ds = None
+    request_render()
+
+
+def _run_action(input_value):
+    """Call the runner's action with the edited params. A successful run
+    closes the window; an error keeps it up (with a notification) so the
+    inputs can be fixed."""
+    fn = input_value.action
+    try:
+        result = fn(**dict(input_value.params))
+    except Exception as e:
+        notify(f"Actions.{fn.__name__} failed: {e}", tag="actions")
+    else:
+        notify(f"Actions.{fn.__name__} -> {result!r}" if result is not None
+               else f"Actions.{fn.__name__} ran", tag="actions")
+        _close_action_runner()
+
+
+from meltygui.view.action_view import draw_action_runner
+
+
+@window(view_func=draw_action_runner, mode=Modes.WINDOW_AUTO_FIT, always_on_top=True)
+@defaults(tint=(0.92, 0.58, 0.25))
+class ActionRunner:
+    action = None  # the Actions function the window is parameterizing
+    params = {}    # name -> value being edited, seeded from the signature
+    _focus_requested = False  # one-shot: focus the first str param next frame

meltygui/core/automation/collection_action.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+
+class OperationType(Enum):
+    COPY = 'copy'
+    MOVE = 'move'
+    ADD = 'add'
+    DELETE = 'delete'
+    NAME_CHANGE = 'name_change'
+
+
+class CollectionAction:
+    def __init__(self,
+                 target_unique=None,
+                 source_unique=None,
+                 target_tag=None,
+                 target_key=None,
+                 source_key=None,
+                 source_collection=None,
+                 target_collection=None,
+                 operation=OperationType.MOVE):
+        self.target_unique = target_unique
+        self.target_key = target_key
+        self.target_tag = target_tag
+        self.target_collection = target_collection
+        self.target_draw_state = None
+
+        self.source_unique = source_unique
+        self.source_key = source_key
+        self.source_collection = source_collection
+        self.source_draw_state = None
+
+        self.operation = operation
+        self.class_move = False
+        self.target_class = None
+
+    def print(self):
+        print(f"CollectionAction: op {self.operation}\n"
+              f"source_key {self.source_key}\n"
+              f"source_unique {self.source_unique}\n"
+              f"target_key {self.target_key}\n"
+              f"target_unique {self.target_unique}\n"
+              f"target_tag {self.target_tag}\n"
+              f"source collection {type(self.source_collection).__name__}\n"
+              f"target collection {type(self.target_collection).__name__}")

meltygui/core/automation/mcp_eval.py

@@ -0,0 +1,167 @@
+"""Evaluate Python in the live launcher process via MCP.
+
+When a studio session is running the snippet runs on the render thread (GL
+context current, safe to read/poke Melty + imgui state) via a post_frame
+hand-off, mirroring screenshot.py; otherwise it runs inline on the caller's
+thread (fine for pure-Python inspection of launcher/server state).
+
+`Melty` and `server`/`model_server` are pre-bound; import anything else you
+need. A trailing expression's repr is returned alongside captured stdout/stderr.
+
+This is arbitrary in-process code execution — intended for inspecting and
+poking live state while iterating.
+"""
+
+import threading
+
+_pending = []
+_lock = threading.Lock()
+
+
+def _build_namespace(extra=None):
+    ns = {"__builtins__": __builtins__}
+    try:
+        from meltygui.core.melty import Melty
+        ns["Melty"] = Melty
+        # Conveniences reachable from Melty: the studio (vis) and the root
+        # AppModel (vis.root). Everything here derives from Melty.
+        vis = getattr(Melty, "vis", None)
+        if vis is not None:
+            ns["vis"] = vis
+            root = getattr(vis, "root", None)
+            if root is not None:
+                ns["app"] = root
+                ns["root"] = root
+    except Exception:
+        pass
+    if extra:
+        ns.update(extra)
+    return ns
+
+
+def _run_code(code, extra=None):
+    """Execute `code`, returning (stdout_text, result_repr_or_None, error_or_None).
+
+    Tries to evaluate it as a single expression first (to capture a value);
+    falls back to exec for statements.
+    """
+    import io
+    import contextlib
+    import traceback
+
+    ns = _build_namespace(extra)
+    buf = io.StringIO()
+    result = None
+    error = None
+    with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+        try:
+            try:
+                compiled = compile(code, "<eval_python>", "eval")
+            except SyntaxError:
+                compiled = None
+            if compiled is not None:
+                value = eval(compiled, ns)
+                if value is not None:
+                    result = repr(value)
+            else:
+                exec(compile(code, "<eval_python>", "exec"), ns)
+        except Exception:
+            error = traceback.format_exc()
+    return buf.getvalue(), result, error
+
+
+def request_eval(code, model_server, timeout=10.0):
+    """Run `code` and return formatted text (where it ran + stdout + result/error)."""
+    extra = {"server": model_server, "model_server": model_server}
+
+    studio_running = False
+    try:
+        studio_running = model_server._studio_running()
+    except Exception:
+        pass
+
+    if not studio_running:
+        out, result, error = _run_code(code, extra)
+        return _format(out, result, error, where="launcher thread (no studio)")
+
+    req = {"code": code, "extra": extra, "event": threading.Event(),
+           "out": "", "result": None, "error": None}
+    with _lock:
+        _pending.append(req)
+    try:
+        from meltygui.core.windowing.glfw_utils import request_render
+        request_render()  # force a frame so the request is served soon
+    except Exception:
+        pass
+
+    if not req["event"].wait(timeout):
+        with _lock:
+            if req in _pending:
+                _pending.remove(req)
+        return f"timed out after {timeout:.0f}s waiting for the render thread"
+    return _format(req["out"], req["result"], req["error"], where="render thread")
+
+
+def request_call(fn, model_server, timeout=10.0):
+    """Run the no-arg callable `fn` on the render thread (inline when no
+    studio is running) and return `(result, error_text)`. The typed MCP
+    query tools (mcp_query.py) ride this instead of eval_python's source
+    string: same queue, same post_frame drain, a Python value back."""
+    import traceback
+    studio_running = False
+    try:
+        studio_running = model_server._studio_running()
+    except Exception:
+        pass
+    if not studio_running:
+        try:
+            return fn(), None
+        except Exception:
+            return None, traceback.format_exc()
+
+    req = {"fn": fn, "event": threading.Event(), "result": None, "error": None}
+    with _lock:
+        _pending.append(req)
+    try:
+        from meltygui.core.windowing.glfw_utils import request_render
+        request_render()
+    except Exception:
+        pass
+    if not req["event"].wait(timeout):
+        with _lock:
+            if req in _pending:
+                _pending.remove(req)
+        return None, f"timed out after {timeout:.0f}s waiting for the render thread"
+    return req["result"], req["error"]
+
+
+def process_evals():
+    """Run pending eval requests on the render thread. Call from post_frame."""
+    import traceback
+    with _lock:
+        if not _pending:
+            return
+        reqs = _pending[:]
+        _pending.clear()
+    for req in reqs:
+        if "fn" in req:
+            try:
+                req["result"] = req["fn"]()
+            except Exception:
+                req["error"] = traceback.format_exc()
+        else:
+            req["out"], req["result"], req["error"] = _run_code(req["code"], req["extra"])
+        req["event"].set()
+
+
+def _format(out, result, error, where):
+    parts = [f"[ran on {where}]"]
+    if out.strip():
+        parts.append("stdout:\n" + out.rstrip())
+    if result is not None:
+        parts.append("result: " + result)
+    if error:
+        parts.append("error:\n" + error.rstrip())
+    if len(parts) == 1:
+        parts.append("(no output)")
+    return "\n".join(parts)

meltygui/core/automation/mcp_hotswap.py

@@ -0,0 +1,107 @@
+"""Hotswap a project source file into the running process, for the MCP server.
+
+Lets an MCP caller apply code edits to a live studio without a full restart. It
+reuses the editor's hotswap machinery rather than re-implementing it:
+
+* ``_recompile_module`` (file_converters.py) compiles the new source and patches
+  every function/class in the module **in place** — existing references (imported
+  names, live instances) keep working because their ``__code__`` is overwritten
+  rather than the objects being replaced.
+* It registers a rollback with ``hotswap_guard``, so a swap that compiles cleanly
+  but throws at runtime is auto-reverted by the render loop's except hook.
+* ``is_editable_source`` is the same fail-closed gate the editor uses — only paths
+  inside the project tree are ever compiled or written.
+
+The launcher (which hosts the MCP server) runs the studio in-process, so the
+studio's modules live in this process's ``sys.modules`` and can be patched from
+the MCP server thread — the same off-render-thread path the editor's background
+recompile already uses.
+"""
+
+import sys
+from pathlib import Path
+
+
+def _resolve_module(path):
+    """Find the live module object loaded from `path` (resolved), or None."""
+    target = Path(path).resolve()
+    for mod in list(sys.modules.values()):
+        f = getattr(mod, "__file__", None)
+        if not f:
+            continue
+        try:
+            if Path(f).resolve() == target:
+                return mod
+        except (OSError, ValueError):
+            continue
+    return None
+
+
+def hotswap_file(path, source=None):
+    """Recompile `path`'s module into the running process and return a status line.
+
+    If `source` is None, the file's current on-disk contents are reloaded. If
+    `source` is given, it is hotswapped first and persisted to disk only after a
+    clean compile, so a syntax error never leaves broken code on disk.
+    """
+    # Imported lazily: this module is loaded by the MCP server, which must not
+    # drag in the (imgui-heavy) editor stack unless a hotswap is actually asked for.
+    from meltygui.code.file_converters import _recompile_module
+    from meltygui.code.fileref import is_editable_source
+    from meltygui.code.libcst_conversion import invalidate_usage_cache
+
+    p = Path(path).resolve()
+    if not is_editable_source(p):
+        return f"refusing to hotswap source outside the project tree: {p}"
+    if source is None and not p.exists():
+        return f"no such file: {p}"
+
+    module = _resolve_module(p)
+    if module is None:
+        return (f"no live module is loaded from {p} — nothing to hotswap. "
+                f"(The file must already be imported in the running process.)")
+
+    provided = source is not None
+    if not provided:
+        try:
+            source = p.read_text(encoding="utf-8")
+        except Exception as e:
+            return f"could not read {p}: {e}"
+
+    # Swap the live module from the in-memory source first; only touch disk on
+    # success. _recompile_module RAISES on a syntax error (compile() in its
+    # try) and RETURNS the exception on an exec-time error - handle both.
+    try:
+        err = _recompile_module(module, source, str(p))
+    except Exception as e:
+        err = e
+    if err is not None:
+        return (f"hotswap FAILED for {module.__name__} ({p.name}): "
+                f"{type(err).__name__}: {err} — live module unchanged, disk unchanged")
+
+    if provided:
+        try:
+            p.write_text(source, encoding="utf-8")
+        except Exception as e:
+            return (f"hotswapped {module.__name__} live, but FAILED to persist to disk: {e} "
+                    f"— change will be lost on restart")
+
+    # Refresh the line caches in BOTH paths - a from-disk reload means the file
+    # was just changed by an external editor, so linecache may still hold the
+    # pre-save content. Stale lines make getsourcelines-based span resolution
+    # (and thus the in-process editor's next save) splice at wrong offsets.
+    invalidate_usage_cache(p)
+    import linecache
+    linecache.checkcache(str(p))
+
+    # Wake the render loop so the new code runs on the next frame.
+    try:
+        from meltygui.core.windowing.glfw_utils import request_render
+        request_render()
+    except Exception:
+        pass
+
+    verb = "applied + saved to disk" if provided else "reloaded from disk"
+    return (f"hotswapped {module.__name__} ({p.name}) — {verb}. "
+            f"Every function/class in the file was patched in place; a runtime "
+            f"error will auto-revert it via the hotswap guard.")