Skip to content

hashgraph-online/awesome-codex-plugins / plugins/aklofas/kicad-happy/skills/kicad

Analyze KiCad projects and PDF schematics: schematics, PCB layouts, Gerbers, footprints, symbols, netlists, and design rules. Reviews designs for bugs, traces nets, cross-references schematic to PCB, extracts BOM data, checks DRC/ERC, DFM, power trees, and regulator circuits. Every finding carries a confidence label and evidence source with trust_summary rollup. Analyzes PDF schematics from dev boards, reference designs, eval kits, and datasheets. Supports KiCad 5–10. Use whenever the user mentions .kicad_sch, .kicad_pcb, .kicad_pro, PCB design review, schematic analysis, PDF schematics, reference designs, Gerber files, DRC/ERC, netlist issues, BOM extraction, signal tracing, power budget, DFM, or wants to understand, debug, compare, or review any hardware design. Also for "check my board", "review before fab", "what's wrong with my schematic", "is this ready to order", "check my power supply", "verify this circuit", OSHWA certification readiness, or any electronics/PCB design question.

FileKindSize
SKILL.mdskill md79.1 KB
references/config-reference.mdmarkdown19.1 KB
references/datasheet-verification.mdmarkdown16.5 KB
references/deep-review.mdmarkdown9.7 KB
references/design-intent.mdmarkdown5.6 KB
references/diff-analysis.mdmarkdown17.6 KB
references/file-formats.mdmarkdown15.1 KB
references/gerber-parsing.mdmarkdown33.5 KB
references/manual-gerber-parsing.mdmarkdown24.5 KB
references/manual-pcb-parsing.mdmarkdown17.2 KB
references/manual-schematic-parsing.mdmarkdown12.8 KB
references/net-tracing.mdmarkdown12.0 KB
references/oshwa-certification.mdmarkdown4.5 KB
references/output-schema.mdmarkdown33.4 KB
references/pcb-layout-analysis.mdmarkdown27.3 KB
references/pdf-schematic-extraction.mdmarkdown15.2 KB
references/report-generation.mdmarkdown56.3 KB
references/schematic-analysis.mdmarkdown63.9 KB
references/standards-compliance.mdmarkdown33.5 KB
references/supplementary-data-sources.mdmarkdown12.5 KB
references/what-if.mdmarkdown19.5 KB
review/README.mdmarkdown4.1 KB
review/fixtures/deep_review.example.jsonconfig1.2 KB
review/fixtures/design_context.example.jsonconfig388 B
review/fixtures/review_annotations.example.jsonconfig707 B
review/prompts/design_context.mdmarkdown4.9 KB
review/schemas/deep_review.schema.jsonconfig3.3 KB
review/schemas/design_context.schema.jsonconfig2.2 KB
review/schemas/review_annotations.schema.jsonconfig1.9 KB
review/scripts/_mini_jsonschema.pyscript6.6 KB
review/scripts/build_review_plan.pyscript2.3 KB
review/scripts/deep_review_gate.pyscript27.3 KB
review/scripts/merge_annotations.pyscript7.0 KB
review/scripts/validate_review.pyscript2.6 KB
scripts/.gitignoreother13 B
scripts/README.mdmarkdown23.4 KB
scripts/analysis_cache.pyscript42.1 KB
scripts/analyze_gerbers.pyscript90.9 KB
scripts/analyze_pcb.pyscript7.4 KB
scripts/analyze_schematic.pyscript6.7 KB
scripts/analyze_thermal.pyscript48.5 KB
scripts/analyzer_envelope.pyscript15.5 KB
scripts/capability_mode.pyscript10.2 KB
scripts/check_report_sections.pyscript10.6 KB
scripts/cross_analysis.pyscript69.4 KB
scripts/cross_verify.pyscript23.1 KB
scripts/design_intent.pyscript13.5 KB
scripts/detection_schema.pyscript26.0 KB
scripts/detector_helpers.pyscript15.2 KB
scripts/diff_analysis.pyscript23.5 KB
scripts/diff_engine.pyscript47.2 KB
scripts/domain_detectors.pyscript260.5 KB
scripts/envelopes/__init__.pyscript0 B
scripts/envelopes/cross_analysis.pyscript5.9 KB
scripts/envelopes/gerber.pyscript16.1 KB
scripts/envelopes/pcb.pyscript25.9 KB
scripts/envelopes/schematic.pyscript23.1 KB
scripts/envelopes/thermal.pyscript7.4 KB
scripts/export_issues.pyscript27.6 KB
scripts/fab_release_gate.pyscript29.8 KB
scripts/finding_schema.pyscript25.7 KB
scripts/gen_output_schema_md.pyscript9.2 KB
scripts/inputs_builder.pyscript4.0 KB
scripts/kicad_core/__init__.pyscript0 B
scripts/kicad_core/classify.pyscript32.5 KB
scripts/kicad_core/cli.pyscript4.2 KB
scripts/kicad_core/coords.pyscript2.0 KB
scripts/kicad_core/diagnostics.pyscript1.9 KB
scripts/kicad_core/executables.pyscript1.0 KB
scripts/kicad_core/fields.pyscript5.9 KB
scripts/kicad_core/fileio.pyscript5.4 KB
scripts/kicad_core/hotloop.pyscript3.1 KB
scripts/kicad_core/instances.pyscript5.7 KB
scripts/kicad_core/model.pyscript4.8 KB
scripts/kicad_core/netnames.pyscript19.1 KB
scripts/kicad_core/netquery.pyscript6.7 KB
scripts/kicad_core/pairing.pyscript1.9 KB
scripts/kicad_core/parts.pyscript28.9 KB
scripts/kicad_core/passives.pyscript10.0 KB
scripts/kicad_core/pdn.pyscript1011 B
scripts/kicad_core/project.pyscript43.2 KB
scripts/kicad_core/render.pyscript2.7 KB
scripts/kicad_core/sexp.pyscript12.6 KB
scripts/kicad_core/textvars.pyscript5.4 KB
scripts/kicad_core/token_cache.pyscript2.2 KB
scripts/kicad_core/values.pyscript14.1 KB
scripts/kicad_types.pyscript15.1 KB
scripts/lifecycle_audit.pyscript6.7 KB
scripts/lifecycle_engine.pyscript52.8 KB
scripts/lookup_detectors.pyscript29.9 KB
scripts/lookup_helpers.pyscript3.0 KB
scripts/methodology_gerbers.mdmarkdown23.1 KB
scripts/methodology_pcb.mdmarkdown22.2 KB
scripts/methodology_schematic.mdmarkdown43.1 KB
scripts/netlist_queries.pyscript4.2 KB
scripts/output_filters.pyscript16.8 KB
scripts/output_io.pyscript5.3 KB
scripts/pcb/__init__.pyscript0 B
scripts/pcb/assembly.pyscript58.3 KB
scripts/pcb/connectivity.pyscript27.7 KB
scripts/pcb/copper.pyscript61.0 KB
scripts/pcb/dfm.pyscript56.9 KB
scripts/pcb/geometry.pyscript59.5 KB
scripts/pcb/pipeline.pyscript30.3 KB
scripts/pcb/presentation.pyscript24.3 KB
scripts/pcb/reader.pyscript87.1 KB
scripts/pcb/routing.pyscript53.5 KB
scripts/project_config.pyscript23.1 KB
scripts/risk_summary.pyscript3.1 KB
scripts/run_id.pyscript1.7 KB
scripts/schema_codec.pyscript5.0 KB
scripts/schematic/__init__.pyscript0 B
scripts/schematic/audits.pyscript56.0 KB
scripts/schematic/bom_stats.pyscript6.1 KB
scripts/schematic/connectivity.pyscript62.9 KB
scripts/schematic/erc_pins.pyscript8.4 KB
scripts/schematic/hierarchy.pyscript21.5 KB
scripts/schematic/ic_analysis.pyscript21.4 KB
scripts/schematic/legacy_reader.pyscript49.4 KB
scripts/schematic/net_analysis.pyscript75.5 KB
scripts/schematic/pipeline.pyscript72.2 KB
scripts/schematic/presentation.pyscript20.9 KB
scripts/schematic/reader.pyscript64.7 KB
scripts/schematic/system_analyses.pyscript126.9 KB
scripts/signal_detectors.pyscript248.0 KB
scripts/summarize_findings.pyexecutablescript17.4 KB
scripts/validation_detectors.pyscript75.3 KB
scripts/what_if.pyscript68.4 KB

