asecli 0.6.2__py3-none-any.whl

asecli/bridge/gui_support.py

@@ -0,0 +1,240 @@
+"""Inspect and install ASECLI's clean-room Unity material GUI."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ..core import ASECLI_GUI_EDITOR, MZGUI_EDITOR
+from ._gui_project import unity_project
+from ._gui_resource_store import install_gui_resource
+from ._gui_resource_upgrade import upgrade_backup_path, upgrade_gui_resource
+from .gui_provider_detection import (
+    runtime_providers,
+    scan_native_mzgui,
+    validate_runtime_probe,
+)
+from .gui_presentation import inspect_inline_help_presentation, require_inline_help_presentation
+from .gui_support_resource import (
+    GUI_AUTHORING_SHA256,
+    GUI_AUTHORING_SOURCE,
+    GUI_SUPPORT_ASSET_PATH,
+    GUI_SUPPORT_KNOWN_PREVIOUS,
+    GUI_SUPPORT_RESOURCE_PARTS,
+    GUI_SUPPORT_SHA256,
+    GUI_SUPPORT_SOURCE,
+    gui_target_state,
+)
+
+
+def inspect_gui_support(
+    project_root: str | Path, *, runtime_probe: dict | None = None
+) -> dict:
+    """Prefer native MZGUI; otherwise select ASECLI's Editor fallback."""
+    project = unity_project(project_root, GUI_SUPPORT_ASSET_PATH)
+    native_evidence, native_candidates = scan_native_mzgui(
+        project.root, skip_source_name=Path(GUI_SUPPORT_ASSET_PATH).name
+    )
+    runtime_provider_details: list[dict] = []
+    if runtime_probe is not None:
+        validate_runtime_probe(runtime_probe, project.assets)
+        runtime_provider_details = runtime_providers(runtime_probe)
+        runtime_native = [
+            item
+            for item in runtime_provider_details
+            if item["shader_gui"] and not item["fallback"]
+        ]
+        if len(runtime_provider_details) == 1 and runtime_native:
+            native_evidence = [
+                *native_evidence,
+                "runtime:" + runtime_native[0]["assembly"],
+            ]
+        elif not runtime_provider_details and native_evidence:
+            native_candidates = [*native_candidates, *native_evidence]
+            native_evidence = []
+    target_state, actual_sha256 = gui_target_state(project.target)
+    providers = []
+    if native_evidence:
+        providers.append("native_mzgui")
+    if target_state in {"installed", "upgrade_available"}:
+        providers.append("asecli_compat")
+    elif target_state == "native_extension":
+        providers.append("asecli_authoring_extension")
+    runtime_fallback = [item for item in runtime_provider_details if item["fallback"]]
+    runtime_conflict = len(runtime_provider_details) > 1
+    if runtime_conflict:
+        provider = "multiple"
+        recommended_editor = None
+    elif native_evidence:
+        if target_state in {"installed", "upgrade_available"}:
+            provider = "multiple"
+            recommended_editor = None
+        elif target_state == "conflict":
+            provider = "target_conflict"
+            recommended_editor = None
+        else:
+            provider = "native_mzgui"
+            recommended_editor = MZGUI_EDITOR
+    elif runtime_fallback and target_state == "absent":
+        provider = "fallback_external"
+        recommended_editor = MZGUI_EDITOR
+    elif target_state in {"conflict", "native_extension"}:
+        provider = "target_conflict"
+        recommended_editor = None
+    elif native_candidates:
+        provider = "unknown"
+        recommended_editor = None
+    elif target_state == "installed":
+        provider = "asecli_compat"
+        recommended_editor = MZGUI_EDITOR
+    elif target_state == "upgrade_available":
+        provider = "asecli_upgrade_available"
+        recommended_editor = MZGUI_EDITOR
+    else:
+        provider = "missing"
+        recommended_editor = MZGUI_EDITOR
+    upgrade_from = GUI_SUPPORT_KNOWN_PREVIOUS.get(actual_sha256)
+    backup = (
+        upgrade_backup_path(project.target, actual_sha256, GUI_SUPPORT_KNOWN_PREVIOUS)
+        if upgrade_from
+        else None
+    )
+
+    return {
+        "project_root": str(project.root),
+        "provider": provider,
+        "providers": providers,
+        "recommended_editor": recommended_editor,
+        "native_mzgui": {
+            "detected": bool(native_evidence),
+            "status": "detected" if native_evidence else ("unknown" if native_candidates else "not_detected"),
+            "editor": MZGUI_EDITOR,
+            "evidence": sorted(set(native_evidence)),
+            "candidates": sorted(set(native_candidates)),
+            "runtime_probe": runtime_probe,
+            "runtime_providers": runtime_provider_details,
+        },
+        "asecli_material_gui": {
+            "editor": MZGUI_EDITOR,
+            "legacy_editor_alias": ASECLI_GUI_EDITOR,
+            "target": str(project.target),
+            "asset_path": GUI_SUPPORT_ASSET_PATH,
+            "state": target_state,
+            "expected_sha256": GUI_SUPPORT_SHA256,
+            "actual_sha256": actual_sha256,
+            "upgrade_available": upgrade_from is not None,
+            "upgrade_from": upgrade_from,
+            "backup": str(backup) if backup else None,
+        },
+        "capabilities": {
+            "foldout": "FoldoutMzgui",
+            "tooltip": "TooltipMzgui",
+            "help_box": "HelpBoxMzgui",
+            "enabled_if": "EnableIfMzgui",
+            "inline_help_presentation": inspect_inline_help_presentation(GUI_SUPPORT_SOURCE),
+            "fallback_editor": MZGUI_EDITOR,
+            "legacy_fallback_editor": ASECLI_GUI_EDITOR,
+            "authoring": {
+                "surface": "Window/Amplify Shader Editor/MZGUI Attributes (ASECLI)",
+                "storage": "ase_custom_attributes",
+                "version_strategy": "runtime_capability_probe",
+                "patches_ase_source": False,
+            },
+            "automatic_technical_tooltip": ["property_name", "shader_default_value"],
+            "ase_version_dependency": False,
+        },
+        "would_write": provider in {"missing", "asecli_upgrade_available"}
+        or (provider == "native_mzgui" and target_state == "absent"),
+        "written": False,
+    }
+
+
+def install_gui_support(
+    project_root: str | Path,
+    *,
+    write: bool = False,
+    runtime_probe: dict | None = None,
+) -> dict:
+    """Inject the Editor fallback only after native MZGUI was ruled out."""
+    state = inspect_gui_support(project_root, runtime_probe=runtime_probe)
+    if state["provider"] == "multiple":
+        raise RuntimeError(
+            "native MZGUI and ASECLI fallback are both installed; remove the ASECLI fallback "
+            "before selecting MZGUI.MZGUI"
+        )
+    if state["provider"] == "native_mzgui":
+        target_state = state["asecli_material_gui"]["state"]
+        if target_state == "native_extension":
+            state["action"] = "use_native_mzgui"
+            state["would_write"] = False
+            return state
+        state["action"] = "install_native_mzgui_extension"
+        if not write:
+            return state
+        project = unity_project(project_root, GUI_SUPPORT_ASSET_PATH)
+        install_gui_resource(project, GUI_AUTHORING_SOURCE.encode("utf-8"))
+        installed = inspect_gui_support(project_root, runtime_probe=runtime_probe)
+        if installed["provider"] != "native_mzgui" or installed[
+            "asecli_material_gui"
+        ]["state"] != "native_extension":
+            raise RuntimeError("ASECLI native MZGUI extension failed digest verification")
+        installed.update(
+            action="install_native_mzgui_extension",
+            would_write=False,
+            written=True,
+            requires_editor_recompile=True,
+        )
+        return installed
+    if state["provider"] == "fallback_external":
+        state["action"] = "use_external_fallback"
+        state["would_write"] = False
+        return state
+    if state["provider"] == "unknown":
+        raise RuntimeError(
+            "native MZGUI may exist in an unverified source or assembly; run gui-support "
+            "with --runtime-probe while the target Editor is connected before installing"
+        )
+    if write:
+        require_inline_help_presentation(GUI_SUPPORT_SOURCE)
+    target_state = state["asecli_material_gui"]["state"]
+    if target_state == "conflict":
+        raise FileExistsError(
+            "ASECLI GUI support target already exists with different content; refusing to overwrite: "
+            + state["asecli_material_gui"]["target"]
+        )
+    if target_state == "installed":
+        state["action"] = "already_installed"
+        state["would_write"] = False
+        return state
+
+    upgrading = target_state == "upgrade_available"
+    state["action"] = (
+        "upgrade_asecli_material_gui" if upgrading else "install_asecli_material_gui"
+    )
+    if not write:
+        return state
+
+    project = unity_project(project_root, GUI_SUPPORT_ASSET_PATH)
+    backup_path = None
+    if upgrading:
+        backup_path = upgrade_gui_resource(
+            project,
+            GUI_SUPPORT_SOURCE.encode("utf-8"),
+            state["asecli_material_gui"]["actual_sha256"],
+            GUI_SUPPORT_KNOWN_PREVIOUS,
+        )
+    else:
+        install_gui_resource(project, GUI_SUPPORT_SOURCE.encode("utf-8"))
+
+    installed = inspect_gui_support(project_root, runtime_probe=runtime_probe)
+    if installed["asecli_material_gui"]["state"] != "installed":
+        raise RuntimeError("ASECLI GUI support was written but failed digest verification")
+    installed["action"] = (
+        "upgrade_asecli_material_gui" if upgrading else "install_asecli_material_gui"
+    )
+    installed["would_write"] = False
+    installed["written"] = True
+    installed["requires_editor_recompile"] = True
+    installed["backed_up"] = backup_path is not None
+    installed["backup"] = str(backup_path) if backup_path else None
+    return installed

