@peter.prib/renderengine 0.13.0 → 0.15.0

package/bin/renderengine.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadModel, checkModel, reportModel, saveModel, formatFindings } from '../src/cli.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function getPackageVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'));
+        return pkg.version || '0.0.0';
+    } catch {
+        return '0.0.0';
+    }
+}
+
+function printUsage() {
+    console.log(`RenderEngine CLI v${getPackageVersion()}
+
+Usage:
+  renderengine <command> [options]
+
+Commands:
+  check <modelPath>       Validate a model and display issues
+    --json                Output findings as JSON
+    --severity <level>    Filter by severity: error, warning, info
+
+  report <modelPath>      Generate a standalone HTML report
+    --output, -o <file>   Output HTML path (default: <modelName>-report.html)
+    --title <title>       Report title
+
+  save <modelPath>        Convert or save a model
+    --output, -o <file>   Output file path (required)
+    --format <format>     Output format: archi (default), exchange, json
+
+General Options:
+  --help, -h              Show this help message
+  --version, -v           Show version number
+`);
+}
+
+function parseArgs(args) {
+    const parsed = { _: [], flags: {} };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--help' || arg === '-h') {
+            parsed.flags.help = true;
+        } else if (arg === '--version' || arg === '-v') {
+            parsed.flags.version = true;
+        } else if (arg === '--json') {
+            parsed.flags.json = true;
+        } else if (arg === '--output' || arg === '-o') {
+            parsed.flags.output = args[++i];
+        } else if (arg === '--format') {
+            parsed.flags.format = args[++i];
+        } else if (arg === '--title') {
+            parsed.flags.title = args[++i];
+        } else if (arg === '--severity') {
+            parsed.flags.severity = args[++i];
+        } else if (arg.startsWith('--')) {
+            const [k, v] = arg.slice(2).split('=');
+            parsed.flags[k] = v ?? true;
+        } else {
+            parsed._.push(arg);
+        }
+    }
+    return parsed;
+}
+
+export async function run(argv = process.argv.slice(2)) {
+    const { _, flags } = parseArgs(argv);
+
+    if (flags.version) {
+        console.log(`v${getPackageVersion()}`);
+        return 0;
+    }
+
+    if (flags.help || !_.length) {
+        printUsage();
+        return 0;
+    }
+
+    const command = _[0];
+    const modelPath = _[1];
+
+    if (!modelPath && command !== 'help') {
+        console.error(`Error: Model path required for '${command}'`);
+        printUsage();
+        return 1;
+    }
+
+    try {
+        const readInput = (file) => {
+            if (!fs.existsSync(file)) throw new Error(`File not found: ${file}`);
+            return fs.readFileSync(file);
+        };
+
+        if (command === 'check') {
+            const model = loadModel(readInput(modelPath));
+            const { findings, summary } = checkModel(model, { severity: flags.severity });
+
+            if (flags.json) {
+                console.log(JSON.stringify({ findings, summary }, null, 2));
+            } else {
+                console.log(formatFindings(findings, summary));
+            }
+            return summary.errors > 0 ? 1 : 0;
+        }
+
+        if (command === 'report') {
+            const model = loadModel(readInput(modelPath));
+            const title = flags.title || model.name || 'Model Report';
+            const html = reportModel(model, { title });
+            const defaultOut = `${path.basename(modelPath, path.extname(modelPath))}-report.html`;
+            const outPath = flags.output || defaultOut;
+
+            fs.writeFileSync(outPath, html, 'utf8');
+            console.log(`Report generated: ${outPath} (${html.length} bytes)`);
+            return 0;
+        }
+
+        if (command === 'save') {
+            if (!flags.output) {
+                console.error('Error: --output (-o) is required for the save command');
+                return 1;
+            }
+            const model = loadModel(readInput(modelPath));
+            const format = flags.format || 'archi';
+            const { data } = saveModel(model, { format });
+
+            if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
+                fs.writeFileSync(flags.output, Buffer.from(data));
+            } else {
+                fs.writeFileSync(flags.output, String(data), 'utf8');
+            }
+            console.log(`Saved model to: ${flags.output} (${format})`);
+            return 0;
+        }
+
+        console.error(`Unknown command: ${command}`);
+        printUsage();
+        return 1;
+    } catch (err) {
+        console.error(`Error: ${err.message}`);
+        return 1;
+    }
+}
+
+// Only execute when run directly from the command line
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(__filename)) {
+    run().then(code => {
+        if (code !== 0) process.exit(code);
+    });
+}