logixia 1.12.2 → 1.12.4

package/dist/cli/index.js

@@ -0,0 +1,1341 @@
+#!/usr/bin/env node
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let commander = require("commander");
+commander = __toESM(commander);
+let picocolors = require("picocolors");
+picocolors = __toESM(picocolors);
+
+//#region src/cli/utils.ts
+/**
+* Render a single cell value. Uses a null/undefined check rather than `||` so
+* falsy-but-real values (0, false, '') still render — a `count=0` or
+* `statusCode=0` field must not silently display as blank.
+*/
+function cellText(value) {
+	return value === null || value === void 0 ? "" : String(value);
+}
+function formatAsTable(rows, columns) {
+	const colWidths = columns.map((c) => Math.max(c.length, ...rows.map((r) => cellText(r[c]).length)));
+	return [
+		columns.map((c, i) => c.padEnd(colWidths[i] ?? 0)).join(" | "),
+		colWidths.map((w) => "-".repeat(w)).join("-|-"),
+		rows.map((r) => columns.map((c, i) => cellText(r[c]).padEnd(colWidths[i] ?? 0)).join(" | ")).join("\n")
+	].join("\n");
+}
+function safeParseLogs(raw) {
+	const lines = raw.split(/\r?\n/).filter(Boolean);
+	const parsed = [];
+	for (const l of lines) {
+		try {
+			const j = JSON.parse(l);
+			parsed.push(j);
+			continue;
+		} catch {}
+		parsed.push({ message: l });
+	}
+	return parsed;
+}
+
+//#endregion
+//#region src/cli/commands/analyze.ts
+function parseDurationToMs(input) {
+	if (!input) return;
+	const m = input.match(/^(\d+)([smhd])$/i);
+	if (!m) return;
+	const n = Number.parseInt(m[1], 10);
+	switch (m[2].toLowerCase()) {
+		case "s": return n * 1e3;
+		case "m": return n * 60 * 1e3;
+		case "h": return n * 60 * 60 * 1e3;
+		case "d": return n * 24 * 60 * 60 * 1e3;
+		default: return;
+	}
+}
+async function analyzeFileContents(raw, opts = {}) {
+	let filtered = safeParseLogs(raw);
+	const durMs = parseDurationToMs(opts.last);
+	if (durMs) {
+		const cutoff = Date.now() - durMs;
+		filtered = filtered.filter((e) => {
+			const row = e;
+			const ts = row["timestamp"] ? new Date(row["timestamp"]).getTime() : void 0;
+			if (!ts) return false;
+			return ts >= cutoff;
+		});
+	}
+	if (opts.level) filtered = filtered.filter((e) => (e["level"] ?? "").toLowerCase() === opts.level.toLowerCase());
+	const byLevel = {};
+	for (const e of filtered) {
+		const l = (e.level || "info").toUpperCase();
+		byLevel[l] = (byLevel[l] || 0) + 1;
+	}
+	if (opts.format === "json") return {
+		total: filtered.length,
+		byLevel
+	};
+	return formatAsTable(Object.keys(byLevel).map((k) => ({
+		level: k,
+		count: byLevel[k]
+	})), ["level", "count"]);
+}
+const analyzeCommand = new commander.Command("analyze").description("Analyze log files for patterns and insights").argument("<file>", "Path to log file").option("--level <level>", "Filter by log level").option("--last <range>", "Time range (e.g., 24h, 7d)").option("--format <fmt>", "Output format (table,json,csv)", "table").action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(`File not found: ${full}`);
+		process.exit(2);
+	}
+	const result = await analyzeFileContents(node_fs.default.readFileSync(full, "utf8"), opts);
+	if (opts.format === "json") {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	console.log(result);
+});
+
+//#endregion
+//#region src/cli/commands/explore.ts
+const CSI = "\x1B[";
+const clearScreen = CSI + "2J";
+const clearLine = CSI + "K";
+const hideCursor = CSI + "?25l";
+const showCursor = CSI + "?25h";
+const altScreen = CSI + "?1049h";
+const mainScreen = CSI + "?1049l";
+function moveTo(row, col) {
+	return `${CSI}${row};${col}H`;
+}
+function write(s) {
+	process.stdout.write(s);
+}
+const ANSI_STRIP_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+	return s.replace(ANSI_STRIP_RE, "");
+}
+function compose(...fns) {
+	return (s) => fns.reduceRight((acc, fn) => fn(acc), s);
+}
+const bgGray = picocolors.default.bgBlackBright;
+function normalizeLevel(level) {
+	if (typeof level === "number") {
+		if (level >= 50) return "error";
+		if (level >= 40) return "warn";
+		if (level >= 30) return "info";
+		if (level >= 20) return "debug";
+		return "trace";
+	}
+	return String(level ?? "info").toLowerCase();
+}
+function levelColor(level) {
+	switch (level) {
+		case "error": return compose(picocolors.default.bgRed, picocolors.default.white);
+		case "warn": return compose(picocolors.default.bgYellow, picocolors.default.black);
+		case "info": return compose(picocolors.default.bgBlue, picocolors.default.white);
+		case "debug": return compose(bgGray, picocolors.default.white);
+		case "trace": return compose(picocolors.default.bgMagenta, picocolors.default.white);
+		case "verbose": return compose(picocolors.default.bgCyan, picocolors.default.black);
+		default: return compose(bgGray, picocolors.default.white);
+	}
+}
+const LEVEL_SHORT = {
+	error: "ERR",
+	warn: "WRN",
+	info: "INF",
+	debug: "DBG",
+	trace: "TRC",
+	verbose: "VRB"
+};
+function levelBadge(level) {
+	const label = ` ${(LEVEL_SHORT[level] ?? level.slice(0, 3).toUpperCase()).padEnd(3)} `;
+	return levelColor(level)(label);
+}
+function formatTime(ts) {
+	if (!ts) return "            ";
+	try {
+		const d = new Date(String(ts));
+		if (Number.isNaN(d.getTime())) return String(ts).slice(0, 12).padEnd(12);
+		return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}.${String(d.getMilliseconds()).padStart(3, "0")}`;
+	} catch {
+		return String(ts).slice(0, 12).padEnd(12);
+	}
+}
+function syntaxColorJson(line) {
+	return line.replace(/"([^"]+)":/g, (_, k) => picocolors.default.cyan(`"${k}"`) + ":").replace(/: "([^"]*)"/g, (_, v) => ": " + picocolors.default.green(`"${v}"`)).replace(/: (-?\d+(?:\.\d+)?)/g, (_, v) => ": " + picocolors.default.yellow(v)).replace(/: (true|false)/g, (_, v) => ": " + picocolors.default.magenta(v)).replace(/: null/g, ": " + picocolors.default.dim("null"));
+}
+function coloriseStackFrame(frame) {
+	const trimmed = frame.trim();
+	if (!trimmed.startsWith("at ")) return picocolors.default.dim("  " + trimmed);
+	const withoutAt = trimmed.slice(3);
+	const parenOpen = withoutAt.lastIndexOf("(");
+	const parenClose = withoutAt.lastIndexOf(")");
+	if (parenOpen !== -1 && parenClose > parenOpen) {
+		const name = withoutAt.slice(0, parenOpen).trimEnd();
+		const loc = withoutAt.slice(parenOpen + 1, parenClose);
+		return "    " + picocolors.default.dim("at ") + picocolors.default.cyan(name) + " " + picocolors.default.dim("(" + loc + ")");
+	}
+	return "    " + picocolors.default.dim("at ") + picocolors.default.cyan(withoutAt);
+}
+function buildDetailLines(entry) {
+	if (!entry) return [picocolors.default.dim("  No entry selected")];
+	const lines = [];
+	const { stack,...rest } = entry;
+	const jsonText = JSON.stringify(rest, null, 2);
+	for (const l of jsonText.split("\n")) lines.push("  " + syntaxColorJson(l));
+	if (stack) {
+		lines.push("");
+		lines.push(picocolors.default.bold(picocolors.default.red("  ▼ STACK TRACE")));
+		for (const sl of String(stack).split("\n")) {
+			if (!sl.trim()) continue;
+			if (sl.trim().startsWith("at ")) lines.push(coloriseStackFrame(sl));
+			else lines.push("  " + picocolors.default.red(sl.trim()));
+		}
+	}
+	return lines;
+}
+var TUIExplorer = class {
+	get LIST_ROWS() {
+		return Math.max(4, this.height - this.HEADER_ROWS - this.STATUS_ROWS - this.DETAIL_ROWS);
+	}
+	constructor(filePath, opts) {
+		this.opts = opts;
+		this.allEntries = [];
+		this.filteredEntries = [];
+		this.selectedIndex = 0;
+		this.listScrollOffset = 0;
+		this.detailScrollOffset = 0;
+		this.searchQuery = "";
+		this.searchMode = false;
+		this.searchBuffer = "";
+		this.exportMode = false;
+		this.exportBuffer = "";
+		this.filePos = 0;
+		this.width = 80;
+		this.height = 24;
+		this.HEADER_ROWS = 3;
+		this.STATUS_ROWS = 1;
+		this.DETAIL_ROWS = 9;
+		this.filePath = node_path.default.resolve(process.cwd(), filePath);
+		this.levelFilters = new Set([
+			"error",
+			"warn",
+			"info",
+			"debug",
+			"trace",
+			"verbose"
+		]);
+		if (opts.levels) this.levelFilters = new Set(opts.levels.split(",").map((l) => l.trim().toLowerCase()).filter(Boolean));
+		if (opts.search) this.searchQuery = opts.search;
+		this.followMode = opts.follow;
+	}
+	run() {
+		if (!node_fs.default.existsSync(this.filePath)) {
+			console.error(picocolors.default.red(`File not found: ${this.filePath}`));
+			process.exit(2);
+		}
+		const raw = node_fs.default.readFileSync(this.filePath, "utf8");
+		this.filePos = node_fs.default.statSync(this.filePath).size;
+		this.allEntries = safeParseLogs(raw);
+		this.applyFilters();
+		write(altScreen + hideCursor);
+		this.getTerminalSize();
+		process.stdout.on("resize", () => {
+			this.getTerminalSize();
+			this.redraw();
+		});
+		if (process.stdin.isTTY) process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdin.on("data", (buf) => {
+			this.handleKey(buf);
+		});
+		if (this.followMode) this.startFollow();
+		this.redraw();
+	}
+	getTerminalSize() {
+		this.width = process.stdout.columns || 80;
+		this.height = process.stdout.rows || 24;
+	}
+	applyFilters() {
+		this.filteredEntries = this.allEntries.filter((entry) => {
+			const lvl = normalizeLevel(entry.level);
+			if (!this.levelFilters.has(lvl)) return false;
+			if (this.searchQuery) {
+				if (!JSON.stringify(entry).toLowerCase().includes(this.searchQuery.toLowerCase())) return false;
+			}
+			return true;
+		});
+		if (this.selectedIndex >= this.filteredEntries.length) this.selectedIndex = Math.max(0, this.filteredEntries.length - 1);
+		this.clampScroll();
+	}
+	clampScroll() {
+		const lr = this.LIST_ROWS;
+		if (this.selectedIndex < this.listScrollOffset) this.listScrollOffset = this.selectedIndex;
+		if (this.selectedIndex >= this.listScrollOffset + lr) this.listScrollOffset = this.selectedIndex - lr + 1;
+		this.listScrollOffset = Math.max(0, this.listScrollOffset);
+	}
+	redraw() {
+		write(clearScreen + moveTo(1, 1));
+		this.drawHeader();
+		this.drawFilterBar();
+		this.drawColHeader();
+		this.drawList();
+		this.drawDetailPanel();
+		this.drawStatusBar();
+	}
+	pad(s, len) {
+		if (s.length >= len) return s.slice(0, len);
+		return s + " ".repeat(len - s.length);
+	}
+	truncate(s, len) {
+		if (len <= 0) return "";
+		if (s.length <= len) return s;
+		return s.slice(0, len - 1) + "…";
+	}
+	drawHeader() {
+		const w = this.width;
+		const title = compose(picocolors.default.bgWhite, picocolors.default.black, picocolors.default.bold)(" LOGIXIA EXPLORE ");
+		const fname = picocolors.default.cyan(` ${node_path.default.basename(this.filePath)} `);
+		const count = picocolors.default.dim(`[${this.filteredEntries.length}/${this.allEntries.length}]`);
+		const follow = this.followMode ? picocolors.default.green(" ⟳ FOLLOW") : "";
+		const search = this.searchQuery ? picocolors.default.yellow(` /${this.searchQuery}`) : "";
+		const left = ` ${title}${fname}`;
+		const right = count + follow + search + " ";
+		const leftLen = stripAnsi(left).length;
+		const rightLen = stripAnsi(right).length;
+		const gap = Math.max(1, w - leftLen - rightLen);
+		write(moveTo(1, 1) + picocolors.default.bgBlack(left + " ".repeat(gap) + right) + clearLine + "\n");
+	}
+	drawFilterBar() {
+		const badges = [
+			["error", "E"],
+			["warn", "W"],
+			["info", "I"],
+			["debug", "D"],
+			["trace", "T"],
+			["verbose", "V"]
+		].map(([lvl, key]) => {
+			return this.levelFilters.has(lvl) ? levelColor(lvl)(` ${key} `) : compose(picocolors.default.dim, picocolors.default.strikethrough)(` ${key} `);
+		}).join(" ");
+		const searchPart = this.searchMode ? compose(picocolors.default.bgYellow, picocolors.default.black)(` /${this.searchBuffer}█ `) : picocolors.default.dim("  /: search ");
+		const w = this.width;
+		const left = "  " + badges;
+		const right = searchPart + " ";
+		const gap = Math.max(1, w - stripAnsi(left).length - stripAnsi(right).length);
+		write(moveTo(2, 1) + picocolors.default.bgBlack(left + " ".repeat(gap) + right) + clearLine + "\n");
+	}
+	drawColHeader() {
+		const w = this.width;
+		const timeCol = " TIME         ";
+		const levelCol = " LVL ";
+		const msgWidth = Math.max(20, w - 14 - 5 - 2);
+		write(moveTo(3, 1) + compose(picocolors.default.bold, picocolors.default.bgBlack, picocolors.default.dim)(timeCol + levelCol + " " + this.pad("MESSAGE", msgWidth)) + clearLine + "\n");
+	}
+	drawList() {
+		const lr = this.LIST_ROWS;
+		const w = this.width;
+		const msgWidth = Math.max(10, w - 13 - 5 - 3);
+		for (let row = 0; row < lr; row++) {
+			const entryIdx = this.listScrollOffset + row;
+			write(moveTo(this.HEADER_ROWS + row + 1, 1));
+			if (entryIdx >= this.filteredEntries.length) {
+				write(picocolors.default.bgBlack(" ".repeat(w)) + clearLine);
+				continue;
+			}
+			const entry = this.filteredEntries[entryIdx];
+			const isSelected = entryIdx === this.selectedIndex;
+			const level = normalizeLevel(entry.level);
+			const time = formatTime(entry.timestamp);
+			const msg = String(entry.message ?? "");
+			const extraFields = Object.entries(entry).filter(([k]) => ![
+				"timestamp",
+				"level",
+				"message",
+				"stack"
+			].includes(k)).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : String(v)}`).join(" ");
+			const msgSlot = Math.floor(msgWidth * .65);
+			const msgPart = this.truncate(msg, msgSlot);
+			const extraPart = this.truncate(extraFields, msgWidth - msgPart.length - 2);
+			const msgDisplay = msgPart + (extraPart ? picocolors.default.dim("  " + extraPart) : "");
+			const line = ` ${time} ` + levelBadge(level) + " " + this.pad(msgDisplay, msgWidth);
+			if (isSelected) {
+				const plain = this.pad(stripAnsi(line), w);
+				write(compose(picocolors.default.bgWhite, picocolors.default.black)(plain));
+			} else if (this.searchQuery) write(this.highlightSearch(this.truncate(line, w)));
+			else write(this.truncate(line, w));
+			write(clearLine);
+		}
+	}
+	drawDetailPanel() {
+		const w = this.width;
+		const sepRow = this.HEADER_ROWS + this.LIST_ROWS + 1;
+		const selected = this.filteredEntries[this.selectedIndex];
+		const label = selected ? ` ▼ DETAIL  (${this.selectedIndex + 1}/${this.filteredEntries.length}) ` : " ▼ DETAIL ";
+		const labelLen = stripAnsi(label).length;
+		const sepLine = compose(picocolors.default.bgBlack, picocolors.default.cyan, picocolors.default.bold)(label) + picocolors.default.dim("─".repeat(Math.max(0, w - labelLen)));
+		write(moveTo(sepRow, 1) + sepLine + clearLine + "\n");
+		const lines = buildDetailLines(selected);
+		for (let row = 0; row < 8; row++) {
+			write(moveTo(sepRow + 1 + row, 1));
+			const lineIdx = this.detailScrollOffset + row;
+			if (lineIdx < lines.length) write(this.truncate(lines[lineIdx], w) + clearLine);
+			else write(picocolors.default.bgBlack(" ".repeat(w)) + clearLine);
+		}
+	}
+	drawStatusBar() {
+		const statusRow = this.height;
+		const bar = "  " + [
+			picocolors.default.bold("j/k") + " move",
+			picocolors.default.bold("/") + " search",
+			picocolors.default.bold("x") + " export",
+			picocolors.default.bold("E/W/I/D/T/V") + " filter",
+			picocolors.default.bold("J/K") + " detail↕",
+			picocolors.default.bold("f") + " follow",
+			picocolors.default.bold("g/G") + " top/bot",
+			picocolors.default.bold("q") + " quit"
+		].join(picocolors.default.dim("  │  "));
+		write(moveTo(statusRow, 1) + compose(picocolors.default.bgBlack, picocolors.default.dim)(this.truncate(bar, this.width)) + clearLine);
+		if (this.exportMode) {
+			const promptRow = this.height - 1;
+			const prompt = compose(picocolors.default.bgYellow, picocolors.default.black)(` Export path (.json/.csv/.ndjson, blank=cancel): ${this.exportBuffer}█ `);
+			write(moveTo(promptRow, 1) + prompt + clearLine);
+		}
+	}
+	handleKey(buf) {
+		const key = buf.toString("utf8");
+		if (key === "") {
+			this.cleanup();
+			return;
+		}
+		if (this.exportMode) {
+			this.handleExportKey(key);
+			return;
+		}
+		if (this.searchMode) {
+			this.handleSearchKey(key);
+			return;
+		}
+		switch (key) {
+			case "j":
+			case "\x1B[B":
+				this.moveSelection(1);
+				break;
+			case "k":
+			case "\x1B[A":
+				this.moveSelection(-1);
+				break;
+			case "g":
+			case "\x1B[1~":
+				this.selectedIndex = 0;
+				this.listScrollOffset = 0;
+				this.detailScrollOffset = 0;
+				break;
+			case "G":
+			case "\x1B[4~":
+				this.selectedIndex = Math.max(0, this.filteredEntries.length - 1);
+				this.clampScroll();
+				this.detailScrollOffset = 0;
+				break;
+			case "\x1B[5~":
+				this.moveSelection(-this.LIST_ROWS);
+				break;
+			case "\x1B[6~":
+				this.moveSelection(this.LIST_ROWS);
+				break;
+			case "J":
+				this.detailScrollOffset++;
+				break;
+			case "K":
+				this.detailScrollOffset = Math.max(0, this.detailScrollOffset - 1);
+				break;
+			case "/":
+				this.searchMode = true;
+				this.searchBuffer = this.searchQuery;
+				break;
+			case "E":
+				this.toggleLevel("error");
+				break;
+			case "W":
+				this.toggleLevel("warn");
+				break;
+			case "I":
+				this.toggleLevel("info");
+				break;
+			case "D":
+				this.toggleLevel("debug");
+				break;
+			case "T":
+				this.toggleLevel("trace");
+				break;
+			case "V":
+				this.toggleLevel("verbose");
+				break;
+			case "f":
+				this.followMode = !this.followMode;
+				if (this.followMode) this.startFollow();
+				else {
+					node_fs.default.unwatchFile(this.filePath);
+					this.fileWatcher = void 0;
+				}
+				break;
+			case "x":
+				this.exportMode = true;
+				this.exportBuffer = "";
+				break;
+			case "q":
+				this.cleanup();
+				return;
+			default: break;
+		}
+		this.redraw();
+	}
+	handleSearchKey(key) {
+		if (key === "\r" || key === "\n") {
+			this.searchQuery = this.searchBuffer;
+			this.searchMode = false;
+			this.applyFilters();
+		} else if (key === "\x1B" || key === "\x1B\x1B") {
+			this.searchMode = false;
+			this.searchBuffer = "";
+			this.searchQuery = "";
+			this.applyFilters();
+		} else if (key === "" || key === "\b") this.searchBuffer = this.searchBuffer.slice(0, -1);
+		else if (key.length === 1 && key >= " ") this.searchBuffer += key;
+		this.redraw();
+	}
+	handleExportKey(key) {
+		if (key === "\r" || key === "\n") {
+			this.exportMode = false;
+			if (this.exportBuffer.trim()) this.doExport(this.exportBuffer.trim());
+			this.redraw();
+		} else if (key === "\x1B") {
+			this.exportMode = false;
+			this.exportBuffer = "";
+			this.redraw();
+		} else if (key === "" || key === "\b") {
+			this.exportBuffer = this.exportBuffer.slice(0, -1);
+			this.redraw();
+		} else if (key.length === 1 && key >= " ") {
+			this.exportBuffer += key;
+			this.redraw();
+		}
+	}
+	doExport(outPath) {
+		const resolved = node_path.default.resolve(process.cwd(), outPath);
+		const ext = node_path.default.extname(outPath).toLowerCase();
+		try {
+			if (ext === ".csv") {
+				const entries = this.filteredEntries;
+				const allKeys = [...new Set(entries.flatMap((e) => Object.keys(e)))];
+				const header = allKeys.join(",");
+				const rows = entries.map((e) => allKeys.map((k) => {
+					const v = e[k];
+					return `"${(typeof v === "string" ? v : JSON.stringify(v ?? "")).replace(/"/g, "\"\"")}"`;
+				}).join(","));
+				node_fs.default.writeFileSync(resolved, [header, ...rows].join("\n"), "utf8");
+			} else if (ext === ".ndjson" || ext === ".jsonl") node_fs.default.writeFileSync(resolved, this.filteredEntries.map((e) => JSON.stringify(e)).join("\n"), "utf8");
+			else node_fs.default.writeFileSync(resolved, JSON.stringify(this.filteredEntries, null, 2), "utf8");
+			write(moveTo(this.height - 1, 1) + compose(picocolors.default.bgGreen, picocolors.default.black)(` ✓ Exported ${this.filteredEntries.length} entries → ${resolved} `) + clearLine);
+			setTimeout(() => {
+				this.redraw();
+			}, 2e3);
+		} catch (err) {
+			write(moveTo(this.height - 1, 1) + compose(picocolors.default.bgRed, picocolors.default.white)(` ✗ Export failed: ${String(err.message)} `) + clearLine);
+			setTimeout(() => {
+				this.redraw();
+			}, 2e3);
+		}
+	}
+	moveSelection(delta) {
+		const max = Math.max(0, this.filteredEntries.length - 1);
+		this.selectedIndex = Math.max(0, Math.min(max, this.selectedIndex + delta));
+		this.detailScrollOffset = 0;
+		this.clampScroll();
+	}
+	toggleLevel(level) {
+		if (this.levelFilters.has(level)) {
+			if (this.levelFilters.size > 1) this.levelFilters.delete(level);
+		} else this.levelFilters.add(level);
+		this.applyFilters();
+	}
+	startFollow() {
+		this.fileWatcher = node_fs.default.watchFile(this.filePath, { interval: 500 }, (curr) => {
+			if (curr.size <= this.filePos) return;
+			try {
+				const rs = node_fs.default.createReadStream(this.filePath, {
+					start: this.filePos,
+					end: curr.size,
+					encoding: "utf8"
+				});
+				let buf = "";
+				rs.on("data", (chunk) => {
+					buf += String(chunk);
+				});
+				rs.on("end", () => {
+					this.filePos = curr.size;
+					const newEntries = safeParseLogs(buf);
+					this.allEntries.push(...newEntries);
+					this.applyFilters();
+					this.selectedIndex = Math.max(0, this.filteredEntries.length - 1);
+					this.clampScroll();
+					this.redraw();
+				});
+			} catch {}
+		});
+	}
+	highlightSearch(line) {
+		if (!this.searchQuery) return line;
+		const plain = stripAnsi(line);
+		const lower = plain.toLowerCase();
+		const needle = this.searchQuery.toLowerCase();
+		let result = "";
+		let i = 0;
+		while (i < plain.length) {
+			const idx = lower.indexOf(needle, i);
+			if (idx === -1) {
+				result += plain.slice(i);
+				break;
+			}
+			result += plain.slice(i, idx) + compose(picocolors.default.bgYellow, picocolors.default.black)(plain.slice(idx, idx + needle.length));
+			i = idx + needle.length;
+		}
+		return result;
+	}
+	cleanup() {
+		if (this.fileWatcher) node_fs.default.unwatchFile(this.filePath);
+		write(showCursor + mainScreen);
+		if (process.stdin.isTTY) process.stdin.setRawMode(false);
+		process.stdin.pause();
+		process.exit(0);
+	}
+};
+const exploreCommand = new commander.Command("explore").description("Interactive TUI log explorer with real-time search, level filters, and export").argument("<file>", "Path to log file (NDJSON / JSON-lines)").option("--follow", "Follow file changes in real-time", false).option("--levels <levels>", "Comma-separated levels to show (e.g. error,warn,info)", "").option("--search <query>", "Pre-populate the search field", "").action((file, opts) => {
+	new TUIExplorer(file, {
+		follow: Boolean(opts.follow),
+		levels: String(opts.levels ?? ""),
+		search: String(opts.search ?? "")
+	}).run();
+});
+
+//#endregion
+//#region src/cli/commands/export.ts
+async function exportLogs(raw, opts = {}) {
+	const entries = safeParseLogs(raw);
+	const fields = opts.fields ? opts.fields.split(",").map((f) => f.trim()) : null;
+	if (opts.format === "csv") return exportAsCSV(entries, fields);
+	else if (opts.format === "json") return exportAsJSON(entries, fields);
+	return JSON.stringify(entries, null, 2);
+}
+function exportAsCSV(entries, fields) {
+	if (entries.length === 0) return "";
+	const columns = fields || Object.keys(entries[0] || {});
+	const lines = [];
+	lines.push(columns.join(","));
+	for (const entry of entries) {
+		const row = columns.map((col) => {
+			const value = entry[col];
+			if (value === void 0 || value === null) return "";
+			const str = String(value);
+			if (str.includes(",") || str.includes("\"") || str.includes("\n")) return `"${str.replace(/"/g, "\"\"")}"`;
+			return str;
+		});
+		lines.push(row.join(","));
+	}
+	return lines.join("\n");
+}
+function exportAsJSON(entries, fields) {
+	if (!fields) return JSON.stringify(entries, null, 2);
+	const filtered = entries.map((entry) => {
+		const obj = {};
+		for (const field of fields) if (entry[field] !== void 0) obj[field] = entry[field];
+		return obj;
+	});
+	return JSON.stringify(filtered, null, 2);
+}
+const exportCommand = new commander.Command("export").description("Export log files to different formats").argument("<file>", "Path to log file").option("--format <fmt>", "Output format (csv, json)", "json").option("--fields <fields>", "Comma-separated list of fields to export (e.g., timestamp,level,message)").option("--output <file>", "Output file path (default: stdout)").action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(`File not found: ${full}`);
+		process.exit(2);
+	}
+	const output = await exportLogs(node_fs.default.readFileSync(full, "utf8"), opts);
+	if (opts.output) {
+		const outPath = node_path.default.resolve(process.cwd(), opts.output);
+		node_fs.default.writeFileSync(outPath, output, "utf8");
+		console.log(`Exported to: ${outPath}`);
+	} else console.log(output);
+});
+
+//#endregion
+//#region src/cli/commands/query.ts
+/**
+* Parse a human-friendly time range string into a `Date`.
+* Returns `undefined` when the string is not recognised.
+*
+* Supported formats:
+*  - "last N minutes" / "last N hours" / "last N days"
+*  - "today"  → start of today (00:00:00)
+*  - "yesterday" → start of yesterday
+*  - ISO 8601 or any string parseable by `new Date()`
+*/
+function parseTimeRange(value) {
+	const norm = value.trim().toLowerCase();
+	if (norm === "today") {
+		const d = /* @__PURE__ */ new Date();
+		d.setHours(0, 0, 0, 0);
+		return d;
+	}
+	if (norm === "yesterday") {
+		const d = /* @__PURE__ */ new Date();
+		d.setDate(d.getDate() - 1);
+		d.setHours(0, 0, 0, 0);
+		return d;
+	}
+	const relMatch = norm.match(/^last\s+(\d+)\s+(minute|minutes|min|hour|hours|day|days|week|weeks)$/);
+	if (relMatch) {
+		const n = Number(relMatch[1]);
+		const unit = relMatch[2];
+		let ms;
+		if (unit.startsWith("min")) ms = n * 6e4;
+		else if (unit.startsWith("hour")) ms = n * 36e5;
+		else if (unit.startsWith("day")) ms = n * 864e5;
+		else ms = n * 7 * 864e5;
+		return new Date(Date.now() - ms);
+	}
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+}
+function parseSQL(sql) {
+	const result = {
+		select: "*",
+		where: null,
+		aggregation: null,
+		orderBy: null,
+		limit: null
+	};
+	const upper = sql.trim().toUpperCase();
+	{
+		const m = /^COUNT\s+BY\s+(\w+)/i.exec(sql.trim());
+		if (m) {
+			result.aggregation = {
+				fn: "COUNT",
+				field: null,
+				groupBy: m[1]
+			};
+			return result;
+		}
+	}
+	{
+		const m = /^GROUP\s+BY\s+(\w+)/i.exec(sql.trim());
+		if (m) {
+			result.aggregation = {
+				fn: "GROUP",
+				field: null,
+				groupBy: m[1]
+			};
+			return result;
+		}
+	}
+	{
+		const m = /^(AVG|SUM|MIN|MAX)\((\w+)\)\s+BY\s+(\w+)/i.exec(sql.trim());
+		if (m) {
+			result.aggregation = {
+				fn: m[1].toUpperCase(),
+				field: m[2],
+				groupBy: m[3]
+			};
+			return result;
+		}
+	}
+	if (upper.startsWith("SELECT")) {
+		const fromIdx = upper.indexOf(" FROM ");
+		if (fromIdx !== -1) {
+			const selectPart = sql.slice(6, fromIdx + sql.length - upper.length).trim();
+			if (selectPart !== "*") result.select = selectPart.split(",").map((s) => s.trim()).filter(Boolean);
+		}
+	}
+	const remainder = sql.trim();
+	const whereTokenIdx = remainder.toUpperCase().indexOf("WHERE ");
+	if (whereTokenIdx !== -1) {
+		const afterWhere = remainder.slice(whereTokenIdx + 6).trimStart();
+		const upperAfter = afterWhere.toUpperCase();
+		const candidates = [upperAfter.indexOf(" ORDER BY "), upperAfter.indexOf(" LIMIT ")].filter((i) => i !== -1);
+		const endIdx = candidates.length > 0 ? Math.min(...candidates) : afterWhere.length;
+		result.where = parseWhereClause(afterWhere.slice(0, endIdx).trim());
+	}
+	const orderMatch = /ORDER\s+BY\s+(\w+)(?:\s+(ASC|DESC))?/i.exec(remainder);
+	if (orderMatch) {
+		var _orderMatch$;
+		result.orderBy = {
+			field: orderMatch[1],
+			dir: ((_orderMatch$ = orderMatch[2]) === null || _orderMatch$ === void 0 ? void 0 : _orderMatch$.toUpperCase()) ?? "ASC"
+		};
+	}
+	const limitMatch = /LIMIT\s+(\d+)/i.exec(remainder);
+	if (limitMatch) result.limit = Number.parseInt(limitMatch[1], 10);
+	return result;
+}
+/**
+* Split `clause` on a top-level ` AND ` / ` OR ` keyword, ignoring the keyword
+* inside quoted values (e.g. `message LIKE 'foo OR bar'`). Scans with a
+* bounded index walk rather than a regex quantifier so the parser stays
+* ReDoS-safe.
+*/
+function splitTopLevel(clause, keyword) {
+	const separator = ` ${keyword} `;
+	const upper = clause.toUpperCase();
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let i = 0;
+	while (i < clause.length) {
+		const ch = clause[i];
+		if (quote !== null) {
+			current += ch;
+			if (ch === quote) quote = null;
+			i += 1;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			current += ch;
+			i += 1;
+			continue;
+		}
+		if (upper.startsWith(separator, i)) {
+			parts.push(current.trim());
+			current = "";
+			i += separator.length;
+			continue;
+		}
+		current += ch;
+		i += 1;
+	}
+	parts.push(current.trim());
+	return parts.filter(Boolean);
+}
+/**
+* Parse a WHERE clause into an AND/OR tree. AND binds tighter than OR, so the
+* clause is first split on top-level `OR`, then each OR branch on top-level
+* `AND`. A single top-level condition is returned unwrapped.
+*/
+function parseWhereClause(clause) {
+	const orBranches = splitTopLevel(clause.replace(/\s+/g, " ").trim(), "OR").map((orPart) => {
+		const conditions = splitTopLevel(orPart, "AND").map((part) => parseCondition(part)).filter((cond) => cond !== null);
+		if (conditions.length === 1) return conditions[0];
+		return {
+			type: "AND",
+			conditions
+		};
+	});
+	if (orBranches.length === 0) return {
+		type: "AND",
+		conditions: []
+	};
+	if (orBranches.length === 1) return orBranches[0];
+	return {
+		type: "OR",
+		conditions: orBranches
+	};
+}
+/** Longest operators first so `>=` / `<=` / `!=` are matched before `>` / `<` / `=`. */
+const COMPARISON_OPS = [
+	">=",
+	"<=",
+	"!=",
+	">",
+	"<",
+	"="
+];
+/** Strip a single matching pair of surrounding single or double quotes. */
+function stripQuotes(value) {
+	if (value.length >= 2) {
+		const first = value[0];
+		const last = value[value.length - 1];
+		if (first === "'" && last === "'" || first === "\"" && last === "\"") return value.slice(1, -1);
+	}
+	return value;
+}
+function parseCondition(expr) {
+	const trimmed = expr.trim();
+	const fieldMatch = /^(\w+)/.exec(trimmed);
+	if (!fieldMatch) return null;
+	const field = fieldMatch[1];
+	const rest = trimmed.slice(field.length).trimStart();
+	const notLikePrefix = /^NOT\s+LIKE\s+/i.exec(rest);
+	if (notLikePrefix) return {
+		field,
+		op: "NOT LIKE",
+		value: stripQuotes(rest.slice(notLikePrefix[0].length).trim()),
+		caseless: true
+	};
+	const likePrefix = /^LIKE\s+/i.exec(rest);
+	if (likePrefix) return {
+		field,
+		op: "LIKE",
+		value: stripQuotes(rest.slice(likePrefix[0].length).trim()),
+		caseless: true
+	};
+	const notInPrefix = /^NOT\s+IN\s*\(/i.exec(rest);
+	if (notInPrefix) return {
+		field,
+		op: "NOT IN",
+		value: rest.slice(notInPrefix[0].length, rest.lastIndexOf(")")).split(",").map((v) => v.trim().replace(/^'|'$/g, ""))
+	};
+	const inPrefix = /^IN\s*\(/i.exec(rest);
+	if (inPrefix) return {
+		field,
+		op: "IN",
+		value: rest.slice(inPrefix[0].length, rest.lastIndexOf(")")).split(",").map((v) => v.trim().replace(/^'|'$/g, ""))
+	};
+	for (const op of COMPARISON_OPS) if (rest.startsWith(op)) {
+		const rawValue = rest.slice(op.length).trim().replace(/^'|'$/g, "");
+		const numValue = Number(rawValue);
+		return {
+			field,
+			op,
+			value: Number.isNaN(numValue) ? rawValue : numValue
+		};
+	}
+	return null;
+}
+function matchesCondition(row, cond) {
+	const rawFieldValue = row[cond.field];
+	if (rawFieldValue === void 0) return false;
+	const fieldStr = String(rawFieldValue).toLowerCase();
+	const condStr = cond.caseless ? String(cond.value).toLowerCase() : String(cond.value);
+	switch (cond.op) {
+		case "=": return String(rawFieldValue) === String(cond.value);
+		case "!=": return String(rawFieldValue) !== String(cond.value);
+		case ">": return Number(rawFieldValue) > Number(cond.value);
+		case ">=": return Number(rawFieldValue) >= Number(cond.value);
+		case "<": return Number(rawFieldValue) < Number(cond.value);
+		case "<=": return Number(rawFieldValue) <= Number(cond.value);
+		case "LIKE": {
+			const pattern = condStr.replace(/%/g, ".*").replace(/_/g, ".");
+			return new RegExp(`^${pattern}$`, "i").test(fieldStr);
+		}
+		case "NOT LIKE": {
+			const pattern = condStr.replace(/%/g, ".*").replace(/_/g, ".");
+			return !new RegExp(`^${pattern}$`, "i").test(fieldStr);
+		}
+		case "IN": return cond.value.some((v) => String(rawFieldValue) === v);
+		case "NOT IN": return !cond.value.some((v) => String(rawFieldValue) === v);
+		default: return false;
+	}
+}
+function matchesWhere(row, where) {
+	if (!where) return true;
+	return matchesNode(row, where);
+}
+/** Evaluate a WHERE tree: AND over its children, OR over its children. */
+function matchesNode(row, node) {
+	if ("op" in node) return matchesCondition(row, node);
+	const children = node.conditions;
+	if (children.length === 0) return true;
+	return node.type === "AND" ? children.every((child) => matchesNode(row, child)) : children.some((child) => matchesNode(row, child));
+}
+function runAggregation(entries, agg) {
+	const { fn, field, groupBy } = agg;
+	if (!groupBy) return picocolors.default.yellow("Aggregation requires a GROUP BY field");
+	const groups = {};
+	for (const entry of entries) {
+		const key = String(entry[groupBy] ?? "(empty)");
+		if (!groups[key]) groups[key] = [];
+		groups[key].push(entry);
+	}
+	if (fn === "COUNT" || fn === "GROUP") return formatAsTable(Object.entries(groups).map(([k, v]) => ({
+		[groupBy]: k,
+		count: v.length
+	})).sort((a, b) => b.count - a.count), [groupBy, "count"]);
+	if (!field) return picocolors.default.yellow("Numeric aggregation requires a field: AVG(field) BY group");
+	return formatAsTable(Object.entries(groups).map(([k, v]) => {
+		const nums = v.map((e) => Number(e[field])).filter((n) => !Number.isNaN(n));
+		let result;
+		switch (fn) {
+			case "AVG":
+				result = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : 0;
+				break;
+			case "SUM":
+				result = nums.reduce((a, b) => a + b, 0);
+				break;
+			case "MIN":
+				result = nums.length ? Math.min(...nums) : 0;
+				break;
+			case "MAX":
+				result = nums.length ? Math.max(...nums) : 0;
+				break;
+			default: result = 0;
+		}
+		return {
+			[groupBy]: k,
+			[`${fn}(${field})`]: Math.round(result * 100) / 100,
+			count: v.length
+		};
+	}).sort((a, b) => {
+		const key = `${fn}(${field})`;
+		return b[key] - a[key];
+	}), [
+		groupBy,
+		`${fn}(${field})`,
+		"count"
+	]);
+}
+function projectRow(row, select) {
+	if (select === "*") return row;
+	const projected = {};
+	for (const field of select) projected[field] = row[field];
+	return projected;
+}
+function formatResults(results, format) {
+	if (results.length === 0) return picocolors.default.yellow("No results found");
+	if (format === "json") return JSON.stringify(results, null, 2);
+	if (format === "ndjson") return results.map((r) => JSON.stringify(r)).join("\n");
+	if (format === "table") return formatAsTable(results, Object.keys(results[0] || {}).slice(0, 6));
+	return results.map((r) => {
+		const level = (r.level || "").toUpperCase();
+		const line = JSON.stringify(r);
+		if (level === "ERROR" || level === "CRITICAL") return picocolors.default.red(line);
+		if (level === "WARN") return picocolors.default.yellow(line);
+		if (level === "DEBUG" || level === "VERBOSE") return picocolors.default.gray(line);
+		return line;
+	}).join("\n");
+}
+function executeQuery(entries, opts) {
+	var _query$orderBy;
+	let rows = entries;
+	const sinceDate = opts.since ? parseTimeRange(opts.since) : void 0;
+	const untilDate = opts.until ? parseTimeRange(opts.until) : void 0;
+	if (sinceDate || untilDate) rows = rows.filter((row) => {
+		const ts = row.timestamp ? new Date(row.timestamp) : null;
+		if (!ts || Number.isNaN(ts.getTime())) return true;
+		if (sinceDate && ts < sinceDate) return false;
+		if (untilDate && ts > untilDate) return false;
+		return true;
+	});
+	const query = opts.sql ? parseSQL(opts.sql) : {
+		select: "*",
+		where: null,
+		aggregation: null,
+		orderBy: null,
+		limit: null
+	};
+	if (query.where) rows = rows.filter((row) => matchesWhere(row, query.where));
+	if (query.aggregation) return {
+		results: [],
+		aggregationOutput: runAggregation(rows, query.aggregation)
+	};
+	rows = rows.map((row) => projectRow(row, query.select));
+	const orderField = ((_query$orderBy = query.orderBy) === null || _query$orderBy === void 0 ? void 0 : _query$orderBy.field) ?? opts.orderBy;
+	if (orderField) {
+		var _query$orderBy2;
+		const dir = ((_query$orderBy2 = query.orderBy) === null || _query$orderBy2 === void 0 ? void 0 : _query$orderBy2.dir) ?? "ASC";
+		rows.sort((a, b) => {
+			const av = a[orderField];
+			const bv = b[orderField];
+			if (av === void 0 && bv === void 0) return 0;
+			if (av === void 0) return dir === "ASC" ? 1 : -1;
+			if (bv === void 0) return dir === "ASC" ? -1 : 1;
+			if (typeof av === "number" && typeof bv === "number") return dir === "ASC" ? av - bv : bv - av;
+			return dir === "ASC" ? String(av).localeCompare(String(bv)) : String(bv).localeCompare(String(av));
+		});
+	}
+	const limitN = query.limit ?? opts.limit;
+	if (limitN && limitN > 0) rows = rows.slice(0, limitN);
+	return {
+		results: rows,
+		aggregationOutput: null
+	};
+}
+const queryCommand = new commander.Command("query").description("Query log files with SQL-like syntax\n\n  Examples:\n    logixia query app.log --sql \"SELECT * FROM logs WHERE level='error'\"\n    logixia query app.log --sql \"COUNT BY level\"\n    logixia query app.log --sql \"AVG(duration) BY endpoint\"\n    logixia query app.log --since \"last 2 hours\" --format table\n    logixia query app.log --follow --sql \"WHERE level='error'\"\n").argument("<file>", "Path to NDJSON or JSON log file").option("--sql <query>", "SQL-like query string").option("--since <time>", "Only include entries after this time (e.g. \"last 2 hours\", \"today\")").option("--until <time>", "Only include entries before this time").option("--limit <n>", "Maximum number of results to return", "0").option("--order-by <field>", "Sort results by this field").option("--format <fmt>", "Output format: line, table, json, ndjson", "line").option("--follow", "Follow file for new entries matching the query (tail mode)", false).action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(picocolors.default.red(`File not found: ${full}`));
+		process.exit(2);
+	}
+	const entries = safeParseLogs(node_fs.default.readFileSync(full, "utf8"));
+	const limitN = opts.limit ? Number.parseInt(opts.limit, 10) : 0;
+	const { results, aggregationOutput } = executeQuery(entries, {
+		sql: opts.sql,
+		since: opts.since,
+		until: opts.until,
+		limit: limitN,
+		orderBy: opts.orderBy
+	});
+	if (aggregationOutput !== null) {
+		console.log(picocolors.default.bold("\nAggregation result:"));
+		console.log(aggregationOutput);
+	} else {
+		console.log(picocolors.default.bold(`\nFound ${picocolors.default.cyan(String(results.length))} match${results.length === 1 ? "" : "es"}`));
+		if (results.length > 0) console.log(formatResults(results, opts.format || "line"));
+	}
+	if (opts.follow) {
+		console.log(picocolors.default.dim("\n--- following (ctrl-c to exit) ---"));
+		let pos = node_fs.default.statSync(full).size;
+		let buffer = "";
+		node_fs.default.watchFile(full, { interval: 300 }, (curr) => {
+			if (curr.size <= pos) return;
+			const rs = node_fs.default.createReadStream(full, {
+				start: pos,
+				end: curr.size,
+				encoding: "utf8"
+			});
+			rs.on("data", (chunk) => {
+				buffer += chunk;
+				const lines = buffer.split(/\r?\n/);
+				buffer = lines.pop() ?? "";
+				for (const line of lines.filter(Boolean)) try {
+					const { results: tailResults } = executeQuery([JSON.parse(line)], {
+						sql: opts.sql,
+						since: opts.since,
+						until: opts.until
+					});
+					if (tailResults.length > 0) console.log(formatResults(tailResults, opts.format || "line"));
+				} catch {
+					if (!opts.sql) console.log(line);
+				}
+			});
+			rs.on("end", () => {
+				pos = curr.size;
+			});
+		});
+	}
+});
+
+//#endregion
+//#region src/cli/commands/search.ts
+function parseQuery(query) {
+	const match = query.match(/^(\w+):(.+)$/);
+	if (match) return {
+		field: match[1],
+		value: match[2]
+	};
+	return { value: query };
+}
+async function searchLogs(raw, opts = {}) {
+	const entries = safeParseLogs(raw);
+	const criteria = parseQuery(opts.query || "");
+	return entries.filter((entry) => {
+		const row = entry;
+		if (criteria.field) {
+			const fieldValue = row[criteria.field];
+			if (fieldValue === void 0) return false;
+			return String(fieldValue).toLowerCase().includes(criteria.value.toLowerCase());
+		} else return JSON.stringify(row).toLowerCase().includes(criteria.value.toLowerCase());
+	});
+}
+function formatSearchResults(results, format, _context) {
+	if (format === "json") return JSON.stringify(results, null, 2);
+	if (format === "table") {
+		if (results.length === 0) return picocolors.default.yellow("No results found");
+		return formatAsTable(results, Object.keys(results[0] || {}).slice(0, 4));
+	}
+	if (results.length === 0) return picocolors.default.yellow("No results found");
+	return results.map((r, idx) => {
+		const line = JSON.stringify(r);
+		return `${picocolors.default.gray(String(idx + 1) + ":")} ${line}`;
+	}).join("\n");
+}
+const searchCommand = new commander.Command("search").description("Search log files with query patterns").argument("<file>", "Path to log file").option("--query <query>", "Search query (e.g., \"user_id:123\" or \"error\")", "").option("--format <fmt>", "Output format (table, json, line)", "line").option("--context <lines>", "Lines of context around matches", "0").action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(`File not found: ${full}`);
+		process.exit(2);
+	}
+	if (!opts.query) {
+		console.error("--query is required");
+		process.exit(2);
+	}
+	const results = await searchLogs(node_fs.default.readFileSync(full, "utf8"), opts);
+	console.log(picocolors.default.bold(`\nFound ${results.length} matches`));
+	console.log(formatSearchResults(results, opts.format, Number.parseInt(opts.context || "0")));
+});
+
+//#endregion
+//#region src/cli/commands/stats.ts
+async function generateStats(raw, opts = {}) {
+	const entries = safeParseLogs(raw);
+	const group = opts.groupBy || "level";
+	const agg = {};
+	let minTime = null;
+	let maxTime = null;
+	for (const e of entries) {
+		const key = (e[group] || e.level || "unknown").toString().toUpperCase();
+		agg[key] = (agg[key] || 0) + 1;
+		if (e.timestamp) {
+			const ts = new Date(e.timestamp);
+			if (!minTime || ts < minTime) minTime = ts;
+			if (!maxTime || ts > maxTime) maxTime = ts;
+		}
+	}
+	return {
+		total: entries.length,
+		groupBy: group,
+		distribution: agg,
+		timeRange: minTime && maxTime ? {
+			start: minTime,
+			end: maxTime
+		} : null
+	};
+}
+function formatStatsOutput(stats, filename) {
+	const s = stats;
+	const lines = [];
+	lines.push(picocolors.default.bold(`\nLog Statistics for ${node_path.default.basename(filename)}`));
+	lines.push(picocolors.default.bold("=".repeat(50)));
+	lines.push(picocolors.default.cyan(`Total Entries: ${s["total"].toLocaleString()}`));
+	if (s["timeRange"]) lines.push(picocolors.default.cyan(`Time Range: ${s["timeRange"]["start"].toISOString()} - ${s["timeRange"]["end"].toISOString()}`));
+	lines.push("");
+	lines.push(picocolors.default.bold(`${s["groupBy"].charAt(0).toUpperCase() + s["groupBy"].slice(1)} Distribution:`));
+	const sorted = Object.entries(s["distribution"]).sort(([, a], [, b]) => b - a);
+	for (const [key, count] of sorted) {
+		const percentage = (count / s["total"] * 100).toFixed(1);
+		const bar = "█".repeat(Math.floor(count / s["total"] * 30));
+		let colorFn = picocolors.default.white;
+		if (key === "ERROR") colorFn = picocolors.default.red;
+		else if (key === "WARN") colorFn = picocolors.default.yellow;
+		else if (key === "INFO") colorFn = picocolors.default.blue;
+		else if (key === "DEBUG") colorFn = picocolors.default.gray;
+		lines.push(colorFn(`  ${key.padEnd(10)} ${String(count).padStart(8)} (${percentage.padStart(5)}%) ${bar}`));
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+const statsCommand = new commander.Command("stats").description("Show statistics for a log file").argument("<file>", "Path to log file").option("--group-by <field>", "Field to group by (default: level)", "level").option("--format <fmt>", "Output format (pretty, json)", "pretty").action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(`File not found: ${full}`);
+		process.exit(2);
+	}
+	const stats = await generateStats(node_fs.default.readFileSync(full, "utf8"), opts);
+	if (opts.format === "json") console.log(JSON.stringify(stats, null, 2));
+	else console.log(formatStatsOutput(stats, file));
+});
+
+//#endregion
+//#region src/cli/commands/tail.ts
+function parseFilter(filter) {
+	if (!filter) return null;
+	const match = filter.match(/^(\w+):(.+)$/);
+	if (!match) return null;
+	return {
+		field: match[1],
+		value: match[2]
+	};
+}
+function applyFilter(line, filter) {
+	if (!filter) return true;
+	try {
+		const fieldValue = JSON.parse(line)[filter.field];
+		if (fieldValue === void 0) return false;
+		return fieldValue.toString().toLowerCase().includes(filter.value.toLowerCase());
+	} catch {
+		return line.toLowerCase().includes(filter.value.toLowerCase());
+	}
+}
+function highlightLine(line, highlight) {
+	if (!highlight) return line;
+	try {
+		const level = (JSON.parse(line).level || "").toUpperCase();
+		if (level === "ERROR") return picocolors.default.red(line);
+		if (level === "WARN") return picocolors.default.yellow(line);
+		if (level === "INFO") return picocolors.default.blue(line);
+		if (level === "DEBUG") return picocolors.default.gray(line);
+		return line;
+	} catch {
+		const regex = new RegExp(highlight, "gi");
+		return line.replace(regex, (match) => picocolors.default.bgYellow(picocolors.default.black(match)));
+	}
+}
+const tailCommand = new commander.Command("tail").description("Follow log files in real-time").argument("<file>", "Path to log file").option("--follow", "Follow file changes", false).option("--filter <filter>", "Filter criteria (e.g., level:error, user_id:123)").option("--highlight <pattern>", "Highlight pattern or color by level").action(async (file, opts) => {
+	const full = node_path.default.resolve(process.cwd(), file);
+	if (!node_fs.default.existsSync(full)) {
+		console.error(`File not found: ${full}`);
+		process.exit(2);
+	}
+	const filterCriteria = parseFilter(opts.filter);
+	const last = node_fs.default.readFileSync(full, "utf8").split(/\r?\n/).filter(Boolean).filter((line) => applyFilter(line, filterCriteria)).slice(-10);
+	for (const line of last) console.log(highlightLine(line, opts.highlight));
+	if (opts.follow) {
+		console.log(picocolors.default.dim("--- following (ctrl-c to exit) ---"));
+		let pos = node_fs.default.statSync(full).size;
+		let buffer = "";
+		node_fs.default.watchFile(full, { interval: 500 }, (curr) => {
+			if (curr.size > pos) {
+				const rs = node_fs.default.createReadStream(full, {
+					start: pos,
+					end: curr.size,
+					encoding: "utf8"
+				});
+				rs.on("data", (chunk) => {
+					buffer += chunk;
+					const lines = buffer.split(/\r?\n/);
+					buffer = lines.pop() || "";
+					for (const line of lines.filter(Boolean)) if (applyFilter(line, filterCriteria)) console.log(highlightLine(line, opts.highlight));
+				});
+				rs.on("end", () => {
+					pos = curr.size;
+				});
+			}
+		});
+	}
+});
+
+//#endregion
+//#region src/cli/index.ts
+const pkgPath = node_path.default.resolve(__dirname, "../..", "package.json");
+let pkg;
+try {
+	pkg = JSON.parse(node_fs.default.readFileSync(pkgPath, "utf8"));
+} catch {
+	pkg = { version: "0.0.0" };
+}
+const program = new commander.Command();
+program.name("logixia").description("Logixia CLI for log management and analysis").version(pkg.version || "0.0.0").addHelpText("after", `\n${picocolors.default.dim("Sponsor logixia:")} https://github.com/sponsors/webcoderspeed · https://paypal.me/Sniperspeed`);
+program.addCommand(analyzeCommand);
+program.addCommand(tailCommand);
+program.addCommand(statsCommand);
+program.addCommand(searchCommand);
+program.addCommand(queryCommand);
+program.addCommand(exportCommand);
+program.addCommand(exploreCommand);
+program.on("command:*", () => {
+	console.error(picocolors.default.red("Invalid command: %s\nSee --help for a list of available commands."), program.args.join(" "));
+	process.exit(1);
+});
+function isDirectRun(argv1, file) {
+	if (!argv1) return false;
+	try {
+		return node_fs.default.realpathSync(argv1) === node_fs.default.realpathSync(file);
+	} catch {
+		return false;
+	}
+}
+if (isDirectRun(process.argv[1], __filename)) program.parse(process.argv);
+
+//#endregion
+exports.isDirectRun = isDirectRun;
+exports.program = program;