rocket-engine 0.0.2b1__py3-none-any.whl

rocket_engine/adapters/lvs_netgen/results.py

@@ -0,0 +1,168 @@
+"""Netgen LVS v1 normalizer: v0 parse output to a ResultBundle.
+
+Maps the ``run_lvs`` parse shape (match flag plus ``violations[]``
+with rule, severity, message, and net/instance subjects) onto a
+typed mismatch table, a bound view, and findings. Pure function
+of the parsed output: no I/O, no tool calls, deterministic ids
+derived from the run id. A match carries no findings; any
+mismatch fails as an error finding.
+"""
+
+TASK = "run_lvs"
+
+_DIAG_CAP = 240
+
+_SEVERITY = {"error": "error", "warning": "warning"}
+
+
+def _cap(text):
+    """Cap one diagnostic string at the bundle prose limit.
+
+    Args:
+        text: Raw diagnostic text, possibly unbounded tool prose.
+
+    Returns:
+        The text unchanged when short, else truncated with an
+            ellipsis marker.
+    """
+    text = text if isinstance(text, str) else str(text)
+    if len(text) <= _DIAG_CAP:
+        return text
+    return text[: _DIAG_CAP - 3] + "..."
+
+
+def _subject(violation):
+    """Name the net or instance one mismatch is about.
+
+    Args:
+        violation: v0 violation with optional net/instance keys.
+
+    Returns:
+        Subject text, or an empty string when unlocated.
+    """
+    return str(violation.get("net") or violation.get("instance") or "")
+
+
+def _provenance(project_id, run_id, tools, provenance):
+    """Build ResultProvenance, defaulting to a placeholder closure.
+
+    Args:
+        project_id: Project the run belongs to.
+        run_id: Run the bundle describes.
+        tools: Tool ingredient mappings (id, version, digest?).
+        provenance: Full provenance mapping when the caller has
+            one; a deterministic placeholder otherwise.
+
+    Returns:
+        Provenance mapping valid against the v1 schema.
+    """
+    if provenance is not None:
+        return provenance
+    ref = {"scope": "project", "id": project_id, "revision": "r1"}
+    return {
+        "snapshot": dict(ref),
+        "input_lock": dict(ref),
+        "closure_hash": "0" * 64,
+        "tools": [
+            {
+                "id": item["id"],
+                "version": item.get("version", ""),
+                "digest": item.get("digest", "0" * 64),
+            }
+            for item in tools
+        ],
+        "parents": [],
+    }
+
+
+def normalize(parsed, *, run_id, project_id="project", target=None,
+              tools=(), provenance=None):
+    """Normalize one netgen LVS parse output to a v1 ResultBundle.
+
+    Mismatch rows become a table dataset (rule, message,
+    subject) plus a bound table view; every mismatch also
+    becomes a finding with a capped message.
+
+    Args:
+        parsed: v0 parse mapping with ``match`` and
+            ``violations[]``.
+        run_id: Run the bundle describes (anchors all ids).
+        project_id: Project the run belongs to.
+        target: v1 target mapping; project kind by default.
+        tools: Tool ingredient mappings for provenance.
+        provenance: Full provenance mapping when the caller has
+            one; a deterministic placeholder otherwise.
+
+    Returns:
+        Schema-valid ResultBundle mapping.
+    """
+    violations = parsed.get("violations") or []
+    table_id = f"{run_id}:dataset:mismatches"
+    datasets = [
+        {
+            "id": table_id,
+            "kind": "table",
+            "row_count": len(violations),
+            "columns": [
+                {
+                    "id": f"{table_id}:rule",
+                    "name": "rule",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [v.get("rule", "") for v in violations],
+                },
+                {
+                    "id": f"{table_id}:message",
+                    "name": "message",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [_cap(v.get("message", "")) for v in violations],
+                },
+                {
+                    "id": f"{table_id}:subject",
+                    "name": "subject",
+                    "dtype": "utf8",
+                    "unit": "1",
+                    "data": [_subject(v) for v in violations],
+                },
+            ],
+            "conditions": [],
+        }
+    ]
+    views = [
+        {
+            "id": f"{run_id}:view:mismatches",
+            "kind": "table",
+            "dataset_id": table_id,
+            "name": "lvs mismatches",
+        }
+    ]
+    findings = [
+        {
+            "id": f"{run_id}:finding:{index}",
+            "severity": _SEVERITY.get(v.get("severity"), "info"),
+            "code": v.get("rule", "lvs_net_mismatch"),
+            "message": _cap(v.get("message", "")),
+        }
+        for index, v in enumerate(violations)
+    ]
+    return {
+        "schema": "rocketeda/results/v1",
+        "ref": {"scope": "project", "id": run_id, "revision": "r1"},
+        "run_id": run_id,
+        "task": TASK,
+        "target": dict(target)
+        if target is not None
+        else {"project_id": project_id, "kind": "project"},
+        "state": "complete",
+        "freshness": "current",
+        "convergence": "not_applicable",
+        "provenance": _provenance(project_id, run_id, tools, provenance),
+        "datasets": datasets,
+        "views": views,
+        "measurements": [],
+        "findings": findings,
+        "artifacts": [],
+        "logs": [],
+        "gaps": [],
+    }

