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

View on GitHub
"""Canonical run-level capability_mode.json writer.

First-writer-wins pattern: the first analyzer in a run creates
analysis/capability_mode.json; subsequent analyzers in the same run
read it and embed only a capability_mode_ref pointer in their envelopes.
"""
from __future__ import annotations

import json
import os
import sys
import tempfile
import time
from pathlib import Path
from typing import Optional

from run_id import generate_run_id
from kicad_core.fileio import json_loads
from kicad_core.diagnostics import record as record_diagnostic

_SCHEMAS_DIR = Path(__file__).resolve().parent.parent.parent / "datasheets" / "schemas"


CAPABILITY_MODE_FILENAME = "capability_mode.json"


def _read_capability_mode(path: Path) -> Optional[dict]:
    """Read an existing capability_mode.json, tolerating a transient
    partial or unreadable file.

    Returns the parsed record, or None if the file can't be read as
    valid JSON after a few short retries. Caller then falls through to
    write its own via os.link — which will succeed (creating a fresh
    valid record) only if the corrupt file no longer exists at write
    time. **No self-heal under os.link first-writer-wins**: if the
    corrupt file persists on disk, os.link raises FileExistsError, the
    caller falls back to re-reading, and the retry loop here will keep
    returning None on the same corrupt content (unparseable JSON). This
    is distinct from valid-but-foreign JSON (e.g. an analyzer envelope
    written to this path by external tooling, not through this module)
    — that case parses fine here and is no longer treated as a wedge;
    see _is_valid_record, which rejects it downstream and the
    caller bypasses it with a fresh in-memory record instead of raising
    or giving up.
    The 5-retry x 5ms sleep window tolerates a file another process is
    still writing or has left partial. This module's own writer never
    exposes one: it closes the complete record before os.link publishes it.
    """
    for _ in range(5):
        try:
            return json_loads(path.read_text(encoding="utf-8"))
        except (ValueError, FileNotFoundError, OSError):
            time.sleep(0.005)
    return None


def _is_valid_record(rec) -> bool:
    """A capability_mode record is a dict with a non-empty string run_id.

    Anything else at the sidecar path (an analyzer envelope, a list, a bare
    string) must not be adopted as the run record: indexing
    record["run_id"] on such a file crashed every analyzer at startup.
    """
    return isinstance(rec, dict) and isinstance(rec.get("run_id"), str) and bool(rec["run_id"])


def _warn_malformed(path: Path, rec) -> None:
    kind = type(rec).__name__ if not isinstance(rec, dict) else "dict without a string run_id"
    print(f"Warning: {path} is not a capability_mode record ({kind}); "
          f"leaving it untouched and using a fresh in-memory run_id",
          file=sys.stderr)


def _detect_datasheet_status(cache_dir: Optional[Path] = None) -> str:
    """Return one of 'verified' | 'partial' | 'heuristic_fallback' | 'unavailable'.

    A minimal check: it looks only at whether extractions are present, not at
    their schema_version.
    """
    if cache_dir is None:
        cache_dir = Path("datasheets/extracted")
    if not cache_dir.exists():
        return "unavailable"
    extractions = list(cache_dir.glob("*.json"))
    if not extractions:
        return "heuristic_fallback"
    # Heuristic: at least one extraction counts as "partial"
    return "partial"


def _compute_coverage_pct(cache_dir: Optional[Path] = None) -> int:
    """Percentage of the parts in the distributor manifest (``datasheets/manifest.json``,
    the schematic's parts as the last sync recorded them) that have an extraction in
    ``cache_dir``. 0 when the manifest, its parts or the folder are missing."""
    if cache_dir is None:
        cache_dir = Path("datasheets/extracted")
    ds_scripts = str(Path(__file__).resolve().parents[2] / "datasheets" / "scripts")
    if ds_scripts not in sys.path:
        sys.path.insert(0, ds_scripts)
    try:
        from datasheet_extract_cache import find_extraction
        from datasheet_types.cache_reader import read_json_object
    except ImportError:
        return 0
    manifest = read_json_object(Path(cache_dir).parent / "manifest.json")
    parts = manifest.get("parts") if manifest else None
    if not isinstance(parts, dict) or not parts:
        return 0
    have = sum(1 for mpn in parts if isinstance(find_extraction(cache_dir, mpn)[0], dict))
    return round(100 * have / len(parts))


def _read_schema_versions() -> dict:
    """Read schema_version from each shipped datasheet schema.

    Returns dict like {"base": "1.0", "regulator": "0.3", "diode": "1.0", ...}.
    Resolved from this file's location so the result does not depend on the cwd.
    """
    schemas_dir = _SCHEMAS_DIR
    versions: dict = {}
    if not schemas_dir.exists():
        return versions
    for schema_path in schemas_dir.glob("*.schema.json"):
        try:
            data = json.loads(schema_path.read_text(encoding="utf-8"))
        except (json.JSONDecodeError, OSError):
            continue
        title = schema_path.stem.replace(".schema", "")
        # Schemas store version in top-level "x-schema-version" key
        sv = data.get("x-schema-version")
        if sv:
            versions[title] = sv
    return versions


