kisch 1.0.0 → 1.0.2

package/src/kisch-cli.js

@@ -1,33 +1,139 @@
 #!/usr/bin/env node
 
 import {program} from "commander";
-import Schematic from "./Schematic.js";
+import Schematic, {loadSchematic, createSchematic} from "./Schematic.js";
 import path from "node:path";
+import pkg from "../package.json" with { type: "json" };
+import {DeclaredError} from "./js-util.js";
+import fs, {promises as fsp} from "fs";
+
+/*todo...
+
+defines
+wires*/
+
+let HELP_TEXT=`
+Examples:
+
+  Transform existng schema by applying script:
+    $ kisch design.sch --script x.js
+
+  Generate script for later use:
+    $ kisch --input fresh.sch --emit x.js
+
+  Load from one file, apply script, and save in another file:
+    $ kisch --input template.sch --script x.js --output out.sch
+
+  Dry-run, just load schematic and apply script, but don't save:
+    $ kisch --input design.sch --script x.js
+`;
 
 program
-	.description("Create or update KiCad schematic based on programmatic description.")
-	.option("--symbol-library-path <path>","Where to find KiCad symbols.")
-	.requiredOption("--script <script>","JavaScript file to transform the schematic.")
-	.argument("<schematic>","KiCad Schematic file.")
+    .name("kisch")
+    .description(
+        "Schematic transformation tool for KiCad.\n\n" +
+        "Reads a schematic, applies a JavaScript transformation script,\n" +
+        "and writes the resulting schematic."
+    )
+    .version(pkg.version, "--version", "Show version")
+    .argument("[inout.kicad_sch]", "Schematic to be used as input and output.")
+
+    // Core options
+    .option("-i, --input <input.kicad_sch>", "Input schematic.")
+    .option("-o, --output <output.kicad_sch>","Output schematic.")
+    .option("-L, --symbol-dir <path>","Where to find KiCad symbols.")
+    .option("-s, --script <script.js>", "Input script to apply to schematic.")
+    .option("-e, --emit <script.js>", "Emit script based on schematic.")
+    .option("-q, --quiet", "No output, except for errors.")
+    //.option("-v, --verbose", "Print detailed execution info")
+    .option(
+        "-D, --define <key=value>", 
+        "Define variable for the script.",
+        (value, previous = []) => {
+            previous.push(value);
+            return previous;
+        }
+    )
+
+    // Custom help formatting
+    .addHelpText("after",HELP_TEXT);
 
 await program.parseAsync();
-let options={
-	...program.opts(),
-	schematic: program.args[0],
-}
 
-//console.log(options);
+try {
+    let options=program.opts();
+    if (program.args[0]) {
+        if (options.input || options.output)
+            throw new DeclaredError("Can't use both positional arg together with -i or -o.");
+
+        options.input=program.args[0];
+        options.output=program.args[0];
+    }
 
-let schematic=new Schematic(options.schematic,{
-	symbolLibraryPath: options.symbolLibraryPath
-});
+    if (!options.input && !options.output)
+        program.help();
 
-await schematic.load();
+    if (!options.define)
+        options.define=[];
+
+    if (!options.symbolDir)
+        options.symbolDir=
+            process.env.KISCH_SYMBOL_DIR ||
+            process.env.KICAD9_SYMBOL_DIR ||
+            process.env.KICAD_SYMBOL_DIR;
+
+    let cons=global.console;
+    if (options.quiet)
+        cons={info: ()=>{}, log: ()=>{}};
+
+    if (!options.symbolDir)
+        throw new DeclaredError("Symbol path missing, pass -L, or set KISCH_SYMBOL_DIR, KICAD9_SYMBOL_DIR or KICAD_SYMBOL_DIR");
+
+    let schematic;
+    if (options.input) {
+        cons.info("Loading: "+options.input);
+        schematic=await loadSchematic(options.input,{
+            symbolLibraryPath: options.symbolDir
+        });
+    }
+
+    else {
+        cons.info("Starting with empty schematic");
+        schematic=await createSchematic({
+            symbolLibraryPath: options.symbolDir
+        });
+    }
+
+    if (options.script) {
+        cons.info("Applying script: "+options.script);
+        global.schematic=schematic;
+        let defines=Object.fromEntries(options.define.map(e=>
+            ([e.slice(0,e.indexOf("=")),e.slice(e.indexOf("=")+1)])
+        ));
+
+        let mod=await import(path.resolve(options.script));
+        if (typeof mod.default=="function")
+            await mod.default(schematic,defines);
+
+        schematic.removeUndeclared();
+    }
+
+    if (options.emit) {
+        cons.info("Emitting script: "+options.emit);
+        await fsp.writeFile(options.emit,schematic.getSource());
+    }
+
+    if (options.output) {
+        cons.info("Saving: "+options.output);
+        await schematic.save(options.output);
+    }
+}
 
