@asymmetric-effort/jsonlint 0.0.2 → 0.0.3

package/build/index.d.ts

@@ -5,6 +5,7 @@ export type { ParseErrorHash } from "./parser.js";
 export { formatJson } from "./formatter.js";
 export { SchemaValidator } from "./schema.js";
 export type { JsonSchema, SchemaError } from "./schema.js";
+export { main } from "./cli.js";
 import { JsonParser } from "./parser.js";
 export declare const parser: JsonParser;
 import { formatJson } from "./formatter.js";

package/build/index.js

@@ -876,12 +876,248 @@ class SchemaValidator {
     }
   }
 }
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+
+// src/version.ts
+var VERSION = "0.0.3";
+
+// src/cli.ts
+function printVersion() {
+  process.stdout.write(`${VERSION}
+`);
+}
+function printUsage() {
+  process.stdout.write(`Usage: jsonlint [OPTIONS] [FILE]
+
+Options:
+  -v, --version            Print version and exit
+  -s, --sort-keys          Sort object keys in output
+  -i, --in-place           Overwrite the input file with formatted output
+  -t, --indent CHAR        Character(s) to use for indentation (default: "  ")
+  -c, --compact            Compact error display
+  -V, --validate FILE      Validate against a JSON Schema file
+  -e, --environment ENV    JSON Schema spec version (default: json-schema-draft-03)
+  -q, --quiet              Do not print parsed JSON to stdout
+  -p, --pretty-print       Force pretty printing (even if invalid)
+  -h, --help               Show this help message
+
+If FILE is omitted, reads from stdin.
+`);
+}
+function parseArgs(args) {
+  const opts = {
+    file: null,
+    sortKeys: false,
+    inPlace: false,
+    indent: "  ",
+    compact: false,
+    validate: null,
+    environment: "json-schema-draft-03",
+    quiet: false,
+    prettyPrint: false,
+    version: false
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "-v":
+      case "--version":
+        opts.version = true;
+        break;
+      case "-s":
+      case "--sort-keys":
+        opts.sortKeys = true;
+        break;
+      case "-i":
+      case "--in-place":
+        opts.inPlace = true;
+        break;
+      case "-t":
+      case "--indent":
+        i++;
+        opts.indent = args[i] ?? "  ";
+        break;
+      case "-c":
+      case "--compact":
+        opts.compact = true;
+        break;
+      case "-V":
+      case "--validate":
+        i++;
+        opts.validate = args[i] ?? null;
+        break;
+      case "-e":
+      case "--environment":
+        i++;
+        opts.environment = args[i] ?? "json-schema-draft-03";
+        break;
+      case "-q":
+      case "--quiet":
+        opts.quiet = true;
+        break;
+      case "-p":
+      case "--pretty-print":
+        opts.prettyPrint = true;
+        break;
+      case "-h":
+      case "--help":
+        printUsage();
+        process.exit(0);
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          process.stderr.write(`Unknown option: ${arg}
+`);
+          process.exit(1);
+        }
+        opts.file = arg;
+        break;
+    }
+    i++;
+  }
+  return opts;
+}
+function sortObject(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObject);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const sorted = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sorted[key] = sortObject(obj[key]);
+    }
+    return sorted;
+  }
+  return obj;
+}
+function readStdin() {
+  try {
+    return readFileSync("/dev/stdin", "utf-8");
+  } catch {
+    process.stderr.write(`Error reading from stdin
+`);
+    process.exit(1);
+  }
+}
+function main(args) {
+  const cliArgs = args ?? process.argv.slice(2);
+  const opts = parseArgs(cliArgs);
+  if (opts.version) {
+    printVersion();
+    return;
+  }
+  let input;
+  let filename;
+  if (opts.file) {
+    try {
+      input = readFileSync(opts.file, "utf-8");
+    } catch {
+      process.stderr.write(`Error: could not open file '${opts.file}'
+`);
+      process.exit(1);
+      return;
+    }
+    filename = opts.file;
+  } else {
+    input = readStdin();
+    filename = "<stdin>";
+  }
+  const parser = new JsonParser;
+  if (opts.compact) {
+    parser.parseError = (str, hash) => {
+      const line = hash.line;
+      const col = hash.loc.last_column;
+      const found = hash.token === "EOF" ? "EOF" : hash.text || hash.token;
+      const expected = hash.expected.join(", ");
+      const msg = `${filename}: line ${line}, col ${col}, found: '${found}' - expected: ${expected}.`;
+      throw new ParseError(msg, hash);
+    };
+  }
+  function formatCompactError(e) {
+    if (opts.compact && e instanceof LexerError) {
+      return `${filename}: line ${e.line}, col ${e.column}, ${e.message.split(`
+`)[0]}`;
+    }
+    return e instanceof Error ? e.message : String(e);
+  }
+  let parsed;
+  try {
+    parsed = parser.parse(input);
+  } catch (e) {
+    if (opts.prettyPrint) {
+      const formatted = formatJson(input, opts.indent);
+      process.stdout.write(formatted + `
+`);
+      try {
+        const reformatParser = new JsonParser;
+        if (opts.compact) {
+          reformatParser.parseError = parser.parseError;
+        }
+        reformatParser.parse(formatted);
+      } catch (e2) {
+        process.stderr.write(formatCompactError(e2) + `
+`);
+      }
+      process.exit(1);
+      return;
+    }
+    process.stderr.write(formatCompactError(e) + `
+`);
+    process.exit(1);
+    return;
+  }
+  if (opts.validate) {
+    let schemaInput;
+    try {
+      schemaInput = readFileSync(opts.validate, "utf-8");
+    } catch {
+      process.stderr.write(`Error: could not open schema file '${opts.validate}'
+`);
+      process.exit(1);
+      return;
+    }
+    let schema;
+    try {
+      schema = JSON.parse(schemaInput);
+    } catch {
+      process.stderr.write(`Error: invalid JSON in schema file '${opts.validate}'
+`);
+      process.exit(1);
+      return;
+    }
+    const validator = new SchemaValidator;
+    const errors = validator.validate(parsed, schema);
+    if (errors.length > 0) {
+      for (const err of errors) {
+        process.stderr.write(`Schema validation error: property '${err.property}': ${err.message}
+`);
+      }
+      process.exit(1);
+      return;
+    }
+  }
+  if (opts.sortKeys) {
+    parsed = sortObject(parsed);
+  }
+  const output = JSON.stringify(parsed, null, opts.indent);
+  if (opts.inPlace && opts.file) {
+    writeFileSync(opts.file, output + `
+`, "utf-8");
+  } else if (!opts.quiet) {
+    process.stdout.write(output + `
+`);
+  }
+}
 // src/index.ts
 var parser = new JsonParser;
 var formatter = { formatJson };
 export {
   parser,
   parse,
+  main,
   formatter,
   formatJson,
   TokenType,

package/build/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.2";
+export declare const VERSION = "0.0.3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asymmetric-effort/jsonlint",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A pure JavaScript/TypeScript JSON parser and validator with detailed error reporting — zero dependencies",
   "type": "module",
   "main": "build/index.js",