asecli/bridge/gui_support_resource.py

@@ -0,0 +1,58 @@
+"""Packaged GUI resource composition and known upgrade identities."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+from .resource_text import compose_resource_text
+
+
+GUI_SUPPORT_ASSET_PATH = "Assets/Editor/ASECLI/ASECLIMaterialGUI.cs"
+GUI_SUPPORT_RESOURCE_PARTS = (
+    "asecli_material_gui.part00.cs.txt",
+    "asecli_material_gui.part01.cs.txt",
+    "asecli_material_gui.authoring.part00.cs.txt",
+    "asecli_material_gui.authoring.store.cs.txt",
+    "asecli_material_gui.authoring.part01.cs.txt",
+    "asecli_material_gui.reconciliation.cs.txt",
+    "asecli_material_gui.transaction.cs.txt",
+    "asecli_material_gui.hydration.cs.txt",
+    "asecli_material_gui.condition.cs.txt",
+)
+GUI_SUPPORT_SOURCE = compose_resource_text(
+    "asecli.bridge", "resources", GUI_SUPPORT_RESOURCE_PARTS
+)
+GUI_SUPPORT_SHA256 = hashlib.sha256(GUI_SUPPORT_SOURCE.encode("utf-8")).hexdigest()
+GUI_AUTHORING_RESOURCE_PARTS = GUI_SUPPORT_RESOURCE_PARTS[2:]
+GUI_AUTHORING_SOURCE = compose_resource_text(
+    "asecli.bridge", "resources", GUI_AUTHORING_RESOURCE_PARTS
+)
+GUI_AUTHORING_SHA256 = hashlib.sha256(GUI_AUTHORING_SOURCE.encode("utf-8")).hexdigest()
+GUI_SUPPORT_KNOWN_PREVIOUS = {
+    "cf45c7d6ad6aa79880205d73f7a6db45e20239cb312f91743056c5efa00b41b8": "0.2.0-original",
+    "9541c541628b8404c66ca2c36e80af25f69960d6e1a07deabad53fd6233c5b7a": "0.3.1-material-only",
+    "04a618f5b95ce564fe70e72f5ef8fe7b9c59394c53e9ec682efe27310dc4a493": "0.3.1-material-only",
+    "76a092825c44ea43fa10bde7cd4185c3af1d3c26a900d90da2d8fadde150967f": "0.3.1-authoring-preview",
+    "77ccadf84e3c2c1eddff343ae535c09af15402b92172e772efdf481d06c3433e": "0.3.1-authoring-preview",
+    "9249b3245c01052e27bb8cf82b9e0c05e8f20ac2adfe21796a1777c4857a25ca": "0.3.1-authoring-preview",
+    "738a79e7e9198dd6b21879d7d42dfad4dae6b74ef6e50e7cf17c4b3372d0e92c": "0.3.2-portable-mzgui",
+    "e0fa59a9fa3ca2840f8ee2d76e03fbbb862919d2476aefec0fe7f4e64150f034": "tooltip-contract",
+}
+
+
+def gui_target_state(target: Path) -> tuple[str, str | None]:
+    if target.is_symlink():
+        return "conflict", None
+    if not target.exists():
+        return "absent", None
+    if not target.is_file():
+        return "conflict", None
+    actual = hashlib.sha256(target.read_bytes()).hexdigest()
+    if actual == GUI_SUPPORT_SHA256:
+        return "installed", actual
+    if actual == GUI_AUTHORING_SHA256:
+        return "native_extension", actual
+    if actual in GUI_SUPPORT_KNOWN_PREVIOUS:
+        return "upgrade_available", actual
+    return "conflict", actual

asecli/bridge/mcp_client.py

@@ -0,0 +1,231 @@
+"""Minimal MCP (Model Context Protocol) streamable-HTTP client.
+
+Speaks just enough JSON-RPC to reach an ``mcp-for-unity`` server:
+initialize -> notifications/initialized -> tools/call.
+Handles both plain-JSON and SSE-framed responses.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from .. import __version__
+
+
+class McpError(RuntimeError):
+    def __init__(self, message: str, *, data: dict | None = None):
+        super().__init__(message)
+        self.data = data
+
+
+def redact(text: str, *secrets: str | None) -> str:
+    for secret in secrets:
+        if secret:
+            text = text.replace(secret, "<redacted>")
+    return text
+
+
+def _timeout_error(
+    phase: str,
+    started: float,
+    budget: float,
+    *,
+    now: float | None = None,
+) -> McpError:
+    elapsed_ms = max(0, round(((time.monotonic() if now is None else now) - started) * 1000))
+    budget_ms = max(0, round(budget * 1000))
+    return McpError(
+        f"MCP {phase} timed out after {elapsed_ms} ms (budget {budget_ms} ms)",
+        data={
+            "phase": phase,
+            "elapsed_ms": elapsed_ms,
+            "budget_ms": budget_ms,
+        },
+    )
+
+
+def validate_mcp_url(url: str, allow_remote: bool = False) -> str:
+    """Validate the MCP endpoint without resolving or contacting it."""
+    try:
+        parsed = urllib.parse.urlsplit(url)
+        host = parsed.hostname
+        parsed.port
+    except ValueError as exc:
+        raise McpError("invalid MCP URL") from exc
+    if parsed.scheme not in {"http", "https"} or not host:
+        raise McpError("MCP URL must use http or https")
+    if parsed.username is not None or parsed.password is not None or parsed.query or parsed.fragment:
+        raise McpError("MCP URL must not contain credentials, query parameters, or fragments")
+    if host.lower() not in {"127.0.0.1", "localhost", "::1"} and not allow_remote:
+        raise McpError("remote MCP URL requires --allow-remote-mcp")
+    return url
+
+
+class NoRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """Never forward MCP headers or tokens to a redirect target."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def tool_text(result: dict, *secrets: str | None) -> str:
+    """Return textual MCP tool output, rejecting tool-level error envelopes."""
+    content = result.get("content")
+    texts = []
+    if isinstance(content, list):
+        texts = [item.get("text", "") for item in content if isinstance(item, dict) and item.get("type") == "text"]
+    summary = "\n".join(text for text in texts if text).strip()
+    if result.get("isError"):
+        detail = redact(summary[:300] or "no error details", *secrets)
+        raise McpError(f"MCP tool failed: {detail}")
+    if not summary:
+        raise McpError("MCP tool returned no textual result")
+    return summary
+
+
+class McpClient:
+    def __init__(
+        self,
+        url: str,
+        instance_token: str | None = None,
+        timeout: float = 120.0,
+        allow_remote: bool = False,
+        *,
+        connect_timeout: float = 20.0,
+    ):
+        self.url = validate_mcp_url(url, allow_remote=allow_remote)
+        self.instance_token = instance_token
+        self.timeout = timeout
+        self.connect_timeout = connect_timeout
+        self.session_id: str | None = None
+        self._next_id = 0
+        self._opener = urllib.request.build_opener(NoRedirectHandler())
+
+    def _post(self, payload: dict, *, timeout: float | None = None) -> dict | None:
+        expected_id = payload.get("id")
+        phase = str(payload.get("method", "request"))
+        effective_timeout = self.timeout if timeout is None else timeout
+        started = time.monotonic()
+        body = json.dumps(payload).encode("utf-8")
+        headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"}
+        if self.session_id:
+            headers["Mcp-Session-Id"] = self.session_id
+        if self.instance_token:
+            headers["X-Unity-Instance-Token"] = self.instance_token
+        req = urllib.request.Request(self.url, data=body, headers=headers, method="POST")
+        try:
+            with self._opener.open(req, timeout=effective_timeout) as resp:
+                sid = resp.headers.get("Mcp-Session-Id")
+                if sid:
+                    self.session_id = sid
+                ctype = resp.headers.get("Content-Type", "")
+                raw = resp.read().decode("utf-8")
+        except urllib.error.HTTPError as e:
+            detail = redact(e.read().decode("utf-8", "replace")[:300], self.instance_token)
+            raise McpError(f"HTTP {e.code}: {detail}") from e
+        except urllib.error.URLError as e:
+            if isinstance(e.reason, TimeoutError):
+                raise _timeout_error(phase, started, effective_timeout) from e
+            detail = redact(str(e.reason), self.instance_token)
+            raise McpError(f"cannot reach MCP server: {detail}") from e
+        except TimeoutError as e:
+            raise _timeout_error(phase, started, effective_timeout) from e
+        if "text/event-stream" in ctype:
+            collected: list[dict] = []
+            for line in raw.splitlines():
+                if line.startswith("data:"):
+                    chunk = line[5:].strip()
+                    if chunk and chunk != "[DONE]":
+                        try:
+                            frame = json.loads(chunk)
+                        except json.JSONDecodeError as exc:
+                            raise McpError("MCP SSE response contained malformed JSON") from exc
+                        if isinstance(frame, dict):
+                            collected.append(frame)
+            if not collected:
+                return None
+            if expected_id is None:
+                return None
+            return _matching_response(collected, expected_id)
+        if not raw.strip():
+            return None
+        try:
+            response = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise McpError("MCP response contained malformed JSON") from exc
+        if not isinstance(response, dict):
+            raise McpError("MCP JSON-RPC response must be an object")
+        if expected_id is None:
+            return response
+        return _matching_response([response], expected_id)
+
+    def _rpc(
+        self,
+        method: str,
+        params: dict | None = None,
+        notify: bool = False,
+        timeout: float | None = None,
+    ) -> dict | None:
+        self._next_id += 1
+        payload: dict = {"jsonrpc": "2.0", "method": method}
+        if params is not None:
+            payload["params"] = params
+        if not notify:
+            payload["id"] = self._next_id
+        resp = self._post(payload) if timeout is None else self._post(payload, timeout=timeout)
+        if notify:
+            return None
+        if resp is None:
+            raise McpError(f"empty response for {method}")
+        if "error" in resp:
+            detail = redact(str(resp["error"]), self.instance_token)
+            raise McpError(f"{method}: {detail}")
+        return resp
+
+    def connect(self) -> dict:
+        started = time.monotonic()
+        deadline = started + self.connect_timeout
+
+        def remaining(phase: str) -> float:
+            now = time.monotonic()
+            value = deadline - now
+            if value > 0:
+                return value
+            raise _timeout_error(phase, started, self.connect_timeout, now=now)
+
+        resp = self._rpc(
+            "initialize",
+            {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "asecli", "version": __version__},
+            },
+            timeout=remaining("initialize"),
+        )
+        self._rpc(
+            "notifications/initialized",
+            {},
+            notify=True,
+            timeout=remaining("notifications/initialized"),
+        )
+        return resp.get("result", {}).get("serverInfo", {})
+
+    def call_tool(self, name: str, arguments: dict) -> dict:
+        resp = self._rpc("tools/call", {"name": name, "arguments": arguments})
+        result = resp.get("result", {})
+        tool_text(result, self.instance_token)
+        return result
+
+
+def _matching_response(frames: list[dict], expected_id: object) -> dict:
+    matches = [frame for frame in frames if frame.get("id") == expected_id]
+    if not matches:
+        observed = [frame.get("id") for frame in frames if "id" in frame]
+        raise McpError(f"JSON-RPC response id mismatch: expected {expected_id!r}, observed {observed!r}")
+    if len(matches) > 1:
+        raise McpError(f"duplicate JSON-RPC responses for request id {expected_id!r}")
+    return matches[0]

asecli/bridge/recompile.py

@@ -0,0 +1,107 @@
+"""Trigger ASE regeneration for a shader inside a running Unity/Tuanjie editor (TASK-0011)."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from pathlib import Path
+
+from .mcp_client import McpClient, McpError, tool_text
+
+RECOMPILE_SNIPPET = '''
+string assetPath = {asset_path};
+var shader = UnityEditor.AssetDatabase.LoadAssetAtPath<UnityEngine.Shader>(assetPath);
+if (shader == null) throw new System.Exception("shader not found: " + assetPath);
+var previousWindow = AmplifyShaderEditor.UIUtils.CurrentWindow;
+var previousSelection = UnityEditor.Selection.activeObject;
+AmplifyShaderEditor.AmplifyShaderEditorWindow win = null;
+try
+{
+    win = UnityEditor.EditorWindow.CreateInstance<AmplifyShaderEditor.AmplifyShaderEditorWindow>();
+    AmplifyShaderEditor.UIUtils.CurrentWindow = win;
+    var uiTextInfo = typeof(AmplifyShaderEditor.UIUtils).GetField(
+        "m_textInfo",
+        System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
+    if (uiTextInfo != null && uiTextInfo.GetValue(null) == null)
+        uiTextInfo.SetValue(null, new System.Globalization.CultureInfo("en-US", false).TextInfo);
+
+    // CommentaryNode.Position reads Event.current. A direct hidden-window load
+    // therefore fails outside OnGUI. Defer the asset and dispatch real GUI
+    // events so ASE loads comment groups in its normal editor lifecycle.
+    var delayedLoad = typeof(AmplifyShaderEditor.AmplifyShaderEditorWindow).GetField(
+        "m_delayedLoadObject",
+        System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
+    if (delayedLoad == null)
+        throw new System.Exception("ASE delayed-load field not found");
+    delayedLoad.SetValue(win, shader);
+    win.Show();
+
+    var layoutEvent = new UnityEngine.Event();
+    layoutEvent.type = UnityEngine.EventType.Layout;
+    win.SendEvent(layoutEvent);
+    var repaintEvent = new UnityEngine.Event();
+    repaintEvent.type = UnityEngine.EventType.Repaint;
+    win.SendEvent(repaintEvent);
+
+    if (win.CurrentGraph == null || win.CurrentGraph.CurrentMasterNode == null)
+        throw new System.Exception("ASE graph did not load in GUI event");
+    bool saved = win.SaveToDisk(false);
+    return "recompiled, saved=" + saved;
+}
+finally
+{
+    UnityEditor.Selection.activeObject = previousSelection;
+    AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+    if (win != null)
+    {
+        win.Close();
+        UnityEngine.Object.DestroyImmediate(win);
+    }
+}
+'''
+
+
+def recompile_via_mcp(
+    shader_path: str,
+    mcp_url: str = "http://127.0.0.1:8080/mcp",
+    instance_token: str | None = None,
+    allow_remote_mcp: bool = False,
+) -> dict:
+    """Open the shader in ASE inside the running editor and force save (regenerate HLSL)."""
+    p = Path(shader_path).resolve()
+    if not p.exists():
+        raise FileNotFoundError(shader_path)
+    before = hashlib.sha1(p.read_bytes()).hexdigest()
+    project_root = _detect_project_root(p)
+    asset_path = p.as_posix().removeprefix(project_root.as_posix() + "/")
+    client = McpClient(mcp_url, instance_token=instance_token, allow_remote=allow_remote_mcp)
+    client.connect()
+    result = client.call_tool(
+        "execute_code", {"action": "execute", "code": RECOMPILE_SNIPPET.replace("{asset_path}", json.dumps(asset_path))}
+    )
+    result_text = tool_text(result, instance_token)
+    saved_match = re.search(r"\brecompiled,\s*saved=(true|false)\b", result_text, re.IGNORECASE)
+    if not saved_match:
+        raise McpError("MCP tool result did not confirm saved state")
+    saved = saved_match.group(1).lower() == "true"
+    if not saved:
+        raise McpError("MCP tool did not confirm saved=True")
+    after = hashlib.sha1(p.read_bytes()).hexdigest()
+    return {
+        "transport": "mcp",
+        "server": mcp_url,
+        "asset_path": asset_path,
+        "saved": saved,
+        "changed": before != after,
+        "tool_result": "recompiled, saved=True",
+    }
+
+
+def _detect_project_root(shader_path: Path) -> Path:
+    cur = shader_path.parent
+    while cur != cur.parent:
+        if (cur / "Assets").is_dir() and (cur / "ProjectSettings").is_dir():
+            return cur
+        cur = cur.parent
+    raise ValueError(f"cannot locate Unity project root for {shader_path}")

asecli/bridge/resource_text.py

@@ -0,0 +1,12 @@
+"""Deterministically compose packaged text resources from ordered fragments."""
+
+from __future__ import annotations
+
+from importlib import resources
+from typing import Iterable
+
+
+def compose_resource_text(package: str, directory: str, fragments: Iterable[str]) -> str:
+    """Return the byte-stable UTF-8 concatenation of explicitly ordered fragments."""
+    root = resources.files(package).joinpath(directory)
+    return "".join(root.joinpath(name).read_text(encoding="utf-8") for name in fragments)