@chengyixu/json-diff-cli 1.0.0

package/index.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+'use strict';
+
+// json-diff-cli — zero-dependency JSON diff tool
+// Usage: json-diff-cli file1.json file2.json [--keys-only] [--no-color]
+
+const fs   = require('fs');
+const path = require('path');
+
+const VERSION = '1.0.0';
+
+const RESET  = '\x1b[0m';
+const RED    = '\x1b[31m';
+const GREEN  = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN   = '\x1b[36m';
+const BLUE   = '\x1b[34m';
+const BOLD   = '\x1b[1m';
+const DIM    = '\x1b[2m';
+
+let useColor = true;
+
+function c(code, str) {
+  return useColor ? `${code}${str}${RESET}` : str;
+}
+
+function printHelp() {
+  console.log(`
+${c(BOLD, 'json-diff-cli')} v${VERSION} — Diff two JSON files
+
+${c(CYAN, 'Usage:')}
+  json-diff-cli <file1.json> <file2.json> [options]
+
+${c(CYAN, 'Options:')}
+  --keys-only    Only show changed keys, not values
+  --no-color     Disable colored output
+  --json         Output result as JSON
+  --quiet        Exit with code 0 even if differences found
+  --version, -v  Show version
+  --help, -h     Show this help
+
+${c(CYAN, 'Exit codes:')}
+  0 — No differences
+  1 — Differences found
+  2 — Error (bad args, parse failure)
+
+${c(CYAN, 'Examples:')}
+  json-diff-cli package.json package-lock.json
+  json-diff-cli a.json b.json --keys-only
+  json-diff-cli old.json new.json --json | jq .
+`);
+}
+
+// ── Deep diff ─────────────────────────────────────────────────────────────
+
+/**
+ * Returns a structured diff:
+ * { added: {path: value}, removed: {path: value}, changed: {path: {from, to}}, same: {path: value} }
+ */
+function deepDiff(a, b, prefix = '') {
+  const added   = {};
+  const removed = {};
+  const changed = {};
+  const same    = {};
+
+  function keyPath(base, key) {
+    if (base === '') return String(key);
+    if (typeof key === 'number') return `${base}[${key}]`;
+    return `${base}.${key}`;
+  }
+
+  function compare(av, bv, path) {
+    const ta = typeOf(av);
+    const tb = typeOf(bv);
+
+    // Both objects
+    if (ta === 'object' && tb === 'object') {
+      const allKeys = new Set([...Object.keys(av), ...Object.keys(bv)]);
+      for (const k of allKeys) {
+        const kp = keyPath(path, k);
+        if (!(k in av)) {
+          flatCollect(bv[k], kp, added);
+        } else if (!(k in bv)) {
+          flatCollect(av[k], kp, removed);
+        } else {
+          compare(av[k], bv[k], kp);
+        }
+      }
+      return;
+    }
+
+    // Both arrays
+    if (ta === 'array' && tb === 'array') {
+      const len = Math.max(av.length, bv.length);
+      for (let i = 0; i < len; i++) {
+        const kp = keyPath(path, i);
+        if (i >= av.length) {
+          flatCollect(bv[i], kp, added);
+        } else if (i >= bv.length) {
+          flatCollect(av[i], kp, removed);
+        } else {
+          compare(av[i], bv[i], kp);
+        }
+      }
+      return;
+    }
+
+    // Type changed or value changed
+    if (ta !== tb || !deepEqual(av, bv)) {
+      if (ta !== tb) {
+        changed[path] = { from: av, to: bv, typeChange: true };
+      } else {
+        changed[path] = { from: av, to: bv };
+      }
+    } else {
+      same[path] = av;
+    }
+  }
+
+  function flatCollect(val, path, target) {
+    const t = typeOf(val);
+    if (t === 'object') {
+      for (const k of Object.keys(val)) {
+        flatCollect(val[k], keyPath(path, k), target);
+      }
+    } else if (t === 'array') {
+      for (let i = 0; i < val.length; i++) {
+        flatCollect(val[i], keyPath(path, i), target);
+      }
+    } else {
+      target[path] = val;
+    }
+  }
+
+  function typeOf(v) {
+    if (v === null) return 'null';
+    if (Array.isArray(v)) return 'array';
+    return typeof v;
+  }
+
+  function deepEqual(x, y) {
+    return JSON.stringify(x) === JSON.stringify(y);
+  }
+
+  compare(a, b, prefix);
+  return { added, removed, changed, same };
+}
+
+// ── Formatters ─────────────────────────────────────────────────────────────
+
+function fmtVal(v, maxLen = 80) {
+  if (v === null) return c(DIM, 'null');
+  if (typeof v === 'boolean') return c(BLUE, String(v));
+  if (typeof v === 'number') return c(BLUE, String(v));
+  if (typeof v === 'string') {
+    const s = JSON.stringify(v);
+    return s.length > maxLen ? s.slice(0, maxLen) + '…"' : s;
+  }
+  const s = JSON.stringify(v);
+  return s.length > maxLen ? s.slice(0, maxLen) + '…' : s;
+}
+
+function printDiff(diff, keysOnly) {
+  const sections = [
+    { label: 'ADDED',   color: GREEN,  items: diff.added,   symbol: '+' },
+    { label: 'REMOVED', color: RED,    items: diff.removed, symbol: '-' },
+    { label: 'CHANGED', color: YELLOW, items: diff.changed, symbol: '~' },
+  ];
+
+  let totalChanges = 0;
+
+  for (const sec of sections) {
+    const keys = Object.keys(sec.items);
+    if (keys.length === 0) continue;
+    totalChanges += keys.length;
+
+    console.log(`\n${c(BOLD + sec.color, sec.label + ` (${keys.length})`)}:`);
+    for (const key of keys.sort()) {
+      const val = sec.items[key];
+      if (sec.label === 'CHANGED') {
+        const { from, to, typeChange } = val;
+        if (keysOnly) {
+          console.log(`  ${c(sec.color, sec.symbol)} ${key}`);
+        } else {
+          const typeNote = typeChange
+            ? c(DIM, ` [${typeof from} → ${typeof to}]`)
+            : '';
+          console.log(`  ${c(YELLOW, '~')} ${c(BOLD, key)}${typeNote}`);
+          console.log(`      ${c(RED,   '- ')}${fmtVal(from)}`);
+          console.log(`      ${c(GREEN, '+ ')}${fmtVal(to)}`);
+        }
+      } else {
+        if (keysOnly) {
+          console.log(`  ${c(sec.color, sec.symbol)} ${key}`);
+        } else {
+          console.log(`  ${c(sec.color, sec.symbol)} ${c(BOLD, key)}: ${fmtVal(val)}`);
+        }
+      }
+    }
+  }
+
+  return totalChanges;
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  printHelp();
+  process.exit(0);
+}
+if (args.includes('--version') || args.includes('-v')) {
+  console.log(`json-diff-cli v${VERSION}`);
+  process.exit(0);
+}
+
+const keysOnly  = args.includes('--keys-only');
+const jsonOut   = args.includes('--json');
+const quiet     = args.includes('--quiet');
+useColor        = !args.includes('--no-color') && !jsonOut && process.stdout.isTTY !== false;
+
+const files = args.filter(a => !a.startsWith('--'));
+
+if (files.length < 2) {
+  console.error(c(RED, 'Error: Two JSON files required.'));
+  printHelp();
+  process.exit(2);
+}
+
+const [file1, file2] = files;
+
+let a, b;
+
+try {
+  a = JSON.parse(fs.readFileSync(file1, 'utf8'));
+} catch (e) {
+  console.error(c(RED, `Error: Cannot parse ${file1}: ${e.message}`));
+  process.exit(2);
+}
+
+try {
+  b = JSON.parse(fs.readFileSync(file2, 'utf8'));
+} catch (e) {
+  console.error(c(RED, `Error: Cannot parse ${file2}: ${e.message}`));
+  process.exit(2);
+}
+
+const diff = deepDiff(a, b);
+const totalAdded   = Object.keys(diff.added).length;
+const totalRemoved = Object.keys(diff.removed).length;
+const totalChanged = Object.keys(diff.changed).length;
+const totalSame    = Object.keys(diff.same).length;
+const hasChanges   = totalAdded + totalRemoved + totalChanged > 0;
+
+if (jsonOut) {
+  console.log(JSON.stringify({
+    added:   diff.added,
+    removed: diff.removed,
+    changed: diff.changed,
+    summary: { added: totalAdded, removed: totalRemoved, changed: totalChanged, same: totalSame },
+  }, null, 2));
+  process.exit(hasChanges && !quiet ? 1 : 0);
+}
+
+// Header
+console.log(`\n${c(BOLD, 'json-diff-cli')} — comparing:`);
+console.log(`  ${c(RED,   'A:')} ${file1}`);
+console.log(`  ${c(GREEN, 'B:')} ${file2}`);
+
+if (!hasChanges) {
+  console.log(`\n${c(GREEN + BOLD, '✔ No differences found')} ${c(DIM, `(${totalSame} matching keys)`)}`);
+  process.exit(0);
+}
+
+printDiff(diff, keysOnly);
+
+// Summary
+const parts = [];
+if (totalAdded)   parts.push(c(GREEN,  `+${totalAdded} added`));
+if (totalRemoved) parts.push(c(RED,    `-${totalRemoved} removed`));
+if (totalChanged) parts.push(c(YELLOW, `~${totalChanged} changed`));
+if (totalSame)    parts.push(c(DIM,    `=${totalSame} same`));
+
+console.log(`\n${c(BOLD, 'Summary:')} ${parts.join('  ')}`);
+process.exit(quiet ? 0 : 1);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@chengyixu/json-diff-cli",
+  "version": "1.0.0",
+  "description": "Show a clear diff between two JSON files — added, removed, and changed keys highlighted. Zero dependencies.",
+  "main": "index.js",
+  "bin": {
+    "json-diff-cli": "./index.js"
+  },
+  "scripts": {
+    "test": "node index.js --help"
+  },
+  "keywords": ["json", "diff", "compare", "cli", "devtools"],
+  "author": "chengyixu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chengyixu/json-diff-cli"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}