lmnr-cli 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -28,12 +28,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let commander = require("commander");
+let fs = require("fs");
 let path = require("path");
 path = __toESM(path);
 let pino = require("pino");
 pino = __toESM(pino);
 let pino_pretty = require("pino-pretty");
 let uuid = require("uuid");
+let csv_parser = require("csv-parser");
+csv_parser = __toESM(csv_parser);
+let export_to_csv = require("export-to-csv");
+let fs_promises = require("fs/promises");
+fs_promises = __toESM(fs_promises);
 let chokidar = require("chokidar");
 chokidar = __toESM(chokidar);
 let http = require("http");
@@ -45,7 +51,7 @@ let readline = require("readline");
 readline = __toESM(readline);
 
 //#region package.json
-var version$1 = "0.1.6";
+var version$1 = "0.1.7";
 
 //#endregion
 //#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
@@ -113,7 +119,7 @@ var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
 var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const fs = require("fs");
+	const fs$1 = require("fs");
 	const path$1 = require("path");
 	const os = require("os");
 	const crypto$1 = require("crypto");
@@ -250,10 +256,10 @@ var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function _vaultPath(options) {
 		let possibleVaultPath = null;
 		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
-			for (const filepath of options.path) if (fs.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+			for (const filepath of options.path) if (fs$1.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
 		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
 		else possibleVaultPath = path$1.resolve(process.cwd(), ".env.vault");
-		if (fs.existsSync(possibleVaultPath)) return possibleVaultPath;
+		if (fs$1.existsSync(possibleVaultPath)) return possibleVaultPath;
 		return null;
 	}
 	function _resolveHome(envPath) {
@@ -287,7 +293,7 @@ var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		let lastError;
 		const parsedAll = {};
 		for (const path$2 of optionPaths) try {
-			const parsed = DotenvModule.parse(fs.readFileSync(path$2, { encoding }));
+			const parsed = DotenvModule.parse(fs$1.readFileSync(path$2, { encoding }));
 			DotenvModule.populate(parsedAll, parsed, options);
 		} catch (e) {
 			if (debug) _debug(`Failed to load ${path$2} ${e.message}`);
@@ -392,7 +398,7 @@ var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../client/dist/index.mjs
 var import_main = require_main();
-var version = "0.8.13";
+var version = "0.8.15";
 function getLangVersion() {
 	if (typeof process !== "undefined" && process.versions && process.versions.node) return `node-${process.versions.node}`;
 	if (typeof navigator !== "undefined" && navigator.userAgent) return `browser-${navigator.userAgent}`;
@@ -500,7 +506,7 @@ const loadEnv = (options) => {
 };
 const logger$1$1 = initializeLogger$1();
 const DEFAULT_DATASET_PULL_LIMIT = 100;
-const DEFAULT_DATASET_PUSH_BATCH_SIZE = 100;
+const DEFAULT_DATASET_PUSH_BATCH_SIZE$1 = 100;
 var DatasetsResource = class extends BaseResource {
 	constructor(baseHttpUrl, projectApiKey) {
 		super(baseHttpUrl, projectApiKey);
@@ -544,7 +550,7 @@ var DatasetsResource = class extends BaseResource {
 	* @param {boolean} [options.createDataset] - Whether to create the dataset if it doesn't exist
 	* @returns {Promise<PushDatapointsResponse | undefined>}
 	*/
-	async push({ points, name, id, batchSize = DEFAULT_DATASET_PUSH_BATCH_SIZE, createDataset = false }) {
+	async push({ points, name, id, batchSize = DEFAULT_DATASET_PUSH_BATCH_SIZE$1, createDataset = false }) {
 		if (!name && !id) throw new Error("Either name or id must be provided");
 		if (name && id) throw new Error("Only one of name or id must be provided");
 		if (createDataset && !name) throw new Error("Name must be provided when creating a new dataset");
@@ -601,7 +607,7 @@ var DatasetsResource = class extends BaseResource {
 		return response.json();
 	}
 };
-const logger$3 = initializeLogger$1();
+const logger$6 = initializeLogger$1();
 const INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 16e6;
 var EvalsResource = class extends BaseResource {
 	constructor(baseHttpUrl, projectApiKey) {
@@ -737,7 +743,7 @@ var EvalsResource = class extends BaseResource {
 	* @returns {Promise<GetDatapointsResponse>} Response from the datapoint retrieval
 	*/
 	async getDatapoints({ datasetName, offset, limit }) {
-		logger$3.warn("evals.getDatapoints() is deprecated. Use client.datasets.pull() instead.");
+		logger$6.warn("evals.getDatapoints() is deprecated. Use client.datasets.pull() instead.");
 		const params = new URLSearchParams({
 			name: datasetName,
 			offset: offset.toString(),
@@ -754,7 +760,7 @@ var EvalsResource = class extends BaseResource {
 		let length = initialLength;
 		let lastResponse = null;
 		for (let i = 0; i < maxRetries; i++) {
-			logger$3.debug(`Retrying save datapoints... ${i + 1} of ${maxRetries}, length: ${length}`);
+			logger$6.debug(`Retrying save datapoints... ${i + 1} of ${maxRetries}, length: ${length}`);
 			const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints`, {
 				method: "POST",
 				headers: this.headers(),
@@ -1012,6 +1018,410 @@ var LaminarClient = class {
 	}
 };
 
+//#endregion
+//#region src/utils/logger.ts
+function initializeLogger(options) {
+	const colorize = options?.colorize ?? true;
+	const level = options?.level ?? process.env.LMNR_LOG_LEVEL?.toLowerCase()?.trim() ?? "info";
+	return (0, pino.default)({ level }, (0, pino_pretty.PinoPretty)({
+		colorize,
+		minimumLevel: level,
+		destination: 2
+	}));
+}
+
+//#endregion
+//#region src/utils/file.ts
+const logger$5 = initializeLogger();
+/**
+* Check if a file has a supported extension.
+*/
+const isSupportedFile = (file) => {
+	const ext = path.extname(file).toLowerCase();
+	return [
+		".json",
+		".csv",
+		".jsonl"
+	].includes(ext);
+};
+/**
+* Collect all supported files from the given paths.
+* Handles both files and directories.
+*/
+const collectFiles = async (paths, recursive = false) => {
+	const collectedFiles = [];
+	for (const filepath of paths) try {
+		const stats = await fs_promises.stat(filepath);
+		if (stats.isFile()) if (isSupportedFile(filepath)) collectedFiles.push(filepath);
+		else logger$5.warn(`Skipping unsupported file type: ${filepath}`);
+		else if (stats.isDirectory()) {
+			const entries = await fs_promises.readdir(filepath);
+			for (const entry of entries) {
+				const fullPath = path.join(filepath, entry);
+				const entryStats = await fs_promises.stat(fullPath);
+				if (entryStats.isFile() && isSupportedFile(fullPath)) collectedFiles.push(fullPath);
+				else if (recursive && entryStats.isDirectory()) {
+					const subFiles = await collectFiles([fullPath], true);
+					collectedFiles.push(...subFiles);
+				}
+			}
+		}
+	} catch (error) {
+		logger$5.warn(`Path does not exist or is not accessible: ${filepath}. Error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return collectedFiles;
+};
+/**
+* Read a JSON file and return its contents.
+*/
+const readJsonFile = async (filepath) => {
+	const content = await fs_promises.readFile(filepath, "utf-8");
+	const parsed = JSON.parse(content);
+	return Array.isArray(parsed) ? parsed : [parsed];
+};
+/**
+* Try to parse a string as JSON. If it fails, return the original string.
+*/
+const tryParseJson = (content) => {
+	if (typeof content !== "string") return content;
+	const trimmed = content.trim();
+	if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return content;
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		logger$5.debug(`Error parsing JSON: ${error instanceof Error ? error.message : String(error)}`);
+		return content;
+	}
+};
+/**
+* Parse each field in a CSV row, attempting to convert JSON strings back to objects.
+*/
+const parseCsvRow = (row) => {
+	const parsed = {};
+	for (const [key, value] of Object.entries(row)) parsed[key] = tryParseJson(value);
+	return parsed;
+};
+/**
+* Read a CSV file and return its contents as an array of objects.
+*/
+const readCsvFile = async (filepath) => new Promise((resolve, reject) => {
+	const results = [];
+	(0, fs.createReadStream)(filepath).pipe((0, csv_parser.default)()).on("data", (data) => results.push(parseCsvRow(data))).on("end", () => resolve(results)).on("error", reject);
+});
+/**
+* Read a JSONL file and return its contents as an array of objects.
+*/
+async function readJsonlFile(filepath) {
+	return (await fs_promises.readFile(filepath, "utf-8")).split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+}
+/**
+* Read a single file and return its contents.
+*/
+async function readFile(filepath) {
+	const ext = path.extname(filepath).toLowerCase();
+	if (ext === ".json") return readJsonFile(filepath);
+	else if (ext === ".csv") return readCsvFile(filepath);
+	else if (ext === ".jsonl") return readJsonlFile(filepath);
+	else throw new Error(`Unsupported file type: ${ext}`);
+}
+/**
+* Load data from all files in the specified paths.
+*/
+const loadFromPaths = async (paths, recursive = false) => {
+	const files = await collectFiles(paths, recursive);
+	if (files.length === 0) {
+		logger$5.warn("No supported files found in the specified paths");
+		return [];
+	}
+	logger$5.info(`Found ${files.length} file(s) to read`);
+	const result = [];
+	for (const file of files) try {
+		const data = await readFile(file);
+		result.push(...data);
+		logger$5.info(`Read ${data.length} record(s) from ${file}`);
+	} catch (error) {
+		logger$5.error(`Error reading file ${file}: ${error instanceof Error ? error.message : String(error)}`);
+		throw error;
+	}
+	return result;
+};
+/**
+* Write data to a JSON file.
+*/
+const writeJsonFile = async (filepath, data) => {
+	const content = JSON.stringify(data, null, 2);
+	await fs_promises.writeFile(filepath, content, "utf-8");
+};
+/**
+* Format data as a CSV string.
+*/
+const formatCsv = (data) => {
+	const formattedData = data.map((item) => Object.fromEntries(Object.entries(item).map(([key, value]) => [key, stringifyForCsv(value)])));
+	return (0, export_to_csv.asString)((0, export_to_csv.generateCsv)((0, export_to_csv.mkConfig)({ useKeysAsHeaders: true }))(formattedData));
+};
+/**
+* Write data to a CSV file.
+*/
+const writeCsvFile = async (filepath, data) => {
+	if (data.length === 0) throw new Error("No data to write to CSV");
+	await fs_promises.writeFile(filepath, formatCsv(data), "utf-8");
+};
+/**
+* Write data to a JSONL file.
+*/
+const writeJsonlFile = async (filepath, data) => {
+	const lines = data.map((item) => JSON.stringify(item)).join("\n");
+	await fs_promises.writeFile(filepath, lines + "\n", "utf-8");
+};
+/**
+* Write data to a file based on the file extension.
+*/
+const writeToFile = async (filepath, data, format) => {
+	const dir = path.dirname(filepath);
+	await fs_promises.mkdir(dir, { recursive: true });
+	const ext = format ?? path.extname(filepath).slice(1);
+	if (format && format !== path.extname(filepath).slice(1)) logger$5.warn(`Output format ${format} does not match file extension ${path.extname(filepath).slice(1)}`);
+	if (ext === "json") await writeJsonFile(filepath, data);
+	else if (ext === "csv") await writeCsvFile(filepath, data);
+	else if (ext === "jsonl") await writeJsonlFile(filepath, data);
+	else throw new Error(`Unsupported output format: ${ext}`);
+};
+/**
+* Convert a value to a CSV-safe string.
+* - Strings and numbers pass through
+* - null/undefined become empty strings
+* - Objects and arrays are stringified to JSON
+*/
+const stringifyForCsv = (value) => {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+};
+/**
+* Print data to console in the specified format.
+*/
+const printToConsole = (data, format = "json") => {
+	if (format === "json") console.log(JSON.stringify(data, null, 2));
+	else if (format === "csv") {
+		if (data.length === 0) {
+			logger$5.error("No data to print");
+			return;
+		}
+		console.log(formatCsv(data));
+	} else if (format === "jsonl") data.forEach((item) => console.log(JSON.stringify(item)));
+	else throw new Error(`Unsupported output format: ${String(format)}. (supported formats: json, csv, jsonl)`);
+};
+
+//#endregion
+//#region src/utils/output.ts
+/**
+* Write structured JSON to stdout. Use this for machine-readable output
+* when --json is set.
+*/
+function outputJson(data) {
+	console.log(JSON.stringify(data));
+}
+/**
+* Write a JSON error to stdout and exit with code 1.
+* Use this in --json mode so agents can parse the failure.
+*/
+function outputJsonError(error, exitCode = 1) {
+	console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+	process.exit(exitCode);
+}
+
+//#endregion
+//#region src/commands/dataset/index.ts
+const logger$4 = initializeLogger();
+const DEFAULT_DATASET_PULL_BATCH_SIZE = 100;
+const DEFAULT_DATASET_PUSH_BATCH_SIZE = 100;
+/**
+* Pull all data from a dataset in batches.
+*/
+const pullAllData = async (client, identifier, batchSize = DEFAULT_DATASET_PULL_BATCH_SIZE, offset = 0, limit) => {
+	let hasMore = true;
+	let currentOffset = offset;
+	const stopAt = limit !== void 0 ? offset + limit : void 0;
+	const result = [];
+	while (hasMore && (stopAt === void 0 || currentOffset < stopAt)) {
+		const data = await client.datasets.pull({
+			...identifier,
+			offset: currentOffset,
+			limit: batchSize
+		});
+		result.push(...data.items);
+		if (data.items.length === 0 || data.items.length < batchSize) hasMore = false;
+		else if (stopAt !== void 0 && currentOffset + batchSize >= stopAt) hasMore = false;
+		else if (data.totalCount !== void 0 && currentOffset + batchSize >= data.totalCount) hasMore = false;
+		currentOffset += batchSize;
+	}
+	if (limit !== void 0) return result.slice(0, limit);
+	return result;
+};
+/**
+* Handle datasets list command.
+*/
+const handleDatasetsList = async (options) => {
+	const client = new LaminarClient({
+		projectApiKey: options.projectApiKey,
+		baseUrl: options.baseUrl,
+		port: options.port
+	});
+	try {
+		const datasets = await client.datasets.listDatasets();
+		if (options.json) {
+			outputJson(datasets);
+			return;
+		}
+		if (datasets.length === 0) {
+			console.log("No datasets found.");
+			return;
+		}
+		const idWidth = 36;
+		const createdAtWidth = 19;
+		console.log(`\n${"ID".padEnd(idWidth)}  ${"Created At".padEnd(createdAtWidth)}  Name`);
+		console.log(`${"-".repeat(idWidth)}  ${"-".repeat(createdAtWidth)}  ${"-".repeat(20)}`);
+		for (const dataset of datasets) {
+			const createdAtStr = new Date(dataset.createdAt).toISOString().replace("T", " ").substring(0, 19);
+			console.log(`${dataset.id.padEnd(idWidth)}  ${createdAtStr.padEnd(createdAtWidth)}  ${dataset.name}`);
+		}
+		console.log(`\nTotal: ${datasets.length} dataset(s)\n`);
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger$4.error(`Failed to list datasets: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+};
+/**
+* Handle datasets push command.
+*/
+const handleDatasetsPush = async (paths, options) => {
+	if (!options.name && !options.id) {
+		if (options.json) outputJsonError("Either name or id must be provided");
+		logger$4.error("Either name or id must be provided");
+		process.exit(1);
+	}
+	if (options.name && options.id) {
+		if (options.json) outputJsonError("Only one of name or id must be provided");
+		logger$4.error("Only one of name or id must be provided");
+		process.exit(1);
+	}
+	const client = new LaminarClient({
+		projectApiKey: options.projectApiKey,
+		baseUrl: options.baseUrl,
+		port: options.port
+	});
+	try {
+		const data = await loadFromPaths(paths, options.recursive);
+		if (data.length === 0) {
+			if (options.json) outputJsonError("No data to push");
+			logger$4.error("No data to push. Skipping");
+			process.exit(1);
+		}
+		const identifier = options.name ? { name: options.name } : { id: options.id };
+		const result = await client.datasets.push({
+			points: data,
+			...identifier,
+			batchSize: options.batchSize ?? DEFAULT_DATASET_PUSH_BATCH_SIZE
+		});
+		if (options.json) {
+			outputJson({
+				datasetId: result?.datasetId,
+				count: data.length
+			});
+			return;
+		}
+		logger$4.info(`Pushed ${data.length} data points to dataset ${options.name || options.id}`);
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger$4.error(`Failed to push dataset: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+};
+/**
+* Handle datasets pull command.
+*/
+const handleDatasetsPull = async (outputPath, options) => {
+	if (!options.name && !options.id) {
+		if (options.json) outputJsonError("Either name or id must be provided");
+		logger$4.error("Either name or id must be provided");
+		process.exit(1);
+	}
+	if (options.name && options.id) {
+		if (options.json) outputJsonError("Only one of name or id must be provided");
+		logger$4.error("Only one of name or id must be provided");
+		process.exit(1);
+	}
+	const client = new LaminarClient({
+		projectApiKey: options.projectApiKey,
+		baseUrl: options.baseUrl,
+		port: options.port
+	});
+	const identifier = options.name ? { name: options.name } : { id: options.id };
+	try {
+		const result = await pullAllData(client, identifier, options.batchSize ?? DEFAULT_DATASET_PULL_BATCH_SIZE, options.offset ?? 0, options.limit);
+		if (outputPath) {
+			await writeToFile(outputPath, result, options.outputFormat);
+			if (options.json) outputJson({
+				path: outputPath,
+				count: result.length
+			});
+			else logger$4.info(`Successfully pulled ${result.length} data points to ${outputPath}`);
+		} else if (options.json) outputJson(result);
+		else printToConsole(result, options.outputFormat ?? "json");
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger$4.error(`Failed to pull dataset: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+};
+/**
+* Handle datasets create command.
+*/
+const handleDatasetsCreate = async (name, paths, options) => {
+	const client = new LaminarClient({
+		projectApiKey: options.projectApiKey,
+		baseUrl: options.baseUrl,
+		port: options.port
+	});
+	try {
+		const data = await loadFromPaths(paths, options.recursive);
+		if (data.length === 0) {
+			if (options.json) outputJsonError("No data to push");
+			logger$4.error("No data to push. Skipping");
+			process.exit(1);
+		}
+		logger$4.info(`Pushing ${data.length} data points to dataset '${name}'...`);
+		await client.datasets.push({
+			points: data,
+			name,
+			batchSize: options.batchSize ?? DEFAULT_DATASET_PUSH_BATCH_SIZE,
+			createDataset: true
+		});
+		logger$4.info(`Successfully pushed ${data.length} data points to dataset '${name}'`);
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger$4.error(`Failed to create dataset: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+	logger$4.info(`Pulling data from dataset '${name}'...`);
+	try {
+		const result = await pullAllData(client, { name }, options.batchSize ?? DEFAULT_DATASET_PULL_BATCH_SIZE, 0, void 0);
+		await writeToFile(options.outputFile, result, options.outputFormat);
+		if (options.json) outputJson({
+			name,
+			path: options.outputFile,
+			count: result.length
+		});
+		else logger$4.info(`Successfully created dataset '${name}' and saved ${result.length} datapoints to ${options.outputFile}`);
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger$4.error(`Failed to pull dataset after creation: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+};
+
 //#endregion
 //#region src/cache-server.ts
 const DEFAULT_START_PORT = 35667;
@@ -1301,20 +1711,9 @@ function createSSEClient(options) {
 */
 const WORKER_MESSAGE_PREFIX = "__LMNR_WORKER__:";
 
-//#endregion
-//#region src/utils.ts
-function initializeLogger(options) {
-	const colorize = options?.colorize ?? true;
-	const level = options?.level ?? process.env.LMNR_LOG_LEVEL?.toLowerCase()?.trim() ?? "info";
-	return (0, pino.default)({ level }, (0, pino_pretty.PinoPretty)({
-		colorize,
-		minimumLevel: level
-	}));
-}
-
 //#endregion
 //#region src/subprocess/executor.ts
-const logger$2 = initializeLogger();
+const logger$3 = initializeLogger();
 /**
 * Track and kill the currently running subprocess
 */
@@ -1345,16 +1744,16 @@ var SubprocessManager = class {
 					const message = JSON.parse(messageJson);
 					switch (message.type) {
 						case "log":
-							logger$2[message.level](message.message);
+							logger$3[message.level](message.message);
 							break;
 						case "error":
 							hasError = true;
-							logger$2.error(`Worker error: ${message.error}`);
-							if (message.stack) logger$2.error(message.stack);
+							logger$3.error(`Worker error: ${message.error}`);
+							if (message.stack) logger$3.error(message.stack);
 							break;
 					}
 				} catch {
-					logger$2.debug("Failed to parse worker protocol message. Printing raw line");
+					logger$3.debug("Failed to parse worker protocol message. Printing raw line");
 					console.log(line.substring(WORKER_MESSAGE_PREFIX.length));
 				}
 				else console.log(line);
@@ -1367,7 +1766,7 @@ var SubprocessManager = class {
 				if (signal) reject(/* @__PURE__ */ new Error(`Worker terminated by signal: ${signal}`));
 				else if (code === 0) resolve(result);
 				else {
-					if (!hasError) logger$2.error(`Worker exited with code ${code}`);
+					if (!hasError) logger$3.error(`Worker exited with code ${code}`);
 					reject(/* @__PURE__ */ new Error(`Worker exited with code ${code}`));
 				}
 			});
@@ -1389,7 +1788,7 @@ var SubprocessManager = class {
 			this.currentProcess.kill("SIGTERM");
 			setTimeout(() => {
 				if (processToKill && processToKill.exitCode === null) {
-					logger$2.warn("Child process did not terminate, using SIGKILL");
+					logger$3.warn("Child process did not terminate, using SIGKILL");
 					processToKill.kill("SIGKILL");
 				}
 			}, 5e3);
@@ -1484,7 +1883,7 @@ function getWorkerCommand(filePath, options) {
 
 //#endregion
 //#region src/commands/dev/metadata.ts
-const logger$1 = initializeLogger();
+const logger$2 = initializeLogger();
 const TS_JS_EXTENSIONS = [
 	".ts",
 	".tsx",
@@ -1502,7 +1901,7 @@ const EXTENSIONS_TO_DISCOVER_METADATA = [...TS_JS_EXTENSIONS, ".py"];
 */
 const METADATA_PROTOCOL_PREFIX = "LMNR_METADATA:";
 const logLmnrPackageNotFoundAndExit = () => {
-	logger$1.error("@lmnr-ai/lmnr package not found or outdated. For JS/TS projects, please install the latest version of @lmnr-ai/lmnr in your project: npm install @lmnr-ai/lmnr\nYou might need to run `lmnr-cli` from the root of your project");
+	logger$2.error("@lmnr-ai/lmnr package not found or outdated. For JS/TS projects, please install the latest version of @lmnr-ai/lmnr in your project: npm install @lmnr-ai/lmnr\nYou might need to run `lmnr-cli` from the root of your project");
 	process.exit(1);
 };
 /**
@@ -1532,20 +1931,20 @@ const discoverTypeScriptMetadata = async (filePath, options) => {
 		loadModule = buildModule.loadModule;
 		selectRolloutFunction = buildModule.selectRolloutFunction;
 		if (!extractRolloutFunctions || !buildFile || !loadModule || !selectRolloutFunction) {
-			logger$1.error("Missing exports from @lmnr-ai/lmnr modules. This may indicate an outdated package version.");
+			logger$2.error("Missing exports from @lmnr-ai/lmnr modules. This may indicate an outdated package version.");
 			logLmnrPackageNotFoundAndExit();
 		}
 	} catch (error) {
 		if (error.code === "MODULE_NOT_FOUND") logLmnrPackageNotFoundAndExit();
-		logger$1.error(`Unexpected error loading @lmnr-ai/lmnr modules: ${error.message}`);
+		logger$2.error(`Unexpected error loading @lmnr-ai/lmnr modules: ${error.message}`);
 		throw error;
 	}
 	let paramsMetadata;
 	try {
 		paramsMetadata = extractRolloutFunctions(filePath);
-		logger$1.debug(`Extracted TypeScript metadata for ${paramsMetadata?.size} functions`);
+		logger$2.debug(`Extracted TypeScript metadata for ${paramsMetadata?.size} functions`);
 	} catch (error) {
-		logger$1.warn("Failed to extract TypeScript metadata, falling back to runtime parsing: " + (error instanceof Error ? error.message : String(error)));
+		logger$2.warn("Failed to extract TypeScript metadata, falling back to runtime parsing: " + (error instanceof Error ? error.message : String(error)));
 	}
 	const moduleText = await buildFile(filePath, {
 		externalPackages: options.externalPackages,
@@ -1557,21 +1956,21 @@ const discoverTypeScriptMetadata = async (filePath, options) => {
 	});
 	const selectedFunction = selectRolloutFunction(options.function);
 	if (paramsMetadata) {
-		logger$1.debug(`Available TS metadata keys: ${Array.from(paramsMetadata.keys()).join(", ")}`);
-		logger$1.debug(`Looking for span name: ${selectedFunction.name} (runtime key: ${selectedFunction.exportName})`);
+		logger$2.debug(`Available TS metadata keys: ${Array.from(paramsMetadata.keys()).join(", ")}`);
+		logger$2.debug(`Looking for span name: ${selectedFunction.name} (runtime key: ${selectedFunction.exportName})`);
 		let foundMetadata = null;
 		for (const [exportName, metadata] of paramsMetadata.entries()) {
-			logger$1.debug(`Checking ${exportName}: span name = ${metadata.name}, export name = ${exportName}`);
+			logger$2.debug(`Checking ${exportName}: span name = ${metadata.name}, export name = ${exportName}`);
 			if (metadata.name === selectedFunction.name) {
 				foundMetadata = metadata;
-				logger$1.debug(`Match. Export name: ${exportName}, span name: ${metadata.name}`);
+				logger$2.debug(`Match. Export name: ${exportName}, span name: ${metadata.name}`);
 				break;
 			}
 		}
 		if (foundMetadata) {
 			selectedFunction.params = foundMetadata.params;
-			logger$1.debug(`Using TypeScript metadata for span: ${selectedFunction.name}`);
-		} else logger$1.info(`No TypeScript metadata found for span name: ${selectedFunction.name}`);
+			logger$2.debug(`Using TypeScript metadata for span: ${selectedFunction.name}`);
+		} else logger$2.info(`No TypeScript metadata found for span name: ${selectedFunction.name}`);
 	}
 	return {
 		functionName: selectedFunction.name,
@@ -1681,7 +2080,7 @@ const extractMetadataFromStdout = (stdout) => {
 * Discovers function metadata for Python files/modules by calling the lmnr Python CLI
 */
 const discoverPythonMetadata = async (filePathOrModule, options) => {
-	logger$1.debug(`Discovering Python metadata for ${filePathOrModule}`);
+	logger$2.debug(`Discovering Python metadata for ${filePathOrModule}`);
 	const args = ["discover"];
 	if (options.pythonModule) args.push("--module", options.pythonModule);
 	else args.push("--file", filePathOrModule);
@@ -1694,8 +2093,8 @@ const discoverPythonMetadata = async (filePathOrModule, options) => {
 		};
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error);
-		logger$1.error(`Error while loading Python file/module: ${errorMessage}`);
-		if (errorMessage.toLowerCase().includes("command not found") || errorMessage.includes("spawn lmnr ENOENT")) logger$1.info(`HINT: Make sure latest version of \`lmnr\` python package is installed. \`pip install --upgrade lmnr\`, or if you are running this command from a virtual environment, make sure to activate it. For \`uv\` users, rerun the command with \`uv run\`, e.g. "uv run npx lmnr-cli dev ${filePathOrModule}"`);
+		logger$2.error(`Error while loading Python file/module: ${errorMessage}`);
+		if (errorMessage.toLowerCase().includes("command not found") || errorMessage.includes("spawn lmnr ENOENT")) logger$2.info(`HINT: Make sure latest version of \`lmnr\` python package is installed. \`pip install --upgrade lmnr\`, or if you are running this command from a virtual environment, make sure to activate it. For \`uv\` users, rerun the command with \`uv run\`, e.g. "uv run npx lmnr-cli dev ${filePathOrModule}"`);
 		throw error;
 	}
 };
@@ -1707,7 +2106,7 @@ const discoverFunctionMetadata = async (filePathOrModule, options) => {
 	const ext = path.extname(filePathOrModule);
 	if (TS_JS_EXTENSIONS.includes(ext)) return await discoverTypeScriptMetadata(filePathOrModule, options);
 	if (ext === ".py") return await discoverPythonMetadata(filePathOrModule, options);
-	logger$1.warn(`No metadata discovery available for ${ext} files`);
+	logger$2.warn(`No metadata discovery available for ${ext} files`);
 	return {
 		functionName: options.function || path.basename(filePathOrModule, ext),
 		params: []
@@ -1716,7 +2115,7 @@ const discoverFunctionMetadata = async (filePathOrModule, options) => {
 
 //#endregion
 //#region src/commands/dev/index.ts
-const logger = initializeLogger();
+const logger$1 = initializeLogger();
 function newUUID() {
 	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
 	return (0, uuid.v4)();
@@ -1747,7 +2146,7 @@ const tryParseArg = (arg) => {
 * Handles a run event from the backend
 */
 const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheServerPort, cache, setMetadata, options, subprocessManager) => {
-	logger.debug("Received run event");
+	logger$1.debug("Received run event");
 	const { trace_id, path_to_count, args: rawArgs, overrides } = event.data;
 	const parsedArgs = Array.isArray(rawArgs) ? rawArgs.map(tryParseArg) : Object.fromEntries(Object.entries(rawArgs).map(([key, value]) => [key, tryParseArg(value)]));
 	cache.clear();
@@ -1756,10 +2155,10 @@ const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheS
 		overrides
 	});
 	try {
-		if (!trace_id || trace_id.trim() === "") logger.info("No spans in cache, starting fresh");
+		if (!trace_id || trace_id.trim() === "") logger$1.info("No spans in cache, starting fresh");
 		else {
 			const paths = Object.keys(path_to_count || {});
-			if (paths.length === 0) logger.info("No spans to cache, starting fresh");
+			if (paths.length === 0) logger$1.info("No spans to cache, starting fresh");
 			else {
 				const query = `
           SELECT name, input, output, attributes, path
@@ -1768,12 +2167,12 @@ const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheS
             AND path IN {paths:String[]}
           ORDER BY start_time ASC
         `;
-				logger.debug(`Querying spans from trace ${trace_id}...`);
+				logger$1.debug(`Querying spans from trace ${trace_id}...`);
 				const spans = await client.sql.query(query, {
 					traceId: trace_id,
 					paths
 				});
-				logger.debug(`Received ${spans.length} spans from backend`);
+				logger$1.debug(`Received ${spans.length} spans from backend`);
 				const spansByPath = {};
 				for (const span of spans) {
 					const path$2 = span.path;
@@ -1811,7 +2210,7 @@ const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheS
 						const cacheKey = `${index}:${path$2}`;
 						cache.set(cacheKey, cachedSpan);
 					});
-					logger.info(`Cached ${spansToCache.length} spans for path: ${path$2}`);
+					logger$1.info(`Cached ${spansToCache.length} spans for path: ${path$2}`);
 				}
 				setMetadata({
 					pathToCount: path_to_count || {},
@@ -1850,7 +2249,7 @@ const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheS
 				status: "RUNNING"
 			});
 		} catch (error) {
-			logger.error(`Error setting debugger session status: ${error instanceof Error ? error.message : error}`);
+			logger$1.error(`Error setting debugger session status: ${error instanceof Error ? error.message : error}`);
 		}
 		await subprocessManager.execute({
 			command: workerCommand.command,
@@ -1863,18 +2262,18 @@ const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheS
 				status: "FINISHED"
 			});
 		} catch (error) {
-			logger.error(`Error setting debugger session status: ${error instanceof Error ? error.message : error}`);
+			logger$1.error(`Error setting debugger session status: ${error instanceof Error ? error.message : error}`);
 		}
 	} catch (error) {
-		logger.error(`Error handling run event: ${error instanceof Error ? error.message : error}`);
-		if (error instanceof Error && error.stack) logger.error(error.stack);
+		logger$1.error(`Error handling run event: ${error instanceof Error ? error.message : error}`);
+		if (error instanceof Error && error.stack) logger$1.error(error.stack);
 		try {
 			await client.rolloutSessions.setStatus({
 				sessionId,
 				status: "FINISHED"
 			});
 		} catch (error$1) {
-			logger.error(`Error setting debugger session status: ${error$1 instanceof Error ? error$1.message : error$1}`);
+			logger$1.error(`Error setting debugger session status: ${error$1 instanceof Error ? error$1.message : error$1}`);
 		}
 	}
 };
@@ -1891,30 +2290,30 @@ async function runDev(filePath, options = {}) {
 		projectApiKey: options.projectApiKey,
 		port: options.port
 	});
-	logger.debug("Starting cache server...");
+	logger$1.debug("Starting cache server...");
 	const { port: cacheServerPort, server: cacheServer, cache, setMetadata } = await startCacheServer();
-	logger.debug(`Cache server started on port ${cacheServerPort}`);
+	logger$1.debug(`Cache server started on port ${cacheServerPort}`);
 	const subprocessManager = new SubprocessManager();
 	let functionName = options.function;
 	let params = [];
 	try {
 		if (isPythonModule || filePath && EXTENSIONS_TO_DISCOVER_METADATA.includes(path.extname(filePath))) {
-			logger.debug("Discovering entrypoint functions...");
+			logger$1.debug("Discovering entrypoint functions...");
 			const metadata = await discoverFunctionMetadata(filePathOrModule, options);
 			functionName = metadata.functionName;
 			params = metadata.params;
-			logger.info(`Serving function: ${functionName}`);
-			logger.debug(`Function parameters: ${JSON.stringify(params, null, 2)}`);
+			logger$1.info(`Serving function: ${functionName}`);
+			logger$1.debug(`Function parameters: ${JSON.stringify(params, null, 2)}`);
 		} else if (filePath) {
 			functionName = options.function || path.basename(filePath, path.extname(filePath));
-			logger.warn(`Metadata discovery not available for ${path.extname(filePath)} files`);
+			logger$1.warn(`Metadata discovery not available for ${path.extname(filePath)} files`);
 		}
 	} catch (error) {
-		logger.error("Failed to discover entrypoint functions: " + (error instanceof Error ? error.message : String(error)));
+		logger$1.error("Failed to discover entrypoint functions: " + (error instanceof Error ? error.message : String(error)));
 		cacheServer.close();
 		throw error;
 	}
-	logger.debug("Setting up file watcher...");
+	logger$1.debug("Setting up file watcher...");
 	const watcher = chokidar.default.watch(".", {
 		ignored: (path$2) => {
 			const ignoredDirs = [
@@ -1949,7 +2348,7 @@ async function runDev(filePath, options = {}) {
 			pollInterval: 100
 		}
 	});
-	logger.debug("Setting up SSE client...");
+	logger$1.debug("Setting up SSE client...");
 	let sseClient = null;
 	try {
 		sseClient = createSSEClient({
@@ -1961,45 +2360,45 @@ async function runDev(filePath, options = {}) {
 		let currentRunPromise = null;
 		let stopRequested = false;
 		sseClient.on("heartbeat", () => {
-			logger.debug("Heartbeat received");
+			logger$1.debug("Heartbeat received");
 		});
 		sseClient.on("run", (event) => {
 			if (currentRunPromise !== null) {
-				logger.warn("Already processing a run event, skipping new run");
+				logger$1.warn("Already processing a run event, skipping new run");
 				return;
 			}
 			currentRunPromise = (async () => {
 				try {
 					stopRequested = false;
 					if (reloadScheduled) {
-						logger.info("Reloading function metadata before run...");
+						logger$1.info("Reloading function metadata before run...");
 						if (isPythonModule || filePath && EXTENSIONS_TO_DISCOVER_METADATA.includes(path.extname(filePath))) try {
 							const metadata = await discoverFunctionMetadata(filePathOrModule, options);
 							if (stopRequested) {
-								logger.info("Run cancelled during metadata discovery");
+								logger$1.info("Run cancelled during metadata discovery");
 								return;
 							}
-							logger.debug(`Updated function metadata: ${metadata.functionName}`);
-							logger.debug(`Updated parameters: ${JSON.stringify(metadata.params, null, 2)}`);
+							logger$1.debug(`Updated function metadata: ${metadata.functionName}`);
+							logger$1.debug(`Updated parameters: ${JSON.stringify(metadata.params, null, 2)}`);
 							if (sseClient) {
 								sseClient.updateMetadata(metadata.params, metadata.functionName);
-								logger.debug("Notified backend of metadata changes");
+								logger$1.debug("Notified backend of metadata changes");
 							}
 							reloadScheduled = false;
 						} catch (error) {
-							logger.error("Failed to update function metadata: " + (error instanceof Error ? error.message : String(error)));
-							if (error instanceof Error && error.stack) logger.debug(`Stack trace: ${error.stack}`);
+							logger$1.error("Failed to update function metadata: " + (error instanceof Error ? error.message : String(error)));
+							if (error instanceof Error && error.stack) logger$1.debug(`Stack trace: ${error.stack}`);
 							return;
 						}
 						else reloadScheduled = false;
 					}
 					if (stopRequested) {
-						logger.info("Run cancelled before execution");
+						logger$1.info("Run cancelled before execution");
 						return;
 					}
 					await handleRunEvent(event, sessionId, filePathOrModule, client, cacheServerPort, cache, setMetadata, options, subprocessManager);
 				} catch (error) {
-					logger.error("Unhandled error in run event handler: " + (error instanceof Error ? error.message : String(error)));
+					logger$1.error("Unhandled error in run event handler: " + (error instanceof Error ? error.message : String(error)));
 				} finally {
 					currentRunPromise = null;
 				}
@@ -2009,65 +2408,65 @@ async function runDev(filePath, options = {}) {
 			const projectId = event.data.project_id;
 			const sessionId$1 = event.data.session_id;
 			const frontendUrl = getFrontendUrl(options.baseUrl, options.frontendPort);
-			if (!didLogHandshake) logger.info(`View your session at ${frontendUrl}/project/${projectId}/debugger-sessions/${sessionId$1}`);
+			if (!didLogHandshake) logger$1.info(`View your session at ${frontendUrl}/project/${projectId}/debugger-sessions/${sessionId$1}`);
 			didLogHandshake = true;
 		});
 		sseClient.on("error", (error) => {
-			logger.warn(`Error connecting to backend: ${error.message}`);
+			logger$1.warn(`Error connecting to backend: ${error.message}`);
 		});
 		sseClient.on("reconnecting", () => {
-			logger.info("Reconnecting to backend...");
+			logger$1.info("Reconnecting to backend...");
 		});
 		sseClient.on("heartbeat_timeout", () => {
-			logger.debug("Heartbeat timeout, reconnecting...");
+			logger$1.debug("Heartbeat timeout, reconnecting...");
 		});
 		sseClient.on("stop", () => {
-			logger.debug("Stop event received");
+			logger$1.debug("Stop event received");
 			stopRequested = true;
-			if (subprocessManager.kill()) logger.info("Current run cancelled");
+			if (subprocessManager.kill()) logger$1.info("Current run cancelled");
 		});
 		let reloadTimeout = null;
 		let reloadScheduled = false;
 		watcher.on("change", (changedPath) => {
-			logger.info(`File changed: ${changedPath}, scheduling reload...`);
+			logger$1.info(`File changed: ${changedPath}, scheduling reload...`);
 			if (reloadTimeout) clearTimeout(reloadTimeout);
 			reloadTimeout = setTimeout(() => {
-				logger.debug("Marking reload as scheduled for next run...");
+				logger$1.debug("Marking reload as scheduled for next run...");
 				reloadTimeout = null;
 				reloadScheduled = true;
 			}, 100);
 		});
 		const shutdown = () => {
-			logger.debug("Shutting down...");
+			logger$1.debug("Shutting down...");
 			if (reloadTimeout) {
 				clearTimeout(reloadTimeout);
 				reloadTimeout = null;
 			}
 			reloadScheduled = false;
-			logger.debug("Closing file watcher...");
+			logger$1.debug("Closing file watcher...");
 			watcher.close().catch((error) => {
-				logger.error(`Failed to close file watcher: ${error instanceof Error ? error.message : error}`);
+				logger$1.error(`Failed to close file watcher: ${error instanceof Error ? error.message : error}`);
 			});
 			subprocessManager.kill();
-			logger.debug("Deleting debugger session...");
+			logger$1.debug("Deleting debugger session...");
 			client.rolloutSessions.delete({ sessionId }).then(() => {
 				if (sseClient) sseClient.shutdown();
 				cacheServer.close(() => {
-					logger.debug("Cache server closed");
+					logger$1.debug("Cache server closed");
 				});
 				process.exit(0);
 			}).catch((error) => {
-				logger.warn(`Failed to delete debugger session: ${error instanceof Error ? error.message : error}`);
+				logger$1.warn(`Failed to delete debugger session: ${error instanceof Error ? error.message : error}`);
 				process.exit(1);
 			});
 		};
 		process.on("SIGINT", shutdown);
 		process.on("SIGTERM", shutdown);
 		process.stdin.resume();
-		logger.debug("Connecting to backend...");
+		logger$1.debug("Connecting to backend...");
 		await sseClient.connectAndListen();
 	} catch (error) {
-		logger.error("Failed to start dev command: " + (error instanceof Error ? error.message : String(error)));
+		logger$1.error("Failed to start dev command: " + (error instanceof Error ? error.message : String(error)));
 		try {
 			await client.rolloutSessions.delete({ sessionId });
 		} catch {}
@@ -2078,11 +2477,92 @@ async function runDev(filePath, options = {}) {
 	}
 }
 
+//#endregion
+//#region src/commands/sql/index.ts
+const logger = initializeLogger();
+const handleSqlQuery = async (query, options) => {
+	const client = new LaminarClient({
+		projectApiKey: options.projectApiKey,
+		baseUrl: options.baseUrl,
+		port: options.port
+	});
+	try {
+		const rows = await client.sql.query(query);
+		if (options.json) {
+			outputJson(rows);
+			return;
+		}
+		if (rows.length === 0) {
+			console.log("No rows returned.");
+			return;
+		}
+		const columns = Object.keys(rows[0]);
+		const widths = columns.map((col) => rows.reduce((max, r) => Math.max(max, String(r[col] ?? "").length), col.length));
+		const header = columns.map((col, i) => col.padEnd(widths[i])).join(" ");
+		const divider = widths.map((w) => "-".repeat(w)).join(" ");
+		console.log(`\n${header}`);
+		console.log(divider);
+		for (const row of rows) console.log(columns.map((col, i) => String(row[col] ?? "").padEnd(widths[i])).join(" "));
+		console.log(`\n${rows.length} row(s)\n`);
+	} catch (error) {
+		if (options.json) outputJsonError(error);
+		logger.error(`Query failed: ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+};
+
+//#endregion
+//#region src/commands/sql/schema.ts
+const SQL_SCHEMA_HELP = `
+Available tables:
+  spans
+    span_id (UUID), name (String), span_type (String: DEFAULT|LLM|TOOL),
+    start_time (DateTime64), end_time (DateTime64), duration (Float64),
+    input_cost (Float64), output_cost (Float64), total_cost (Float64),
+    input_tokens (Int64), output_tokens (Int64), total_tokens (Int64),
+    request_model (String), response_model (String), model (String),
+    trace_id (UUID), provider (String), path (String),
+    input (String), output (String), status (String),
+    parent_span_id (UUID), attributes (String), tags (Array(String))
+
+  traces
+    id (UUID), start_time (DateTime64), end_time (DateTime64),
+    input_tokens (Int64), output_tokens (Int64), total_tokens (Int64),
+    input_cost (Float64), output_cost (Float64), total_cost (Float64),
+    duration (Float64), metadata (String), session_id (String),
+    user_id (String), status (String), top_span_id (UUID),
+    top_span_name (String), top_span_type (String), trace_type (String),
+    tags (Array(String)), has_browser_session (Bool)
+
+  events
+    id (UUID), type (String), name (String), span_id (UUID),
+    timestamp (DateTime64), attributes (String)
+
+  signal_events
+    id (UUID), signal_id (UUID), trace_id (UUID), run_id (UUID),
+    name (String), payload (String), timestamp (DateTime64)
+
+  signal_runs
+    signal_id (UUID), job_id (UUID), trigger_id (UUID), run_id (UUID),
+    trace_id (UUID), status (String), event_id (UUID), updated_at (DateTime64)
+
+  evaluation_datapoints
+    id (UUID), evaluation_id (UUID), data (String), target (String),
+    metadata (String), executor_output (String), index (UInt64),
+    trace_id (UUID), group_id (String), scores (String),
+    created_at (DateTime64), dataset_id (UUID),
+    dataset_datapoint_id (UUID), dataset_datapoint_created_at (DateTime64)
+
+  dataset_datapoints
+    id (UUID), created_at (DateTime64), dataset_id (UUID),
+    data (String), target (String), metadata (String)
+`;
+
 //#endregion
 //#region src/index.ts
 async function main() {
 	const program = new commander.Command();
-	program.name("lmnr-cli").description("CLI for Laminar agent debugger").version(version$1, "-v, --version", "display version number");
+	program.name("lmnr-cli").description("CLI for the Laminar agent observability platform").version(version$1, "-v, --version", "display version number");
 	program.command("dev").description("Start a debugging session").argument("[file]", "Path to file containing the entrypoint function(s). Either `file` or `-m` must be provided.").option("-m, --python-module <module>", "Python module path (e.g., src.myfile). Either `file` or `-m` must be provided.").option("--function <name>", "Specific function to serve (if multiple entrypoint functions found)").option("--project-api-key <key>", "Project API key. If not provided, reads from LMNR_PROJECT_API_KEY env variable").option("--base-url <url>", "Base URL for the Laminar API. Defaults to https://api.lmnr.ai or LMNR_BASE_URL env variable").option("--port <port>", "Port for the Laminar API. Defaults to 443", (val) => parseInt(val, 10)).option("--grpc-port <port>", "Port for the Laminar gRPC backend. Defaults to 8443", (val) => parseInt(val, 10)).option("--frontend-port <port>", "Port for the Laminar frontend. Defaults to 5667", (val) => parseInt(val, 10)).option("--external-packages <packages...>", "[ADVANCED] List of packages to pass as external to esbuild. This will not link the packages directly into the dev file, but will instead require them at runtime. Read more: https://esbuild.github.io/api/#external").option("--dynamic-imports-to-skip <modules...>", "[ADVANCED] List of module names to skip when encountered as dynamic imports. These dynamic imports will resolve to an empty module to prevent build failures. This is meant to skip the imports that are not used in the entrypoint function itself.").option("--command <command>", "[ADVANCED] Custom command to run the worker (e.g., python3, node)").option("--command-args <args...>", "[ADVANCED] Arguments for the custom command").action(async (file, options) => {
 		if (!file && !options.pythonModule) {
 			console.error("Error: Must provide either a file path or --python-module (-m) flag");
@@ -2099,6 +2579,44 @@ Examples:
   $ lmnr-cli dev agent.py                    # Python file (script mode)
   $ lmnr-cli dev -m src.agent                # Python module (module mode)
   $ lmnr-cli dev agent.ts --function myAgent # Specific function
+`);
+	const datasetsCmd = program.command("dataset").description("Manage datasets").option("--project-api-key <key>", "Project API key. If not provided, reads from LMNR_PROJECT_API_KEY env variable").option("--base-url <url>", "Base URL for the Laminar API. Defaults to https://api.lmnr.ai or LMNR_BASE_URL env variable").option("--port <port>", "Port for the Laminar API. Defaults to 443", (val) => parseInt(val, 10)).option("--json", "Output structured JSON to stdout");
+	datasetsCmd.command("list").description("List all datasets").action(async (_options, cmd) => {
+		await handleDatasetsList(cmd.optsWithGlobals());
+	});
+	datasetsCmd.command("push").description("Push datapoints to an existing dataset").argument("<paths...>", "Paths to files or directories containing data to push").option("-n, --name <name>", "Name of the dataset (either name or id must be provided)").option("--id <id>", "ID of the dataset (either name or id must be provided)").option("-r, --recursive", "Recursively read files in directories", false).option("--batch-size <size>", "Batch size for pushing data", (val) => parseInt(val, 10), 100).action(async (paths, _options, cmd) => {
+		await handleDatasetsPush(paths, cmd.optsWithGlobals());
+	});
+	datasetsCmd.command("pull").description("Pull data from a dataset").argument("[output-path]", "Path to save the data. If not provided, prints to console").option("-n, --name <name>", "Name of the dataset (either name or id must be provided)").option("--id <id>", "ID of the dataset (either name or id must be provided)").option("--output-format <format>", "Output format (json, csv, jsonl). Inferred from file extension if not provided").option("--batch-size <size>", "Batch size for pulling data", (val) => parseInt(val, 10), 100).option("--limit <limit>", "Limit number of datapoints to pull", (val) => parseInt(val, 10)).option("--offset <offset>", "Offset for pagination", (val) => parseInt(val, 10), 0).action(async (outputPath, _options, cmd) => {
+		await handleDatasetsPull(outputPath, cmd.optsWithGlobals());
+	});
+	datasetsCmd.command("create").description("Create a dataset from input files").argument("<name>", "Name of the dataset to create").argument("<paths...>", "Paths to files or directories containing data to push").requiredOption("-o, --output-file <file>", "Path to save the pulled data").option("--output-format <format>", "Output format (json, csv, jsonl). Inferred from file extension if not provided").option("-r, --recursive", "Recursively read files in directories", false).option("--batch-size <size>", "Batch size for pushing/pulling data", (val) => parseInt(val, 10), 100).action(async (name, paths, _options, cmd) => {
+		await handleDatasetsCreate(name, paths, cmd.optsWithGlobals());
+	});
+	const sqlCmd = program.command("sql").description("Run SQL queries against your Laminar project data").option("--project-api-key <key>", "Project API key. If not provided, reads from LMNR_PROJECT_API_KEY env variable").option("--base-url <url>", "Base URL for the Laminar API. Defaults to https://api.lmnr.ai or LMNR_BASE_URL env variable").option("--port <port>", "Port for the Laminar API. Defaults to 443", (val) => parseInt(val, 10)).option("--json", "Output structured JSON to stdout");
+	sqlCmd.command("query").description("Execute a SQL query").argument("<query>", "SQL query string").action(async (query, _options, cmd) => {
+		await handleSqlQuery(query, cmd.optsWithGlobals());
+	}).addHelpText("after", SQL_SCHEMA_HELP + `
+Examples:
+  $ lmnr-cli sql query "SELECT * FROM spans LIMIT 10"
+  $ lmnr-cli sql query "SELECT id, total_cost, status FROM traces LIMIT 20"
+  $ lmnr-cli sql query "SELECT * FROM spans LIMIT 10" --json
+`);
+	sqlCmd.command("schema").description("Show available tables and their columns").action(() => {
+		process.stdout.write(SQL_SCHEMA_HELP);
+	});
+	program.addHelpText("after", `
+Examples:
+  lmnr-cli dev agent.ts                                       # Debugger TypeScript entrypoint
+  lmnr-cli dev agent.py                                       # Debugger Python script mode
+  lmnr-cli dev -m src.agent                                   # Debuger Python module mode
+  lmnr-cli dataset list --json                               # List all datasets
+  lmnr-cli dataset push data.jsonl -n my-dataset --json     # Push data to a dataset
+  lmnr-cli dataset pull output.jsonl -n my-dataset --json   # Pull data from a dataset
+  lmnr-cli sql query "SELECT * FROM spans LIMIT 10" --json   # Query spans
+  lmnr-cli sql query "SELECT t.id, s.name FROM traces t \
+    JOIN spans s ON t.id = s.trace_id LIMIT 20" --json
+  lmnr-cli sql schema                                         # Show available tables
 `);
 	await program.parseAsync();
 }