asecli 0.6.2__py3-none-any.whl

asecli/bridge/editor_create.py

@@ -0,0 +1,173 @@
+"""Transactionally create a new ASE shader through a fixed Editor executor."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+from pathlib import Path
+import secrets
+
+from .editor_spec import EditorGraphSpec, SUPPORTED_ASE_VERSIONS
+from .mcp_client import McpClient, McpError, redact, tool_text
+from .resource_text import compose_resource_text
+
+
+EDITOR_CREATE_RESOURCE_PARTS = (
+    "editor_create.part00.cs.txt",
+    "editor_create.part01.cs.txt",
+    "editor_create.part02.cs.txt",
+    "editor_create.part03.cs.txt",
+    "editor_create.part04.cs.txt",
+)
+EDITOR_CREATE_SNIPPET = compose_resource_text(
+    "asecli.bridge", "resources", EDITOR_CREATE_RESOURCE_PARTS
+)
+_RESULT_MARKER = "ASECLI_EDITOR_CREATE_V1:"
+
+
+def create_shader_via_mcp(
+    shader_path: str | Path,
+    spec: EditorGraphSpec,
+    mcp_url: str = "http://127.0.0.1:8080/mcp",
+    instance_token: str | None = None,
+    allow_remote_mcp: bool = False,
+) -> dict:
+    """Create one absent shader and accept only a verified Save/Load manifest."""
+    target = Path(shader_path).resolve()
+    if target.suffix.lower() != ".shader":
+        raise ValueError("Editor create target must use the .shader extension")
+    if not target.parent.is_dir():
+        raise FileNotFoundError(f"parent directory not found: {target.parent}")
+    if target.exists() or target.is_symlink():
+        raise FileExistsError(f"Editor create target already exists: {target}")
+    project_root, asset_path = _project_asset_path(target)
+    transaction_nonce = secrets.token_hex(16)
+    temporary_asset_path = _temporary_asset_path(asset_path, transaction_nonce)
+    payload = spec.editor_payload(asset_path, temporary_asset_path)
+    encoded = base64.b64encode(
+        json.dumps(payload, ensure_ascii=False, separators=(",", ":"), sort_keys=True).encode("utf-8")
+    ).decode("ascii")
+    code = EDITOR_CREATE_SNIPPET.replace("{payload_base64}", encoded)
+    client = McpClient(mcp_url, instance_token=instance_token, allow_remote=allow_remote_mcp)
+    client.connect()
+    result = client.call_tool(
+        "execute_code",
+        {
+            "action": "execute",
+            "code": code,
+            # The fixed transactional executor uses AssetDatabase.DeleteAsset
+            # only to roll back its nonce-scoped staging asset. MCP 3.4.7 blocks
+            # that API by pattern unless the per-call safety scan is disabled.
+            "safety_checks": False,
+        },
+    )
+    response = _parse_result(_execute_code_result_text(result, instance_token))
+    _validate_result(response, asset_path, spec.expected_manifest())
+    if not target.is_file():
+        raise McpError("Editor create reported success but target file is missing")
+    temporary_file = project_root / temporary_asset_path
+    if temporary_file.exists() or temporary_file.with_suffix(temporary_file.suffix + ".meta").exists():
+        raise McpError("Editor create left a temporary asset after commit")
+    meta_file = target.with_suffix(target.suffix + ".meta")
+    return {
+        "transport": "mcp",
+        "server": mcp_url,
+        "asset_path": asset_path,
+        "ase_version": response["ase_version"],
+        "template_guid": response["template_guid"],
+        "shader_name": response["shader_name"],
+        "saved": True,
+        # Compat: reloaded means the staging asset was LoadFromDisk'd, not the committed target.
+        "reloaded": True,
+        "staging_reloaded": True,
+        "target_graph_reloaded": False,
+        "committed": True,
+        "changed": True,
+        "manifest": response["manifest"],
+        "transaction_nonce": transaction_nonce,
+        "shader_sha256": _sha256(target),
+        "meta_sha256": _sha256(meta_file) if meta_file.is_file() else None,
+    }
+
+
+def _project_asset_path(target: Path) -> tuple[Path, str]:
+    current = target.parent
+    while current != current.parent:
+        if (current / "Assets").is_dir() and (current / "ProjectSettings").is_dir():
+            try:
+                relative = target.relative_to(current)
+            except ValueError as exc:  # pragma: no cover - resolve makes this defensive
+                raise ValueError("Editor create target is outside the Unity project") from exc
+            if not relative.parts or relative.parts[0] != "Assets":
+                raise ValueError("Editor create target must be inside the Unity project Assets directory")
+            return current, relative.as_posix()
+        current = current.parent
+    raise ValueError("cannot locate Unity project root; target must be inside Assets")
+
+
+def _temporary_asset_path(asset_path: str, transaction_nonce: str) -> str:
+    target = Path(asset_path)
+    return (target.parent / f"ASECLI-Temp-{transaction_nonce}-{target.name}").as_posix()
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _parse_result(text: str) -> dict:
+    marker_index = text.find(_RESULT_MARKER)
+    if marker_index < 0:
+        raise McpError("MCP tool result did not contain the Editor create protocol marker")
+    raw = text[marker_index + len(_RESULT_MARKER) :].lstrip()
+    try:
+        value, _ = json.JSONDecoder().raw_decode(raw)
+    except json.JSONDecodeError as exc:
+        raise McpError("MCP tool returned malformed Editor create JSON") from exc
+    if not isinstance(value, dict):
+        raise McpError("MCP Editor create result must be a JSON object")
+    return value
+
+
+def _execute_code_result_text(result: dict, instance_token: str | None) -> str:
+    """Unwrap execute_code's JSON envelope while retaining legacy text support."""
+    text = tool_text(result, instance_token)
+    try:
+        envelope = json.loads(text)
+    except json.JSONDecodeError:
+        return text
+    if not isinstance(envelope, dict):
+        return text
+    if envelope.get("success") is False:
+        detail = envelope.get("message")
+        if not isinstance(detail, str) or not detail.strip():
+            detail = "no error details"
+        raise McpError(f"MCP execute_code reported failure: {redact(detail[:300], instance_token)}")
+    data = envelope.get("data")
+    if isinstance(data, dict) and isinstance(data.get("result"), str):
+        return data["result"]
+    return text
+
+
+def _validate_result(response: dict, asset_path: str, expected_manifest: dict) -> None:
+    if response.get("protocol") != "ASECLI_EDITOR_CREATE_V1":
+        raise McpError("Editor create protocol version is missing or unsupported")
+    version = response.get("ase_version")
+    if version not in SUPPORTED_ASE_VERSIONS:
+        raise McpError(f"Editor create returned unsupported ASE version: {version}")
+    if response.get("asset_path") != asset_path:
+        raise McpError("Editor create returned a different asset path")
+    expected_template = expected_manifest["template"]
+    if response.get("template_guid") != expected_template["guid"]:
+        raise McpError("Editor create returned a different template guid")
+    if response.get("shader_name") != expected_template["shader_name"]:
+        raise McpError("Editor create returned a different shader name")
+    for field in ("saved", "reloaded", "committed"):
+        if response.get(field) is not True:
+            raise McpError(f"Editor create did not confirm {field}=True")
+    if response.get("manifest") != expected_manifest:
+        raise McpError("Editor create Save/Load manifest does not match the requested graph")

