@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/mwi/code/engine/motionworks_iec_mcp/com.py

@@ -0,0 +1,268 @@
+"""Drive MotionWorks IEC directly through COM with pywin32.
+
+This is the Tier 3 automation path in Python, as the project requires: the
+``Ade.Application.550`` automation server, its type library, and a **32-bit**
+interpreter. It is deliberately one of two implementations of the same job --
+``mw_build.ps1`` under 32-bit PowerShell is the other -- so the two can be compared
+when something goes wrong, rather than there being a single opaque path.
+
+Why 32-bit is mandatory
+-----------------------
+``mwt.exe`` is a 32-bit local COM server, so a 64-bit process cannot instantiate it.
+Run this from the ``.venv32`` interpreter. ``available()`` reports the reason rather
+than failing obscurely, because "pywin32 is missing" and "the IDE is not running" are
+very different problems.
+
+Why the IDE must already be running
+-----------------------------------
+``Ade.Application.550`` is registered as a *LocalServer32*, so instantiating it
+**launches** ``mwt.exe`` if it is not already up. A freshly launched IDE has no
+project services ready, and calling into it returns ``Internal error`` for every
+project call. So this client never launches the IDE; it refuses and says so.
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+#: Repository root, two levels up from this module.
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+
+#: The automation ProgID, and its CLSID for error messages.
+PROG_ID = "Ade.Application.550"
+CLSID = "{05500000-0108-2706-100F-0080C7AC3298}"
+
+#: ``AdeCompileType`` values. 1 is an asynchronous Build; 2 is Rebuild. 0 and 3-6 are
+#: not valid -- confirmed by probing the server, which rejects them.
+COMPILE_BUILD = 1
+COMPILE_REBUILD = 2
+
+
+def interpreter_32() -> Path | None:
+    """The 32-bit interpreter this server delegates COM work to."""
+    candidate = PROJECT_ROOT / ".venv32" / "Scripts" / "python.exe"
+    return candidate if candidate.is_file() else None
+
+
+def query_via_32bit(compile_kind: int = 0, timeout: float = 120.0) -> dict[str, object]:
+    """Ask the 32-bit interpreter to query the automation server, and return its JSON.
+
+    This MCP server runs under a 64-bit interpreter, which cannot instantiate the
+    32-bit COM server. Only ``mw_com_status`` needs COM -- everything else works on
+    either -- so rather than requiring the whole server to run 32-bit (which would
+    also need the ``mcp`` package installed there), the COM work is delegated.
+
+    The child writes JSON to a file rather than stdout, because capturing a child's
+    output through a pipe is unreliable in this environment.
+    """
+    import json
+    import subprocess
+    import tempfile
+
+    interpreter = interpreter_32()
+    if interpreter is None:
+        return {
+            "ok": False,
+            "error": (
+                "no 32-bit interpreter found at .venv32\\Scripts\\python.exe. COM "
+                "automation needs one, because mwt.exe is a 32-bit local server."
+            ),
+        }
+
+    helper = PROJECT_ROOT / "tools" / "com_query.py"
+    if not helper.is_file():
+        return {"ok": False, "error": f"helper not found: {helper}"}
+
+    with tempfile.TemporaryDirectory() as tmp:
+        result = Path(tmp) / "com.json"
+        command = [str(interpreter), "-X", "utf8", str(helper), "--out", str(result)]
+        if compile_kind:
+            command += ["--compile", str(compile_kind)]
+        try:
+            subprocess.run(
+                command,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=timeout,
+                creationflags=0x08000000,
+            )
+        except Exception as exc:  # noqa: BLE001
+            return {"ok": False, "error": f"could not run the 32-bit helper: {exc}"}
+        try:
+            return json.loads(result.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as exc:
+            return {"ok": False, "error": f"the helper produced no usable result: {exc}"}
+
+
+class ComUnavailable(RuntimeError):
+    """The automation server could not be reached, with the reason why."""
+
+
+def is_32bit() -> bool:
+    """Whether this interpreter is 32-bit, which the COM server requires."""
+    return sys.maxsize <= 2**32
+
+
+def available() -> tuple[bool, str]:
+    """Whether this interpreter can use the automation server at all."""
+    if sys.platform != "win32":
+        return False, "not Windows"
+    if not is_32bit():
+        return (
+            False,
+            f"this is a {struct_calcsize() * 8}-bit interpreter, but mwt.exe is a "
+            f"32-bit local COM server; use the 32-bit interpreter (python.exe under "
+            f".venv32)",
+        )
+    try:
+        import win32com.client  # noqa: F401
+    except ImportError as exc:
+        return False, (
+            f"pywin32 is not installed in this interpreter ({exc}); install it with: "
+            f"python -m pip install pywin32"
+        )
+    return True, "ok"
+
+
+def struct_calcsize() -> int:
+    """``8`` for 64-bit, ``4`` for 32-bit, for messages."""
+    import struct
+
+    return struct.calcsize("P")
+
+
+def connect(visible: bool = True):
+    """Attach to a **running** MotionWorks IEC automation server.
+
+    Raises :class:`ComUnavailable` rather than launching the IDE, because a
+    launched-but-uninitialised IDE answers every project call with ``Internal
+    error`` and that is indistinguishable from a real failure.
+    """
+    ok, reason = available()
+    if not ok:
+        raise ComUnavailable(reason)
+
+    import win32com.client
+
+    from . import ide
+
+    running = [
+        (pid, name)
+        for pid, name in ide.motionworks_running(include_helpers=False)
+    ]
+    if not running:
+        raise ComUnavailable(
+            "MotionWorks IEC is not running. Instantiating "
+            f"{PROG_ID} would launch it, and a freshly launched IDE has no project "
+            "services, so every call would fail with 'Internal error'. Start "
+            "MotionWorks IEC, open the project, then retry."
+        )
+
+    try:
+        app = win32com.client.GetActiveObject(PROG_ID)
+    except Exception as exc:  # noqa: BLE001 - COM raises a variety of types
+        # Deliberately **no Dispatch fallback here.** Dispatch on a LocalServer32
+        # would launch another mwt.exe, and we have just confirmed one is already
+        # running; spawning a second IDE to talk to the first is never right.
+        raise ComUnavailable(
+            f"MotionWorks IEC is running (pid "
+            f"{', '.join(str(p) for p, _ in running)}) but its automation server "
+            f"could not be attached to: {exc}. This usually means the IDE is up as a "
+            f"COM/DDE server without having initialised its project services -- see "
+            f"docs/tier3-com-build.md."
+        ) from exc
+
+    if visible:
+        try:
+            app.Visible = True
+        except Exception:  # noqa: BLE001 - not fatal
+            pass
+    return app
+
+
+def project_state(app) -> dict[str, object]:
+    """Read ``IsProjectOpen`` / ``IsCompiled`` / ``IsModified`` without raising.
+
+    Each is reported as a value or as an error string. A failed call here is the
+    signal that the IDE is up but its project services are not -- which must not be
+    confused with "the project does not compile".
+    """
+    state: dict[str, object] = {}
+    for label, getter in (
+        ("project_open", lambda: app.IsProjectOpen()),
+        ("compiled", lambda: app.ActiveProject.IsCompiled),
+        ("modified", lambda: app.ActiveProject.IsModified),
+        ("name", lambda: app.ActiveProject.Name),
+    ):
+        try:
+            state[label] = getter()
+        except Exception as exc:  # noqa: BLE001
+            state[label] = f"error: {exc}"
+    return state
+
+
+def services_ready(app) -> tuple[bool, str]:
+    """Whether the IDE's project services are usable.
+
+    Distinguishes the important case: a ``False`` here means no compile was
+    attempted, so "compiled is False" would be misleading if reported as a build
+    failure.
+    """
+    state = project_state(app)
+    opened = state.get("project_open")
+    if isinstance(opened, str):
+        return False, (
+            "the IDE is running but its project services are not answering "
+            f"({opened}). No compile was attempted, so this is NOT a build failure."
+        )
+    if opened is not True:
+        return False, "no project is open in MotionWorks IEC"
+    return True, "ok"
+
+
+def compile_project(
+    app, kind: int = COMPILE_REBUILD, settle: float = 3.0
+) -> dict[str, object]:
+    """Ask the IDE to Build or Rebuild the active project.
+
+    ``Ade.Compile`` rejects a second call while the compiler is running
+    (``"...compiler is running"``), so a rebuild is retried until it is accepted.
+    The result reports whether the call was accepted, which is not the same as
+    whether the project compiled -- read ``ActiveProject.IsCompiled`` afterwards.
+    """
+    result: dict[str, object] = {"requested": kind, "accepted": False, "note": ""}
+    try:
+        app.ActiveProject.Compile(kind)
+        result["accepted"] = True
+    except Exception as exc:  # noqa: BLE001
+        message = str(exc)
+        if "compiler is running" in message.casefold():
+            result["note"] = "the compiler was busy; retry once it finishes"
+        else:
+            result["note"] = message
+
+    time.sleep(settle)
+    result["state"] = project_state(app)
+    return result
+
+
+def summary(app) -> str:
+    """A one-block human-readable report, for tool output."""
+    ok, reason = available()
+    lines = [f"pywin32 COM client: {'usable' if ok else 'unusable'} ({reason})"]
+    if not ok:
+        return "\n".join(lines)
+
+    try:
+        state = project_state(app)
+    except ComUnavailable as exc:
+        lines.append(f"not connected: {exc}")
+        return "\n".join(lines)
+
+    for key in ("name", "project_open", "compiled", "modified"):
+        lines.append(f"  {key:13}: {state.get(key)}")
+    ready, why = services_ready(app)
+    lines.append(f"  services     : {'ready' if ready else why}")
+    return "\n".join(lines)

package/vendor/mwi/code/engine/motionworks_iec_mcp/datatypes.py

@@ -0,0 +1,204 @@
+"""Read a MotionWorks project's user-defined data types from ``DT/Tyllist.typ``.
+
+Why this exists: a POU in this project declares ``CamData : CamSegmentStruct`` and
+``CamTable : Y_MS_CAM_STRUCT``, and writing Structured Text that touches either one needs
+the member names. Nothing in this plugin could read them, so the agent was writing code
+against types it could not see.
+
+The file is line-oriented, tab-separated. Measured from a real project:
+
+    (*
+    NDTE: 297        number of data types
+    NCPE: 943        number of components (members, array bounds, and so on)
+    NDME: 147        number of direct members
+    *)
+    24 0<TAB>ControllerInfoTypes\\Cont<TAB>FIRMWARE_INFO<TAB>1031<TAB>5<TAB>USER<TAB>STRUCT
+    25 0<TAB><TAB>VersionNumber<TAB>VERSION_NUMBER<TAB>1027<TAB>0
+
+Splitting on tabs, a TYPE line and a MEMBER line differ in ONE place that matters:
+
+    TYPE    ['24 0', 'ControllerInfoTypes\\Cont', 'FIRMWARE_INFO', '1031', '5', 'USER', 'STRUCT']
+    MEMBER  ['25 0', '',                          'VersionNumber', 'VERSION_NUMBER', '1027', '0']
+
+so the discriminator is the CONTAINER field at index 1 - empty for a member, a namespace
+path for a type - and the NAME is at index 2 in both cases. An earlier version of this
+reader looked at index 2 for the container and index 3 for the name, which turned every
+member into a type with an id for a name: it reported 1054 types where the header says 297.
+
+An ARRAY carries its element type on the type line and its bound on the line after:
+
+    15 0<TAB>ControllerInfoTypes\\Cont<TAB>BYTE32<TAB>1024<TAB>1<TAB>USER<TAB>ARRAY<TAB>BYTE<TAB>17
+    15 0<TAB><TAB><TAB>0<TAB>31
+
+Library types are NOT in this file. ``CamGenerator`` and ``Y_CamStructSelect`` are used by
+the POUs and absent here, because they come from an installed library rather than the
+project. This reader reports what the project defines and says so when asked for one it does
+not have.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .errors import NotFound
+
+TYPE_FILE = "DT/Tyllist.typ"
+_COUNTS = re.compile(r"^\s*(\w+)\s*:\s*(\d+)\s*$")
+_INDEX = re.compile(r"^\s*\d+(\s+\d+)?\s*$")
+
+
+@dataclass
+class DataTypeMember:
+    """One member of a user-defined type."""
+
+    name: str
+    type_name: str
+    type_id: int = 0
+    array_size: int | None = None
+
+
+@dataclass
+class DataType:
+    """One user-defined type."""
+
+    name: str
+    kind: str = ""
+    type_id: int = 0
+    container: str = ""
+    declared_members: int = 0
+    element_type: str = ""
+    element_id: int = 0
+    members: list[DataTypeMember] = field(default_factory=list)
+
+    @property
+    def is_struct(self) -> bool:
+        return self.kind.upper() in ("STRUCT", "UNION")
+
+    @property
+    def is_array(self) -> bool:
+        return self.kind.upper() in ("ARRAY", "MATRIX")
+
+
+def types_path(project_root: Path) -> Path:
+    candidate = Path(project_root) / TYPE_FILE
+    if not candidate.is_file():
+        raise NotFound(
+            f"no {TYPE_FILE} in {project_root}; this project defines no data types of its own "
+            f"- library types such as CamGenerator live outside the project"
+        )
+    return candidate
+
+
+def _int_at(fields: list[str], index: int, default: int = 0) -> int:
+    if index >= len(fields):
+        return default
+    try:
+        return int(fields[index].strip())
+    except ValueError:
+        return default
+
+
+def read_types(project_root: Path) -> tuple[list[DataType], dict[str, int]]:
+    """Parse the type list, returning ``(types, header_counts)``.
+
+    ``header_counts`` is the file's own ``NDTE``/``NCPE``/``NDME`` tally, which is a useful
+    check on the parse: a count that does not match the number of types found means the
+    layout is not what this reader assumes.
+    """
+    text = types_path(project_root).read_text(encoding="latin1", errors="replace")
+
+    counts: dict[str, int] = {}
+    types: list[DataType] = []
+    current: DataType | None = None
+    pending_array: DataType | None = None
+
+    for raw in text.splitlines():
+        if not raw.strip():
+            continue
+        stripped = raw.strip()
+        if stripped.startswith("(*") or stripped.startswith("*)"):
+            continue
+        match = _COUNTS.match(stripped)
+        if match:
+            counts[match.group(1)] = int(match.group(2))
+            continue
+
+        fields = raw.split("\t")
+        if len(fields) < 2 or not _INDEX.match(fields[0]):
+            continue
+
+        container, name = fields[1].strip(), (fields[2].strip() if len(fields) > 2 else "")
+
+        if container:
+            # A TYPE line: container, NAME, id, declared count, source, KIND, ...
+            if not name:
+                continue
+            kind = fields[6].strip() if len(fields) > 6 else ""
+            current = DataType(
+                name=name,
+                kind=kind,
+                type_id=_int_at(fields, 3),
+                container=container,
+                declared_members=_int_at(fields, 4),
+            )
+            if current.is_array and len(fields) > 7:
+                current.element_type = fields[7].strip()
+                current.element_id = _int_at(fields, 8)
+                pending_array = current
+            else:
+                pending_array = None
+            types.append(current)
+            continue
+
+        # A MEMBER line, or the bound line that follows an ARRAY type line.
+        if pending_array is not None and not name:
+            for value in fields[2:]:
+                if value.strip().isdigit():
+                    pending_array.declared_members = int(value.strip())
+                    break
+            pending_array = None
+            continue
+
+        if current is None:
+            continue
+        # The bound line of an array whose element field was blank arrives here as a
+        # nameless record with a number; treat that as the bound, not a member.
+        if not name:
+            for value in fields[2:]:
+                if value.strip().isdigit():
+                    current.declared_members = int(value.strip())
+                    break
+            continue
+
+        bound = None
+        for value in fields[5:]:
+            text_value = value.strip()
+            if text_value.isdigit() and int(text_value) > 1:
+                bound = int(text_value)
+                break
+        current.members.append(
+            DataTypeMember(
+                name=name,
+                type_name=fields[3].strip() if len(fields) > 3 else "",
+                type_id=_int_at(fields, 4),
+                array_size=bound,
+            )
+        )
+
+    return types, counts
+
+
+def find_type(project_root: Path, name: str) -> DataType:
+    """One type by name, case-insensitively."""
+    types, _ = read_types(project_root)
+    for t in types:
+        if t.name.lower() == name.lower():
+            return t
+    defined = sorted({t.name for t in types})
+    sample = ", ".join(defined[:25])
+    raise NotFound(
+        f"no data type named {name!r} defined in this project. It defines {len(types)}: "
+        f"{sample}{' ...' if len(defined) > 25 else ''}. Types used by POUs but absent here "
+        f"come from an installed library rather than the project."
+    )