circuitscript 0.0.24 → 0.0.26

package/dist/cjs/export.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateKiCADNetList = void 0;
+exports.SExpObject = exports._id = exports.IdObject = exports.printTree = exports.generateKiCADNetList = void 0;
 const globals_js_1 = require("./globals.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 function generateKiCADNetList(netlist) {
     const componentsList = [];
     const nets = {};
+    const missingFootprints = [];
     netlist.forEach(entry => {
         const { instance, pins } = entry;
         if (instance.assignedRefDes !== null) {
@@ -25,7 +26,10 @@ function generateKiCADNetList(netlist) {
                     instance.parameters.get('footprint')]);
             }
             else {
-                console.log(instance.assignedRefDes, instance.instanceName, 'does not have footprint');
+                missingFootprints.push({
+                    refdes: instance.assignedRefDes,
+                    instanceName: instance.instanceName
+                });
             }
             componentsList.push(instanceDetails);
             for (const key in pins) {
@@ -66,18 +70,22 @@ function generateKiCADNetList(netlist) {
         ]);
         counter++;
     }
+    const dateString = new Date().toISOString().slice(0, 10);
     const tree = [
         Id("export"),
         [Id("version"), "E"],
         [Id("design"),
-            [Id("source"), "/somefile"],
-            [Id("date"), "2023-11-19"],
+            [Id("source"), "/unknown-file"],
+            [Id("date"), dateString],
             [Id("tool"), "circuitscript-to-kicad"]
         ],
         [Id('components'), ...componentsList],
         [Id('nets'), ...netItems]
     ];
-    return printTree(tree);
+    return {
+        tree,
+        missingFootprints
+    };
 }
 exports.generateKiCADNetList = generateKiCADNetList;
 function printTree(tree, level = 0) {
@@ -99,6 +107,7 @@ function printTree(tree, level = 0) {
     }
     return "(" + output.join(" ") + ")";
 }
+exports.printTree = printTree;
 function Id(name) {
     return new IdObject(name);
 }
@@ -107,3 +116,80 @@ class IdObject {
         this.keyName = keyName;
     }
 }
