agentic-hil 0.2.0__py3-none-any.whl

agentic_hil/__init__.py

@@ -0,0 +1,7 @@
+"""Agentic HIL compatibility package.
+
+The implementation still lives under ``hardci`` during the 0.x rename window.
+"""
+
+from hardci import *  # noqa: F403
+from hardci import __version__ as __version__

agentic_hil/__main__.py

@@ -0,0 +1,4 @@
+from agentic_hil.cli import entrypoint
+
+if __name__ == "__main__":
+    raise SystemExit(entrypoint())

agentic_hil/cli.py

@@ -0,0 +1,5 @@
+"""Agentic HIL CLI entry point."""
+
+from hardci.cli import entrypoint
+
+__all__ = ["entrypoint"]

agentic_hil/pytest_plugin.py

@@ -0,0 +1,8 @@
+"""Agentic HIL pytest plugin entry point."""
+
+from hardci.pytest_plugin import _hardci_service as _hardci_service
+from hardci.pytest_plugin import agentic_hil as agentic_hil
+from hardci.pytest_plugin import hardci_config as hardci_config
+from hardci.pytest_plugin import pytest_addoption as pytest_addoption
+from hardci.pytest_plugin import resolve_plugin_config_path as resolve_plugin_config_path
+from hardci.pytest_plugin import rootdir_anchored as rootdir_anchored

