akcli-kicad 0.15.0__tar.gz

akcli_kicad-0.15.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Li, ching yu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

akcli_kicad-0.15.0/PKG-INFO

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: akcli-kicad
+Version: 0.15.0
+Summary: AI-native schematic design agent, purpose-built for KiCad: draw and edit .kicad_sch from JSON op-lists with net-diff safety rails, run ERC/design/intent checks, simulate on bundled ngspice, source parts, and import Altium .SchDoc/.PcbDoc read-only into the KiCad flow.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tipoLi5890/akcli
+Project-URL: Repository, https://github.com/tipoLi5890/akcli.git
+Project-URL: Changelog, https://github.com/tipoLi5890/akcli/blob/main/CHANGELOG.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: jsonschema>=4; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+<img src="docs/assets/hero.png" alt="akcli — KiCad-native design CLI for humans and AI agents" width="820">
+
+<p><strong>AI-native schematic design, purpose-built for KiCad — a zero-dependency (pure-stdlib Python) CLI.</strong></p>
+
+<p>
+  <a href="https://github.com/tipoLi5890/akcli/actions/workflows/ci.yml"><img src="https://github.com/tipoLi5890/akcli/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero runtime dependencies">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT">
+</p>
+
+<p><strong>English</strong> · <a href=".github/README.zh-Hant.md">繁體中文</a> · <a href=".github/README.zh-Hans.md">简体中文</a></p>
+
+</div>
+
+---
+
+**akcli** is a zero-dependency Python CLI for **AI-native schematic design on KiCad** — a scriptable
+design loop that you or **any AI agent** can drive end to end (bundled plugins/skills ship for Claude
+Code, Codex, and OpenCode, but a shell is all it takes). Author a `.kicad_sch` from a JSON op-list,
+run ERC / design-review / BOM / schematic ↔ PCB checks, simulate on ngspice, and source real
+JLCPCB/LCSC parts. Existing Altium `.SchDoc` / `.SchLib` / `.PcbDoc` / `.PcbLib` designs import
+read-only — an on-ramp into the KiCad flow, which is where all development happens.
+
+## Install
+
+Zero runtime dependencies; needs **Python ≥ 3.11** (for stdlib `tomllib`). The distribution is
+`akcli-kicad`; the command is `akcli`:
+
+```bash
+pipx install akcli-kicad        # or: pip install akcli-kicad
+akcli --version
+
+# or run straight from a clone, no install
+git clone https://github.com/tipoLi5890/akcli
+./akcli/bin/akcli --help        # wrapper auto-selects a Python ≥ 3.11
+```
+
+Claude Code plugin (marketplace name `akcli`):
+
+```text
+/plugin marketplace add tipoLi5890/akcli
+/plugin install akcli@akcli
+```
+
+Codex plugin (same name `akcli`):
+
+```bash
+codex plugin marketplace add tipoLi5890/akcli   # or `add ./` from a clone
+codex plugin install akcli@akcli
+```
+
+Full details, per-agent setup, and troubleshooting in [INSTALL.md](INSTALL.md).
+
+## Quickstart
+
+Read a design, check it, and draw into it — straight from the shell:
+
+```bash
+akcli read  board.kicad_sch --summary                            # normalized JSON, context-budgeted
+akcli check board.kicad_sch                                      # ERC-lite + power + BOM + connectivity
+akcli draw  board.kicad_sch --ops ops.json                       # dry-run: shows changes + net diff
+akcli draw  board.kicad_sch --ops ops.json --apply --strict-nets # atomic write + verify + backup
+akcli undo  board.kicad_sch                                      # revert the last write
+```
+
+Every write is a dry run by default; `--apply` goes through an atomic snapshot → temp → verify →
+replace pipeline with a pure-Python connectivity gate, and `akcli undo` reverts from a rotated backup
+stack. Altium files are read-only offline.
+
+## What it does
+
+One normalized model behind every command, so each check, diff, and report works on a KiCad
+`.kicad_sch` — and just the same on an imported Altium `.SchDoc`:
+
+| Command | What it does |
+|---|---|
+| `read` · `net` · `component` · `pins` | Parse KiCad or Altium into one normalized JSON model; query nets, components, and pin coordinates. |
+| `new` · `plan` · `draw` · `ops` · `arrange` | Author a `.kicad_sch` from a versioned **22-op + 10-macro** JSON op-list, behind a net-diff safety gate and one-command `undo`. |
+| `check` · `verify` · `diff` · `pinmap` | ERC-lite + power + BOM + intent / contract checks, schematic ↔ PCB equivalence, net-membership diff, MCU pin → net map. |
+| `review` | Advisory, confidence-graded design review across six detector families (signal / validation / pcb / emc / domain / gerber). |
+| `sim` | Render to a SPICE deck and assert on KiCad's bundled ngspice; sweep corners; fit diode models from datasheet points. |
+| `jlc` | Search JLCPCB/LCSC (stock, price, Basic/Extended), convert a part into a KiCad library in-process, fetch datasheets. |
+| `calc` | **60** standards-cited offline calculators (E-series, IPC-2221, impedance, I²C pull-ups, buck/boost…), each citing its reference. |
+| `library` · `fab` · `release` | Library-workspace audit/repair, versioned fab-profile checks, and a release preflight that writes a traceable manifest. |
+| `render` · `doc` · `view` | Pure-stdlib SVG render, a Markdown pinout book, and a localhost `/calc` + `/live` dashboard. |
+
+Two headline examples — a design review and a part search:
+
+```bash
+akcli review analyze board.kicad_sch --profile deep --pcb board.kicad_pcb   # advisory findings + evidence
+akcli jlc search "0.1uF 0402 X7R"                                           # JLCPCB/LCSC catalog (needs network)
+```
+
+## Use with AI agents
+
+`akcli` is a plain CLI, so any shell-capable agent can drive it. Commands emit structured JSON with
+`--json` (carrying a `schema_version`), each op-list carries a `protocol_version`, and `akcli
+capabilities` self-describes the entire CLI surface in one JSON document — and every error code ships a
+machine-readable `remediation` hint.
+
+- **Claude Code** — install the bundled plugin for five `/akcli:circuit-*` commands (review, pinmap,
+  draw, diff, parts) plus twelve skills spanning design, review, authoring, Altium interop, parts
+  sourcing, calculators, and release gating.
+- **Codex** — install the bundled plugin, or drop the loose skill folders into `.agents/skills/` for
+  auto-discovery. See [docs/codex-plugin.md](docs/codex-plugin.md).
+- **OpenCode** — auto-discovers the bundled skills; see
+  [INSTALL.md](INSTALL.md#use-with-ai-coding-agents) for the exact commands.
+
+## Why akcli
+
+- **Zero runtime dependencies.** Standard library only (including `tomllib`) — easy to vendor, sandbox,
+  or run in CI.
+- **Purpose-built for KiCad.** An iterative KiCad S-expression parser and byte-stable writer at the
+  core; Altium designs come in read-only through pure-stdlib OLE2/CFBF record decoding, straight into
+  the same KiCad flow. No compiled extensions.
+- **Byte-identical re-apply.** Deterministic UUIDv5 + replace-in-place makes every edit idempotent —
+  re-running an op-list produces the same bytes.
+- **Connectivity is the only hard write gate.** Every `plan`/`draw` prints a before/after net diff
+  (splits, merges, renames — matched by pin membership, never by name); `--strict-nets` refuses a
+  write that splits or merges a named net.
+- **Net inference you can trust.** A rebuilt net layer handles global same-name merges, junctions,
+  T-junctions, and No-ERC markers — fixing the classic "same-named nets split into single-pin nets" bug.
+
+## Optional external tools
+
+"Zero-dependency" means zero Python **package** dependencies: `pip install` pulls in nothing, and the
+entire core loop (read / plan / draw / check / diff / calc / render) runs on the standard library
+alone. A few features can use something outside Python — always detected at runtime, never required
+by the core loop:
+
+| Feature | Uses | If missing |
+|---|---|---|
+| Advisory ERC second opinion, `view live` SVG | `kicad-cli` (local executable) | Skipped silently — non-fatal, results stay advisory. |
+| `sim` execution (`--deck-only` needs nothing) | libngspice (bundled with KiCad) | `sim` exits with `NGSPICE_MISSING`; everything else unaffected. |
+| `jlc` part search / datasheet fetch | Network | The **only** networked command family; all others are fully offline. |
+
+`akcli doctor` probes each of these and prints per-OS remediation.
+
+## Documentation
+
+| Doc | Covers |
+|---|---|
+| [SPEC.md](docs/SPEC.md) | Data model, config tables, JSON schemas |
+| [cli-reference.md](docs/cli-reference.md) | Every command and flag |
+| [op-list-authoring.md](docs/op-list-authoring.md) | Op-list authoring bible (ops, macros, groups) |
+| [design-integrity.md](docs/design-integrity.md) | Contracts, fab profiles, release preflight |
+| [review-rules.md](docs/review-rules.md) | Design-review rule catalogue |
+| [sim.md](docs/sim.md) | Simulation reference |
+| [ROADMAP.md](ROADMAP.md) | Roadmap to v1.0 with exit criteria |
+
+## Roadmap
+
+**Shipped (v0.15.0):** KiCad write/draw from a 22-op + 10-macro vocabulary (hierarchical `add_sheet`,
+net-diff safety rails, `new` / multi-level `undo`), net-preserving `arrange --groups` re-layout, the
+advisory `akcli review` engine (six detector families, now including power-entry protection, plus a
+datasheet facts store, `propose` / `tree` / `validate`), ERC / power / BOM / diff / pinmap / intent /
+contract checks with waivers and SARIF, schematic ↔ PCB `verify`, a project `library` workspace,
+versioned `fab` profiles, a `release preflight` gate, `akcli sim` on KiCad's bundled ngspice,
+JLCPCB/LCSC sourcing with datasheet fetch, 60 standards-cited calculators, pure-stdlib SVG rendering,
+and version-tolerant Altium/KiCad readers.
+
+**Ahead (→ v1.0):** the contract-freeze audit. The first PyPI release (`pip install akcli-kicad`) shipped in 0.15.0.
+*Deferred by decision:* a GitHub Action gating schematic PRs, the `view` waveform panel, and a native
+MCP server (the plain CLI serves agents today). Full plan with exit criteria in
+[ROADMAP.md](ROADMAP.md).
+
+## Acknowledgments
+
+`akcli jlc` builds on (full attribution in [ACKNOWLEDGMENTS.md](ACKNOWLEDGMENTS.md) and
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)):
+
+- **JLC2KiCadLib** by **TousstNicolas** (MIT) — LCSC → KiCad conversion core, vendored.
+- **jlcsearch** (tscircuit, MIT) and **jlcparts** (MIT) — part-search backend.
+- **EasyEDA / LCSC / JLCPCB** — component data source.
+
+## Contact
+
+Questions, bugs, or feature requests: please
+[open a GitHub issue](https://github.com/tipoLi5890/akcli/issues).
+
+## License
+
+MIT © 2026 Li, ching yu. See [LICENSE](LICENSE); third-party attribution in
+[ACKNOWLEDGMENTS.md](ACKNOWLEDGMENTS.md) and [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md), and the
+security model in [SECURITY.md](SECURITY.md).

akcli_kicad-0.15.0/README.md

@@ -0,0 +1,188 @@
+<div align="center">
+
+<img src="docs/assets/hero.png" alt="akcli — KiCad-native design CLI for humans and AI agents" width="820">
+
+<p><strong>AI-native schematic design, purpose-built for KiCad — a zero-dependency (pure-stdlib Python) CLI.</strong></p>
+
+<p>
+  <a href="https://github.com/tipoLi5890/akcli/actions/workflows/ci.yml"><img src="https://github.com/tipoLi5890/akcli/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero runtime dependencies">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT">
+</p>
+
+<p><strong>English</strong> · <a href=".github/README.zh-Hant.md">繁體中文</a> · <a href=".github/README.zh-Hans.md">简体中文</a></p>
+
+</div>
+
+---
+
+**akcli** is a zero-dependency Python CLI for **AI-native schematic design on KiCad** — a scriptable
+design loop that you or **any AI agent** can drive end to end (bundled plugins/skills ship for Claude
+Code, Codex, and OpenCode, but a shell is all it takes). Author a `.kicad_sch` from a JSON op-list,
+run ERC / design-review / BOM / schematic ↔ PCB checks, simulate on ngspice, and source real
+JLCPCB/LCSC parts. Existing Altium `.SchDoc` / `.SchLib` / `.PcbDoc` / `.PcbLib` designs import
+read-only — an on-ramp into the KiCad flow, which is where all development happens.
+
+## Install
+
+Zero runtime dependencies; needs **Python ≥ 3.11** (for stdlib `tomllib`). The distribution is
+`akcli-kicad`; the command is `akcli`:
+
+```bash
+pipx install akcli-kicad        # or: pip install akcli-kicad
+akcli --version
+
+# or run straight from a clone, no install
+git clone https://github.com/tipoLi5890/akcli
+./akcli/bin/akcli --help        # wrapper auto-selects a Python ≥ 3.11
+```
+
+Claude Code plugin (marketplace name `akcli`):
+
+```text
+/plugin marketplace add tipoLi5890/akcli
+/plugin install akcli@akcli
+```
+
+Codex plugin (same name `akcli`):
+
+```bash
+codex plugin marketplace add tipoLi5890/akcli   # or `add ./` from a clone
+codex plugin install akcli@akcli
+```
+
+Full details, per-agent setup, and troubleshooting in [INSTALL.md](INSTALL.md).
+
+## Quickstart
+
+Read a design, check it, and draw into it — straight from the shell:
+
+```bash
+akcli read  board.kicad_sch --summary                            # normalized JSON, context-budgeted
+akcli check board.kicad_sch                                      # ERC-lite + power + BOM + connectivity
+akcli draw  board.kicad_sch --ops ops.json                       # dry-run: shows changes + net diff
+akcli draw  board.kicad_sch --ops ops.json --apply --strict-nets # atomic write + verify + backup
+akcli undo  board.kicad_sch                                      # revert the last write
+```
+
+Every write is a dry run by default; `--apply` goes through an atomic snapshot → temp → verify →
+replace pipeline with a pure-Python connectivity gate, and `akcli undo` reverts from a rotated backup
+stack. Altium files are read-only offline.
+
+## What it does
+
+One normalized model behind every command, so each check, diff, and report works on a KiCad
+`.kicad_sch` — and just the same on an imported Altium `.SchDoc`:
+
+| Command | What it does |
+|---|---|
+| `read` · `net` · `component` · `pins` | Parse KiCad or Altium into one normalized JSON model; query nets, components, and pin coordinates. |
+| `new` · `plan` · `draw` · `ops` · `arrange` | Author a `.kicad_sch` from a versioned **22-op + 10-macro** JSON op-list, behind a net-diff safety gate and one-command `undo`. |
+| `check` · `verify` · `diff` · `pinmap` | ERC-lite + power + BOM + intent / contract checks, schematic ↔ PCB equivalence, net-membership diff, MCU pin → net map. |
+| `review` | Advisory, confidence-graded design review across six detector families (signal / validation / pcb / emc / domain / gerber). |
+| `sim` | Render to a SPICE deck and assert on KiCad's bundled ngspice; sweep corners; fit diode models from datasheet points. |
+| `jlc` | Search JLCPCB/LCSC (stock, price, Basic/Extended), convert a part into a KiCad library in-process, fetch datasheets. |
+| `calc` | **60** standards-cited offline calculators (E-series, IPC-2221, impedance, I²C pull-ups, buck/boost…), each citing its reference. |
+| `library` · `fab` · `release` | Library-workspace audit/repair, versioned fab-profile checks, and a release preflight that writes a traceable manifest. |
+| `render` · `doc` · `view` | Pure-stdlib SVG render, a Markdown pinout book, and a localhost `/calc` + `/live` dashboard. |
+
+Two headline examples — a design review and a part search:
+
+```bash
+akcli review analyze board.kicad_sch --profile deep --pcb board.kicad_pcb   # advisory findings + evidence
+akcli jlc search "0.1uF 0402 X7R"                                           # JLCPCB/LCSC catalog (needs network)
+```
+
+## Use with AI agents
+
+`akcli` is a plain CLI, so any shell-capable agent can drive it. Commands emit structured JSON with
+`--json` (carrying a `schema_version`), each op-list carries a `protocol_version`, and `akcli
+capabilities` self-describes the entire CLI surface in one JSON document — and every error code ships a
+machine-readable `remediation` hint.
+
+- **Claude Code** — install the bundled plugin for five `/akcli:circuit-*` commands (review, pinmap,
+  draw, diff, parts) plus twelve skills spanning design, review, authoring, Altium interop, parts
+  sourcing, calculators, and release gating.
+- **Codex** — install the bundled plugin, or drop the loose skill folders into `.agents/skills/` for
+  auto-discovery. See [docs/codex-plugin.md](docs/codex-plugin.md).
+- **OpenCode** — auto-discovers the bundled skills; see
+  [INSTALL.md](INSTALL.md#use-with-ai-coding-agents) for the exact commands.
+
+## Why akcli
+
+- **Zero runtime dependencies.** Standard library only (including `tomllib`) — easy to vendor, sandbox,
+  or run in CI.
+- **Purpose-built for KiCad.** An iterative KiCad S-expression parser and byte-stable writer at the
+  core; Altium designs come in read-only through pure-stdlib OLE2/CFBF record decoding, straight into
+  the same KiCad flow. No compiled extensions.
+- **Byte-identical re-apply.** Deterministic UUIDv5 + replace-in-place makes every edit idempotent —
+  re-running an op-list produces the same bytes.
+- **Connectivity is the only hard write gate.** Every `plan`/`draw` prints a before/after net diff
+  (splits, merges, renames — matched by pin membership, never by name); `--strict-nets` refuses a
+  write that splits or merges a named net.
+- **Net inference you can trust.** A rebuilt net layer handles global same-name merges, junctions,
+  T-junctions, and No-ERC markers — fixing the classic "same-named nets split into single-pin nets" bug.
+
+## Optional external tools
+
+"Zero-dependency" means zero Python **package** dependencies: `pip install` pulls in nothing, and the
+entire core loop (read / plan / draw / check / diff / calc / render) runs on the standard library
+alone. A few features can use something outside Python — always detected at runtime, never required
+by the core loop:
+
+| Feature | Uses | If missing |
+|---|---|---|
+| Advisory ERC second opinion, `view live` SVG | `kicad-cli` (local executable) | Skipped silently — non-fatal, results stay advisory. |
+| `sim` execution (`--deck-only` needs nothing) | libngspice (bundled with KiCad) | `sim` exits with `NGSPICE_MISSING`; everything else unaffected. |
+| `jlc` part search / datasheet fetch | Network | The **only** networked command family; all others are fully offline. |
+
+`akcli doctor` probes each of these and prints per-OS remediation.
+
+## Documentation
+
+| Doc | Covers |
+|---|---|
+| [SPEC.md](docs/SPEC.md) | Data model, config tables, JSON schemas |
+| [cli-reference.md](docs/cli-reference.md) | Every command and flag |
+| [op-list-authoring.md](docs/op-list-authoring.md) | Op-list authoring bible (ops, macros, groups) |
+| [design-integrity.md](docs/design-integrity.md) | Contracts, fab profiles, release preflight |
+| [review-rules.md](docs/review-rules.md) | Design-review rule catalogue |
+| [sim.md](docs/sim.md) | Simulation reference |
+| [ROADMAP.md](ROADMAP.md) | Roadmap to v1.0 with exit criteria |
+
+## Roadmap
+
+**Shipped (v0.15.0):** KiCad write/draw from a 22-op + 10-macro vocabulary (hierarchical `add_sheet`,
+net-diff safety rails, `new` / multi-level `undo`), net-preserving `arrange --groups` re-layout, the
+advisory `akcli review` engine (six detector families, now including power-entry protection, plus a
+datasheet facts store, `propose` / `tree` / `validate`), ERC / power / BOM / diff / pinmap / intent /
+contract checks with waivers and SARIF, schematic ↔ PCB `verify`, a project `library` workspace,
+versioned `fab` profiles, a `release preflight` gate, `akcli sim` on KiCad's bundled ngspice,
+JLCPCB/LCSC sourcing with datasheet fetch, 60 standards-cited calculators, pure-stdlib SVG rendering,
+and version-tolerant Altium/KiCad readers.
+
+**Ahead (→ v1.0):** the contract-freeze audit. The first PyPI release (`pip install akcli-kicad`) shipped in 0.15.0.
+*Deferred by decision:* a GitHub Action gating schematic PRs, the `view` waveform panel, and a native
+MCP server (the plain CLI serves agents today). Full plan with exit criteria in
+[ROADMAP.md](ROADMAP.md).
+
+## Acknowledgments
+
+`akcli jlc` builds on (full attribution in [ACKNOWLEDGMENTS.md](ACKNOWLEDGMENTS.md) and
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)):
+
+- **JLC2KiCadLib** by **TousstNicolas** (MIT) — LCSC → KiCad conversion core, vendored.
+- **jlcsearch** (tscircuit, MIT) and **jlcparts** (MIT) — part-search backend.
+- **EasyEDA / LCSC / JLCPCB** — component data source.
+
+## Contact
+
+Questions, bugs, or feature requests: please
+[open a GitHub issue](https://github.com/tipoLi5890/akcli/issues).
+
+## License
+
+MIT © 2026 Li, ching yu. See [LICENSE](LICENSE); third-party attribution in
+[ACKNOWLEDGMENTS.md](ACKNOWLEDGMENTS.md) and [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md), and the
+security model in [SECURITY.md](SECURITY.md).

akcli_kicad-0.15.0/pyproject.toml

@@ -0,0 +1,104 @@
+[build-system]
+# PEP 639 bare license string (`license = "MIT"`) requires setuptools >= 77.
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+# PyPI dist name: the distribution ships as `akcli-kicad` while the import
+# package and CLI stay `akcli` (see src/akcli/__init__.py name cascade);
+# keep the three in lockstep.
+name = "akcli-kicad"
+version = "0.15.0"
+description = "AI-native schematic design agent, purpose-built for KiCad: draw and edit .kicad_sch from JSON op-lists with net-diff safety rails, run ERC/design/intent checks, simulate on bundled ngspice, source parts, and import Altium .SchDoc/.PcbDoc read-only into the KiCad flow."
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Manufacturing",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/tipoLi5890/akcli"
+Repository = "https://github.com/tipoLi5890/akcli.git"
+Changelog = "https://github.com/tipoLi5890/akcli/blob/main/CHANGELOG.md"
+
+[project.scripts]
+akcli = "akcli.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "jsonschema>=4", "build", "twine", "ruff>=0.15", "mypy>=1.10"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"akcli.webui" = ["*.html"]
+"akcli.schemas" = ["*.json"]
+# sim/builtin.lib is loaded at runtime via Path(__file__); it MUST ship in the
+# wheel or `akcli sim` with a builtin model breaks on a non-editable install.
+"akcli.sim" = ["*.lib"]
+# vendored MIT library — ship its license/provenance for compliance.
+"akcli._vendor.jlc2kicadlib" = ["LICENSE", "PROVENANCE.md"]
+
+[tool.ruff]
+# Vendored jlc2kicadlib is kept byte-close to upstream; never lint it.
+extend-exclude = ["src/akcli/_vendor"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "W"]
+
+[tool.ruff.lint.per-file-ignores]
+# `l` is inductance throughout the calc domain, not an ambiguous name.
+"src/akcli/calc/electrical.py" = ["E741"]
+"src/akcli/calc/power.py" = ["E741"]
+# Grandfathered spare imports/f-strings; clean up at next functional touch
+# rather than churning otherwise-untouched modules for the lint gate.
+"src/akcli/calc/registry.py" = ["F401"]
+"src/akcli/calc/regulator.py" = ["F401"]
+"src/akcli/ops.py" = ["F401"]
+"src/akcli/parts/bom_jlc.py" = ["F401", "F541"]
+# Deliberate compact paired coordinate statements in the S-expression writer.
+"src/akcli/writers/kicad.py" = ["E702"]
+# Tests favor readability: spare imports/locals and compact fuzz mutators are fine.
+"tests/**" = ["E702", "E741", "F401", "F841"]
+
+[tool.mypy]
+# Beachhead: gate packages module-by-module as each is brought up to the bar
+# rather than the whole tree at once. Covered so far: the networked layer
+# (parts), the calculators, and the typed core (model/errors/units/safety/
+# netdiff/journal/render_svg/kicad_escape/config/arrange).
+files = [
+    "src/akcli/parts", "src/akcli/calc",
+    "src/akcli/model.py", "src/akcli/errors.py", "src/akcli/units.py",
+    "src/akcli/safety.py", "src/akcli/netdiff.py", "src/akcli/journal.py",
+    "src/akcli/render_svg.py", "src/akcli/kicad_escape.py",
+    "src/akcli/config.py", "src/akcli/arrange.py",
+]
+python_version = "3.11"
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unreachable = true
+no_implicit_optional = true
+# parts/ imports ..model, ..checks.bom (untyped elsewhere in the tree); check
+# call sites here but don't cascade errors into or require annotations on
+# modules outside this beachhead.
+follow_imports = "silent"
+
+[[tool.mypy.overrides]]
+# jlcsearch/EasyEDA JSON payloads are untyped `object`/`dict` by design (see
+# module docstrings) — the defensive `getattr`/duck-typed opener plumbing
+# isn't worth fighting the checker over for a first pass.
+module = "akcli.parts.*"
+disallow_untyped_calls = false

akcli_kicad-0.15.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

akcli_kicad-0.15.0/src/akcli/__init__.py

@@ -0,0 +1,46 @@
+"""akcli — read Altium .SchDoc and KiCad .kicad_sch, run checks, draw KiCad.
+
+Zero-runtime-dependency Python package (stdlib only). This top-level module exposes
+the package version and the analysis/protocol version constants used across the CLI.
+
+Name cascade (LOCKED): PyPI dist = ``akcli-kicad`` (the ``akcli`` name is
+taken on PyPI by an unrelated project); import package = ``akcli``; CLI =
+``akcli``.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+
+def _resolve_version() -> str:
+    """Report the version of the code actually running, dev checkout or install.
+
+    A co-located ``pyproject.toml`` (``project.name == "akcli-kicad"``) means we are
+    executing FROM the source tree; that file is the freshest truth and WINS —
+    an editable or older install otherwise pins stale metadata, so bumping the
+    working tree would not move ``akcli --version`` and a real update reads as
+    "unchanged" (the exact confusion the 0.7.0/design-integrity overlap caused).
+    An installed wheel has no such sibling pyproject, so it falls through to the
+    dist metadata. Last-resort ``"0.0.0"`` only if neither source is readable.
+    """
+    try:
+        import tomllib
+        from pathlib import Path
+
+        pyproject = Path(__file__).resolve().parents[2] / "pyproject.toml"
+        with pyproject.open("rb") as fh:
+            project = tomllib.load(fh).get("project", {})
+        if project.get("name") == "akcli-kicad" and project.get("version"):
+            return project["version"]
+    except Exception:
+        pass
+    try:
+        return _pkg_version("akcli-kicad")
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+__version__ = _resolve_version()
+
+__all__ = ["__version__"]

akcli_kicad-0.15.0/src/akcli/__main__.py

@@ -0,0 +1,7 @@
+"""``python -m akcli`` entry point (thin shim over :func:`cli.main`)."""
+
+from __future__ import annotations
+
+from .cli import main
+
+raise SystemExit(main())

akcli_kicad-0.15.0/src/akcli/_vendor/jlc2kicadlib/LICENSE

@@ -0,0 +1,9 @@
+ The MIT License (MIT)
+
+Copyright © 2021 TousstNicolas 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

akcli_kicad-0.15.0/src/akcli/_vendor/jlc2kicadlib/PROVENANCE.md

@@ -0,0 +1,23 @@
+# Provenance — vendored JLC2KiCadLib
+
+- Upstream: https://github.com/TousstNicolas/JLC2KiCad_lib
+- License: MIT (see `LICENSE` in this directory, preserved verbatim)
+- Vendored commit: `48d36032108d64b0f59755234681f1ce8bc98d46`
+- Files taken: `helper.py`, `footprint/{footprint,footprint_handlers,model3d}.py`,
+  `symbol/{symbol,symbol_handlers}.py`. The upstream CLI entry
+  (`JLC2KiCadLib.py`) is NOT vendored — akcli drives `create_footprint` /
+  `create_symbol` directly from `drivers/jlc2kicad.py`.
+
+## Local modifications (kept minimal, all import-level)
+
+1. `import requests` → `from .. import _http as requests` (stdlib urllib shim;
+   keeps akcli zero-dependency).
+2. `from KicadModTree import ...` → `from .._kmt import ...`. **KicadModTree is
+   GPLv3+ and is deliberately not vendored or imported**; `_kmt.py` is an
+   original, clean-room implementation of just the API surface these files use,
+   written against the KiCad footprint *file format* (it emits the modern
+   `(footprint ...)` s-expression dialect rather than the legacy `(module ...)`
+   output of KicadModTree 1.x).
+
+`_http.py` and `_kmt.py` are original akcli code (project MIT license), not
+upstream files.

akcli_kicad-0.15.0/src/akcli/_vendor/jlc2kicadlib/__init__.py

@@ -0,0 +1,7 @@
+"""Vendored JLC2KiCadLib (MIT, (c) 2021 TousstNicolas) — see LICENSE + PROVENANCE.md.
+
+Only the conversion core is vendored (footprint/ + symbol/ + helper.py). Its two
+upstream dependencies are NOT vendored: ``requests`` is replaced by the stdlib
+shim ``_http`` and the GPLv3 ``KicadModTree`` by the clean-room ``_kmt`` writer
+(implemented from the KiCad footprint file format, not from KicadModTree code).
+"""