scripts/envelopes/schematic.py

View on GitHub
"""Schematic analyzer output envelope.

The runtime emits a sprawling result dict — ~40 top-level keys spanning
hard-typed core (summary, trust_summary, findings, components, nets,
bom, statistics) and many detector-specific analysis bags
(design_analysis, placement_analysis, bus_topology, sleep_current_audit,
etc.).  This envelope types every top-level key the runtime actually
emits on the simple fixture, while leaving the free-form analysis bags
as plain ``dict`` schemas.  Consumers get the discriminator fields
(analyzer_type, schema_version) as ``const`` strings and a guaranteed
shape for the universal blocks; detector-specific contents inside the
bags are free-form.

Additional properties are permitted by JSON Schema default so optional
sections that only appear on richer projects (sheets, project_settings,
pdn_impedance, etc.) validate cleanly whether present or absent.
"""
from __future__ import annotations

import os
import sys
from dataclasses import dataclass, field
from typing import Optional

# Make shared primitives importable when this module is loaded from
# tests, from the analyzer, or via generator tooling.
_HERE = os.path.dirname(os.path.abspath(__file__))
_PARENT = os.path.dirname(_HERE)
if _PARENT not in sys.path:
    sys.path.insert(0, _PARENT)

from analyzer_envelope import (  # noqa: E402
    TrustSummary, Finding, Assessment, BySeverity, TitleBlock, InputsBlock, CompatBlock, Diagnostic,
)


