sysml2kit 0.2.0__tar.gz → 0.3.0__tar.gz

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.3.0 — 2026-08-21
+
+- **Verification execution** (`sysml2kit.verify`): `verificationBinding`
+  metadata binds an analysis case to an engine resolved by name from the
+  `sysml2kit.engines` entry-point group (model text never names code paths).
+  `run_verification` executes bound analyses and checks each metricKey
+  requirement with margins; `apply_results` writes metrics and verdicts back
+  into the model with provenance, idempotently. CLI `sysml2kit verify`, MCP
+  tool `requirements_verify` (nine tools now), `verify` extra for YAML
+  configs, and a `docs/verification.md` flagship page. First engine:
+  phased-array-systems (PR #2 there).
+- **Live-server harness**: `docker/compose.yaml` runs the pilot
+  implementation (digest-pinned) + postgres; `api`-marked round-trip tests
+  pass against the real server; weekly advisory `live-api` workflow. Live
+  testing hardened the client and reader for the pilot dialect: list-typed
+  endpoints/typing/text adapted on push and tolerated on read, verify/derive
+  pushed as Dependency, multiplicity/doc dropped by the server, server-minted
+  element ids; known-@type records that do not fit the profile now degrade to
+  OpaqueElement instead of failing the read.
+- **`api` CLI group**: `projects`, `pull` (newest commit by default),
+  `push --create`; `SYSML2KIT_API_URL`/`SYSML2KIT_API_TOKEN` env vars;
+  `SysMLApiClient.head_commit`.
+- **Diagrams docs page** and a README refresh for the 0.3 surface.
+- Upstream sysmlpy fixes submitted for the two pinned parse losses:
+  dependency statements (mycr0ft/sysmlpy#7) and allocate endpoints
+  (mycr0ft/sysmlpy#6).
+
 ## 0.2.0 — 2026-08-21
 
 - **Parse fidelity**: the sysmlpy backend now walks the raw ANTLR dict

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sysml2kit
-Version: 0.2.0
+Version: 0.3.0
 Summary: API-first Python tooling for building, querying, validating, and automating SysML v2 models
 Project-URL: Homepage, https://github.com/jman4162/sysml2kit
 Project-URL: Source, https://github.com/jman4162/sysml2kit
@@ -34,6 +34,8 @@ Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.26; extra == 'mcp'
 Provides-Extra: parse
 Requires-Dist: sysmlpy<0.37,>=0.36.2; extra == 'parse'
+Provides-Extra: verify
+Requires-Dist: pyyaml>=6.0; extra == 'verify'
 Description-Content-Type: text/markdown
 
 # sysml2kit
@@ -42,20 +44,25 @@ Description-Content-Type: text/markdown
 [![PyPI](https://img.shields.io/pypi/v/sysml2kit)](https://pypi.org/project/sysml2kit/)
 [![Python](https://img.shields.io/pypi/pyversions/sysml2kit)](https://pypi.org/project/sysml2kit/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
+[![Docs](https://img.shields.io/badge/docs-jman4162.github.io-blue)](https://jman4162.github.io/sysml2kit/)
 
 API-first Python tooling for building, querying, validating, and automating
 SysML v2 models.
 
-> **Status: pre-alpha.** The 0.1.x line has a working core (model, writer,
-> interchange, queries, validation, diff, API client, parse backend); the API
-> may still move between minor versions. Pin an exact version if you depend
-> on it.
+> **Status: pre-alpha.** The 0.3.x line covers the full loop: model, writer,
+> interchange, queries, validation, diff, mermaid views, parse backend, MCP
+> server, API client with a live-server harness, and verification execution.
+> The API may still move between minor versions; pin an exact version if you
+> depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
 
 `sysml2kit` is the requirements/architecture/traceability layer for
 engineering automation stacks: build a system model in Python, emit standard
 SysML v2 textual notation and Systems Modeling API JSON, run traceability
 queries (which requirements are unsatisfied? unverified? allocated where?),
-validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
+validate, diff, and **execute verification**: analyses bound to registered
+engines run for real, and their metrics check the model's requirements. It
+targets the OMG SysML v2 standard, not any vendor tool. Docs:
+https://jman4162.github.io/sysml2kit/
 
 ## What it does
 
@@ -72,8 +79,15 @@ validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
 - **Traceability queries**: unsatisfied/unverified requirements, allocation
   tables, requirement-to-part trace matrices.
 - **Validation and diff**: rule-based model checks and element-level diffs.
+- **Verification execution**: `verificationBinding` metadata binds an
+  analysis case to an engine from the `sysml2kit.engines` entry-point group;
+  `sysml2kit verify` runs it and checks each requirement with margins, and
+  can write results back into the model with provenance.
+- **Mermaid views**: ownership-tree and requirement-trace diagrams.
+- **MCP server**: nine tools for agents (`sysml2kit mcp serve`).
 - **API client**: a thin HTTP client for the OMG Systems Modeling API and
-  Services endpoints.
+  Services endpoints, plus a docker compose harness running the pilot
+  implementation for live round-trip testing.
 
 ## Install
 
@@ -81,6 +95,8 @@ validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
 pip install sysml2kit            # core: build, write, query, validate, diff
 pip install "sysml2kit[parse]"   # + read .sysml files (sysmlpy backend)
 pip install "sysml2kit[graph]"   # + NetworkX export
+pip install "sysml2kit[mcp]"     # + MCP server for agents
+pip install "sysml2kit[verify]"  # + YAML verification-binding configs
 ```
 
 ## Quick start
@@ -119,9 +135,13 @@ sysml2kit
 ├── query         # traceability queries
 ├── validation    # rule-based checks (S2K001...)
 ├── diff          # element-level model diff
+├── views         # mermaid diagrams (trace, tree)
+├── verify        # verification bindings, engine registry, runner
 ├── api           # Systems Modeling API HTTP client
 ├── backends      # parser backends (sysmlpy behind the [parse] extra)
 ├── interop       # tool-agnostic requirement extraction
+├── mcp           # MCP server (behind the [mcp] extra)
+├── graph, units, workspace   # NetworkX export, pint helpers, path safety
 └── cli           # `sysml2kit` command line
 ```
 
@@ -131,13 +151,17 @@ The spec pin, element subset, and known deviations are documented in
 
 Domain content lives outside the kit. For antenna/RF systems engineering, see
 [sysml2kit-rf-library](https://github.com/jman4162/sysml2kit-rf-library), a
-SysML v2 model library consumed through this package.
+SysML v2 model library consumed through this package. Downstream bridges are
+merged in [phased-array-systems](https://github.com/jman4162/phased-array-systems)
+(`interop.sysml`: requirement sets and the `phased-array-systems` verification
+engine) and [aedl](https://github.com/jman4162/aedl-electromagnetic-design-agent)
+(`aedl.interop`: bound-form requirements).
 
 ## For agents
 
-An MCP server ships behind the `mcp` extra with eight tools: `model_show`,
+An MCP server ships behind the `mcp` extra with nine tools: `model_show`,
 `model_validate`, `model_diff`, `model_export`, `model_diagram`,
-`requirements_trace`, `requirements_extract`, `library_load`. Artifacts are
+`requirements_trace`, `requirements_extract`, `requirements_verify`, `library_load`. Artifacts are
 returned as file paths, not payloads.
 
 ```bash
@@ -149,8 +173,9 @@ sysml2kit mcp serve            # stdio; --transport http also supported
 {"mcpServers": {"sysml2kit": {"command": "sysml2kit", "args": ["mcp", "serve"]}}}
 ```
 
-The CLI (`sysml2kit show | validate | diff | export | fmt`) covers the same
-operations for shell use.
+The CLI covers the same operations for shell use:
+`sysml2kit show | validate | diff | export | fmt | verify | api | mcp serve`
+(`export --to mermaid` renders diagrams).
 
 ## Development
 

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/README.md

@@ -4,20 +4,25 @@
 [![PyPI](https://img.shields.io/pypi/v/sysml2kit)](https://pypi.org/project/sysml2kit/)
 [![Python](https://img.shields.io/pypi/pyversions/sysml2kit)](https://pypi.org/project/sysml2kit/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE)
+[![Docs](https://img.shields.io/badge/docs-jman4162.github.io-blue)](https://jman4162.github.io/sysml2kit/)
 
 API-first Python tooling for building, querying, validating, and automating
 SysML v2 models.
 
-> **Status: pre-alpha.** The 0.1.x line has a working core (model, writer,
-> interchange, queries, validation, diff, API client, parse backend); the API
-> may still move between minor versions. Pin an exact version if you depend
-> on it.
+> **Status: pre-alpha.** The 0.3.x line covers the full loop: model, writer,
+> interchange, queries, validation, diff, mermaid views, parse backend, MCP
+> server, API client with a live-server harness, and verification execution.
+> The API may still move between minor versions; pin an exact version if you
+> depend on it. Changes: [CHANGELOG.md](CHANGELOG.md).
 
 `sysml2kit` is the requirements/architecture/traceability layer for
 engineering automation stacks: build a system model in Python, emit standard
 SysML v2 textual notation and Systems Modeling API JSON, run traceability
 queries (which requirements are unsatisfied? unverified? allocated where?),
-validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
+validate, diff, and **execute verification**: analyses bound to registered
+engines run for real, and their metrics check the model's requirements. It
+targets the OMG SysML v2 standard, not any vendor tool. Docs:
+https://jman4162.github.io/sysml2kit/
 
 ## What it does
 
@@ -34,8 +39,15 @@ validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
 - **Traceability queries**: unsatisfied/unverified requirements, allocation
   tables, requirement-to-part trace matrices.
 - **Validation and diff**: rule-based model checks and element-level diffs.
+- **Verification execution**: `verificationBinding` metadata binds an
+  analysis case to an engine from the `sysml2kit.engines` entry-point group;
+  `sysml2kit verify` runs it and checks each requirement with margins, and
+  can write results back into the model with provenance.
+- **Mermaid views**: ownership-tree and requirement-trace diagrams.
+- **MCP server**: nine tools for agents (`sysml2kit mcp serve`).
 - **API client**: a thin HTTP client for the OMG Systems Modeling API and
-  Services endpoints.
+  Services endpoints, plus a docker compose harness running the pilot
+  implementation for live round-trip testing.
 
 ## Install
 
@@ -43,6 +55,8 @@ validate, and diff. It targets the OMG SysML v2 standard, not any vendor tool.
 pip install sysml2kit            # core: build, write, query, validate, diff
 pip install "sysml2kit[parse]"   # + read .sysml files (sysmlpy backend)
 pip install "sysml2kit[graph]"   # + NetworkX export
+pip install "sysml2kit[mcp]"     # + MCP server for agents
+pip install "sysml2kit[verify]"  # + YAML verification-binding configs
 ```
 
 ## Quick start
@@ -81,9 +95,13 @@ sysml2kit
 ├── query         # traceability queries
 ├── validation    # rule-based checks (S2K001...)
 ├── diff          # element-level model diff
+├── views         # mermaid diagrams (trace, tree)
+├── verify        # verification bindings, engine registry, runner
 ├── api           # Systems Modeling API HTTP client
 ├── backends      # parser backends (sysmlpy behind the [parse] extra)
 ├── interop       # tool-agnostic requirement extraction
+├── mcp           # MCP server (behind the [mcp] extra)
+├── graph, units, workspace   # NetworkX export, pint helpers, path safety
 └── cli           # `sysml2kit` command line
 ```
 
@@ -93,13 +111,17 @@ The spec pin, element subset, and known deviations are documented in
 
 Domain content lives outside the kit. For antenna/RF systems engineering, see
 [sysml2kit-rf-library](https://github.com/jman4162/sysml2kit-rf-library), a
-SysML v2 model library consumed through this package.
+SysML v2 model library consumed through this package. Downstream bridges are
+merged in [phased-array-systems](https://github.com/jman4162/phased-array-systems)
+(`interop.sysml`: requirement sets and the `phased-array-systems` verification
+engine) and [aedl](https://github.com/jman4162/aedl-electromagnetic-design-agent)
+(`aedl.interop`: bound-form requirements).
 
 ## For agents
 
-An MCP server ships behind the `mcp` extra with eight tools: `model_show`,
+An MCP server ships behind the `mcp` extra with nine tools: `model_show`,
 `model_validate`, `model_diff`, `model_export`, `model_diagram`,
-`requirements_trace`, `requirements_extract`, `library_load`. Artifacts are
+`requirements_trace`, `requirements_extract`, `requirements_verify`, `library_load`. Artifacts are
 returned as file paths, not payloads.
 
 ```bash
@@ -111,8 +133,9 @@ sysml2kit mcp serve            # stdio; --transport http also supported
 {"mcpServers": {"sysml2kit": {"command": "sysml2kit", "args": ["mcp", "serve"]}}}
 ```
 
-The CLI (`sysml2kit show | validate | diff | export | fmt`) covers the same
-operations for shell use.
+The CLI covers the same operations for shell use:
+`sysml2kit show | validate | diff | export | fmt | verify | api | mcp serve`
+(`export --to mermaid` renders diagrams).
 
 ## Development
 

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/SPEC.md

@@ -77,6 +77,33 @@ test failure.
 - `Model.assign_stable_ids()` rewrites ids as UUIDv5 hashes of qualified
   names so generated interchange files diff cleanly under version control.
 
+## Verification binding convention
+
+A ``MetadataUsage`` named ``verificationBinding`` annotating an
+``AnalysisCaseUsage`` binds that analysis to an executable engine. Values
+(flat scalars, per the metadata model):
+
+| key | type | meaning |
+|---|---|---|
+| ``engine`` | str, required | registry name, e.g. ``"phased-array-systems"`` |
+| ``configRef`` | str, optional | ``.yaml``/``.yml``/``.json`` payload file next to the model file (resolved relative to its directory, containment-checked; no ``..``) |
+| ``payload.<dotted>`` | scalar, optional | override deep-merged over the loaded config; dotted keys expand to nested dicts |
+
+Engines resolve **by name** against a registry populated from the
+``sysml2kit.engines`` entry-point group and explicit caller registration.
+Model text never names importable code paths — models are data. The runner
+does not interpret payload contents; each engine owns its payload schema
+(engines needing a config plus scalar arguments define reserved top-level
+keys such as ``config``/``args``).
+
+Results written back by ``sysml2kit.verify.apply_results`` are attributes on
+the analysis (``source`` starts with ``sysml2kit.verify``) and a
+``verificationVerdict`` metadata on each requirement; both replace prior
+same-named results, so reruns do not accumulate.
+
+Bindings are an interchange-JSON feature: metadata values round-trip through
+JSON, while textual-notation fidelity for metadata is not yet pinned.
+
 ## Provenance on values
 
 `AttributeValue` carries optional `source` and `confidence` fields, following

sysml2kit-0.3.0/docker/compose.yaml

@@ -0,0 +1,35 @@
+# Local Systems Modeling API server (the OMG pilot implementation) for
+# live-client testing:  docker compose -f docker/compose.yaml up -d
+# then scripts/wait_for_api.sh and  pytest -m api  with
+# SYSML2KIT_API_URL=http://localhost:9000.
+#
+# The app image is the MBSE-mashup containerization of the pilot, pinned by
+# digest (tag 244c221a..., pushed 2025-12-12). Its entrypoint rewrites
+# persistence.xml from the JDBC_*/HIBERNATE_* env vars; hbm2ddl=update
+# creates the schema on first boot. amd64-only: Apple-silicon hosts run it
+# under emulation (the platform key below).
+services:
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_PASSWORD: mysecretpassword
+      POSTGRES_DB: sysml2
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d sysml2"]
+      interval: 5s
+      timeout: 3s
+      retries: 24
+
+  api:
+    image: mbsemashup/sysmlv2-api.pilotimpl@sha256:ac5607986dd529fc98a55aa391ac9f51b275c36f74f946285121c896f7e914c6
+    platform: linux/amd64
+    depends_on:
+      db:
+        condition: service_healthy
+    ports:
+      - "9000:9000"
+    environment:
+      JDBC_URL: jdbc:postgresql://db:5432/sysml2
+      JDBC_USER: postgres
+      JDBC_PASSWORD: mysecretpassword
+      HIBERNATE_HBM2DDL: update

sysml2kit-0.3.0/docs/api-client.md

@@ -0,0 +1,49 @@
+# API client
+
+`sysml2kit.api.SysMLApiClient` is a hand-written httpx client for the OMG
+Systems Modeling API and Services endpoints (the REST binding any conformant
+model server exposes).
+
+```python
+from sysml2kit.api import SysMLApiClient
+
+with SysMLApiClient("https://models.example.com", token="…") as client:
+    for project in client.list_projects():
+        print(project.id, project.name)
+    model = client.list_elements(project_id, commit_id)  # -> sysml2kit Model
+    client.push_model(project_id, model, message="update")
+```
+
+Covered in v0.1: `list_projects`, `get_project`, `list_branches`,
+`list_commits`, `get_commit`, `get_element`, `list_elements` (returns a
+`Model` via the interchange reader), `create_project`, and `push_model`
+(POSTs a commit whose change set inserts the model's records). Branch
+management and merges are not covered yet.
+
+Failures raise `ApiError(status, detail)`. The client sends the bearer token
+to whatever base URL you configure; use HTTPS.
+
+## Local live server and the pilot dialect
+
+`docker compose -f docker/compose.yaml up -d` starts the pilot
+implementation (sha-pinned image + postgres); `scripts/wait_for_api.sh`
+polls until it answers, and `SYSML2KIT_API_URL=http://localhost:9000
+pytest -m api` runs the live round-trip suite (a weekly advisory workflow
+does the same in CI). The CLI mirrors the client:
+
+```bash
+export SYSML2KIT_API_URL=http://localhost:9000
+sysml2kit api projects
+sysml2kit api push model.json --project demo --create
+sysml2kit api pull demo -o pulled.json
+```
+
+The pilot speaks the full abstract syntax, so `push_model` adapts records on
+the way out and the interchange reader tolerates the differences on the way
+back. What survives a server round trip: element kinds, names, short names,
+requirement text. What does not (documented degradations — full fidelity
+lives in interchange JSON files): ownership (the pilot models it as
+OwningMembership elements and ignores our owner key), verify/derive kinds
+(pushed as `Dependency`), multiplicity and doc strings (dropped), and
+element ids (the server mints its own, so stable-id workflows are
+local-file-only).

sysml2kit-0.3.0/docs/verification.md

@@ -0,0 +1,87 @@
+# Verification execution
+
+`sysml2kit.verify` closes the loop the traceability queries only describe:
+it runs the analyses a model's verify links point at and checks each
+requirement against real metrics.
+
+## The binding convention
+
+An analysis case becomes executable when it carries a `verificationBinding`
+metadata (see SPEC.md for the normative statement):
+
+```python
+from sysml2kit.model import builder
+
+analysis = builder.analysis(model, "pasStudy", owner=pkg, subject=terminal)
+builder.verify(model, source=analysis, target=link_margin_req, owner=pkg)
+builder.metadata(
+    model,
+    analysis,
+    {"engine": "phased-array-systems", "configRef": "study.yaml"},
+    name="verificationBinding",
+)
+```
+
+- `engine` names an entry in the engine registry — never a code path.
+  Models are data; the registry decides what runs.
+- `configRef` points at a YAML/JSON payload next to the model file.
+- `payload.<dotted>` values override entries in the loaded config
+  (`payload.scenario.range_km: 500`).
+
+## Engines
+
+An engine is a callable: payload dict in, flat metrics mapping out.
+Packages ship engines through the `sysml2kit.engines` entry-point group:
+
+```toml
+[project.entry-points."sysml2kit.engines"]
+phased-array-systems = "phased_array_systems.interop.sysml:run_study"
+```
+
+Installing such a package makes its engine available by name. The CLI also
+accepts operator-supplied engines (`--engine name=module:function`), and
+library callers register directly on an `EngineRegistry`.
+
+## Running
+
+```bash
+sysml2kit verify model.json --report run.json
+sysml2kit verify model.json --write-back -o annotated.json
+```
+
+```python
+from sysml2kit.verify import run_verification, apply_results
+
+run = run_verification(model, model_path=path)
+print(run.passed)
+for verdict in run.requirements:
+    print(verdict.requirement_id, verdict.status, verdict.margin)
+apply_results(model, run)  # record results into the model, idempotent
+```
+
+Each requirement verdict carries the metric key, operator, threshold,
+actual value, and margin; `passed` is true only when every must-severity
+requirement passes and no engine errored. Metrics that are absent or
+non-numeric yield `unknown`, which does not pass. Engine exceptions are
+captured per analysis, never raised.
+
+Write-back records each checked metric as an attribute on its analysis with
+a provenance `source` (`sysml2kit.verify <engine>==<version> <timestamp>`)
+and a `verificationVerdict` metadata on each requirement, replacing prior
+results so reruns do not accumulate.
+
+Over MCP, the `requirements_verify` tool runs the same flow with
+entry-point engines only, returning `passed`, must-failures, and the report
+path.
+
+## End to end with the RF library
+
+With `phased-array-systems` and `sysml2kit-rf-library` installed:
+
+```bash
+MODEL=$(python -c 'import sysml2kit_rf_library as m; print(m.models_dir())')/interchange/satcom_terminal_pas.json
+sysml2kit verify "$MODEL" --report run.json
+```
+
+runs a phased-array study and checks link margin, EIRP, sidelobes, prime
+power, and cost against the model's thresholds.

sysml2kit-0.3.0/docs/views.md

@@ -0,0 +1,24 @@
+# Diagrams
+
+`sysml2kit.views` renders two mermaid views; output is deterministic, so
+diagrams diff cleanly and render anywhere mermaid fences do (these docs,
+GitHub, Claude artifacts).
+
+```python
+from sysml2kit.views import to_mermaid_trace, to_mermaid_tree
+
+print(to_mermaid_trace(model))  # requirements, parts, analyses + edges
+print(to_mermaid_tree(model))  # package/part/port ownership
+```
+
+```bash
+sysml2kit export model.json --to mermaid --diagram trace -o trace.mmd
+sysml2kit export model.json --to mermaid --diagram tree
+```
+
+The trace view draws requirements as hexagons, analyses as parallelograms,
+and parts as rounded boxes, with edge styles per relationship kind: solid
+`satisfy`, dotted `verify`/`derive`, thick `allocate`. Only elements that
+participate in a relationship appear, so large models stay readable.
+
+Over MCP, the `model_diagram` tool writes the same views to a `.mmd` file.

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/mkdocs.yml

@@ -34,7 +34,9 @@ nav:
   - Quickstart: quickstart.md
   - Concepts: concepts.md
   - Traceability: traceability.md
+  - Verification: verification.md
   - Interchange: interchange.md
+  - Diagrams: views.md
   - Command line: cli.md
   - MCP server: mcp.md
   - API client: api-client.md

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/pyproject.toml

@@ -52,6 +52,8 @@ parse = ["sysmlpy>=0.36.2,<0.37"]
 graph = ["networkx>=3.2"]
 # mcp 2.0.0 removed mcp.server.fastmcp; stay on 1.x until the surface is ported.
 mcp = ["mcp>=1.26,<2"]
+# YAML verification-binding configs; JSON configs work without it.
+verify = ["pyyaml>=6.0"]
 
 [project.scripts]
 sysml2kit = "sysml2kit.cli:app"
@@ -70,15 +72,17 @@ test = [
   "hypothesis>=6.130",
   "respx>=0.22",
 ]
-lint = ["mypy>=1.15", "ruff>=0.16"]
+lint = ["mypy>=1.15", "ruff>=0.16", "types-PyYAML>=6.0"]
 parse-test = ["sysmlpy>=0.36.2,<0.37"]
 mcp-test = ["mcp>=1.26,<2"]
+verify-test = ["pyyaml>=6.0"]
 docs = ["mkdocs-material>=9.5", "mkdocstrings[python]>=0.27"]
 dev = [
   { include-group = "test" },
   { include-group = "lint" },
   { include-group = "parse-test" },
   { include-group = "mcp-test" },
+  { include-group = "verify-test" },
   { include-group = "docs" },
 ]
 

sysml2kit-0.3.0/scripts/wait_for_api.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Wait for a Systems Modeling API server to answer; used locally and in CI.
+set -u
+
+URL="${SYSML2KIT_API_URL:-http://localhost:9000}"
+DEADLINE=$((SECONDS + ${WAIT_FOR_API_TIMEOUT:-180}))
+
+echo "[wait_for_api] polling ${URL}/projects"
+while [ $SECONDS -lt $DEADLINE ]; do
+  if curl -sf "${URL}/projects" >/dev/null 2>&1; then
+    echo "[wait_for_api] server is up (${SECONDS}s)"
+    exit 0
+  fi
+  sleep 3
+done
+echo "[wait_for_api] timed out after ${WAIT_FOR_API_TIMEOUT:-180}s" >&2
+exit 1

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/src/sysml2kit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
 __commit_id__ = commit_id = None

{sysml2kit-0.2.0 → sysml2kit-0.3.0}/src/sysml2kit/api/client.py

@@ -101,6 +101,37 @@ class SysMLApiClient:
             payload["description"] = description
         return Project.model_validate(self._post("/projects", payload))
 
+    @staticmethod
+    def _to_server_record(record: dict[str, Any]) -> dict[str, Any]:
+        """Adapt one interchange record to the pilot server's dialect.
+
+        The abstract syntax types relationship ``source``/``target`` as lists
+        of related elements; sysml2kit's records carry a single ``{"@id"}``
+        (a documented profile simplification). Wrap them on the way out; the
+        interchange reader unwraps single-element lists on the way back.
+        """
+        adapted = dict(record)
+        for key in ("source", "target", "definition"):
+            value = adapted.get(key)
+            if isinstance(value, dict) and set(value) == {"@id"}:
+                adapted[key] = [value]
+        # Profile simplifications with no server-side shape are dropped on
+        # push (multiplicity is opaque text here, a Multiplicity element
+        # there). Fidelity lives in interchange JSON files, not the server.
+        adapted.pop("multiplicity", None)
+        # RequirementUsage/RequirementDefinition `text` is List<String> there.
+        if isinstance(adapted.get("text"), str):
+            adapted["text"] = [adapted["text"]]
+        # The pilot's type vocabulary has no DeriveRequirementUsage or
+        # VerifyRequirementUsage; those push as Dependency (client/supplier),
+        # losing the kind distinction on pull — same degradation class as the
+        # textual notation. Full fidelity lives in interchange JSON files.
+        if adapted.get("@type") in ("DeriveRequirementUsage", "VerifyRequirementUsage"):
+            adapted["@type"] = "Dependency"
+            adapted["client"] = adapted.pop("source", None) or []
+            adapted["supplier"] = adapted.pop("target", None) or []
+        return adapted
+
     def push_model(
         self,
         project_id: str,
@@ -110,7 +141,10 @@ class SysMLApiClient:
         message: str | None = None,
     ) -> Commit:
         """Create a commit whose change set inserts every element of the model."""
-        change = [{"@type": "DataVersion", "payload": record} for record in model_to_json(model)]
+        change = [
+            {"@type": "DataVersion", "payload": self._to_server_record(record)}
+            for record in model_to_json(model)
+        ]
         payload: dict[str, Any] = {"@type": "Commit", "change": change}
         if message:
             payload["description"] = message
@@ -118,3 +152,10 @@ class SysMLApiClient:
         if branch:
             path += f"?branchId={branch}"
         return Commit.model_validate(self._post(path, payload))
+
+    def head_commit(self, project_id: str) -> Commit:
+        """Return the newest commit of a project; raises ApiError when empty."""
+        commits = self.list_commits(project_id)
+        if not commits:
+            raise ApiError(404, f"project {project_id} has no commits")
+        return commits[-1]