asecli/bridge/editor_spec.py

@@ -0,0 +1,250 @@
+"""Strict declarative contract for the narrow ASE Editor creation backend."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._editor_primitives import ExpansionSpec, expansion_classes, primitive_class
+
+SUPPORTED_ASE_VERSIONS = frozenset({"1.9.6.2"})
+
+
+class SpecError(ValueError):
+    """EditorGraphSpec is outside the explicitly supported v1 grammar."""
+
+
+@dataclass(frozen=True)
+class TemplateSpec:
+    guid: str
+    shader_name: str
+
+    def to_dict(self) -> dict:
+        return {"guid": self.guid, "shader_name": self.shader_name}
+
+
+@dataclass(frozen=True)
+class InputSpec:
+    name: str
+    type: str
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "type": self.type}
+
+
+@dataclass(frozen=True)
+class NodeSpec:
+    alias: str
+    kind: str
+    position: tuple[float, float]
+    type: str | None = None
+    property_name: str | None = None
+    inspector_name: str | None = None
+    tooltip: str | None = None
+    help: str | None = None
+    enabled_if: dict | None = None
+    parameter_type: str | None = None
+    name: str | None = None
+    code: str | None = None
+    output_type: str | None = None
+    inputs: tuple[InputSpec, ...] = ()
+    precision: str | None = None
+    default: Any | None = None
+    min: float | None = None
+    max: float | None = None
+    op: str | None = None
+    recipe: str | None = None
+    expansion: ExpansionSpec | None = None
+
+    @property
+    def ase_type(self) -> str:
+        if self.kind == "sampler":
+            return "SamplerNode"
+        if self.kind == "custom_expression":
+            return "CustomExpressionNode"
+        if self.kind == "primitive":
+            assert self.op is not None
+            cls = primitive_class(self.op)
+            assert cls is not None
+            return cls
+        if self.kind == "recipe":
+            # A recipe expands to multiple ASE nodes; the manifest records the
+            # authoritative expansion, not a single class name.
+            return "Recipe"
+        assert self.type is not None
+        return self.type
+
+    def to_dict(self) -> dict:
+        result: dict[str, Any] = {
+            "alias": self.alias,
+            "kind": self.kind,
+            "position": list(self.position),
+        }
+        if self.type is not None:
+            result["type"] = self.type
+        if self.precision is not None:
+            result["precision"] = self.precision
+        if self.default is not None:
+            result["default"] = self.default
+        if self.min is not None:
+            result["min"] = self.min
+            result["max"] = self.max
+        if self.property_name is not None:
+            result.update(
+                property_name=self.property_name,
+                inspector_name=self.inspector_name,
+                parameter_type=self.parameter_type,
+            )
+            if self.tooltip is not None:
+                result["tooltip"] = self.tooltip
+            if self.help is not None:
+                result["help"] = self.help
+            if self.enabled_if is not None:
+                result["enabled_if"] = dict(self.enabled_if)
+        if self.kind == "custom_expression":
+            result.update(
+                name=self.name,
+                code=self.code,
+                output_type=self.output_type,
+                inputs=[item.to_dict() for item in self.inputs],
+            )
+        if self.kind == "primitive":
+            result["op"] = self.op
+        if self.kind == "recipe":
+            result.update(
+                recipe=self.recipe,
+                code=self.code,
+                output_type=self.output_type,
+                inputs=[item.to_dict() for item in self.inputs],
+                expansion=self.expansion.to_dict(),
+            )
+        return result
+
+    def manifest_entry(self) -> dict:
+        result: dict[str, Any] = {"alias": self.alias, "kind": self.kind, "type": self.ase_type}
+        if self.property_name is not None:
+            result.update(
+                property_name=self.property_name,
+                inspector_name=self.inspector_name,
+                parameter_type=self.parameter_type,
+            )
+        if self.precision is not None:
+            result["precision"] = self.precision
+        if self.default is not None:
+            result["default"] = self.default
+        if self.min is not None:
+            result["min"] = self.min
+            result["max"] = self.max
+        if self.kind == "custom_expression":
+            result.update(
+                name=self.name,
+                code=self.code,
+                output_type=self.output_type,
+                inputs=[item.to_dict() for item in self.inputs],
+            )
+        if self.kind == "primitive":
+            result["op"] = self.op
+        if self.kind == "recipe":
+            if self.expansion_is_native():
+                classes = expansion_classes(self.expansion.primitives)
+                assert classes is not None
+                result.update(
+                    recipe=self.recipe,
+                    output_type=self.output_type,
+                    expansion_nodes=[
+                        {"id": primitive.id, "type": cls}
+                        for primitive, cls in zip(self.expansion.primitives, classes)
+                    ],
+                )
+            else:
+                # Fallback: the executor emits a single CustomExpressionNode
+                # using the authoritative HLSL code.
+                result["type"] = "CustomExpressionNode"
+                result.update(
+                    name=self.recipe,
+                    code=self.code,
+                    output_type=self.output_type,
+                    inputs=[item.to_dict() for item in self.inputs],
+                )
+        return result
+
+    def expansion_is_native(self) -> bool:
+        assert self.expansion is not None
+        if expansion_classes(self.expansion.primitives) is None:
+            return False
+        ids = {primitive.id for primitive in self.expansion.primitives}
+        return self.expansion.output in ids
+
+
+@dataclass(frozen=True)
+class EndpointSpec:
+    node: str
+    port: int
+
+    def to_dict(self) -> dict:
+        return {"node": self.node, "port": self.port}
+
+
+@dataclass(frozen=True)
+class ConnectionSpec:
+    source: EndpointSpec
+    destination: EndpointSpec
+
+    def to_dict(self) -> dict:
+        return {"from": self.source.to_dict(), "to": self.destination.to_dict()}
+
+
+@dataclass(frozen=True)
+class EditorGraphSpec:
+    version: int
+    template: TemplateSpec
+    nodes: tuple[NodeSpec, ...]
+    connections: tuple[ConnectionSpec, ...]
+    primitives_version: int | None = None
+
+    @classmethod
+    def from_dict(cls, value: Any) -> "EditorGraphSpec":
+        from ._editor_spec_validation import parse_editor_graph_spec
+
+        return parse_editor_graph_spec(value)
+
+    def to_dict(self) -> dict:
+        result: dict[str, Any] = {
+            "version": self.version,
+            "template": self.template.to_dict(),
+            "nodes": [node.to_dict() for node in self.nodes],
+            "connections": [item.to_dict() for item in self.connections],
+        }
+        if self.primitives_version is not None:
+            result["primitives_version"] = self.primitives_version
+        return result
+
+    def editor_payload(self, asset_path: str, temporary_asset_path: str) -> dict:
+        # The fixed ASE executor protocol remains v1. Presentation-only fields
+        # are finalized and verified by the CLI after ASE commits the graph.
+        payload = self.to_dict()
+        payload["version"] = 1
+        for node in payload["nodes"]:
+            node.pop("help", None)
+            node.pop("tooltip", None)
+            node.pop("enabled_if", None)
+        return {**payload, "asset_path": asset_path, "temporary_asset_path": temporary_asset_path}
+
+    def expected_manifest(self) -> dict:
+        return {
+            "template": self.template.to_dict(),
+            "nodes": [node.manifest_entry() for node in self.nodes],
+            "connections": [item.to_dict() for item in self.connections],
+        }
+
+
+def load_editor_graph_spec(path: str | Path) -> EditorGraphSpec:
+    from ._editor_spec_io import load_editor_graph_spec as _load
+
+    return _load(path)
+
+
+def route_create_backend(requested: str, spec: EditorGraphSpec | None) -> str:
+    from ._editor_spec_io import route_create_backend as _route
+
+    return _route(requested, spec)

asecli/bridge/graph_geometry.py

@@ -0,0 +1,249 @@
+"""Editor-accurate node, title, and port geometry for meticulous layout."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+
+from .mcp_client import McpClient, McpError, tool_text
+from .recompile import _detect_project_root
+from .graph_geometry_parser import parse_geometry_payload
+
+
+GEOMETRY_SNIPPET = r'''
+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 flags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public |
+                System.Reflection.BindingFlags.NonPublic;
+    System.Func<System.Type, string, System.Reflection.MemberInfo> findMember = (type, name) =>
+    {{
+        while (type != null)
+        {{
+            var property = type.GetProperty(name, flags);
+            if (property != null) return property;
+            var field = type.GetField(name, flags);
+            if (field != null) return field;
+            type = type.BaseType;
+        }}
+        return null;
+    }};
+    System.Func<System.Reflection.MemberInfo, object, object> readMember = (member, owner) =>
+    {{
+        if (member is System.Reflection.PropertyInfo)
+            return ((System.Reflection.PropertyInfo)member).GetValue(owner, null);
+        if (member is System.Reflection.FieldInfo)
+            return ((System.Reflection.FieldInfo)member).GetValue(owner);
+        return null;
+    }};
+    System.Func<object, string> displayText = value =>
+    {{
+        if (value == null) return "";
+        if (value is UnityEngine.GUIContent) return ((UnityEngine.GUIContent)value).text ?? "";
+        return value.ToString() ?? "";
+    }};
+    System.Func<string, string> encodeText = value => System.Convert.ToBase64String(
+        System.Text.Encoding.UTF8.GetBytes(value ?? ""));
+    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);
+    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");
+
+    // ASE only fills TruePosition size, HeaderPosition and port rectangles
+    // while a node participates in a layout pass. Large graphs leave
+    // off-screen nodes unmeasured, so run one non-drawing, all-visible layout
+    // pass in the temporary window before collecting geometry.
+    var probeDraw = win.CameraDrawInfo;
+    if (probeDraw == null)
+        throw new System.Exception("ASE camera draw-info is unavailable");
+    // ParentNode visibility compares against CameraArea width/height and does
+    // not use its x/y origin, so translate graph coordinates into the positive
+    // probe viewport instead of using a negative-origin rectangle.
+    probeDraw.CameraArea = new UnityEngine.Rect(0f, 0f, 20000000f, 20000000f);
+    probeDraw.TransformedCameraArea = probeDraw.CameraArea;
+    probeDraw.CameraOffset = new UnityEngine.Vector2(10000000f, 10000000f);
+    probeDraw.InvertedZoom = 1f;
+    probeDraw.CurrentEventType = UnityEngine.EventType.Repaint;
+    foreach (var probeNode in win.CurrentGraph.AllNodes)
+    {{
+        probeNode.OnNodeLogicUpdate(probeDraw);
+        probeNode.OnNodeLayout(probeDraw);
+    }}
+
+    var inv = System.Globalization.CultureInfo.InvariantCulture;
+    var sb = new System.Text.StringBuilder("ASECLI_GEOMETRY_V3\n");
+    foreach (var node in win.CurrentGraph.AllNodes)
+    {{
+        var rect = node.TruePosition;
+        // Template multi-pass graphs keep dormant master placeholders whose
+        // editor rect is intentionally empty. They are not part of the
+        // currently drawable graph and are omitted from the geometry payload.
+        if (rect.width <= 0 || rect.height <= 0) continue;
+        var global = node.GlobalPosition;
+        var scaleX = global.width / rect.width;
+        var scaleY = global.height / rect.height;
+        if (scaleX <= 0 || scaleY <= 0)
+            throw new System.Exception("ASE node coordinate transform unavailable for node " + node.UniqueId);
+        var nodeType = node.GetType();
+        var titleMember = findMember(nodeType, "TitleContent") ?? findMember(nodeType, "m_content") ??
+                          findMember(nodeType, "Title") ?? findMember(nodeType, "m_title");
+        string nodeTitle = displayText(readMember(titleMember, node));
+        var headerMember = findMember(nodeType, "HeaderPosition") ?? findMember(nodeType, "m_headerPosition");
+        object headerValue = headerMember is System.Reflection.PropertyInfo
+            ? ((System.Reflection.PropertyInfo)headerMember).GetValue(node, null)
+            : headerMember is System.Reflection.FieldInfo
+                ? ((System.Reflection.FieldInfo)headerMember).GetValue(node) : null;
+        if (!(headerValue is UnityEngine.Rect))
+            throw new System.Exception("ASE node header geometry unavailable for node " + node.UniqueId);
+        var header = (UnityEngine.Rect)headerValue;
+        sb.Append("N|").Append(node.UniqueId).Append('|')
+          .Append(rect.x.ToString("R", inv)).Append('|').Append(rect.y.ToString("R", inv)).Append('|')
+          .Append(rect.width.ToString("R", inv)).Append('|').Append(rect.height.ToString("R", inv)).Append('|')
+          .Append((header.height / scaleY).ToString("R", inv)).Append('|')
+          .Append(encodeText(nodeTitle)).Append('\n');
+        foreach (var port in node.InputPorts)
+        {{
+            var portType = port.GetType();
+            var idMember = findMember(portType, "PortId") ?? findMember(portType, "UniqueId") ??
+                           findMember(portType, "m_portId");
+            var posMember = findMember(portType, "Position") ?? findMember(portType, "PortPosition") ??
+                            findMember(portType, "m_position");
+            var nameMember = findMember(portType, "Name") ?? findMember(portType, "m_name");
+            object idValue = idMember is System.Reflection.PropertyInfo
+                ? ((System.Reflection.PropertyInfo)idMember).GetValue(port, null)
+                : idMember is System.Reflection.FieldInfo ? ((System.Reflection.FieldInfo)idMember).GetValue(port) : null;
+            object posValue = posMember is System.Reflection.PropertyInfo
+                ? ((System.Reflection.PropertyInfo)posMember).GetValue(port, null)
+                : posMember is System.Reflection.FieldInfo ? ((System.Reflection.FieldInfo)posMember).GetValue(port) : null;
+            if (idValue == null || (!(posValue is UnityEngine.Rect) && !(posValue is UnityEngine.Vector2)))
+                throw new System.Exception("ASE input-port geometry unavailable for node " + node.UniqueId);
+            if (posValue is UnityEngine.Rect && (((UnityEngine.Rect)posValue).width <= 0 || ((UnityEngine.Rect)posValue).height <= 0))
+                continue;
+            if (posValue is UnityEngine.Vector2 && ((UnityEngine.Vector2)posValue) == UnityEngine.Vector2.zero)
+                continue;
+            var screenCenter = posValue is UnityEngine.Rect ? ((UnityEngine.Rect)posValue).center : (UnityEngine.Vector2)posValue;
+            string portName = displayText(readMember(nameMember, port));
+            var portCenter = new UnityEngine.Vector2(
+                rect.x + (screenCenter.x - global.x) / scaleX,
+                rect.y + (screenCenter.y - global.y) / scaleY);
+            sb.Append("I|").Append(node.UniqueId).Append('|').Append(idValue).Append('|')
+              .Append(portCenter.x.ToString("R", inv)).Append('|')
+              .Append(portCenter.y.ToString("R", inv)).Append('|')
+              .Append(encodeText(portName)).Append('\n');
+        }}
+        foreach (var port in node.OutputPorts)
+        {{
+            var portType = port.GetType();
+            var idMember = findMember(portType, "PortId") ?? findMember(portType, "UniqueId") ??
+                           findMember(portType, "m_portId");
+            var posMember = findMember(portType, "Position") ?? findMember(portType, "PortPosition") ??
+                            findMember(portType, "m_position");
+            var nameMember = findMember(portType, "Name") ?? findMember(portType, "m_name");
+            object idValue = idMember is System.Reflection.PropertyInfo
+                ? ((System.Reflection.PropertyInfo)idMember).GetValue(port, null)
+                : idMember is System.Reflection.FieldInfo ? ((System.Reflection.FieldInfo)idMember).GetValue(port) : null;
+            object posValue = posMember is System.Reflection.PropertyInfo
+                ? ((System.Reflection.PropertyInfo)posMember).GetValue(port, null)
+                : posMember is System.Reflection.FieldInfo ? ((System.Reflection.FieldInfo)posMember).GetValue(port) : null;
+            if (idValue == null || (!(posValue is UnityEngine.Rect) && !(posValue is UnityEngine.Vector2)))
+                throw new System.Exception("ASE output-port geometry unavailable for node " + node.UniqueId);
+            if (posValue is UnityEngine.Rect && (((UnityEngine.Rect)posValue).width <= 0 || ((UnityEngine.Rect)posValue).height <= 0))
+                continue;
+            if (posValue is UnityEngine.Vector2 && ((UnityEngine.Vector2)posValue) == UnityEngine.Vector2.zero)
+                continue;
+            var screenCenter = posValue is UnityEngine.Rect ? ((UnityEngine.Rect)posValue).center : (UnityEngine.Vector2)posValue;
+            string portName = displayText(readMember(nameMember, port));
+            var portCenter = new UnityEngine.Vector2(
+                rect.x + (screenCenter.x - global.x) / scaleX,
+                rect.y + (screenCenter.y - global.y) / scaleY);
+            sb.Append("O|").Append(node.UniqueId).Append('|').Append(idValue).Append('|')
+              .Append(portCenter.x.ToString("R", inv)).Append('|')
+              .Append(portCenter.y.ToString("R", inv)).Append('|')
+              .Append(encodeText(portName)).Append('\n');
+        }}
+    }}
+    return sb.ToString();
+}}
+finally
+{{
+    UnityEditor.Selection.activeObject = previousSelection;
+    AmplifyShaderEditor.UIUtils.CurrentWindow = previousWindow;
+    if (win != null) {{ win.Close(); UnityEngine.Object.DestroyImmediate(win); }}
+}}
+'''
+
+
+@dataclass(frozen=True)
+class EditorNodeGeometry:
+    x: float
+    y: float
+    width: float
+    height: float
+    title_height: float
+    input_ports: dict[str, tuple[float, float]]
+    output_ports: dict[str, tuple[float, float]]
+    node_title: str = ""
+    input_port_labels: dict[str, str] | None = None
+    output_port_labels: dict[str, str] | None = None
+
+
+def inspect_graph_geometry_via_mcp(
+    shader_path: str, *, mcp_url: str = "http://127.0.0.1:8080/mcp",
+    instance_token: str | None = None, unity_instance: str | None = None,
+    allow_remote_mcp: bool = False,
+) -> dict[str, EditorNodeGeometry]:
+    path = Path(shader_path).resolve()
+    if not path.exists():
+        raise FileNotFoundError(shader_path)
+    root = _detect_project_root(path)
+    asset_path = path.as_posix().removeprefix(root.as_posix() + "/")
+    client = McpClient(mcp_url, instance_token=instance_token, allow_remote=allow_remote_mcp)
+    client.connect()
+    args = {"action": "execute", "code": GEOMETRY_SNIPPET.format(asset_path=json.dumps(asset_path))}
+    if unity_instance is not None:
+        args["unity_instance"] = unity_instance
+    envelope_text = tool_text(client.call_tool("execute_code", args), instance_token)
+    try:
+        envelope = json.loads(envelope_text)
+    except json.JSONDecodeError as exc:
+        raise McpError("MCP graph-geometry result has an unexpected envelope") from exc
+    if not isinstance(envelope, dict):
+        raise McpError("MCP graph-geometry result has an unexpected envelope")
+    if envelope.get("success") is False:
+        data = envelope.get("data") if isinstance(envelope.get("data"), dict) else {}
+        detail = envelope.get("message") or data.get("reason") or "Unity execution failed"
+        available = data.get("available_instances")
+        if isinstance(available, list) and available:
+            detail = f"{detail}; available instances: {', '.join(str(item) for item in available)}"
+        raise McpError(str(detail), data=data)
+    try:
+        payload = envelope["data"]["result"]
+    except (KeyError, TypeError) as exc:
+        raise McpError("MCP graph-geometry result has an unexpected envelope") from exc
+    if not isinstance(payload, str) or not payload.startswith(("ASECLI_GEOMETRY_V2\n", "ASECLI_GEOMETRY_V3\n")):
+        raise McpError("MCP graph-geometry result has an unexpected payload")
+    return parse_geometry_payload(payload, EditorNodeGeometry)
+
+
+def _parse_geometry_payload(payload: str) -> dict[str, EditorNodeGeometry]:
+    """Compatibility wrapper retained for focused parser tests/importers."""
+    return parse_geometry_payload(payload, EditorNodeGeometry)