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/gerber.py

View on GitHub
"""Gerber analyzer output envelope.

The runtime of ``analyze_gerbers.py`` emits a tight core (analyzer_type,
schema_version, summary, trust_summary, directory, generator,
layer_count, statistics, completeness, alignment, drill_classification,
pad_summary, findings) plus optional/gated blocks
(trace_widths, component_analysis, net_analysis, job_file, zip_archives,
connectivity) and always emits the gerbers[]/drills[]/drill_tools
structural maps.

Tightens:
    - analyzer_type + schema_version carry ``const`` discriminators.
    - summary, trust_summary, statistics, completeness, alignment,
      drill_classification, pad_summary, trace_widths, component_analysis,
      net_analysis, board_dimensions are typed dataclasses mirroring
      runtime shape.
    - gerbers[]/drills[]/job_file/zip_archives/connectivity are typed as
      ``list[dict]`` / ``dict`` for v1.4.

Mode gating:
    - ``--full`` adds ``connectivity`` at the top level (flat pin list).
    - Zip archive sweep only emits ``zip_archives`` when a .zip is
      present in the gerber directory.
    - ``trace_widths``, ``component_analysis``, ``net_analysis``,
      ``job_file`` appear only when the source data is parseable.
    - ``audience_summary`` is added by the output filter pipeline.

Additional properties are permitted by JSON Schema default.
"""
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, InputsBlock, CompatBlock, Diagnostic,
)


@dataclass
class GerberSummary:
    """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 GerberStatistics:
    """File/draw/flash/hole counts."""
    gerber_files: int = field(metadata={
        "description": "Count of parsed gerber files."})
    drill_files: int = field(metadata={
        "description": "Count of parsed drill (.drl) files."})
    total_holes: int = field(metadata={
        "description": "Sum of hole counts across all drill files."})
    total_flashes: int = field(metadata={
        "description": "Sum of flash operations across all gerber files."})
    total_draws: int = field(metadata={
        "description": "Sum of draw operations across all gerber files."})


@dataclass
class BoardDimensions:
    """Physical board size derived from gbrjob/Edge.Cuts/fallback."""
    width_mm: Optional[float] = field(default=None, metadata={
        "description": "Board width in mm; null if no dimension source was usable."})
    height_mm: Optional[float] = field(default=None, metadata={
        "description": "Board height in mm; null if no dimension source was usable."})
    area_mm2: Optional[float] = field(default=None, metadata={
        "description": "Board area in mm^2 (width_mm * height_mm); null if "
                       "dimensions unavailable."})
    source: Optional[str] = field(default=None, metadata={
        "description": "Dimension origin: 'gbrjob' | 'edge_cuts' | 'layer_extents'."})


@dataclass
class Completeness:
    """Layer/drill completeness rollup."""
    expected_layers: list[str] = field(metadata={
        "description": "Layers expected for the board stackup "
                       "(sourced from gbrjob when available, filename "
                       "heuristic otherwise)."})
    found_layers: list[str] = field(metadata={
        "description": "Layers actually present in the directory."})
    missing: list[str] = field(metadata={
        "description": "Expected layers not found on disk."})
    extra: list[str] = field(metadata={
        "description": "Found layers not in the expected set."})
    complete: bool = field(metadata={
        "description": "True when missing == [] and all expected layers present."})
    has_pth_drill: bool = field(metadata={
        "description": "True when a plated through-hole drill file was found."})
    has_npth_drill: bool = field(metadata={
        "description": "True when a non-plated through-hole drill file was found."})
    source: str = field(metadata={
        "description": "How expected_layers was derived: 'gbrjob' | "
                       "'filename_heuristic'."})


@dataclass
class LayerExtent:
    """Bounding dimensions of a single layer's drawn content."""
    width: float = field(metadata={
        "description": "Max extent in X (mm) across flashes/draws on this layer."})
    height: float = field(metadata={
        "description": "Max extent in Y (mm) across flashes/draws on this layer."})


@dataclass
class Alignment:
    """Cross-layer alignment report."""
    aligned: bool = field(metadata={
        "description": "True when copper/edge layers agree in outer extents."})
    issues: list[str] = field(metadata={
        "description": "Human-readable descriptions of alignment mismatches."})
    layer_extents: dict[str, LayerExtent] = field(metadata={
        "description": "Per-layer bounding extents keyed by layer name "
                       "(e.g. 'F.Cu', 'Edge.Cuts', 'drill_mixed')."})


