@puyinkai/xiaobao-cli 0.1.0

package/dist/format-BZvv8lYc.mjs

@@ -0,0 +1,610 @@
+//#region node_modules/.pnpm/@toon-format+toon@2.2.0/node_modules/@toon-format/toon/dist/index.mjs
+const NULL_LITERAL = "null";
+const DEFAULT_DELIMITER = {
+	comma: ",",
+	tab: "	",
+	pipe: "|"
+}.comma;
+/**
+* Escapes special characters in a string for encoding.
+*
+* @remarks
+* Handles backslashes, quotes, newlines, carriage returns, and tabs.
+*/
+function escapeString(value) {
+	return value.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`).replace(/\n/g, `\\n`).replace(/\r/g, `\\r`).replace(/\t/g, `\\t`);
+}
+function isBooleanOrNullLiteral(token) {
+	return token === "true" || token === "false" || token === "null";
+}
+function normalizeValue(value) {
+	if (value === null) return null;
+	if (typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function") {
+		const next = value.toJSON();
+		if (next !== value) return normalizeValue(next);
+	}
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (Object.is(value, -0)) return 0;
+		if (!Number.isFinite(value)) return null;
+		return value;
+	}
+	if (typeof value === "bigint") {
+		if (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER) return Number(value);
+		return value.toString();
+	}
+	if (value instanceof Date) return value.toISOString();
+	if (Array.isArray(value)) return value.map(normalizeValue);
+	if (value instanceof Set) return Array.from(value).map(normalizeValue);
+	if (value instanceof Map) return Object.fromEntries(Array.from(value, ([k, v]) => [String(k), normalizeValue(v)]));
+	if (isPlainObject(value)) {
+		const encodedValues = {};
+		for (const key in value) if (Object.hasOwn(value, key)) encodedValues[key] = normalizeValue(value[key]);
+		return encodedValues;
+	}
+	return null;
+}
+function isJsonPrimitive(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonArray(value) {
+	return Array.isArray(value);
+}
+function isJsonObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isEmptyObject(value) {
+	return Object.keys(value).length === 0;
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+}
+function isArrayOfPrimitives(value) {
+	return value.length === 0 || value.every((item) => isJsonPrimitive(item));
+}
+function isArrayOfArrays(value) {
+	return value.length === 0 || value.every((item) => isJsonArray(item));
+}
+function isArrayOfObjects(value) {
+	return value.length === 0 || value.every((item) => isJsonObject(item));
+}
+const NUMERIC_LIKE_PATTERN = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+const LEADING_ZERO_PATTERN = /^0\d+$/;
+/**
+* Checks if a key can be used without quotes.
+*
+* @remarks
+* Valid unquoted keys must start with a letter or underscore,
+* followed by letters, digits, underscores, or dots.
+*/
+function isValidUnquotedKey(key) {
+	return /^[A-Z_][\w.]*$/i.test(key);
+}
+/**
+* Checks if a key segment is a valid identifier for safe folding/expansion.
+*
+* @remarks
+* Identifier segments are more restrictive than unquoted keys:
+* - Must start with a letter or underscore
+* - Followed only by letters, digits, or underscores (no dots)
+* - Used for safe key folding and path expansion
+*/
+function isIdentifierSegment(key) {
+	return /^[A-Z_]\w*$/i.test(key);
+}
+/**
+* Determines if a string value can be safely encoded without quotes.
+*
+* @remarks
+* A string needs quoting if it:
+* - Is empty
+* - Has leading or trailing whitespace
+* - Could be confused with a literal (boolean, null, number)
+* - Contains structural characters (colons, brackets, braces)
+* - Contains quotes or backslashes (need escaping)
+* - Contains control characters (newlines, tabs, etc.)
+* - Contains the active delimiter
+* - Starts with a list marker (hyphen)
+*/
+function isSafeUnquoted(value, delimiter = DEFAULT_DELIMITER) {
+	if (!value) return false;
+	if (value !== value.trim()) return false;
+	if (isBooleanOrNullLiteral(value) || isNumericLike(value)) return false;
+	if (value.includes(":")) return false;
+	if (value.includes("\"") || value.includes("\\")) return false;
+	if (/[[\]{}]/.test(value)) return false;
+	if (/[\n\r\t]/.test(value)) return false;
+	if (value.includes(delimiter)) return false;
+	if (value.startsWith("-")) return false;
+	return true;
+}
+/**
+* Checks if a string looks like a number.
+*
+* @remarks
+* Match numbers like `42`, `-3.14`, `1e-6`, `05`, etc.
+*/
+function isNumericLike(value) {
+	return NUMERIC_LIKE_PATTERN.test(value) || LEADING_ZERO_PATTERN.test(value);
+}
+/**
+* Attempts to fold a single-key object chain into a dotted path.
+*
+* @remarks
+* Folding traverses nested objects with single keys, collapsing them into a dotted path.
+* It stops when:
+* - A non-single-key object is encountered
+* - An array is encountered (arrays are not "single-key objects")
+* - A primitive value is reached
+* - The flatten depth limit is reached
+* - Any segment fails safe mode validation
+*
+* Safe mode requirements:
+* - `options.keyFolding` must be `'safe'`
+* - Every segment must be a valid identifier (no dots, no special chars)
+* - The folded key must not collide with existing sibling keys
+* - No segment should require quoting
+*
+* @param key - The starting key to fold
+* @param value - The value associated with the key
+* @param siblings - Array of all sibling keys at this level (for collision detection)
+* @param options - Resolved encoding options
+* @returns A FoldResult if folding is possible, undefined otherwise
+*/
+function tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, flattenDepth) {
+	if (options.keyFolding !== "safe") return;
+	if (!isJsonObject(value)) return;
+	const { segments, tail, leafValue } = collectSingleKeyChain(key, value, flattenDepth ?? options.flattenDepth);
+	if (segments.length < 2) return;
+	if (!segments.every((seg) => isIdentifierSegment(seg))) return;
+	const foldedKey = buildFoldedKey(segments);
+	const absolutePath = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
+	if (siblings.includes(foldedKey)) return;
+	if (rootLiteralKeys && rootLiteralKeys.has(absolutePath)) return;
+	return {
+		foldedKey,
+		remainder: tail,
+		leafValue,
+		segmentCount: segments.length
+	};
+}
+/**
+* Collects a chain of single-key objects into segments.
+*
+* @remarks
+* Traverses nested objects, collecting keys until:
+* - A non-single-key object is found
+* - An array is encountered
+* - A primitive is reached
+* - An empty object is reached
+* - The depth limit is reached
+*
+* @param startKey - The initial key to start the chain
+* @param startValue - The value to traverse
+* @param maxDepth - Maximum number of segments to collect
+* @returns Object containing segments array, tail value, and leaf value
+*/
+function collectSingleKeyChain(startKey, startValue, maxDepth) {
+	const segments = [startKey];
+	let currentValue = startValue;
+	while (segments.length < maxDepth) {
+		if (!isJsonObject(currentValue)) break;
+		const keys = Object.keys(currentValue);
+		if (keys.length !== 1) break;
+		const nextKey = keys[0];
+		const nextValue = currentValue[nextKey];
+		segments.push(nextKey);
+		currentValue = nextValue;
+	}
+	if (!isJsonObject(currentValue) || isEmptyObject(currentValue)) return {
+		segments,
+		tail: void 0,
+		leafValue: currentValue
+	};
+	return {
+		segments,
+		tail: currentValue,
+		leafValue: currentValue
+	};
+}
+function buildFoldedKey(segments) {
+	return segments.join(".");
+}
+function encodePrimitive(value, delimiter) {
+	if (value === null) return NULL_LITERAL;
+	if (typeof value === "boolean") return String(value);
+	if (typeof value === "number") return String(value);
+	return encodeStringLiteral(value, delimiter);
+}
+function encodeStringLiteral(value, delimiter = DEFAULT_DELIMITER) {
+	if (isSafeUnquoted(value, delimiter)) return value;
+	return `"${escapeString(value)}"`;
+}
+function encodeKey(key) {
+	if (isValidUnquotedKey(key)) return key;
+	return `"${escapeString(key)}"`;
+}
+function encodeAndJoinPrimitives(values, delimiter = DEFAULT_DELIMITER) {
+	return values.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+}
+function formatHeader(length, options) {
+	const key = options?.key;
+	const fields = options?.fields;
+	const delimiter = options?.delimiter ?? ",";
+	let header = "";
+	if (key != null) header += encodeKey(key);
+	header += `[${length}${delimiter !== DEFAULT_DELIMITER ? delimiter : ""}]`;
+	if (fields) {
+		const quotedFields = fields.map((f) => encodeKey(f));
+		header += `{${quotedFields.join(delimiter)}}`;
+	}
+	header += ":";
+	return header;
+}
+function* encodeJsonValue(value, options, depth) {
+	if (isJsonPrimitive(value)) {
+		const encodedPrimitive = encodePrimitive(value, options.delimiter);
+		if (encodedPrimitive !== "") yield encodedPrimitive;
+		return;
+	}
+	if (isJsonArray(value)) yield* encodeArrayLines(void 0, value, depth, options);
+	else if (isJsonObject(value)) yield* encodeObjectLines(value, depth, options);
+}
+function* encodeObjectLines(value, depth, options, rootLiteralKeys, pathPrefix, remainingDepth) {
+	const keys = Object.keys(value);
+	if (depth === 0 && !rootLiteralKeys) rootLiteralKeys = new Set(keys.filter((k) => k.includes(".")));
+	const effectiveFlattenDepth = remainingDepth ?? options.flattenDepth;
+	for (const [key, val] of Object.entries(value)) yield* encodeKeyValuePairLines(key, val, depth, options, keys, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+}
+function* encodeKeyValuePairLines(key, value, depth, options, siblings, rootLiteralKeys, pathPrefix, flattenDepth) {
+	const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+	const effectiveFlattenDepth = flattenDepth ?? options.flattenDepth;
+	if (options.keyFolding === "safe" && siblings) {
+		const foldResult = tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+		if (foldResult) {
+			const { foldedKey, remainder, leafValue, segmentCount } = foldResult;
+			const encodedFoldedKey = encodeKey(foldedKey);
+			if (remainder === void 0) {
+				if (isJsonPrimitive(leafValue)) {
+					yield indentedLine(depth, `${encodedFoldedKey}: ${encodePrimitive(leafValue, options.delimiter)}`, options.indent);
+					return;
+				} else if (isJsonArray(leafValue)) {
+					yield* encodeArrayLines(foldedKey, leafValue, depth, options);
+					return;
+				} else if (isJsonObject(leafValue) && isEmptyObject(leafValue)) {
+					yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+					return;
+				}
+			}
+			if (isJsonObject(remainder)) {
+				yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+				const remainingDepth = effectiveFlattenDepth - segmentCount;
+				const foldedPath = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
+				yield* encodeObjectLines(remainder, depth + 1, options, rootLiteralKeys, foldedPath, remainingDepth);
+				return;
+			}
+		}
+	}
+	const encodedKey = encodeKey(key);
+	if (isJsonPrimitive(value)) yield indentedLine(depth, `${encodedKey}: ${encodePrimitive(value, options.delimiter)}`, options.indent);
+	else if (isJsonArray(value)) yield* encodeArrayLines(key, value, depth, options);
+	else if (isJsonObject(value)) {
+		yield indentedLine(depth, `${encodedKey}:`, options.indent);
+		if (!isEmptyObject(value)) yield* encodeObjectLines(value, depth + 1, options, rootLiteralKeys, currentPath, effectiveFlattenDepth);
+	}
+}
+function* encodeArrayLines(key, value, depth, options) {
+	if (value.length === 0) {
+		yield indentedLine(depth, formatHeader(0, {
+			key,
+			delimiter: options.delimiter
+		}), options.indent);
+		return;
+	}
+	if (isArrayOfPrimitives(value)) {
+		yield indentedLine(depth, encodeInlineArrayLine(value, options.delimiter, key), options.indent);
+		return;
+	}
+	if (isArrayOfArrays(value)) {
+		if (value.every((arr) => isArrayOfPrimitives(arr))) {
+			yield* encodeArrayOfArraysAsListItemsLines(key, value, depth, options);
+			return;
+		}
+	}
+	if (isArrayOfObjects(value)) {
+		const header = extractTabularHeader(value);
+		if (header) yield* encodeArrayOfObjectsAsTabularLines(key, value, header, depth, options);
+		else yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+		return;
+	}
+	yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+}
+function* encodeArrayOfArraysAsListItemsLines(prefix, values, depth, options) {
+	yield indentedLine(depth, formatHeader(values.length, {
+		key: prefix,
+		delimiter: options.delimiter
+	}), options.indent);
+	for (const arr of values) if (isArrayOfPrimitives(arr)) {
+		const arrayLine = encodeInlineArrayLine(arr, options.delimiter);
+		yield indentedListItem(depth + 1, arrayLine, options.indent);
+	}
+}
+function encodeInlineArrayLine(values, delimiter, prefix) {
+	const header = formatHeader(values.length, {
+		key: prefix,
+		delimiter
+	});
+	const joinedValue = encodeAndJoinPrimitives(values, delimiter);
+	if (values.length === 0) return header;
+	return `${header} ${joinedValue}`;
+}
+function* encodeArrayOfObjectsAsTabularLines(prefix, rows, header, depth, options) {
+	yield indentedLine(depth, formatHeader(rows.length, {
+		key: prefix,
+		fields: header,
+		delimiter: options.delimiter
+	}), options.indent);
+	yield* writeTabularRowsLines(rows, header, depth + 1, options);
+}
+function extractTabularHeader(rows) {
+	if (rows.length === 0) return;
+	const firstRow = rows[0];
+	const firstKeys = Object.keys(firstRow);
+	if (firstKeys.length === 0) return;
+	if (isTabularArray(rows, firstKeys)) return firstKeys;
+}
+function isTabularArray(rows, header) {
+	for (const row of rows) {
+		if (Object.keys(row).length !== header.length) return false;
+		for (const key of header) {
+			if (!(key in row)) return false;
+			if (!isJsonPrimitive(row[key])) return false;
+		}
+	}
+	return true;
+}
+function* writeTabularRowsLines(rows, header, depth, options) {
+	for (const row of rows) yield indentedLine(depth, encodeAndJoinPrimitives(header.map((key) => row[key]), options.delimiter), options.indent);
+}
+function* encodeMixedArrayAsListItemsLines(prefix, items, depth, options) {
+	yield indentedLine(depth, formatHeader(items.length, {
+		key: prefix,
+		delimiter: options.delimiter
+	}), options.indent);
+	for (const item of items) yield* encodeListItemValueLines(item, depth + 1, options);
+}
+function* encodeObjectAsListItemLines(obj, depth, options) {
+	if (isEmptyObject(obj)) {
+		yield indentedLine(depth, "-", options.indent);
+		return;
+	}
+	const entries = Object.entries(obj);
+	const [firstKey, firstValue] = entries[0];
+	const restEntries = entries.slice(1);
+	if (isJsonArray(firstValue) && isArrayOfObjects(firstValue)) {
+		const header = extractTabularHeader(firstValue);
+		if (header) {
+			yield indentedListItem(depth, formatHeader(firstValue.length, {
+				key: firstKey,
+				fields: header,
+				delimiter: options.delimiter
+			}), options.indent);
+			yield* writeTabularRowsLines(firstValue, header, depth + 2, options);
+			if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+			return;
+		}
+	}
+	const encodedKey = encodeKey(firstKey);
+	if (isJsonPrimitive(firstValue)) yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indent);
+	else if (isJsonArray(firstValue)) if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}${formatHeader(0, { delimiter: options.delimiter })}`, options.indent);
+	else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indent);
+	else {
+		yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indent);
+		for (const item of firstValue) yield* encodeListItemValueLines(item, depth + 2, options);
+	}
+	else if (isJsonObject(firstValue)) {
+		yield indentedListItem(depth, `${encodedKey}:`, options.indent);
+		if (!isEmptyObject(firstValue)) yield* encodeObjectLines(firstValue, depth + 2, options);
+	}
+	if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+}
+function* encodeListItemValueLines(value, depth, options) {
+	if (isJsonPrimitive(value)) yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indent);
+	else if (isJsonArray(value)) if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indent);
+	else {
+		yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indent);
+		for (const item of value) yield* encodeListItemValueLines(item, depth + 1, options);
+	}
+	else if (isJsonObject(value)) yield* encodeObjectAsListItemLines(value, depth, options);
+}
+function indentedLine(depth, content, indentSize) {
+	return " ".repeat(indentSize * depth) + content;
+}
+function indentedListItem(depth, content, indentSize) {
+	return indentedLine(depth, "- " + content, indentSize);
+}
+/**
+* Applies a replacer function to a `JsonValue` and all its descendants.
+*
+* The replacer is called for:
+* - The root value (with key='', path=[])
+* - Every object property (with the property name as key)
+* - Every array element (with the string index as key: '0', '1', etc.)
+*
+* @param root - The normalized `JsonValue` to transform
+* @param replacer - The replacer function to apply
+* @returns The transformed `JsonValue`
+*/
+function applyReplacer(root, replacer) {
+	const replacedRoot = replacer("", root, []);
+	if (replacedRoot === void 0) return transformChildren(root, replacer, []);
+	return transformChildren(normalizeValue(replacedRoot), replacer, []);
+}
+/**
+* Recursively transforms the children of a `JsonValue` using the replacer.
+*
+* @param value - The value whose children should be transformed
+* @param replacer - The replacer function to apply
+* @param path - Current path from root
+* @returns The value with transformed children
+*/
+function transformChildren(value, replacer, path) {
+	if (isJsonObject(value)) return transformObject(value, replacer, path);
+	if (isJsonArray(value)) return transformArray(value, replacer, path);
+	return value;
+}
+/**
+* Transforms an object by applying the replacer to each property.
+*
+* @param obj - The object to transform
+* @param replacer - The replacer function to apply
+* @param path - Current path from root
+* @returns A new object with transformed properties
+*/
+function transformObject(obj, replacer, path) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const childPath = [...path, key];
+		const replacedValue = replacer(key, value, childPath);
+		if (replacedValue === void 0) continue;
+		result[key] = transformChildren(normalizeValue(replacedValue), replacer, childPath);
+	}
+	return result;
+}
+/**
+* Transforms an array by applying the replacer to each element.
+*
+* @param arr - The array to transform
+* @param replacer - The replacer function to apply
+* @param path - Current path from root
+* @returns A new array with transformed elements
+*/
+function transformArray(arr, replacer, path) {
+	const result = [];
+	for (let i = 0; i < arr.length; i++) {
+		const value = arr[i];
+		const childPath = [...path, i];
+		const replacedValue = replacer(String(i), value, childPath);
+		if (replacedValue === void 0) continue;
+		const normalizedValue = normalizeValue(replacedValue);
+		result.push(transformChildren(normalizedValue, replacer, childPath));
+	}
+	return result;
+}
+/**
+* Encodes a JavaScript value into TOON format string.
+*
+* @param input - Any JavaScript value (objects, arrays, primitives)
+* @param options - Optional encoding configuration
+* @returns TOON formatted string
+*
+* @example
+* ```ts
+* encode({ name: 'Alice', age: 30 })
+* // name: Alice
+* // age: 30
+*
+* encode({ users: [{ id: 1 }, { id: 2 }] })
+* // users[]:
+* //   - id: 1
+* //   - id: 2
+*
+* encode(data, { indent: 4, keyFolding: 'safe' })
+* ```
+*/
+function encode(input, options) {
+	return Array.from(encodeLines(input, options)).join("\n");
+}
+/**
+* Encodes a JavaScript value into TOON format as a sequence of lines.
+*
+* This function yields TOON lines one at a time without building the full string,
+* making it suitable for streaming large outputs to files, HTTP responses, or process stdout.
+*
+* @param input - Any JavaScript value (objects, arrays, primitives)
+* @param options - Optional encoding configuration
+* @returns Iterable of TOON lines (without trailing newlines)
+*
+* @example
+* ```ts
+* // Stream to stdout
+* for (const line of encodeLines({ name: 'Alice', age: 30 })) {
+*   console.log(line)
+* }
+*
+* // Collect to array
+* const lines = Array.from(encodeLines(data))
+*
+* // Equivalent to encode()
+* const toonString = Array.from(encodeLines(data, options)).join('\n')
+* ```
+*/
+function encodeLines(input, options) {
+	const normalizedValue = normalizeValue(input);
+	const resolvedOptions = resolveOptions(options);
+	return encodeJsonValue(resolvedOptions.replacer ? applyReplacer(normalizedValue, resolvedOptions.replacer) : normalizedValue, resolvedOptions, 0);
+}
+function resolveOptions(options) {
+	return {
+		indent: options?.indent ?? 2,
+		delimiter: options?.delimiter ?? DEFAULT_DELIMITER,
+		keyFolding: options?.keyFolding ?? "off",
+		flattenDepth: options?.flattenDepth ?? Number.POSITIVE_INFINITY,
+		replacer: options?.replacer
+	};
+}
+//#endregion
+//#region src/output/format.ts
+/**
+* Format a result payload to stdout in one of three flavours:
+*
+*   json   (default)   pretty JSON, agent-friendly and human-OK
+*   toon              TOON (Token-Oriented Object Notation) — ~30-50% fewer
+*                     tokens on uniform array-of-objects (LLM context optimization)
+*   table             not implemented in 0.1.0 — falls back to pretty JSON
+*                     (a v0.1.x target; pure cosmetic, doesn't affect agent flow)
+*
+* Errors / logs MUST NOT go through here — use stderr (console.error) so
+* agents parsing stdout don't break.
+*/
+function writeResult(data, format = "json") {
+	const text = normalize(format) === "toon" ? encode(data) : JSON.stringify(data, null, 2);
+	process.stdout.write(text + "\n");
+}
+/** Print an error structurally to stdout (still parseable) and a hint to stderr. */
+function writeError(error, format = "json") {
+	const payload = serializeError(error);
+	const text = normalize(format) === "toon" ? encode(payload) : JSON.stringify(payload, null, 2);
+	process.stdout.write(text + "\n");
+	const hint = payload.message;
+	if (hint) process.stderr.write(`error: ${hint}\n`);
+}
+function normalize(f) {
+	if (f === "toon") return "toon";
+	if (f === "table") return "table";
+	return "json";
+}
+function serializeError(error) {
+	if (error instanceof Error) return {
+		error: error.name,
+		message: error.message
+	};
+	if (error && typeof error === "object") {
+		const obj = error;
+		const errorKey = obj.code ?? obj.error ?? "UNKNOWN";
+		return {
+			error: errorKey,
+			message: obj.message ?? (obj.status != null ? `HTTP ${obj.status}` : null) ?? String(errorKey),
+			...obj.status != null ? { status: obj.status } : {},
+			...obj.body != null ? { details: obj.body } : {}
+		};
+	}
+	return {
+		error: "UNKNOWN",
+		message: String(error)
+	};
+}
+//#endregion
+export { writeResult as n, writeError as t };

