@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

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

@@ -0,0 +1,218 @@
+"""Versioned vendor references and bounded local PDF search. No IDE operations."""
+from __future__ import annotations
+import hashlib
+import json
+import os
+import re
+from pathlib import Path
+from urllib.parse import urlsplit
+from urllib.request import Request, urlopen
+from uuid import uuid4
+
+DATA = Path(__file__).with_name('reference_data')
+MAX_DOWNLOAD = 64 * 1024 * 1024
+
+
+def catalog():
+    return json.loads((DATA / 'catalog.json').read_text(encoding='utf-8'))
+
+
+def citation(source_id, pages=None, section=None):
+    source = next(s for s in catalog()['sources'] if s['id'] == source_id)
+    return {**source, 'pdf_pages': pages or [], 'section': section,
+            'page_url': source['url'] + (f'#page={pages[0]}' if pages else ''),
+            'version_match': 'not_verified_against_installed_library'}
+
+
+def reference(topic_id):
+    topic = next(t for t in catalog()['topics'] if t['id'] == topic_id)
+    return {**topic, 'citation': citation(topic['source_id'], topic['pdf_pages'], topic['section'])}
+
+
+def tokens(text):
+    return re.findall(r'[a-z0-9_]+', text.casefold())
+
+
+def _score(query, text):
+    wanted = set(tokens(query))
+    actual = set(tokens(text))
+    # Full-phrase matching also helps PDFs whose glyph extraction omits spaces.
+    compact = re.sub(r'\s+', '', text.casefold())
+    phrase = re.sub(r'\s+', '', query.casefold())
+    return len(wanted & actual) + (4 if phrase and phrase in compact else 0)
+
+
+def cache_root():
+    from .staging import workspace_root
+    workspace = workspace_root()
+    root = (workspace / '.motionworks' / 'references').resolve()
+    if not root.is_relative_to(workspace):
+        raise ValueError('Reference cache escapes the workspace')
+    return root
+
+
+def _safe_child(root, name):
+    path = root / name
+    if not path.resolve().is_relative_to(root):
+        raise ValueError('Linked reference cache entry escapes its directory')
+    return path
+
+
+def search(query='', *, source_id=None, limit=5):
+    limit = max(1, min(int(limit), 10))
+    data = catalog()
+    if source_id and source_id not in {s['id'] for s in data['sources']}:
+        raise ValueError('Unknown source_id')
+    if not query.strip():
+        return {'sources': [s for s in data['sources'] if not source_id or s['id'] == source_id], 'topics': [{'id': t['id'], 'title': t['title']} for t in data['topics'] if not source_id or t['source_id'] == source_id],
+                'signatures': sorted(data['signatures']), 'note': 'Curated notes work offline; sync PDFs for page search.'}
+    if len(query) > 256: raise ValueError('Reference query must be at most 256 characters')
+    scored = []
+    for topic in data['topics']:
+        if source_id and topic['source_id'] != source_id: continue
+        score = _score(query, ' '.join([topic['title'], topic['summary'], *topic['tags']]))
+        if score: scored.append((score, topic['id']))
+    curated = [reference(id) for _, id in sorted(scored, key=lambda x: (-x[0], x[1]))[:limit]]
+    pages, unavailable = [], []
+    exact_signature = signature(query.strip())
+    root = cache_root()
+    for source in data['sources']:
+        if source['kind'] != 'pdf' or (source_id and source['id'] != source_id): continue
+        path = _safe_child(root, source['id'] + '.json')
+        if not path.exists():
+            unavailable.append(source['id']); continue
+        try:
+            cached = json.loads(path.read_text(encoding='utf-8'))
+            pdf = _safe_child(root, source['id'] + '.pdf')
+            if cached['sha256'] != source['sha256'] or hashlib.sha256(pdf.read_bytes()).hexdigest() != source['sha256']:
+                raise ValueError('Cached PDF version/hash does not match reviewed source')
+            if len(cached['pages']) != source['pages'] or not all(isinstance(p, str) for p in cached['pages']):
+                raise ValueError('Cached page index is incomplete')
+            if cached.get('text_sha256') != hashlib.sha256(json.dumps(cached['pages'], ensure_ascii=False).encode('utf-8')).hexdigest():
+                raise ValueError('Cached page index failed integrity check; synchronize again')
+            best = []
+            for i, text in enumerate(cached['pages'], 1):
+                score = _score(query, text)
+                if score:
+                    score += min(3, text.casefold().count(query.strip().casefold()))
+                    if _score(query, text[:180]) >= 4: score += 2
+                    if any(t['source_id'] == source['id'] and i in t['pdf_pages'] for t in curated): score += 8
+                    if exact_signature and exact_signature['source_id'] == source['id'] and i in exact_signature['pdf_pages']: score += 20
+                if score: best.append((score, i, text))
+            # At most one short excerpt per source; other matches remain page links.
+            for rank, (_, page, text) in enumerate(sorted(best, key=lambda x: (-x[0], x[1]))[:limit]):
+                hit = re.search(re.escape(query.strip()), text, re.I)
+                start = hit.start() if hit else 0
+                excerpt = ' '.join(text[start:].split()[:20])[:150] if rank == 0 else None
+                pages.append({'source_id': source['id'], 'pdf_page': page, 'excerpt': excerpt,
+                              'citation': citation(source['id'], [page], 'PDF search result')})
+        except (OSError, ValueError, KeyError) as exc:
+            unavailable.append({'source_id': source['id'], 'reason': str(exc)})
+    return {'query': query, 'topics': curated, 'pages': pages, 'unavailable_indexes': unavailable,
+            'note': 'PDF pages are physical 1-based pages, which can differ from printed labels. Historical references do not establish installed-version compatibility.'}
+
+
+def signature(name):
+    match = next((v for k, v in catalog()['signatures'].items() if k.casefold() == name.casefold()), None)
+    if match is None: return None
+    return {**match, 'citation': citation(match['source_id'], match['pdf_pages'], match['section'])}
+
+
+def _atomic(path, data):
+    temp = path.with_name(path.name + '.' + uuid4().hex + '.tmp')
+    try:
+        temp.write_bytes(data)
+        os.replace(temp, path)
+    finally:
+        temp.unlink(missing_ok=True)
+
+
+def _fetch(url):
+    # Only catalog URLs are passed here. Never send project data or credentials.
+    with urlopen(Request(url, headers={'User-Agent': 'MotionWorksReference/0.3'}), timeout=45) as response:
+        final = urlsplit(response.url)
+        if final.scheme != 'https' or final.hostname != 'www.yaskawa.com':
+            raise ValueError('Reference download redirected outside the official host')
+        raw = response.read(MAX_DOWNLOAD + 1)
+    if len(raw) > MAX_DOWNLOAD or not raw.startswith(b'%PDF'):
+        raise ValueError('Official download did not return a supported PDF; it may require login')
+    return raw
+
+
+def sync(source_ids=None):
+    data = catalog()
+    sources = {s['id']: s for s in data['sources'] if s['kind'] == 'pdf'}
+    ids = list(dict.fromkeys(sources if source_ids is None else source_ids))
+    if any(id not in sources for id in ids): raise ValueError('Only catalog PDF source IDs can be synchronized')
+    try:
+        from pypdf import PdfReader
+    except ImportError:
+        return {'ok': False, 'error': 'PDF indexing requires pypdf in the selected plugin Python runtime. Curated search remains available.', 'sources': []}
+    root = cache_root(); root.mkdir(parents=True, exist_ok=True)
+    results = []
+    for id in ids:
+        source = sources[id]
+        try:
+            pdf = _safe_child(root, id + '.pdf')
+            index = _safe_child(root, id + '.json')
+            raw = pdf.read_bytes() if pdf.exists() else _fetch(source['url'])
+            digest = hashlib.sha256(raw).hexdigest()
+            if digest != source['sha256']:
+                raise ValueError('Vendor PDF differs from the reviewed revision. Catalog review is required; no old page citations were applied.')
+            import io
+            reader = PdfReader(io.BytesIO(raw))
+            if len(reader.pages) != source['pages']: raise ValueError('PDF page count differs from catalog')
+            pages = [page.extract_text() or '' for page in reader.pages]
+            _atomic(pdf, raw)
+            text_digest = hashlib.sha256(json.dumps(pages, ensure_ascii=False).encode('utf-8')).hexdigest()
+            _atomic(index, json.dumps({'sha256': digest, 'text_sha256': text_digest, 'pages': pages}, ensure_ascii=False).encode('utf-8'))
+            results.append({'source_id': id, 'status': 'indexed', 'pages': len(pages), 'path': str(pdf), 'revision': source['revision']})
+        except Exception as exc:
+            results.append({'source_id': id, 'status': 'unavailable', 'error': str(exc)})
+    return {'ok': all(r['status'] == 'indexed' for r in results), 'sources': results}
+
+
+def diagnose(message):
+    if not message.strip(): raise ValueError('Supply the compiler/runtime diagnostic text')
+    patterns = [
+        (r'file error.*(?:\.vbc|src\.st1)|MSILv2ResManager|variable.*not found', 'diagnostics', 'compiler_or_native_format', ['Preserve the exact project, error text and transaction journal.', 'Compare paired VB/VGR declarations and source stream hashes with the last verified snapshot.', 'Do not patch generated cache files, replace a binary container as text, or restore underneath an open IDE.']),
+        (r'division by zero|divide.by.zero', 'diagnostics', 'runtime', ['Inspect denominators and cam-generation segment lengths at the faulting operation.', 'Zero compiler errors do not exclude runtime arithmetic faults. Capture runtime values before proposing a change.']),
+        (r'identity.*workspace|outside.*stag|ENOTDIR', 'diagnostics', 'workspace_state', ['Read the calling session workspace and mw_workflow_check for the explicit stage.', 'Check relocated identity paths and wrappers. Do not weaken guards or restage over unsynced source edits.']),
+        (r'error\s+in\s+native\s+code\s+generation', 'native-code-error', 'compiler', ['Read the first underlying compiler diagnostic.', 'Compare IDE, controller target and library versions before changing declarations.']),
+        (r'operand\s+not\s+implemented|area\s+exceeded', 'address-range', 'runtime_or_debug', ['Inspect IO_Configuration address ranges.', 'Compare the located variable address with the configured driver.']),
+        (r'no\s+matching\s+global|global-not-declared-external|external.*(?:missing|mismatch)', 'scope', 'compiler', ['Compare the resource global with the POU external name and type.', 'Inspect both VB and VGR consistency; do not convert an external to a local just to hide the error.']),
+        (r'type.*(?:invalid|mismatch)|incompatible.*type|cannot.*convert', 'strict-types', 'compiler', ['Read operand declarations and FB formal types.', 'Use an explicit, range-appropriate conversion where intended.']),
+        (r'\b4370\b|motionprohibited', 'stop', 'runtime', ['Inspect axis state, active commands and the MC_Stop instance.', 'Do not automatically clear interlocks or reset the axis.']),
+        (r'\b4625\b|axis.*(?:id|number).*not', 'axis-id', 'runtime', ['Compare the logical axis reference with Hardware Configuration.']),
+        (r'watchdog|task.*overrun', 'task-priority', 'runtime', ['Inspect task timing, execution load and priority.', 'Do not mask an overrun merely by extending its watchdog.']),
+        (r'completion unverified|stalled|empty.*errors', 'diagnostics', 'ide_state', ['Inspect modal dialogs and current compiler state.', 'An empty error pane is not a success verdict; never repair disk files under an open IDE.']),
+    ]
+    matches = [{'category': kind, 'evidence': reference(topic), 'suggested_checks': checks,
+                'confidence': 'candidate_not_confirmed', 'mapping': 'plugin_authored_from_cited_guidance'}
+               for pattern, topic, kind, checks in patterns if re.search(pattern, message, re.I)]
+    if re.search(r'''illegal\s+IEC\s+syntax\s+at\s+or\s+before\s+['"]>['"]''',message,re.I):
+        matches.append({
+            'category':'compiler',
+            'confidence':'candidate_not_confirmed',
+            'mapping':'plugin_authored_from_live_observation_and_installed_help',
+            'evidence':{'kind':'installed_help_and_live_compile',
+                        'observed_ide':'MotionWorks IEC 3 Pro, automation version 1.19',
+                        'installed_help':{'tool':'mw_code_installed_help','module':'ST001','topic':'callingfunctionblocksinst.htm'}},
+            'suggested_checks':[
+                'Read the exact offending ST line before diagnosing the token.',
+                'If the line uses => for an FB output, read the installed ST FB-call topic: the tested IDE rejected that form and accepted assignments from instance output fields after the call.',
+                'Resolve actual pin directions/types with mw_code_block_interface. Keep in-out bindings in the call; capture output fields afterward.',
+                'A greater-than token can fail for other reasons. Confirm the source context and installed version, then use guarded code editing and fresh Build/Make; do not rewrite automatically.'
+            ]})
+    return {'matches': matches, 'matched': bool(matches), 'automatic_changes': False,
+            'next': 'Confirm candidates against the exact diagnostic, project and installed versions.' if matches else 'No documented mapping matched. Preserve the exact message and inspect its source location; do not invent a root cause.'}
+
+
+def patterns(name=None):
+    data = json.loads((DATA / 'patterns.json').read_text(encoding='utf-8'))
+    if name is None: return {'patterns': [{'id': p['id'], 'title': p['title']} for p in data]}
+    found = next((p for p in data if p['id'] == name), None)
+    if found is None: raise ValueError('Unknown pattern ID')
+    return {**found, 'references': [reference(id) for id in found['topic_ids']],
+            'provenance': 'Original illustrative plugin pattern; not copied vendor code',
+            'validation': 'Requires project-specific adaptation and native IDE compile; no hardware action is performed'}

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