@dataclass
class DrillClassTool:
    """One tool/diameter entry inside a drill classification bucket."""
    diameter_mm: float = field(metadata={"description": "Tool diameter in mm."})
    count: int = field(metadata={"description": "Hole count for this tool."})


@dataclass
class DrillClassBucket:
    """A classified bucket of drills (vias, component holes, mounting)."""
    count: int = field(metadata={
        "description": "Total hole count in this bucket."})
    tools: list[DrillClassTool] = field(metadata={
        "description": "Per-diameter breakdown."})


@dataclass
class DrillClassification:
    """Functional classification of drill holes."""
    classification_method: str = field(metadata={
        "description": "How holes were classified: 'x2_attributes' | "
                       "'diameter_heuristic'."})
    vias: DrillClassBucket = field(metadata={
        "description": "Via drills bucket."})
    component_holes: DrillClassBucket = field(metadata={
        "description": "Component pin drills bucket."})
    mounting_holes: DrillClassBucket = field(metadata={
        "description": "Mounting/NPTH drills bucket."})


@dataclass
class PadSummary:
    """Aperture-function rollup from gerber flashes."""
    smd_apertures: int = field(metadata={
        "description": "Count of SMD pad apertures."})
    via_apertures: int = field(metadata={
        "description": "Count of via pad apertures."})
    tht_holes: int = field(metadata={
        "description": "Count of through-hole pad apertures (component drills)."})
    heatsink_apertures: int = field(metadata={
        "description": "Count of heatsink/thermal apertures."})
    smd_ratio: float = field(metadata={
        "description": "SMD pad ratio = smd_apertures / total pads."})
    smd_source: str = field(metadata={
        "description": "Where SMD classification came from: "
                       "'x2_aperture_function' | 'size_heuristic'."})


@dataclass
class TraceWidths:
    """Trace width rollup derived from conductor apertures."""
    unique_widths_mm: list[float] = field(metadata={
        "description": "Sorted list of distinct conductor widths (mm)."})
    width_count: int = field(metadata={
        "description": "Count of unique widths."})
    min_trace_mm: float = field(metadata={
        "description": "Minimum conductor width (mm)."})
    max_trace_mm: float = field(metadata={
        "description": "Maximum conductor width (mm)."})
    min_feature_mm: float = field(metadata={
        "description": "Minimum feature size (mm) — smallest aperture used "
                       "for any conductor/flash."})


@dataclass
class ComponentAnalysis:
    """X2 component attribute rollup."""
    total_unique: int = field(metadata={
        "description": "Count of distinct component references."})
    total_pads: int = field(metadata={
        "description": "Total pad flash count attributed to components."})
    front_side: int = field(metadata={
        "description": "Count of front-side components."})
    back_side: int = field(metadata={
        "description": "Count of back-side components."})
    has_x2_data: bool = field(metadata={
        "description": "True when X2 component attributes were present in "
                       "the gerber stream."})
    component_refs: list[str] = field(metadata={
        "description": "All component references (e.g. ['D1','J1','R1'])."})
    pads_per_component: dict[str, int] = field(metadata={
        "description": "Reference -> pad flash count."})


@dataclass
class NetAnalysis:
    """X2 net attribute rollup."""
    total_unique: int = field(metadata={
        "description": "Count of distinct nets."})
    total_pins: int = field(metadata={
        "description": "Total pin count across all nets."})
    named_nets: int = field(metadata={
        "description": "Count of nets with names."})
    unnamed_nets: int = field(metadata={
        "description": "Count of unnamed/anonymous nets."})
    power_nets: list[str] = field(metadata={
        "description": "Power net names identified (e.g. ['+5V','GND'])."})
    signal_nets: list[str] = field(metadata={
        "description": "Non-power signal net names."})