package/dist/headers-D79npewp.mjs

@@ -0,0 +1,11 @@
+//#region src/output/headers.ts
+function tenantProjectHeaders(active) {
+	return {
+		"X-Tenant-Id": active.tenantId,
+		"X-Tenant-Name": encodeURIComponent(active.tenantName),
+		"X-Project-Id": active.projectId,
+		"X-Project-Name": encodeURIComponent(active.projectName)
+	};
+}
+//#endregion
+export { tenantProjectHeaders as t };

package/dist/list--o5Q_PI8.mjs

@@ -0,0 +1,80 @@
+import { a as resolveConfig } from "./device-flow-BgsZipYA.mjs";
+import { t as xbApiFetch } from "./api-client-DwySN6x-.mjs";
+import { n as writeResult, t as writeError } from "./format-BZvv8lYc.mjs";
+import { t as requireActiveProject } from "./project-store-Bz5kf-EI.mjs";
+import { n as mergeUserIds, r as toLocalDateTime, t as csvToArray } from "./util-DgwkUfV9.mjs";
+import { t as tenantProjectHeaders } from "./headers-D79npewp.mjs";
+import { defineCommand } from "citty";
+//#region src/commands/audio/list.ts
+/**
+* `xiaobao-cli audio list` — page audio metadata via POST /ai-open/audio/page.
+*
+* Mirrors openclaw-xiaobao xiaobao_list_audio. Returns audio metadata only
+* (audioId / fileId / startTime / endTime / duration / sale info / fileUrl).
+* Transcript text comes from `xiaobao-cli audio text <audio-id>`.
+*/
+var list_default = defineCommand({
+	meta: {
+		name: "list",
+		description: "录音元数据分页查询（按时间范围 + 可选顾问过滤）"
+	},
+	args: {
+		from: {
+			type: "string",
+			required: true,
+			description: "录音开始时间，yyyy-MM-dd HH:mm:ss（或 ISO，自动转换）"
+		},
+		to: {
+			type: "string",
+			required: true,
+			description: "录音结束时间，同 from 格式"
+		},
+		"user-id": {
+			type: "string",
+			description: "单顾问 user-id 过滤"
+		},
+		"user-id-list": {
+			type: "string",
+			description: "CSV: u1,u2,u3 多顾问"
+		},
+		page: {
+			type: "string",
+			default: "1"
+		},
+		size: {
+			type: "string",
+			default: "10"
+		},
+		"api-base": { type: "string" },
+		"auth-base": { type: "string" },
+		format: {
+			type: "string",
+			default: "json"
+		}
+	},
+	async run({ args }) {
+		try {
+			const config = resolveConfig({
+				apiBase: args["api-base"],
+				authBase: args["auth-base"]
+			});
+			const active = await requireActiveProject();
+			const mergedUserIds = mergeUserIds(args["user-id"], csvToArray(args["user-id-list"]));
+			writeResult(await xbApiFetch(config, "POST", "/ai-open/audio/page", {
+				headers: tenantProjectHeaders(active),
+				body: {
+					fromDate: toLocalDateTime(args.from),
+					toDate: toLocalDateTime(args.to),
+					userIdList: mergedUserIds,
+					page: Number(args.page),
+					size: Number(args.size)
+				}
+			}), args.format);
+		} catch (err) {
+			writeError(err, args.format);
+			process.exit(1);
+		}
+	}
+});
+//#endregion
+export { list_default as default };