@@ -0,0 +1,250 @@
+"""Read the library side of a MotionWorks project: which function blocks it uses, and what
+those blocks offer.
+
+Two sources, and they answer different questions.
+
+**`eCLRPouDependencies.dat` is the map.** It is plain text at the top of the resource
+directory and names every POU and library block in the project with its kind and what it
+depends on::
+
+    PouDep.Cache;schema 1
+    0,CalcBezier,3,FB
+    1,CalcSplineMatrix,3,FB
+    2,CalcSpline,3,FB; 1,CalcSplineMatrix
+    4,CamGenerator,3,FB; 2,CalcSpline; 0,CalcBezier; 3,MasterIndex_Lookup
+    5,TopCutterCamSetup,2,PG; 4,CamGenerator
+
+so ``2,PG`` is a program and ``3,FB`` a function block, and the trailing entries are the
+blocks it calls. That is enough to answer "what does this POU use" without reading any
+binary.
+
+**The block's own members come from its compiled assembly.** A library block in this project
+is compiled to ``<name>.DLL`` beside the resource, and it is a real .NET assembly - the
+signature is ``BSJB``, runtime ``v4.0.30319`` - so its identifiers sit in the metadata
+``#Strings`` heap as plain UTF-8. Measured on CamGenerator.DLL, that heap begins with the
+names that matter::
+
+    CamGenerator, ProConOS_eCLR, Iec61131Standard, MasterIndex_Lookup, CalcSpline,
+    CalcBezier, FUNCTION_BLOCK, CamSegmentStruct, Y_MS_CAM_STRUCT, ...
+    Execute, TableSize, Done, Busy, Error, ErrorID, iActive, CamData, CamTable
+
+WHAT THIS CANNOT TELL YOU, and it matters: **the heap does not record input/output
+direction.** ``Execute`` and ``Done`` are distinguishable by convention, not by evidence
+here, and this module does not guess. It reports the names the assembly defines and says
+plainly that direction is not among them. The block's own declarations/native parameter
+table (``mw_code_block_interface``) establish direction; caller instance declarations
+do not establish a block's pin directions.
+
+The heap also carries compiler temporaries - ``__temp_1`` through ``__temp_50``, ``s1``
+through ``s7`` - which are noise here, so they are filtered out rather than reported as if
+they were part of the block's interface.
+"""
+from __future__ import annotations
+
+import re
+import struct
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .errors import NotFound
+
+DEPENDENCY_FILE = "C/Configuration/R/Resource/eCLRPouDependencies.dat"
+RESOURCE_DIR = "C/Configuration/R/Resource"
+
+KINDS = {"1": "FUNCTION", "2": "PROGRAM", "3": "FUNCTION_BLOCK", "4": "FUNCTION_BLOCK"}
+
+# Names the compiler generates rather than the author writing: temporaries, scratch
+# registers and one/two-letter locals. Reporting these as part of a block's interface would
+# be worse than reporting nothing.
+_NOISE = re.compile(
+    r"^(__temp_\d+|__\w+|_\w+|[a-z]\d*|[A-Z]\d*|[a-z]{2}\d*|k\d+|sPtr|amm|amp|C0|d|p)$"
+)
+
+
+@dataclass
+class Block:
+    """One POU or library block named in the dependency manifest."""
+
+    index: int
+    name: str
+    kind: str
+    depends_on: list[str] = field(default_factory=list)
+
+    @property
+    def is_library(self) -> bool:
+        return self.kind == "FUNCTION_BLOCK" or self.kind == "FUNCTION"
+
+
+@dataclass
+class BlockMembers:
+    """The identifiers an assembly defines, in heap order."""
+
+    name: str
+    assembly: str
+    runtime: str
+    identifiers: list[str] = field(default_factory=list)
+    filtered_out: int = 0
+
+
+def _resource_dir(project_root: Path) -> Path:
+    candidate = Path(project_root) / RESOURCE_DIR
+    if not candidate.is_dir():
+        raise NotFound(f"no {RESOURCE_DIR} in {project_root}")
+    return candidate
+
+
+def read_dependencies(project_root: Path) -> list[Block]:
+    """Parse ``eCLRPouDependencies.dat`` into blocks, in file order."""
+    path = Path(project_root) / DEPENDENCY_FILE
+    if not path.is_file():
+        raise NotFound(
+            f"no {DEPENDENCY_FILE} in {project_root}; the project has not been built, so it "
+            f"has no dependency manifest yet"
+        )
+    blocks: list[Block] = []
+    by_index: dict[int, Block] = {}
+    for raw in path.read_text(encoding="latin1", errors="replace").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("PouDep"):
+            continue
+        parts = [p.strip() for p in line.split(";")]
+        head = parts[0].split(",")
+        if len(head) < 4:
+            continue
+        try:
+            index = int(head[0])
+        except ValueError:
+            continue
+        name, code = head[1], head[2]
+        block = Block(index=index, name=name, kind=KINDS.get(code, f"KIND_{code}"))
+        blocks.append(block)
+        by_index[index] = block
+
+    # second pass: the trailing entries are indices, resolved once every block is known
+    for raw in path.read_text(encoding="latin1", errors="replace").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("PouDep"):
+            continue
+        parts = [p.strip() for p in line.split(";")]
+        head = parts[0].split(",")
+        if len(head) < 4:
+            continue
+        try:
+            index = int(head[0])
+        except ValueError:
+            continue
+        block = by_index.get(index)
+        if block is None:
+            continue
+        for dep in parts[1:]:
+            if not dep:
+                continue
+            dep_index = dep.split(",")[0].strip()
+            try:
+                target = by_index.get(int(dep_index))
+            except ValueError:
+                target = None
+            block.depends_on.append(target.name if target else dep)
+    return blocks
+
+
+# ── .NET metadata ────────────────────────────────────────────────────────────────
+
+def _metadata_streams(data: bytes):
+    """Locate the .NET metadata streams, or None if this is not a managed assembly."""
+    at = data.find(b"BSJB")
+    if at < 0:
+        return None
+    off = at + 4
+    try:
+        _major, _minor, _reserved, version_len = struct.unpack_from("<HHII", data, off)
+    except struct.error:
+        return None
+    off += 12
+    version = data[off:off + version_len].split(b"\x00")[0].decode("ascii", "replace")
+    off += version_len + 2
+    try:
+        count = struct.unpack_from("<H", data, off)[0]
+    except struct.error:
+        return None
+    off += 2
+    heaps: dict[str, tuple[int, int]] = {}
+    for _ in range(count):
+        try:
+            stream_off, stream_size = struct.unpack_from("<II", data, off)
+        except struct.error:
+            return None
+        off += 8
+        end = data.find(b"\x00", off)
+        if end < 0:
+            return None
+        name = data[off:end].decode("ascii", "replace")
+        off = (end + 1 + 3) & ~3
+        heaps[name] = (at + stream_off, stream_size)
+    return version, heaps
+
+
+def _strings(data: bytes, base: int, size: int) -> list[str]:
+    raw = data[base:base + size]
+    out: list[str] = []
+    current = bytearray()
+    for byte in raw:
+        if byte == 0:
+            if current:
+                out.append(current.decode("utf-8", "replace"))
+            current = bytearray()
+        else:
+            current.append(byte)
+    if current:
+        out.append(current.decode("utf-8", "replace"))
+    return out
+
+
+def read_block_members(project_root: Path, name: str) -> BlockMembers:
+    """Identifiers defined by a block's compiled assembly.
+
+    Direction is NOT among them - see the module docstring - so this reports names and says
+    so rather than presenting a guess as an interface.
+    """
+    directory = _resource_dir(project_root)
+    for candidate in (directory / f"{name}.DLL", directory / f"{name}.dll"):
+        if candidate.is_file():
+            assembly = candidate
+            break
+    else:
+        blocks = {b.name.lower(): b for b in read_dependencies(project_root)}
+        known = ", ".join(sorted(b.name for b in blocks.values())[:25])
+        raise NotFound(
+            f"no compiled assembly for {name!r} in {RESOURCE_DIR}. Blocks with an assembly "
+            f"here: {known}. A block with no assembly may be defined in the project's own "
+            f"source rather than a library - list those with mw_code_pous."
+        )
+
+    data = assembly.read_bytes()
+    streams = _metadata_streams(data)
+    if not streams:
+        raise NotFound(
+            f"{assembly.name} is not a managed assembly, so it has no readable identifier "
+            f"table. It may be legacy native code."
+        )
+    version, heaps = streams
+    if "#Strings" not in heaps:
+        raise NotFound(f"{assembly.name} has .NET metadata but no #Strings heap")
+
+    base, size = heaps["#Strings"]
+    everything = _strings(data, base, size)
+    seen: set[str] = set()
+    kept: list[str] = []
+    dropped = 0
+    for item in everything:
+        if not item or item in seen:
+            continue
+        seen.add(item)
+        if _NOISE.match(item):
+            dropped += 1
+            continue
+        kept.append(item)
+    return BlockMembers(
+        name=name, assembly=assembly.name, runtime=version,
+        identifiers=kept, filtered_out=dropped,
+    )