agentic_hil-0.2.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: agentic-hil
+Version: 0.2.0
+Summary: Agentic hardware-in-the-loop tools for AI-assisted embedded firmware loops
+Author-email: Hannes Pauli <mail@hannes-pauli.de>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/agentic-hil/agentic-hil
+Project-URL: Repository, https://github.com/agentic-hil/agentic-hil.git
+Project-URL: Issues, https://github.com/agentic-hil/agentic-hil/issues
+Keywords: mcp,model-context-protocol,embedded,hardware-in-the-loop,openocd,firmware,serial,stlink,debugger,agentic-hil,agentic,hardci,stm32
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.22
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: pyserial>=3.5
+Provides-Extra: can
+Requires-Dist: python-can>=4.4; extra == "can"
+Provides-Extra: pyocd
+Requires-Dist: pyocd>=0.36; extra == "pyocd"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# Agentic HIL
+
+**Your AI agent can develop firmware on its own — because Agentic HIL closes the loop with real hardware.**
+
+```
++--> build --> flash --> stimulate --> observe --+
+|                                                |
++<-------------- diagnose & fix -----------------+
+
+  your agent, unattended -- you review the pull request
+```
+
+Agentic HIL is a Python package that exposes bounded MCP tools for probing, flashing, resetting, artifact validation, serial and CAN stimulus/feedback, test adapters, reports, and logs — without giving an agent arbitrary host or debugger access. A project-local policy file (`.hardci/config.yaml`) defines exactly which devices, actions, paths, and limits are allowed. That policy gate is what makes unattended hardware access workable in the first place.
+
+HardCI adapters are the reference hardware for Agentic HIL: physical pytest fixtures for sensor simulation, loads, and fault injection.
+
+## Why
+
+A green build is not enough in embedded development: firmware has to behave correctly on the real board. Classic tools automate single steps — flash here, read a log there — but the moment real hardware has to respond, a human is back in the loop. Handing an agent a raw debugger shell or direct serial access instead is neither safe nor reproducible. Agentic HIL closes the gap with a small, auditable gate:
+
+```
+AI agent / CI  ──MCP (stdio)──▶  Agentic HIL  ──policy check──▶  OpenOCD / pyOCD / STM32CubeProgrammer
+                                    │                        serial ports (pyserial)
+                                    │                        CAN (PEAK / SocketCAN / bridge)
+                                    ▼
+                       structured results, reports, logs
+```
+
+Every hardware action is validated against the project policy, executed with timeouts, logged to `.hardci/logs/`, and answered with a structured JSON result (`ok`, `error_type`, `summary`, `likely_causes`, `report_path`, `log_path`) that an agent can act on.
+
+## Install
+
+The easiest path: tell your AI agent
+
+> Install Agentic HIL and set it up for this project.
+
+Agents follow [AI_AGENT_QUICKSTART.md](AI_AGENT_QUICKSTART.md) — everything installs user-local, **no admin rights required, ever**.
+
+By hand, without installing anything (no `PATH` changes; needs [uv](https://docs.astral.sh/uv/) or pipx):
+
+```bash
+uvx agentic-hil --version
+uvx --from git+https://github.com/agentic-hil/agentic-hil agentic-hil --version
+```
+
+Persistent user-local install (recommended for the MCP server entry):
+
+```bash
+uv tool install agentic-hil      # or: pipx install agentic-hil
+agentic-hil init
+agentic-hil doctor
+agentic-hil mcp-config --output .mcp.json
+```
+
+For direct PEAK/SocketCAN access install the CAN extra: `uv tool install 'agentic-hil[can]'`. See [TROUBLESHOOTING.md](TROUBLESHOOTING.md) when something does not start.
+
+## MCP Entry
+
+Project-local `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "agentic-hil": {
+      "command": "agentic-hil",
+      "args": ["mcp-stdio", "--config", ".hardci/config.yaml"]
+    }
+  }
+}
+```
+
+## Configuration
+
+`agentic-hil init` writes a starter `.hardci/config.yaml`. The file is the policy — it names the target, the debugger backend, allowed artifact roots, named serial ports and CAN buses, and per-action permissions:
+
+```yaml
+target:
+  name: "sensor-board"
+  controller: "stm32f4"
+
+debugger:
+  type: "openocd"            # or "pyocd" (most Cortex-M targets), or "stlink" (STM32CubeProgrammer CLI)
+  interface_cfg: "interface/stlink.cfg"
+  target_cfg: "target/stm32f4x.cfg"
+  timeout_s: 60
+
+artifacts:
+  allowed_roots: ["build"]   # firmware may only be flashed from here
+  allowed_extensions: [".elf", ".hex", ".bin"]
+
+com_ports:
+  dut_uart:
+    device: "/dev/ttyACM0"
+    baudrate: 115200
+
+can_buses:
+  dut_can:
+    adapter: "socketcan"     # or "peak", or "process" for a custom bridge
+    channel: "can0"
+    bitrate: 500000
+
+adapters:
+  ntc_sim:                   # sensor/actuator/fault-simulation bridge
+    executable: "examples/adapters/sim_ntc_adapter.py"
+    channels: ["temperature", "resistance"]
+    faults: ["open", "short_to_gnd", "short_to_vcc"]
+
+permissions:
+  allow_flash: true
+  allow_com_write: true
+  allow_can_write: true
+  allow_adapter_write: true
+  allow_raw_debugger_commands: false
+  allow_mass_erase: false
+```
+
+Export the full JSON schema with `agentic-hil schema --output agentic-hil-config.schema.json`.
+
+## MCP Tools
+
+| Group | Tools | Notes |
+|-------|-------|-------|
+| Debugger | `hardci_debugger_info`, `hardci_probe_target`, `hardci_reset_target` | OpenOCD, pyOCD, or STM32CubeProgrammer CLI |
+| Firmware | `hardci_flash_firmware`, `hardci_artifact_upload` | artifacts are validated (path, extension, format, SHA-256) before flashing; post-flash reset requires `reset_after_flash: true` |
+| Serial | `hardci_com_ports_list`, `hardci_com_session_start`, `hardci_com_session_stop`, `hardci_com_write`, `hardci_com_read` | named ports only, buffered background reader |
+| CAN | `hardci_can_buses_list`, `hardci_can_session_start`, `hardci_can_session_stop`, `hardci_can_send`, `hardci_can_read` | PEAK, SocketCAN, or a process bridge |
+| Test adapters | `hardci_adapters_list`, `hardci_adapter_session_start`, `hardci_adapter_session_stop`, `hardci_adapter_set_value`, `hardci_adapter_inject_fault`, `hardci_adapter_clear_fault`, `hardci_adapter_measure` | sensor/actuator/fault simulation via the [adapter bridge protocol](examples/adapters/README.md) |
+| Diagnostics | `hardci_get_last_report`, `hardci_classify_last_error` | structured error classification with likely causes |
+| Debug sessions | `hardci_debug_*` (start/stop/status, breakpoints, continue/halt, symbol info, memory dump) | typed GDB/MI sessions via the OpenOCD backend's gdbserver; unexpected breakpoints and target exceptions are returned as structured stop reasons; symbol allowlist and dump-size limits come from the `debug:` policy section |
+
+A typical loop: build firmware → `hardci_flash_firmware` with `reset_after_flash: true` when a fresh boot is required → `hardci_com_session_start` → stimulate via `hardci_com_write`/`hardci_can_send`/`hardci_adapter_set_value` → assert on `hardci_com_read`/`hardci_can_read`/`hardci_adapter_measure` → on failure, `hardci_classify_last_error`.
+
+## Test Adapters
+
+Real-world firmware bugs show up under electrical conditions that standard lab tools cannot reproduce on demand: an open or shorted sensor, a drifting NTC, a missing load, a bouncing contact. The `adapters:` section connects HardCI to test adapters that simulate exactly these states — physical adapter hardware or pure-software simulators, both speaking the same [JSON bridge protocol](examples/adapters/README.md).
+
+Example diagnosis loop with the bundled NTC simulator (`examples/adapters/sim_ntc_adapter.py`): flash the firmware, set the simulated sensor to 25 °C and assert nominal behavior, inject an `open` fault and assert the firmware reports the sensor failure, clear the fault and assert recovery — every step automated, reproducible, and policy-gated.
+
+## Safety Model
+
+- The agent never gets a shell, a raw debugger, or a device path — only the named, configured resources.
+- Firmware artifacts must live under `artifacts.allowed_roots`, match an allowed extension, pass format plausibility checks, and are hashed before flashing. Path traversal is rejected.
+- Permission switches gate high-risk action classes; `permission_denied` results are authoritative and agents are instructed to stop (see [AGENTS.md](AGENTS.md)).
+- Deliberate interlock: flashing is refused while `allow_raw_debugger_commands` or `allow_mass_erase` is enabled — validated flashing and unrestricted debugger access are mutually exclusive policies.
+- Serial/CAN writes are size-capped (`max_write_bytes`, `max_frame_data_bytes`); reads are buffer-capped. Debugger calls run with timeouts and TCP servers disabled (OpenOCD `gdb_port`/`tcl_port`/`telnet_port disabled`); only a typed debug session opens a `gdb_port`, bound to `localhost` on an ephemeral port for exactly that session, and it is torn down with the session.
+- Test adapter channels and fault names are explicit allowlists — HardCI rejects anything not named in the config before it reaches the adapter bridge.
+- All actions log to `.hardci/logs/` and write a structured report to `.hardci/reports/`.
+
+## pytest Plugin
+
+Installing `agentic-hil` registers a pytest plugin, so CI regression suites can drive the same policy-gated tools without an MCP client:
+
+```python
+def test_open_sensor_diagnosis(agentic_hil):
+    started = agentic_hil.call("hardci_adapter_session_start", {"adapter_id": "ntc_sim"})
+    assert started["ok"] is True
+    injected = agentic_hil.call("hardci_adapter_inject_fault", {"adapter_id": "ntc_sim", "fault": "open"})
+    assert injected["ok"] is True
+    # ...assert the firmware's reaction via hardci_com_read...
+```
+
+The `agentic_hil` fixture loads `.hardci/config.yaml` relative to the pytest rootdir (override with `--hardci-config` or the `hardci_config` ini option). Tests are skipped when no configuration file exists, but an existing invalid configuration fails loudly — a config typo must not silently disable the hardware suite in CI. Adapter, COM, and CAN sessions opened during a test are stopped afterwards so stimulus state cannot leak between tests. See [examples/pytest/](examples/pytest/) for a full diagnosis-loop example, and [examples/nucleo-f446re_demo/](examples/nucleo-f446re_demo/) for the complete loop on real hardware: a bare-metal STM32 firmware that is built, flashed, reset, and asserted on via its UART boot banner.
+
+## Common Commands
+
+```text
+agentic-hil init
+agentic-hil doctor
+agentic-hil com-ports
+agentic-hil mcp-config --output .mcp.json
+agentic-hil mcp-stdio --config .hardci/config.yaml
+agentic-hil com-stdio --config .hardci/config.yaml --port dut_uart
+agentic-hil schema --output agentic-hil-config.schema.json
+agentic-hil skill-install --agent opencode
+```
+
+## Platform Support
+
+Linux, macOS, and Windows (CI-tested on Python 3.10–3.13). Debugger backends: OpenOCD, pyOCD (`agentic-hil[pyocd]` — covers most ARM Cortex-M targets via CMSIS packs and CMSIS-DAP/ST-Link/J-Link probes, set `debugger.target_type`), and STM32CubeProgrammer CLI (auto-discovered on Windows). Direct CAN requires `agentic-hil[can]` (python-can); any other adapter can be attached through the `process` bridge protocol.
+
+## Development
+
+```bash
+python -m pip install -e '.[dev]'
+ruff check src tests
+pytest
+python -m build
+twine check dist/*
+```
+
+The package is configured for PyPI publishing through GitHub trusted publishing in `.github/workflows/workflow.yml`.
+
+## Security
+
+Policy bypasses are treated as vulnerabilities — see [SECURITY.md](SECURITY.md).
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE).

agentic_hil-0.2.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+agentic_hil/__init__.py,sha256=tVGaKfjMV-dVozwfFZo9OAkKNZGwOqq7zBsY4w_D_aA,203
+agentic_hil/__main__.py,sha256=Zp6cL6o7kRhrJ1lOVM9KJT7ClwPjpQsRLcN1kCNNsEk,102
+agentic_hil/cli.py,sha256=mmlR8d0YeVG0NeQCI8Q6UMMFcSIyAsOiFmfrq3rNj4A,96
+agentic_hil/pytest_plugin.py,sha256=Eb5xU93DbD46zPVRDgbVKfklnQgkVgJHOSpZQxVS3zE,468
+agentic_hil-0.2.0.dist-info/licenses/LICENSE,sha256=JLxvyDV4hBilJy5TBoLKvaixXwQtR27OrBTfI2QqnFQ,11342
+hardci/__init__.py,sha256=YI1ZQVMC-Z9KzuCTK79i8cFAO-wIK7EQpAfLR2Le-t0,1092
+hardci/__main__.py,sha256=3HMvTHnVrtQkdx4GrDG1eTpq7qgv130tWA1ConRmjkk,97
+hardci/adapters.py,sha256=oJ841O8ti7dypwIerGwnSiDKC4VFyo25hWWh0E52q3U,15711
+hardci/artifacts.py,sha256=6BIBkg2WEvnch00E-ZK6AVP1U4NRNoudUlD8F70q8Ig,14699
+hardci/bridge.py,sha256=nblksssxqQZMT7Ub2xd6YN0jfxjnhvLcGhm8gNlvkpM,4247
+hardci/can.py,sha256=bh_X875G2KqUyz2zUos6ZGCkOCJnSHBApZe-XG7YCeI,21225
+hardci/cli.py,sha256=XgGvdIpZtcz07la4OBIVK2B0n-WSOUSDeLJzedNdi_s,18469
+hardci/comports.py,sha256=ZjPLIvvTefYRDC1Up2C9b9wEuEvfhtRxY3HEpcixO1k,19136
+hardci/comstdio.py,sha256=U6kCmMpRNq5M3qiFx3yGg8VHD6LI_Musdx_DygtmImg,3320
+hardci/config.py,sha256=Dcgsiy_CdybThzT4DAqbFRus1YZH5FK-PP9jrIV-hzY,14161
+hardci/debugger.py,sha256=tXjwEZhRHgyi9b94nWNu-VMoMCippxCfTviX7eEOAz4,2056
+hardci/gdbmi.py,sha256=l4duKywRJrX6_zAU9wphQT3Qj4_9lREb_Ev3Q-3mtRQ,11133
+hardci/mcp.py,sha256=FRYimOP1T3Hm1Zja4q-RmxW5EKRp2jsRATFUdbjENTM,17453
+hardci/pytest_plugin.py,sha256=TToMM3quJIXsaxgVlHeqVfb8Pb7e31XbK2G7WPi09bo,3788
+hardci/report.py,sha256=k5tAFsN5fWtlHGc5dtMDzKGHFo0tDXWC66fWaBIameg,2423
+hardci/stdio.py,sha256=TmSXb_6v0lSTVadhD90RXSbiD_6KEo-8AMh_gJIeuw4,2633
+hardci/tools.py,sha256=TpXSOwMzkzdlo8UX7e_9cXjPl3ycgHqJfzSll98kGaU,11211
+hardci/types.py,sha256=_YKpKcZsIHZFYh-zin_wD7BtuhlERL49i1kdQaYQrhM,2687
+hardci/backends/__init__.py,sha256=PuIvfY8o7jggM3ujdZUB1EscsYeO16F_dHgebjTP1dA,147
+hardci/backends/common.py,sha256=Uc7NUg9h8MUf89VSZdtV_z1agMuOYoMx17yJAjmByf8,4022
+hardci/backends/gdbdebug.py,sha256=gsILdsD3CkPL7OjPOo3jljjzZhSdfnYHKzbkKixUzRM,39450
+hardci/backends/openocd.py,sha256=AX1n2v4ob-0SjNgDSxnFX9Pr3Ngc5nopYYVsZ-8I2AU,19524
+hardci/backends/pyocd.py,sha256=J4gb7I5RWWdmpoTNUzo0WelUMnWfPZhkWrFidpY1xjE,17762
+hardci/backends/stlink.py,sha256=PhDZBYz8JBgLTSvvvUImpcnXalTWLlavr7F_nK5aWxA,18906
+hardci/schemas/config.schema.json,sha256=oroCq0ZkoQ1X0oFsyjxsbI8529w8yARKWp15AN1fZY4,7484
+hardci/skills/hardci-config-setup/SKILL.md,sha256=OhRQKxsk1oTZtBi8yky7xWUuu1ZXcaM-jP0GTIQv3F0,660
+hardci/templates/mcp.json,sha256=jFrp89pGY95DTF64wOVoCr0_U4VLLOQRv-OTcjCZ92k,138
+agentic_hil-0.2.0.dist-info/METADATA,sha256=DHSpjsBo5lhi6B2avGNp6IWXJU-Jpq_TpaFkXTZOyeU,12442
+agentic_hil-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agentic_hil-0.2.0.dist-info/entry_points.txt,sha256=cWjBjg-DuNFY8TowbKq2_LqNjEmhGC2MioB_19sSPOg,111
+agentic_hil-0.2.0.dist-info/top_level.txt,sha256=l7bCIVIf7dlAXIpRNtUzjaze7jaOLbsgWl63rLNaQ_s,19
+agentic_hil-0.2.0.dist-info/RECORD,,

agentic_hil-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agentic_hil-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+agentic-hil = agentic_hil.cli:entrypoint
+
+[pytest11]
+agentic_hil = agentic_hil.pytest_plugin

agentic_hil-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Hannes Pauli
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

agentic_hil-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+agentic_hil
+hardci

hardci/__init__.py

@@ -0,0 +1,30 @@
+"""HardCI - safe local hardware-in-the-loop bridge for AI agents."""
+
+from typing import TYPE_CHECKING, Any
+
+__version__ = "0.2.0"
+
+if TYPE_CHECKING:
+    from hardci.artifacts import ArtifactManager
+    from hardci.config import ConfigError, load_config
+    from hardci.tools import HardCIToolService
+
+__all__ = ["ArtifactManager", "ConfigError", "HardCIToolService", "load_config"]
+
+# Lazy re-exports (PEP 562): the pytest11 entry point imports this package on
+# every pytest startup, so the package root must not pull in yaml/jsonschema.
+_LAZY_EXPORTS = {
+    "ArtifactManager": ("hardci.artifacts", "ArtifactManager"),
+    "ConfigError": ("hardci.config", "ConfigError"),
+    "HardCIToolService": ("hardci.tools", "HardCIToolService"),
+    "load_config": ("hardci.config", "load_config"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _LAZY_EXPORTS:
+        from importlib import import_module
+
+        module_name, attribute = _LAZY_EXPORTS[name]
+        return getattr(import_module(module_name), attribute)
+    raise AttributeError(f"module 'hardci' has no attribute {name!r}")

hardci/__main__.py

@@ -0,0 +1,4 @@
+from hardci.cli import entrypoint
+
+if __name__ == "__main__":
+    raise SystemExit(entrypoint())