-global.schematic=schematic;
-let mod=await import(path.resolve(options.script));
-if (typeof mod.default=="function")
-	await mod.default(schematic);
+catch (e) {
+    if (e.declared) {
+        console.log("Error: "+e.message);
+        process.exit(1);
+    }
 
-schematic.removeUndeclared();
-await schematic.save();
+    throw e;
+}

package/src/node-util.js

@@ -0,0 +1,17 @@
+import {spawn} from 'node:child_process';
+
+export function runCommand(cmd, args = []) {
+    return new Promise((resolve, reject) => {
+        const child=spawn(cmd,args,{stdio: 'inherit'});
+
+        child.on('close', (code)=>{
+            if (code===0) {
+                resolve();
+            } else {
+                reject(new Error(`Command exited with code ${code}`));
+            }
+        });
+
+        child.on('error', reject);
+    });
+}

package/lab/kish-test.js

@@ -1,35 +0,0 @@
-import {openSchematic} from "../src/Schematic.js";
-import fs, {promises as fsp} from "fs";
-
-await fsp.rm("lab/kitest",{force: true, recursive: true});
-await fsp.cp("lab/kitest-org","lab/kitest",{recursive: true});
-
-let schematic=await openSchematic("lab/kitest/kitest.kicad_sch",{
-	symbolLibraryPath: "/home/micke/Repo.ext/kicad-symbols"
-});
-
-await schematic.use(
-	"Connector_Generic:Conn_01x08"
-);
-
-schematic.sym("J1").pin(1).connect(schematic.sym("J3").pin(2));
-schematic.sym("J3").pin(1).connect("GND");
-schematic.sym("J1").pin(1).connect(schematic.sym("J3").pin(1));
-
-let r=schematic.sym("J3").getBoundingRect();
-
-/*for (let i=4; i<20; i++) {
-	schematic.declare("J"+i,{
-		symbol: "Connector_Generic:Conn_01x08",
-	});
-}*/
-
-schematic.declare("J4",{
-	symbol: "Connector_Generic:Conn_01x04",
-});
-
-schematic.sym("J4").pin(1).connect("GND");
-schematic.sym("J4").pin(4).connect(schematic.sym("J3").pin(3));
-schematic.sym("J1").pin(1).connect(schematic.sym("J4").pin(1));
-
-await schematic.save();

package/lab/kitest-org/kitest.kicad_pcb

@@ -1,2 +0,0 @@
-(kicad_pcb (version 20241229) (generator "pcbnew") (generator_version "9.0")
-)

package/lab/kitest-org/kitest.kicad_prl

@@ -1,98 +0,0 @@
-{
-  "board": {
-    "active_layer": 0,
-    "active_layer_preset": "",
-    "auto_track_width": true,
-    "hidden_netclasses": [],
-    "hidden_nets": [],
-    "high_contrast_mode": 0,
-    "net_color_mode": 1,
-    "opacity": {
-      "images": 0.6,
-      "pads": 1.0,
-      "shapes": 1.0,
-      "tracks": 1.0,
-      "vias": 1.0,
-      "zones": 0.6
-    },
-    "selection_filter": {
-      "dimensions": true,
-      "footprints": true,
-      "graphics": true,
-      "keepouts": true,
-      "lockedItems": false,
-      "otherItems": true,
-      "pads": true,
-      "text": true,
-      "tracks": true,
-      "vias": true,
-      "zones": true
-    },
-    "visible_items": [
-      "vias",
-      "footprint_text",
-      "footprint_anchors",
-      "ratsnest",
-      "grid",
-      "footprints_front",
-      "footprints_back",
-      "footprint_values",
-      "footprint_references",
-      "tracks",
-      "drc_errors",
-      "drawing_sheet",
-      "bitmaps",
-      "pads",
-      "zones",
-      "drc_warnings",
-      "drc_exclusions",
-      "locked_item_shadows",
-      "conflict_shadows",
-      "shapes"
-    ],
-    "visible_layers": "ffffffff_ffffffff_ffffffff_ffffffff",
-    "zone_display_mode": 0
-  },
-  "git": {
-    "repo_type": "",
-    "repo_username": "",
-    "ssh_key": ""
-  },
-  "meta": {
-    "filename": "kitest.kicad_prl",
-    "version": 5
-  },
-  "net_inspector_panel": {
-    "col_hidden": [],
-    "col_order": [],
-    "col_widths": [],
-    "custom_group_rules": [],
-    "expanded_rows": [],
-    "filter_by_net_name": true,
-    "filter_by_netclass": true,
-    "filter_text": "",
-    "group_by_constraint": false,
-    "group_by_netclass": false,
-    "show_unconnected_nets": false,
-    "show_zero_pad_nets": false,
-    "sort_ascending": true,
-    "sorting_column": -1
-  },
-  "open_jobsets": [],
-  "project": {
-    "files": []
-  },
-  "schematic": {
-    "selection_filter": {
-      "graphics": true,
-      "images": true,
-      "labels": true,
-      "lockedItems": false,
-      "otherItems": true,
-      "pins": true,
-      "symbols": true,
-      "text": true,
-      "wires": true
-    }
-  }
-}