json-term 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,695 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import fs from "fs";
+import pc4 from "picocolors";
+
+// src/formatter.ts
+import pc from "picocolors";
+function getValueType(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return "array";
+  const t = typeof value;
+  if (t === "object") return "object";
+  if (t === "string") return "string";
+  if (t === "number") return "number";
+  if (t === "boolean") return "boolean";
+  return "string";
+}
+function formatValue(value, truncateLen = 80) {
+  const type = getValueType(value);
+  switch (type) {
+    case "string": {
+      const str = JSON.stringify(value);
+      const truncated = str.length > truncateLen ? str.slice(0, truncateLen - 3) + '..."' : str;
+      return pc.green(truncated);
+    }
+    case "number":
+      return pc.yellow(String(value));
+    case "boolean":
+      return pc.magenta(String(value));
+    case "null":
+      return pc.dim("null");
+    case "array":
+      return pc.dim(`[${value.length} items]`);
+    case "object":
+      return pc.dim(`{${Object.keys(value).length} keys}`);
+    default:
+      return String(value);
+  }
+}
+function formatKey(key) {
+  return pc.bold(pc.cyan(key));
+}
+function buildTree(data, key, path = "$", depth = 0, maxInitialDepth = 2, parentId) {
+  const type = getValueType(data);
+  const id = `${path}-${key || "root"}-${depth}`;
+  const collapsed = depth >= maxInitialDepth;
+  const node = {
+    id,
+    key,
+    value: data,
+    type,
+    depth,
+    path,
+    collapsed,
+    parentId
+  };
+  if (type === "object" && data !== null) {
+    const keys = Object.keys(data);
+    node.itemCount = keys.length;
+    node.children = keys.map(
+      (k) => buildTree(
+        data[k],
+        k,
+        path === "$" ? k : `${path}.${k}`,
+        depth + 1,
+        maxInitialDepth,
+        id
+      )
+    );
+  } else if (type === "array") {
+    node.itemCount = data.length;
+    node.children = data.map(
+      (item, idx) => buildTree(
+        item,
+        `[${idx}]`,
+        `${path}[${idx}]`,
+        depth + 1,
+        maxInitialDepth,
+        id
+      )
+    );
+  }
+  return node;
+}
+function prettyPrintTree(node, indent = "", isLast = true) {
+  const isRoot = node.depth === 0;
+  const marker = node.type === "object" || node.type === "array" ? node.collapsed ? pc.cyan("\u25B6 ") : pc.cyan("\u25BC ") : pc.dim("\u2022 ");
+  let line = "";
+  if (!isRoot) {
+    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    line += pc.dim(indent + branch) + marker;
+    if (node.key) {
+      line += formatKey(node.key) + pc.dim(": ");
+    }
+  } else {
+    line += marker + (node.key ? formatKey(node.key) + pc.dim(": ") : pc.bold(pc.white("root: ")));
+  }
+  if (node.type === "object") {
+    line += pc.dim(`{ ${node.itemCount} keys }`);
+  } else if (node.type === "array") {
+    line += pc.dim(`[ ${node.itemCount} items ]`);
+  } else {
+    line += formatValue(node.value);
+  }
+  const lines = [line];
+  if (!node.collapsed && node.children && node.children.length > 0) {
+    const nextIndent = isRoot ? "" : indent + (isLast ? "    " : "\u2502   ");
+    node.children.forEach((child, index) => {
+      const childIsLast = index === node.children.length - 1;
+      lines.push(prettyPrintTree(child, nextIndent, childIsLast));
+    });
+  }
+  return lines.join("\n");
+}
+
+// src/differ.ts
+import pc2 from "picocolors";
+function diffJSON(a, b, key, path = "$", depth = 0, maxInitialDepth = 3) {
+  const typeA = getValueType(a);
+  const typeB = getValueType(b);
+  const id = `${path}-${key || "diff"}-${depth}`;
+  const collapsed = depth >= maxInitialDepth;
+  if (a === void 0 && b !== void 0) {
+    const node = {
+      id,
+      key,
+      path,
+      depth,
+      status: "added",
+      newValue: b,
+      type: typeB,
+      collapsed: false
+    };
+    if (typeB === "object" && b !== null) {
+      node.itemCount = Object.keys(b).length;
+      node.children = Object.keys(b).map(
+        (k) => diffJSON(void 0, b[k], k, path === "$" ? k : `${path}.${k}`, depth + 1, maxInitialDepth)
+      );
+    } else if (typeB === "array") {
+      node.itemCount = b.length;
+      node.children = b.map(
+        (item, idx) => diffJSON(void 0, item, `[${idx}]`, `${path}[${idx}]`, depth + 1, maxInitialDepth)
+      );
+    }
+    return node;
+  }
+  if (a !== void 0 && b === void 0) {
+    const node = {
+      id,
+      key,
+      path,
+      depth,
+      status: "removed",
+      oldValue: a,
+      type: typeA,
+      collapsed: false
+    };
+    if (typeA === "object" && a !== null) {
+      node.itemCount = Object.keys(a).length;
+      node.children = Object.keys(a).map(
+        (k) => diffJSON(a[k], void 0, k, path === "$" ? k : `${path}.${k}`, depth + 1, maxInitialDepth)
+      );
+    } else if (typeA === "array") {
+      node.itemCount = a.length;
+      node.children = a.map(
+        (item, idx) => diffJSON(item, void 0, `[${idx}]`, `${path}[${idx}]`, depth + 1, maxInitialDepth)
+      );
+    }
+    return node;
+  }
+  if (typeA !== typeB) {
+    return {
+      id,
+      key,
+      path,
+      depth,
+      status: "modified",
+      oldValue: a,
+      newValue: b,
+      type: typeB,
+      collapsed: false
+    };
+  }
+  if (typeA === "object" && a !== null && b !== null) {
+    const allKeys = Array.from(/* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]));
+    const children = [];
+    let hasModifications = false;
+    for (const k of allKeys) {
+      const child = diffJSON(
+        a[k],
+        b[k],
+        k,
+        path === "$" ? k : `${path}.${k}`,
+        depth + 1,
+        maxInitialDepth
+      );
+      if (child.status !== "unchanged") hasModifications = true;
+      children.push(child);
+    }
+    return {
+      id,
+      key,
+      path,
+      depth,
+      status: hasModifications ? "modified" : "unchanged",
+      oldValue: a,
+      newValue: b,
+      type: "object",
+      itemCount: allKeys.length,
+      collapsed,
+      children
+    };
+  }
+  if (typeA === "array") {
+    const maxLen = Math.max(a.length, b.length);
+    const children = [];
+    let hasModifications = false;
+    for (let i = 0; i < maxLen; i++) {
+      const child = diffJSON(
+        a[i],
+        b[i],
+        `[${i}]`,
+        `${path}[${i}]`,
+        depth + 1,
+        maxInitialDepth
+      );
+      if (child.status !== "unchanged") hasModifications = true;
+      children.push(child);
+    }
+    return {
+      id,
+      key,
+      path,
+      depth,
+      status: hasModifications ? "modified" : "unchanged",
+      oldValue: a,
+      newValue: b,
+      type: "array",
+      itemCount: maxLen,
+      collapsed,
+      children
+    };
+  }
+  if (a !== b) {
+    return {
+      id,
+      key,
+      path,
+      depth,
+      status: "modified",
+      oldValue: a,
+      newValue: b,
+      type: typeB,
+      collapsed: false
+    };
+  }
+  return {
+    id,
+    key,
+    path,
+    depth,
+    status: "unchanged",
+    oldValue: a,
+    newValue: b,
+    type: typeA,
+    collapsed
+  };
+}
+function calculateDiffStats(node) {
+  const stats = { added: 0, removed: 0, modified: 0, unchanged: 0 };
+  function traverse(n) {
+    if (n.children && n.children.length > 0) {
+      n.children.forEach(traverse);
+    } else {
+      stats[n.status]++;
+    }
+  }
+  traverse(node);
+  return stats;
+}
+function prettyPrintDiff(node, options = {}, indent = "", isLast = true) {
+  const showUnchanged = options.showUnchanged ?? true;
+  if (!showUnchanged && node.status === "unchanged" && (!node.children || node.children.length === 0)) {
+    return "";
+  }
+  const isRoot = node.depth === 0;
+  let prefix = "  ";
+  let statusColor = pc2.dim;
+  if (node.status === "added") {
+    prefix = pc2.green("+ ");
+    statusColor = pc2.green;
+  } else if (node.status === "removed") {
+    prefix = pc2.red("- ");
+    statusColor = pc2.red;
+  } else if (node.status === "modified") {
+    prefix = pc2.yellow("~ ");
+    statusColor = pc2.yellow;
+  }
+  let line = prefix;
+  if (!isRoot) {
+    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    line += pc2.dim(indent + branch);
+    if (node.key) {
+      line += formatKey(node.key) + pc2.dim(": ");
+    }
+  } else {
+    line += node.key ? formatKey(node.key) + pc2.dim(": ") : pc2.bold("diff: ");
+  }
+  if (node.status === "added") {
+    line += statusColor(formatValue(node.newValue));
+  } else if (node.status === "removed") {
+    line += statusColor(formatValue(node.oldValue));
+  } else if (node.status === "modified") {
+    if (node.type === "object" || node.type === "array") {
+      line += statusColor(`{ ${node.itemCount} items modified }`);
+    } else {
+      line += `${pc2.red(formatValue(node.oldValue))} ${pc2.dim("->")} ${pc2.green(formatValue(node.newValue))}`;
+    }
+  } else {
+    line += pc2.dim(formatValue(node.newValue));
+  }
+  const lines = [line];
+  if (!node.collapsed && node.children && node.children.length > 0) {
+    const nextIndent = isRoot ? "" : indent + (isLast ? "    " : "\u2502   ");
+    node.children.forEach((child, index) => {
+      const childIsLast = index === node.children.length - 1;
+      const childStr = prettyPrintDiff(child, options, nextIndent, childIsLast);
+      if (childStr) lines.push(childStr);
+    });
+  }
+  return lines.join("\n");
+}
+
+// src/interactive.ts
+import readline from "readline";
+import pc3 from "picocolors";
+
+// src/utils/clipboard.ts
+import { exec } from "child_process";
+import os from "os";
+async function copyToClipboard(text) {
+  const platform = os.platform();
+  return new Promise((resolve) => {
+    let proc;
+    if (platform === "darwin") {
+      proc = exec("pbcopy", (err) => resolve(!err));
+    } else if (platform === "win32") {
+      proc = exec("clip", (err) => resolve(!err));
+    } else {
+      proc = exec("wl-copy 2>/dev/null || xclip -selection clipboard 2>/dev/null || xsel --clipboard --input", (err) => {
+        resolve(!err);
+      });
+    }
+    if (proc.stdin) {
+      proc.stdin.write(text);
+      proc.stdin.end();
+    } else {
+      resolve(false);
+    }
+  });
+}
+
+// src/interactive.ts
+var InteractiveViewer = class {
+  root;
+  flatList = [];
+  selectedIndex = 0;
+  searchQuery = "";
+  isSearching = false;
+  searchInput = "";
+  notification = "";
+  notificationTimer = null;
+  isDiff;
+  constructor(root, isDiff = false) {
+    this.root = root;
+    this.isDiff = isDiff;
+    this.rebuildFlatList();
+  }
+  isDiffNode(node) {
+    return this.isDiff && "status" in node;
+  }
+  rebuildFlatList() {
+    const list = [];
+    const traverse = (node, currentDepth) => {
+      if (this.searchQuery) {
+        const query = this.searchQuery.toLowerCase();
+        const keyMatch = node.key && node.key.toLowerCase().includes(query);
+        const pathMatch = node.path && node.path.toLowerCase().includes(query);
+        const valMatch = "value" in node ? JSON.stringify(node.value).toLowerCase().includes(query) : "newValue" in node ? JSON.stringify(node.newValue).toLowerCase().includes(query) : false;
+        if (!keyMatch && !pathMatch && !valMatch && (!node.children || node.children.length === 0)) {
+          return;
+        }
+      }
+      list.push({ node, depth: currentDepth, isDiff: this.isDiff });
+      if (!node.collapsed && node.children && node.children.length > 0) {
+        for (const child of node.children) {
+          traverse(child, currentDepth + 1);
+        }
+      }
+    };
+    traverse(this.root, 0);
+    this.flatList = list;
+    if (this.selectedIndex >= this.flatList.length) {
+      this.selectedIndex = Math.max(0, this.flatList.length - 1);
+    }
+  }
+  setNotification(msg) {
+    this.notification = msg;
+    if (this.notificationTimer) clearTimeout(this.notificationTimer);
+    this.notificationTimer = setTimeout(() => {
+      this.notification = "";
+      this.render();
+    }, 2500);
+  }
+  render() {
+    const rows = process.stdout.rows || 24;
+    const maxVisibleRows = Math.max(5, rows - 5);
+    let startIdx = 0;
+    if (this.selectedIndex >= maxVisibleRows) {
+      startIdx = this.selectedIndex - maxVisibleRows + 1;
+    }
+    const endIdx = Math.min(this.flatList.length, startIdx + maxVisibleRows);
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H\x1B[?25l");
+    const title = this.isDiff ? " JSON Structural Diff Explorer " : " Interactive JSON Tree Explorer ";
+    console.log(pc3.bgCyan(pc3.black(pc3.bold(` ${title} `)) + pc3.dim(` [Total items: ${this.flatList.length}]`)));
+    for (let i = startIdx; i < endIdx; i++) {
+      const { node, depth } = this.flatList[i];
+      const isSelected = i === this.selectedIndex;
+      const indent = "  ".repeat(depth);
+      let marker = "\u2022 ";
+      if (node.children && node.children.length > 0) {
+        marker = node.collapsed ? "\u25B6 " : "\u25BC ";
+      }
+      let lineContent = "";
+      if (this.isDiffNode(node)) {
+        let diffPrefix = "  ";
+        if (node.status === "added") diffPrefix = pc3.green("+ ");
+        else if (node.status === "removed") diffPrefix = pc3.red("- ");
+        else if (node.status === "modified") diffPrefix = pc3.yellow("~ ");
+        lineContent = diffPrefix + indent + marker;
+        if (node.key) lineContent += formatKey(node.key) + pc3.dim(": ");
+        if (node.status === "added") {
+          lineContent += pc3.green(formatValue(node.newValue, 50));
+        } else if (node.status === "removed") {
+          lineContent += pc3.red(formatValue(node.oldValue, 50));
+        } else if (node.status === "modified") {
+          if (node.type === "object" || node.type === "array") {
+            lineContent += pc3.yellow(`{ ${node.itemCount} modified }`);
+          } else {
+            lineContent += `${pc3.red(formatValue(node.oldValue, 25))} -> ${pc3.green(formatValue(node.newValue, 25))}`;
+          }
+        } else {
+          lineContent += pc3.dim(formatValue(node.newValue, 50));
+        }
+      } else {
+        const treeNode = node;
+        lineContent = indent + marker;
+        if (treeNode.key) lineContent += formatKey(treeNode.key) + pc3.dim(": ");
+        if (treeNode.type === "object") {
+          lineContent += pc3.dim(`{ ${treeNode.itemCount} keys }`);
+        } else if (treeNode.type === "array") {
+          lineContent += pc3.dim(`[ ${treeNode.itemCount} items ]`);
+        } else {
+          lineContent += formatValue(treeNode.value, 60);
+        }
+      }
+      if (isSelected) {
+        console.log(pc3.bgBlue(pc3.white(pc3.bold(`> ${lineContent}`))));
+      } else {
+        console.log(`  ${lineContent}`);
+      }
+    }
+    const selectedItem = this.flatList[this.selectedIndex];
+    const currentPath = selectedItem ? selectedItem.node.path : "$";
+    console.log("\n" + pc3.dim("\u2500".repeat(Math.min(process.stdout.columns || 80, 80))));
+    if (this.notification) {
+      console.log(pc3.green(pc3.bold(` ${this.notification}`)));
+    } else if (this.isSearching) {
+      console.log(pc3.yellow(pc3.bold(` Search: /${this.searchInput}\u2588`)));
+    } else {
+      console.log(pc3.bold(pc3.cyan(` Path: ${currentPath}`)));
+      console.log(
+        pc3.dim(" [\u2191/\u2193] Move  [Enter/Space] Toggle  [e] Expand All  [c] Collapse All  [p] Copy Path  [y] Copy Val  [/] Search  [q] Exit")
+      );
+    }
+  }
+  expandAll(node) {
+    node.collapsed = false;
+    if (node.children) node.children.forEach((c) => this.expandAll(c));
+  }
+  collapseAll(node) {
+    if (node.depth > 0) node.collapsed = true;
+    if (node.children) node.children.forEach((c) => this.collapseAll(c));
+  }
+  async start() {
+    if (!process.stdin.isTTY) {
+      return;
+    }
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    this.render();
+    return new Promise((resolve) => {
+      const onKeypress = async (str, key) => {
+        if (this.isSearching) {
+          if (key.name === "return") {
+            this.searchQuery = this.searchInput;
+            this.isSearching = false;
+            this.rebuildFlatList();
+            this.render();
+            return;
+          }
+          if (key.name === "escape") {
+            this.isSearching = false;
+            this.searchInput = "";
+            this.render();
+            return;
+          }
+          if (key.name === "backspace") {
+            this.searchInput = this.searchInput.slice(0, -1);
+            this.render();
+            return;
+          }
+          if (str && str.length === 1) {
+            this.searchInput += str;
+            this.render();
+            return;
+          }
+        }
+        if (key.name === "up" || key.name === "k") {
+          if (this.selectedIndex > 0) {
+            this.selectedIndex--;
+            this.render();
+          }
+        } else if (key.name === "down" || key.name === "j") {
+          if (this.selectedIndex < this.flatList.length - 1) {
+            this.selectedIndex++;
+            this.render();
+          }
+        } else if (key.name === "return" || key.name === "space" || key.name === "right" || key.name === "left") {
+          const item = this.flatList[this.selectedIndex];
+          if (item && item.node.children && item.node.children.length > 0) {
+            item.node.collapsed = !item.node.collapsed;
+            this.rebuildFlatList();
+            this.render();
+          }
+        } else if (str === "e" || str === "E") {
+          this.expandAll(this.root);
+          this.rebuildFlatList();
+          this.render();
+        } else if (str === "c" || str === "C") {
+          this.collapseAll(this.root);
+          this.rebuildFlatList();
+          this.render();
+        } else if (str === "p" || str === "P") {
+          const item = this.flatList[this.selectedIndex];
+          if (item) {
+            await copyToClipboard(item.node.path);
+            this.setNotification(`\u2714 Copied JSONPath: ${item.node.path}`);
+          }
+        } else if (str === "y" || str === "Y") {
+          const item = this.flatList[this.selectedIndex];
+          if (item) {
+            const val = "value" in item.node ? item.node.value : item.node.newValue;
+            const textToCopy = typeof val === "object" ? JSON.stringify(val, null, 2) : String(val);
+            await copyToClipboard(textToCopy);
+            this.setNotification(`\u2714 Copied value to clipboard!`);
+          }
+        } else if (str === "/") {
+          this.isSearching = true;
+          this.searchInput = "";
+          this.render();
+        } else if (key.ctrl && key.name === "c" || key.name === "escape" || str === "q" || str === "Q") {
+          process.stdin.removeListener("keypress", onKeypress);
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdout.write("\x1B[?25h\n");
+          resolve();
+        }
+      };
+      process.stdin.on("keypress", onKeypress);
+    });
+  }
+};
+
+// src/cli.ts
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data.trim());
+    });
+    setTimeout(() => {
+      if (!data) resolve("");
+    }, 100);
+  });
+}
+function parseJSON(raw, label = "Input") {
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${label}: ${err.message}`);
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("json-term").description("High-fidelity interactive terminal JSON viewer, collapsible tree explorer, type syntax highlighter, and structural diff tool.").version("1.0.0", "-v, --version", "Output the current version").argument("[file]", "JSON file to view or compare").option("-p, --print", "Print formatted non-interactive tree to stdout", false).option("-d, --depth <number>", "Initial tree expansion depth", (val) => parseInt(val, 10), 2).option("-s, --search <query>", "Filter tree by key or value query").action(async (fileArg, options) => {
+    try {
+      let raw = "";
+      if (fileArg) {
+        if (!fs.existsSync(fileArg)) {
+          console.error(pc4.red(`Error: File not found: ${fileArg}`));
+          process.exit(1);
+        }
+        raw = await fs.promises.readFile(fileArg, "utf-8");
+      } else {
+        raw = await readStdin();
+      }
+      if (!raw) {
+        program.help();
+        process.exit(1);
+      }
+      const data = parseJSON(raw, fileArg || "stdin");
+      const tree = buildTree(data, fileArg || "root", "$", 0, options.depth);
+      if (options.print || !process.stdin.isTTY) {
+        console.log(prettyPrintTree(tree));
+      } else {
+        const viewer = new InteractiveViewer(tree, false);
+        await viewer.start();
+      }
+    } catch (err) {
+      console.error(pc4.red(`Error: ${err.message || err}`));
+      process.exit(1);
+    }
+  });
+  program.command("diff <fileA> [fileB]").description("Structural JSON diff between two files or stdin").option("-p, --print", "Print formatted non-interactive diff to stdout", false).option("-d, --depth <number>", "Initial expansion depth", (val) => parseInt(val, 10), 3).option("--no-unchanged", "Hide unchanged nodes from the diff view", false).action(async (fileA, fileB, diffOptions) => {
+    try {
+      if (!fs.existsSync(fileA)) {
+        console.error(pc4.red(`Error: File not found: ${fileA}`));
+        process.exit(1);
+      }
+      const rawA = await fs.promises.readFile(fileA, "utf-8");
+      const dataA = parseJSON(rawA, fileA);
+      let dataB;
+      if (fileB) {
+        if (!fs.existsSync(fileB)) {
+          console.error(pc4.red(`Error: File not found: ${fileB}`));
+          process.exit(1);
+        }
+        const rawB = await fs.promises.readFile(fileB, "utf-8");
+        dataB = parseJSON(rawB, fileB);
+      } else {
+        const stdinData = await readStdin();
+        if (!stdinData) {
+          console.error(pc4.red("Error: Please specify second file or pipe JSON via stdin."));
+          process.exit(1);
+        }
+        dataB = parseJSON(stdinData, "stdin");
+      }
+      const diffTree = diffJSON(dataA, dataB, `${fileA} \u2194 ${fileB || "stdin"}`, "$", 0, diffOptions.depth);
+      const stats = calculateDiffStats(diffTree);
+      if (diffOptions.print || !process.stdin.isTTY) {
+        console.log(
+          pc4.bold(
+            `Diff Stats: ${pc4.green(`+${stats.added}`)} ${pc4.red(`-${stats.removed}`)} ${pc4.yellow(`~${stats.modified}`)} ${pc4.dim(`=${stats.unchanged}`)}
+`
+          )
+        );
+        console.log(prettyPrintDiff(diffTree, { showUnchanged: diffOptions.unchanged }));
+      } else {
+        const viewer = new InteractiveViewer(diffTree, true);
+        await viewer.start();
+      }
+    } catch (err) {
+      console.error(pc4.red(`Error: ${err.message || err}`));
+      process.exit(1);
+    }
+  });
+  await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+  console.error(pc4.red(`Error: ${err.message || err}`));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.mjs.map