def _fresh_record(datasheet_extraction, cache_dir, llm_review_status, schema_versions) -> dict:
    return {
        "run_id": generate_run_id(),
        "datasheet_extraction": datasheet_extraction or _detect_datasheet_status(cache_dir),
        "datasheet_coverage_pct": _compute_coverage_pct(cache_dir),
        "llm_review": llm_review_status,
        "insertion_points_active": [],
        "schema_versions": schema_versions or _read_schema_versions(),
        "platform": "claude-code",
        "tier_map": {},
    }


def get_or_create_capability_mode(
    analysis_dir,
    *,
    llm_review_status: str = "disabled",
    datasheet_extraction: Optional[str] = None,
    schema_versions: Optional[dict] = None,
    cache_dir: Optional[Path] = None,
) -> dict:
    """Return the canonical capability_mode record for analysis_dir, creating it if absent.

    First-writer-wins: subsequent calls return the existing record verbatim,
    NOT updating fields. Updates require explicit refresh by the orchestrator
    (e.g., when llm_review transitions from disabled to active mid-run).
    """
    analysis_dir = Path(analysis_dir)
    path = analysis_dir / CAPABILITY_MODE_FILENAME
    if path.exists():
        existing = _read_capability_mode(path)
        if existing is not None:
            if _is_valid_record(existing):
                return existing
            # Parses, but is not ours — never crash the analysis
            # over a sidecar; do not overwrite someone else's file either.
            _warn_malformed(path, existing)
            return _fresh_record(datasheet_extraction, cache_dir,
                                 llm_review_status, schema_versions)
        # exists() is True but the file isn't valid JSON yet — most likely
        # another process or external tool left a partial file (our own
        # writer never exposes one at this path). Fall through and try to write our own.
        # If we win the os.link race, the file is now our valid record.
        # If we lose (FileExistsError), we re-read the winner's record —
        # which will succeed if the racing writer completed, or return
        # the original record stub if the file was externally corrupted
        # (no self-heal under os.link first-writer-wins; see
        # _read_capability_mode docstring for recovery).
    record = _fresh_record(datasheet_extraction, cache_dir, llm_review_status, schema_versions)
    try:
        analysis_dir.mkdir(parents=True, exist_ok=True)
        fd, tmp_path = tempfile.mkstemp(dir=analysis_dir, prefix=".capmode-", suffix=".tmp")
    except OSError as exc:
        # A read-only directory (sandbox, read-only checkout) must not fail the analysis.
        record_diagnostic(None, "capability_mode.get_or_create_capability_mode", exc,
                          f"{CAPABILITY_MODE_FILENAME} not written, in-memory record used")
        return record
    # Atomic create: stage the full record to a temp file in the same
    # directory, then os.link() it into place. os.link raises
    # FileExistsError if the target already exists, so it is an atomic
    # exclusive-create — this gives BOTH guarantees the old non-atomic
    # write_text() lacked:
    #   1. no partial read — the content is fully written before linking,
    #      so a concurrent reader never sees a half-written file (the old
    #      code could crash a reader with JSONDecodeError mid-write);
    #   2. true first-writer-wins — if two analyzers race past the
    #      exists() check above, exactly one os.link() succeeds; the loser
    #      reads the winner's record, so every analyzer in the run shares
    #      one run_id (HI-7).
    try:
        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as f:
            f.write(json.dumps(record, indent=2, sort_keys=True) + "\n")
        try:
            os.link(tmp_path, path)
        except FileExistsError:
            # Another analyzer won the race — return its record, not ours.
            winner = _read_capability_mode(path)
            if _is_valid_record(winner):
                return winner
            if winner is not None:
                _warn_malformed(path, winner)
            return record
    except OSError as exc:
        # Full disk, or a filesystem without hard links (FAT, exFAT).
        record_diagnostic(None, "capability_mode.get_or_create_capability_mode", exc,
                          f"{CAPABILITY_MODE_FILENAME} not written, in-memory record used")
        return record
    finally:
        try:
            os.unlink(tmp_path)
        except OSError:
            pass
    return record


def get_capability_mode_ref(analysis_dir, **kwargs) -> dict:
    """Return a {source, run_id} pointer for embedding in analyzer envelopes.

    Side-effect: ensures capability_mode.json exists (first-writer-wins).
    """
    record = get_or_create_capability_mode(analysis_dir, **kwargs)
    return {
        "source": f"analysis/{CAPABILITY_MODE_FILENAME}",
        "run_id": record["run_id"],
    }
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