@dataclass
class GerberEnvelope:
    """Top-level output of analyze_gerbers.py.

    Tight typing on universal fields; loose ``dict`` / ``list[dict]``
    typing on gerbers[]/drills[]/job_file/zip_archives/connectivity for
    v1.4.
    """

    # --- Discriminators ---
    analyzer_type: str = field(metadata={
        "description": "Always 'gerber'.",
        "const": "gerber"})
    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: GerberSummary = field(metadata={
        "description": "Roll-up summary (total + by_severity)."})
    trust_summary: TrustSummary = field(metadata={
        "description": "Trust posture rollup (confidence + evidence source)."})
    directory: str = field(metadata={
        "description": "Resolved absolute path of the scanned gerber directory."})
    layer_count: int = field(metadata={
        "description": "Layer count derived from gbrjob or filename heuristic."})
    statistics: GerberStatistics = field(metadata={
        "description": "File / draw / flash / hole totals."})
    completeness: Completeness = field(metadata={
        "description": "Expected-vs-found layers and drill presence."})
    alignment: Alignment = field(metadata={
        "description": "Cross-layer alignment report."})
    drill_classification: DrillClassification = field(metadata={
        "description": "Vias / component / mounting hole breakdown."})
    pad_summary: PadSummary = field(metadata={
        "description": "Aperture-function rollup (SMD / via / TH / heatsink)."})
    findings: list[Finding] = field(metadata={
        "description": "All gerber findings (flat list)."})
    assessments: list[Assessment] = field(metadata={
        "description": "Informational assessments (empty for gerber at v1.4)."})
    board_dimensions: BoardDimensions = field(metadata={
        "description": "Physical board dimensions (from gbrjob or edge cuts)."})
    generator: Optional[str] = field(default=None, metadata={
        "description": "Generator string (e.g. 'Pcbnew 10.0.1-...'); null if "
                       "no GenerationSoftware tag and no gbrjob info."})

    # --- Structural arrays/maps (always emitted even if empty) ---
    # Items are free-form dicts: per-aperture structure and X2 attribute
    # shape are not typed.
    gerbers: list[dict] = field(default_factory=list, metadata={
        "description": "Per-gerber-file summary. Each item: "
                       "{filename, layer_type, units, aperture_count, "
                       "draw_count, flash_count, region_count, "
                       "x2_attributes, x2_component_count, x2_net_count, "
                       "x2_pin_count, aperture_analysis}."})
    drills: list[dict] = field(default_factory=list, metadata={
        "description": "Per-drill-file summary. Each item: "
                       "{filename, type, units, hole_count, layer_span, "
                       "tools (T# -> {diameter_mm, hole_count, "
                       "aper_function}), x2_attributes}."})
    # drill_tools values are {diameter_mm, count, type}; kept as an open dict (see output-schema.md).
    drill_tools: dict[str, dict] = field(default_factory=dict, metadata={
        "description": "Aggregated tool map keyed by 'Xmm' diameter label "
                       "with value {diameter_mm, count, type}."})

    # --- Optional blocks (content-gated) ---
    trace_widths: Optional[TraceWidths] = field(default=None, metadata={
        "description": "Trace width rollup; omitted when no conductor "
                       "apertures were observed."})
    component_analysis: Optional[ComponentAnalysis] = field(default=None, metadata={
        "description": "X2 component attribute rollup; omitted when no X2 "
                       "component data in the gerber stream."})
    net_analysis: Optional[NetAnalysis] = field(default=None, metadata={
        "description": "X2 net attribute rollup; omitted when no X2 net "
                       "data in the gerber stream."})
    # Free-form dict: the stackup/design_rules shape is not typed.
    job_file: Optional[dict] = field(default=None, metadata={
        "description": "Parsed .gbrjob contents: project_name, vendor, "
                       "generator, layer_count, board_width_mm, "
                       "board_height_mm, board_thickness_mm, creation_date, "
                       "finish, stackup, design_rules, expected_files. "
                       "Omitted when no .gbrjob present."})
    # Entries are free-form dicts.
    zip_archives: Optional[list[dict]] = field(default=None, metadata={
        "description": "Zip archive sweep; each entry: {filename, "
                       "size_bytes, modified (when the file stat succeeds), "
                       "total_files, gerber_files, drill_files, other_files, "
                       "newest_member_date (when any member date parses), "
                       "vs_loose_files (loose_files_newer | archive_newer | "
                       "same_age), age_delta_hours (unless same_age), error "
                       "(when the archive cannot be read)}. Omitted when no "
                       ".zip files in the directory."})

    # --- --full mode additions ---
    # Entries are free-form dicts.
    connectivity: Optional[list[dict]] = field(default=None, metadata={
        "description": "Flat pin-to-net list from X2 attributes (--full "
                       "only). Each item: {ref, pin, pin_name, net}."})

    # --- 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."})
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