@creationix/rex 0.3.1 → 0.6.0

package/rx-cli.ts

@@ -0,0 +1,298 @@
+import * as rexc from "./rexc.ts";
+import { stringify as rexStringify } from "./rex.ts";
+import {
+	setColorEnabled,
+	highlightLine,
+	highlightJSON,
+} from "./rex-repl.ts";
+import { readFile, writeFile } from "node:fs/promises";
+
+// ── Types ────────────────────────────────────────────────────
+
+type Format = "json" | "rexc";
+type OutputFormat = Format | "tree";
+
+type RxOptions = {
+	files: string[];
+	fromFormat?: Format;
+	toFormat?: OutputFormat;
+	select?: string;
+	out?: string;
+	color: boolean;
+	colorExplicit: boolean;
+	help: boolean;
+};
+
+// ── Arg parsing ──────────────────────────────────────────────
+
+function parseArgs(argv: string[]): RxOptions {
+	const opts: RxOptions = {
+		files: [],
+		color: process.stdout.isTTY ?? false,
+		colorExplicit: false,
+		help: false,
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i]!;
+		if (arg === "-h" || arg === "--help") { opts.help = true; continue; }
+		if (arg === "--color") { opts.color = true; opts.colorExplicit = true; continue; }
+		if (arg === "--no-color") { opts.color = false; opts.colorExplicit = true; continue; }
+		if (arg === "-j" || arg === "--json") { opts.toFormat = "json"; continue; }
+		if (arg === "-r" || arg === "--rexc") { opts.toFormat = "rexc"; continue; }
+		if (arg === "-t" || arg === "--tree") { opts.toFormat = "tree"; continue; }
+		if (arg === "--from") {
+			const v = argv[++i];
+			if (v !== "json" && v !== "rexc") throw new Error("--from must be 'json' or 'rexc'");
+			opts.fromFormat = v;
+			continue;
+		}
+		if (arg === "--to") {
+			const v = argv[++i];
+			if (v !== "json" && v !== "rexc" && v !== "tree") throw new Error("--to must be 'json', 'rexc', or 'tree'");
+			opts.toFormat = v;
+			continue;
+		}
+		if (arg === "-s" || arg === "--select") {
+			const v = argv[++i];
+			if (!v) throw new Error("Missing value for --select");
+			opts.select = v;
+			continue;
+		}
+		if (arg === "-o" || arg === "--out") {
+			const v = argv[++i];
+			if (!v) throw new Error("Missing value for --out");
+			opts.out = v;
+			continue;
+		}
+		if (!arg.startsWith("-") || arg === "-") {
+			opts.files.push(arg);
+			continue;
+		}
+		throw new Error(`Unknown option: ${arg}`);
+	}
+	return opts;
+}
+
+function usage(): string {
+	return [
+		"rx — inspect, convert, and filter REXC & JSON data.",
+		"",
+		"Usage:",
+		"  rx data.rexc                   Pretty-print rexc as a tree",
+		"  rx data.rexc --to json         Convert rexc to JSON",
+		"  rx data.json --to rexc         Convert JSON to rexc",
+		"  cat data.rexc | rx             Read from stdin (auto-detect)",
+		"  rx -s .routes[0].op data.rexc  Select a sub-value",
+		"",
+		"Input:",
+		"  <file>              Read from file (format auto-detected by extension)",
+		"  -                   Read from stdin explicitly",
+		"  (no args, piped)    Read from stdin automatically",
+		"",
+		"Format control:",
+		"  --from json|rexc    Force input format (default: auto-detect)",
+		"  --to json|rexc|tree Output format",
+		"  -j, --json          Shortcut for --to json",
+		"  -r, --rexc          Shortcut for --to rexc",
+		"  -t, --tree          Shortcut for --to tree",
+		"",
+		"  Default output: tree on TTY, json when piped.",
+		"",
+		"Filtering:",
+		"  -s, --select <path> Dot-path selector (e.g. .foo.bar[0].baz)",
+		"",
+		"Output:",
+		"  -o, --out <path>    Write to file instead of stdout",
+		"  --color             Force ANSI color",
+		"  --no-color          Disable ANSI color",
+		"  -h, --help          Show this message",
+	].join("\n");
+}
+
+// ── Format detection ─────────────────────────────────────────
+
+function formatFromExt(path: string): Format | undefined {
+	if (path.endsWith(".json")) return "json";
+	if (path.endsWith(".rexc")) return "rexc";
+	return undefined;
+}
+
+function detectFormat(content: string): Format {
+	const t = content.trimStart();
+	if (/^[\[{"0-9tfn\-]/.test(t)) {
+		try { JSON.parse(content); return "json"; } catch { /* not json */ }
+	}
+	return "rexc";
+}
+
+// ── Input reading ────────────────────────────────────────────
+
+async function readStdin(): Promise<string> {
+	const chunks: Buffer[] = [];
+	for await (const chunk of process.stdin) {
+		chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+type ParsedInput = { value: unknown };
+
+function parseRaw(raw: string, format: Format): unknown {
+	if (format === "json") return JSON.parse(raw);
+	return rexc.parse(raw.trim());
+}
+
+async function readInput(opts: RxOptions): Promise<ParsedInput> {
+	if (opts.files.length === 0) {
+		// stdin
+		if (process.stdin.isTTY) throw new Error("No input. Provide a file or pipe data via stdin.");
+		const raw = await readStdin();
+		if (!raw.trim()) throw new Error("Empty stdin.");
+		const format = opts.fromFormat ?? detectFormat(raw);
+		return { value: parseRaw(raw, format) };
+	}
+
+	if (opts.files.length === 1) {
+		const file = opts.files[0]!;
+		const raw = file === "-" ? await readStdin() : await readFile(file, "utf8");
+		const format = opts.fromFormat ?? (file === "-" ? detectFormat(raw) : formatFromExt(file) ?? detectFormat(raw));
+		return { value: parseRaw(raw, format) };
+	}
+
+	// Multiple files → array
+	const values: unknown[] = [];
+	for (const file of opts.files) {
+		const raw = file === "-" ? await readStdin() : await readFile(file, "utf8");
+		const format = opts.fromFormat ?? (file === "-" ? detectFormat(raw) : formatFromExt(file) ?? detectFormat(raw));
+		values.push(parseRaw(raw, format));
+	}
+	return { value: values };
+}
+
+// ── Selector ─────────────────────────────────────────────────
+
+type Segment = { type: "key"; name: string } | { type: "index"; value: number };
+
+function parseSelector(selector: string): Segment[] {
+	const segments: Segment[] = [];
+	const re = /\.([a-zA-Z_][\w-]*)|(\[(\d+)\])/g;
+	// Allow leading bare key without dot
+	let s = selector;
+	if (s.startsWith(".")) s = s; // keep as-is, regex handles it
+	else if (!s.startsWith("[")) s = "." + s; // prepend dot for bare key
+
+	let match: RegExpExecArray | null;
+	let lastIndex = 0;
+	while ((match = re.exec(s)) !== null) {
+		if (match.index !== lastIndex) {
+			throw new Error(`Invalid selector at position ${lastIndex}: ${selector}`);
+		}
+		if (match[1] !== undefined) {
+			segments.push({ type: "key", name: match[1] });
+		} else if (match[3] !== undefined) {
+			segments.push({ type: "index", value: parseInt(match[3], 10) });
+		}
+		lastIndex = re.lastIndex;
+	}
+	if (lastIndex !== s.length) {
+		throw new Error(`Invalid selector at position ${lastIndex}: ${selector}`);
+	}
+	return segments;
+}
+
+function applySelector(value: unknown, selector: string): unknown {
+	if (selector === "." || selector === "") return value;
+	const segments = parseSelector(selector);
+	let current = value;
+	let path = "";
+	for (const seg of segments) {
+		if (seg.type === "key") {
+			path += `.${seg.name}`;
+			if (current === null || current === undefined || typeof current !== "object" || Array.isArray(current)) {
+				throw new Error(`Selector ${path}: cannot access property '${seg.name}' on ${typeLabel(current)}`);
+			}
+			const obj = current as Record<string, unknown>;
+			if (!(seg.name in obj)) {
+				throw new Error(`Selector ${path}: property '${seg.name}' not found`);
+			}
+			current = obj[seg.name];
+		} else {
+			path += `[${seg.value}]`;
+			if (!Array.isArray(current)) {
+				throw new Error(`Selector ${path}: cannot index into ${typeLabel(current)}`);
+			}
+			if (seg.value < 0 || seg.value >= current.length) {
+				throw new Error(`Selector ${path}: index ${seg.value} out of range (length ${current.length})`);
+			}
+			current = current[seg.value];
+		}
+	}
+	return current;
+}
+
+function typeLabel(v: unknown): string {
+	if (v === null) return "null";
+	if (v === undefined) return "undefined";
+	if (Array.isArray(v)) return "array";
+	return typeof v;
+}
+
+// ── Output formatting ────────────────────────────────────────
+
+function formatTree(value: unknown, color: boolean): string {
+	const text = rexStringify(value, { indent: 2, maxWidth: 80 });
+	if (!color) return text;
+	return text.split("\n").map((line) => highlightLine(line)).join("\n");
+}
+
+function normalizeForJson(value: unknown, inArray: boolean): unknown {
+	if (value === undefined) return inArray ? null : undefined;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((item) => normalizeForJson(item, true));
+	const out: Record<string, unknown> = {};
+	for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+		const n = normalizeForJson(val, false);
+		if (n !== undefined) out[key] = n;
+	}
+	return out;
+}
+
+function formatOutput(value: unknown, format: OutputFormat, color: boolean): string {
+	if (format === "tree") return formatTree(value, color);
+	if (format === "json") {
+		const text = JSON.stringify(normalizeForJson(value, false), null, 2) ?? "null";
+		return color ? highlightJSON(text) : text;
+	}
+	// rexc
+	return rexc.stringify(value);
+}
+
+// ── Main ─────────────────────────────────────────────────────
+
+async function main() {
+	const opts = parseArgs(process.argv.slice(2));
+	if (opts.help) { console.log(usage()); return; }
+
+	setColorEnabled(opts.color);
+
+	const toFormat: OutputFormat = opts.toFormat
+		?? (process.stdout.isTTY ? "tree" : "json");
+
+	const { value: parsed } = await readInput(opts);
+
+	const value = opts.select ? applySelector(parsed, opts.select) : parsed;
+
+	const output = formatOutput(value, toFormat, opts.color);
+
+	if (opts.out) {
+		await writeFile(opts.out, output + "\n", "utf8");
+	} else {
+		process.stdout.write(output + "\n");
+	}
+}
+
+await main().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`rx: ${message}\n`);
+	process.exit(1);
+});