@dataclass
class SchematicSummary:
    """Top-level roll-up (mirrors the runtime's summary dict)."""
    total_findings: int = field(metadata={
        "description": "Count of findings[]."})
    by_severity: BySeverity = field(metadata={
        "description": "Breakdown by severity bucket."})


@dataclass
class PowerRailEntry:
    """Power rail statistic entry. Voltage may be null for ground nets."""
    name: str = field(metadata={
        "description": "Power rail net name."})
    voltage: Optional[float] = field(default=None, metadata={
        "description": "Rail voltage in volts; null for ground or "
                       "unresolved rails."})


@dataclass
class Statistics:
    """Component / net counts and coverage summaries."""
    total_components: int = field(metadata={
        "description": "Total component count (excluding power symbols)."})
    unique_parts: int = field(metadata={
        "description": "Count of distinct (value, footprint, MPN) triples."})
    dnp_parts: int = field(metadata={
        "description": "Components marked Do Not Populate."})
    total_nets: int = field(metadata={
        "description": "Count of distinct nets."})
    total_wires: int = field(metadata={
        "description": "Wire segment count."})
    total_no_connects: int = field(metadata={
        "description": "No-connect flag count."})
    component_types: dict[str, int] = field(metadata={
        "description": "Map: component type name -> count."})
    power_rails: list[PowerRailEntry] = field(metadata={
        "description": "Power rail net entries {name, voltage} detected."})
    missing_mpn: list[str] = field(metadata={
        "description": "References missing MPN property."})
    missing_footprint: list[str] = field(metadata={
        "description": "References missing footprint."})


@dataclass
class NetPin:
    """One pin participating in a net."""
    component: str = field(metadata={
        "description": "Component reference."})
    pin_number: str = field(metadata={
        "description": "Pin number on component."})
    pin_name: Optional[str] = field(default=None, metadata={
        "description": "Pin name."})
    pin_type: Optional[str] = field(default=None, metadata={
        "description": "Electrical type."})


@dataclass
class NetLabel:
    """One label record attached to a net."""
    name: str = field(metadata={
        "description": "Label text."})
    type: str = field(metadata={
        "description": "Label kind: 'label', 'global_label', 'hierarchical_label', or 'directive_label'."})