rocket_engine/adapters/mcp/README.md

@@ -0,0 +1,19 @@
+# adapters/mcp — project-scoped MCP stdio server
+
+The MCP bridge exposes the engine operation and query vocabulary as tools. `McpTransport` validates and routes calls to the same `Engine.submit` path used by other clients; the server itself owns no agent loop, queue policy, or verdict logic. stdout is reserved for MCP protocol traffic.
+
+## Trust boundary
+
+Local-only trust: this server speaks stdio to the local harness under OS identity — no tokens, no listener, no remote execution, no multi-user, hence no auth step (the named `TRUST_NOTE` in `server.py`). Human Run on the displayed cell is the approval; the harness edge (rocket-fuel client permissions) owns ask/deny. Same caller-blind API as every other transport; localhost-only, no auth.
+
+## Project binding
+
+`--project` binds the server to one project and fills the project ID and current expected revision for mutation calls. `--project-dir` additionally confines `run_spice` source paths to that project, loads run targets and the PDK pin from its `constraints.yaml` (`pdk: <id>` pins the one registered revision, `pdk: {id, revision}` is taken as written, `none` means generic models, and an unregistered id fails with `unknown_pdk`), chooses the run work directory, and writes completed run evidence under `results/engine-runs/`.
+
+Normal solver operations currently execute inline through `submit` and return their completion. `run_job` remains available for deferred work, pool draining, and idempotent result retrieval. This differs from older Fuel notes that describe every run as a two-call admission/execution sequence; use the [current Engine implementation](../../composition.py) and generated [API reference](../../../docs/engine-api.md) for the live behavior.
+
+## Tool descriptions and schemas
+
+Descriptions are derived from the same handler docstrings used by the generated API reference. The MCP `inputSchema` is still generic for most operation/query tools; `python_execute` is the current specific-schema exception. The open [MCP-SCHEMA ticket](../../../docs/tickets/MCP-SCHEMA.md) tracks wiring generated schemas to every tool. `cancel_job` is also not yet part of the public operation vocabulary.
+
+Python execution requests an approval; the agent cannot approve its own code. Approval resolution belongs to the trusted client path. See [`execution/`](../../execution/README.md), the [Fuel contract note](../../../docs/fuel-contract.md), and the [PRD harness boundary](../../../../PRD/harness/README.md).

rocket_engine/adapters/mcp/__init__.py

@@ -0,0 +1,85 @@
+"""MCP stdio bridge (request/response + get_events_since polling, NOT push — see PUSH-EVENTS): tool calls in, bounded replies out.
+
+Only cataloged operations and read queries are exposed. Anything else
+— host shells first among them — is rejected, never routed.
+"""
+
+import uuid
+
+from ...clients.runtime import RuntimeClient
+from ...interfaces.vocabulary import OPERATIONS, QUERIES
+from .. import api
+from ..base import enforce_scope, parse_json
+from ..errors import AdapterError
+
+
+class McpTransport:
+    """MCP transport over an engine: tool calls in, bounded replies out.
+
+    Args:
+        engine: Engine the tool calls submit against.
+        project_id: Optional scope; calls for another project are
+            denied, never routed.
+    """
+
+    host_execution_enabled = False
+
+    def __init__(self, engine, project_id=None):
+        self._engine = engine
+        self._project_id = project_id
+
+    def handle(self, text):
+        """Route one tools/call message through the engine.
+
+        Args:
+            text: Raw JSON-RPC message with method tools/call and
+                params holding the tool name plus arguments
+                (project_id required).
+
+        Returns:
+            Engine admission ack or query result for the tool call.
+
+        Raises:
+            AdapterError: unsupported_operation for a foreign
+                method or an uncataloged tool, invalid_command for
+                a missing project_id, cross_project_denied for a
+                call outside the bound scope.
+
+        Caution: Only cataloged operations and read queries are
+            exposed — anything else, host shells first among them,
+            is rejected, never routed.
+        """
+        message = parse_json(text)
+        if message.get("method") != "tools/call":
+            raise AdapterError(
+                "unsupported_operation",
+                f"Unsupported method: {message.get('method')}.",
+            )
+        params = message.get("params", {})
+        name = params.get("name")
+        if name not in OPERATIONS and name not in QUERIES:
+            raise AdapterError("unsupported_operation", f"Unsupported tool: {name}.")
+        arguments = dict(params.get("arguments", {}))
+        if arguments.get("project_id") is None:
+            raise AdapterError("invalid_command", "Missing project_id in arguments.")
+        enforce_scope(arguments.get("project_id"), self._project_id)
+        return api.submit(
+            self._engine,
+            arguments.pop("project_id"),
+            name,
+            arguments,
+            request_id=str(message.get("id", uuid.uuid4().hex)),
+        )
+
+    def runtime_client(self):
+        """Serve this transport's engine through the shared client.
+
+        The MCP list/call path is untouched — this binds the same
+        engine's integrated runtime (deferred submit, pump, wait,
+        cancel, watch) so MCP clients share one run identity
+        with every other transport.
+
+        Returns:
+            RuntimeClient bound to this transport's engine.
+        """
+        return RuntimeClient(self._engine)