inscript-lang 2.13.0__tar.gz → 3.0.0__tar.gz

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.13.0
+Version: 3.0.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.13.0"
+VERSION = "3.0.0"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"
@@ -2752,6 +2752,17 @@ Examples:
                         help="v2.12.0: Start Electron bridge JSON-RPC server")
     parser.add_argument("--bridge-port", type=int, default=8765,
                         help="v2.12.0: Port for --studio-bridge (default: 8765)")
+    # v3.0.0: Studio + Visual Scripting
+    parser.add_argument("--studio", action="store_true",
+                        help="v3.0.0: Launch InScript Studio web IDE in browser")
+    parser.add_argument("--studio-port", type=int, default=8080,
+                        help="v3.0.0: Port for Studio web app (default: 8080)")
+    parser.add_argument("--visual-compile", metavar="FILE",
+                        help="v3.0.0: Compile a .vins visual script to .ins source")
+    parser.add_argument("--vins-output", metavar="FILE",
+                        help="v3.0.0: Output path for --visual-compile (default: <input>.ins)")
+    parser.add_argument("--vins-template", metavar="NAME",
+                        help="v3.0.0: Generate a .vins template for visual scripting")
     parser.add_argument("--lsp", action="store_true",
                         help="Start the Language Server (requires: pip install pygls)")
     parser.add_argument("--game", action="store_true",
@@ -3067,6 +3078,57 @@ Examples:
             bridge.stop()
         return 0
 
+    # ── v3.0.0 Studio + Visual Scripting ──────────────────────────────────
+    if getattr(args, 'studio', False):
+        import time as _time
+        studio_port = getattr(args, 'studio_port', 8080)
+        bridge_port = getattr(args, 'bridge_port', 8765)
+        proj_dir    = getattr(args, 'project_dir', '.') or '.'
+        from studio_app import StudioApp
+        app_s = StudioApp(proj_dir, studio_port=studio_port, bridge_port=bridge_port)
+        app_s.start()
+        url = app_s.url
+        print(f"[InScript Studio] ✅  Running at {url}")
+        print(f"[InScript Studio] Project: {os.path.abspath(proj_dir)}")
+        print(f"[InScript Studio] Ctrl+C to stop")
+        # Open browser
+        try:
+            import webbrowser as _wb
+            _wb.open(url)
+        except Exception:
+            pass
+        try:
+            while True: _time.sleep(1)
+        except KeyboardInterrupt:
+            app_s.stop()
+            print(f"[InScript Studio] Stopped.")
+        return 0
+
+    if getattr(args, 'visual_compile', None) is not None:
+        from visual_script import compile_file
+        vins_path = args.visual_compile
+        out_path  = getattr(args, 'vins_output', None)
+        if not os.path.isfile(vins_path):
+            print(f"[visual] File not found: {vins_path}", file=sys.stderr); return 1
+        try:
+            result_path = compile_file(vins_path, out_path)
+            print(f"[visual] Written to: {result_path}")
+        except Exception as _ve:
+            print(f"[visual] Compile error: {_ve}", file=sys.stderr); return 1
+        return 0
+
+    if getattr(args, 'vins_template', None) is not None:
+        import json as _j
+        from visual_script import make_template
+        name     = args.vins_template
+        out_path = f"{name}.vins"
+        tmpl     = make_template(name)
+        with open(out_path, "w") as f:
+            _j.dump(tmpl, f, indent=2)
+        print(f"[visual] Template written to {out_path}")
+        print(f"[visual] Compile with: inscript --visual-compile {out_path}")
+        return 0
+
     # v1.9.1: --no-typecheck is deprecated — emit a warning and honour it
     if getattr(args, 'no_typecheck', False):
         print(

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.13.0
+Version: 3.0.0
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/setup.py

@@ -57,6 +57,7 @@ setup(
         # ── v2.7.0+ runtime modules ───────────────────────────────────────────
         "scene_tree", "hot_reload", "export_pipeline",
         "studio_bridge", "inscript_studio_api", "studio_readiness",
+        "visual_script", "studio_app", "vins_editor",
     ],
     package_data     = {"": ["examples/*.ins", "lsp/*.py", "*.md"]},
     install_requires = [],

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/stdlib.py

@@ -1163,3 +1163,46 @@ try:
     import stdlib_assets  # noqa: F401
 except Exception as _e4:
     import sys; print(f'[stdlib_assets load error] {_e4}', file=sys.stderr)
+
+# ── Studio IPC (v3.0.0): allows subprocess games to publish scene state ──────
+try:
+    from studio_bridge import _IPC_STATE_FILE, _ipc_write_scene
+
+    def _studio_publish_scene(scene_manager_or_dict=None):
+        """
+        Called from .ins: import "studio_ipc" as ipc; ipc.publish_scene()
+        Writes current scene state to the IPC file so Studio can inspect it.
+        """
+        import json as _j
+        data = {"nodes": [], "count": 0, "source": "ipc"}
+        if scene_manager_or_dict is not None:
+            try:
+                from scene_tree import SceneManager, SceneTree
+                if hasattr(scene_manager_or_dict, 'current'):
+                    sm = scene_manager_or_dict
+                    if sm.current:
+                        nodes = []
+                        def _walk(inst, parent=None):
+                            nodes.append({
+                                "name": inst.name,
+                                "blueprint": inst.blueprint.name,
+                                "parent": parent,
+                                "children": [c.name for c in inst.get_children()],
+                                "props": {k: str(v) for k, v in inst._props.items()
+                                          if not callable(v)},
+                            })
+                            for child in inst.get_children():
+                                _walk(child, inst.name)
+                        _walk(sm.current.root)
+                        data = {"nodes": nodes, "count": len(nodes), "source": "ipc"}
+            except Exception:
+                pass
+        _ipc_write_scene(data)
+
+    from stdlib import register_module as _rm
+    _rm("studio_ipc", {
+        "publish_scene": _studio_publish_scene,
+        "ipc_file":      _IPC_STATE_FILE,
+    })
+except Exception as _se:
+    pass

{inscript_lang-2.13.0 → inscript_lang-3.0.0}/studio_bridge.py

@@ -583,3 +583,159 @@ def _INPUT_MANAGER_INSTANCE():
         return _imi
     except ImportError:
         return None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# v3.0.0: IPC scene state file (fixes subprocess/inspection disconnect)
+# ─────────────────────────────────────────────────────────────────────────────
+# When a game runs via start_game, it cannot be introspected directly from
+# the bridge because they are separate processes. The fix: the game process
+# writes its live scene state to a temp JSON file every N frames.
+# The bridge reads that file for get_live_scene / set_node_prop.
+
+import tempfile as _tempfile
+
+_IPC_STATE_FILE = os.path.join(_tempfile.gettempdir(), "inscript_studio_ipc.json")
+
+
+def _ipc_write_scene(scene_data: dict) -> None:
+    """Called from within the game process to publish scene state."""
+    try:
+        import json as _j
+        tmp = _IPC_STATE_FILE + ".tmp"
+        with open(tmp, "w") as f:
+            _j.dump(scene_data, f)
+        os.replace(tmp, _IPC_STATE_FILE)
+    except Exception:
+        pass
+
+
+def _ipc_read_scene() -> dict:
+    """Called from the bridge to read scene state written by game process."""
+    try:
+        import json as _j
+        with open(_IPC_STATE_FILE) as f:
+            return _j.load(f)
+    except Exception:
+        return {"nodes": [], "count": 0, "source": "ipc"}
+
+
+def _extend_bridge_v300(bridge_cls):
+    """v3.0.0 patches: real build RPC, IPC-aware get_live_scene."""
+
+    # ── Real build RPC ────────────────────────────────────────────────────────
+    def _rpc_build(self, params: dict) -> dict:
+        """
+        Actually runs `inscript --build <target> --project-dir <dir>`.
+        Non-blocking — spawns subprocess, streams output to _build_output.
+        """
+        target      = params.get("target", "desktop")
+        project_dir = params.get("project_dir", ".")
+
+        if not hasattr(self, "_build_outputs"):
+            self._build_outputs = {}
+        if not hasattr(self, "_build_procs"):
+            self._build_procs   = {}
+
+        inscript_py = os.path.join(os.path.dirname(__file__), "inscript.py")
+        cmd = [sys.executable, inscript_py,
+               "--build", target,
+               "--project-dir", os.path.abspath(project_dir)]
+
+        output_lines = []
+        self._build_outputs[target] = output_lines
+
+        def _run():
+            try:
+                proc = _subprocess.Popen(
+                    cmd, stdout=_subprocess.PIPE, stderr=_subprocess.STDOUT,
+                    text=True, bufsize=1
+                )
+                self._build_procs[target] = proc
+                for line in proc.stdout:
+                    output_lines.append(line.rstrip("\n"))
+                proc.wait()
+                status = "ok" if proc.returncode == 0 else "error"
+                output_lines.append(f"[build:{target}] exit {proc.returncode} — {status}")
+            except Exception as e:
+                output_lines.append(f"[build:{target}] ERROR: {e}")
+
+        t = threading.Thread(target=_run, daemon=True)
+        t.start()
+        return {"started": True, "target": target,
+                "project_dir": os.path.abspath(project_dir)}
+
+    def _rpc_build_status(self, params: dict) -> dict:
+        """Poll build output since a given line index."""
+        target = params.get("target", "desktop")
+        since  = int(params.get("since", 0))
+        outputs = getattr(self, "_build_outputs", {})
+        lines   = outputs.get(target, [])
+        proc    = getattr(self, "_build_procs", {}).get(target)
+        running = proc is not None and proc.poll() is None
+        return {
+            "target":  target,
+            "running": running,
+            "output":  lines[since:],
+            "total":   len(lines),
+        }
+
+    # ── IPC-aware get_live_scene ──────────────────────────────────────────────
+    def _rpc_get_live_scene_v300(self, params: dict) -> dict:
+        """
+        v3.0.0: Check both sources:
+          1. Bridge's own interpreter (if run() was called)
+          2. IPC file (if start_game subprocess is running and wrote state)
+        """
+        # Check if we have a live interpreter
+        with self._lock:
+            if self._interp is not None:
+                from scene_tree import NodeInstance
+                nodes = []
+                for name, val in self._interp._globals._store.items():
+                    if isinstance(val, NodeInstance):
+                        nodes.append({
+                            "name":      name,
+                            "blueprint": val.blueprint.name,
+                            "parent":    val._parent.name if val._parent else None,
+                            "children":  [c.name for c in val.get_children()],
+                            "props":     {k: str(v) for k, v in val._props.items()
+                                          if not callable(v)},
+                        })
+                if nodes:
+                    return {"nodes": nodes, "count": len(nodes), "source": "interpreter"}
+
+        # Fall back to IPC file (subprocess game)
+        ipc = _ipc_read_scene()
+        if ipc.get("nodes"):
+            return ipc
+
+        # Check if game process is running — give a hint
+        gp = getattr(self, "_game_process", None)
+        if gp and gp.is_running():
+            return {"nodes": [], "count": 0,
+                    "source": "ipc",
+                    "hint": ("Game is running as subprocess. To enable live scene "
+                             "inspection, add this to your .ins file: "
+                             "'import \"studio_ipc\" as ipc' and call 'ipc.publish_scene()'.")}
+        return {"nodes": [], "count": 0, "source": "none"}
+
+    # ── Patch dispatch ────────────────────────────────────────────────────────
+    _NEW_V300 = {
+        "build":          _rpc_build,
+        "build_status":   _rpc_build_status,
+    }
+
+    _orig_dispatch_v300 = bridge_cls._dispatch
+
+    def _new_dispatch_v300(self, method, params):
+        if method == "get_live_scene":
+            return _rpc_get_live_scene_v300(self, params)
+        if method in _NEW_V300:
+            return _NEW_V300[method](self, params)
+        return _orig_dispatch_v300(self, method, params)
+
+    bridge_cls._dispatch = _new_dispatch_v300
+
+
+_extend_bridge_v300(StudioBridge)