@dataclass
class NetEntry:
    """Connectivity entry for one net."""
    name: str = field(metadata={
        "description": "Net name."})
    pins: list[NetPin] = field(metadata={
        "description": "Pins on this net."})
    point_count: int = field(metadata={
        "description": "Geometric connection point count."})
    no_connect: bool = field(default=False, metadata={
        "description": "Net terminated by a no-connect flag."})
    has_pwr_flag: bool = field(default=False, metadata={
        "description": "Net carries a PWR_FLAG ERC source declaration."})
    labels: list[NetLabel] = field(default_factory=list, metadata={
        "description": "Label records attached to this net."})
    display_name: str | None = field(default=None, metadata={"description":
        "Name KiCad shows when it differs from the map key: the decoded "
        "form of an escaped key (A{slash}B -> A/B), the bare name of a "
        "sheet-qualified local net (/<sheet>/<name>), or a Ref.PinName hint for "
        "an __unnamed_ net. Absent when the key is already the shown name."})


@dataclass
class BomEntry:
    """One deduplicated BOM row."""
    value: Optional[str] = field(default=None, metadata={
        "description": "Value string."})
    footprint: Optional[str] = field(default=None, metadata={
        "description": "Footprint."})
    mpn: Optional[str] = field(default=None, metadata={
        "description": "MPN."})
    manufacturer: Optional[str] = field(default=None, metadata={
        "description": "Manufacturer."})
    digikey: Optional[str] = field(default=None, metadata={
        "description": "DigiKey SKU."})
    mouser: Optional[str] = field(default=None, metadata={
        "description": "Mouser SKU."})
    lcsc: Optional[str] = field(default=None, metadata={
        "description": "LCSC SKU."})
    element14: Optional[str] = field(default=None, metadata={
        "description": "element14 SKU."})
    datasheet: Optional[str] = field(default=None, metadata={
        "description": "Datasheet URL or local path."})
    description: Optional[str] = field(default=None, metadata={
        "description": "Description."})
    references: list[str] = field(default_factory=list, metadata={
        "description": "Refdes list."})
    quantity: int = field(default=0, metadata={
        "description": "Quantity for this line item."})
    dnp: bool = field(default=False, metadata={
        "description": "DNP flag."})
    type: Optional[str] = field(default=None, metadata={
        "description": "Component type."})


@dataclass
class PinCoverageWarning:
    """One entry in pin_coverage_warnings."""
    component: str = field(metadata={
        "description": "Component reference with pin coverage gap."})
    lib_id: str = field(metadata={
        "description": "KiCad library ID of the symbol."})
    expected_pins: int = field(metadata={
        "description": "Count of non-NC pins in the library symbol."})
    placed_pins: int = field(metadata={
        "description": "Count of pins actually placed across units."})
    missing_count: int = field(metadata={
        "description": "Count of missing placements."})
    message: str = field(metadata={
        "description": "Human-readable warning message."})


@dataclass
class BusUnresolved:
    """One bus construct the resolver could not confidently resolve."""
    reason: str = field(metadata={
        "description": "Why this bus construct could not be resolved."})
    name: Optional[str] = field(default=None, metadata={
        "description": "Associated bus alias / label / sheet-pin name, "
                       "when known; null otherwise."})


@dataclass
class BusTopology:
    """Bus wire statistics and resolver honesty markers (GH #25)."""
    bus_wire_count: int = field(metadata={
        "description": "Count of bus wire segments."})
    bus_entry_count: int = field(metadata={
        "description": "Count of bus entry taps."})
    unresolved: list[BusUnresolved] = field(metadata={
        "description": "Bus constructs the resolver could not confidently "
                       "resolve — connectivity through them is NOT asserted "
                       "(honest-limitation marker, GH #25)."})


