wirestudio 0.17.2__tar.gz → 0.18.0__tar.gz

{wirestudio-0.17.2/wirestudio.egg-info → wirestudio-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wirestudio
-Version: 0.17.2
+Version: 0.18.0
 Summary: Agent-driven IoT device design tool that produces ESPHome YAML.
 Author: wirestudio contributors
 License: MIT

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_agent.py

@@ -145,6 +145,19 @@ def test_set_param_set_and_delete(lib, garage_motion_design):
     assert "address" not in bme1["params"]
 
 
+def test_set_strict_toggles_design_field(lib, garage_motion_design):
+    assert garage_motion_design.get("strict", False) is False
+    out, is_error = execute_tool(
+        "set_strict", {"enabled": True}, garage_motion_design, lib,
+    )
+    assert is_error is False
+    assert garage_motion_design["strict"] is True
+    assert json.loads(out)["strict"] is True
+
+    execute_tool("set_strict", {"enabled": False}, garage_motion_design, lib)
+    assert garage_motion_design["strict"] is False
+
+
 def test_set_connection_updates_existing(lib, garage_motion_design):
     out, is_error = execute_tool(
         "set_connection",

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_api.py

@@ -160,13 +160,26 @@ def test_render_strict_mode_blocks_on_compat_warning(client):
     assert strict.status_code == 422
     detail = strict.json()["detail"]
     assert detail["error"] == "strict_mode_blocked"
-    assert "compatibility issue" in detail["message"]
-    assert len(detail["warnings"]) >= 1
+    assert "need attention" in detail["message"]
+    assert len(detail["blockers"]) >= 1
     assert all(
-        w["severity"] in ("warn", "error") for w in detail["warnings"]
+        b["severity"] in ("warn", "error") for b in detail["blockers"]
     )
 
 
+def test_render_strict_via_design_field_blocks(client):
+    """`strict: true` on the design blocks generation with no ?strict query --
+    the toggle lives in design.json so generation stays a pure function of it."""
+    design = json.loads((EXAMPLES_DIR / "ttgo-lora32.json").read_text())
+    design["strict"] = True
+    blocked = client.post("/design/render", json=design)
+    assert blocked.status_code == 422
+    assert blocked.json()["detail"]["error"] == "strict_mode_blocked"
+
+    design["strict"] = False
+    assert client.post("/design/render", json=design).status_code == 200
+
+
 def test_render_strict_mode_ignores_info_severity(client):
     """info-severity entries (like the D1 Mini A0 voltage_limit) should
     NOT trip strict mode -- they're educational, not blocking. We use

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_compatibility.py

@@ -139,6 +139,38 @@ def test_a0_voltage_limit_emits_info(lib):
     assert "input_only" in set(lib_d1.gpio_capabilities["A0"])
 
 
+def test_pwm_output_on_no_pwm_pin_is_an_error(lib):
+    """D1 Mini's D0 (GPIO16) has no timer PWM. Hand-wiring pwm_fan.PWM (a
+    requires_pwm output) there should emit a hard error -- the solver won't
+    auto-assign it, but a manual bind must still be caught."""
+    d = _load("solder-fan")
+    for c in d["connections"]:
+        if c["component_id"] == "exhaust" and c["pin_role"] == "PWM":
+            c["target"] = {"kind": "gpio", "pin": "D0"}
+    warnings = check_pin_compatibility(d, lib)
+    errs = [w for w in _by_code(warnings, "function_unsupported")
+            if w.pin == "D0" and w.pin_role == "PWM"]
+    assert len(errs) == 1
+    assert errs[0].severity == "error"
+    assert "PWM" in errs[0].message
+
+
+def test_interrupt_input_on_no_interrupt_pin_is_an_error(lib):
+    """D1 Mini's D0 (GPIO16) can't fire edge interrupts. Hand-wiring the fan's
+    tachometer (pulse_counter, a requires_interrupt input) there should emit a
+    hard error."""
+    d = _load("solder-fan")
+    for c in d["connections"]:
+        if c["component_id"] == "exhaust" and c["pin_role"] == "TACH":
+            c["target"] = {"kind": "gpio", "pin": "D0"}
+    warnings = check_pin_compatibility(d, lib)
+    errs = [w for w in _by_code(warnings, "function_unsupported")
+            if w.pin == "D0" and w.pin_role == "TACH"]
+    assert len(errs) == 1
+    assert errs[0].severity == "error"
+    assert "interrupt" in errs[0].message
+
+
 def test_no_i2c_pin_used_as_i2c_bus_warns(lib):
     """D1 Mini's D0 is tagged no_i2c. If the user routes an I2C bus's SDA or
     SCL through D0, the validator should warn."""

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_fleet.py

@@ -43,6 +43,11 @@ class FakeFleetAddon:
         # ({"id", "run_id", "state", "target", "finished_at"}) to drive the
         # run-status verdict tests.
         self.queue_jobs: list[dict] = []
+        # run_id -> {"app": bytes | None, "factory": bytes | None}; tests
+        # populate this to drive the firmware-artifact passthrough tests.
+        # None means "not built" -> the addon 404s (matches the fleet-side
+        # contract that 404 = not ready or unavailable).
+        self.firmware: dict[str, dict[str, bytes | None]] = {}
 
     def transport(self) -> httpx.MockTransport:
         def handler(req: httpx.Request) -> httpx.Response:
@@ -110,6 +115,26 @@ class FakeFleetAddon:
                     "finished": bool(self.job_logs[run_id]["finished"]),
                 })
 
+            # GET /ui/api/jobs/{run_id}/firmware            -> app image
+            # GET /ui/api/jobs/{run_id}/firmware/factory    -> factory image
+            if method == "GET" and path.startswith("/ui/api/jobs/") and (
+                path.endswith("/firmware") or path.endswith("/firmware/factory")
+            ):
+                kind = "factory" if path.endswith("/factory") else "app"
+                trim = "/firmware/factory" if kind == "factory" else "/firmware"
+                run_id = path[len("/ui/api/jobs/"):-len(trim)]
+                slot = self.firmware.get(run_id)
+                if slot is None:
+                    return httpx.Response(404, json={"error": "unknown run_id"})
+                data = slot.get(kind)
+                if data is None:
+                    return httpx.Response(404, json={"error": f"no {kind} image"})
+                return httpx.Response(
+                    200,
+                    content=data,
+                    headers={"content-type": "application/octet-stream"},
+                )
+
             return httpx.Response(404, json={"error": "not found"})
 
         return httpx.MockTransport(handler)
@@ -342,8 +367,8 @@ async def test_fleet_push_strict_blocks_on_compat_warning(monkeypatch, tmp_path)
     assert strict.status_code == 422
     detail = strict.json()["detail"]
     assert detail["error"] == "strict_mode_blocked"
-    assert "compatibility issue" in detail["message"]
-    assert all(w["severity"] in ("warn", "error") for w in detail["warnings"])
+    assert "need attention" in detail["message"]
+    assert all(b["severity"] in ("warn", "error") for b in detail["blockers"])
     # The push must NOT have hit the addon when strict refuses.
     assert len(addon.compile_runs) == 0
 
@@ -488,6 +513,115 @@ async def test_fleet_job_log_unknown_run_id_returns_502(monkeypatch, tmp_path):
     assert r.status_code == 502
 
 
+# ---------------------------------------------------------------------------
+# Build-artifact passthrough (fleet -> studio -> browser WebSerial)
+# ---------------------------------------------------------------------------
+
+async def test_get_firmware_returns_app_image_bytes():
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {"app": b"FAKE-APP-IMAGE", "factory": None}
+    fc = addon.make_client()
+    data = await fc.get_firmware("run-1")
+    assert data == b"FAKE-APP-IMAGE"
+
+
+async def test_get_firmware_factory_uses_factory_subpath():
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {
+        "app": b"APP",
+        "factory": b"BOOT+PART+APP",
+    }
+    fc = addon.make_client()
+    data = await fc.get_firmware("run-1", factory=True)
+    assert data == b"BOOT+PART+APP"
+
+
+async def test_get_firmware_unknown_run_id_raises():
+    addon = FakeFleetAddon()
+    fc = addon.make_client()
+    with pytest.raises(FleetUnavailable, match="not available"):
+        await fc.get_firmware("nope")
+
+
+async def test_get_firmware_factory_missing_raises():
+    # The build produced an app image but the older ESPHome on the fleet
+    # didn't emit firmware-factory.bin -- the addon 404s factory while the
+    # app image is fine. The dialog falls back / surfaces the message.
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {"app": b"APP", "factory": None}
+    fc = addon.make_client()
+    with pytest.raises(FleetUnavailable, match="not available"):
+        await fc.get_firmware("run-1", factory=True)
+
+
+async def test_get_firmware_unconfigured_raises():
+    fc = FleetClient(base_url=None, token=None)
+    with pytest.raises(FleetUnavailable, match="missing"):
+        await fc.get_firmware("run-1")
+
+
+async def test_fleet_firmware_endpoint_unconfigured_returns_503(monkeypatch, tmp_path):
+    client = _make_client(monkeypatch, tmp_path, addon=None)
+    r = client.get("/fleet/jobs/run-1/firmware")
+    assert r.status_code == 503
+
+
+async def test_fleet_firmware_endpoint_round_trips_app_image(monkeypatch, tmp_path):
+    addon = FakeFleetAddon()
+    addon.firmware["run-7"] = {"app": b"\x01\x02APP", "factory": None}
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/run-7/firmware")
+    assert r.status_code == 200
+    assert r.headers["content-type"] == "application/octet-stream"
+    assert r.headers["content-disposition"] == 'attachment; filename="run-7.bin"'
+    assert r.content == b"\x01\x02APP"
+
+
+async def test_fleet_firmware_endpoint_round_trips_factory_image(monkeypatch, tmp_path):
+    addon = FakeFleetAddon()
+    addon.firmware["run-7"] = {"app": b"app", "factory": b"\xe9\x00\x00FACTORY"}
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/run-7/firmware?factory=true")
+    assert r.status_code == 200
+    assert r.headers["content-disposition"] == 'attachment; filename="run-7-factory.bin"'
+    assert r.content == b"\xe9\x00\x00FACTORY"
+
+
+async def test_fleet_firmware_endpoint_unknown_run_id_returns_404(monkeypatch, tmp_path):
+    # 404 means "not ready yet / not built" -- the dialog uses this to keep
+    # waiting on the compile rather than treating it as a fleet outage (which
+    # would be 502).
+    addon = FakeFleetAddon()
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/ghost/firmware")
+    assert r.status_code == 404
+
+
+async def test_fleet_firmware_endpoint_addon_unreachable_returns_502(monkeypatch, tmp_path):
+    # Addon returns a 5xx (here, simulated via missing handler -> 404 then
+    # mapped to "not available"). For a transport-level failure we'd return
+    # 502; cover that explicitly by pointing the client at a transport that
+    # always 500s.
+    def boom_handler(req: httpx.Request) -> httpx.Response:
+        if req.url.path.startswith("/ui/api/jobs/") and req.url.path.endswith(
+            "/firmware"
+        ):
+            return httpx.Response(500, json={"error": "internal"})
+        return httpx.Response(404)
+
+    transport = httpx.MockTransport(boom_handler)
+    fc = FleetClient(
+        base_url="http://broken-fleet.local", token="tok-123", transport=transport,
+    )
+
+    class _BrokenAddon:
+        def make_client(self): return fc
+
+    client = _make_client(monkeypatch, tmp_path, addon=_BrokenAddon())
+    r = client.get("/fleet/jobs/run-1/firmware")
+    assert r.status_code == 502
+
+
 # ---------------------------------------------------------------------------
 # SSE log relay
 # ---------------------------------------------------------------------------

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_mcp_auth.py

@@ -12,6 +12,9 @@ from starlette.routing import Route
 from wirestudio.mcp.auth import (
     DEFAULT_TOKEN_PATH,
     BearerTokenMiddleware,
+    TokenManagedError,
+    TokenStore,
+    load_token_store,
     resolve_token,
 )
 
@@ -34,7 +37,8 @@ def _build_app(token: str) -> Starlette:
             Route("/public", _ok),
         ]
     )
-    app.add_middleware(BearerTokenMiddleware, token=token)
+    store = TokenStore(token=token, path=Path("/unused"), env_managed=True)
+    app.add_middleware(BearerTokenMiddleware, store=store)
     return app
 
 
@@ -115,6 +119,43 @@ def test_resolve_token_generates_and_persists(monkeypatch, tmp_path: Path):
     assert resolve_token(token_path=file_path) == token
 
 
+async def test_middleware_reads_rotated_token_without_restart(tmp_path: Path):
+    # Rotation updates the live store; the already-mounted middleware must
+    # validate against the new token, not the one captured at startup.
+    file_path = tmp_path / "mcp-token"
+    file_path.write_text("original")
+    store = TokenStore(token="original", path=file_path, env_managed=False)
+
+    app = Starlette(routes=[Route("/mcp", _ok)])
+    app.add_middleware(BearerTokenMiddleware, store=store)
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        new_token = store.rotate()
+        r_old = await c.get("/mcp", headers={"Authorization": "Bearer original"})
+        r_new = await c.get("/mcp", headers={"Authorization": f"Bearer {new_token}"})
+    assert r_old.status_code == 401
+    assert r_new.status_code == 200
+
+
+def test_token_store_rotate_persists_new_token(tmp_path: Path):
+    file_path = tmp_path / "mcp-token"
+    store = load_token_store(token_path=file_path)
+    first = store.token
+    rotated = store.rotate()
+    assert rotated != first
+    assert store.token == rotated
+    assert file_path.read_text() == rotated
+    assert file_path.stat().st_mode & 0o777 == 0o600
+
+
+def test_token_store_rotate_refuses_env_managed(monkeypatch, tmp_path: Path):
+    monkeypatch.setenv("WIRESTUDIO_MCP_TOKEN", "from-env")
+    store = load_token_store(token_path=tmp_path / "mcp-token")
+    assert store.env_managed is True
+    with pytest.raises(TokenManagedError):
+        store.rotate()
+
+
 def test_default_token_path_is_under_user_config():
     # Anchored to ~/.config/wirestudio so operators know where to look
     # without grepping the source.

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_mcp_server.py

@@ -28,6 +28,7 @@ EXPECTED_TOOLS = {
     "remove_component",
     "set_param",
     "set_connection",
+    "set_strict",
     "add_bus",
     "solve_pins",
     "kicad_schematic",
@@ -122,6 +123,20 @@ async def test_add_component_persists_to_store(mcp_server):
     assert saved["components"][0]["id"] == payload["instance_id"]
 
 
+async def test_set_strict_persists_and_validate_honors_it(mcp_server):
+    server, store = mcp_server
+    design_id = _seed_design(store)
+
+    out = await server.call_tool("set_strict", {"design_id": design_id, "enabled": True})
+    assert _content_to_dict(out)["strict"] is True
+    # Persisted so every later tool call (and the browser) sees strict on.
+    assert store.load(design_id)["strict"] is True
+
+    out = await server.call_tool("set_strict", {"design_id": design_id, "enabled": False})
+    assert _content_to_dict(out)["strict"] is False
+    assert store.load(design_id)["strict"] is False
+
+
 async def test_validate_against_stored_design(mcp_server):
     server, store = mcp_server
     design_id = _seed_design(store)

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_modules.py

@@ -4,7 +4,9 @@ import pytest
 from fastapi.testclient import TestClient
 
 from wirestudio.api.app import create_app
+from wirestudio.csp.pin_solver import solve_pins
 from wirestudio.designs.seed import insert_module
+from wirestudio.generate import render_yaml
 from wirestudio.generate.ascii_gen import render_ascii
 from wirestudio.library import default_library
 from wirestudio.model import Design
@@ -36,6 +38,28 @@ def test_unknown_module_raises():
         default_library().module("nope")
 
 
+@pytest.mark.parametrize("module_id", [m.id for m in default_library().list_modules()])
+@pytest.mark.parametrize("board_id,mcu", [
+    ("esp32-devkitc-v4", "esp32"),
+    ("wemos-d1-mini", "esp8266"),
+])
+def test_module_inserts_solves_and_renders(module_id, board_id, mcu):
+    """Every bundled module must expand into real components that auto-wire,
+    solve to concrete pins with no unresolved connections, and render valid
+    ESPHome YAML -- on both an ESP32 and an ESP8266 host."""
+    lib = default_library()
+    m = lib.module(module_id)
+    d = _base_design()
+    d["board"] = {"library_id": board_id, "mcu": mcu, "framework": "arduino"}
+    d["power"]["budget_ma"] = 1000
+    _, d = insert_module(d, lib, m)
+    assert len(d["components"]) == len(m.components)
+    result = solve_pins(d, lib)
+    assert result.unresolved == [], f"{module_id}/{board_id}: {result.unresolved}"
+    yaml_out = render_yaml(Design.model_validate(result.design), lib)
+    assert yaml_out.strip()
+
+
 # --- insert_module ----------------------------------------------------------
 
 def test_insert_module_adds_all_components_with_provenance():

{wirestudio-0.17.2 → wirestudio-0.18.0}/tests/test_pin_solver.py

@@ -281,3 +281,41 @@ def test_solver_prefers_adc1_over_adc2_for_analog_in(library):
     # shift as the board YAML evolves; the invariant is "not on ADC2".
     adc1_pins = {"GPIO32", "GPIO33", "GPIO34", "GPIO35", "GPIO36", "GPIO39"}
     assert chosen in adc1_pins, f"expected ADC1 pin, got {chosen}"
+
+
+def _d1_mini_design(components: list[dict], connections: list[dict]) -> dict:
+    return {
+        "schema_version": "0.1",
+        "id": "pwm-pref",
+        "name": "PWM pref",
+        "board": {"library_id": "wemos-d1-mini", "mcu": "esp8266"},
+        "components": components,
+        "buses": [],
+        "connections": connections,
+    }
+
+
+def test_pwm_output_avoids_no_pwm_pin_and_prefers_pwm(library):
+    """A requires_pwm output (pwm_fan.PWM) must never land on ESP8266's D0
+    (tagged no_pwm -- GPIO16 has no timer PWM), and should prefer a
+    pwm-tagged pin (D5/D6/D7) over an untagged-but-usable gpio."""
+    d = _d1_mini_design(
+        [{"id": "fan", "library_id": "pwm_fan", "params": {}}],
+        [{"component_id": "fan", "pin_role": "PWM", "target": {"kind": "gpio", "pin": ""}}],
+    )
+    result = solve_pins(d, library)
+    chosen = next(a for a in result.assigned if a.pin_role == "PWM").new_target["pin"]
+    assert chosen != "D0"
+    assert chosen in ("D5", "D6", "D7")  # pwm-tagged pins on wemos-d1-mini
+
+
+def test_interrupt_input_avoids_no_interrupt_pin(library):
+    """A requires_interrupt input (pulse_counter.PULSE) must never land on
+    ESP8266's D0 (tagged no_interrupt -- GPIO16 can't attachInterrupt)."""
+    d = _d1_mini_design(
+        [{"id": "flow", "library_id": "pulse_counter", "params": {}}],
+        [{"component_id": "flow", "pin_role": "PULSE", "target": {"kind": "gpio", "pin": ""}}],
+    )
+    result = solve_pins(d, library)
+    chosen = next(a for a in result.assigned if a.pin_role == "PULSE").new_target["pin"]
+    assert chosen != "D0"

wirestudio-0.18.0/tests/test_strict.py

@@ -0,0 +1,165 @@
+"""Strict mode: the design-level toggle that makes warnings block generation.
+
+Permissive (default) surfaces electrical/CSP violations in warnings but still
+generates. Strict (`design.strict: true`, or a per-call override) refuses to
+generate while any warn/error compatibility entry or design warning remains.
+Covers the shared blocker helper plus every generation surface that honors it:
+the MCP/agent render + validate tools and the CLI.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import jsonschema
+import pytest
+
+from wirestudio.agent.tools import _run_render, _run_validate
+from wirestudio.csp.compatibility import strict_blockers
+from wirestudio.generate.__main__ import main as generate_main
+from wirestudio.library import default_library
+from wirestudio.model import Design
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+EXAMPLES_DIR = REPO_ROOT / "wirestudio" / "examples"
+
+
+@pytest.fixture
+def lib():
+    return default_library()
+
+
+def _clean() -> dict:
+    """solder-fan is warn/error-clean (it carries one info-level A0
+    voltage_limit, which must never block)."""
+    return json.loads((EXAMPLES_DIR / "solder-fan.json").read_text())
+
+
+def _dirty_compat() -> dict:
+    """Reroute the fan's PWM to D0 (no_pwm) -> a function_unsupported error."""
+    d = _clean()
+    for c in d["connections"]:
+        if c["component_id"] == "exhaust" and c["pin_role"] == "PWM":
+            c["target"] = {"kind": "gpio", "pin": "D0"}
+    return d
+
+
+# --- model / schema ---------------------------------------------------------
+
+def test_design_defaults_to_permissive():
+    d = Design.model_validate(_clean())
+    assert d.strict is False
+
+
+def test_schema_accepts_strict_flag():
+    schema = json.loads((REPO_ROOT / "wirestudio" / "schema" / "design.schema.json").read_text())
+    design = _clean()
+    design["strict"] = True
+    jsonschema.validate(design, schema)  # must not raise
+
+
+# --- strict_blockers helper -------------------------------------------------
+
+def test_strict_blockers_empty_for_clean_design(lib):
+    assert strict_blockers(_clean(), lib) == []
+
+
+def test_strict_blockers_flags_compat_warn_error(lib):
+    blockers = strict_blockers(_dirty_compat(), lib)
+    assert len(blockers) == 1
+    assert blockers[0].kind == "compatibility"
+    assert blockers[0].severity == "error"
+    assert blockers[0].code == "function_unsupported"
+
+
+def test_strict_blockers_includes_design_warnings(lib):
+    d = _clean()
+    d["warnings"] = [
+        {"level": "error", "code": "demo", "text": "electrical violation"},
+        {"level": "info", "code": "note", "text": "just fyi"},
+    ]
+    blockers = strict_blockers(d, lib)
+    # error-level design warning blocks; info-level does not.
+    kinds = [(b.kind, b.severity, b.code) for b in blockers]
+    assert ("design", "error", "demo") in kinds
+    assert all(b.severity != "info" for b in blockers)
+
+
+def test_strict_blockers_ignores_info_severity(lib):
+    """The solder-fan pot on A0 emits an info voltage_limit -- never a blocker."""
+    from wirestudio.csp.compatibility import check_pin_compatibility
+    compat = check_pin_compatibility(_clean(), lib)
+    assert any(w.severity == "info" for w in compat)  # the A0 ceiling note
+    assert strict_blockers(_clean(), lib) == []
+
+
+# --- MCP/agent render tool --------------------------------------------------
+
+def test_render_permissive_generates_despite_blockers(lib):
+    d = _dirty_compat()
+    d["strict"] = False
+    assert _run_render(d, lib)["ok"] is True
+
+
+def test_render_strict_blocks_on_dirty_design(lib):
+    d = _dirty_compat()
+    d["strict"] = True
+    r = _run_render(d, lib)
+    assert r["ok"] is False
+    assert r["strict_blocked"] is True
+    assert len(r["blockers"]) == 1
+
+
+def test_render_strict_passes_clean_design(lib):
+    d = _clean()
+    d["strict"] = True
+    r = _run_render(d, lib)
+    assert r["ok"] is True
+    assert r["yaml"].startswith("esphome:")
+
+
+# --- MCP/agent validate tool ------------------------------------------------
+
+def test_validate_permissive_ok_but_surfaces_blockers(lib):
+    d = _dirty_compat()
+    d["strict"] = False
+    r = _run_validate(d, lib)
+    assert r["ok"] is True          # permissive validate stays ok
+    assert r["strict"] is False
+    assert len(r["blockers"]) == 1  # but the blocker is still shown
+
+
+def test_validate_strict_fails_on_blockers(lib):
+    d = _dirty_compat()
+    d["strict"] = True
+    r = _run_validate(d, lib)
+    assert r["ok"] is False
+    assert r["strict"] is True
+    assert len(r["blockers"]) == 1
+
+
+# --- CLI --------------------------------------------------------------------
+
+def _write(tmp_path: Path, design: dict) -> Path:
+    p = tmp_path / "design.json"
+    p.write_text(json.dumps(design))
+    return p
+
+
+def test_cli_strict_design_blocks(tmp_path):
+    d = _dirty_compat()
+    d["strict"] = True
+    assert generate_main([str(_write(tmp_path, d))]) == 1
+
+
+def test_cli_strict_flag_overrides_permissive_design(tmp_path):
+    d = _dirty_compat()
+    d["strict"] = False
+    assert generate_main([str(_write(tmp_path, d)), "--strict"]) == 1
+
+
+def test_cli_clean_strict_design_generates(tmp_path, capsys):
+    d = _clean()
+    d["strict"] = True
+    assert generate_main([str(_write(tmp_path, d))]) == 0
+    assert "esphome:" in capsys.readouterr().out

{wirestudio-0.17.2 → wirestudio-0.18.0}/wirestudio/__init__.py

@@ -1,3 +1,3 @@
 """wirestudio: design.json -> ESPHome YAML + ASCII diagram."""
 
-__version__ = "0.17.2"
+__version__ = "0.18.0"