boom-format 0.9.0

package/dist/cli.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+import {
+  decode,
+  encode,
+  parseText,
+  stringify
+} from "./chunk-5PQH6SJJ.js";
+
+// src/cli.ts
+import * as fs from "fs";
+import * as path from "path";
+var VERSION = "1.0.0";
+var BOOM_MAGIC = [66, 79, 79, 77];
+function printHelp() {
+  console.log(`
+BOOM CLI v${VERSION} - Binary Object Optimised Markup
+
+Usage:
+  boom encode <input.json> [output]        Encode JSON to BOOM format
+  boom decode <input.boom> [output.json]   Decode BOOM to JSON
+  boom info <input.boom>                   Show info about a BOOM file
+  boom <input.json>                        Shorthand for encode
+
+Output Formats:
+  --binary, -b   Output BOOM binary format (default)
+  --text, -t     Output BOOM text format (.boom.txt)
+  --json, -j     Output JSON format (for decode)
+
+Options:
+  --help, -h     Show this help message
+  --version, -v  Show version
+  --pretty, -p   Pretty-print output (JSON and text)
+  --dict, -d     Use shared dictionary (default: true)
+  --no-dict      Disable shared dictionary
+
+Examples:
+  boom encode data.json                    # Output: data.boom (binary)
+  boom encode data.json --text             # Output: data.boom.txt (text)
+  boom encode data.json output.boom        # Custom output file
+  boom decode data.boom                    # Output: data.json
+  boom decode data.boom --pretty           # Pretty-printed JSON
+  boom decode data.boom.txt                # Decode BOOM text
+  boom info data.boom                      # Show file info
+  cat data.json | boom encode - > out.boom # Stdin/stdout
+  cat data.boom | boom decode -            # Decode from stdin
+
+File Extensions:
+  .boom          BOOM binary format
+  .boom.txt      BOOM text format (human-readable)
+  .json          JSON format
+`);
+}
+function printVersion() {
+  console.log(`boom v${VERSION}`);
+}
+function parseArgs(args) {
+  const options = {
+    command: "help",
+    input: null,
+    output: null,
+    pretty: false,
+    useDict: true,
+    format: "binary"
+  };
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      options.command = "help";
+      return options;
+    }
+    if (arg === "--version" || arg === "-v") {
+      options.command = "version";
+      return options;
+    }
+    if (arg === "--pretty" || arg === "-p") {
+      options.pretty = true;
+      continue;
+    }
+    if (arg === "--dict" || arg === "-d") {
+      options.useDict = true;
+      continue;
+    }
+    if (arg === "--no-dict") {
+      options.useDict = false;
+      continue;
+    }
+    if (arg === "--binary" || arg === "-b") {
+      options.format = "binary";
+      continue;
+    }
+    if (arg === "--text" || arg === "-t") {
+      options.format = "text";
+      continue;
+    }
+    if (arg === "--json" || arg === "-j") {
+      options.format = "json";
+      continue;
+    }
+    if (arg === "-") {
+      positional.push(arg);
+    } else if (arg.startsWith("-")) {
+      console.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length === 0) {
+    options.command = "help";
+    return options;
+  }
+  const cmd = positional[0];
+  if (!cmd) {
+    options.command = "help";
+    return options;
+  }
+  const cmdLower = cmd.toLowerCase();
+  if (cmdLower === "encode") {
+    options.command = "encode";
+    options.input = positional[1] ?? null;
+    options.output = positional[2] ?? null;
+  } else if (cmdLower === "decode") {
+    options.command = "decode";
+    options.input = positional[1] ?? null;
+    options.output = positional[2] ?? null;
+  } else if (cmdLower === "info") {
+    options.command = "info";
+    options.input = positional[1] ?? null;
+  } else if (cmdLower === "help") {
+    options.command = "help";
+  } else if (cmdLower === "version") {
+    options.command = "version";
+  } else {
+    const inputFile = positional[0];
+    if (inputFile) {
+      options.input = inputFile;
+      options.output = positional[1] ?? null;
+      if (inputFile.endsWith(".boom") || inputFile.endsWith(".boom.txt")) {
+        options.command = "decode";
+      } else {
+        options.command = "encode";
+      }
+    }
+  }
+  return options;
+}
+function readInput(inputPath) {
+  if (inputPath === "-") {
+    return fs.readFileSync(0);
+  }
+  return fs.readFileSync(inputPath);
+}
+function getOutputPath(inputPath, command, format) {
+  if (inputPath === "-") {
+    return "-";
+  }
+  let base;
+  const dir = path.dirname(inputPath);
+  if (inputPath.endsWith(".boom.txt")) {
+    base = path.basename(inputPath, ".boom.txt");
+  } else {
+    const ext = path.extname(inputPath);
+    base = path.basename(inputPath, ext);
+  }
+  if (command === "encode") {
+    if (format === "text") {
+      return path.join(dir, base + ".boom.txt");
+    }
+    return path.join(dir, base + ".boom");
+  } else {
+    return path.join(dir, base + ".json");
+  }
+}
+function writeOutput(outputPath, data) {
+  if (outputPath === "-") {
+    if (typeof data === "string") {
+      process.stdout.write(data);
+    } else {
+      process.stdout.write(data);
+    }
+  } else {
+    fs.writeFileSync(outputPath, data);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return bytes + " B";
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(2) + " KB";
+  return (bytes / (1024 * 1024)).toFixed(2) + " MB";
+}
+async function runEncode(options) {
+  if (!options.input) {
+    console.error("Error: No input file specified");
+    process.exit(1);
+  }
+  const inputData = readInput(options.input);
+  const jsonData = JSON.parse(inputData.toString("utf-8"));
+  const outputPath = options.output || getOutputPath(options.input, "encode", options.format);
+  if (options.format === "text") {
+    const textData = stringify(jsonData, { compact: !options.pretty });
+    writeOutput(outputPath, textData + "\n");
+    if (outputPath !== "-") {
+      const savings = ((1 - textData.length / inputData.length) * 100).toFixed(1);
+      console.log(`Encoded: ${options.input} -> ${outputPath}`);
+      console.log(`  JSON:      ${formatBytes(inputData.length)}`);
+      console.log(`  BOOM text: ${formatBytes(textData.length)} (${savings}% smaller)`);
+    }
+  } else {
+    const boomData = encode(jsonData, { enableInterning: options.useDict });
+    writeOutput(outputPath, Buffer.from(boomData));
+    if (outputPath !== "-") {
+      const savings = ((1 - boomData.length / inputData.length) * 100).toFixed(1);
+      console.log(`Encoded: ${options.input} -> ${outputPath}`);
+      console.log(`  JSON:        ${formatBytes(inputData.length)}`);
+      console.log(`  BOOM binary: ${formatBytes(boomData.length)} (${savings}% smaller)`);
+    }
+  }
+}
+async function runDecode(options) {
+  if (!options.input) {
+    console.error("Error: No input file specified");
+    process.exit(1);
+  }
+  const inputData = readInput(options.input);
+  const isTextFormat = options.input.endsWith(".boom.txt") || options.input.endsWith(".txt") || !isBinaryFormat(inputData);
+  let jsonData;
+  let inputFormat;
+  if (isTextFormat) {
+    const textContent = inputData.toString("utf-8");
+    jsonData = parseText(textContent);
+    inputFormat = "BOOM text";
+  } else {
+    const boomArray = new Uint8Array(inputData);
+    if (boomArray.length < 6 || boomArray[0] !== BOOM_MAGIC[0] || boomArray[1] !== BOOM_MAGIC[1] || boomArray[2] !== BOOM_MAGIC[2] || boomArray[3] !== BOOM_MAGIC[3]) {
+      console.error("Error: Not a valid BOOM file (invalid magic header)");
+      process.exit(1);
+    }
+    jsonData = decode(boomArray);
+    inputFormat = "BOOM binary";
+  }
+  const jsonString = options.pretty ? JSON.stringify(jsonData, null, 2) : JSON.stringify(jsonData);
+  const outputPath = options.output || getOutputPath(options.input, "decode", options.format);
+  writeOutput(outputPath, jsonString + "\n");
+  if (outputPath !== "-") {
+    console.log(`Decoded: ${options.input} -> ${outputPath}`);
+    console.log(`  ${inputFormat}: ${formatBytes(inputData.length)}`);
+    console.log(`  JSON:        ${formatBytes(jsonString.length)}`);
+  }
+}
+function isBinaryFormat(data) {
+  return data.length >= 4 && data[0] === BOOM_MAGIC[0] && data[1] === BOOM_MAGIC[1] && data[2] === BOOM_MAGIC[2] && data[3] === BOOM_MAGIC[3];
+}
+async function runInfo(options) {
+  if (!options.input) {
+    console.error("Error: No input file specified");
+    process.exit(1);
+  }
+  const inputData = readInput(options.input);
+  const boomArray = new Uint8Array(inputData);
+  if (boomArray.length < 6 || boomArray[0] !== BOOM_MAGIC[0] || boomArray[1] !== BOOM_MAGIC[1] || boomArray[2] !== BOOM_MAGIC[2] || boomArray[3] !== BOOM_MAGIC[3]) {
+    console.error("Error: Not a valid BOOM file (invalid magic header)");
+    process.exit(1);
+  }
+  const version = boomArray[4];
+  const flags = boomArray[5];
+  const usesDict = flags !== void 0 ? (flags & 1) !== 0 : false;
+  const jsonData = decode(boomArray);
+  const jsonString = JSON.stringify(jsonData);
+  const prettyJson = JSON.stringify(jsonData, null, 2);
+  const savings = ((1 - boomArray.length / jsonString.length) * 100).toFixed(1);
+  console.log(`BOOM File Info: ${options.input}`);
+  console.log(`${"\u2500".repeat(50)}`);
+  console.log(`  Format version:    ${version}`);
+  console.log(`  Uses dictionary:   ${usesDict ? "yes" : "no"}`);
+  console.log(`  BOOM size:         ${formatBytes(boomArray.length)}`);
+  console.log(`  JSON size:         ${formatBytes(jsonString.length)}`);
+  console.log(`  Size reduction:    ${savings}%`);
+  console.log(`${"\u2500".repeat(50)}`);
+  console.log(`Preview (first 500 chars):`);
+  console.log(prettyJson.slice(0, 500) + (prettyJson.length > 500 ? "..." : ""));
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  try {
+    switch (options.command) {
+      case "help":
+        printHelp();
+        break;
+      case "version":
+        printVersion();
+        break;
+      case "encode":
+        await runEncode(options);
+        break;
+      case "decode":
+        await runDecode(options);
+        break;
+      case "info":
+        await runInfo(options);
+        break;
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("An unknown error occurred");
+    }
+    process.exit(1);
+  }
+}
+main();