@dataclass
class SchematicEnvelope:
    """Top-level output of analyze_schematic.py.

    Tight typing on universal fields (analyzer_type, schema_version,
    summary, trust_summary, findings, statistics, bom, nets).  Loose
    ``dict`` typing on detector-specific analysis bags so each bag's
    per-rule_id shape can vary independently.

    Optional fields at the bottom are only emitted on richer projects
    (hierarchy, protocol_compliance, sleep_current_audit, etc.); the
    simple fixture emits only a few of them.
    """

    # --- Discriminators ---
    analyzer_type: str = field(metadata={
        "description": "Always 'schematic'.",
        "const": "schematic"})
    schema_version: str = field(metadata={
        "description": "Semver. Value: '1.4.0'.",
        "const": "1.4.0"})

    # --- Provenance ---
    inputs: InputsBlock = field(metadata={
        "description": "Source files, hashes, run_id, config_hash, upstream "
                       "artifacts for this run."})
    compat: CompatBlock = field(metadata={
        "description": "Schema compatibility metadata: minimum consumer "
                       "version + deprecated/experimental field lists."})
    diagnostics: list[Diagnostic] = field(default_factory=list, kw_only=True, metadata={
        "description": "Guarded failures that degraded this run (section omitted, "
                       "fallback model used). Empty when nothing degraded."})

    # --- Universal core ---
    summary: SchematicSummary = field(metadata={
        "description": "Roll-up summary (total + by_severity)."})
    trust_summary: TrustSummary = field(metadata={
        "description": "Trust posture rollup (confidence + evidence source "
                       "+ optional BOM coverage)."})
    kicad_version: str = field(metadata={
        "description": "KiCad generator version string, e.g. '9.0' or '5 (legacy)'."})
    file_version: str = field(metadata={
        "description": "KiCad file format version string."})
    title_block: TitleBlock = field(metadata={
        "description": "KiCad title block (title/date/rev/company/comments)."})
    statistics: Statistics = field(metadata={
        "description": "Component, net, and coverage counts."})
    findings: list[Finding] = field(metadata={
        "description": "All findings (flat, rich-finding format)."})
    assessments: list[Assessment] = field(metadata={
        "description": "Informational assessments (empty for schematic at v1.4; "
                       "reserved for future measurement-style records)."})
    bom: list[BomEntry] = field(metadata={
        "description": "Deduplicated BOM rows."})
    components: list[dict] = field(metadata={
        "description": "Every non-power component as a dict. Shape is "
                       "effectively open: reference/value/lib_id/"
                       "footprint/datasheet/description/mpn/manufacturer/"
                       "distributor SKUs/geometry/uuid/type/parsed_value "
                       "plus internal bookkeeping (_sheet, pin_nets, "
                       "pin_uuids)."})
    nets: dict[str, NetEntry] = field(metadata={
        "description": "Net connectivity map keyed by unique net key — the "
                       "display name, sheet-qualified as /<sheet>/<name> "
                       "when distinct nets share a bare name."})
    subcircuits: list[dict] = field(metadata={
        "description": "IC neighbourhoods, one entry per IC: "
                       "[{center_ic, ic_value, ic_mpn, ic_lib_id, "
                       "neighbor_components: [{ref, value, type}], description}]; "
                       "neighbours share a non-power, non-ground net with the "
                       "IC. Not hierarchical sheets; detected circuits are in "
                       "findings[]."})
    ic_pin_analysis: list[dict] = field(metadata={
        "description": "Per-IC pin mappings. Each entry carries reference, "
                       "value, type, lib_id, mpn, description, datasheet, "
                       "function, total_pins, unconnected_pins, pins[], "
                       "power_pins[], signal_pins[], decoupling_caps_by_rail. "
                       "Covers type in {ic, connector, crystal, oscillator}; "
                       "transistors live in transistor_pin_analysis[]."})
    transistor_pin_analysis: list[dict] = field(metadata={
        "description": "Per-transistor pin mappings. Same shape as "
                       "ic_pin_analysis entries but filtered to "
                       "type=transistor (MOSFETs, BJTs, FETs). Lets bridge / "
                       "half-bridge / gate-driver reviewers verify "
                       "gate/source/drain wiring without reconstructing pin "
                       "maps from nets[].pins[] by hand."})

    # --- Analysis bags (free-form dicts; shape varies per rule_id) ---
    design_analysis: dict = field(metadata={
        "description": "Design-level analyses: net_classification, "
                       "power_domains, cross_domain_signals, bus_analysis "
                       "(i2c/spi/uart/can), differential_pairs, "
                       "erc_warnings, passive_warnings."})
    connectivity_issues: dict = field(metadata={
        "description": "Connectivity issue lists: single_pin_nets, "
                       "single_pin_net_findings, multi_driver_nets, "
                       "unconnected_pins, power_net_summary."})
    annotation_issues: dict = field(metadata={
        "description": "Annotation issue bag: duplicate_references, "
                       "unannotated, missing_value, zero_indexed_refs."})
    ground_domains: dict = field(metadata={
        "description": "Ground topology: ground_nets, multiple_domains, "
                       "domains, optional star-ground note."})
    bus_topology: BusTopology = field(metadata={
        "description": "Bus wire statistics: bus_wire_count, bus_entry_count, "
                       "unresolved. May also carry aliases / "
                       "detected_bus_signals (undeclared, shape varies)."})
    wire_geometry: dict = field(metadata={
        "description": "Wire-geometry summary: total_wires, "
                       "total_length_mm, avg_length_mm, optional "
                       "diagonal/short-wire callouts."})
    simulation_readiness: dict = field(metadata={
        "description": "SPICE readiness rollup: total_components, "
                       "likely_simulatable, needs_model, "
                       "simulatable_percent, components_without_model."})
    hierarchical_labels: dict = field(metadata={
        "description": "Label counts: global_label_count, "
                       "hierarchical_label_count, optional "
                       "unconnected_hierarchical or conflict warnings."})
    placement_analysis: dict = field(metadata={
        "description": "Placement stats: bounding_box, clusters, grid_size."})
    property_issues: dict = field(metadata={
        "description": "Property validation issues: missing/mismatched "
                       "symbol properties (MPN, footprint, datasheet, value), "
                       "blank description fields, non-ASCII character "
                       "warnings. Keyed by issue category."})
    sourcing_audit: dict = field(metadata={
        "description": "Sourcing audit: missing_mpn/digikey/lcsc lists, "
                       "mpn_coverage, mpn_percent, total_bom_components."})
    rail_voltages: dict[str, Optional[float]] = field(metadata={
        "description": "Per-net rail voltage (volts). Nulls permitted for "
                       "ground or unresolved rails."})

    # --- Runtime "also emitted" companions ---
    # These may be absent on some paths but the simple fixture emits them,
    # so they are required by default.  Optional-by-design blocks live
    # below.
    labels: list[dict] = field(default_factory=list, metadata={
        "description": "Extracted label records."})
    no_connects: list[dict] = field(default_factory=list, metadata={
        "description": "Extracted no-connect flag records."})
    power_symbols: list[dict] = field(default_factory=list, metadata={
        "description": "Power symbol placements: [{net_name, x, y, lib_id, "
                       "_sheet, _power_scope}]."})
    pwr_flag_warnings: list[dict] = field(default_factory=list, metadata={
        "description": "PWR_FLAG warnings: [{net, message, pin_types}]."})
    label_shape_warnings: list = field(default_factory=list, metadata={
        "description": "Label-shape mismatch warnings."})
    footprint_filter_warnings: list = field(default_factory=list, metadata={
        "description": "Footprint filter warnings from lib_symbols."})

    # --- Capability pointer ---
    capability_mode_ref: Optional[dict] = field(default=None, metadata={
        "description": "Pointer to canonical analysis/capability_mode.json run-level "
                       "record. Shape: {source, run_id}."})

    # --- Stage/audience derived blocks ---
    audience_summary: Optional[dict] = field(default=None, metadata={
        "description": "Designer/reviewer/manager summary views; only "
                       "present when output filters ran."})

    # --- Project/intent/config attachments ---
    design_intent: Optional[dict] = field(default=None, metadata={
        "description": "Resolved design intent: approved_manufacturers, "
                       "ipc_class, target_market, operating_temp_range, "
                       "preferred_passive_size, product_class, "
                       "test_coverage_target, expected_lifetime_years, "
                       "detection_signals, source, confidence."})
    project_config: Optional[dict] = field(default=None, metadata={
        "description": "Copy of the resolved project block from "
                       ".kicad-happy.json (when present)."})
    project_settings: Optional[dict] = field(default=None, metadata={
        "description": "Selected KiCad project settings extracted from "
                       ".kicad_pro (when present)."})

    # --- Coverage / audit sections ---
    bom_lock: Optional[dict] = field(default=None, metadata={
        "description": "BOM lock verification: status, lock_pct, "
                       "components_with_mpn, missing_mpn, etc."})
    bom_optimization: Optional[dict] = field(default=None, metadata={
        "description": "BOM optimization bag: single_use_passive_values, "
                       "unique_value_counts, total_unique_footprints, "
                       "consolidation_suggestions."})
    missing_info: Optional[dict] = field(default=None, metadata={
        "description": "Data-gap rollup: missing_mpn, missing_footprint, "
                       "missing_datasheet, heuristic_vref."})
    # --- Specialised analysis (gated on content) ---
    sleep_current_audit: Optional[dict] = field(default=None, metadata={
        "description": "Sleep-current audit: rails, total_estimated_sleep_uA, "
                       "realistic_total_uA, conditional_pull_up_uA, "
                       "observations."})
    test_coverage: Optional[dict] = field(default=None, metadata={
        "description": "Test coverage audit: test_points, test_point_count, "
                       "covered_nets, uncovered_key_nets, observations, "
                       "optional debug_connectors."})
    assembly_complexity: Optional[dict] = field(default=None, metadata={
        "description": "Assembly complexity score and breakdown."})
    power_budget: Optional[dict] = field(default=None, metadata={
        "description": "Estimated power budget per rail."})
    power_sequencing: Optional[dict] = field(default=None, metadata={
        "description": "Power sequencing dependencies and warnings."})
    power_sequencing_validation: Optional[dict] = field(default=None, metadata={
        "description": "Validated power tree with provenance."})
    pdn_impedance: Optional[dict] = field(default=None, metadata={
        "description": "PDN impedance analysis per rail."})
    usb_compliance: Optional[dict] = field(default=None, metadata={
        "description": "USB compliance checks."})
    inrush_analysis: Optional[dict] = field(default=None, metadata={
        "description": "Inrush current estimation by rail."})
    protocol_compliance: Optional[dict] = field(default=None, metadata={
        "description": "Protocol compliance checks (I2C/SPI/UART/etc.)."})

    # --- Warnings / notices ---
    # These stay bare `list` fields: items are heterogeneous dicts with
    # inconsistent keys across detector paths.
    text_annotations: Optional[list] = field(default=None, metadata={
        "description": "Text annotations extracted from the schematic."})
    alternate_pin_summary: Optional[dict] = field(default=None, metadata={
        "description": "Alternate-pin usage summary."})
    pin_coverage_warnings: Optional[list[PinCoverageWarning]] = field(default=None, metadata={
        "description": "Warnings about pin coverage gaps. Emitted "
                       "when a placed symbol has fewer pins connected than "
                       "the library definition expects. Present only when "
                       "such warnings fire."})
    instance_consistency_warnings: Optional[list] = field(default=None, metadata={
        "description": "Multi-instance symbol consistency warnings."})
    generic_symbol_warnings: Optional[list] = field(default=None, metadata={
        "description": "Warnings about generic symbol usage without MPN."})

    # --- Legacy / hierarchy / sheet metadata ---
    sheets: Optional[list] = field(default=None, metadata={
        "description": "Hierarchical sheet list (multi-sheet only)."})
    sheets_parsed: Optional[int] = field(default=None, metadata={
        "description": "Count of parsed sheets (legacy .sch)."})
    sheet_files: Optional[list[str]] = field(default=None, metadata={
        "description": "Parsed sheet file paths (legacy .sch)."})
    legacy_analysis_quality: Optional[dict] = field(default=None, metadata={
        "description": "Legacy .sch quality rollup: is_legacy_schematic, "
                       "library_resolution, pin_source_coverage."})
    hierarchy_context: Optional[dict] = field(default=None, metadata={
        "description": "Not emitted: no analyzer path produces it."})
    hierarchy_warning: Optional[str] = field(default=None, metadata={
        "description": "Emitted when sub-sheet was detected without root."})
    redirected_from: Optional[str] = field(default=None, metadata={
        "description": "Original filename when a sub-sheet was redirected "
                       "to the project root. Emitted in JSON as "
                       "'_redirected_from'.",
        "json_name": "_redirected_from"})
    stale_file_warning: Optional[str] = field(default=None, metadata={
        "description": "Emitted when input file is not in the project "
                       "sheet tree. Emitted in JSON as "
                       "'_stale_file_warning'.",
        "json_name": "_stale_file_warning"})
    net_classifications: Optional[dict] = field(default=None, metadata={
        "description": "Per-net classification map promoted from "
                       "signal_analysis (legacy alias of "
                       "design_analysis.net_classification)."})
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 321kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 321kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 321kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 197kUpdated Claude CodeCodexVerifiedInstall