Designer commands
Every command of the designer as the edsnx command line, JSON-RPC, MCP and the script API see it.
Every command of the designer, as the edsnx CLI (edsnx <cli words> <path> --flag value), JSON-RPC (method = id),
MCP (tool = id) and the script API see it. Units: millimetres (KiCad coordinates, y grows downwards) and degrees.
Edit commands return newIds (ids of created objects, for chaining), revision and hash; queries return
concise JSON (counts first, limit 200 by default, numbers rounded to 3 decimals). See board AUT-1…AUT-4.
449 commands: Board edits 71, Schematic edits 54, Project 25, Queries 13, Libraries 29, Checks 2, Custom tools 2, Rendering 3, Session 19, Timeline and export 6, Overlays and probes 4, Documentation sheets 7, Review 10, Simulation 10, Footprint edits 19, Symbol edits 16, Requirements and solving 8, Solve loop 7, Multi-board systems 12, Assembly variants 8, Rooms 9, Reuse blocks 6, Pin and gate swap 4, Manufacturer parts 2, BOM cost 1, Rigid-flex and HDI 18, DFM / DFA / DFF profiles 9, Output jobs 6, Releases 4, Panelization 6, Test points 6, Comments 6, Web viewer 1, MCAD co-design 21, Signal and power integrity 16, Gerber engine and viewer 9.
UI-only commands#
These need the open editor (dialogs, view modes); headless runs (edsnx without --attach) refuse them with ui-only.
block.showPanel(softforge.edsnx.reuse.show): Reuse Panelcomment.showPanel(softforge.edsnx.comments.show): Comments and Design Review Panelgerber.compareReview(softforge.edsnx.gerber.compareReview): Review Gerber vs Gerbergerber.openSet(softforge.edsnx.gerber.openSet): Open fab set…lib.footprintModels(softforge.edsnx.model3d.footprintModels): 3D models of the footprintlib.manage(softforge.edsnx.libraries.manage): Manage librarieslib.openModel3d(softforge.edsnx.model3d.open): Open 3D modelpcb.addComponentDialog(softforge.edsnx.addComponent): Add Component dialogpcb.autorouteDialog(softforge.edsnx.autoroute): Autoroute dialogpcb.editInPlace(softforge.edsnx.editInPlace): Edit in Placepcb.openBoardSetup(softforge.edsnx.boardSetup): Board Setup dialogpcb.routersPage(softforge.edsnx.routers.show): Routers pagepcb.routingOptions(softforge.edsnx.routingOptions): Routing optionspcb.view2d(softforge.edsnx.view2d): 2D viewpcb.view3d(softforge.edsnx.view3d): 3D viewproject.details(softforge.edsnx.project.details): Project detailsproject.importReport(softforge.edsnx.interop.showReport): Show import reportproject.openBom(softforge.edsnx.bom): BOM dialogproject.openFabOutputs(softforge.edsnx.fabOutputs): Fabrication Outputs dialogrelease.openDialog(softforge.edsnx.release): Release…sch.cleanupWiresDialog(softforge.edsnx.cleanupWires): Clean up wiressch.editInPlace(softforge.edsnx.editInPlace): Edit in Placesch.openFieldsTable(softforge.edsnx.fieldsTable): Symbol Fields Tablesch.pageSettings(softforge.edsnx.pageSettings): Page settingssch.wiresPanel(softforge.edsnx.wiresPanel): Wires panelsession.gettingStarted(softforge.edsnx.gettingStarted): Getting startedsession.openDesignFile(softforge.edsnx.design.openDesignFile): Open design filesession.panels.reveal(softforge.edsnx.panels.reveal): Show a workbench viewsession.preferences(softforge.edsnx.preferences): Preferencessession.toolGallery(softforge.edsnx.toolGallery): Tool gallerysession.welcome(softforge.edsnx.welcome): Welcomesi.showPanel(softforge.edsnx.si.show): SI/PI Panelsolve.openDialog(softforge.edsnx.solve): Solve Requirements…system.open3d(softforge.edsnx.system.open3d): Open 3D assemblytimeline.export: Export playbacktimeline.pause: Pausetimeline.play: Playtimeline.seek: Seekvariant.openDialog(softforge.edsnx.variants): Variants…
Board edits#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
pcb.addArcTrack | edsnx pcb add-arc-track | edit | Add arc track. Add an arc track through start, mid and end (mm). Edits the board as one undo step; returns newIds, revision and hash. | path: string, layer: string, start: [x, y], mid: [x, y], end: [x, y], width: number, net?: string | integer | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addComponentDialogsoftforge.edsnx.addComponent | edsnx pcb add-component-dialog | ui | Add Component dialog. Open the Add Component dialog. Agents: use lib.search then pcb.placeFootprint / sch.placeSymbol. UI-only: needs the open editor. | path?: string | object |
pcb.addDimension | edsnx pcb add-dimension | edit | Add dimension. Add a dimension (aligned, orthogonal, leader, center, radial) through pts (mm). Edits the board as one undo step; returns newIds, revision and hash. | path: string, kind: “aligned” | “orthogonal” | “leader” | “center” | “radial”, layer: string, pts: [x, y][], height?: number, units?: “mm” | “in” | “mils”, precision?: integer, orientation?: “horizontal” | “vertical” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addGraphic | edsnx pcb add-graphic | edit | Add graphic. Add a line, rect (2 points), circle (centre, point on circle), arc (start, mid, end), poly or (schematic) bezier. Width in mm; board footprint graphics with footprintId. Edits the board as one undo step; returns newIds, revision and hash. | path: string, kind: “line” | “rect” | “circle” | “arc” | “poly” | “bezier”, layer: string, pts: [x, y][], width: number, fill?: boolean, footprintId?: string, style?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addNet | edsnx pcb add-net | edit | Add net. Add a net by name (KiCad ≤ 9 net table; KiCad 10 boards create nets when an item names them). Edits the board as one undo step; returns newIds, revision and hash. | path: string, name: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addText | edsnx pcb add-text | edit | Add text. Add a text at at (mm), rotation in degrees, size [w, h] mm. Edits the board as one undo step; returns newIds, revision and hash. | path: string, layer: string, at: [x, y], rot: number, text: string, size: [x, y], thickness: number, mirror?: boolean, footprintId?: string, knockout?: boolean, bold?: boolean, italic?: boolean, justify?: “left” | “center” | “right” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addTextBox | edsnx pcb add-text-box | edit | Add text box. Add a text box between corners a and b (mm); the text word-wraps to the box. Board: knockout, border, margins [l, t, r, b], justify, valign, rot, footprintId. Edits the board as one undo step; returns newIds, revision and hash. | path: string, layer: string, a: [x, y], b: [x, y], text: string, size: [x, y], thickness: number, style?: object, knockout?: boolean, border?: boolean, margins?: [x0, y0, x1, y1], justify?: “left” | “center” | “right”, valign?: “top” | “center” | “bottom”, rot?: number, footprintId?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addTrack | edsnx pcb add-track | edit | Add track. Add a track polyline: one segment per consecutive pair of points, on one copper layer. Width in mm. newIds are the segments. Edits the board as one undo step; returns newIds, revision and hash. | path: string, layer: string, pts: [x, y][], width: number, net?: string | integer | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addVia | edsnx pcb add-via | edit | Add via. Add a via at at (mm) between two copper layers; size and drill in mm; kind through (default), blind or micro. Edits the board as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], size: number, drill: number, layers: string[], net?: string | integer, kind?: “through” | “blind” | “micro” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.addZone | edsnx pcb add-zone | edit | Add zone. Add a copper zone or rule area (keepout) with the given outline (≥ 3 points, mm). Fill it with pcb.fillZones. Edits the board as one undo step; returns newIds, revision and hash. | path: string, pts: [x, y][], zone: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.align | edsnx pcb align | edit | Align. Align board items (footprints, tracks, vias, graphics, zones) by their bounding boxes read from the board: left/right/top/bottom edges or centres (centerX: same x, centerY: same y), to the extent of the selection (default) or of the first item, which then stays. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], mode: “left” | “right” | “top” | “bottom” | “centerX” | “centerY”, to?: “selection” | “first” = “selection”, bounds?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.alignItems | edsnx pcb align-items | edit | Align items. Align items: left/right/top/bottom edges or centres (centerX: same x, centerY: same y) to the extent of the selection (default) or of the first item. bounds (id → [minX, minY, maxX, maxY] mm) gives item boxes; without it the anchors are used (pcb.align fills it from the board). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], mode: “left” | “right” | “top” | “bottom” | “centerX” | “centerY”, to?: “selection” | “first” = “selection”, bounds?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.applyNetlist | edsnx pcb apply-netlist | edit | Apply netlist. Update the board from a KiCad s-expression netlist text (prefer project.updatePcb, which exports it). Edits the board as one undo step; returns newIds, revision and hash. | path: string, netlistText: string, options?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.array | edsnx pcb array | edit | Create array. KiCad’s Create Array: copies of the items on a grid (cols × rows cells at pitch [dx, dy] mm, the original is cell (0, 0), copies row by row) or on a circle (count items in all over angle degrees about center: a full turn spreads them by angle / count, a partial arc by angle / (count − 1); rotate turns the copies). Footprint copies get the next free references of their prefix unless renumber is false. newIds are the copies. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], kind: “grid” | “circular”, cols?: integer, rows?: integer, pitch?: [x, y], count?: integer, center?: [x, y], angle?: number, rotate?: boolean, renumber?: boolean = true | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.arrayItems | edsnx pcb array-items | edit | Create array. KiCad’s Create Array: copies of the items on a grid (cols × rows, pitch [dx, dy] mm) or on a circle (count copies over angle degrees about center, rotate turns the copies). The originals are the first cell; newIds are the copies. renumber gives footprint copies the next free references. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], kind: “grid” | “circular”, cols?: integer, rows?: integer, pitch?: [x, y], count?: integer, center?: [x, y], angle?: number, rotate?: boolean, renumber?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.autoposition | edsnx pcb autoposition | edit | Autoposition labels. Place the labels of symbols / footprints around their group box: Altium’s eight positions (leftAbove, centerAbove, rightAbove, leftCenter, rightCenter, leftBelow, centerBelow, rightBelow) or KiCad’s default (kicad: the side with the fewest pins); horizontal, justified away from the box, stacked. fields defaults to the visible, unlocked labels. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], preset: “leftAbove” | “centerAbove” | “rightAbove” | “leftCenter” | “rightCenter” | “leftBelow” | “centerBelow” | “rightBelow” | “kicad”, fields?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.autoroute | edsnx pcb autoroute | edit | Autoroute. Route a board (or nets, net classes, an area, given items) with a router provider (built-in, Freerouting, add-ons: see pcb.autoroute.providers) and apply the result as one undo step “Autoroute (conformance runs the provider conformance suite (7 cases) on the board or the sample project and prints a table (format json: the report). | path?: string, provider?: string = “builtin”, nets?: string[], classes?: string[], area?: [x, y][], areaLayers?: string[], ids?: string[], options?: object, budget?: any, passes?: integer, preserve?: boolean = true, excludeLocked?: boolean = true, apply?: boolean = true, conformance?: string, format?: “table” | “json” = “table” | object |
pcb.autoroute.cancel | edsnx pcb autoroute cancel | session | Cancel autoroute. Cancel autoroute runs in progress in this session or the attached editor: the run with runId, or all. Returns the cancelled run ids. | runId?: string | object |
pcb.autoroute.providers | edsnx pcb autoroute providers | query | Router providers. The router providers available to pcb.autoroute: id, name, vendor, version, origin (builtin, addon, tool), capabilities (diff pairs, length matching, shove, blind/buried and micro vias, layers, area, incremental, cancel, progress), licence state (free, licensed, trial with days left, unlicensed with buy/trial links, error) and the options schema; plus known providers that are not installed (catalogue). Conformance cases: routes-sample-board, respects-scope-nets, respects-locked, cancels, reports-progress, drc-clean-result, preserves-existing. | catalogue?: boolean = true | object |
pcb.autorouteDialogsoftforge.edsnx.autoroute | edsnx pcb autoroute-dialog | ui | Autoroute dialog. Open the Autoroute dialog (provider, scope, options, budget, progress, review). Agents: use pcb.autoroute. UI-only: needs the open editor. | path?: string | object |
pcb.batch | edsnx pcb batch | edit | Batch. Apply several intents as one undo step (rolled back entirely on the first failure). Edits the board as one undo step; returns newIds, revision and hash. | path: string, label: string, intents: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.delete | edsnx pcb delete | edit | Delete. Delete items. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.distribute | edsnx pcb distribute | edit | Distribute. Distribute board items along x or y by their bounding boxes read from the board: equal gaps between the boxes (default) or equal spacing of the centres. The two outer items stay; fewer than three items do not move. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], axis: “x” | “y”, by?: “gaps” | “centers” = “gaps”, bounds?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.distributeItems | edsnx pcb distribute-items | edit | Distribute items. Distribute items along x or y with equal gaps between their boxes (default) or equal spacing of their centres; the two outer items stay. bounds as for alignItems. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], axis: “x” | “y”, by?: “gaps” | “centers” = “gaps”, bounds?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.dragSegment | edsnx pcb drag-segment | edit | Drag segment. Drag board copper with the interactive drag engine, DRC-aware: action drag (a segment along its normal, or an arc’s bulge) | corner | via | run (collinear chain) | net (every track and via of a net; pad ends stretch) | bus (parallel segments ids, pitch kept) | break | moveEnd | slide | toArc | retrace (net class width and via size along the run) | reroute (pts replaces the old path between its ends, loop removal). The grip is grip, else end (start | end), else the item’s middle; the cursor goes to to or grip + by (mm). mode: ignore (collisions allowed only with allowViolations) | stop (up to the first obstacle) | walkaround | hug | shove | shoveHug; angle: keep45 | free | keepArcs. Zones of the dirty region are healed (heal). One undo step; drag reports the resolved mode, shoved items and collisions; a refused move fails with check-failed. | path: string, action?: “drag” | “corner” | “via” | “run” | “net” | “bus” | “break” | “moveEnd” | “slide” | “toArc” | “retrace” | “reroute” = “drag”, id?: string, ids?: string[], net?: string, grip?: [x, y], end?: “start” | “end”, to?: [x, y], by?: [x, y], mode?: “ignore” | “stop” | “walkaround” | “hug” | “shove” | “shoveHug” = “shove”, angle?: “keep45” | “free” | “keepArcs” = “keep45”, heal?: boolean = true, allowViolations?: boolean = false, pts?: [x, y][], layer?: string, width?: number | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, drag |
pcb.dragTrack | edsnx pcb drag-track | edit | Drag track. KiCad’s 45° drag: move a segment by by along its normal; connected segments follow. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, by: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.duplicate | edsnx pcb duplicate | edit | Duplicate. Copy items, offset by by (mm); newIds are the copies. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], by: [x, y], withWires?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.editGroup | edsnx pcb edit-group | edit | Edit symbol / footprint in place. Apply library editor intents (sym.* / fp.* ops and move / rotate / flip / delete, in the library editor’s frame: symbol mm y up, footprint mm) to the instance’s own symbol | path: string, id: string, intents: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.editInPlacesoftforge.edsnx.editInPlace | edsnx pcb edit-in-place | ui | Edit in Place. Enter isolation mode on the selected footprint (double-click it): pads, graphics and texts edited in place with the courtyard handles, the rest of the board dimmed. Agents: use pcb.editGroup / pcb.resizeGroup / pcb.setLabelAnchor / pcb.updateLibraryFromInstance. UI-only: needs the open editor. | path?: string | object |
pcb.fillZonessoftforge.edsnx.fillZones | edsnx pcb fill-zones | edit | Fill zones. Recompute the filled areas of zones (all when ids is omitted) with the native zone filler. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.flip | edsnx pcb flip | edit | Flip. Flip items to the other board side (mirrored about the vertical axis through about or their centre). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], about?: [x, y], wires?: “rubberband” | “reroute” | “detach”, vertical?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.flipToBack | edsnx pcb flip-to-back | edit | Flip to back. Flip the front-side items among ids to the back side, each about its own position (layers swapped, geometry mirrored); items already on the back are left alone. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.group | edsnx pcb group | edit | Group. Group board items (a pad or a footprint text stands for its footprint; a group uuid nests that group). Items leave the group they were in; a group left empty is removed. Writes (group "name" (uuid …) (members …)); newIds = [group uuid]. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], name?: string, locked?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.groupItems | edsnx pcb group-items | edit | Group. Group board items: writes a (group "name" (uuid …) (members …)); newIds = [group uuid]. Items already in a group leave it. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], name?: string, locked?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.healZones | edsnx pcb heal-zones | edit | Heal zones. Refill the filled zones whose outline meets region inside that region only (the rest of each fill is kept; islands removed by the zone rule), as a drag commit does. layers limits the copper layers, ids the zones. Unfilled zones and keepouts are left alone. Edits the board as one undo step; returns newIds, revision and hash. | path: string, region: [x0, y0, x1, y1], layers?: string[], ids?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.lock | edsnx pcb lock | edit | Lock. Lock board items so tools do not move them (locked false unlocks). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], locked?: boolean = true | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.move | edsnx pcb move | edit | Move. Move items by a vector (mm). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], by: [x, y], wires?: “rubberband” | “reroute” | “detach” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.moveFootprint | edsnx pcb move-footprint | edit | Move footprint with its tracks. Move, rotate and flip footprints (by ids or refs) with their attached copper, as the move tool does: by [dx, dy] mm or to [x, y] (the first footprint’s origin), rotate degrees counter-clockwise and flip (other side) about the first footprint (or about). tracks adapts the attached tracks: rubberBand (stretch and re-corner at 45°, default), reroute (rip and route again with the walkaround router), ripUp (delete; the ratsnest shows), keep (leave them). A pad that changes side reaches its track through a via of the net class. Tracks between the moved footprints move rigidly. shove pushes footprints whose courtyards overlap; checks warn (default: apply and list the placement issues), strict (refuse a move with issues) or off. One undo step. | path: string, ids?: string[], refs?: string[], by?: [x, y], to?: [x, y], rotate?: number, flip?: boolean, about?: [x, y], tracks?: “rubberBand” | “reroute” | “ripUp” | “keep”, shove?: boolean, checks?: “warn” | “strict” | “off” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, issues, runs, shoved |
pcb.moveTracks | edsnx pcb move-tracks | edit | Move tracks. Replace segment polylines (pts [] deletes) and move vias, as push-and-shove does. Edits the board as one undo step; returns newIds, revision and hash. | path: string, changes: object[], vias?: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.openBoardSetupsoftforge.edsnx.boardSetup | edsnx pcb open-board-setup | ui | Board Setup dialog. Open the Board Setup dialog (layers, stack-up, rules, net classes). Agents: use project.boardSetup.get/set. UI-only: needs the open editor. | path?: string | object |
pcb.placeFootprint | edsnx pcb place-footprint | edit | Place footprint. Place library footprint lib:name at at (mm) with rotation rot (degrees) on F.Cu or B.Cu, with reference/value and optional pad nets ({ “1”: “GND” }). newIds = [footprint uuid]. Edits the board as one undo step; returns newIds, revision and hash. | path: string, lib: string, name: string, at: [x, y], rot?: number = 0, layer?: “F.Cu” | “B.Cu” = “F.Cu”, ref?: string, value?: string, padNets?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.replaceFootprint | edsnx pcb replace-footprint | edit | Change footprint. Replace a footprint by library footprint lib:name, keeping position, reference, value and pad nets. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, lib: string, name: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.resizeGroup | edsnx pcb resize-group | edit | Resize group box. Resize the group box of a symbol (body rectangle, edges on the 1.27 mm grid) or footprint (courtyard / fabrication outline) to [minX, minY, maxX, maxY] in the group’s local frame (mm, y down, unrotated): pins and pads on an edge follow it, labels keep their offset to their anchor (auto: re-placed with their preset). A local override. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, box: [x0, y0, x1, y1], auto?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.revertToLibrary | edsnx pcb revert-to-library | edit | Revert to library. Drop the local override of a symbol / footprint: it draws its library item again (wires on moved pins follow). Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.rotate | edsnx pcb rotate | edit | Rotate. Rotate items by deg degrees (counter-clockwise as KiCad shows it) about about or their centre. Schematic rotations snap to 90°. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], deg: number, about?: [x, y], wires?: “rubberband” | “reroute” | “detach” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.route | edsnx pcb route | edit | Route. Route a net along a polyline on one copper layer (one track segment per pair of points, mm) and optionally drop vias at given points. Width and via sizes default to the net class, then the board defaults. One undo step; newIds are the segments then the vias. | path: string, layer: string, pts: [x, y][], width?: number, net?: string | integer, vias?: array | object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.routersPagesoftforge.edsnx.routers.show | edsnx pcb routers-page | ui | Routers page. Open the Routers page (providers, capabilities, licences, install / buy / trial links). Agents: use pcb.autoroute.providers. UI-only: needs the open editor. | path?: string | object |
pcb.routingOptionssoftforge.edsnx.routingOptions | edsnx pcb routing-options | ui | Routing options. Open the interactive router options. Agents: use pcb.route. UI-only: needs the open editor. | path?: string | object |
pcb.setAttrs | edsnx pcb set-attrs | edit | Set attributes. Generic attribute edit; keys follow Item.attrs from query.items (width, size, drill, layer, layers, net, text, rot, at, …). mm and degrees. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, attrs: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setBoardSetup | edsnx pcb set-board-setup | edit | Board setup. Change board setup: layers, stack-up, design rules, defaults, severities (board file and .kicad_pro). Edits the board as one undo step; returns newIds, revision and hash. | path: string, setup: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setDiffPairs | edsnx pcb set-diff-pairs | edit | Differential pairs. Replace the explicit differential pair table (.kicad_pro). Edits the board as one undo step; returns newIds, revision and hash. | path: string, pairs: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setGroupRigid | edsnx pcb set-group-rigid | edit | Set group rigid. Make a placed symbol / footprint rigid (its labels move only with it) or flexible (labels can be moved one by one and keep their anchored offset); null removes the flag so the softforge.edsnx.symbolGroups.defaultRigid setting decides. Stored as a hidden instance property KiCad keeps. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, rigid: boolean | null | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setLabelAnchor | edsnx pcb set-label-anchor | edit | Set label anchor. One label of a symbol / footprint (field name; board free text by its id fpt:at (mm; refused while the group is rigid or the label locked), or, on a board, KiCad’s Keep upright of the text (upright; false writes (unlocked yes)). Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, field: string, anchor?: “nw” | “n” | “ne” | “w” | “c” | “e” | “sw” | “s” | “se” | null, locked?: boolean, preset?: “leftAbove” | “centerAbove” | “rightAbove” | “leftCenter” | “rightCenter” | “leftBelow” | “centerBelow” | “rightBelow” | “kicad” | null, at?: [x, y], upright?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setLocked | edsnx pcb set-locked | edit | Lock / unlock. Lock or unlock board items (locked items are not moved by tools). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[], locked: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setMatchedGroups | edsnx pcb set-matched-groups | edit | Matched length groups. Replace the matched length groups (.kicad_pro). Edits the board as one undo step; returns newIds, revision and hash. | path: string, groups: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setNetClasses | edsnx pcb set-net-classes | edit | Net classes. Replace the net classes (.kicad_pro); sizes in mm. Edits the board as one undo step; returns newIds, revision and hash. | path: string, netClasses: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setPad | edsnx pcb set-pad | edit | Edit pad. Edit one pad of a footprint (by number or pad uuid): shape, type, number, size [w, h], drill (Ø or [w, h]), layers, roundRatio, net. Edits the board as one undo step; returns newIds, revision and hash. | path: string, footprintId: string, pad: string, attrs: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setPadNet | edsnx pcb set-pad-net | edit | Set pad net. Assign a net to one pad of a footprint (by pad number). Edits the board as one undo step; returns newIds, revision and hash. | path: string, footprintId: string, pad: string, net: string | integer | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setPadStack | edsnx pcb set-pad-stack | edit | Pad padstack. KiCad 9/10 padstack of one pad (number or uuid): mode normal | front_inner_back | custom, and per-layer shape patches (“F.Cu” is the pad itself; “Inner”, “B.Cu” or copper layer names). Keys: shape, size [w, h], offset, roundRatio, chamferRatio, chamfer, rectDelta, zoneConnect, thermalBridgeWidth, thermalGap, thermalAngle, clearance. Edits the board as one undo step; returns newIds, revision and hash. | path: string, footprintId: string, pad: string, mode: “normal” | “front_inner_back” | “custom”, layers?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setProjectSection | edsnx pcb set-project-section | edit | Project section. Replace softforge.<section> of the .kicad_pro (rooms, blocks, …); null or [] removes it. Prefer room.* / block.*, which keep the board in step. Edits the board as one undo step; returns newIds, revision and hash. | path: string, section: string, value: any | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setProperty | edsnx pcb set-property | edit | Set property. Set a field of a footprint or symbol (Reference, Value, Footprint, Datasheet, user fields). Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, field: string, value: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setTeardrops | edsnx pcb set-teardrops | edit | Teardrops. Remove teardrop zones (all, or ids) and add teardrops with their outlines (mm). Edits the board as one undo step; returns newIds, revision and hash. | path: string, remove?: string | array, add: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.setZone | edsnx pcb set-zone | edit | Edit zone. Change zone settings and/or its outline. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, zone: object, pts?: [x, y][] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.splitTrack | edsnx pcb split-track | edit | Split track. Split a track segment at at (projected onto it); newIds = [the new segment]. Edits the board as one undo step; returns newIds, revision and hash. | path: string, id: string, at: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.swap | edsnx pcb swap | edit | Swap. KiCad’s Swap: two items exchange places. Two footprints exchange position, rotation and board side; other pairs exchange their anchor positions. One undo step. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.unfillZonessoftforge.edsnx.unfillZones | edsnx pcb unfill-zones | edit | Unfill zones. Remove the filled areas of zones (all when ids is omitted). Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.ungroup | edsnx pcb ungroup | edit | Ungroup. Remove groups, given by group uuid or by a member id (its innermost group). The members stay on the board; members of a nested group move up to its parent group. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.ungroupItems | edsnx pcb ungroup-items | edit | Ungroup. Remove groups (by group uuid, or by a member id: its group). The members stay on the board. Edits the board as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.updateLibraryFromInstance | edsnx pcb update-library-from-instance | edit | Update library from instance. Push a symbol’s / footprint’s local override to its library item through the library editor (sym.symSetBody / the .kicad_mod): scope ’library’ writes the library only (the instance keeps its own symbol), ‘all’ also updates every instance of the item in this file. The library file is written by the editor host or the CLI. Edits the board as one undo step; returns newIds, revision and hash. Headless runs also write the library file (returned as library). | path: string, id: string, scope: “library” | “all” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
pcb.view2dsoftforge.edsnx.view2d | edsnx pcb view2d | ui | 2D view. Switch the board editor to the 2D view. UI-only: needs the open editor. | path?: string | object |
pcb.view3dsoftforge.edsnx.view3d | edsnx pcb view3d | ui | 3D view. Switch the board editor to the 3D view. Agents: use project.export3d or the render commands. UI-only: needs the open editor. | path?: string | object |
Examples
pcb.addArcTrackAdd arc track:{"path":"board.kicad_pcb","layer":"F.Cu","start":[10,10],"mid":[12.93,12.93],"end":[10,20],"width":0.25}pcb.addComponentDialogAdd Component dialog:{}pcb.addDimensionAdd dimension:{"path":"board.kicad_pcb","kind":"aligned","layer":"Dwgs.User","pts":[[0,0],[50,0]],"height":5}pcb.addGraphicAdd graphic:{"path":"board.kicad_pcb","kind":"rect","layer":"Edge.Cuts","pts":[[0,0],[50,40]],"width":0.1}pcb.addNetAdd net:{"path":"board.kicad_pcb","name":"SDA"}pcb.addTextAdd text:{"path":"board.kicad_pcb","layer":"F.SilkS","at":[10,5],"rot":0,"text":"v1.0","size":[1,1],"thickness":0.15}pcb.addTextBoxAdd text box:{"path":"board.kicad_pcb","layer":"F.SilkS","a":[0,0],"b":[20,10],"text":"Note","size":[1,1],"thickness":0.15}pcb.addTrackAdd track:{"path":"board.kicad_pcb","layer":"F.Cu","pts":[[10,10],[20,10]],"width":0.25,"net":"GND"}pcb.addViaAdd via:{"path":"board.kicad_pcb","at":[20,10],"size":0.8,"drill":0.4,"layers":["F.Cu","B.Cu"],"net":"GND"}pcb.addZoneAdd zone:{"path":"board.kicad_pcb","pts":[[0,0],[50,0],[50,40],[0,40]],"zone":{"layers":["B.Cu"],"net":"GND"}}pcb.alignAlign three footprints on their top edges:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>","<uuid>"],"mode":"top"}pcb.alignItemsAlign items:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>"],"mode":"left"}pcb.applyNetlistApply netlist:{"path":"board.kicad_pcb","netlistText":"(export (version \"E\") …)","options":{"deleteExtra":false,"replaceFootprints":false,"matchBy":"reference"}}pcb.arrayEight LEDs on a circle:{"path":"board.kicad_pcb","ids":["<uuid>"],"kind":"circular","count":8,"center":[100,100],"angle":360,"rotate":true}pcb.arrayItemsCreate array:{"path":"board.kicad_pcb","ids":["<uuid>"],"kind":"grid","cols":4,"rows":2,"pitch":[2.54,2.54],"renumber":true}pcb.autopositionAutoposition labels:{"path":"board.kicad_pcb","ids":["<uuid>"],"preset":"rightCenter"}pcb.autorouteRoute two nets with the built-in router, refuse new DRC violations:{"path":"board.kicad_pcb","provider":"builtin","nets":["GND","+5V"],"budget":120}pcb.autorouteWhole board with Freerouting, 10 passes:{"path":"board.kicad_pcb","provider":"freerouting","passes":10}pcb.autorouteConformance suite of a provider:{"conformance":"builtin"}pcb.autoroute.cancelCancel every run:{}pcb.autoroute.providersList the providers:{}pcb.autorouteDialogAutoroute dialog:{}pcb.batchBatch:{"path":"board.kicad_pcb","label":"Two moves","intents":[{"op":"move","ids":["<uuid>"],"by":[1,0]},{"op":"move","ids":["<uuid>"],"by":[0,1]}]}pcb.deleteDelete:{"path":"board.kicad_pcb","ids":["<uuid>"]}pcb.distributeSpace three footprints evenly in x:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>","<uuid>"],"axis":"x","by":"centers"}pcb.distributeItemsDistribute items:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>","<uuid>"],"axis":"x"}pcb.dragSegmentDrag a segment 1 mm down, shoving other tracks:{"path":"board.kicad_pcb","action":"drag","id":"<uuid>","by":[0,1],"mode":"shove","angle":"keep45","heal":true,"allowViolations":false}pcb.dragSegmentMove a via, walking its tracks around obstacles:{"path":"board.kicad_pcb","action":"via","id":"<uuid>","to":[52,48],"mode":"walkaround","angle":"keep45","heal":true,"allowViolations":false}pcb.dragTrackDrag track:{"path":"board.kicad_pcb","id":"<uuid>","by":[0,1]}pcb.duplicateDuplicate:{"path":"board.kicad_pcb","ids":["<uuid>"],"by":[5,0]}pcb.editGroupEdit symbol / footprint in place:{"path":"board.kicad_pcb","id":"<uuid>","intents":[{"op":"symEditPin","id":"pin:NE555P_1_1:2","pin":{"name":"TRIG"}}]}pcb.editInPlaceEdit in Place:{}pcb.fillZonesFill zones:{"path":"board.kicad_pcb"}pcb.flipFlip:{"path":"board.kicad_pcb","ids":["<uuid>"]}pcb.flipToBackFlip to back:{"path":"board.kicad_pcb","ids":["<uuid>"]}pcb.groupGroup:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>"],"name":"Power stage","locked":false}pcb.groupItemsGroup:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>"],"name":"Power stage"}pcb.healZonesHeal zones:{"path":"board.kicad_pcb","region":[40,40,60,60]}pcb.lockLock two footprints:{"path":"board.kicad_pcb","ids":["<uuid>","<uuid>"]}pcb.moveMove:{"path":"board.kicad_pcb","ids":["<uuid>"],"by":[2.54,0]}pcb.moveFootprintMove U3 5 mm right, re-routing its tracks:{"path":"board.kicad_pcb","refs":["U3"],"by":[5,0],"tracks":"reroute"}pcb.moveFootprintFlip C4 to the back, stretching its tracks through vias; refuse placement issues:{"path":"board.kicad_pcb","refs":["C4"],"flip":true,"checks":"strict"}pcb.moveTracksMove tracks:{"path":"board.kicad_pcb","changes":[{"id":"<uuid>","pts":[[10,10],[15,15]]}]}pcb.openBoardSetupBoard Setup dialog:{}pcb.placeFootprintPlace footprint:{"path":"board.kicad_pcb","lib":"Resistor_SMD","name":"R_0603_1608Metric","at":[30,20],"rot":90,"ref":"R7","value":"10k"}pcb.replaceFootprintChange footprint:{"path":"board.kicad_pcb","id":"<uuid>","lib":"Resistor_SMD","name":"R_0805_2012Metric"}pcb.resizeGroupResize group box:{"path":"board.kicad_pcb","id":"<uuid>","box":[-10.16,-7.62,10.16,7.62]}pcb.revertToLibraryRevert to library:{"path":"board.kicad_pcb","id":"<uuid>"}pcb.rotateRotate:{"path":"board.kicad_pcb","ids":["<uuid>"],"deg":90}pcb.routeRoute GND from a pad to a via:{"path":"board.kicad_pcb","layer":"F.Cu","net":"GND","pts":[[10,10],[15,10],[15,14]],"vias":[[15,14]]}pcb.routersPageRouters page:{}pcb.routingOptionsRouting options:{}pcb.setAttrsSet attributes:{"path":"board.kicad_pcb","id":"<uuid>","attrs":{"width":0.3}}pcb.setBoardSetupBoard setup:{"path":"board.kicad_pcb","setup":{"rules":{"minClearance":0.2}}}pcb.setDiffPairsDifferential pairs:{"path":"board.kicad_pcb","pairs":[{"name":"USB","p":"USB_D+","n":"USB_D-"}]}pcb.setGroupRigidSet group rigid:{"path":"board.kicad_pcb","id":"<uuid>","rigid":true}pcb.setLabelAnchorSet label anchor:{"path":"board.kicad_pcb","id":"<uuid>","field":"Reference","preset":"centerAbove","locked":true}pcb.setLockedLock / unlock:{"path":"board.kicad_pcb","ids":["<uuid>"],"locked":true}pcb.setMatchedGroupsMatched length groups:{"path":"board.kicad_pcb","groups":[{"name":"DDR","members":[{"net":"DQ0"},{"net":"DQ1"}],"target":"longest","tolerance":0.5}]}pcb.setNetClassesNet classes:{"path":"board.kicad_pcb","netClasses":[{"name":"Default","clearance":0.2,"trackWidth":0.25,"viaDiameter":0.6,"viaDrill":0.3},{"name":"Power","clearance":0.2,"trackWidth":0.5,"viaDiameter":0.8,"viaDrill":0.4,"patterns":["VCC","GND"]}]}pcb.setPadEdit pad:{"path":"board.kicad_pcb","footprintId":"<uuid>","pad":"1","attrs":{"size":[1,1.2]}}pcb.setPadNetSet pad net:{"path":"board.kicad_pcb","footprintId":"<uuid>","pad":"1","net":"GND"}pcb.setPadStackPad padstack:{"path":"board.kicad_pcb","footprintId":"<uuid>","pad":"1","mode":"front_inner_back","layers":{"Inner":{"shape":"circle","size":[1.2,1.2]}}}pcb.setProjectSectionProject section:{"path":"board.kicad_pcb","section":"rooms","value":[{"name":"Timer","sheet":"/<sheet uuid>/","side":"F"}]}pcb.setPropertySet property:{"path":"board.kicad_pcb","id":"<uuid>","field":"Value","value":"10k"}pcb.setTeardropsTeardrops:{"path":"board.kicad_pcb","remove":"all","add":[]}pcb.setZoneEdit zone:{"path":"board.kicad_pcb","id":"<uuid>","zone":{"clearance":0.3}}pcb.splitTrackSplit track:{"path":"board.kicad_pcb","id":"<uuid>","at":[15,10]}pcb.swapSwap R1 and R2:{"path":"board.kicad_pcb","ids":["<uuid R1>","<uuid R2>"]}pcb.unfillZonesUnfill zones:{"path":"board.kicad_pcb"}pcb.ungroupUngroup:{"path":"board.kicad_pcb","ids":["<group uuid>"]}pcb.ungroupItemsUngroup:{"path":"board.kicad_pcb","ids":["<group uuid>"]}pcb.updateLibraryFromInstanceUpdate library from instance:{"path":"board.kicad_pcb","id":"<uuid>","scope":"all"}pcb.view2d2D view:{}pcb.view3d3D view:{}
Schematic edits#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
sch.addBusEntry | edsnx sch add-bus-entry | edit | Add bus entry. Add a wire-to-bus entry with one end at at (mm) and the other at at + size (default [2.54, 2.54]). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], size?: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addGraphic | edsnx sch add-graphic | edit | Add graphic. Add a line, rect (2 points), circle (centre, point on circle), arc (start, mid, end), poly or (schematic) bezier. Width in mm; board footprint graphics with footprintId. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, kind: “line” | “rect” | “circle” | “arc” | “poly” | “bezier”, layer: string, pts: [x, y][], width: number, fill?: boolean, footprintId?: string, style?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addImage | edsnx sch add-image | edit | Add image. Place a PNG bitmap (base64 data) at at (mm) with an optional scale. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], data: string, scale?: number, layer?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addJunction | edsnx sch add-junction | edit | Add junction. Add a junction dot at at (mm). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addLabel | edsnx sch add-label | edit | Add label. Add a net label (local, global, hierarchical or netclass directive) at at (mm), rotation in degrees. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, kind?: “local” | “global” | “hierarchical” | “netclass” = “local”, at: [x, y], rot?: number = 0, text: string, shape?: “input” | “output” | “bidirectional” | “tri_state” | “passive” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addNoConnect | edsnx sch add-no-connect | edit | Add no-connect. Add a no-connect flag on a pin end at at (mm). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addSheet | edsnx sch add-sheet | edit | Add sheet. Add a hierarchical sheet box at at of size (mm) for sheet file file. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], size: [x, y], name: string, file: string, sheetPath?: string, fields?: object, style?: object, borderWidth?: number | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addSheetPin | edsnx sch add-sheet-pin | edit | Add sheet pin. Add a pin to a sheet box at at (mm, on the sheet border). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, sheetId: string, name: string, at: [x, y], shape: “input” | “output” | “bidirectional” | “tri_state” | “passive” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addText | edsnx sch add-text | edit | Add text. Add a text at at (mm), rotation in degrees, size [w, h] mm. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, layer: string, at: [x, y], rot: number, text: string, size: [x, y], thickness: number, mirror?: boolean, footprintId?: string, knockout?: boolean, bold?: boolean, italic?: boolean, justify?: “left” | “center” | “right” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addTextBox | edsnx sch add-text-box | edit | Add text box. Add a text box between corners a and b (mm); the text word-wraps to the box. Board: knockout, border, margins [l, t, r, b], justify, valign, rot, footprintId. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, layer: string, a: [x, y], b: [x, y], text: string, size: [x, y], thickness: number, style?: object, knockout?: boolean, border?: boolean, margins?: [x0, y0, x1, y1], justify?: “left” | “center” | “right”, valign?: “top” | “center” | “bottom”, rot?: number, footprintId?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addWire | edsnx sch add-wire | edit | Add wire. Add a wire (or bus) polyline: one segment per consecutive pair of points (mm, on the 1.27 mm grid). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, pts: [x, y][], bus?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.addWireVertex | edsnx sch add-wire-vertex | edit | Add wire vertex. Add a vertex on a wire at at (mm): a two-point wire is split there, a multi-point wire gets a point. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, at: [x, y] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.alignWires | edsnx sch align-wires | edit | Align wires. Drag the wires parallel to the first one onto its line; their neighbours stretch and connections are kept (as dragWireSegment). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.annotatesoftforge.edsnx.annotate | edsnx sch annotate | edit | Annotate. Assign reference numbers (all, or only unannotated symbols) in this file. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, scope?: “all” | “unannotated” = “unannotated”, options?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.autoWire | edsnx sch auto-wire | edit | Auto Wire. Route a wire from pts[0] to pts[1] on the 1.27 mm grid around symbols, pins and wires (A*, Altium Auto Wire / Capture Auto Wire); it touches no other pin or wire end and never overlaps a wire. Further points join the new wires (multiple points, a junction where they land). With bus the last point is on a bus: the wire ends on a new bus entry there, labelled bus.label. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, pts: [x, y][], crossingAvoidance?: number, avoidPinEnds?: “always” | “off”, bus?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.autoposition | edsnx sch autoposition | edit | Autoposition labels. Place the labels of symbols / footprints around their group box: Altium’s eight positions (leftAbove, centerAbove, rightAbove, leftCenter, rightCenter, leftBelow, centerBelow, rightBelow) or KiCad’s default (kicad: the side with the fewest pins); horizontal, justified away from the box, stacked. fields defaults to the visible, unlocked labels. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], preset: “leftAbove” | “centerAbove” | “rightAbove” | “leftCenter” | “rightCenter” | “leftBelow” | “centerBelow” | “rightBelow” | “kicad”, fields?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.batch | edsnx sch batch | edit | Batch. Apply several intents as one undo step (rolled back entirely on the first failure). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, label: string, intents: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.cleanupWires | edsnx sch cleanup-wires | edit | Clean up wires. Clean up schematic wires without changing connectivity: remove zero-length and duplicate wires, merge collinear wires meeting end to end, remove junctions joining fewer than three connections and add missing ones, optionally snap dangling ends onto the grid. ids limits it to those wires. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids?: string[], zeroLength?: boolean = true, duplicates?: boolean = true, merge?: boolean = true, junctions?: boolean = true, grid?: boolean = false | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.cleanupWiresDialogsoftforge.edsnx.cleanupWires | edsnx sch cleanup-wires-dialog | ui | Clean up wires. Clean up wires of the active schematic (merge collinear, zero-length, duplicates, junctions). Agents: use sch.cleanupWires. UI-only: needs the open editor. | path?: string | object |
sch.clearAnnotationsoftforge.edsnx.clearAnnotation | edsnx sch clear-annotation | edit | Clear annotation. Reset references to “R?” (all symbols, or ids). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids?: string[], sheetPath?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.convertWires | edsnx sch convert-wires | edit | Convert wire / bus. Turn wires into buses (to: "bus") or buses into wires (to: "wire"), keeping their points. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], to: “bus” | “wire” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.delete | edsnx sch delete | edit | Delete. Delete items. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.dragWireSegment | edsnx sch drag-wire-segment | edit | Drag wire segment. Drag a schematic wire segment by by (mm): it moves perpendicular to itself, neighbouring wires stretch and every connection is kept (corners, junctions, labels follow). With end (0 or 1) that end slides along the segment. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, by: [x, y], end?: 0 | 1 | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.duplicate | edsnx sch duplicate | edit | Duplicate. Copy items, offset by by (mm); newIds are the copies. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], by: [x, y], withWires?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.editGroup | edsnx sch edit-group | edit | Edit symbol / footprint in place. Apply library editor intents (sym.* / fp.* ops and move / rotate / flip / delete, in the library editor’s frame: symbol mm y up, footprint mm) to the instance’s own symbol | path: string, id: string, intents: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.editInPlacesoftforge.edsnx.editInPlace | edsnx sch edit-in-place | ui | Edit in Place. Enter isolation mode on the selected symbol (double-click its body): body, pins and labels edited in place, the rest dimmed; Enter / click outside applies, Esc cancels. Agents: use sch.editGroup / sch.resizeGroup / sch.setLabelAnchor / sch.updateLibraryFromInstance. UI-only: needs the open editor. | path?: string | object |
sch.flip | edsnx sch flip | edit | Flip. Mirror items horizontally (or vertically with vertical) about about or their centre. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], about?: [x, y], wires?: “rubberband” | “reroute” | “detach”, vertical?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.label | edsnx sch label | edit | Label. Name a net with a label at a wire point (mm); kind local (default), global, hierarchical or netclass; rot in degrees (default 0). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, kind?: “local” | “global” | “hierarchical” | “netclass” = “local”, at: [x, y], rot?: number = 0, text: string, shape?: “input” | “output” | “bidirectional” | “tri_state” | “passive” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.mergeWires | edsnx sch merge-wires | edit | Merge wires. Merge collinear wires that meet end to end with nothing else at the joint (all wires, or ids). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.move | edsnx sch move | edit | Move. Move items by a vector (mm). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], by: [x, y], wires?: “rubberband” | “reroute” | “detach” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.moveSymbol | edsnx sch move-symbol | edit | Move symbol with its wires. Move symbols (and any other selected items) by a vector (mm) with the wires on their pins following, as the move tool does: wires rubberband (stretched and re-cornered, the default), reroute (ripped and re-routed by Auto Wire up to the first branch) or detach (left in place). Same as sch.move with wires. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], by: [x, y], wires?: “rubberband” | “reroute” | “detach” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.moveWireEnd | edsnx sch move-wire-end | edit | Move wire end. Move end end (0 = first point) of a wire segment to to (mm). With orthogonal (default true) a diagonal result gets a corner. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, end: 0 | 1, to: [x, y], orthogonal?: boolean = true | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.openFieldsTablesoftforge.edsnx.fieldsTable | edsnx sch open-fields-table | ui | Symbol Fields Table. Open the Symbol Fields Table. Agents: use sch.setProperty. UI-only: needs the open editor. | path?: string | object |
sch.pageSettingssoftforge.edsnx.pageSettings | edsnx sch page-settings | ui | Page settings. Open the Page settings dialog of the active schematic (paper size and orientation, title block). Agents: use sch.setPaper / sch.setTitleBlock. UI-only: needs the open editor. | path?: string | object |
sch.placeSymbol | edsnx sch place-symbol | edit | Place symbol. Place library symbol lib:name at at (mm), rotation (degrees), optional mirror/unit, reference, value and fields (Footprint, Datasheet, MPN…). newIds = [symbol uuid]. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, lib: string, name: string, at: [x, y], rot?: number = 0, mirror?: “x” | “y”, unit?: integer, ref?: string, value?: string, sheetPath?: string, fields?: object, footprint?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.removeWireVertex | edsnx sch remove-wire-vertex | edit | Remove wire vertex. Remove the vertex at at (mm): the two wires meeting there (and nothing else) become one straight wire; with id, the point of that multi-point wire. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], id?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.replaceSymbol | edsnx sch replace-symbol | edit | Change symbol. Change a symbol’s library symbol, keeping fields, position and instances. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, lib: string, name: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.resizeGroup | edsnx sch resize-group | edit | Resize group box. Resize the group box of a symbol (body rectangle, edges on the 1.27 mm grid) or footprint (courtyard / fabrication outline) to [minX, minY, maxX, maxY] in the group’s local frame (mm, y down, unrotated): pins and pads on an edge follow it, labels keep their offset to their anchor (auto: re-placed with their preset). A local override. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, box: [x0, y0, x1, y1], auto?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.revertToLibrary | edsnx sch revert-to-library | edit | Revert to library. Drop the local override of a symbol / footprint: it draws its library item again (wires on moved pins follow). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.rotate | edsnx sch rotate | edit | Rotate. Rotate items by deg degrees (multiples of 90) about about or their centre. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[], deg: number, about?: [x, y], wires?: “rubberband” | “reroute” | “detach” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setAttrs | edsnx sch set-attrs | edit | Set attributes. Generic attribute edit; keys follow Item.attrs from query.items (width, size, drill, layer, layers, net, text, rot, at, …). mm and degrees. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, attrs: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setGroupRigid | edsnx sch set-group-rigid | edit | Set group rigid. Make a placed symbol / footprint rigid (its labels move only with it) or flexible (labels can be moved one by one and keep their anchored offset); null removes the flag so the softforge.edsnx.symbolGroups.defaultRigid setting decides. Stored as a hidden instance property KiCad keeps. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, rigid: boolean | null | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setLabelAnchor | edsnx sch set-label-anchor | edit | Set label anchor. One label of a symbol / footprint (field name; board free text by its id fpt:at (mm; refused while the group is rigid or the label locked), or, on a board, KiCad’s Keep upright of the text (upright; false writes (unlocked yes)). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, field: string, anchor?: “nw” | “n” | “ne” | “w” | “c” | “e” | “sw” | “s” | “se” | null, locked?: boolean, preset?: “leftAbove” | “centerAbove” | “rightAbove” | “leftCenter” | “rightCenter” | “leftBelow” | “centerBelow” | “rightBelow” | “kicad” | null, at?: [x, y], upright?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setPaper | edsnx sch set-paper | edit | Set paper. Set the sheet’s paper: a KiCad size (A4, A3, A2, A1, A0, A, B, C, D, E, USLetter, USLegal, USLedger) with an orientation (landscape by default), or User with width and height in mm. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, size: string, orientation?: “portrait” | “landscape”, width?: number, height?: number | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setProperty | edsnx sch set-property | edit | Set property. Set a field of a footprint or symbol (Reference, Value, Footprint, Datasheet, user fields). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, field: string, value: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setReference | edsnx sch set-reference | edit | Set reference. Set a symbol’s reference designator for one sheet instance (sheetPath, / | path: string, id: string, ref: string, sheetPath?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.setTitleBlock | edsnx sch set-title-block | edit | Set title block. Set the sheet’s title block: title, date, rev, company and comments 1–9. A field given empty is removed, a field not given is kept; no field left removes the block. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, title?: string, date?: string, rev?: string, company?: string, comments?: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.splitWire | edsnx sch split-wire | edit | Break wire. Split a wire segment at at (mm) into two wires meeting there. With gap (mm) a piece of that length is cut out (the net is split); relabel then adds a label with that name on the part left without one. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, at: [x, y], gap?: number, relabel?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.straightenWires | edsnx sch straighten-wires | edit | Straighten wires. Make diagonal wires orthogonal: an L-shaped pair touching nothing else, else an Auto Wire route between the same ends. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.trimWire | edsnx sch trim-wire | edit | Trim / extend wire. Extend a dangling wire end along its line to the first pin, wire end or junction (within 50 mm), or trim an end that overshoots a pin back to it. end picks the end (both are tried when absent). Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, id: string, end?: 0 | 1 | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.unfoldBus | edsnx sch unfold-bus | edit | Unfold from bus. KiCad’s Unfold from Bus (C): a bus entry at at (mm, a point on a bus), a wire from the entry towards to and a local label member (a member net of the bus, e.g. D3 of D[0..7]) at the wire end. newIds = [entry, wire, label]. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, at: [x, y], to: [x, y], member: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.updateLibraryFromInstance | edsnx sch update-library-from-instance | edit | Update library from instance. Push a symbol’s / footprint’s local override to its library item through the library editor (sym.symSetBody / the .kicad_mod): scope ’library’ writes the library only (the instance keeps its own symbol), ‘all’ also updates every instance of the item in this file. The library file is written by the editor host or the CLI. Edits the schematic as one undo step; returns newIds, revision and hash. Headless runs also write the library file (returned as library). | path: string, id: string, scope: “library” | “all” | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.wire | edsnx sch wire | edit | Wire. Draw a wire through points (mm; keep them on the 1.27 mm grid so pins connect). Same as sch.addWire. Edits the schematic as one undo step; returns newIds, revision and hash. | path: string, pts: [x, y][], bus?: boolean = false | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
sch.wiresPanelsoftforge.edsnx.wiresPanel | edsnx sch wires-panel | ui | Wires panel. Show the Wires panel (placement mode, crossing avoidance, symbol move mode, wire tools). Agents: use sch.autoWire / sch.cleanupWires. UI-only: needs the open editor. | path?: string | object |
Examples
sch.addBusEntryAdd bus entry:{"path":"root.kicad_sch","at":[101.6,50.8],"size":[2.54,-2.54]}sch.addGraphicAdd graphic:{"path":"root.kicad_sch","kind":"rect","layer":"Edge.Cuts","pts":[[0,0],[50,40]],"width":0.1}sch.addImageAdd image:{"path":"root.kicad_sch","at":[50,50],"data":"<base64 png>"}sch.addJunctionAdd junction:{"path":"root.kicad_sch","at":[100.33,50.8]}sch.addLabelAdd label:{"path":"root.kicad_sch","kind":"local","at":[110.49,50.8],"rot":0,"text":"VCC"}sch.addNoConnectAdd no-connect:{"path":"root.kicad_sch","at":[100.33,50.8]}sch.addSheetAdd sheet:{"path":"root.kicad_sch","at":[150,50],"size":[30,20],"name":"Power","file":"power.kicad_sch"}sch.addSheetPinAdd sheet pin:{"path":"root.kicad_sch","sheetId":"<uuid>","name":"VCC","at":[150,55],"shape":"input"}sch.addTextAdd text:{"path":"root.kicad_sch","layer":"F.SilkS","at":[10,5],"rot":0,"text":"v1.0","size":[1,1],"thickness":0.15}sch.addTextBoxAdd text box:{"path":"root.kicad_sch","layer":"F.SilkS","a":[0,0],"b":[20,10],"text":"Note","size":[1,1],"thickness":0.15}sch.addWireAdd wire:{"path":"root.kicad_sch","pts":[[100.33,50.8],[120.65,50.8]]}sch.addWireVertexAdd wire vertex:{"path":"root.kicad_sch","id":"<uuid>","at":[110.49,50.8]}sch.alignWiresAlign wires:{"path":"root.kicad_sch","ids":["<reference uuid>","<uuid>"]}sch.annotateAnnotate:{"path":"root.kicad_sch","scope":"unannotated"}sch.autoWireAuto Wire:{"path":"root.kicad_sch","pts":[[100.33,50.8],[130.81,63.5]],"crossingAvoidance":70}sch.autopositionAutoposition labels:{"path":"root.kicad_sch","ids":["<uuid>"],"preset":"rightCenter"}sch.batchBatch:{"path":"root.kicad_sch","label":"Two moves","intents":[{"op":"move","ids":["<uuid>"],"by":[1,0]},{"op":"move","ids":["<uuid>"],"by":[0,1]}]}sch.cleanupWiresClean up wires:{"path":"root.kicad_sch"}sch.cleanupWiresDialogClean up wires:{}sch.clearAnnotationClear annotation:{"path":"root.kicad_sch"}sch.convertWiresConvert wire / bus:{"path":"root.kicad_sch","ids":["<uuid>"],"to":"bus"}sch.deleteDelete:{"path":"root.kicad_sch","ids":["<uuid>"]}sch.dragWireSegmentDrag wire segment:{"path":"root.kicad_sch","id":"<uuid>","by":[0,2.54]}sch.duplicateDuplicate:{"path":"root.kicad_sch","ids":["<uuid>"],"by":[5,0]}sch.editGroupEdit symbol / footprint in place:{"path":"root.kicad_sch","id":"<uuid>","intents":[{"op":"symEditPin","id":"pin:NE555P_1_1:2","pin":{"name":"TRIG"}}]}sch.editInPlaceEdit in Place:{}sch.flipFlip:{"path":"root.kicad_sch","ids":["<uuid>"]}sch.labelAdd label:{"path":"root.kicad_sch","at":[110.49,50.8],"text":"VCC"}sch.mergeWiresMerge wires:{"path":"root.kicad_sch"}sch.moveMove:{"path":"root.kicad_sch","ids":["<uuid>"],"by":[2.54,0]}sch.moveSymbolMove a symbol two grid steps right, re-routing its wires:{"path":"root.kicad_sch","ids":["<symbol uuid>"],"by":[5.08,0],"wires":"reroute"}sch.moveWireEndMove wire end:{"path":"root.kicad_sch","id":"<uuid>","end":1,"to":[120.65,55.88]}sch.openFieldsTableSymbol Fields Table:{}sch.pageSettingsPage settings:{}sch.placeSymbolPlace symbol:{"path":"root.kicad_sch","lib":"Device","name":"R","at":[100.33,50.8],"rot":0,"ref":"R1","value":"10k","footprint":"Resistor_SMD:R_0603_1608Metric"}sch.removeWireVertexRemove wire vertex:{"path":"root.kicad_sch","at":[110.49,50.8]}sch.replaceSymbolChange symbol:{"path":"root.kicad_sch","id":"<uuid>","lib":"Device","name":"R_Small"}sch.resizeGroupResize group box:{"path":"root.kicad_sch","id":"<uuid>","box":[-10.16,-7.62,10.16,7.62]}sch.revertToLibraryRevert to library:{"path":"root.kicad_sch","id":"<uuid>"}sch.rotateRotate:{"path":"root.kicad_sch","ids":["<uuid>"],"deg":90}sch.setAttrsSet attributes:{"path":"root.kicad_sch","id":"<uuid>","attrs":{"width":0.3}}sch.setGroupRigidSet group rigid:{"path":"root.kicad_sch","id":"<uuid>","rigid":true}sch.setLabelAnchorSet label anchor:{"path":"root.kicad_sch","id":"<uuid>","field":"Reference","preset":"centerAbove","locked":true}sch.setPaperSet paper:{"path":"root.kicad_sch","size":"A3"}sch.setPropertySet property:{"path":"root.kicad_sch","id":"<uuid>","field":"Value","value":"10k"}sch.setReferenceSet reference:{"path":"root.kicad_sch","id":"<uuid>","ref":"R12"}sch.setTitleBlockSet title block:{"path":"root.kicad_sch","title":"nlinx nano module","rev":"A","comments":["Power"]}sch.splitWireBreak wire:{"path":"root.kicad_sch","id":"<uuid>","at":[110.49,50.8]}sch.straightenWiresStraighten wires:{"path":"root.kicad_sch","ids":["<uuid>"]}sch.trimWireTrim / extend wire:{"path":"root.kicad_sch","id":"<uuid>"}sch.unfoldBusUnfold from bus:{"path":"root.kicad_sch","at":[101.6,50.8],"to":[111.76,53.34],"member":"D3"}sch.updateLibraryFromInstanceUpdate library from instance:{"path":"root.kicad_sch","id":"<uuid>","scope":"all"}sch.wireAdd wire:{"path":"root.kicad_sch","pts":[[100.33,50.8],[120.65,50.8]]}sch.wiresPanelWires panel:{}
Project#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
project.annotate | edsnx project annotate | edit | Annotate project. Annotate the schematic hierarchy: every sheet instance (scope “all”) or this sheet, numbering unannotated symbols (mode “unannotated”) or renumbering all; references stay unique across the project. One undo step per sheet file. | path: string, scope?: “all” | “sheet” = “all”, mode?: “unannotated” | “all” = “unannotated”, options?: object | newIds, label, sheets, changed, revision, hash |
project.boardSetup.get | edsnx project board-setup get | query | Get board setup. The board setup: layers, copper count, thickness, stack-up, design rules (mm), default sizes, net classes, severities. | path: string | layers, copperLayers, thicknessMm, stackup, rules, defaults, netClasses, ruleSeverities, finish, maskPaste, textDefaults, diffPairTable, matchedGroups |
project.boardSetup.set | edsnx project board-setup set | edit | Set board setup. Change part of the board setup (the keys given): rules, defaults, layers, stack-up, severities. Same as pcb.setBoardSetup. | path: string, setup: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
project.bom | edsnx project bom | export | Export BOM. Bill of materials (CSV grouped by value, KiCad defaults) or a netlist of the schematic, with kicad-cli on the saved files. Returns the output file. | path: string, format?: “csv” | “python-bom” | “netlist-xml” | “netlist” = “csv”, out?: string, variant?: string | file |
project.detailssoftforge.edsnx.project.details | edsnx project details | ui | Project details. Open the Project details page of a KiCad project (.kicad_pro): sheets, board facts, libraries, outputs, checks, tools and agent, with the actions to open the editors and run the checks; also the read-only editor of .kicad_pro files (2.4.0 #504). UI-only: opens its own page. | path?: string | object |
project.drill | edsnx project drill | export | Drill files. Excellon drill files (and drill map) with kicad-cli into outDir. Returns the files written. | path: string, outDir?: string, options?: object, perSpan?: boolean = false, variant?: string | files, folder, errors |
project.exportsoftforge.edsnx.interop.export | edsnx project export | export | Export files. Exports design files (folders: every design file below them; KiCad files and KiCad project folders are imported in memory first) through a registered exporter (as, project.formats) into out: kicad, gerber (native Gerber X2 / Excellon / job), odb and ipc2581 (kicad-cli), dsn (Specctra), idx (MCAD baseline), pdf and svg (plots), json (the reduced document), or an add-on format. Returns the files written and the report of what the format cannot hold. edsnx export is the same from the shell. | files: string[], as: string, out: string, options?: object, dryRun?: boolean | ok, exporter, files, summary, report |
project.export3d | edsnx project export3d | export | Export 3D. Export the board as STEP, VRML or glTF binary (.glb) with kicad-cli. Returns the output file. | path: string, format?: “step” | “vrml” | “glb” = “step”, out?: string, variant?: string | file |
project.fabricate | edsnx project fabricate | export | Fabrication outputs. Gerbers, drill and position files in one go (kicad-cli) into outDir, plus ODB++ / IPC-2581 when odb / ipc2581 are set. Returns the files written and per-step errors. | path: string, format?: “gerber” | “pdf” | “svg” | “dxf” | “ps” = “gerber”, layers?: string[], outDir?: string, options?: object, perSpan?: boolean = false, odb?: boolean | object, ipc2581?: boolean | object, variant?: string | files, folder, errors |
project.formats | edsnx project formats | query | Import and export formats. The registered importers (id, name, extensions, origin: builtin or the add-on that registered it) and exporters (id, name, the design kinds they write, the extensions of their files, whether they need kicad-cli, what the format loses). | — | importers, exporters |
project.importsoftforge.edsnx.interop.import | edsnx project import | tool | Import files. Imports foreign files into design files under to, through the registered importers (project.formats): KiCad 6–10 files, Gerber / Excellon fab sets (a folder, a zip or one file of the set → one board), Eagle 6+ XML schematics, boards and libraries, and add-on formats. Without importer each file goes to the first importer that reads it, a folder to the first importer that reads something in it. Returns the design files written and the loss report (what was dropped, approximated, kept as text, not attached). edsnx import is the same from the shell. | files: string[], to: string, importer?: string, options?: object, dryRun?: boolean | ok, importers, designs, attachments, summary, report |
project.importReportsoftforge.edsnx.interop.showReport | edsnx project import-report | ui | Show import report. Shows the loss report of the last import or export in the Problems view (one entry per file, object and reason) and offers to open the design files it wrote. | — | shown |
project.ipc2581 | edsnx project ipc2581 | export | Export IPC-2581. IPC-2581 of the board with kicad-cli (KiCad 8+): revision B or C, units, precision, compression and the BOM columns from symbol fields. Writes | path: string, outDir?: string = “fab/”, out?: string, options?: object | file, kind, bytes |
project.migrateDesignsoftforge.edsnx.design.migrateProject | edsnx project migrate-design | tool | Migrate project to design files. Converts a KiCad project to a native project: every KiCad file of the project folder gets its design file next to it (meta.kicad: "export"); a compatibility cache in step keeps its history. The design files become authoritative and the KiCad files an export target, written on every save. The KiCad files are not changed. Returns the files written and the importer’s loss report. | project: string, dryRun?: boolean | project, designs, summary, report |
project.netClasses.get | edsnx project net-classes get | query | Get net classes. Net classes of the project (sizes in mm, patterns) and the class of each net. | path: string | netClasses, assignments |
project.netClasses.set | edsnx project net-classes set | edit | Set net classes. Replace the net classes (.kicad_pro): name, clearance, track width, via sizes (mm), patterns. Same as pcb.setNetClasses. | path: string, netClasses: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
project.new | edsnx project new | tool | New project. Create a KiCad project from a template in a new folder (out, default ./origin), .kicad_prl and project library tables. The files are written when the command returns (no session_save needed). Returns the folder, the files and the resolved template, stack-up, size and copper layer count; –dry-run returns the plan only. | name: string, template?: “2layer” | “4layer” | “6layer” = “2layer”, size?: string, stackup?: “generic-2l-1.6” | “generic-2l-0.8” | “jlc-4l-1.6” | “generic-4l-1.6” | “generic-6l-1.2”, out?: string, title?: string, company?: string, rev?: string, origin?: [x, y], force?: boolean, date?: string | dir, name, project, schematic, board, files, template, stackup, size, origin, copperLayers, dryRun |
project.odb | edsnx project odb | export | Export ODB++. ODB++ of the board with kicad-cli (KiCad 9+): units, precision, compression zip/tgz/none. Writes | path: string, outDir?: string = “fab/”, out?: string, options?: object | file, kind, bytes |
project.openBomsoftforge.edsnx.bom | edsnx project open-bom | ui | BOM dialog. Open the BOM dialog. Agents: use project.bom. UI-only: needs the open editor. | path?: string | object |
project.openFabOutputssoftforge.edsnx.fabOutputs | edsnx project open-fab-outputs | ui | Fabrication Outputs dialog. Open the Fabrication Outputs dialog. Agents: use project.plot / drill / position / fabricate. UI-only: needs the open editor. | path?: string | object |
project.plotsoftforge.edsnx.plot | edsnx project plot | export | Plot (Gerbers). Plot board layers with kicad-cli (Gerber by default, also pdf/svg/dxf/ps) into outDir (default fab/). Unsaved edits are plotted from a temp copy. Returns the files written. | path: string, format?: “gerber” | “pdf” | “svg” | “dxf” | “ps” = “gerber”, layers?: string[], outDir?: string, options?: object, variant?: string | files, folder, errors |
project.position | edsnx project position | export | Position files. Component position (pick and place) files with kicad-cli into outDir. Returns the files written. | path: string, outDir?: string, options?: object, variant?: string | files, folder, errors |
project.syncPlan | edsnx project sync-plan | query | Plan Update PCB. What project.updatePcb would do, without changing anything: counts per action kind, action messages and warnings. | path: string, schematic?: string, netlistFile?: string, options?: object | empty, stats, actions, warnings |
project.updatePcbsoftforge.edsnx.updateFromSchematic | edsnx project update-pcb | edit | Update PCB from Schematic. Carry the schematic over to the board (KiCad’s F8): export the netlist with kicad-cli (or read netlistFile), add/replace footprints from the libraries, set pad nets, values and references, delete extras when asked. One undo step; returns the plan’s action messages and warnings. | path: string, schematic?: string, netlistFile?: string, options?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, actions, warnings |
project.updateSchematicsoftforge.edsnx.updateSchematicFromPcb | edsnx project update-schematic | edit | Update Schematic from PCB. Back-annotate the board to the schematic (KiCad’s Update Schematic from PCB): re-annotated references (per sheet instance), values, footprint ids, DNP / exclude-from-BOM flags and, with the schematic netlist (kicad-cli or netlistFile), net names renamed on the board (local and global labels). Footprints are matched to symbols by their uuid path, then by reference. One undoable group across the sheets; returns the plan’s messages, warnings and the sheets changed. | path: string, schematic?: string, netlistFile?: string, options?: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, actions, warnings, sheets |
Examples
project.annotateNumber every new symbol:{"path":"root.kicad_sch"}project.boardSetup.getDesign rules:{"path":"board.kicad_pcb"}project.boardSetup.setTighter clearance:{"path":"board.kicad_pcb","setup":{"rules":{"minClearance":0.15}}}project.bomBOM as CSV:{"path":"root.kicad_sch","out":"fab/bom.csv"}project.detailsProject details:{}project.drillInto fab/:{"path":"board.kicad_pcb","outDir":"fab/"}project.exportGerbers of a board:{"files":["blinky.design.pcb"],"as":"gerber","out":"fab/"}project.exportThe sample project as Specctra DSN:{"files":["examples/sample-project"],"as":"dsn","out":"route/"}project.export3dSTEP model:{"path":"board.kicad_pcb","format":"step","out":"fab/board.step"}project.fabricateInto fab/:{"path":"board.kicad_pcb","outDir":"fab/"}project.formatsWhat can be imported and exported:{}project.importAn Eagle board and schematic:{"files":["divider.brd","divider.sch"],"to":"design/"}project.importA fab set as a board:{"files":["fab/"],"to":"design/","importer":"gerber"}project.importReportShow the last report:{}project.ipc2581IPC-2581 rev C with manufacturer part numbers:{"path":"board.kicad_pcb","options":{"version":"C","bomMfgPn":"MPN"}}project.migrateDesignMigrate the sample project:{"project":"examples/sample-project/blinky.kicad_pro"}project.netClasses.getClasses and assignments:{"path":"board.kicad_pcb"}project.netClasses.setA power class:{"path":"board.kicad_pcb","netClasses":[{"name":"Default","clearance":0.2,"trackWidth":0.25,"viaDiameter":0.6,"viaDrill":0.3},{"name":"Power","clearance":0.2,"trackWidth":0.6,"viaDiameter":0.8,"viaDrill":0.4,"patterns":["+5V","GND"]}]}project.newA 2-layer 50 x 35 mm board:{"name":"blinky","template":"2layer","size":"50x35"}project.newA 4-layer board on the JLC stack-up:{"name":"logger","template":"4layer","size":"80x60","stackup":"jlc-4l-1.6","out":"hw/logger"}project.odbODB++ zip into fab/:{"path":"board.kicad_pcb","outDir":"fab/"}project.openBomBOM dialog:{}project.openFabOutputsFabrication Outputs dialog:{}project.plotGerbers into fab/:{"path":"board.kicad_pcb","outDir":"fab/"}project.positionInto fab/:{"path":"board.kicad_pcb","outDir":"fab/"}project.syncPlanPreview the sync:{"path":"board.kicad_pcb"}project.updatePcbSync the board with its schematic:{"path":"board.kicad_pcb"}project.updatePcbAlso delete footprints not in the schematic:{"path":"board.kicad_pcb","options":{"deleteExtra":true,"replaceFootprints":true,"matchBy":"reference"}}project.updateSchematicBack-annotate the board (dry run first with –dry-run):{"path":"board.kicad_pcb"}project.updateSchematicOnly references and values, matched by reference:{"path":"board.kicad_pcb","options":{"footprints":false,"attributes":false,"netNames":false,"matchBy":"reference"}}
Queries#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
query.bounds | edsnx query bounds | query | Bounds. Bounding box [minX, minY, maxX, maxY] (mm) of the board outline (or the whole document), or of the given ids / filter; with the item count. | path: string, ids?: string[], type?: string | array, net?: string | array, ref?: string | array, layer?: string | array | bounds, count, source |
query.describe | edsnx query describe | query | Describe document. Overview of a board or schematic: bounds (board outline, mm), layers, item counts per kind, net count, unrouted connections, revision and hash; boards add copper layers, thickness, default sizes and net classes; schematics list the sheet hierarchy. checks: true adds native DRC/ERC error and warning counts. | path: string, checks?: boolean = false | path, kind, revision, hash, bounds, layers, counts, nets, unrouted |
query.freeArea | edsnx query free-area | query | Free area. Room around a point on a copper layer: free is the distance (mm) from at to the nearest copper/hole/edge/keepout obstacle (capped at radius), insideBoard whether the point is inside the outline, then the obstacles within radius (nearest first) with id, kind, net and distance. Use it to place vias, footprints or route detours. | path: string, at: [x, y], radius?: number = 5, layer?: string = “F.Cu”, limit?: integer = 50 | at, radius, free, layer, insideBoard, obstacles |
query.groups | edsnx query groups | query | Matched-length groups. Matched-length groups of the .kicad_pro (net_settings.matched_groups): each group with its target (mm or ps; “longest” resolved), tolerance, skew, verdict (ok) and one row per member net: routed length, routed plus the ratsnest remainder, delta to the target, status (ok / short / long / unrouted) and via count. name glob filters. | path: string, name?: string | array, limit?: integer = 200 | total, ok, groups |
query.items | edsnx query items | query | List items. Items matching a filter (AND of: type, layer, net, ref globs; value glob; text substring; within [x0, y0, x1, y1]; near { at, r }; ids). Returns total, counts per type, the bounds of all matches, then up to limit (200) concise items: id, type, layer, net, ref, value, lib, at, rot, bounds, width, pads. Boards: footprint, track, arc, via, zone, graphic, text, dimension (and pad when asked by type); schematics: symbol, sheet, sheetPin, wire, bus, junction, noConnect, label, globalLabel, hierLabel, text. | path: string, type?: string | array, layer?: string | array, net?: string | array, ref?: string | array, value?: string, text?: string, within?: [x0, y0, x1, y1], near?: object, ids?: string[], limit?: integer = 200 | total, returned, bounds, counts, items |
query.net | edsnx query net | query | Net details. One net: summary, its pads (“R1.2” with position), tracks, vias and zones (concise items) and its unrouted connections. | path: string, name: string, limit?: integer = 200 | net, pads, items, unrouted |
query.nets | edsnx query nets | query | List nets. Nets with their class, pad count, track and via counts, routed length (mm) and unrouted connection count; net glob filters, unroutedOnly keeps nets still to route. Up to limit nets, total first. | path: string, net?: string | array, unroutedOnly?: boolean = false, limit?: integer = 200 | total, unrouted, nets |
query.pairs | edsnx query pairs | query | Differential pairs. Differential pairs of a board: the explicit table of the .kicad_pro, then KiCad’s name rule (_P/_N, +/-) and net-class suffixes. Each pair: name, positive and negative net, source (explicit / name / class), net class, resolved width, gap and via gap (mm), routed length of each side (mm), skew (|P − N| mm), unrouted connections and whether both sides are routed. name glob filters. | path: string, name?: string | array, limit?: integer = 200 | total, pairs |
query.ratsnest | edsnx query ratsnest | query | Ratsnest. The ratsnest: connections still to route, each with its net, the pads it joins (“R1.2” → “U1.5”), their positions and the straight length (mm). Sorted shortest first; net glob filters. Alias of query.unrouted. | path: string, net?: string | array, limit?: integer = 200 | total, connections |
query.select | edsnx query select | query | Select ids. Ids of the items matching a filter (same filter as query.items), for chaining into edits (move, delete, setLocked…). Returns total and up to limit ids. | path: string, type?: string | array, layer?: string | array, net?: string | array, ref?: string | array, value?: string, text?: string, within?: [x0, y0, x1, y1], near?: object, ids?: string[], limit?: integer = 1000 | total, ids |
query.sheetTree | edsnx query sheet-tree | query | Sheet hierarchy. The schematic hierarchy of the project a sheet belongs to: root file, project name, and the tree of sheets (instance path, name, file, page). | path: string | root, project, sheets, tree |
query.unrouted | edsnx query unrouted | query | Unrouted connections. The ratsnest: connections still to route, each with its net, the pads it joins (“R1.2” → “U1.5”), their positions and the straight length (mm). Sorted shortest first; net glob filters. | path: string, net?: string | array, limit?: integer = 200 | total, connections |
query.violations | edsnx query violations | query | Violations. Native DRC (boards) or ERC (schematics, whole hierarchy) violations of the current unsaved text: counts per rule, then violations with rule, severity, message, position (mm) and item ids. Options: rules, severity, limit, includeExcluded. | path: string, rules?: string[], severity?: “all” | “error” | “warning” = “all”, limit?: integer = 200, includeExcluded?: boolean = false | errors, warnings, total, violations |
Examples
query.boundsBoard outline:{"path":"board.kicad_pcb"}query.boundsExtent of U1 and U2:{"path":"board.kicad_pcb","ref":["U1","U2"]}query.describeBoard overview with check counts:{"path":"board.kicad_pcb","checks":true}query.freeAreaRoom for a via near a pad:{"path":"board.kicad_pcb","at":[100,100],"radius":2,"layer":"B.Cu"}query.groupsEvery group and its verdict:{"path":"board.kicad_pcb"}query.itemsFootprints whose reference starts with R:{"path":"board.kicad_pcb","type":"footprint","ref":"R*"}query.itemsTracks of GND on the bottom layer:{"path":"board.kicad_pcb","type":"track","net":"GND","layer":"B.Cu"}query.itemsAnything within 5 mm of a point:{"path":"board.kicad_pcb","near":{"at":[100,100],"r":5}}query.netEverything on GND:{"path":"board.kicad_pcb","name":"GND"}query.netsNets left to route:{"path":"board.kicad_pcb","unroutedOnly":true}query.pairsEvery pair with its skew:{"path":"board.kicad_pcb"}query.pairsUSB pairs only:{"path":"board.kicad_pcb","name":"USB*"}query.ratsnestWhat is left to route:{"path":"board.kicad_pcb"}query.selectEvery via of net GND:{"path":"board.kicad_pcb","type":"via","net":"GND"}query.sheetTreeHierarchy of the project:{"path":"root.kicad_sch"}query.unroutedWhat is left to route:{"path":"board.kicad_pcb"}query.violationsClearance problems only:{"path":"board.kicad_pcb","rules":["clearance"]}
Libraries#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
lib.footprint.addPad | edsnx lib footprint add-pad | edit | Add pad. Add a pad to a .kicad_mod (fp.fpAddPad): defaults SMD roundrect 1 × 1 mm, next free number. | path: string, pad: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.export | edsnx lib footprint export | export | Export footprint. Export a footprint: svg (kicad-cli fp export svg, one file per footprint into out), or board (a .kicad_pcb holding the footprint at the origin, for kicad-cli pcb drc / export). | path: string, format: “svg” | “board”, out?: string, layers?: string | files |
lib.footprint.get | edsnx lib footprint get | query | Footprint model. A footprint as the editor sees it: pads (number, type, shape, position, size, drill, layers, margins, thermal settings, custom primitives), graphics per layer, texts, attributes, clearances, 3D models, properties, net ties. Ids feed the fp.* edit commands. | path?: string, lib?: string, name?: string, project?: string | name, version, layer, description, keywords, locked, properties, attrs, clearances, netTieGroups, models, pads, graphics, texts, textBoxes, zones, courtyard, bbox |
lib.footprint.list | edsnx lib footprint list | query | List library footprints. The footprints of a .pretty folder (path) or of a library nickname (lib, from the fp-lib-table of project): name, description, keywords, pad count, smd. | path?: string, lib?: string, project?: string, query?: string, limit?: integer = 500 | total, footprints |
lib.footprint.new | edsnx lib footprint new | edit | New footprint. Write a new footprint file: blank, a copy of from (renamed), or a wizard result (wizard: soic, qfp, qfn, bga, dip, sip, chip, tht2, header, mountingHole with params). path is the .kicad_mod to write or the .pretty folder (then name or the wizard names the file). | path: string, name?: string, from?: string, wizard?: “soic” | “qfp” | “qfn” | “bga” | “dip” | “sip” | “chip” | “tht2” | “header” | “mountingHole”, params?: object, overwrite?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.padArray | edsnx lib footprint pad-array | edit | Pad array. Grid or circular array of a pad (fp.fpPadArray): template is a pad id or a pad spec; numbering numeric, alpha or bga. | path: string, template: string | object, array: object, removeTemplate?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.renumber | edsnx lib footprint renumber | edit | Renumber pads. Renumber pads: in the order of ids, or every pad by order (file, rows: by y then x, columns: by x then y, ccw: counter-clockwise from the top left as IC pins run), from start by step with a prefix. | path: string, ids?: string[], order?: “file” | “rows” | “columns” | “ccw” = “file”, start?: integer = 1, step?: integer = 1, prefix?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.set3dModel | edsnx lib footprint set3d-model | edit | 3D model. Set or add a 3D model (fp.fpSet3dModel); remove: true removes model index. | path: string, index?: integer, model?: object, remove?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.setAttrs | edsnx lib footprint set-attrs | edit | Footprint attributes. Footprint attributes (fp.fpSetAttrs) and, in one step, description / keywords. | path: string, attrs?: object, description?: string, keywords?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
lib.footprint.wizard | edsnx lib footprint wizard | query | Footprint wizard. Without kind: the wizards and their parameters (mm). With kind: the generated footprint (name, pads, courtyard) and its .kicad_mod text; lib.footprint.new writes it. | kind?: “soic” | “qfp” | “qfn” | “bga” | “dip” | “sip” | “chip” | “tht2” | “header” | “mountingHole”, params?: object, name?: string, text?: boolean = true | object |
lib.footprintModelssoftforge.edsnx.model3d.footprintModels | edsnx lib footprint-models | ui | 3D models of the footprint. List the (model …) entries of the footprint open in the Footprint Editor, resolved against the KiCad environment (KICAD*_3DMODEL_DIR, KIPRJMOD), and open the chosen one in the 3D model viewer (2.5.0 #510). UI-only: needs the open editor. | path?: string | object |
lib.import | edsnx lib import | export | Import a library. Import a foreign library into KiCad libraries: Altium .SchLib / .PcbLib / .IntLib, Eagle .lbr, EasyEDA / LCSC JSON, SnapEDA / Ultra Librarian / SamacSys zip packages. Writes | file: string, format?: “altium” | “eagle” | “easyeda” | “package”, out: string, dir?: string | files, symbols, footprints, models, report, text |
lib.list | edsnx lib list | query | List libraries. Footprint or symbol libraries from the global and project library tables: nickname, uri, description, source (global/project). | kind: “footprint” | “symbol”, path?: string | total, libraries |
lib.managesoftforge.edsnx.libraries.manage | edsnx lib manage | ui | Manage libraries. Open the library manager. Agents: use lib.list / lib.search. UI-only: needs the open editor. | path?: string | object |
lib.managed.approve | edsnx lib managed approve | export | Set part review states. Set the review state of managed library parts (keys “symbol:Lib:Name” / “footprint:Lib:Name”) in library.json: approved (default), draft or deprecated, with the reviewer, a note and a replacement; commit commits library.json. | path: string, parts: string[], state?: “approved” | “draft” | “deprecated” = “approved”, by?: string, note?: string, replacedBy?: string, commit?: boolean = false | object |
lib.managed.status | edsnx lib managed status | query | Managed library status. Status of a managed library repository (a git folder with library.json): name, version, HEAD, upstream, behind / ahead, update available (with fetch), the sidecar diff to the upstream and the draft / approved / deprecated counts. | path: string, fetch?: boolean = false | object |
lib.managed.sync | edsnx lib managed sync | export | Sync library.json. Sync a managed library’s library.json with its files: new parts become draft, removed parts are dropped (or deprecated with deprecateMissing), approved parts whose content changed go back to draft. Returns the changes. | path: string, deprecateMissing?: boolean = false | changes, file |
lib.managed.whereUsed | edsnx lib managed where-used | query | Where used. Projects (under roots, default the current folder) whose schematics or boards use lib:name (or any part of the library without name): file, reference, lib id. | lib: string, name?: string, roots?: string[] | projects, uses |
lib.openModel3dsoftforge.edsnx.model3d.open | edsnx lib open-model3d | ui | Open 3D model. Open a 3D model file (.step, .stp, .wrl, .glb, .gltf) in the 3D model viewer: STEP and VRML are converted once with kicad-cli (pcb export glb), glTF loads as it is; the bounding box in mm, Fit / Iso / Top (2.5.0 #510). UI-only: opens its own page. | path?: string | object |
lib.preview | edsnx lib preview | query | Library item details. One footprint or symbol: description, keywords, datasheet; footprints add their pads (number, position relative to the anchor in mm, size, shape, layer) and bounds; symbols add units, pins (number, name, electrical type, position) and the compatible footprints from the footprint filters. | kind: “footprint” | “symbol”, lib: string, name: string, unit?: integer, path?: string | kind, lib, name, description, keywords, datasheet, pads, smd, units, unitNames, pins, power, footprint, fpFilters, compatible, bounds, padList |
lib.search | edsnx lib search | query | Search libraries. Search footprints and/or symbols by words (name, description, keywords; all words must match), optionally in one library. Returns totals and up to limit hits: lib, name, description, pads/smd (footprints), units/footprint (symbols). Place hits with pcb.placeFootprint / sch.placeSymbol. | query: string, kind?: “footprint” | “symbol” | “both” = “both”, lib?: string, limit?: integer = 25, path?: string | footprints, symbols |
lib.symbol.addGraphic | edsnx lib symbol add-graphic | edit | Add graphic to library symbol. Add a body graphic to a library symbol: rect [start, end], circle [centre, point on circle], arc [start, mid, end], line/poly/bezier points or text [at]; library mm, y up; unit 0 = all units. Fill: style.fillType none/outline/background/color. | path: string, symbol: string, unit?: integer, bodyStyle?: integer, kind: “line” | “rect” | “circle” | “arc” | “poly” | “bezier” | “text”, pts: [x, y][], width?: number, style?: object, text?: string, size?: number, rot?: number | path, changed, newIds, dryRun, diff |
lib.symbol.addPin | edsnx lib symbol add-pin | edit | Add pin to library symbol. Add a pin to a library symbol: number, name, electrical type, graphic shape, connection point (library mm, y up), orientation (direction towards the body), length, unit and body style. newIds = [pin id]. | path: string, symbol: string, number: string, name?: string = “~”, type?: “input” | “output” | “bidirectional” | “tri_state” | “passive” | “free” | “unspecified” | “power_in” | “power_out” | “open_collector” | “open_emitter” | “no_connect” = “passive”, shape?: “line” | “inverted” | “clock” | “inverted_clock” | “input_low” | “clock_low” | “output_low” | “edge_clock_high” | “non_logic” = “line”, at: [x, y], rot?: number = 0, length?: number = 2.54, hidden?: boolean, unit?: integer = 1, bodyStyle?: integer = 1 | path, changed, newIds, dryRun, diff |
lib.symbol.delete | edsnx lib symbol delete | edit | Delete library symbol. Delete a symbol from a .kicad_sym library (refused while other symbols extend it). | path: string, name: string | path, changed, newIds, dryRun, diff |
lib.symbol.export | edsnx lib symbol export | edit | Export library symbol. Copy a symbol to another .kicad_sym library (created when missing), optionally renamed. A derived symbol is flattened unless its parent is in the target library; replace overwrites a symbol of the same name. | path: string, name: string, to: string, as?: string, replace?: boolean = false | path, changed, newIds, dryRun, diff |
lib.symbol.get | edsnx lib symbol get | query | Library symbol details. One symbol of a .kicad_sym library as the symbol editor sees it: fields, flags, units, De Morgan, pin options, every pin (id, number, name, type, shape, position, orientation, length, unit, body style, alternates) and body graphic (id, kind, points). Library mm, y up. | path: string, name: string | name, fields, units, pins, graphics |
lib.symbol.list | edsnx lib symbol list | query | List library symbols. The symbols of a .kicad_sym library: name, parent (extends), units, De Morgan, power, pin count, description and keywords. | path: string | path, total, symbols |
lib.symbol.new | edsnx lib symbol new | edit | New library symbol. Create a symbol in a .kicad_sym library (the file is created when missing): from scratch with fields, units, De Morgan and power flag, or derived from another symbol (extends). Add pins and graphics with lib.symbol.addPin / addGraphic. | path: string, name: string, extends?: string, reference?: string, value?: string, footprint?: string, datasheet?: string, description?: string, keywords?: string, fpFilters?: string[], units?: integer, deMorgan?: boolean, power?: boolean, text?: string, replace?: boolean | path, changed, newIds, dryRun, diff |
lib.symbol.setProperty | edsnx lib symbol set-property | edit | Set library symbol field. Set or add a field of a library symbol (Reference, Value, Footprint, Datasheet, Description, ki_keywords, ki_fp_filters or a user field); optional position (library mm), visibility and size. | path: string, symbol: string, key: string, value: string, at?: [x, y], hidden?: boolean, size?: number | path, changed, newIds, dryRun, diff |
Examples
lib.footprint.addPadA THT pad:{"path":"Custom.pretty/MyPart.kicad_mod","pad":{"at":[2.54,0],"type":"thru_hole","shape":"circle","size":[1.7,1.7],"drill":{"diameter":1}}}lib.footprint.exportSVG of a footprint:{"path":"Custom.pretty/MyPart.kicad_mod","format":"svg","out":"svg"}lib.footprint.getA library file:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod"}lib.footprint.getFrom the global libraries:{"lib":"Resistor_SMD","name":"R_0603_1608Metric"}lib.footprint.listFootprints of a project library:{"path":"Custom.pretty"}lib.footprint.listA global library:{"lib":"Package_SO","query":"SOIC-8"}lib.footprint.newSOIC-14 from the wizard:{"path":"Custom.pretty","wizard":"soic","params":{"pins":14}}lib.footprint.newBlank:{"path":"Custom.pretty","name":"MyPart"}lib.footprint.padArray2 × 10 header grid from a new pad:{"path":"Custom.pretty/MyPart.kicad_mod","template":{"at":[0,0],"type":"thru_hole","shape":"circle","size":[1.7,1.7]},"array":{"kind":"grid","nx":2,"ny":10,"dx":2.54,"dy":2.54}}lib.footprint.renumberCounter-clockwise from 1:{"path":"Custom.pretty/MyPart.kicad_mod","order":"ccw"}lib.footprint.set3dModelOffset the model:{"path":"Custom.pretty/MyPart.kicad_mod","index":0,"model":{"offset":[0,0,0.1]}}lib.footprint.setAttrsSMD, excluded from the BOM:{"path":"Custom.pretty/MyPart.kicad_mod","attrs":{"type":"smd","excludeFromBom":true}}lib.footprint.wizardList the wizards:{}lib.footprint.wizardA 0805 resistor:{"kind":"chip","params":{"size":"0805","prefix":"R"},"text":false}lib.footprintModels3D models of the footprint:{}lib.importAn Eagle library:{"file":"parts.lbr","format":"eagle","out":"Eagle_parts"}lib.importAn Altium schematic library:{"file":"OpAmps.SchLib","out":"OpAmps"}lib.listFootprint libraries of a project:{"kind":"footprint","path":"board.kicad_pcb"}lib.manageManage libraries:{}lib.managed.approveApprove a symbol and commit:{"path":"libs/acme","parts":["symbol:Acme:R_10k"],"commit":true}lib.managed.statusCheck for updates:{"path":"libs/acme","fetch":true}lib.managed.syncAfter adding parts:{"path":"libs/acme"}lib.managed.whereUsedUses of a symbol:{"lib":"Acme","name":"R_10k"}lib.openModel3dOpen 3D model:{}lib.previewPads of a footprint:{"kind":"footprint","lib":"Resistor_SMD","name":"R_0603_1608Metric"}lib.previewPins of a symbol:{"kind":"symbol","lib":"Device","name":"R"}lib.search0603 resistor footprints:{"query":"0603 resistor","kind":"footprint"}lib.searchOp-amp symbols:{"query":"opamp dual","kind":"symbol","limit":10}lib.symbol.addGraphicA body rectangle with the background fill:{"path":"MyLib.kicad_sym","symbol":"MyChip","unit":0,"kind":"rect","pts":[[-7.62,5.08],[7.62,-5.08]],"width":0.254,"style":{"fillType":"background"}}lib.symbol.addPinA power pin on the left:{"path":"MyLib.kicad_sym","symbol":"MyChip","number":"1","name":"VCC","type":"power_in","at":[-10.16,2.54],"rot":0}lib.symbol.deleteDelete a symbol:{"path":"MyLib.kicad_sym","name":"MyChip"}lib.symbol.exportCopy a symbol to the project library:{"path":"/usr/share/kicad/symbols/Device.kicad_sym","name":"R","to":"Project.kicad_sym"}lib.symbol.getPins and fields of a symbol:{"path":"MyLib.kicad_sym","name":"MyChip"}lib.symbol.listSymbols of a library:{"path":"MyLib.kicad_sym"}lib.symbol.newA new IC symbol:{"path":"MyLib.kicad_sym","name":"MyChip","reference":"U","value":"MyChip","footprint":"Package_SO:SOIC-8_3.9x4.9mm_P1.27mm"}lib.symbol.newA derived symbol:{"path":"MyLib.kicad_sym","name":"MyChipB","extends":"MyChip","value":"MyChipB"}lib.symbol.setPropertySet the footprint:{"path":"MyLib.kicad_sym","symbol":"MyChip","key":"Footprint","value":"Package_SO:SOIC-8_3.9x4.9mm_P1.27mm"}
Checks#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
check.drcsoftforge.edsnx.runDrc | edsnx check drc | check | Run DRC. Design rule check of a board: counts (errors, warnings, per rule) then violations with rule id, severity, message, position (mm) and item ids. Native engine by default (unsaved text, kicad-cli rule ids); engine “kicad-cli” runs KiCad’s own DRC with schematic parity. | path: string, engine?: “native” | “kicad-cli” | “auto” = “native”, rules?: string[], severity?: “all” | “error” | “warning” = “all”, limit?: integer = 200, includeExcluded?: boolean = false | kind, engine, path, errors, warnings, excluded, total, returned, byRule, violations, partial, ms |
check.ercsoftforge.edsnx.runErc | edsnx check erc | check | Run ERC. Electrical rule check of a schematic project (the whole hierarchy of the root sheet): counts then violations with rule id, severity, message, position and item ids. Native engine by default; engine “kicad-cli” runs KiCad’s ERC on the files. | path: string, engine?: “native” | “kicad-cli” | “auto” = “native”, rules?: string[], severity?: “all” | “error” | “warning” = “all”, limit?: integer = 200, includeExcluded?: boolean = false | kind, engine, path, errors, warnings, excluded, total, returned, byRule, violations, partial, ms |
Examples
check.drcErrors only:{"path":"board.kicad_pcb","severity":"error"}check.drcWith KiCad itself:{"path":"board.kicad_pcb","engine":"kicad-cli"}check.ercAll violations:{"path":"root.kicad_sch"}check.ercWith KiCad itself:{"path":"root.kicad_sch","engine":"kicad-cli"}
Custom tools#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
tool.list | edsnx tool list | query | List tools. Custom tools of the project (kicad-tools.json or .kicad/tools.json next to the .kicad_pro): id, name, command, triggers, overlay count. | path: string | projectDir, tools |
tool.run | edsnx tool run | tool | Run tool. Run a custom tool (simulator, script) of the project: substitutes ${board}, ${outputDir}…, streams progress, loads the overlays it writes. Returns state, message, duration, output folder, overlays and the log tail. Save the board first: tools read the files. | path: string, id: string | id, state, message, durationMs, outputDir, overlays, log |
Examples
tool.listTools of a project:{"path":"board.kicad_pcb"}tool.runThermal simulation of the sample project:{"path":"blinky.kicad_pcb","id":"thermal"}
Rendering#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
render.diff | edsnx render diff | query | Visual diff. Visual diff of two PNG files, or of two documents (.kicad_pcb/.kicad_sch, rendered first with the same options): a PNG with unchanged pixels dimmed and changed ones highlighted (green added, red removed, violet recoloured), the changed-area percentage and the changed bounds in pixels. | a: string, b: string, out?: string, threshold?: integer = 24, layers?: string[], width?: integer = 1200, height?: integer = 800, mode?: “2d” | “3d” = “2d” | out, png, changedPercent, changedPixels, width, height, bounds |
render.png | edsnx render png | query | Render PNG. Render a board or schematic to PNG with the editor’s renderer in headless Chromium (2D or 3D), optionally only some layers, a region in mm, or one highlighted net. Returns the file written, or the PNG base64 when no out is given. In an attached session the editor’s unsaved text is rendered. | path: string, out?: string, layers?: string[], region?: [x0, y0, x1, y1], highlightNet?: string, mode?: “2d” | “3d” = “2d”, width?: integer = 1200, height?: integer = 800, theme?: “dark” | “light” = “dark”, camera?: “iso” | “top” | “bottom” | “front” | “back” | “left” | “right”, realistic?: boolean, view3d?: object | out, png, width, height, mode |
render.svg | edsnx render svg | export | Render SVG. Plot a board (chosen layers, board area only) or one schematic page to SVG with kicad-cli. Returns the file written, or the SVG text when no out is given. | path: string, out?: string, layers?: string[], page?: integer | out, svg, bytes |
Examples
render.diffWhat changed between two boards:{"a":"old.kicad_pcb","b":"board.kicad_pcb","out":"diff.png"}render.pngTop copper of a board, 1200×800:{"path":"board.kicad_pcb","out":"board.png","layers":["F.Cu","Edge.Cuts"]}render.pngRealistic 3D render, ENIG on a black mask:{"path":"board.kicad_pcb","out":"board-3d.png","realistic":true,"view3d":{"realistic":{"finish":"enig","mask":"black"}}}render.svgCopper and outline of a board:{"path":"board.kicad_pcb","out":"board.svg","layers":["F.Cu","B.Cu","Edge.Cuts"]}
Session#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
session.baselinesoftforge.edsnx.design.baseline | edsnx session baseline | edit | Create baseline. Names the current state of an open document in its design file: a baseline.create event (id, name, description; the state hash is recorded when the list is applied), one undo step, written on save. Returns the baseline id. | path: string, name: string, description?: string | id, path |
session.batch | edsnx session batch | session | Batch. Run registry commands in order ({ id, args } steps, as a –batch file) as one undoable group: the first failure rolls every document back. Returns each step’s result. | label?: string = “Batch”, steps: object[] | steps, results |
session.close | edsnx session close | session | Close document. Close a document (unsaved changes are dropped). | path: string | closed |
session.consolidatesoftforge.edsnx.design.consolidate | edsnx session consolidate | session | Consolidate design file. Folds the write-append list of a design file into its tree (docs/design-file-format.md §9): the tree becomes the document after the last event in effect, the list restarts with a wal.base marker and one consolidate record, and the file is written whole. For an open document the folded tree is checked against what the session shows, the document must be saved first and its undo history is cleared; a design file that is not open is consolidated on disk. Refused when an event does not apply. | path: string | path, folded |
session.describe | edsnx session describe | session | Describe session. Session id and mode (headless or attached), working directory, actor, open documents with their undo/redo labels when the session keeps them. | — | id, mode, cwd, actor, documents |
session.documents | edsnx session documents | session | Open documents. Documents open in the session with revision, hash and dirty flag. | — | documents |
session.exportsoftforge.edsnx.agent.exportSession | edsnx session export | export | Export session. Export the session log (.edsnx/session.jsonl of the project: every command of the edsnx CLI and of agents attached to the editor, with revisions, created ids and errors) as JSON (one document: summary and entries) or as a Markdown report. Writes out (relative to the working directory) when given, else returns the text. Returns the format, the log file, the entry count and the file written or the text. | format?: “json” | “markdown” = “markdown”, log?: string, out?: string, since?: string, limit?: integer, title?: string | format, log, entries, failed, out, text |
session.gettingStartedsoftforge.edsnx.gettingStarted | edsnx session getting-started | ui | Getting started. Open the Getting started page: the setup status of the extension (kicad-cli, global library tables, licence, panels layout, agent and MCP) with one action per row; linked from the Welcome page (2.4.0 #503, #506). UI-only: opens its own page. | path?: string | object |
session.open | edsnx session open | session | Open document. Open a board or schematic in the session (reads the file and its .kicad_pro). Returns path, kind, revision and hash. | path: string | path, kind, revision, hash, dirty, project |
session.openDesignFilesoftforge.edsnx.design.openDesignFile | edsnx session open-design-file | ui | Open design file. Opens the design file of the active document in the editor: the .design.* cache of a KiCad file of a KiCad project, or the design file a migrated project’s KiCad file is exported from. | — | opened |
session.panels.revealsoftforge.edsnx.panels.reveal | edsnx session panels reveal | ui | Show a workbench view. Show a view of the SoftForge side bars for the open document (Layers, Properties, Checks, Nets, 3D, …): panel is a panel id, all (every view serving the document kind) or default (the default set). path opens that document first. The focus stays in the editor unless focus is true. Returns the panels shown and the ones that do not serve the document kind; with layout.panels = editor nothing is shown (layout editor). Views show what the editor shows; agents read the same data with query.* and check.*. UI-only: needs the open editor. | panel: “layers” | “items” | “nets” | “sheets” | “design” | “inspect” | “properties” | “bom” | “layerStack” | “fpLib” | “symLib” | “gerber” | “objects” | “document” | “libraries” | “tools” | “fpProps” | “symProps” | “gerberTools” | “panelEditor” | “group” | “checks” | “requirements” | “wires” | “review” | “routing” | “placement” | “testPoints” | “docProperties” | “view3d” | “lengthMatching” | “overlays” | “probes” | “system” | “harness” | “dfm” | “reuse” | “simulation” | “mcad” | “si” | “agent” | “comments” | “all” | “default”, path?: string, focus?: boolean = false | shown, skipped, layout |
session.preferencessoftforge.edsnx.preferences | edsnx session preferences | ui | Preferences. Open the editor preferences. UI-only: needs the open editor. | path?: string | object |
session.redosoftforge.edsnx.redo | edsnx session redo | session | Redo. Redo the last undone edit of a document. done=false when there was nothing to redo. | path: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, done |
session.revert | edsnx session revert | session | Revert. Discard unsaved changes and the undo history of a document; reload it from disk. | path: string | path, kind, revision, hash, dirty, project |
session.save | edsnx session save | session | Save. Write a document (or every changed document) and its .kicad_pro to disk; returns the files written. | path?: string | written |
session.toolGallerysoftforge.edsnx.toolGallery | edsnx session tool-gallery | ui | Tool gallery. Open the Tool gallery (every editor tool with its demo clip, keys and description). Agents: read docs/tools.md. UI-only: needs the open editor. | path?: string | object |
session.transaction | edsnx session transaction | edit | Transaction. Apply several raw EditIntents to one document as one undo step; everything is rolled back on the first failure. Returns newIds of all steps. | path: string, label?: string = “Transaction”, intents: object[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
session.undosoftforge.edsnx.undo | edsnx session undo | session | Undo. Undo the last edit of a document. done=false when there was nothing to undo. | path: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, done |
session.welcomesoftforge.edsnx.welcome | edsnx session welcome | ui | Welcome. Open the Welcome page: the wordmark, the version and the kicad-cli found, Open a KiCad project… and Create an example board, the five cards (schematic editor, board editor, libraries, fabrication, edsnx and the agent) and the links to the documentation, the setup page, the issues and the licence; opens once after install while softforge.edsnx.welcome.showOnStartup is true (2.4.0 #506). UI-only: opens its own page. | path?: string | object |
Examples
session.baselineMark the state sent to the fab:{"path":"blinky.design.pcb","name":"Sent to fab"}session.batchPlace and route:{"steps":[{"id":"pcb.placeFootprint","args":{"path":"board.kicad_pcb","lib":"Resistor_SMD","name":"R_0603_1608Metric","at":[30,20],"ref":"R9"}},{"id":"pcb.route","args":{"path":"board.kicad_pcb","layer":"F.Cu","net":"GND","pts":[[29.2,20],[25,20]]}}]}session.closeClose:{"path":"board.kicad_pcb"}session.consolidateFold the history of the open board:{"path":"blinky.design.pcb"}session.describeDescribe:{}session.documentsList:{}session.exportMarkdown report next to the project:{"format":"markdown","out":"session.md"}session.exportThe last hour as JSON:{"format":"json","since":"1h"}session.gettingStartedGetting started:{}session.openOpen a board:{"path":"board.kicad_pcb"}session.openDesignFileOpen the design file:{}session.panels.revealShow the Checks view:{"panel":"checks"}session.panels.revealShow the default views of a board:{"panel":"default","path":"blinky.kicad_pcb"}session.preferencesPreferences:{}session.redoRedo:{"path":"board.kicad_pcb"}session.revertRevert:{"path":"board.kicad_pcb"}session.saveSave everything:{}session.toolGalleryTool gallery:{}session.transactionTwo tracks at once:{"path":"board.kicad_pcb","label":"Two tracks","intents":[{"op":"addTrack","layer":"F.Cu","pts":[[0,0],[5,0]],"width":0.25},{"op":"addTrack","layer":"F.Cu","pts":[[5,0],[5,5]],"width":0.25}]}session.undoUndo:{"path":"board.kicad_pcb"}session.welcomeWelcome:{}
Timeline and export#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
timeline.export | edsnx timeline export | ui | Export playback. Render the timeline frame by frame (frame-locked) and save a WebM, an MP4 (needs ffmpeg on PATH) or a PNG sequence (.zip) to out. Options: fps, width × height, range [start, end] in base units (default in/out or the whole timeline), hud (time readout + legend), view 2d/3d. Returns the file written and the frame count. Needs the open editor (attached session). | path?: string, out: string, format?: “webm” | “mp4” | “png”, fps?: number = 30, width?: integer = 1920, height?: integer = 1080, range?: [x, y], hud?: boolean = true, view?: “2d” | “3d” | path, frames |
timeline.get | edsnx timeline get | query | Timeline state. The playback state of the board editor: t, range, playing, speed, loop, in/out, live and the time-bearing overlays with their axes. state is null when the editor has no timeline yet. Needs the attached editor. | path?: string | state |
timeline.pause | edsnx timeline pause | ui | Pause. Pause playback. Needs the open editor (attached session). | path?: string | state |
timeline.play | edsnx timeline play | ui | Play. Start playback of the time-bearing overlays from the playhead. Needs the open editor (attached session). | path?: string | state |
timeline.seek | edsnx timeline seek | ui | Seek. Move the playhead to t (base units: s, Hz, step or degrees), or step n frames with step. Needs the open editor (attached session). | path?: string, t?: number, step?: integer | state |
timeline.set | edsnx timeline set | session | Set timeline. Change the playback state: seek (t), play/pause (playing), speed, real time, loop, in/out range (null clears), follow live frames. Returns the new state. Needs the attached editor. | path?: string, state: object | state |
Examples
timeline.exportExport the in/out range as WebM:{"out":"sim/playback.webm","fps":30,"width":1920,"height":1080}timeline.getWhere is the playhead?:{}timeline.pausePause:{}timeline.playPlay:{}timeline.seekGo to 1.5 ns:{"t":1.5e-9}timeline.seekNext frame:{"step":1}timeline.setLoop the first 2 ns at half speed:{"state":{"inOut":[0,2e-9],"loop":true,"speed":0.5}}
Overlays and probes#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
overlay.probes.add | edsnx overlay probes add | session | Add probe. Pin a probe at a board point (mm) on a field overlay (default: the one whose legend is shown); it records the value over every frame. Returns the probe (with its trace when traces is true). Needs the attached editor. | path?: string, at: [x, y], overlayId?: string, z?: number, label?: string, id?: string, component?: “magnitude” | “x” | “y” | “z” | “phase”, traces?: boolean = false | probe |
overlay.probes.export | edsnx overlay probes export | export | Export probes. The probe traces as CSV (one row per frame time, one column per probe component; empty cells are frames not sampled yet). Returns the CSV text. Needs the attached editor. | path?: string, ids?: string[] | csv |
overlay.probes.list | edsnx overlay probes list | query | List probes. Probes pinned on time-bearing overlays: id, overlay, position (mm), label, unit, frames and how many are sampled, components; with traces: every value per component and the frame times. Needs the attached editor. | path?: string, ids?: string[], traces?: boolean = false | probes |
overlay.probes.remove | edsnx overlay probes remove | session | Remove probes. Remove probes by id (all when ids is omitted). Returns the removed ids. Needs the attached editor. | path?: string, ids?: string[] | removed |
Examples
overlay.probes.addProbe |E| near U1:{"at":[42.5,31.2],"label":"U1 pin 3"}overlay.probes.exportCSV of all probes:{}overlay.probes.listProbes with their traces:{"traces":true}overlay.probes.removeRemove every probe:{}
Documentation sheets#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
doc.autoBalloon | edsnx doc auto-balloon | edit | Auto-balloon a view. Place a balloon for every BOM part shown in a view (numbered with the first BOM table’s lines), laid out around the view; existing balloons of the view keep their ids. Default view: the first top/bottom view. | path: string, viewId?: string | added, balloons, viewId, dryRun |
doc.exportsoftforge.edsnx.doc.export | edsnx doc export | export | Export documentation set. Export the documentation set with kicad-cli: PDF = one file, every sheet in the print order (root sidecar order; unlisted schematic sheets first), one bookmark per sheet; SVG / DXF = one file per sheet into a folder. sheet exports one sheet (or a few) instead of the set. Reads the files on disk (save first). | path: string, format?: “pdf” | “svg” | “dxf” = “pdf”, out?: string, includeSchematics?: boolean = true, bookmarks?: boolean = true, sheet?: string, viewer?: boolean = false | files, pages, reordered, bookmarks, warnings |
doc.insertTable | edsnx doc insert-table | edit | Insert a documentation table. Add a live table to a documentation sheet and generate it: layer stack (Board Setup stack-up), drill table (pads and vias), BOM (grouped like kicad-cli, bom scope / groupBy / fields), revision, board notes or custom. at is the table’s top-left corner (sheet mm). | path: string, kind?: “layerStack” | “drill” | “bom” | “revision” | “notes” | “custom” = “bom”, at?: [x, y], name?: string, bom?: object, fontSize?: number | changed, ok, message, id, dryRun |
doc.insertView | edsnx doc insert-view | edit | Insert a draft view. Add a draft view of the board to a sheet (it becomes a documentation sheet when it has no sidecar yet) and generate it: top / bottom (mirrored) assembly, fabrication, detail (board region, parent view), section (board line, parent) or a 3D render (camera). at is where the view’s top-left board corner lands on the sheet (mm). | path: string, type?: “top” | “bottom” | “fabrication” | “detail” | “section” | “render3d” = “top”, at?: [x, y], style?: “assembly” | “fabrication” | “realistic” | “outline” | “panel”, scale?: number, layers?: string[], name?: string, board?: string, parent?: string, region?: [x0, y0, x1, y1], line?: [x, y][], camera?: “iso” | “top” | “bottom” | “front” | “back” | “left” | “right”, update?: “onSave” | “manual” | changed, ok, message, id, dryRun |
doc.newSheetsoftforge.edsnx.doc.newSheet | edsnx doc new-sheet | edit | New documentation sheet. Create a documentation sheet <name>.kicad_sch (paper, title block) with an empty sidecar, add it to the hierarchy under the root schematic and put it last in the documentation set’s print order. | path: string, name: string, paper?: “A5” | “A4” | “A3” | “A2” | “A1” | “A0” | “A” | “B” | “C” | “D” | “E” = “A3”, file?: string | file, sheetId, dryRun |
doc.refreshsoftforge.edsnx.doc.refreshAll | edsnx doc refresh | edit | Refresh documentation from the board. Regenerate the views, tables, balloons, dimensions and notes of a documentation sheet from its board (all of them, or ids), rewrite their groups in the sheet and stamp the sidecar (board hash, revision, time). | path: string, ids?: string[] | changed, ok, message, id, dryRun |
doc.status | edsnx doc status | query | Documentation sheet status. Whether a sheet is a documentation sheet (it has a <sheet>.kicad_doc.json sidecar), its views and tables with their stale flags (board changed since generation), balloon count and orphan groups, and the documentation set’s sheets in print order. | path: string | documentation, sheet, status, sidecar, tree |
Examples
doc.autoBalloonBalloon the top view:{"path":"assembly.kicad_sch"}doc.exportOne PDF with bookmarks:{"path":"blinky.kicad_sch","format":"pdf","out":"doc/blinky-documentation.pdf"}doc.exportThe assembly sheet alone as SVG:{"path":"blinky.kicad_sch","format":"svg","out":"doc/svg/","sheet":"assembly.kicad_sch"}doc.insertTableProject BOM table:{"path":"assembly.kicad_sch","kind":"bom","at":[280,30]}doc.insertViewTop assembly view at 1:1:{"path":"assembly.kicad_sch","type":"top","at":[30,40]}doc.insertViewDetail of a region at 4:1:{"path":"assembly.kicad_sch","type":"detail","parent":"v1","region":[100,80,110,90],"scale":4,"at":[250,40]}doc.newSheetAn A3 assembly sheet:{"path":"blinky.kicad_sch","name":"Assembly","paper":"A3"}doc.refreshRefresh every view and table:{"path":"assembly.kicad_sch"}doc.statusStatus of the assembly sheet:{"path":"assembly.kicad_sch"}
Review#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
review.approve | edsnx review approve | edit | Approve design review. Approve a design review as the git user (or user), with an optional comment. Refused (check-failed, listing the open items) while checklist items are not done; Request changes is not gated. The review is approved when someone approved and nobody requests changes. | path?: string = “.”, review?: string, comment?: string, user?: string | file, review |
review.checklist | edsnx review checklist | edit | Edit review checklist. Tick / untick a checklist item of a design review (item: id, 1-based index or text; done default toggles), add one (add) or remove one (remove). Without changes it returns the checklist. | path?: string = “.”, review?: string, item?: string, done?: boolean, add?: string, remove?: string, by?: string | file, checklist, done, total |
review.ciReport | edsnx review ci-report | check | Review CI report. The last step of the CI template: reads the check outputs of the pipeline (checks folder: erc.json, drc.json, req.json from edsnx … --json), the exported viewer, and writes review-ci.json (status passed / failed, one entry per check, pipeline / viewer / report URLs) and the review report (Markdown: review state, checks, changes against the base, comments). strict fails (exit 1) when a check failed, after writing. | path?: string = “.”, checks?: string, viewer?: string, out?: string = “review-ci.json”, report?: string, pipeline?: string, viewerUrl?: string, reportUrl?: string, review?: string, strict?: boolean = false | file, report, status, checks |
review.ciTemplate | edsnx review ci-template | query | Review CI template. The design review pipeline for GitLab CI (gitlab, .gitlab-ci.yml) or GitHub Actions (github, .github/workflows/design-review.yml): installs the edsnx CLI from the SoftForge Electronics Designer VSIX (EDSNX_VSIX_URL), runs edsnx check erc / drc, edsnx req eval, edsnx viewer export and edsnx review ci-report, publishes public/ (viewer, report, review-ci.json) as artifacts and pages. out writes it; project is the project folder relative to the repository root. | gitlab?: boolean = false, github?: boolean = false, project?: string, out?: string | kind, text, file |
review.create | edsnx review create | edit | Create design review. Create a design review for a branch (default: the current git branch) against a base (default: origin’s default branch, else main / master): title, checklist (the default template or checklist), reviewers (pending approvals). Stored in <project>.reviews.json; one live review per branch. | path?: string = “.”, title: string, branch?: string, base?: string, checklist?: string[], reviewers?: string[], author?: string | file, review |
review.diff | edsnx review diff | query | Review changes. Change list of a board or schematic against a git revision (HEAD, a branch, a tag, a commit, : for the index) or another file: items matched by uuid, each added, removed, moved (position, rotation, side/layer) or changed (reference, value, footprint/symbol, net, lock, fields, attributes, geometry, pad nets) with one detail line per difference (“moved (+2.54, 0)”, “Value 10k → 4k7”), the position (mm) and bounds. Also returns the counts per kind and the base label. | path: string, base: string, against?: string, sheets?: boolean = false | path, base, changes, counts, sheets |
review.image | edsnx review image | query | Review visual diff. Visual diff of a board or schematic against a git revision or another file: both are rendered with the editor’s renderer in headless Chromium over the same area (the union of both documents’ bounds), then compared pixel by pixel (unchanged pixels dimmed, added green, removed red, recoloured violet). Returns the PNG file written (or base64 without out), the changed-area percentage and the changed bounds in pixels. Needs Chromium or Chrome (CHROME_PATH). | path: string, base: string, against?: string, out?: string, width?: integer = 1200, height?: integer = 800, threshold?: integer = 24, layers?: string[], theme?: “dark” | “light” = “dark” | out, png, changedPercent, changedPixels, width, height, bounds, base |
review.notes | edsnx review notes | export | Review release notes. Release notes of a design review as Markdown: the commits of the branch since its base (git log base..HEAD), the design changes (refresh first), the resolved comment threads, the CI checks and the review state. out writes the file. | path?: string = “.”, review?: string, out?: string, intro?: string | text, file, commits |
review.requestChanges | edsnx review request-changes | edit | Request changes. Request changes on a design review as the git user (or user), with a comment saying what. | path?: string = “.”, review?: string, comment?: string, user?: string | file, review |
review.status | edsnx review status | query | Design review status. A design review (default: the open review of the current branch, all lists every review): state, checklist progress, approvals, CI status from review-ci.json (project folder, ci/, public/ or ci), and with refresh the changed items against the base (0.9.0 review diff; image adds the visual diff %, needs Chromium), written back to the sidecar. | path?: string = “.”, review?: string, all?: boolean = false, refresh?: boolean = false, image?: boolean = false, ci?: string | file, review, reviews, branch, warnings |
Examples
review.approveApprove the current branch:{"comment":"Fab files look good"}review.checklistTick item 2:{"item":"2","done":true}review.checklistAdd an item:{"add":"Thermal relief on the GND pads"}review.ciReportAfter the check steps of the template:{"checks":"ci","viewer":"public/viewer","out":"public/review-ci.json","strict":true}review.ciTemplateGitLab CI:{"gitlab":true,"out":".gitlab-ci.yml"}review.ciTemplateGitHub Actions:{"github":true,"out":".github/workflows/design-review.yml"}review.createReview the current branch:{"title":"USB-C connector and fab review"}review.createWith reviewers:{"title":"Rev B","base":"main","reviewers":["Maria"]}review.diffWhat changed in the board since the last commit:{"path":"board.kicad_pcb","base":"HEAD"}review.diffSchematic on a branch against main:{"path":"board.kicad_sch","base":"main","against":"feature"}review.imageVisual diff of the board against HEAD:{"path":"board.kicad_pcb","base":"HEAD","out":"review.png"}review.notesNotes of the current branch:{"out":"review/release-notes.md"}review.requestChangesAsk for a change:{"comment":"Move R8 off the crystal"}review.statusStatus of the current branch with changes:{"refresh":true}review.statusEvery review:{"all":true}
Simulation#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
sim.ac | edsnx sim ac | tool | AC analysis. Small-signal AC sweep (.ac dec|oct|lin points fstart fstop). Vectors are complex: summaries give the magnitude; measurements f3db, bw, gainAt and phaseAt work on |H|. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, measurements?: object[], out?: string, currents?: boolean, sweep?: “dec” | “oct” | “lin” = “dec”, points?: integer = 20, fstart?: string = “10”, fstop?: string = “1Meg” | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
sim.measure | edsnx sim measure | tool | Measure. Run the analysis and return only the measurements (rise time, peak, RMS, frequency at −3 dB, …), computed in JS from the result vectors so they work with any ngspice. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, analysis?: object, measurements: object[] | analysis, measurements, diagnostics |
sim.models.list | edsnx sim models list | query | List simulation models. Simulation model of every symbol (device, type, parameters, pin map, library, enabled, tolerance; inferred when it has no Sim fields) and the model files (.lib/.sub/.mod) of the project with their model counts. | path: string | symbols, libraries, used |
sim.models.set | edsnx sim models set | edit | Set simulation model. Write the Sim.* fields of a symbol (by reference or id): device, type, params (object, merged over the current ones unless replaceParams), pins (“1=+ 2=-”), library, name, enabled (Sim.Enable), tolerance (“5%”). One undo step. | path: string, ref?: string, id?: string, device?: string, type?: string, params?: object, replaceParams?: boolean = false, pins?: string, library?: string, name?: string, enabled?: boolean, tolerance?: string | object |
sim.montecarlo | edsnx sim montecarlo | tool | Monte Carlo. Run an analysis N times with R/C/L values drawn within their tolerance (Sim.Tolerance, else defaults R 1 %, C 10 %, L 10 %) and any further parameter named in params (source, model, instance or .param values, with their tolerance), seeded; progress per phase (netlist, runs, post-processing); returns per measurement mean, std, min, max, p5/p50/p95 and a histogram, plus the varied parts. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, measurements?: object[], out?: string, currents?: boolean, analysis?: object, runs?: integer = 50, seed?: integer = 1, distribution?: “gaussian” | “uniform” = “gaussian”, defaults?: object, params?: object[] | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
sim.netlist | edsnx sim netlist | query | SPICE netlist. The SPICE netlist of a schematic (kicad-cli or the built-in netlister) with its analysis directives; out writes it to a file. Returns the netlister used, element count, warnings and the netlist text (first 200 lines). | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, out?: string | netlister, elements, analyses, warnings, netlist, out |
sim.op | edsnx sim op | tool | Operating point. DC operating point (.op): every node voltage and, per device, the current through it, the voltage across it and the absorbed power (W; negative for sources delivering power). | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, out?: string | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
sim.run | edsnx sim run | tool | Run simulation. Run ngspice on the schematic: the given analysis (default the schematic’s first .tran/.ac/.dc/.op directive), optionally a parameter sweep or Monte Carlo, with measurements. Returns per-vector summaries (min, max, final), the operating point, measurements, Monte Carlo statistics and diagnostics; out writes every vector as CSV. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, measurements?: object[], out?: string, currents?: boolean, analysis?: object, sweep?: object, montecarlo?: object | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
sim.sweep | edsnx sim sweep | tool | Parameter sweep. Repeat an analysis for each value of an element (its value rewritten) or a .param (rewritten or added): values, or start/stop/points on a lin/log scale. Returns one plot summary and measurement row per step. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, measurements?: object[], out?: string, currents?: boolean, analysis?: object, target: string, values?: number[], start?: number, stop?: number, points?: integer, scale?: “lin” | “log”, kind?: “element” | “param” | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
sim.tran | edsnx sim tran | tool | Transient analysis. Transient analysis (.tran step stop [start [maxStep]]), SPICE numbers as strings (“10u”, “5m”). Returns per-vector min/max/final and the measurements; out writes the waveforms as CSV. | path: string, netlister?: “auto” | “kicad-cli” | “builtin” = “auto”, measurements?: object[], out?: string, currents?: boolean, step?: string = “10u”, stop?: string = “1m”, start?: string, maxStep?: string, uic?: boolean | analysis, netlister, ngspice, durationMs, plots, op, measurements, montecarlo, sweep, diagnostics, warnings, out |
Examples
sim.acBode of the RC low-pass:{"path":"examples/sim-rc/sim-rc.kicad_sch","measurements":[{"kind":"f3db","trace":"V(/out)"}]}sim.measurePeak-to-peak and RMS of the output:{"path":"examples/sim-rc/sim-rc.kicad_sch","measurements":[{"kind":"pp","trace":"V(/out)"},{"kind":"rms","trace":"V(/out)"}]}sim.models.listModels of the RC example:{"path":"examples/sim-rc/sim-rc.kicad_sch"}sim.models.setR1 as a 2.2k resistor with 1 % tolerance:{"path":"examples/sim-rc/sim-rc.kicad_sch","ref":"R1","device":"R","params":{"r":"2.2k"},"tolerance":"1%"}sim.montecarlo50 runs of the corner frequency:{"path":"examples/sim-rc/sim-rc.kicad_sch","runs":50,"analysis":{"kind":"ac","sweep":"dec","points":20,"fstart":"10","fstop":"1Meg"},"measurements":[{"kind":"f3db","trace":"V(/out)"}]}sim.netlistNetlist of the RC example:{"path":"examples/sim-rc/sim-rc.kicad_sch"}sim.netlistBuilt-in netlister into a file:{"path":"examples/sim-rc/sim-rc.kicad_sch","netlister":"builtin","out":"sim/rc.cir"}sim.opBias point:{"path":"examples/sim-rc/sim-rc.kicad_sch"}sim.runThe schematic’s own analysis:{"path":"examples/sim-rc/sim-rc.kicad_sch"}sim.runAC with the −3 dB point:{"path":"examples/sim-rc/sim-rc.kicad_sch","analysis":{"kind":"ac","sweep":"dec","points":20,"fstart":"10","fstop":"1Meg"},"measurements":[{"kind":"f3db","trace":"V(/out)"}]}sim.sweepR1 = 1k, 2k, 4k on the AC response:{"path":"examples/sim-rc/sim-rc.kicad_sch","target":"R1","values":[1000,2000,4000],"analysis":{"kind":"ac","sweep":"dec","points":10,"fstart":"10","fstop":"1Meg"},"measurements":[{"kind":"f3db","trace":"V(/out)"}]}sim.tran5 ms with the peak-to-peak of /out:{"path":"examples/sim-rc/sim-rc.kicad_sch","step":"10u","stop":"5m","measurements":[{"kind":"pp","trace":"V(/out)"}]}
Footprint edits#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
fp.fpAddGraphic | edsnx fp fp-add-graphic | edit | Add graphic. Add a line, rect, circle, arc, polygon or Bézier on a footprint layer (F.SilkS, F.Fab, F.CrtYd, …). newIds = [id]. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, graphic: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpAddPad | edsnx fp fp-add-pad | edit | Add pad. Add a pad to the footprint (defaults: SMD roundrect 1 × 1 mm on F.Cu/F.Paste/F.Mask, the next free number; THT pads get a drill). newIds = [pad id]. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, pad: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpDelete | edsnx fp fp-delete | edit | Delete footprint. Library operation: delete footprint name from the .pretty. Acts on the .pretty folder of path. | path: string, name: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpDeleteGraphic | edsnx fp fp-delete-graphic | edit | Delete graphics. Delete graphics, user texts or text boxes. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpDeletePad | edsnx fp fp-delete-pad | edit | Delete pads. Delete pads. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, ids: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpDuplicate | edsnx fp fp-duplicate | edit | Duplicate footprint. Library operation: copy footprint name of the .pretty to newName (the editor host applies it; headless: lib.footprint.new with from). Acts on the .pretty folder of path. | path: string, name: string, newName: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpEditGraphic | edsnx fp fp-edit-graphic | edit | Edit graphic. Change a graphic: layer, width, points, fill, stroke type. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, id: string, patch: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpEditPad | edsnx fp fp-edit-pad | edit | Edit pads. Change pad fields (number, type, shape, position, size, drill, layers, margins, thermal settings, pin function/type, custom primitives…); null removes an optional field. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, ids: string[], patch: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpEditText | edsnx fp fp-edit-text | edit | Edit text. Change a footprint text (Reference, Value, a property with a layer, a user text) or text box: text, layer, position, rotation, size [w, h], thickness, hidden, knockout, mirror, justify, bold, italic; text boxes also box [w, h], align, valign, border, borderWidth, strokeType and margins. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, id: string, patch: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpNewFootprint | edsnx fp fp-new-footprint | edit | New footprint. Replace the footprint (replace: true) with a blank one or a wizard result (soic, qfp, qfn, bga, dip, sip, chip, tht2, header, mountingHole); without replace the editor host / lib.footprint.new writes a new file. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, name: string, wizard?: object, replace?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpPadArray | edsnx fp fp-pad-array | edit | Pad array. Grid or circular array of a pad (template: a pad id or a pad spec), numbered numerically, alphabetically or BGA-style (A1…); the template is element 0 unless removeTemplate. newIds are the new pads. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, template: string | object, array: object, removeTemplate?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpRemove3dModel | edsnx fp fp-remove3d-model | edit | Remove 3D model. Remove 3D model index. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, index: integer | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpRename | edsnx fp fp-rename | edit | Rename footprint. Library operation: rename footprint name of the .pretty (file and footprint name). Acts on the .pretty folder of path. | path: string, name: string, newName: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpRenumberPads | edsnx fp fp-renumber-pads | edit | Renumber pads. Renumber pads in the given order (KiCad’s Renumber Pads tool, click order): prefix + start, start + step, … Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, ids: string[], start?: integer = 1, step?: integer = 1, prefix?: string | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpSet3dModel | edsnx fp fp-set3d-model | edit | 3D model. Change 3D model index (or add one without index): path, offset [x, y, z] mm, scale, rotate [x, y, z] degrees, hide, opacity. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, index?: integer, model: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpSetAttrs | edsnx fp fp-set-attrs | edit | Footprint attributes. Footprint type (smd / through_hole / unspecified), board only, exclude from position files / BOM, DNP, allow missing courtyard, allow soldermask bridges, private layers. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, attrs: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpSetClearances | edsnx fp fp-set-clearances | edit | Footprint clearances. Footprint-level overrides: clearance, solder mask margin, paste margin and ratio, zone connection, thermal relief width and gap (null removes one). Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, clearances: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpSetNetTieGroups | edsnx fp fp-set-net-tie-groups | edit | Net tie groups. Net tie pad groups, each a comma-separated list of pad numbers (“1, 2”); [] removes them. Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, groups: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
fp.fpSetProperty | edsnx fp fp-set-property | edit | Footprint property. Set (value null: remove) a footprint property: Description and Keywords (descr / tags), Reference, Value, Datasheet or a user field (new fields are hidden on F.Fab). Edits the .kicad_mod in place (minimal diff); returns newIds and the new hash. | path: string, name: string, value: string | null, hidden?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
Examples
fp.fpAddGraphicAdd graphic:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","graphic":{"kind":"rect","layer":"F.CrtYd","pts":[[-2,-1],[2,1]],"width":0.05}}fp.fpAddPadAdd pad:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","pad":{"at":[2,0],"type":"smd","shape":"roundrect","size":[1.2,0.6]}}fp.fpDeleteDelete footprint:{"path":"Custom.pretty","name":"R_0603_Mine"}fp.fpDeleteGraphicDelete graphics:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","ids":["fpg:2"]}fp.fpDeletePadDelete pads:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","ids":["pad:3"]}fp.fpDuplicateDuplicate footprint:{"path":"Custom.pretty","name":"R_0603_1608Metric","newName":"R_0603_Custom"}fp.fpEditGraphicEdit graphic:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","id":"fpg:0","patch":{"layer":"F.Fab","width":0.1}}fp.fpEditPadEdit pads:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","ids":["pad:0"],"patch":{"size":[1.5,0.7],"maskMargin":0.05}}fp.fpEditTextEdit text:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","id":"prop:Reference","patch":{"at":[0,-2.5],"layer":"F.SilkS"}}fp.fpNewFootprintNew footprint:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","name":"SOIC-8_Custom","wizard":{"kind":"soic","params":{"pins":8}},"replace":true}fp.fpPadArrayPad array:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","template":"pad:0","array":{"kind":"grid","nx":4,"ny":1,"dx":1.27,"dy":0,"start":1}}fp.fpRemove3dModelRemove 3D model:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","index":0}fp.fpRenameRename footprint:{"path":"Custom.pretty","name":"R_0603_Custom","newName":"R_0603_Mine"}fp.fpRenumberPadsRenumber pads:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","ids":["pad:0","pad:1"],"start":1}fp.fpSet3dModel3D model:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","model":{"path":"${KICAD9_3DMODEL_DIR}/Package_SO.3dshapes/SOIC-8_3.9x4.9mm_P1.27mm.step"}}fp.fpSetAttrsFootprint attributes:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","attrs":{"type":"smd","excludeFromBom":false}}fp.fpSetClearancesFootprint clearances:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","clearances":{"maskMargin":0.05,"clearance":null}}fp.fpSetNetTieGroupsNet tie groups:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","groups":["1, 2"]}fp.fpSetPropertyFootprint property:{"path":"Custom.pretty/SOIC-8_Custom.kicad_mod","name":"Description","value":"SOIC-8, 1.27 mm pitch"}
Symbol edits#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
sym.symAddGraphic | edsnx sym sym-add-graphic | edit | Add body graphic. Add a body graphic to a library symbol: rect [start, end], circle [centre, point on circle], arc [start, mid, end], line/poly/bezier points or text [at] (library mm, y up). Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, unit?: integer, bodyStyle?: integer, kind: “line” | “rect” | “circle” | “arc” | “poly” | “bezier” | “text”, pts: [x, y][], width?: number, style?: object, text?: string, size?: number, rot?: number | path, changed, newIds, dryRun, diff |
sym.symAddPin | edsnx sym sym-add-pin | edit | Add pin. Add a pin to a library symbol (library mm, y up; rot = direction towards the body, 0/90/180/270). newIds = [pin id]. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, unit?: integer, bodyStyle?: integer, pin: object | path, changed, newIds, dryRun, diff |
sym.symDeleteGraphic | edsnx sym sym-delete-graphic | edit | Delete body graphics. Delete body graphics of a library symbol by id. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, ids: string[] | path, changed, newIds, dryRun, diff |
sym.symDeletePin | edsnx sym sym-delete-pin | edit | Delete pins. Delete pins of a library symbol by id. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, ids: string[] | path, changed, newIds, dryRun, diff |
sym.symDeleteSymbol | edsnx sym sym-delete-symbol | edit | Delete symbol. Delete a symbol from the library (refused while other symbols extend it). Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, name: string | path, changed, newIds, dryRun, diff |
sym.symEditGraphic | edsnx sym sym-edit-graphic | edit | Edit body graphic. Change the points, stroke width, style, text or size of a body graphic; on a text box also bold, italic, justification, border and margins. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, id: string, pts?: [x, y][], width?: number, style?: object, text?: string, size?: number, rot?: number, bold?: boolean, italic?: boolean, align?: “left” | “center” | “right”, valign?: “top” | “center” | “bottom”, border?: boolean, margins?: any | path, changed, newIds, dryRun, diff |
sym.symEditPin | edsnx sym sym-edit-pin | edit | Edit pin. Change a pin of a library symbol: number, name, type, shape, position, orientation, length, visibility, alternates; unit / bodyStyle move it. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, id: string, pin: object | path, changed, newIds, dryRun, diff |
sym.symEditProperty | edsnx sym sym-edit-property | edit | Edit symbol field. Set or add a field of a library symbol (Reference, Value, Footprint, Datasheet, Description, ki_keywords, ki_fp_filters, user fields): value, position (library mm), rotation, visibility, size; newKey renames, remove deletes. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, key: string, value?: string, at?: [x, y], rot?: number, hidden?: boolean, showName?: boolean, size?: number, newKey?: string, remove?: boolean | path, changed, newIds, dryRun, diff |
sym.symImportPinsCsv | edsnx sym sym-import-pins-csv | edit | Import pins (CSV). Add pins from CSV/TSV rows number,name,type,shape,x,y,orientation,length,unit (header optional; rows without a position stack on the left); replace deletes the existing pins first. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, csv: string, unit?: integer, bodyStyle?: integer, replace?: boolean | path, changed, newIds, dryRun, diff |
sym.symNewSymbol | edsnx sym sym-new-symbol | edit | New symbol. Create a library symbol: from scratch (fields, units, De Morgan, power), derived from another (extends), or a copy of a (symbol …) text renamed to name; replace overwrites an existing symbol of that name. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, name: string, extends?: string, reference?: string, value?: string, footprint?: string, datasheet?: string, description?: string, keywords?: string, fpFilters?: string[], units?: integer, deMorgan?: boolean, power?: boolean, text?: string, replace?: boolean | path, changed, newIds, dryRun, diff |
sym.symRenameSymbol | edsnx sym sym-rename-symbol | edit | Rename symbol. Rename a library symbol, its sub-symbols and the extends of symbols derived from it. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, from: string, to: string | path, changed, newIds, dryRun, diff |
sym.symSetBody | edsnx sym sym-set-body | edit | Set symbol body. Replace the units (sub-symbols with their pins and graphics) of a library symbol by those of body, a (symbol …) text such as a schematic instance symbol; untouched units stay byte-identical (Update library from instance). Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, body: string | path, changed, newIds, dryRun, diff |
sym.symSetDeMorgan | edsnx sym sym-set-de-morgan | edit | De Morgan body style. Turn the alternate (De Morgan) body style of a library symbol on (pins copied to style 2) or off (style 2 deleted). Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, enabled: boolean | path, changed, newIds, dryRun, diff |
sym.symSetFlags | edsnx sym sym-set-flags | edit | Symbol flags. Power symbol (none/global/local), in BOM, on board, exclude from simulation, in position files. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, power?: “none” | “global” | “local”, inBom?: boolean, onBoard?: boolean, excludeFromSim?: boolean, inPosFiles?: boolean | path, changed, newIds, dryRun, diff |
sym.symSetPinOptions | edsnx sym sym-set-pin-options | edit | Pin name options. Pin name offset (mm; 0 puts names outside, above the pin) and pin name / number visibility. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, nameOffset?: number, hideNames?: boolean, hideNumbers?: boolean | path, changed, newIds, dryRun, diff |
sym.symSetUnits | edsnx sym sym-set-units | edit | Symbol units. Set the unit count of a library symbol (units above the count are deleted with their items), whether units are interchangeable, and unit names. Edits the .kicad_sym file in place (library mm, y up); returns newIds. | path: string, symbol: string, count: integer, interchangeable?: boolean, names?: object | path, changed, newIds, dryRun, diff |
Examples
sym.symAddGraphicAdd body graphic:{"path":"MyLib.kicad_sym","symbol":"MyChip","unit":0,"kind":"rect","pts":[[-5.08,5.08],[5.08,-5.08]],"width":0.254,"style":{"fillType":"background"}}sym.symAddPinAdd pin:{"path":"MyLib.kicad_sym","symbol":"MyChip","unit":1,"pin":{"number":"1","name":"VCC","type":"power_in","at":[-7.62,2.54],"rot":0,"length":2.54}}sym.symDeleteGraphicDelete body graphics:{"path":"MyLib.kicad_sym","ids":["gfx:MyChip_0_1:2"]}sym.symDeletePinDelete pins:{"path":"MyLib.kicad_sym","ids":["pin:MyChip_1_1:3"]}sym.symDeleteSymbolDelete symbol:{"path":"MyLib.kicad_sym","name":"MyChip"}sym.symEditGraphicEdit body graphic:{"path":"MyLib.kicad_sym","id":"gfx:MyChip_0_1:2","width":0.254}sym.symEditPinEdit pin:{"path":"MyLib.kicad_sym","id":"pin:MyChip_1_1:3","pin":{"name":"VDD","type":"power_in"}}sym.symEditPropertyEdit symbol field:{"path":"MyLib.kicad_sym","symbol":"MyChip","key":"Footprint","value":"Package_SO:SOIC-8_3.9x4.9mm_P1.27mm"}sym.symImportPinsCsvImport pins (CSV):{"path":"MyLib.kicad_sym","symbol":"MyChip","csv":"number,name,type\n1,VCC,power_in\n2,GND,power_in"}sym.symNewSymbolNew symbol:{"path":"MyLib.kicad_sym","name":"MyChip","reference":"U","value":"MyChip","footprint":"Package_SO:SOIC-8_3.9x4.9mm_P1.27mm"}sym.symRenameSymbolRename symbol:{"path":"MyLib.kicad_sym","from":"MyChip","to":"MyChip2"}sym.symSetBodySet symbol body:{"path":"MyLib.kicad_sym","symbol":"NE555P","body":"(symbol \"Timer:NE555P_U1\" (symbol \"NE555P_U1_1_1\" (rectangle (start -7.62 7.62) (end 7.62 -7.62))))"}sym.symSetDeMorganDe Morgan body style:{"path":"MyLib.kicad_sym","symbol":"MyChip","enabled":true}sym.symSetFlagsSymbol flags:{"path":"MyLib.kicad_sym","symbol":"MyChip","inBom":true,"onBoard":true}sym.symSetPinOptionsPin name options:{"path":"MyLib.kicad_sym","symbol":"MyChip","nameOffset":1.016}sym.symSetUnitsSymbol units:{"path":"MyLib.kicad_sym","symbol":"MyChip","count":2,"interchangeable":false}
Requirements and solving#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
req.add | edsnx req add | edit | Add requirement. Add a requirement (defaults: severity error, weight 1, aggregate max, op <=, eval live). A zone2d region becomes a req:<id> rule area on its family’s user layer (one undo step on the board); the JSON is written next to the board. Returns the id. | path: string, requirement: object | id, requirement, file, zoneEdits |
req.eval | edsnx req eval | check | Evaluate requirements. Evaluate the requirements (all, or only) on the current board: with runTools the tools they depend on run first (tool.run; the board is saved because tools read the files). Returns per requirement status (satisfied | violated | unknown | stale | disabled), value, limit, margin (negative = violated), the worst location (worst.at [x, y, z] mm, t, f, itemId) and hints for agents: itemsInRegion, contributingFootprints, contributingNets, freeSpace circles near the worst point, suggestions. Also counts, the solve score (Σ weight·max(0, −margin)) and the tool runs. record stores the results and a history entry in the JSON. | path: string, only?: string[], runTools?: boolean = false, record?: boolean = false | path, results, counts, score, tools, warnings |
req.get | edsnx req get | query | Get requirement. One requirement in full (region outline, quantity, window, mask, tools), its last stored result and its history series (value, margin, status per iteration). | path: string, id: string | requirement, result, history |
req.history | edsnx req history | query | Requirement history. History of the requirements file (one entry per solve iteration or recorded evaluation: iteration, time, by, edits, note, violated count), newest last; with id, the value/margin/status series of that requirement. | path: string, id?: string, limit?: integer = 50 | entries, series, total |
req.list | edsnx req list | query | List requirements. Requirements of a board (<board>.kicad_requirements.json joined with the board’s req: constraint zones): id, name, severity, weight, family, region, quantity, operator and limit, and the last stored status. Drafts (zones without a requirement) and missing zones are listed. | path: string, family?: string | path, file, exists, families, requirements, drafts, missing, warnings |
req.remove | edsnx req remove | edit | Remove requirements. Remove requirements and their constraint zones (one undo step on the board). | path: string, ids: string[] | removed, file, zoneEdits |
req.report | edsnx req report | check | Requirements report. Requirements report: Markdown (summary, one row per requirement, details of the violated ones, history) or JSON. Evaluates first (stored results with evaluate: false); out writes the file, else the text is returned. | path: string, format?: “markdown” | “json” = “markdown”, out?: string, evaluate?: boolean = true, runTools?: boolean = false, hints?: boolean | format, file, text, report |
req.set | edsnx req set | edit | Edit requirement. Change fields of a requirement (patch is merged; quantity and window merge field by field). Zones follow (one undo step). | path: string, id: string, patch: object | id, requirement, file, zoneEdits |
Examples
req.addT < 70 °C over the regulator:{"path":"blinky.kicad_pcb","requirement":{"name":"Regulator below 70 °C","layerFamily":"cst.thermal","region":{"kind":"zone2d","layer":"User.1","outline":[[115,104],[128,104],[128,117],[115,117]]},"quantity":{"source":"overlay","id":"thermal:field0","unit":"°C"},"aggregate":"max","op":"<","limit":70,"dependsOnTools":["thermal"],"eval":"onToolRun"}}req.evalRun the tools, then evaluate:{"path":"blinky.kicad_pcb","runTools":true}req.evalOne requirement:{"path":"blinky.kicad_pcb","only":["r-thermal"]}req.getThe thermal requirement:{"path":"blinky.kicad_pcb","id":"r-thermal"}req.historyLast ten entries:{"path":"blinky.kicad_pcb","limit":10}req.listRequirements of the sample board:{"path":"blinky.kicad_pcb"}req.removeRemove one:{"path":"blinky.kicad_pcb","ids":["r-thermal"]}req.reportMarkdown report:{"path":"blinky.kicad_pcb","out":"requirements.md"}req.reportJSON for a script:{"path":"blinky.kicad_pcb","format":"json"}req.setRaise the limit:{"path":"blinky.kicad_pcb","id":"r-thermal","patch":{"limit":75}}
Solve loop#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
solve.cancel | edsnx solve cancel | session | Cancel solve. Cancel a solve run (this process, or another one through its cancel file). The board keeps the state of the last kept iteration (Revert in the dialog, or session.undo). | path: string, runId?: string | runId, cancelled |
solve.openDialogsoftforge.edsnx.solve | edsnx solve open-dialog | ui | Solve Requirements…. Open the Solve dialog of the board editor (requirements, strategy, budget, gate, iteration log, accept/revert/replay). Agents: use solve.run. UI-only: needs the open editor. | path?: string | object |
solve.propose | edsnx solve propose | tool | Propose solve edits. Answer the prompt of an agent solve run (solve.run with agent): intents are board EditIntents ({ op: “move”, ids, by } …) and/or registry steps ({ id: “pcb.autoroute”, args }), applied as one iteration with the DRC gate. Returns the run status after that iteration (the next prompt while it continues). stop: true ends the run. A run in another process gets the proposal through its intents file. | path: string, runId?: string, intents?: object[], intentsFile?: string, note?: string, stop?: boolean = false, wait?: boolean = true | delivered, runId, state |
solve.replay | edsnx solve replay | tool | Replay solve log. Re-apply a solve log (.edsnx/solve-force skips the checks), every step is hash-checked, and the final hash is compared with the run’s. upTo stops after an iteration. Default log: the latest run of the board. | path: string, log?: string, force?: boolean = false, upTo?: integer | replayed, matches, finalHash, expectedHash |
solve.run | edsnx solve run | tool | Solve requirements. Run the solve loop on the board: evaluate → pick the violated requirements by weight → a strategy proposes edits (auto: the first strategy that handles the worst requirement; placementSearch, netWiden, stitchGround, heightSwap, router, add-on strategies; or agent: true: you answer prompts with solve.propose) → applied as one transaction with the DRC/ERC gate (rolled back on new errors) → tools re-run → re-evaluated; a worse score is reverted. Stops at satisfied, budget, no progress (back to the best iteration) or cancel. Every iteration is logged to .edsnx/solve-agent it returns at the first prompt (state “awaiting”, prompt with results and hints). The run lives in this process: in a shell pass wait (and answer via the intents file or stdin). | path: string, requirements?: string[], strategy?: string = “auto”, agent?: boolean = false, budget?: object, iterations?: integer, seconds?: number, gate?: boolean = true, seed?: integer, options?: object, wait?: boolean, background?: boolean = false, stdin?: boolean = false, id?: string | runId, state, outcome, iterations, logFile, prompt |
solve.status | edsnx solve status | query | Solve status. Status of a solve run (this process, else from the .edsnx/solve-<id> files): state (running | awaiting | done), outcome, iterations, scores, log file, and the current prompt while it awaits a proposal. Default: the latest run of the board. | path: string, runId?: string, wait?: number | runId, state |
solve.strategies | edsnx solve strategies | query | Solve strategies. The registered solve strategies (built-ins and add-ons: id, name, description, origin) and, with path, which of them handle each violated requirement of the board’s stored results. | path?: string | strategies, handles |
Examples
solve.cancelStop the running solve:{"path":"blinky.kicad_pcb"}solve.openDialogSolve dialog:{}solve.proposeMove U1 3 mm right:{"path":"blinky.kicad_pcb","intents":[{"op":"move","ids":["<U1 uuid>"],"by":[3,0]}],"note":"spread the heat sources"}solve.replayReplay the latest run on a fresh copy:{"path":"copy/blinky.kicad_pcb","log":".edsnx/solve-2026-10-12T10-31-05-123Z.jsonl"}solve.runPlacement search on the thermal requirement, seeded:{"path":"blinky.kicad_pcb","requirements":["r-thermal"],"strategy":"placementSearch","seed":1,"iterations":12}solve.runClaude proposes the edits:{"path":"blinky.kicad_pcb","agent":true}solve.statusLatest run:{"path":"blinky.kicad_pcb"}solve.strategiesWhat can solve the sample board:{"path":"blinky.kicad_pcb"}
Multi-board systems#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
system.addBoard | edsnx system add-board | edit | Add board to system. Add a board (a KiCad project) to the system, with an optional id (default the project name), placement (mm, degrees about X then Y then Z) and assembly variant. | path?: string, project: string, id?: string, name?: string, variant?: string, at?: number[], rot?: number[] | file, files, dryRun, issues |
system.addCable | edsnx system add-cable | edit | New cable. Add a cable between two connectors (board.ref): the given wires (pins board.ref.pin, colour, gauge, length), or one wire per pin pair up to the smaller pin count (signals from a, IEC colours); a cable mate is added. | path?: string, a?: string, b?: string, id?: string, name?: string, length?: number, gauge?: string, partNumber?: string, wires?: object[] | file, cable, files, dryRun |
system.assembly.clash | edsnx system assembly clash | check | Assembly clash check. Clash check of the 3D assembly: each board’s glb (kicad-cli export, cached in .edsnx/system-glb; the outline box when there is no glb) at its placement, mated connectors left out, plus an enclosure (.glb, .stl or a faceted .step; a B-rep .step through the OCCT add-on). Board AABBs, then part AABBs, then triangle tests, then containment (a part entirely inside a closed body, by ray parity: contained on the pair); returns the clashing part pairs with a point each. | path?: string, enclosure?: string, glb?: boolean = true | pairs, hits, triangles, boxes, ms, warnings |
system.assembly.place | edsnx system assembly place | edit | Place board in assembly. Set a board’s placement in the 3D assembly (at in mm, rot in degrees about X then Y then Z), or snap it on a direct mate (mate id): the board moves so its connector seats on the other board’s, offset mm apart. | path?: string, board: string, at?: number[], rot?: number[], snap?: string, offset?: number | file, board, placement, files, dryRun |
system.describe | edsnx system describe | query | Describe system. Boards (project, layers, size, placement, variant, connector candidates), connectors with their pin maps (signal, direction, voltage, mandatory), mates with pin counts and status, cables, system nets, validation issues and the ERC counts. | path?: string | file, boards, connectors, mates, cables, nets, issues, erc |
system.ercsoftforge.edsnx.system.erc | edsnx system erc | check | System ERC. Check the connections between boards: pin count per mate (error when direct, warning through a cable), out↔out and power↔ground conflicts, unconnected power / ground / Sys.Mandatory pins of mated connectors, voltage domains (Sys.Voltage), duplicate signal names, and the file’s validation (unknown boards, connectors, pins). Violations carry the system sheet position. out writes the JSON report. | path?: string, out?: string | system, violations, counts, file |
system.export | edsnx system export | export | Export assembly. Export the 3D assembly: glb merges the boards’ glbs (kicad-cli) at their placements, one node per board; step writes boards and enclosure as STEP: through the OCCT add-on when it is installed (each board’s STEP from kicad-cli placed by its matrix, B-rep), else a faceted AP214 STEP from the meshes (faceted: true; closed meshes as FACETED_BREP solids); json writes the scene (placements, matrices, connector frames). | path?: string, format?: “glb” | “step” | “json” = “glb”, out: string, enclosure?: string, faceted?: boolean | file, boards, missing, warnings, faceted, triangles, solids, shells |
system.harnesssoftforge.edsnx.system.harness | edsnx system harness | export | Harness documentation. Harness documentation: the from-to table (cable, from board.J.pin, to board.J.pin, signal, colour, gauge, length) and the cable BOM; out *.csv writes the from-to table (Excel-compatible CSV; bom: true the cable BOM), *.kicad_sch the Harness documentation sheet (drawing + tables, K sidecar), *.pdf that sheet printed by kicad-cli, *.json both tables. | path?: string, out?: string, bom?: boolean, paper?: “A3” | “A2” | “A1” | “A0” | fromTo, bom, files, warnings |
system.mate | edsnx system mate | edit | Mate connectors. Mate two connectors (board.ref): directly (board to board; pins paired by number or pinMap) or through an existing cable. snap also places board b so its connector seats on a’s (offset = distance between the connector faces, mm). | path?: string, a: string, b: string, cable?: string, pinMap?: string[][], offset?: number, snap?: boolean, id?: string | file, mate, status, files, placement, dryRun |
system.newsoftforge.edsnx.system.new | edsnx system new | edit | New system. Create a multi-board system file (default system.kicad_sys.json in the folder) with the given boards (.kicad_pro files) side by side, and its system schematic (system.kicad_sch: boards as hierarchical sheets, connector pins as sheet pins). | path?: string, name?: string, boards?: string[], force?: boolean | file, files, dryRun, issues |
system.open3dsoftforge.edsnx.system.open3d | edsnx system open3d | ui | Open 3D assembly. Open the system 3D assembly in the editor: every board’s glb at its placement, gizmo handles (move / rotate), snap on connector, clash check, glb / STEP export. | path?: string | object |
system.sheet | edsnx system sheet | edit | System schematic. Regenerate the system schematic and its board proxy sheets from the system file (board sheet positions are kept), or with from: "sheet" update the system file from the edited sheet (wires between sheet pins → cable wires, deleted wires removed, direct mate pin maps, cable lengths) and then regenerate. | path?: string, from?: “system” | “sheet” = “system” | file, files, changes, dryRun |
Examples
system.addBoardAdd the sensor board:{"path":"examples/system-sample","project":"examples/system-sample/sensor/sensor.kicad_pro","id":"sensor"}system.addCableA 150 mm harness:{"path":"examples/system-sample","a":"main.J4","b":"sensor.J1","id":"W1","length":150,"gauge":"AWG26"}system.assembly.clashClash check:{"path":"examples/system-sample"}system.assembly.placeLift the sensor 20 mm:{"path":"examples/system-sample","board":"sensor","at":[70,0,20],"rot":[0,0,0]}system.describeThe sample system:{"path":"examples/system-sample"}system.ercERC of the sample system:{"path":"examples/system-sample"}system.exportAssembly glb:{"path":"examples/system-sample","format":"glb","out":"out/assembly.glb"}system.harnessFrom-to table as CSV:{"path":"examples/system-sample","out":"harness.csv"}system.harnessHarness sheet as PDF:{"path":"examples/system-sample","out":"harness.pdf"}system.mateBoard-to-board mate:{"path":"hw","a":"main.J3","b":"display.J1","snap":true}system.newA system of two boards:{"path":"hw","name":"Logger","boards":["hw/main/main.kicad_pro","hw/sensor/sensor.kicad_pro"]}system.open3dOpen the 3D assembly:{}system.sheetTake the wiring drawn on the sheet:{"path":"examples/system-sample","from":"sheet"}
Assembly variants#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
variant.activate | edsnx variant activate | edit | Activate variant. Make a variant the active one (the editors show it, checks leave its DNP parts unconnected); base = the KiCad files. Stored in the .kicad_pro. | path: string, id: string | active |
variant.add | edsnx variant add | edit | Add variant. Add an assembly variant (written to the .kicad_pro). from copies the overrides of another variant. Returns the new variant id. | path: string, name: string, id?: string, description?: string, from?: string, activate?: boolean = false | id, project |
variant.bake | edsnx variant bake | edit | Write variant to files. Write a variant into the KiCad files so KiCad shows it: DNP and exclude-from-BOM of every symbol (all sheets) and footprint, with values also Value / Footprint / field overrides. The Base state is recorded in the .kicad_pro; restore: true writes it back. Baking another variant restores Base first. Writes the files (save open editors first). | path: string, id?: string, values?: boolean = false, restore?: boolean = false | variant, files, refs, warnings |
variant.exportBom | edsnx variant export-bom | export | Export variant BOM. Bill of materials of a variant (default: the active one): the project’s BOM preset (or preset, a built-in or project preset name) applied to the symbols as the variant sees them (DNP, values, fields), grouped and sorted like kicad-cli sch export bom. Writes out (CSV / TSV by the format preset, html: true for HTML) or returns the rows. | path: string, id?: string, preset?: string, out?: string, html?: boolean = false, excludeDnp?: boolean | variant, file, headers, rows, components |
variant.list | edsnx variant list | query | List variants. Assembly variants of the project (softforge.variants in the .kicad_pro): Base (the KiCad files) and every variant with its override count and DNP references, the active variant and what the last bake wrote. overrides: true lists every override. | path: string, overrides?: boolean = false | project, active, variants, baked |
variant.openDialogsoftforge.edsnx.variants | edsnx variant open-dialog | ui | Variants…. Open the Variants dialog of the editor (matrix of components × variants with fitted / DNP / override cells, filters, bulk edit, CSV import/export, BOM per variant). Agents: use variant.list / variant.set. UI-only: needs the open editor. | path?: string | object |
variant.remove | edsnx variant remove | edit | Remove variant. Remove an assembly variant (Base becomes active when it was). The KiCad files are not touched (bake –restore first if it was written to them). | path: string, id: string | removed, active |
variant.set | edsnx variant set | edit | Set variant overrides. Set overrides of references in a variant: fitted / dnp (not populated), value, footprint, fields, excludeFromBom; null clears a key, clear: true removes the references’ overrides. name / description rename the variant. Returns the resulting overrides of those references. | path: string, id: string, refs?: string[], ref?: string, fitted?: boolean | null, dnp?: boolean | null, value?: string | null, footprint?: string | null, fields?: object, excludeFromBom?: boolean | null, clear?: boolean, name?: string, description?: string | id, overrides |
Examples
variant.activateShow the Lite variant:{"path":"blinky.kicad_pro","id":"lite"}variant.addA Lite variant:{"path":"blinky.kicad_pro","name":"Lite","description":"No programming header"}variant.bakeWrite Lite into the KiCad files:{"path":"blinky.kicad_pro","id":"lite"}variant.bakeBack to Base:{"path":"blinky.kicad_pro","restore":true}variant.exportBomBOM of Lite as CSV:{"path":"blinky.kicad_pro","id":"lite","out":"fab/blinky-lite-bom.csv"}variant.listVariants of the sample project:{"path":"blinky.kicad_pro","overrides":true}variant.openDialogVariants dialog:{}variant.removeRemove Lite:{"path":"blinky.kicad_pro","id":"lite"}variant.setJ2 not fitted and R3 = 1k in Lite:{"path":"blinky.kicad_pro","id":"lite","ref":"J2","fitted":false}variant.setA value override:{"path":"blinky.kicad_pro","id":"lite","refs":["R3"],"value":"1k"}
Rooms#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
room.add | edsnx room add | edit | Add room. Add a room: a room:<name> rule area (nothing kept out) on the “Rooms” user layer with outline (mm), or wrapped around its members with margin when no outline is given, and its definition in .kicad_pro softforge.rooms (members by sheet and/or references, side, height limit, clearance). One undo step. | path: string, name: string, outline?: [x, y][], margin?: number = 1, sheet?: string, refs?: string[], nested?: boolean, side?: “F” | “B”, heightMax?: number, clearance?: number, fixed?: boolean | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
room.arrange | edsnx room arrange | edit | Arrange in room. Pack a room’s members inside its outline (largest first, row by row, spacing mm apart, around other parts inside it). Members that do not fit stay and are listed. One undo step. | path: string, name: string, spacing?: number = 1 | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, moved, unplaced |
room.check | edsnx room check | check | Check rooms. Room rules (also part of the native DRC as warnings): room_part_outside (a member’s body is not inside its room), room_wrong_side, room_height (Height field / package table over heightMax), room_component_clearance. Returns the violations with references and positions. | path: string | violations, count |
room.fit | edsnx room fit | edit | Fit room to parts. Fit rooms to their parts (a part is at home in the room that lists its reference, else in its sheet’s room): a rectangle room becomes the box of its parts’ bodies plus margin (it may shrink; growOnly keeps what is larger), any other outline grows around the parts outside it and keeps its shape. Rooms grow on their own when a member is moved out of them or Update PCB adds parts to a full room, unless the room is locked or fixed. Without names, every room. One undo step. | path: string, names?: string[], margin?: number, growOnly?: boolean = false | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, fitted |
room.fromSheets | edsnx room from-sheets | edit | Rooms from sheets. One room per schematic sheet instance (the footprints’ path prefix), named after the sheet (“Root” for the root sheet): wrap draws each room around its parts (nothing moves), grid tiles the rooms over the board and packs each sheet’s parts inside its room, auto wraps when every part is inside the board outline. Existing rooms of a sheet keep their name and rules. Later Update PCB places new parts in their sheet’s room. One undo step. | path: string, mode?: “auto” | “wrap” | “grid” = “auto”, margin?: number = 1, spacing?: number = 1 | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps, rooms, mode, moved, unplaced |
room.list | edsnx room list | query | List rooms. Rooms of a board: the room:<name> rule areas joined with .kicad_pro softforge.rooms. Per room: members (references), parts outside it, rules (side, heightMax, clearance) and warnings; the user layer they live on. | path: string | layer, rooms |
room.move | edsnx room move | edit | Move room. Move a room with its parts: by by [dx, dy] or so its outline’s top-left corner goes to. withRouting also moves the tracks and vias that lie entirely inside the room. One undo step. | path: string, name: string, by?: [x, y], to?: [x, y], withRouting?: boolean = false | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
room.remove | edsnx room remove | edit | Remove rooms. Remove rooms: their rule areas and definitions (the parts stay). One undo step. | path: string, names: string[] | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
room.set | edsnx room set | edit | Edit room. Change a room: rules (sheet, refs, nested, side, heightMax, clearance, fixed, margin; null clears), its outline, or rename it (newName). One undo step. | path: string, name: string, newName?: string, outline?: [x, y][], sheet?: string | null, refs?: array | null, nested?: boolean | null, side?: “F” | “B” | null, heightMax?: number | null, clearance?: number | null, fixed?: boolean | null, margin?: number | null | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
Examples
room.addA room for the Timer sheet, front side, parts up to 6 mm:{"path":"blinky.kicad_pcb","name":"Timer","sheet":"Timer","side":"F","heightMax":6}room.arrangePack the Timer parts:{"path":"blinky.kicad_pcb","name":"Timer"}room.checkParts outside their rooms:{"path":"blinky.kicad_pcb"}room.fitFit the Timer room around its parts:{"path":"blinky.kicad_pcb","names":["Timer"]}room.fromSheetsA room around each sheet’s parts:{"path":"blinky.kicad_pcb","mode":"wrap"}room.listRooms of the sample board:{"path":"blinky.kicad_pcb"}room.moveMove the Timer room 5 mm right:{"path":"blinky.kicad_pcb","name":"Timer","by":[5,0]}room.removeRemove the Timer room:{"path":"blinky.kicad_pcb","names":["Timer"]}room.setBack side only:{"path":"blinky.kicad_pcb","name":"Timer","side":"B"}
Reuse blocks#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
block.list | edsnx block list | query | List blocks. The snippets library: blocks (*.kicad_block.json) in paths, $EDSNX_BLOCK_PATHS and blocks/ next to the board (one level of sub-folders), filtered by query (name, description, references, ports); with a board, also the blocks placed on it with each instance’s sync state (in-sync, outdated: the block changed, modified: parts moved by hand, missing: block file not found). | path?: string, paths?: string[], query?: string | library, placed, folders |
block.make | edsnx block make | edit | Make block. Make a reuse block from a sheet instance on the board (Make block from selection): the instance’s sheet file, its footprints and the tracks, arcs, vias and zones of its nets inside its box (plus include, minus exclude) are written to dir as <slug>.kicad_sch (symbol instances stripped), <slug>.kicad_pcb (a KiCad board fragment, items verbatim) and <slug>.kicad_block.json (anchor, footprints by sheet-relative key, nets, hash). A sheet holding hierarchical sheets (other blocks) makes a nested block: its sub-sheet files go along and the parts of every level are in the layout. Text variables in the fields (${R_VALUE}) become the block’s parameters. The board does not change. | path: string, sheet: string, name: string, description?: string, dir?: string, include?: string[], exclude?: string[], anchor?: [x, y], margin?: number = 1, parameters?: object | block, files, footprints, copper |
block.place | edsnx block place | edit | Place block. Place a block count times: the block’s sheet file is copied into the project (once), each instance becomes a hierarchical sheet on the root schematic (sheet pins for its ports, labels per connect port → net) with references in its own range (R1 → R101, R201, … or from base), the schematics are saved and Update PCB runs (kicad-cli), then the block’s layout is placed on each instance at at + k·pitch turned by rot: footprints matched by sheet-relative key, tracks/vias/zones copied with the instance’s nets and grouped block:<name>/<sheet>. Instances are recorded in .kicad_pro softforge.blocks. updatePcb: false stops after the schematic (block.update lays out instances later). A nested block brings its sub-sheet files and numbers the references of every level in the instance’s range; power symbols get theirs as KiCad annotates them (#PWR0101). parameters set the block’s parameters per instance (fields of the sheet symbol that KiCad resolves in ${NAME}). | path: string, block: string, count?: integer = 1, at?: [x, y], pitch?: [x, y], rot?: number = 0, names?: string[], connect?: object, base?: integer, step?: integer = 100, schematic?: string, sheetAt?: [x, y], updatePcb?: boolean = true, paths?: string[], parameters?: object | array | instances, warnings, sheetFile |
block.replicate | edsnx block replicate | edit | Replicate layout. Replicate the layout of one sheet instance onto other instances of the same sheet (Altium room formation / Allegro reuse): footprints matched by sheet-relative key take the source’s relative placement and the source’s tracks, arcs, vias and zones are copied with each target’s nets. Each target keeps its reference part (the largest common footprint) where it is unless at is given. One undo group. | path: string, from: string, to?: string[], at?: [x, y], rot?: number, include?: string[], exclude?: string[] | targets, warnings |
block.showPanelsoftforge.edsnx.reuse.show | edsnx block show-panel | ui | Reuse Panel. Show the Reuse panel of the board editor: rooms with part counts and outside warnings, reuse blocks with their sync state (Place, Replicate layout, Update instances), the snippets library, pin and gate swap groups. | path?: string | object |
block.update | edsnx block update | edit | Update block instances. Bring the instances of placed blocks (.kicad_pro softforge.blocks) up to date with their block files: an outdated instance (block hash changed), one never laid out, or every one with force, gets the block’s copper again (its previous block: group is replaced) and its footprints re-placed, except footprints the user moved since (kept and reported). Returns per instance what changed. | path: string, block?: string, force?: boolean = false | instances, warnings |
Examples
block.listBlocks of the project:{"path":"blinky.kicad_pcb"}block.makeThe Timer sheet as a block:{"path":"blinky.kicad_pcb","sheet":"Timer","name":"NE555 astable"}block.placeTwo LED drivers fed from OUT:{"path":"blinky.kicad_pcb","block":"blocks/led-driver/led-driver.kicad_block.json","count":2,"at":[104,126],"pitch":[14,0],"connect":{"IN":"OUT"}}block.replicateLED1’s layout onto the other LED driver instances:{"path":"blinky.kicad_pcb","from":"LED1"}block.showPanelOpen the Reuse panel:{}block.updateRe-place the instances of changed blocks:{"path":"blinky.kicad_pcb"}
Pin and gate swap#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
swap.gates | edsnx swap gates | edit | Swap gates. Swap two units (gates) of a multi-unit part: the schematic placements exchange their unit numbers (their wiring stays where it is) and the board pads of the two units trade nets pin name by pin name. The units must be interchangeable (identical pin names, or Swap.Gates yes) unless force. Attached copper: as swap.pins (re-attached by default). One undo group. | path: string, ref: string, units: integer[], copper?: “reattach” | “ripUp” | “refuse”, ripUp?: boolean = false, force?: boolean = false, allInstances?: boolean = false | changes, ripped, reattached, unrouted, schematic, instances, warnings |
swap.list | edsnx swap list | query | Swap groups. Swappable pin groups of the board’s footprints (their Swap.Groups property, copied from the symbol by Update PCB: “1,2;A1,A2,A3”), gate swap flags (Swap.Gates) and alternative footprints (Swap.Footprints). | path: string, ref?: string | groups, gates, alternatives |
swap.part | edsnx swap part | edit | Swap part. Swap a part for an alternative footprint (Swap.Footprints of the part, unless force): without variant the board footprint is replaced (pads keep their nets) and the symbol’s Footprint field follows; with variant nothing is edited here and the footprint override for that variant is returned (variantOverride) — and applied through variant.set (the variant table’s footprint override). | path: string, ref: string, footprint: string, variant?: string, force?: boolean = false | variantOverride, applied, board, schematic, warnings |
swap.pins | edsnx swap pins | edit | Swap pins. Swap two pins of a part: the two pads trade nets on the board and the pins’ connections are swapped in the schematic (wire ends, labels, junctions, no-connect flags move between the two pins), so Update PCB stays empty. The pads must share a swap group (Swap.Groups) unless force. Copper attached to the pads keeps its net: each track is cut back from its pad and joined to the pad that now carries its net (straight, around the pads, or through vias on another layer when the two connections cross), clear of other nets (reattached); a connection with no clean path is ripped up (unrouted, a warning). copper: "ripUp" (or ripUp) deletes the attached copper instead, "refuse" fails with the conflicts. A part in a sheet used several times needs allInstances (the schematic change applies to every instance). One undo group. | path: string, ref: string, pads: string[], copper?: “reattach” | “ripUp” | “refuse”, ripUp?: boolean = false, force?: boolean = false, schematic?: boolean = true, allInstances?: boolean = false | changes, ripped, reattached, unrouted, schematic, instances, warnings |
Examples
swap.gatesSwap units A and B of U2:{"path":"board.kicad_pcb","ref":"U2","units":[1,2]}swap.listSwap groups of the board:{"path":"blinky.kicad_pcb"}swap.partR3 as 0603:{"path":"blinky.kicad_pcb","ref":"R3","footprint":"Resistor_SMD:R_0603_1608Metric","force":true}swap.pinsSwap the two ends of R3 (its tracks follow):{"path":"blinky.kicad_pcb","ref":"R3","pads":["1","2"],"force":true}
Manufacturer parts#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
parts.offers | edsnx parts offers | query | Part offers. Distributor offers of a part (MPN or provider id) from the enabled providers: distributor, sku, stock, MOQ, multiple, currency and price breaks. | mpn: string, providers?: string[], offline?: boolean = false | offers, errors |
parts.search | edsnx parts search | query | Search manufacturer parts. Search the part data providers (Octopart/Nexar, Mouser, Digi-Key, LCSC, add-ons; cached, rate limited) by keywords or MPN. Returns hits: provider, mpn, manufacturer, description, package, lifecycle (active / nrnd / eol / obsolete), stock, price@100 and the providers that know the part; errors lists provider failures. | query: string, providers?: string[], limit?: integer = 20, inStock?: boolean = false, activeOnly?: boolean = false, manufacturers?: string[], offline?: boolean = false | hits, errors, cached |
Examples
parts.offersOffers of NE555P (recorded fixtures):{"mpn":"NE555P","providers":["fixture"]}parts.searchA 10k 0805 resistor in stock:{"query":"10k 0805 resistor","inStock":true}parts.searchRecorded fixtures (no keys):{"query":"NE555P","providers":["fixture"]}
BOM cost#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
bom.cost | edsnx bom cost | query | BOM cost. BOM costing: the project’s BOM lines (grouped by MPN, else Value + Footprint; DNP and variant-unfitted parts not bought) resolved against the part data providers, the cheapest offer for qty × boards (MOQ / multiple, price breaks, stock first, approved manufacturers and preferred distributors from cart writes a distributor cart CSV, report a cost report (.md or .csv). | path: string, qty?: integer = 1, variant?: string, providers?: string[], offline?: boolean = false, currency?: string, attrition?: number, cart?: “mouser” | “digikey” | “lcsc”, cartOut?: string, report?: string | boards, currency, perBoard, total, lines, warnings, perVariant |
Examples
bom.costCost of 100 boards of the Lite variant:{"path":"blinky.kicad_pro","qty":100,"variant":"Lite"}bom.costRecorded fixtures, LCSC cart:{"path":".","qty":10,"providers":["fixture"],"cart":"lcsc"}
Rigid-flex and HDI#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
flex.bend.add | edsnx flex bend add | edit | Add bend line. Add a bend line a→b (mm) across a flex region: a Dwgs.User line in a group flex:bend:<id> (KiCad shows it) and its inner radius (mm, default 1), signed angle (deg, + folds the far side up, default 90) and folding order (default next) in the JSON. The far side is the side away from the largest rigid region. Returns the id. | path: string, id?: string, name?: string, a: [x, y], b: [x, y], radius?: number = 1, angle?: number = 90, order?: integer, regionId?: string | id, bend, file, boardEdits |
flex.bend.remove | edsnx flex bend remove | edit | Remove bend lines. Remove bend lines (their grouped lines go too). | path: string, ids: string[] | removed, file, boardEdits |
flex.bend.set | edsnx flex bend set | edit | Edit bend line. Change a bend line: end points (moves its line), radius, angle, order, name, region. | path: string, id: string, name?: string, a?: [x, y], b?: [x, y], radius?: number, angle?: number, order?: integer, regionId?: string | id, bend, file, boardEdits |
flex.check | edsnx flex check | check | Flex and HDI checks. Native DRC limited to the rigid-flex and HDI rules (via_span_invalid, via_aspect_ratio, via_annular_span, micro_via_stacking, flex_bend_radius, flex_copper_on_bend, flex_stiffener_overlap, flex_coverlay_opening, flex_layer_absent, flex_component_on_bend) on the session’s board text and | path: string, severity?: “all” | “error” | “warning” = “all”, limit?: integer = 100 | kind, engine, path, errors, warnings, excluded, total, returned, byRule, violations, partial, ms |
flex.describe | edsnx flex describe | query | Describe rigid-flex. Stack-up regions of a board (flex: rule areas joined with <board>.kicad_flex.json; the board wins on outlines): id, name, kind (rigid | flex | rigid-flex-transition), copper layer set, absent layers, materials, derived thickness, coverlay, stiffener; bend lines (end points, radius, angle, order, bend zone width); via spans; drafts (zones without a JSON region), missing zones and warnings. With at [x, y]: the region and stack at that point (the whole-board default region where no region is). | path: string, at?: [x, y] | file, regions, bends, viaSpans, at, drafts, missing, warnings |
flex.export | edsnx flex export | query | Export rigid-flex 3D. Export the 3D board flat or folded (state, or fold 0…1) as glb (board, regions with their stacks, models; metres, y up like kicad-cli) or png (3D screenshot), through the headless renderer (Chromium). | path: string, state?: “flat” | “folded” = “folded”, fold?: number, format?: “glb” | “png” = “glb”, out: string, width?: integer, height?: integer | file, format, fold, bytes |
flex.fold | edsnx flex fold | check | Fold rigid-flex. The board in a fold state (state flat | folded, or fold 0…1; mode together | sequence by order): the angle applied per bend, the folded extent (mm) and the folded clearance check — rigid regions and component bodies (courtyard × Height) that collide once folded but not flat (rule flex_folded_clearance, contacts in board mm with z). Parts crossing bend lines are listed. out writes the folded board and models as glb and png a 3D screenshot through the headless renderer (Chromium). | path: string, state?: “flat” | “folded” = “folded”, fold?: number, mode?: “together” | “sequence” = “together”, clearance?: number = 0, out?: string, png?: string, width?: integer, height?: integer | fold, applied, extent, collisions, onBends, files, render |
flex.region.add | edsnx flex region add | edit | Add stack-up region. Add a stack-up region: a flex:<id> rule area (nothing kept out) on the “Flex regions” user layer with outline (mm) and the region in <board>.kicad_flex.json (kind, stack top to bottom, absent copper layers, coverlay, stiffener). Defaults: rigid → the Board Setup stack-up; flex → coverlay / copper / polyimide / copper / coverlay with the inner layers absent. One undo step. Returns the id. | path: string, id?: string, name?: string, kind?: “rigid” | “flex” | “rigid-flex-transition”, outline: [x, y][], stack?: object[], absentLayers?: string[], coverlay?: object, stiffener?: object | id, region, file, boardEdits |
flex.region.remove | edsnx flex region remove | edit | Remove stack-up regions. Remove regions and their rule areas (the board falls back to the Board Setup stack-up there). One undo step. | path: string, ids: string[] | removed, file, boardEdits |
flex.region.set | edsnx flex region set | edit | Edit stack-up region. Change a region: name, kind, outline (moves its rule area), stack, absent layers, coverlay, stiffener (null clears coverlay / stiffener). One undo step. | path: string, id: string, name?: string, kind?: “rigid” | “flex” | “rigid-flex-transition”, outline?: [x, y][], stack?: object[], absentLayers?: string[], coverlay?: object | null, stiffener?: object | null | id, region, file, boardEdits |
flex.span.add | edsnx flex span add | edit | Add via span. Add a via span between two copper layers (kind from the layers unless given: through / blind / buried; micro for laser microvias), size and drill default to the net class via (micro: µvia). The first span added also writes the default through span. Returns the span and the list. | path: string, id?: string, from: string, to: string, kind?: “through” | “blind” | “buried” | “micro”, size?: number, drill?: number, laser?: boolean | null, stacked?: boolean | null, staggeredMin?: number | null, aspectRatioMax?: number | null, annularMin?: number | null, drillGroup?: string | null | span, file, spans |
flex.span.assign | edsnx flex span assign | edit | Put vias on a span. Put vias on a via span: KiCad type (through / blind / micro), layers, size and drill of the span. span omitted: the shortest span that connects each via’s layers. Undoable. | path: string, ids: string[], span?: string | newIds |
flex.span.drill | edsnx flex span drill | export | Drill files per span. Native Excellon drill files per via span / layer pair into outDir (default fab/): | path: string, outDir?: string = “fab/” | files, folder, groups |
flex.span.list | edsnx flex span list | query | List via spans. HDI via spans of a board (viaSpans of | path: string | path, spans, defined, issues |
flex.span.remove | edsnx flex span remove | edit | Remove via span. Remove a via span (vias that used it are reported by flex.check as via_span_invalid). | path: string, id: string | removed, file, spans |
flex.span.replace | edsnx flex span replace | edit | Replace via spans. Replace the whole via span list (Board Setup ▸ Via Spans Apply). An empty list removes the definitions (the default through span applies again). | path: string, spans: object[] | file, spans |
flex.span.rules | edsnx flex span rules | edit | Write via span rules. Write the spans as .kicad_dru rules named SPAN: <id> (hole_size min = max(depth / max aspect ratio), annular_width min, µvia diameter) plus SPAN: layer pairs (disallow via for any other layer pair), so kicad-cli reports span violations as drill_out_of_range / annular_width / items_not_allowed. Other rules are kept byte for byte; remove: true deletes the SPAN rules. Returns the rules written. | path: string, remove?: boolean = false, pairs?: boolean = true | file, rules, text |
flex.span.set | edsnx flex span set | edit | Set via span. Change a via span: layers, kind, size, drill, laser, stacked, staggeredMin, aspectRatioMax, annularMin, drillGroup (null clears an option); newId renames it. Vias already placed are not changed (flex.span.assign does that). | path: string, id: string, newId?: string, from?: string, to?: string, kind?: “through” | “blind” | “buried” | “micro”, size?: number, drill?: number, laser?: boolean | null, stacked?: boolean | null, staggeredMin?: number | null, aspectRatioMax?: number | null, annularMin?: number | null, drillGroup?: string | null | span, file |
Examples
flex.bend.addA 90° bend across the flex tail:{"path":"rigid-flex.kicad_pcb","a":[140,94],"b":[140,106],"radius":1,"angle":90}flex.bend.removeRemove a bend:{"path":"rigid-flex.kicad_pcb","ids":["b2"]}flex.bend.setFold the tail flat on itself:{"path":"rigid-flex.kicad_pcb","id":"b1","angle":180}flex.checkHDI and flex checks:{"path":"hdi6.kicad_pcb"}flex.describeRegions and bends of the rigid-flex sample:{"path":"rigid-flex.kicad_pcb"}flex.describeStack at a point of the flex tail:{"path":"rigid-flex.kicad_pcb","at":[140,100]}flex.exportFlat glb:{"path":"rigid-flex.kicad_pcb","state":"flat","out":"flat.glb"}flex.foldFolded clearance of the sample:{"path":"rigid-flex.kicad_pcb","state":"folded"}flex.foldFolded glb:{"path":"rigid-flex.kicad_pcb","state":"folded","out":"folded.glb"}flex.region.addA flex tail between two rigid parts:{"path":"rigid-flex.kicad_pcb","name":"Flex","kind":"flex","outline":[[130,95],[170,95],[170,105],[130,105]]}flex.region.removeRemove a region:{"path":"rigid-flex.kicad_pcb","ids":["r3"]}flex.region.setInner layers absent in the flex:{"path":"rigid-flex.kicad_pcb","id":"r3","absentLayers":["In1.Cu","In2.Cu"]}flex.span.addBlind F.Cu–In1.Cu:{"path":"hdi6.kicad_pcb","from":"F.Cu","to":"In1.Cu","size":0.45,"drill":0.2}flex.span.addLaser microvia In1–In2, staggered only:{"path":"hdi6.kicad_pcb","from":"In1.Cu","to":"In2.Cu","kind":"micro","size":0.35,"drill":0.15,"stacked":false,"staggeredMin":0.4}flex.span.assignA via onto the blind span:{"path":"hdi6.kicad_pcb","ids":["<via uuid>"],"span":"blind-F-In1"}flex.span.drillDrill files per span into fab/:{"path":"hdi6.kicad_pcb","outDir":"fab/"}flex.span.listSpans of the HDI fixture:{"path":"hdi6.kicad_pcb"}flex.span.removeRemove a span:{"path":"hdi6.kicad_pcb","id":"micro-In1-In2"}flex.span.replaceTwo spans:{"path":"hdi6.kicad_pcb","spans":[{"id":"blind-F-In1","kind":"blind","from":"F.Cu","to":"In1.Cu","size":0.45,"drill":0.2},{"id":"micro-In1-In2","kind":"micro","from":"In1.Cu","to":"In2.Cu","size":0.35,"drill":0.15}]}flex.span.rulesSpan rules for kicad-cli:{"path":"hdi6.kicad_pcb"}flex.span.setStricter annular ring:{"path":"hdi6.kicad_pcb","id":"micro-In1-In2","annularMin":0.1}
DFM / DFA / DFF profiles#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
dfm.profiles.activate | edsnx dfm profiles activate | edit | Activate DFM profile. Set the project’s active DFM profile (softforge.dfm.active in the .kicad_pro): live DFM, the Checks panel DFM group and the release gate use it. none clears it (default by copper layer count). | path?: string = “.”, id: string | active |
dfm.profiles.export | edsnx dfm profiles export | export | Export DFM profile. Write a DFM profile (bundled, file or project) to a JSON file, to edit it or share it with another project. | path?: string = “.”, id: string, out?: string | file |
dfm.profiles.get | edsnx dfm profiles get | query | Get DFM profile. One DFM profile as JSON (limits in mm, ratio or count; DFA spacing table; DFF test access). | path?: string = “.”, id: string | object |
dfm.profiles.import | edsnx dfm profiles import | edit | Import DFM profile. Import a DFM profile (a JSON file of one profile, an array, or { profiles: […] }; or profile as an object) into the .kicad_pro softforge.dfm.profiles (replacing one with the same id). Validates every limit; activate makes it the active profile. | path?: string = “.”, file?: string, profile?: object, activate?: boolean = false | imported, active |
dfm.profiles.list | edsnx dfm profiles list | query | List DFM profiles. DFM profiles available to the project: bundled (JLCPCB 2/4/6-layer, PCBWay, OSH Park, Eurocircuits, Aisler: typical values, verify), *.dfm.json files in the project folder or dfm/, and those imported into the .kicad_pro; with the active one and any profile file errors. | path?: string = “.” | active, profiles, errors |
dfm.profiles.remove | edsnx dfm profiles remove | edit | Remove DFM profile. Remove an imported profile from the .kicad_pro (bundled and file profiles cannot be removed this way). | path?: string = “.”, id: string | removed |
dfm.runsoftforge.edsnx.dfm.run | edsnx dfm run | check | Run DFM. Evaluate a fabricator profile (DFM fab limits, DFA assembly spacing, DFF test access) against the board: track width, clearance (geometry and net classes), drill, annular ring, via diameter, mask slivers and expansion, silk width and silk-to-pad, copper to edge, hole to hole / copper, aspect ratio, via in pad, slots, board thickness and size; DFA spacing by package class pair, edge keep-out, tall next to short, same side; DFF access % and probe pitch. Returns counts, per-rule counts and the violations (rule ids dfm_* / dfa_* / dff_*, mm). out writes the full JSON report. | path?: string = “.”, profile?: string, rules?: “dfm_track_width” | “dfm_clearance” | “dfm_drill” | “dfm_annular_ring” | “dfm_mask_sliver” | “dfm_silk_width” | “dfm_silk_to_pad” | “dfm_copper_to_edge” | “dfm_hole_to_hole” | “dfm_aspect_ratio” | “dfm_via_in_pad” | “dfa_spacing” | “dfa_edge_keepout” | “dfa_tall_near_short” | “dff_test_access” | “dff_test_pitch” | “dfm_hole_to_copper” | “dfm_via_diameter” | “dfm_mask_expansion” | “dfm_board_thickness” | “dfm_slot_width” | “dfm_board_size” | “dfa_same_side”[], severity?: “all” | “error” | “warning” = “all”, limit?: integer = 200, out?: string | profile, counts, byRule, violations, testAccess, skipped, file, truncated |
dfm.savePack | edsnx dfm save-pack | edit | Save DFM profile as rule pack. Write the profile’s hard limits (annular ring, drill range, hole to hole, NPTH to copper, track width, copper to edge, mask dam, silk clearance and thickness) as the Constraint Manager’s “DFM: …” custom rules into the board’s .kicad_dru, so kicad-cli’s DRC enforces them too. Other rules of the file are kept. | path?: string = “.”, profile?: string | file, rules, profile |
dfm.viaInPad.set | edsnx dfm via-in-pad set | edit | Set via-in-pad policy. Choose how a DFM profile treats vias inside SMD pads for this project: allowed (no finding), warn (a dfm_via_in_pad warning: filled and capped vias cost extra) or forbidden (an error); default goes back to the profile’s own policy. Stored per profile in the .kicad_pro (softforge.dfm.viaInPad); the DFM tab’s Via in pad selector calls this. | path?: string = “.”, mode: “allowed” | “warn” | “forbidden” | “default”, profile?: string | profile, mode, source |
Examples
dfm.profiles.activateUse the JLCPCB 4-layer limits:{"id":"jlcpcb-4"}dfm.profiles.exportCopy a bundled profile to edit:{"id":"jlcpcb-4","out":"myfab.dfm.json"}dfm.profiles.getThe bundled JLCPCB 4-layer profile:{"id":"jlcpcb-4"}dfm.profiles.importImport and activate a fab profile:{"path":"blinky.kicad_pro","file":"myfab.dfm.json","activate":true}dfm.profiles.listProfiles of the project:{"path":"blinky.kicad_pro"}dfm.profiles.removeRemove an imported profile:{"id":"myfab"}dfm.runJLCPCB 4-layer limits on the sample:{"path":"blinky.kicad_pcb","profile":"jlcpcb-4"}dfm.runThe active profile, errors only:{"severity":"error"}dfm.savePackEnforce the JLCPCB 2-layer limits in kicad-cli too:{"profile":"jlcpcb-2"}dfm.viaInPad.setWarn instead of failing on via-in-pad with JLCPCB 2-layer:{"mode":"warn","profile":"jlcpcb-2"}
Output jobs#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
jobs.jobset.list | edsnx jobs jobset list | query | List job sets. KiCad job sets (.kicad_jobset) of the project folder: each output (folder or archive) as an output job with its steps, and the KiCad jobs it cannot run here (unsupported). | path?: string = “.”, file?: string | jobsets |
jobs.jobset.run | edsnx jobs jobset run | export | Run job set. Run a KiCad job set through the output jobs: every output (or output, by id or description) becomes an output job whose steps are its KiCad jobs (Gerbers, drill, position, BOM, PDFs, SVG, DXF, STEP / glTF, ODB++, IPC-2581, IPC-D-356, netlist, execute command); the same export commands, manifest.json and zip as edsnx jobs run. KiCad jobs without an output kind here (DRC, ERC, render, GenCAD …) are reported as skipped steps. | path?: string = “.”, file?: string, output?: string, out?: string, version?: string, variant?: string | file, ok, outputs, skipped |
jobs.jobset.save | edsnx jobs jobset save | export | Save output jobs as job set. Write output jobs into a KiCad job set that kicad-cli jobset run (KiCad 9+) can run: one KiCad job per step KiCad has, one output per job (archive when the job zips). An existing job set is updated in place (outputs with the same id replaced, everything else kept). Steps KiCad has no job for (documentation set, panel, web viewer, requirements report, Gerber checks) are listed as skipped. | path?: string = “.”, file?: string, jobs?: string[] | file, outputs, skipped |
jobs.list | edsnx jobs list | query | List output jobs. Output jobs of the project (.kicad_pro softforge.outputJobs, else the defaults fab, assembly, docs, panel, webviewer, all): id, name, folder, zip and steps (kinds: gerber, drill, position, bom, pdfSch, pdfPcb, svg, dxf, step, glb, odb, ipc2581, ipcd356, netlist, docset, panel, webviewer, reqReport, custom, gerberCheck). | path?: string = “.” | jobs, custom, errors |
jobs.run | edsnx jobs run | export | Run output job. Run an output job: each step through the export commands (project.plot / drill / position / bom / export3d / odb / ipc2581, doc.export, panel.export, req.report, kicad-cli for schematic PDF and IPC-D-356, custom shell commands) into | path?: string = “.”, id: string, out?: string, version?: string, variant?: string | job, ok, folder, out, steps, files, zip, manifest |
jobs.set | edsnx jobs set | edit | Set output jobs. Replace the project’s output jobs (softforge.outputJobs in the .kicad_pro). Each job: { id, name, folder, zip?, steps: [{ kind, options?, folder?, name? (template: ${project} ${version} ${kind} ${job} ${date} ${variant}), variant?, enabled? }] }. [] restores the defaults. | path?: string = “.”, jobs: object[] | jobs |
Examples
jobs.jobset.listJob sets of the project:{}jobs.jobset.runRun every output of the project’s job set:{}jobs.jobset.runOnly the Fabrication output, into out/:{"output":"Fabrication","out":"out"}jobs.jobset.saveFabrication and assembly jobs as.kicad_jobset: {"jobs":["fab","assembly"]}jobs.listJobs of the sample project:{"path":"blinky.kicad_pro"}jobs.runFabrication package into out/:{"id":"fab","out":"out"}jobs.runAssembly outputs of a variant:{"id":"assembly","variant":"lite"}jobs.setA Gerber + drill job zipped:{"jobs":[{"id":"fab","name":"Fabrication","folder":"fab","zip":true,"steps":[{"kind":"gerber"},{"kind":"drill"}]}]}
Releases#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
release.list | edsnx release list | query | List releases. Releases of the project (releases/ | path?: string = “.” | current, releases |
release.openDialogsoftforge.edsnx.release | edsnx release open-dialog | ui | Release…. Open the Release dialog of the editor: version, the gate list (ERC, DRC, requirements, DFM, test access, panel DRC, clean git) with Fix gate, output jobs, notes, Release (tag). Agents: use release.plan / release.run. UI-only: needs the open editor. | path?: string | object |
release.plan | edsnx release plan | check | Plan release. The release gate without producing anything: each entry { name, ok, detail } for ERC, DRC (errors and unrouted), requirements (req.eval), DFM (a profile), test access %, panel DRC and a clean git working tree; firstFailing is what Fix gate opens. | path?: string = “.”, gate?: string[], version?: string | ok, gate, firstFailing, tokens, version, tag, problems |
release.run | edsnx release run | export | Release. Release the project: the gate (refused when it fails unless force), then stamp the version (REVISION text variable, title block revisions, softforge.release), run the jobs into releases/commit) and git tag -a v<version> (tag). Returns the ReleaseResult with every gate entry, outputs and errors. | path?: string = “.”, version: string, jobs?: string[], gate?: string[], tag?: boolean = false, commit?: boolean = false, notes?: string, folder?: string, variant?: string, stamp?: boolean = true, force?: boolean = false | version, ok, gate, outputs, tag, folder, notesFile, zip, stamps, errors |
Examples
release.listRelease history:{"path":"blinky.kicad_pro"}release.openDialogRelease dialog:{}release.planWould a release pass?:{"gate":["drc","erc","dfm:jlcpcb-4"]}release.runRelease 1.4.0 with fab and assembly outputs, gated on DRC, ERC and JLCPCB 4-layer DFM, tagged:{"version":"1.4.0","jobs":["fab","assembly"],"gate":["drc","erc","dfm:jlcpcb-4"],"tag":true}
Panelization#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
panel.describe | edsnx panel describe | query | Describe panel. The panel file and what the generator makes of it: panel size, instances (board, position, rotation), tabs, mouse-bite holes, V-score lines (positions), fiducials, tooling holes, warnings; and whether the output board exists and is up to date. | path?: string | file, panel, summary, instances, vscores, output, upToDate |
panel.drc | edsnx panel drc | check | Panel DRC. Board DRC on the generated panel board plus the panel rules (panel_board_to_rail, panel_mousebite_copper, panel_fiducial_clearance, panel_vscore_copper): native engine (default), kicad-cli, or both (kicad-cli’s report, the panel rules from the native engine). Limits come from the panel file’s options (boardToRail 0.5, mousebiteCopper 0.25, fiducialClearance 1.5, vscoreCopper 0.4 mm by default). | path?: string, engine?: “native” | “kicad-cli” | “both” = “native” | errors, warnings, violations, engines |
panel.export | edsnx panel export | export | Export panel. Write the panel board (and its .kicad_pro) to out (default the panel file’s output), and with gerbers plot the Gerbers (copper, paste, silk, mask, Edge.Cuts) and the Excellon drill files of the panel through kicad-cli into that folder (relative to the panel board). | path?: string, out?: string, gerbers?: string | board, files, errors |
panel.generate | edsnx panel generate | edit | Generate panel board. Generate the panel board from the panel file: every instance’s items transformed (references kept, Panel.Instance property, nets prefixed P | path?: string | file, files, dryRun, summary, panel |
panel.newsoftforge.edsnx.panel.new | edsnx panel new | edit | New panel. Create a panel file (*.kicad_panel, default | path?: string, name?: string, boards: string[], cols?: integer = 3, rows?: integer = 2, gapX?: number, gapY?: number, rails?: number = 8, alternateRotation?: boolean = true, rowsSeparation?: “vscore” | “mousebites” | “tabs” | “none”, colsSeparation?: “vscore” | “mousebites” | “tabs” | “none”, generate?: boolean = true, force?: boolean | file, files, dryRun, summary, panel |
panel.set | edsnx panel set | edit | Set panel fields. Change the panel file: name, boards (paths relative to the panel file, or {id, board, variant}), layout ({kind: “grid”, cols, rows, gapX, gapY, alternateRotation} or {kind: “manual”}), instances (manual layout: {boardId, at, rot}), rails ({top, bottom, left, right, fiducials, toolingHoles: {d, inset}}), separation ({rows, cols}: a kind or a Separation), text, options (DRC limits, refill, output). The panel board is regenerated when generate (default true). | path?: string, name?: string, boards?: any[], layout?: object, instances?: any[], rails?: object, separation?: object, text?: any[], options?: object, size?: object, generate?: boolean = true | file, files, dryRun, summary, panel |
Examples
panel.describeThe sample panel:{"path":"examples/sample-project/blinky.kicad_panel"}panel.drcPanel DRC of the sample panel:{"path":"examples/sample-project/blinky.kicad_panel"}panel.exportPanel Gerbers:{"path":"examples/sample-project/blinky.kicad_panel","gerbers":"fab/"}panel.generateRegenerate the sample panel:{"path":"examples/sample-project/blinky.kicad_panel"}panel.newA 3 × 2 panel of the sample board:{"path":"examples/sample-project/blinky.kicad_panel","boards":["examples/sample-project/blinky.kicad_pcb"]}panel.setFour columns, mouse bites with 6 holes:{"path":"examples/sample-project/blinky.kicad_panel","layout":{"cols":4},"separation":{"cols":{"kind":"mousebites","count":6}},"generate":false}
Test points#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
test.assign | edsnx test assign | edit | Assign test points. Assign one test point per net needing access (existing pads, then vias, by the rules; the most constrained nets first; pitch kept), propose a test pad (TestPoint:TestPoint_Pad_Dplace add those pads (ref TP | path: string, rules?: object, place?: boolean = false | report, proposals, placed, summary |
test.ipcd356 | edsnx test ipcd356 | export | IPC-D-356 netlist. Write the IPC-D-356A netlist of the board (bare-board test). engine “auto” uses kicad-cli when installed (pcb export ipcd356), else the native writer (src/test/ipcd356.ts, the same records); “native” always the writer. testPointsOnly (native) keeps the records of the assigned test points. | path: string, out?: string, engine?: “auto” | “kicad-cli” | “native” = “auto”, testPointsOnly?: boolean = false, rules?: object | file, engine, records |
test.probeReport | edsnx test probe-report | export | Probe report. The test points as a probe report: “csv” (TP, Net, X, Y, Side, Size, Source, Ref), “flying” (generic flying-probe / ICT CSV: Name, Net, X, Y, Side T/B, Pad, Type) or “takaya” (fixed-column text). Coordinates in mm from the board outline’s lower-left corner, y up (origin “kicad”: KiCad coordinates). Proposed pads are included unless existing. | path: string, out?: string, format?: “csv” | “flying” | “takaya” = “csv”, origin?: “lower-left” | “kicad” = “lower-left”, existing?: boolean = false, rules?: object | file, points, accessPercent, text |
test.report | edsnx test report | query | Test access report. Test access per net under the rules: the assigned points (id, net, position, side, source pad / via / added), nets without access with the reason, access %. existing counts only copper already on the board (no proposed pads): what DFF checks (dff_test_access). | path: string, rules?: object, existing?: boolean = false | report, summary |
test.rules.get | edsnx test rules get | query | Test point rules. The test point rules of the board’s project (.kicad_pro softforge.testPoints) with the defaults filled: nets (“all”), padMin 0.8 mm, pitchMin 1.27 mm, side “either”, prefer pads. | path: string | nets, padMin, pitchMin, side, preferVias, preferPads, excludeNets |
test.rules.set | edsnx test rules set | edit | Set test point rules. Merge rules into the project’s test point rules (.kicad_pro softforge.testPoints), one undo step with the board. | path: string, rules: object | newIds, touched, revision, hash, label, message, dryRun, diff, changed, steps |
Examples
test.assignAssign on the sample:{"path":"examples/sample-project/blinky.kicad_pcb"}test.ipcd356IPC-D-356 of the sample:{"path":"examples/sample-project/blinky.kicad_pcb","engine":"native"}test.probeReportFlying-probe CSV of the sample:{"path":"examples/sample-project/blinky.kicad_pcb","format":"flying"}test.reportAccess on the sample:{"path":"examples/sample-project/blinky.kicad_pcb"}test.rules.getSample rules:{"path":"examples/sample-project/blinky.kicad_pcb"}test.rules.setBottom-side probing, 2.54 mm pitch:{"path":"examples/sample-project/blinky.kicad_pcb","rules":{"side":"bottom","pitchMin":2.54}}
Comments#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
comment.add | edsnx comment add | edit | Add comment. Start a comment thread: on an item (item: uuid or reference, the thread follows the item when it moves), a point (at mm, optional layer), a region (region outline mm) or the whole document / project (none). Mentions are @handles (@agent posts the thread to the attached agent from the editor). The author defaults to git config user.name. Writes <project>.comments.json. | path: string, body: string, item?: string, at?: [x, y], region?: [x, y][], layer?: string, author?: string, labels?: string[] | file, thread |
comment.export | edsnx comment export | export | Export comments. The comment threads as Markdown for the review report (one section per thread: anchor, state, author, body, replies; detached item anchors marked). out writes the file, else the text is returned. | path?: string = “.”, state?: “open” | “resolved” | “all” = “all”, out?: string | text, file, threads |
comment.list | edsnx comment list | query | List comments. Comment threads of the project (<project>.comments.json): number, state (open / resolved), author, body, replies, the anchor (item uuid, point, region or file) resolved on its document (“R8”, detached when the item is gone) and the counts. Filter by state or by document. | path?: string = “.”, state?: “open” | “resolved” | “all” = “all”, file?: string | file, threads, counts |
comment.reply | edsnx comment reply | edit | Reply to comment. Reply to a comment thread (by number or id). The author defaults to git config user.name; @mentions are recorded. | path?: string = “.”, thread: string, body: string, author?: string | file, thread, reply |
comment.resolve | edsnx comment resolve | edit | Resolve comment. Resolve a comment thread (by number or id), or reopen it with reopen. Records who resolved it and when. | path?: string = “.”, thread: string, reopen?: boolean = false, by?: string | file, thread |
comment.showPanelsoftforge.edsnx.comments.show | edsnx comment show-panel | ui | Comments and Design Review Panel. Show the Comments tab of the board or schematic editor: the comment threads of the document (filter, New comment, Region, Export to report), the Live Share session, the design review of the current branch and the web viewer card. | path?: string = “.” | object |
Examples
comment.addOn R8:{"path":"blinky.kicad_pcb","item":"R8","body":"This trace runs under the crystal; can we move it to B.Cu? @agent"}comment.addAt a point:{"path":"blinky.kicad_pcb","at":[120.5,98],"layer":"F.Cu","body":"Zone clearance near U1"}comment.exportOpen threads into the report:{"state":"open","out":"review/comments.md"}comment.listOpen threads:{"path":"blinky.kicad_pro","state":"open"}comment.listThreads on the board:{"file":"blinky.kicad_pcb"}comment.replyReply to #1:{"thread":"1","body":"Yes, re-routing on B.Cu with a via pair."}comment.resolveResolve #2:{"thread":"2"}comment.resolveReopen #2:{"thread":"2","reopen":true}comment.showPanelOpen the Comments tab:{}
Web viewer#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
viewer.export | edsnx viewer export | export | Export web viewer. Export a static web viewer folder (index.html, viewer.js, data/): the boards and schematics of the project (or documents) with layers, net highlight, measure, zoom / pan; 3d adds the components’ 3D models for the 3D tab (read natively from the footprints’ VRML / glb models, no kicad-cli; models3d kicad-cli or auto to use it), comments the comment pins, checks ERC / DRC markers. The documents show an assembly variant (variant, default the project’s active one; base the files): DNP parts crossed / hatched as in the editors and left out of the 3D models, value overrides on the canvas. Opens from file:// and any static host (relative paths only). Returns the folder, files, size, manifest and the link (baseUrl, else the setting softforge.edsnx.collab.baseUrl in .vscode/settings.json, else the CI-written URL, else file://). | path?: string = “.”, documents?: string[], out?: string = “viewer”, 3d?: boolean = false, models3d?: “native” | “kicad-cli” | “auto” = “native”, comments?: boolean = false, checks?: boolean = false, variant?: string, title?: string, baseUrl?: string | out, files, bytes, manifest, url, urlSource, warnings |
Examples
viewer.exportProject with comments and checks:{"path":"blinky.kicad_pro","out":"public/viewer","comments":true,"checks":true}viewer.exportBoard with 3D:{"path":"blinky.kicad_pcb","out":"viewer","3d":true}viewer.exportAn assembly variant, published under a base URL:{"path":"blinky.kicad_pro","out":"public/viewer","variant":"lite","baseUrl":"https://team.pages.example/blinky/viewer"}
MCAD co-design#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
mcad.boolean | edsnx mcad boolean | edit | Reference solid boolean. Combine two reference solids: op union, subtract (a − b) or intersect. With the OCCT add-on and both solids from STEP files the boolean runs on the exact B-rep (tolerance ~1e-7 mm) and is tessellated once; otherwise mesh CSG (BSP) on their triangles in the main extension, whose curved faces carry the input tessellation’s chord error (src/mcad/booleans.ts). The result is a glb in .softforge/mcad/ that replaces solid a (or becomes solid id); hideB hides solid b. Returns the engine, the precision note, the volume and the triangle count. | path: string, a: string, b: string, op: “union” | “subtract” | “intersect”, id?: string, name?: string, hideB?: boolean = false, meshQuality?: number = 0.5 | solid, engine, precision, volumeMm3, triangles, file |
mcad.clearancesoftforge.edsnx.mcad.clearance | edsnx mcad clearance | check | MCAD clearance check. 3D clearance of the board against its reference solids (src/mcad/clearance.ts; the DRC rules mcad_*): component bodies (courtyard × height: Height field, package table, type default; or their 3D model meshes with models) colliding with a solid (penetration depth along the smallest push, location in the MCAD frame and on the board), bodies closer than clearanceMinMm (enclosure clearance), bodies completely inside a closed solid, solids intruding into the board, parts above a height envelope, enclosure bosses without a mounting hole. Returns the hits, the minimum clearance (negative = penetration), an interference volume estimate and the time. | path: string, clearanceMinMm?: number, componentPairs?: boolean = false, models?: string | hits, envelopes, mounting, minClearanceMm, interferenceMm3, counts, ms, warnings |
mcad.describe | edsnx mcad describe | query | Describe MCAD. The board’s MCAD file (<board>.kicad_mcad.json): reference solids (file, kind, placement in the MCAD frame — mm, z up, y = −KiCad y, z = 0 on the board bottom — opacity, visibility, mesh state and bounds), height envelopes, enclosure bosses, the clearance minimum, whether the OCCT add-on is available, and the IDX exchange history. | path: string | file, exists, occt, solids, envelopes, bosses, clearanceMinMm, history, warnings |
mcad.envelope.add | edsnx mcad envelope add | edit | Add height envelope. Add a height envelope: parts on side whose footprint box overlaps outline may be at most maxHeight mm high (rule mcad_height_envelope). Returns the id. | path: string, id?: string, name?: string, outline: [x, y][], side?: “top” | “bottom” = “top”, maxHeight: number | id, envelope, file |
mcad.envelope.remove | edsnx mcad envelope remove | edit | Remove height envelopes. Remove height envelopes. | path: string, ids: string[] | removed, file |
mcad.envelope.set | edsnx mcad envelope set | edit | Edit height envelope. Change a height envelope: name, outline, side, maxHeight. | path: string, id: string, name?: string, outline?: [x, y][], side?: “top” | “bottom”, maxHeight?: number | envelope, file |
mcad.exportStep | edsnx mcad export-step | export | Export board STEP. The board as a STEP assembly through the OCCT add-on: the outline with its cut-outs and drilled holes (⌀ ≥ minHole) extruded by the board thickness from z = 0, plus each footprint’s STEP model (paths with ${VARS} expanded from the environment and the project; .wrl falls back to the .step beside it) placed at its position, rotation and side with the model’s offset / rotation / scale. Parts without a STEP model are listed in missing. MCAD frame: mm, z up, y = −KiCad y. | path: string, out: string, components?: boolean = true, minHole?: number = 0.6 | file, bytes, components, holes, missing |
mcad.idx.apply | edsnx mcad idx apply | edit | Apply accepted IDX changes. Apply the accepted changes of the pending IDX exchange: outline (Edge.Cuts replaced), component and mounting-hole moves / rotations / side, Height fields, keep-out rule areas (add / reshape / delete) in one undo step on the board; height limits and mounting bosses in the MCAD file. Changes that cannot apply (new electrical parts, pad holes) are listed in skipped. | path: string, file?: string | applied, skipped, edits |
mcad.idx.decide | edsnx mcad idx decide | edit | Accept / reject IDX changes. Accept or reject changes of the pending IDX exchange (or of file): accept / reject list item ids (* = every undecided one), comments maps item id → comment for the response. | path: string, file?: string, accept?: string[], reject?: string[], comments?: object | changes |
mcad.idx.export | edsnx mcad idx export | export | Export IDX. Write the board as an IDX 3.0 baseline (ProSTEP iViP EDMDDataSet, SendInformation): board outline and thickness, cut-outs, non-plated and mounting holes, keep-out rule areas, component placements with heights (Height field / package table) and sides, height envelopes as component keep-outs with an upper bound. Coordinates in the MCAD frame (y up). Records the exchange in <board>.kicad_idx.json. | path: string, out: string, creator?: string | file, items, bytes, baseline |
mcad.idx.history | edsnx mcad idx history | query | IDX history. The IDX exchanges of the board (<board>.kicad_idx.json), newest last: file, direction (ecad = sent, mcad = received), date, item count, changes with their decisions, when applied. | path: string, changes?: boolean = false | exchanges |
mcad.idx.importsoftforge.edsnx.mcad.idxImport | edsnx mcad idx import | query | Import IDX. Read an IDX from MCAD (a baseline or SendChanges proposals) and compute its changes against the board’s current items: board outline, holes, mounting holes, keep-outs, component moves / rotations / heights, height limits, notes — each with a summary (op add / modify / remove). Records the exchange (decisions undecided); the editor opens the review dialog. Nothing changes on the board until mcad.idx.apply. | path: string, file: string | kind, items, changes, header |
mcad.idx.respond | edsnx mcad idx respond | export | Write IDX response. Write the response IDX for the pending exchange: SendChanges with each change’s IsAccepted (true / false; undecided count as rejected) and comment, for the MCAD tool to merge. Recorded in the history. | path: string, out: string, file?: string | file, accepted, rejected, undecided |
mcad.importStepsoftforge.edsnx.mcad.importStep | edsnx mcad import-step | edit | Import reference solid. Add (or replace, with id) a reference solid such as an enclosure: a STEP is tessellated by the OCCT add-on (meshQuality 0…1) into .softforge/mcad/<name>-<key>.glb, a .glb (metres, y up like kicad-cli) is referenced as is. Placement at / rot in the MCAD frame (mm, degrees about x, then y, then z). With detectBosses the add-on’s vertical cylinders of the STEP become mounting bosses. Writes the MCAD file; returns the solid and its bounds. | path: string, file: string, id?: string, name?: string, kind?: “enclosure” | “battery” | “mechanical” | “other”, at?: number[], rot?: number[], opacity?: number, meshQuality?: number = 0.5, detectBosses?: boolean = false | solid, bounds, converted, bosses, file |
mcad.linksoftforge.edsnx.mcad.link | edsnx mcad link | edit | MCAD link folder. Set the live MCAD link: an exchange folder shared with the MCAD system. The board’s IDX baseline is written there (<stem>-ecad-baseline.idx, unless publish is false); IDX proposals (.idx / .xml) and solids (.step / .stp / .glb) that MCAD drops there become proposals (mcad.link.scan; the editor watches the folder and opens the review). off clears the link. Without folder or off: the current link and the files waiting. | path: string, folder?: string, off?: boolean = false, publish?: boolean = true | folder, baseline, waiting |
mcad.link.respond | edsnx mcad link respond | edit | Answer MCAD link proposal. Answer the pending IDX exchange through the link folder: apply applies the accepted changes first (as mcad.idx.apply), reject rejects every undecided change (with comment); the response IDX (<stem>-ecad-response-<time>.idx) is written into the folder for MCAD to merge. | path: string, apply?: boolean = false, reject?: boolean = false, comment?: string | file, accepted, rejected, undecided, applied |
mcad.link.scan | edsnx mcad link scan | query | Scan MCAD link folder. Take the new or changed files of the MCAD link folder as proposals: an IDX is imported against the board (an exchange with its changes, as mcad.idx.import; review with mcad.idx.decide), a STEP / glb becomes “update reference solid | path: string, settleMs?: integer = 300 | proposals |
mcad.outline | edsnx mcad outline | edit | Board outline from STEP / DXF. Set the board outline from MCAD: a DXF (LINE / ARC / CIRCLE / LWPOLYLINE / POLYLINE, built in) or a STEP (the OCCT add-on: the largest planar face at the top or bottom, else a section). The largest loop is the outline, loops inside it are cut-outs; y is flipped (MCAD y up → KiCad y down) and offset [dx, dy] (board mm) is added. With replace (default) the board-level Edge.Cuts shapes are deleted first. One undo step. preview returns the outline without editing. | path: string, file: string, plane?: “top” | “bottom” = “top”, layer?: string, offset?: [x, y], replace?: boolean = true, preview?: boolean = false, tolerance?: number | outer, holes, size, source, deleted, edits, warnings |
mcad.requirement | edsnx mcad requirement | edit | Enclosure clearance requirement. Add a requirement (layer family Mechanical) that the clearance between component bodies and the enclosure stays ≥ limit (default the MCAD file’s minimum clearance): quantity mechanical enclosureClearance, aggregate min, over the board. The editor supplies the value from each clearance run (requirementsEval setExternalQuantity). Returns the requirement id and the current minimum. | path: string, limit?: number, name?: string | id, limit, current |
mcad.solid.remove | edsnx mcad solid remove | edit | Remove reference solids. Remove reference solids (and the bosses detected on them). Cached glbs stay in .softforge/mcad/. | path: string, ids: string[] | removed, file |
mcad.solid.set | edsnx mcad solid set | edit | Edit reference solid. Change a reference solid: name, kind, at / rot (MCAD frame), opacity, visible. | path: string, id: string, name?: string, kind?: “enclosure” | “battery” | “mechanical” | “other”, at?: number[], rot?: number[], opacity?: number, visible?: boolean | solid, file |
Examples
mcad.booleanCut the connector opening out of the enclosure:{"path":"blinky.kicad_pcb","a":"s1","b":"s2","op":"subtract","hideB":true}mcad.clearanceThe sample under its enclosure:{"path":"blinky.kicad_pcb"}mcad.describeThe sample’s enclosure and envelope:{"path":"blinky.kicad_pcb"}mcad.envelope.add4 mm under a display window:{"path":"blinky.kicad_pcb","name":"Display","outline":[[119,108],[131,108],[131,120],[119,120]],"maxHeight":4}mcad.envelope.removeRemove an envelope:{"path":"blinky.kicad_pcb","ids":["e1"]}mcad.envelope.setAllow 5.5 mm:{"path":"blinky.kicad_pcb","id":"e1","maxHeight":5.5}mcad.exportStepThe sample board as STEP:{"path":"blinky.kicad_pcb","out":"blinky.step"}mcad.idx.applyApply what was accepted:{"path":"blinky.kicad_pcb"}mcad.idx.decideAccept the hole move, reject the keepout:{"path":"blinky.kicad_pcb","accept":["mounting:H1"],"reject":["keepout:K1"],"comments":{"keepout:K1":"Antenna area needs copper"}}mcad.idx.exportBaseline for the MCAD team:{"path":"blinky.kicad_pcb","out":"blinky.idx"}mcad.idx.historyExchanges so far:{"path":"blinky.kicad_pcb"}mcad.idx.importProposals from the enclosure designer:{"path":"blinky.kicad_pcb","file":"from-mcad.idx"}mcad.idx.respondAnswer the MCAD proposals:{"path":"blinky.kicad_pcb","out":"blinky-response.idx"}mcad.importStepThe sample enclosure (glb) over the board:{"path":"blinky.kicad_pcb","file":"enclosure.glb","at":[125,-117.5,0]}mcad.importStepA STEP enclosure with its bosses:{"path":"blinky.kicad_pcb","file":"enclosure.step","at":[125,-117.5,0],"detectBosses":true}mcad.linkLink to the enclosure team’s share:{"path":"blinky.kicad_pcb","folder":"mcad-exchange"}mcad.linkStop the link:{"path":"blinky.kicad_pcb","off":true}mcad.link.respondApply what was accepted and answer:{"path":"blinky.kicad_pcb","apply":true}mcad.link.respondReject the proposal:{"path":"blinky.kicad_pcb","reject":true,"comment":"Keep the connector where it is"}mcad.link.scanWhat did MCAD send?:{"path":"blinky.kicad_pcb"}mcad.outlineOutline from a DXF, moved into the sheet:{"path":"blinky.kicad_pcb","file":"outline.dxf","offset":[100,135]}mcad.outlinePreview the outline of a STEP:{"path":"blinky.kicad_pcb","file":"enclosure-pcb.step","preview":true}mcad.requirementKeep 1 mm to the enclosure:{"path":"blinky.kicad_pcb","limit":1}mcad.solid.removeRemove the enclosure:{"path":"blinky.kicad_pcb","ids":["s1"]}mcad.solid.setLift the enclosure 0.5 mm:{"path":"blinky.kicad_pcb","id":"s1","at":[125,-117.5,0.5]}
Signal and power integrity#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
si.ac | edsnx si ac | check | PDN impedance (AC). AC impedance |Z(f)| of each supply net seen from an IC’s supply pins (2.1.0): plane pairs (the net’s fills facing ground fills on the adjacent layer, C = ε0·εr·A/h, the plane-to-plane capacitance), decoupling capacitors (value from the footprint, ESL / ESR from its ESL / ESR fields when present, else by package; mounting and spreading inductance), the VRM (R + L) and the IC’s via loop; the target impedance V·ripple / (I·transient fraction) and the bands above it. Run on demand, separate from the DC solve. Records the results in the SI file. | path: string, nets?: string[], at?: string, fMinHz?: number, fMaxHz?: number, points?: integer, targetOhm?: number, record?: boolean = true | ac, file, ms |
si.asRequirement | edsnx si as-requirement | edit | PDN result as requirement. Add an L requirement on the PDN overlay of a net: quantity: "drop" → max of the si.pdn.<net>.drop overlay (mV) ≤ limit (default the net’s irDropMaxMv), "current" → max of si.pdn.<net>.j (A/mm²) ≤ limit (default jMaxAPerMm2). Evaluated live in the editor when the SI/PI panel has solved the net. Returns the requirement id (req.add). | path: string, net: string, quantity?: “drop” | “current” = “drop”, limit?: number | id, requirement |
si.checks | edsnx si checks | check | Return path and EMC checks. The signal / power integrity DRC rules alone (native engine, with the board’s SI file): si_return_path_split, si_reference_change_no_via, si_stitching_pitch, si_edge_rate_series_r, si_stub_length, si_crosstalk_coupling, si_impedance_out_of_range, pdn_ir_drop, pdn_current_density, pdn_decoupling_distance. Each violation has the rule, severity, message, position and items. The pdn_* rules use the results recorded by si.pdn. decoupling also lists the decoupling estimate per IC and supply net. | path: string, rules?: “si_return_path_split” | “si_reference_change_no_via” | “si_stitching_pitch” | “si_edge_rate_series_r” | “si_stub_length” | “si_crosstalk_coupling” | “si_impedance_out_of_range” | “pdn_ir_drop” | “pdn_current_density” | “pdn_decoupling_distance”[] | violations, errors, warnings, decoupling |
si.describe | edsnx si describe | query | Describe signal / power integrity setup. The SI file of a board (<board>.kicad_si.json): rule settings (fMaxHz, stitching λ fraction, stub, crosstalk, impedance tolerance and targets, IR-drop limits per net, J max, decoupling distance), IBIS-lite models (built-in and the file’s), per-net driver / receiver models and pins, load and source points, and a summary of the last results (worst Z0 / crosstalk per net, drop and J per PDN net). | path: string | file, exists, rules, models, netModels, sources, loads, results, warnings |
si.emission | edsnx si emission | check | Radiated-emission estimate. An ESTIMATE of the radiated emission against the CISPR 32 class B limit (2.1.0; not a measurement): differential-mode radiation of every analysed signal net’s loop (Ott, E = 2.63e-14·f²·A·I/r) and common-mode radiation driven by the return-path discontinuities of the si_return_path_split / si_reference_change_no_via checks into an attached cable (E = 1.257e-6·f·L·I_cm/r), the clock spectra as trapezoid envelopes, 10 m below 1 GHz and 3 m above. Per frequency: dBµV/m of each part, total, limit and margin; the worst margin; the sources ranked; the assumptions. clocks sets toggle frequencies per net, cableM the cable (0: the board). Records the result in the SI file. | path: string, nets?: string[], clocks?: object, defaultClockHz?: number, cableM?: number, points?: integer, record?: boolean = true | estimate, worst, sources, points, assumptions, file |
si.handoff | edsnx si handoff | export | Field-solver hand-off. Write a field-solver model of the selected nets: tool: "openems" writes <name>.py (CSXCAD + openEMS python: dielectrics, copper as extruded polygons, lumped ports, mesh, run, Touchstone output) and geometry.xml (CSX); tool: "elmer" writes model.geo (gmsh), case.sif (VectorHelmholtz) and run.sh. The region defaults to the nets’ copper + 3 mm; reference planes (fills of other nets) in the region are included. Mesh presets: coarse / normal / fine = 10 / 20 / 40 cells per wavelength at fMax in the dielectric. Ports default to the two farthest pads of each net (50 Ω). | path: string, tool: “openems” | “elmer”, nets: string[], region?: [x0, y0, x1, y1], mesh?: “coarse” | “normal” | “fine” = “normal”, fMaxHz?: number, ports?: object[], out: string, name?: string | files, ports, region, resolution, warnings |
si.lossy | edsnx si lossy | query | Lossy line model. The lossy, dispersive line model of a track (2.1.0): per frequency R (skin effect, Wheeler’s incremental-inductance rule), L, G (Djordjevic–Sarkar dielectric fitted to the layer’s εr and tan δ), C, Zc, the conductor / dielectric / total attenuation (dB/m) and the phase delay, for a layer and width; or, with net, the insertion loss of the net’s routed copper and (out) its 2-port Touchstone (the sections cascaded, 50 Ω ports) for the S-parameter card. | path: string, layer?: string, width?: number, net?: string, freqHz?: number[], out?: string | line, points, net, file |
si.pdn | edsnx si pdn | check | PDN IR drop. DC solve of each PDN net’s copper (zone fills on a grid, tracks, vias, pads as a resistive mesh) under its load and source points: worst drop (mV) and where, worst current density (A/mm²), where and on which layer, drop per load, the limit (irDropMaxMv) and the decoupling check (nearest capacitor per IC and supply net, loop inductance nH). gridMm sets the grid pitch (default automatic). out writes the drop and current-density fields as overlay JSON files (<net>-drop.json, <net>-j.json). Records the results in the SI file (the pdn_* DRC rules read them). | path: string, nets?: string[], gridMm?: number, out?: string, record?: boolean = true | pdn, fields, warnings, file, ms |
si.point.add | edsnx si point add | edit | Add load / source point. Add a PDN load (kind: "load", currentA drawn from the net there; on a return net whose sources are all 0 V the current flows back in) or source (kind: "source", voltageV, default from the net name: +3V3 → 3.3, GND → 0) on a pad (ref + pad) or at at on layer of net. Returns the point. | path: string, kind?: “load” | “source” = “load”, id?: string, net?: string, ref?: string, pad?: string | integer, at?: [x, y], layer?: string, currentA?: number, voltageV?: number | point, file |
si.point.remove | edsnx si point remove | edit | Remove load / source points. Remove load and source points by id. | path: string, ids: string[] | removed, file |
si.set | edsnx si set | edit | Set SI rules and models. Change the SI file: rules is merged into the rule settings (irDropMaxMv merged per net), netModels per net (null removes a net’s entry), models adds or replaces IBIS-lite models by id ({ id, name, kind: driver | receiver | io, rOut Ω, cIn pF, vHigh, vLow, edgePsPerV, thresholds { vih, vil } }). Writes <board>.kicad_si.json. | path: string, rules?: object, netModels?: object, models?: object[] | file, rules, netModels, models |
si.showPanelsoftforge.edsnx.si.show | edsnx si show-panel | ui | SI/PI Panel. Show the SI/PI panel of the board editor: per-net table (Z0, delay, crosstalk, reflection), PDN table (load, drop, J max with limits), return path and EMC checks, Add load point / Solve DC / Decoupling check / As requirement, S-parameters and field-solver hand-off. | path?: string | object |
si.solve | edsnx si solve | export | Run a field solver. Run openEMS or Elmer on the hand-off model of the selected nets (2.1.0): the model is written to out (si.handoff), then openEMS runs geometry.xml (its port probes become <name>.s<N>p) or the python script, Elmer runs run.sh (gmsh → ElmerGrid → ElmerSolver → <name>.vtu). Fails with “service-unavailable” and the owner note when the solver is not installed (si.solvers). | path: string, tool: “openems” | “elmer”, nets: string[], mesh?: “coarse” | “normal” | “fine” = “coarse”, fMaxHz?: number, out: string, name?: string | files, touchstone, field, warnings |
si.solvers | edsnx si solvers | query | Field solvers installed. Detect openEMS (the openEMS executable, or its python bindings) and Elmer (ElmerSolver, ElmerGrid and gmsh): installed or not, how it runs, the programs probed with their first output line, the reason when not installed and the owner note (what to install). The openEMS / Elmer custom tools and si.solve use the same detection. | — | solvers |
si.sparams | edsnx si sparams | query | Read S-parameters. Read a Touchstone file (.sNp, v1 or v2): ports, frequency range and points, reference impedance, and per requested pair (default S11 and S21) |S| in dB at up to points frequencies plus the −3 dB and −10 dB crossing frequencies. | file: string, pairs?: integer[][], points?: integer = 21 | ports, z0, fMinHz, fMaxHz, count, params |
si.tline | edsnx si tline | check | Transmission lines and crosstalk. Per signal net: Z0 average / min / max (Ω) of its segments from the stack-up (microstrip / stripline; Zdiff of coupled differential pair segments), delay (ps) from the driver pin to the receiver (or the farthest pad), routed length, via stubs (mm, quarter-wave resonance Hz), crosstalk against parallel neighbours (aggressor, coupled length, spacing, NEXT / FEXT dB, worst point) and, with a driver model, the reflection estimate (overshoot %, settle ps, monotonic, notes). segments adds every segment. Records the results in the SI file. | path: string, nets?: string[], segments?: boolean = false, record?: boolean = true | nets, file, ms |
Examples
si.acAC impedance of every supply net:{"path":"blinky.kicad_pcb"}si.ac+5V against 0.1 Ω up to 500 MHz:{"path":"blinky.kicad_pcb","nets":["+5V"],"targetOhm":0.1,"fMaxHz":500000000}si.asRequirement+5V drop below 50 mV:{"path":"blinky.kicad_pcb","net":"+5V","quantity":"drop","limit":50}si.checksReturn path and EMC of the sample:{"path":"blinky.kicad_pcb"}si.describeSI setup of the sample:{"path":"blinky.kicad_pcb"}si.emissionEmission estimate of the sample:{"path":"blinky.kicad_pcb"}si.emissionA 25 MHz clock on /OUT, no cable:{"path":"blinky.kicad_pcb","clocks":{"/OUT":25000000},"cableM":0}si.handoffopenEMS model of /OUT:{"path":"blinky.kicad_pcb","tool":"openems","nets":["/OUT"],"out":"si/openems"}si.lossyF.Cu 0.3 mm line:{"path":"blinky.kicad_pcb","layer":"F.Cu","width":0.3}si.lossyLoss of a net with its Touchstone:{"path":"blinky.kicad_pcb","net":"/OUT","out":"si/out-lossy.s2p"}si.pdnSolve every PDN net:{"path":"blinky.kicad_pcb"}si.pdn+5V with field files:{"path":"blinky.kicad_pcb","nets":["+5V"],"out":"si-fields"}si.point.add0.3 A load on U1 pin 8:{"path":"blinky.kicad_pcb","kind":"load","ref":"U1","pad":"8","currentA":0.3}si.point.add5 V source on J1 pin 1:{"path":"blinky.kicad_pcb","kind":"source","ref":"J1","pad":"1"}si.point.removeRemove a load:{"path":"blinky.kicad_pcb","ids":["L1"]}si.setIR-drop limit and a driver model:{"path":"blinky.kicad_pcb","rules":{"irDropMaxMv":{"+5V":50}},"netModels":{"/OUT":{"driver":"cmos5","receiver":"input-5pf","driverPin":"U1.3","receiverPin":"J2.1"}}}si.showPanelOpen the SI/PI panel:{}si.solveopenEMS on /OUT:{"path":"blinky.kicad_pcb","tool":"openems","nets":["/OUT"],"out":"si/openems-run"}si.solversWhich field solvers are installed:{}si.sparamsS11 / S21 of the sample’s line:{"file":"si/out-line.s2p"}si.tlineEvery signal net:{"path":"blinky.kicad_pcb"}si.tlineOne net with segments:{"path":"blinky.kicad_pcb","nets":["/OUT"],"segments":true}
Gerber engine and viewer#
| Command | CLI | Kind | Description | Args | Result |
|---|---|---|---|---|---|
gerber.check | edsnx gerber check | check | Check Gerbers. Gerber-level DFM on a fab set from any tool (rules gbr_min_feature, gbr_min_clearance, gbr_min_annular, gbr_sliver, gbr_mask_opening, gbr_paste_opening, gbr_outline_open, gbr_drill_to_copper, gbr_missing_layer, gbr_attribute_mismatch): min copper feature (erosion), min copper clearance, min annular ring (plated holes vs copper), solder mask slivers, pads without mask opening, paste off copper, Profile outline closure, hole to copper, missing layers and job-file attribute mismatches. Limits from profile (a DFM profile id: jlcpcb-4 …), else the project’s active profile when the set sits in a project, else defaults; single limits override. failOn error / warning puts the findings in errors (output jobs fail the step). out writes the JSON report. | path: string, profile?: string, board?: string, rules?: “gbr_min_feature” | “gbr_min_clearance” | “gbr_min_annular” | “gbr_sliver” | “gbr_mask_opening” | “gbr_paste_opening” | “gbr_outline_open” | “gbr_drill_to_copper” | “gbr_missing_layer” | “gbr_attribute_mismatch”[], minFeature?: number, minClearance?: number, minAnnular?: number, sliver?: number, drillToCopper?: number, failOn?: “none” | “error” | “warning” = “none”, out?: string, limit?: integer = 200, text?: boolean = false, load?: boolean = false | counts, summary, findings, settings, profile, errors, file, table, truncated, load |
gerber.compare | edsnx gerber compare | check | Compare Gerbers. Compare two fab sets layer by layer (paired by X2 file function, file-name heuristics otherwise): dark area of each, XOR area and its share of the layer, XOR regions with bboxes (only in a / only in b), aperture function counts, drill hits per size and file attribute differences. Either side may be a .kicad_pcb, plotted natively (Gerber vs board). ok when every pair is within tolerance % with no other difference and no layer is unmatched. | path: string, b: string, tolerance?: number = 0.01, shapes?: boolean = false, ignore?: string[], maxRegions?: integer = 20, text?: boolean = false, png?: string | ok, tolerancePct, pairs, unmatchedA, unmatchedB, a, b, table, diff |
gerber.compareReviewsoftforge.edsnx.gerber.compareReview | edsnx gerber compare-review | ui | Review Gerber vs Gerber. Open the Gerber vs Gerber review in the Gerber viewer: one row per layer with the XOR thumbnail, areas, XOR %, regions (click to centre), aperture and attribute differences, Export Markdown, and a stale banner with Re-run when a file of either set changes on disk. Without arguments it reviews the active viewer’s last compare, else asks for two fab sets. UI-only: agents use gerber.compare. | a?: string, b?: string | object |
gerber.export | edsnx gerber export | export | Export Gerbers. Plot a board into a fabrication set: one RS-274X file per layer (X2 file functions, aperture functions, X2 netlist .N/.P/.C attributes), Excellon drill files (PTH / NPTH), drill maps and the .gbrjob job file. engine native (default: the SoftForge engine, no KiCad needed) or kicad-cli. Flags mirror the Plot dialog (layers, precision, protel, x2, netlist, disableMacros, subtractMask, auxOrigin, mergeNpth, drillMap, drillUnits; options takes a whole PlotOptions). Unsaved edits of an open board are plotted. Returns the files written. | path: string, out?: string = “fab/”, engine?: “native” | “kicad-cli” = “native”, layers?: string[], precision?: 5 | 6, protel?: boolean, x2?: boolean, netlist?: boolean, disableMacros?: boolean, subtractMask?: boolean, auxOrigin?: boolean, mergeNpth?: boolean, drillMap?: boolean, drillUnits?: “mm” | “in”, options?: object, variant?: string, glyphs?: “kicad” | “softforge” = “kicad” | files, folder, engine, warnings, errors |
gerber.job | edsnx gerber job | query | Gerber job file. The job file (.gbrjob) of a fab set: project, size, copper layer count, thickness, files with their FileFunction and polarity, the material stack-up, plus missing / mismatch (job entries without a file, files whose X2 function or polarity differ, gbr_missing_layer / gbr_attribute_mismatch). With a .kicad_pcb: the native engine’s job file (out writes it). | path: string, out?: string | job, files, missing, mismatch, file |
gerber.openSetsoftforge.edsnx.gerber.openSet | edsnx gerber open-set | ui | Open fab set…. Open a folder or a .zip of Gerber / drill / job files in the Gerber viewer (custom editor softforge.edsnx.gerber; opening one .gbr / .drl / .gbrjob loads its siblings as the set). UI-only: needs the open editor. Agents: use gerber.set and gerber.view. | path?: string | object |
gerber.parse | edsnx gerber parse | query | Parse a Gerber, drill or job file. Read one fab file with the SoftForge Gerber reader. Gerber: units, coordinate format, X2 file attributes (function, polarity, generator, project), apertures (D-code, shape, size in mm, aperture function, use count), macro names, object counts (flashes, draws, arcs, regions, clear objects, X3 components), the bounding box (mm, board frame: y down) and the dark area after clear passes when geometry. Excellon: units, format, tools (diameter mm, plated), hits / slots / routes. Job: the parsed .gbrjob. Every unknown or legacy construct is a warning, never an error. | path: string, geometry?: boolean = true | file, kind, warnings |
gerber.set | edsnx gerber set | query | Read a fab set. Load a fab set (a folder, a .zip, or one file of it → its folder) as the Gerber viewer does: each layer with its id, file, name (F.Cu, B.Mask, Edge.Cuts … from the X2 .FileFunction, the job file or the file name: KiCad -F_Cu.gbr, Protel .gtl/.gbl/.gts/.gbs/.gto/.gbo/.gtp/.gbp/.gm1/.gko, .drl/.xln/.txt), function, colour, side, default order (0 = top of the Layers list) and kind; the job file (stack-up, board thickness); the status line (Gerber · 11 files · mm · 4.6 · X2); parse times and warnings per file. | path: string | root, layers, status, warnings |
gerber.view | edsnx gerber view | export | Render Gerbers. Render a fab set (folder, zip, one Gerber/drill file’s folder, or a board plotted natively) with the Gerber viewer’s colours and stacking to a PNG (png), an SVG (svg) and / or a PDF (pdf, vector, 1:1). Headless and browser-free (a software rasteriser). layers limits the layers (F.Cu, B.Mask, Edge.Cuts, PTH … or file names), flipped views from the bottom. Returns the files and the layers drawn. | path: string, png?: string, svg?: string, pdf?: string, layers?: string[], size?: integer = 1600, flipped?: boolean = false, background?: string = “#0b1b2b” | files, layers, width, height, warnings |
Examples
gerber.checkA fab zip against the JLCPCB 4-layer limits:{"path":"fab.zip","profile":"jlcpcb-4"}gerber.checkOnly the outline and drill checks:{"path":"fab/","rules":["gbr_outline_open","gbr_drill_to_copper"]}gerber.compareDid the plot match the board?:{"path":"blinky.kicad_pcb","b":"fab/"}gerber.compareTwo revisions of a fab set:{"path":"fab-rev-a.zip","b":"fab-rev-b.zip","tolerance":0}gerber.compareReviewReview two revisions:{"a":"fab-rev-b.zip","b":"fab-rev-a.zip"}gerber.exportNative Gerbers, drill and job file into fab/:{"path":"blinky.kicad_pcb","out":"fab/"}gerber.exportkicad-cli, 4.5 format:{"path":"blinky.kicad_pcb","out":"fab-cli/","engine":"kicad-cli","precision":5}gerber.jobThe job file of a fab folder:{"path":"fab/"}gerber.jobWrite the native job file of a board:{"path":"blinky.kicad_pcb","out":"fab/blinky-job.gbrjob"}gerber.openSetOpen the sample fab set:{"path":"examples/sample-project/fab"}gerber.parseThe sample front copper:{"path":"examples/sample-project/fab/blinky-F_Cu.gbr"}gerber.setThe sample fab set:{"path":"examples/sample-project/fab"}gerber.viewPNG of a fab folder:{"path":"fab/","png":"fab.png"}gerber.viewBottom copper and mask as SVG:{"path":"fab.zip","svg":"bottom.svg","layers":["B.Cu","B.Mask"],"flipped":true}