+exports.IdObject = IdObject;
+function _id(key) {
+    return new IdObject(key);
+}
+exports._id = _id;
+class SExpObject {
+    constructor(object) {
+        this.object = object;
+    }
+    getKey(object = null) {
+        object = object ?? this.object;
+        return object[0];
+    }
+    getValue(object = null) {
+        object = object ?? this.object;
+        return object.slice(1);
+    }
+    getJSON(object = null) {
+        object = object ?? this.object;
+        if (!Array.isArray(object)) {
+            return object;
+        }
+        const properties = {};
+        const keyName = object[0].keyName;
+        if (object.length === 2) {
+            properties[keyName] = this.getJSON(object[1]);
+        }
+        else {
+            const innerProps = {};
+            this.getValue(object).forEach(item => {
+                const tmpValue = this.getJSON(item);
+                if (typeof tmpValue === "object") {
+                    for (const key in tmpValue) {
+                        if (innerProps[key]) {
+                            if (!Array.isArray(innerProps[key])) {
+                                innerProps[key] = [innerProps[key]];
+                            }
+                            innerProps[key].push(tmpValue[key]);
+                        }
+                        else {
+                            innerProps[key] = tmpValue[key];
+                        }
+                    }
+                }
+                else {
+                    innerProps[item[0].keyName] = tmpValue;
+                }
+            });
+            properties[keyName] = innerProps;
+        }
+        return properties;
+    }
+    getWithId(id, object = null) {
+        object = object ?? this.object;
+        let result = null;
+        const key = object[0];
+        if (key.keyName === id) {
+            return object;
+        }
+        else {
+            this.getValue(object).some(item => {
+                if (Array.isArray(item)) {
+                    result = this.getWithId(id, item);
+                    if (result !== null) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        }
+        return result;
+    }
+    print() {
+        console.log(printTree(this.object));
+    }
+}
+exports.SExpObject = SExpObject;

package/dist/cjs/geometry.js

@@ -53,8 +53,12 @@ class Label extends core_1.default.Polygon {
         return new Label(id, useText, [x, y], polygon, style, box);
     }
     rotate(angle, origin) {
-        const polygonRotate = super.rotate(angle, origin);
-        return new Label(this.id, this.text, this.anchorPoint, polygonRotate, this.style, this.textMeasurementBounds);
+        const feature = super.rotate(angle, origin);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+    }
+    transform(matrix) {
+        const feature = super.transform(matrix);
+        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
     }
     getLabelPosition() {
         return this.anchorPoint;
@@ -104,6 +108,10 @@ class Geometry {
         const angleRads = angleDegrees * Math.PI / 180;
         return feature.rotate(angleRads, Geometry.point(center[0], center[1]));
     }
+    static flip(feature, flipX, flipY) {
+        const flipMatrix = (new core_1.default.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return feature.transform(flipMatrix);
+    }
     static groupRotate(features, angle, center) {
         const angleRads = angle * Math.PI / 180;
         const rotateAboutPoint = Geometry.point(center[0], center[1]);
@@ -111,6 +119,12 @@ class Geometry {
             return feature.rotate(angleRads, rotateAboutPoint);
         });
     }
+    static groupFlip(features, flipX, flipY) {
+        const flipMatrix = (new core_1.default.Matrix()).scale(flipX === 0 ? 1 : -1, flipY == 0 ? 1 : -1);
+        return features.map(feature => {
+            return feature.transform(flipMatrix);
+        });
+    }
     static groupBounds(features) {
         let minX = Number.POSITIVE_INFINITY;
         let minY = Number.POSITIVE_INFINITY;
@@ -171,9 +185,7 @@ class Geometry {
                 }
                 const startPoint = getArcPointRadians(x, y, radius, item.startAngle);
                 const endPoint = getArcPointRadians(x, y, radius, useEndAngle);
-                paths.push('M ' + startPoint[0] + ' ' + startPoint[1]
-                    + 'A ' + radius + ' ' + radius + ' 0 1 1 '
-                    + endPoint[0] + ' ' + endPoint[1] + extraEnd);
+                paths.push('M', startPoint[0], startPoint[1], 'A', radius, radius, 0, 1, 1, endPoint[0], endPoint[1], extraEnd);
             }
             else {
                 const coords = Geometry.getCoords(item);
@@ -183,19 +195,27 @@ class Geometry {
                 for (let i = 0; i < coords.length; i++) {
                     const [x, y] = coords[i];
                     const command = (i === 0) ? 'M' : 'L';
-                    path.push(`${command} ${x} ${y}`);
+                    path.push(`${command}`, x, y);
                 }
                 if (isClosedPolygon) {
                     path.push('Z');
                 }
-                paths.push(path.join(' '));
+                paths.push(...path);
             }
         });
         return {
-            path: paths.join(" "),
+            path: this.roundPathValues(paths),
             isClosedPolygon,
         };
     }
+    static roundPathValues(pathItems) {
+        return pathItems.map(item => {
+            if (typeof item === 'number') {
+                return (+item.toFixed(7)).toString();
+            }
+            return item;
+        }).join(" ");
+    }
     static angle(dx, dy) {
         const line = new core_1.default.Segment(new core_1.default.Point(0, 0), new core_1.default.Point(dx, dy));
         return line.slope * 180 / Math.PI;

package/dist/cjs/globals.js

@@ -13,8 +13,6 @@ var GlobalNames;
 exports.NoNetText = 'NO_NET';
 var ParamKeys;
 (function (ParamKeys) {
-    ParamKeys["__is_net"] = "__is_net";
-    ParamKeys["__is_label"] = "__is_label";
     ParamKeys["priority"] = "priority";
     ParamKeys["net_name"] = "net_name";
 })(ParamKeys || (exports.ParamKeys = ParamKeys = {}));
@@ -50,6 +48,7 @@ var ReferenceTypes;
     ReferenceTypes["value"] = "value";
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
+    ReferenceTypes["pinType"] = "pinType";
 })(ReferenceTypes || (exports.ReferenceTypes = ReferenceTypes = {}));
 var BlockTypes;
 (function (BlockTypes) {

package/dist/cjs/helpers.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrentPath = exports.detectJSModuleType = exports.renderScript = exports.JSModuleType = void 0;
+exports.getPackageVersion = exports.getDefaultLibsPath = exports.getFontsPath = exports.getCurrentPath = exports.detectJSModuleType = exports.renderScript = exports.validateScript = exports.ParseErrorStrategy = exports.getSemanticTokens = exports.getScriptText = exports.prepareFile = exports.JSModuleType = void 0;
 const fs_1 = require("fs");
 const export_js_1 = require("./export.js");
 const layout_js_1 = require("./layout.js");
@@ -10,17 +13,164 @@ const render_js_1 = require("./render.js");
 const utils_js_1 = require("./utils.js");
 const visitor_js_1 = require("./visitor.js");
 const this_file_1 = require("this-file");
+const SymbolValidatorVisitor_js_1 = require("./SymbolValidatorVisitor.js");
+const antlr4ng_1 = require("antlr4ng");
+const lexer_js_1 = require("./lexer.js");
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const SemanticTokenVisitor_js_1 = require("./SemanticTokenVisitor.js");
+const path_1 = __importDefault(require("path"));
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
     JSModuleType["ESM"] = "mjs";
 })(JSModuleType || (exports.JSModuleType = JSModuleType = {}));
+function prepareFile(textData) {
+    const chars = antlr4ng_1.CharStream.fromString(textData);
+    const lexer = new lexer_js_1.MainLexer(chars);
+    const lexerTimer = new utils_js_1.SimpleStopwatch();
+    const tokens = new antlr4ng_1.CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parser = new CircuitScriptParser_js_1.CircuitScriptParser(tokens);
+    return {
+        parser,
+        lexer,
+        lexerTimeTaken,
+        tokens
+    };
+}
+exports.prepareFile = prepareFile;
+function getScriptText(filePath) {
+    try {
+        return (0, fs_1.readFileSync)(filePath, { encoding: 'utf-8' });
+    }
+    catch (err) {
+        return null;
+    }
+}
+exports.getScriptText = getScriptText;
+function getSemanticTokens(scriptData, options) {
+    const { parser, lexer, tokens } = prepareFile(scriptData);
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SemanticTokenVisitor_js_1.SemanticTokensVisitor(true, null, currentDirectory, defaultLibsPath, lexer, scriptData);
+    parser.removeErrorListeners();
+    visitor.onImportFile = (visitor, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('Error while parsing: ', err);
+                hasParseError = true;
+                hasError = true;
+            }
+        }
+        else {
+            console.log('File does not exist');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const semanticTokens = visitor.getTokens();
+    const parsedTokens = (0, SemanticTokenVisitor_js_1.prepareTokens)(tokens.getTokens(), lexer, scriptData);
+    const finalParsedTokens = [];
+    parsedTokens.forEach(token => {
+        const location = `${token.line}_${token.column}`;
+        if (semanticTokens.has(location)) {
+            finalParsedTokens.push(semanticTokens.get(location));
+        }
+        else {
+            finalParsedTokens.push(token);
+        }
+    });
+    return {
+        visitor,
+        parsedTokens: finalParsedTokens
+    };
+}
+exports.getSemanticTokens = getSemanticTokens;
+class TokenErrorListener extends antlr4ng_1.BaseErrorListener {
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        console.log(msg);
+    }
+}
+class ParseErrorStrategy extends antlr4ng_1.DefaultErrorStrategy {
+    reportUnwantedToken(recognizer) {
+        if (this.inErrorRecoveryMode(recognizer)) {
+            return;
+        }
+        this.beginErrorCondition(recognizer);
+        const t = recognizer.getCurrentToken();
+        const tokenName = this.getTokenErrorDisplay(t);
+        const msg = "extraneous input " + tokenName;
+        recognizer.notifyErrorListeners(msg, t, null);
+        this.endErrorCondition(recognizer);
+    }
+}
+exports.ParseErrorStrategy = ParseErrorStrategy;
+function validateScript(scriptData, options) {
+    const { parser } = prepareFile(scriptData);
+    parser.removeErrorListeners();
+    parser.errorHandler = new ParseErrorStrategy();
+    parser.addErrorListener(new TokenErrorListener());
+    const tree = parser.script();
+    const { currentDirectory = null, defaultLibsPath, } = options;
+    const visitor = new SymbolValidatorVisitor_js_1.SymbolValidatorVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, textData) => {
+        let hasError = false;
+        let hasParseError = false;
+        if (textData !== null) {
+            const { parser } = prepareFile(textData);
+            const tree = parser.script();
+            try {
+                visitor.visit(tree);
+            }
+            catch (err) {
+                console.log('got an error while parsing tree: ', err);
+                hasParseError = true;
+                hasError = true;
+            }
+        }
+        else {
+            console.log('file does not exist!');
+            hasError = true;
+        }
+        return {
+            hasError, hasParseError
+        };
+    };
+    visitor.visit(tree);
+    const symbolTable = visitor.getSymbols();
+    symbolTable.clearUndefined();
+    const visitorResolver = new SymbolValidatorVisitor_js_1.SymbolValidatorResolveVisitor(true, null, currentDirectory, defaultLibsPath);
+    visitorResolver.setSymbols(visitor.getSymbols());
+    visitorResolver.onImportFile = visitor.onImportFile;
+    visitorResolver.visit(tree);
+    return visitorResolver;
+}
+exports.validateScript = validateScript;
 function renderScript(scriptData, outputPath, options) {
     const { currentDirectory = null, defaultLibsPath, dumpNets = false, dumpData = false, kicadNetlistPath = null, showStats = false } = options;
-    const visitor = new visitor_js_1.MainVisitor(true);
-    visitor.onImportFile = visitor.createImportFileHandler(currentDirectory, defaultLibsPath);
-    visitor.print('reading file');
-    visitor.print('done reading file');
+    const onErrorHandler = (line, column, message, error) => {
+        if (error instanceof visitor_js_1.VisitorExecutionException) {
+            console.log('Error', line, column, message, error.errorMessage);
+        }
+    };
+    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, currentDirectory, defaultLibsPath);
+    visitor.onImportFile = (visitor, fileData) => {
+        const { hasError, hasParseError } = (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+        return { hasError, hasParseError };
+    };
+    visitor.log('reading file');
+    visitor.log('done reading file');
     const { tree, parser, hasParseError, hasError, parserTimeTaken, lexerTimeTaken } = (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
@@ -38,8 +188,11 @@ function renderScript(scriptData, outputPath, options) {
         console.log('Error during annotation: ', err);
     }
     if (kicadNetlistPath) {
-        const kicadNetList = (0, export_js_1.generateKiCADNetList)(visitor.getNetList());
-        (0, fs_1.writeFileSync)(kicadNetlistPath, kicadNetList);
+        const { tree: kicadNetList, missingFootprints } = (0, export_js_1.generateKiCADNetList)(visitor.getNetList());
+        missingFootprints.forEach(entry => {
+            console.log(`${entry.refdes} (${entry.instanceName}) does not have footprint`);
+        });
+        (0, fs_1.writeFileSync)(kicadNetlistPath, (0, export_js_1.printTree)(kicadNetList));
         console.log('Generated KiCad netlist file');
     }
     const { sequence, nets } = visitor.getGraph();
@@ -97,3 +250,23 @@ function getCurrentPath() {
     return { filePath: filename };
 }
 exports.getCurrentPath = getCurrentPath;
+function getToolsPath() {
+    const { filePath } = getCurrentPath();
+    return path_1.default.normalize(path_1.default.dirname(filePath) + '/../../');
+}
+function getFontsPath() {
+    const toolsPath = getToolsPath();
+    return path_1.default.normalize(toolsPath + "fonts");
+}
+exports.getFontsPath = getFontsPath;
+function getDefaultLibsPath() {
+    const toolsPath = getToolsPath();
+    return path_1.default.normalize(toolsPath + "libs");
+}
+exports.getDefaultLibsPath = getDefaultLibsPath;
+function getPackageVersion() {
+    const packageJson = JSON.parse((0, fs_1.readFileSync)(getToolsPath() + 'package.json').toString());
+    const { version } = packageJson;
+    return version;
+}
+exports.getPackageVersion = getPackageVersion;

package/dist/cjs/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./parser.js"), exports);
 __exportStar(require("./render.js"), exports);
 __exportStar(require("./utils.js"), exports);
 __exportStar(require("./visitor.js"), exports);
+__exportStar(require("./sizing.js"), exports);
+__exportStar(require("./objects/types.js"), exports);

package/dist/cjs/layout.js

@@ -395,6 +395,14 @@ class LayoutEngine {
                         didSetAngle = true;
                         tmpSymbol.angle = component.parameters.get('angle');
                     }
+                    if (component.parameters.has('flipX')) {
+                        tmpSymbol.flipX =
+                            component.parameters.get('flipX');
+                    }
+                    if (component.parameters.has('flipY')) {
+                        tmpSymbol.flipY =
+                            component.parameters.get('flipY');
+                    }
                     if (tmpSymbol instanceof draw_symbols_js_1.SymbolCustom && widthProp) {
                         tmpSymbol.bodyWidth = widthProp;
                     }

package/dist/cjs/lexer.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MainLexer = void 0;
-const antlr4_1 = require("antlr4");
-const CircuitScriptParser_js_1 = __importDefault(require("./antlr/CircuitScriptParser.js"));
-const CircuitScriptLexer_js_1 = __importDefault(require("./antlr/CircuitScriptLexer.js"));
-class MainLexer extends CircuitScriptLexer_js_1.default {
+const antlr4ng_1 = require("antlr4ng");
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const CircuitScriptLexer_js_1 = require("./antlr/CircuitScriptLexer.js");
+class MainLexer extends CircuitScriptLexer_js_1.CircuitScriptLexer {
     constructor(input) {
         super(input);
         this.tokens = [];
@@ -25,38 +22,38 @@ class MainLexer extends CircuitScriptLexer_js_1.default {
         this.tokens.push(token);
     }
     nextToken() {
-        if (this._input.LA(1) === CircuitScriptParser_js_1.default.EOF && this.indents.length) {
+        if (this.inputStream.LA(1) === CircuitScriptParser_js_1.CircuitScriptParser.EOF && this.indents.length) {
             this.tokens = this.tokens.filter(function (val) {
-                return val.type !== CircuitScriptParser_js_1.default.EOF;
+                return val.type !== CircuitScriptParser_js_1.CircuitScriptParser.EOF;
             });
-            this.emitToken(this.commonToken(CircuitScriptParser_js_1.default.NEWLINE, "\n"));
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, "\n"));
             while (this.indents.length) {
                 this.emitToken(this.createDedent());
                 this.indents.pop();
             }
-            this.emitToken(this.commonToken(CircuitScriptParser_js_1.default.EOF, "<EOF>"));
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.EOF, "<EOF>"));
         }
         const next = super.nextToken();
         return this.tokens.length ? this.tokens.shift() : next;
     }
     createDedent() {
-        return this.commonToken(CircuitScriptParser_js_1.default.DEDENT, "");
+        return this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.DEDENT, "");
     }
     getCharIndex() {
-        return this._input.index;
+        return this.inputStream.index;
     }
     commonToken(type, text) {
         const stop = this.getCharIndex() - 1;
         const start = text.length ? stop - text.length + 1 : stop;
-        const token = new antlr4_1.CommonToken([this, this._input], type, 0, start, stop);
-        let tokenTypeString;
-        if (type === CircuitScriptParser_js_1.default.INDENT) {
+        const token = antlr4ng_1.CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
+        let tokenTypeString = null;
+        if (type === CircuitScriptParser_js_1.CircuitScriptParser.INDENT) {
             tokenTypeString = "indent";
         }
-        else if (type === CircuitScriptParser_js_1.default.DEDENT) {
+        else if (type === CircuitScriptParser_js_1.CircuitScriptParser.DEDENT) {
             tokenTypeString = "dedent";
         }
-        if (tokenTypeString) {
+        if (tokenTypeString !== null) {
             token.text = tokenTypeString;
         }
         return token;
@@ -85,14 +82,14 @@ class MainLexer extends CircuitScriptLexer_js_1.default {
     onNewLine() {
         const newLine = this.text.replace(/[^\r\n]+/g, '');
         const spaces = this.text.replace(/[\r\n]+/g, '');
-        const next = this._input.LA(1);
-        const nextnext = this._input.LA(2);
+        const next = this.inputStream.LA(1);
+        const nextnext = this.inputStream.LA(2);
         if (this.opened > 0 || (nextnext != -1 &&
             (next === 13 || next === 10 || next === 35))) {
             this.skip();
         }
         else {
-            this.emitToken(this.commonToken(CircuitScriptParser_js_1.default.NEWLINE, newLine));
+            this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.NEWLINE, newLine));
             const indent = this.getIndentationCount(spaces);
             const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
             if (indent === previous) {
@@ -100,7 +97,7 @@ class MainLexer extends CircuitScriptLexer_js_1.default {
             }
             else if (indent > previous) {
                 this.indents.push(indent);
-                this.emitToken(this.commonToken(CircuitScriptParser_js_1.default.INDENT, spaces));
+                this.emitToken(this.commonToken(CircuitScriptParser_js_1.CircuitScriptParser.INDENT, spaces));
             }
             else {
                 while (this.indents.length && this.indents[this.indents.length - 1] > indent) {

package/dist/cjs/main.js

@@ -11,20 +11,15 @@ const fs_1 = require("fs");
 const sizing_js_1 = require("./sizing.js");
 const helpers_js_1 = require("./helpers.js");
 async function main() {
-    const { filePath } = (0, helpers_js_1.getCurrentPath)();
-    const toolSrcPath = filePath;
-    const toolDirectory = path_1.default.dirname(toolSrcPath) + '/../../';
-    const fontsPath = toolDirectory + '/fonts';
-    const defaultLibsPath = toolDirectory + '/libs';
-    const packageJson = JSON.parse((0, fs_1.readFileSync)(toolDirectory + 'package.json').toString());
-    ;
-    const { version } = packageJson;
+    const fontsPath = (0, helpers_js_1.getFontsPath)();
+    const defaultLibsPath = (0, helpers_js_1.getDefaultLibsPath)();
+    const version = (0, helpers_js_1.getPackageVersion)();
     commander_1.program
         .description('generate graphical output from circuitscript files')
         .version(version)
+        .argument('[input path]', 'Input path')
+        .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
-        .option('-f, --input-file <path>', 'Input file')
-        .option('-o, --output <path>', 'Output path')
         .option('-c, --current-directory <path>', 'Set current directory')
         .option('-k, --kicad-netlist <filename>', 'Create KiCad netlist')
         .option('-w, --watch', 'Watch for file changes')
@@ -39,8 +34,8 @@ async function main() {
     }
     commander_1.program.parse();
     const options = commander_1.program.opts();
+    const args = commander_1.program.args;
     const watchFileChanges = options.watch;
-    const outputPath = options.output ?? null;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
     const kicadNetlist = options.kicadNetlist;
@@ -49,19 +44,27 @@ async function main() {
         console.log('watching for file changes...');
     }
     await (0, sizing_js_1.prepareSVGEnvironment)(fontsPath);
-    let inputFilePath = null;
-    let scriptData;
-    if (options.input) {
-        scriptData = options.input;
+    let inputFilePath = "";
+    if (args.length > 2) {
+        console.log("Error: Extra arguments passed");
+        return;
     }
-    else {
-        inputFilePath = options.inputFile;
+    let scriptData;
+    if (args.length > 0 && args[0]) {
+        inputFilePath = args[0];
         scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
         if (currentDirectory === null) {
             currentDirectory = path_1.default.dirname(inputFilePath);
         }
     }
-    const renderOptions = {
+    else if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        console.log("Error: No input provided");
+        return;
+    }
+    const scriptOptions = {
         currentDirectory,
         defaultLibsPath,
         dumpNets,
@@ -69,7 +72,11 @@ async function main() {
         kicadNetlistPath: kicadNetlist,
         showStats: options.stats,
     };
-    const output = (0, helpers_js_1.renderScript)(scriptData, outputPath, renderOptions);
+    let outputPath = null;
+    if (args.length > 0 && args[1]) {
+        outputPath = args[1];
+    }
+    const output = (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output) {
         console.log(output);
     }
@@ -77,7 +84,7 @@ async function main() {
         (0, fs_1.watch)(inputFilePath, event => {
             if (event === 'change') {
                 const scriptData = (0, fs_1.readFileSync)(inputFilePath, { encoding: 'utf-8' });
-                (0, helpers_js_1.renderScript)(scriptData, outputPath, renderOptions);
+                (0, helpers_js_1.renderScript)(scriptData, outputPath, scriptOptions);
                 console.log('done');
             }
         });