cdx-chores 0.0.7

package/dist/index.mjs

@@ -0,0 +1,787 @@
+import { Command } from "commander";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { confirm, input, select } from "@inquirer/prompts";
+
+//#region src/cli/csv.ts
+function normalizeLineBreaks(value) {
+	return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function quoteCsvField(value) {
+	const text = value === null || value === void 0 ? "" : typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
+	if (/["\n,]/.test(text)) return `"${text.replaceAll("\"", "\"\"")}"`;
+	return text;
+}
+function stringifyCsv(rows) {
+	if (rows.length === 0) return "";
+	const headers = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const key of Object.keys(row)) if (!seen.has(key)) {
+		seen.add(key);
+		headers.push(key);
+	}
+	return `${[headers.map((header) => quoteCsvField(header)).join(","), ...rows.map((row) => headers.map((header) => quoteCsvField(row[header])).join(","))].join("\n")}\n`;
+}
+function parseCsv(text) {
+	const source = normalizeLineBreaks(text);
+	if (source.length === 0) return [];
+	const rows = [];
+	let row = [];
+	let field = "";
+	let inQuotes = false;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		if (inQuotes) {
+			if (char === "\"") if (source[index + 1] === "\"") {
+				field += "\"";
+				index += 1;
+			} else inQuotes = false;
+			else field += char;
+			continue;
+		}
+		if (char === "\"") {
+			inQuotes = true;
+			continue;
+		}
+		if (char === ",") {
+			row.push(field);
+			field = "";
+			continue;
+		}
+		if (char === "\n") {
+			row.push(field);
+			rows.push(row);
+			row = [];
+			field = "";
+			continue;
+		}
+		field += char;
+	}
+	row.push(field);
+	if (row.length > 1 || row[0] !== "" || rows.length === 0) rows.push(row);
+	return rows;
+}
+function csvRowsToObjects(rows) {
+	if (rows.length === 0) return [];
+	const [headerRow, ...dataRows] = rows;
+	const headers = headerRow.map((header, index) => (index === 0 ? header.replace(/^\uFEFF/, "") : header).trim());
+	return dataRows.filter((row) => row.some((value) => value.length > 0)).map((row) => {
+		const record = {};
+		headers.forEach((header, index) => {
+			if (header.length === 0) return;
+			record[header] = row[index] ?? "";
+		});
+		return record;
+	});
+}
+
+//#endregion
+//#region src/cli/errors.ts
+var CliError = class extends Error {
+	exitCode;
+	code;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "CliError";
+		this.exitCode = options.exitCode ?? 1;
+		this.code = options.code ?? "CLI_ERROR";
+	}
+};
+function toCliError(error) {
+	if (error instanceof CliError) return error;
+	return new CliError(error instanceof Error ? error.message : String(error));
+}
+
+//#endregion
+//#region src/cli/process.ts
+async function execCommand(command, args, options = {}) {
+	return await new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", (error) => {
+			reject(error);
+		});
+		child.on("close", (code, signal) => {
+			resolve({
+				ok: code === 0,
+				code,
+				signal,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/cli/deps.ts
+function installHintFor(command, platform) {
+	if (platform === "darwin") return command === "pandoc" ? "brew install pandoc" : "brew install ffmpeg";
+	if (platform === "win32") return command === "pandoc" ? "Install via winget/choco (example: winget install --id JohnMacFarlane.Pandoc)" : "Install via winget/choco (example: winget install Gyan.FFmpeg)";
+	return command === "pandoc" ? "Install via your package manager (examples: apt/dnf/pacman) for pandoc" : "Install via your package manager (examples: apt/dnf/pacman) for ffmpeg";
+}
+function parseVersion(command, output) {
+	const firstLine = output.split(/\r?\n/, 1)[0]?.trim() ?? "";
+	if (!firstLine) return null;
+	if (command === "pandoc") return firstLine.match(/^pandoc\s+([^\s]+)/i)?.[1] ?? firstLine;
+	if (command === "ffmpeg") return firstLine.match(/^ffmpeg version\s+([^\s]+)/i)?.[1] ?? firstLine;
+	return firstLine;
+}
+async function inspectCommand(command, platform) {
+	try {
+		const result = await execCommand(command, command === "pandoc" ? ["--version"] : ["-version"]);
+		return {
+			name: command,
+			available: result.ok,
+			version: result.ok ? parseVersion(command, result.stdout || result.stderr) : null,
+			installHint: installHintFor(command, platform)
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (/ENOENT/i.test(message)) return {
+			name: command,
+			available: false,
+			version: null,
+			installHint: installHintFor(command, platform)
+		};
+		throw new CliError(`Failed to inspect dependency '${command}': ${message}`, {
+			code: "DEPENDENCY_CHECK_FAILED",
+			exitCode: 2
+		});
+	}
+}
+async function requireCommandAvailable(command, platform) {
+	const status = await inspectCommand(command, platform);
+	if (status.available) return;
+	throw new CliError(`Missing required dependency: ${command}. Install suggestion: ${status.installHint}`, {
+		code: "DEPENDENCY_MISSING",
+		exitCode: 2
+	});
+}
+
+//#endregion
+//#region src/cli/fs-utils.ts
+function resolveFromCwd(runtime, filePath) {
+	return resolve(runtime.cwd, filePath);
+}
+async function readTextFileRequired(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		throw new CliError(`Failed to read file: ${path} (${error instanceof Error ? error.message : String(error)})`, {
+			code: "FILE_READ_ERROR",
+			exitCode: 2
+		});
+	}
+}
+async function ensureParentDir(path) {
+	await mkdir(dirname(path), { recursive: true });
+}
+async function writeTextFileSafe(path, content, options = {}) {
+	const overwrite = options.overwrite ?? false;
+	try {
+		if (!overwrite) {
+			await stat(path);
+			throw new CliError(`Output file already exists: ${path}. Use --overwrite to replace it.`, {
+				code: "OUTPUT_EXISTS",
+				exitCode: 2
+			});
+		}
+	} catch (error) {
+		if (error instanceof CliError) throw error;
+	}
+	await ensureParentDir(path);
+	try {
+		await writeFile(path, content, "utf8");
+	} catch (error) {
+		throw new CliError(`Failed to write file: ${path} (${error instanceof Error ? error.message : String(error)})`, {
+			code: "FILE_WRITE_ERROR",
+			exitCode: 2
+		});
+	}
+}
+function defaultOutputPath(inputPath, nextExtension) {
+	const extension = nextExtension.startsWith(".") ? nextExtension : `.${nextExtension}`;
+	const currentExt = extname(inputPath);
+	if (currentExt.length === 0) return `${inputPath}${extension}`;
+	return `${inputPath.slice(0, -currentExt.length)}${extension}`;
+}
+function slugifyName(value) {
+	return value.normalize("NFKD").replace(/[^\x00-\x7F]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "file";
+}
+function formatFileDateTime(date) {
+	return `${date.getUTCFullYear()}${String(date.getUTCMonth() + 1).padStart(2, "0")}${String(date.getUTCDate()).padStart(2, "0")}-${String(date.getUTCHours()).padStart(2, "0")}${String(date.getUTCMinutes()).padStart(2, "0")}${String(date.getUTCSeconds()).padStart(2, "0")}`;
+}
+async function planBatchRename(runtime, directoryInput, options = {}) {
+	const directoryPath = resolveFromCwd(runtime, directoryInput);
+	const files = (await readdir(directoryPath, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+	const prefix = slugifyName(options.prefix?.trim() || "file");
+	const plannedTargets = /* @__PURE__ */ new Set();
+	const sourcePaths = /* @__PURE__ */ new Set();
+	const plans = [];
+	for (const name of files) {
+		const sourcePath = join(directoryPath, name);
+		sourcePaths.add(sourcePath);
+		let fileStats;
+		try {
+			fileStats = await stat(sourcePath);
+		} catch {
+			continue;
+		}
+		const ext = extname(name).toLowerCase();
+		const slug = slugifyName(basename(name, extname(name))).slice(0, 48);
+		const dt = formatFileDateTime(fileStats.mtime ?? options.now ?? runtime.now());
+		let counter = 0;
+		let candidatePath = "";
+		while (true) {
+			candidatePath = join(directoryPath, `${prefix}-${dt}-${slug}${counter === 0 ? "" : `-${String(counter).padStart(2, "0")}`}${ext}`);
+			if (!plannedTargets.has(candidatePath)) break;
+			counter += 1;
+		}
+		plannedTargets.add(candidatePath);
+		plans.push({
+			fromPath: sourcePath,
+			toPath: candidatePath,
+			changed: sourcePath !== candidatePath
+		});
+	}
+	return {
+		directoryPath,
+		plans
+	};
+}
+async function applyPlannedRenames(plans) {
+	const changes = plans.filter((plan) => plan.changed);
+	if (changes.length === 0) return;
+	const tempMoves = [];
+	for (let index = 0; index < changes.length; index += 1) {
+		const plan = changes[index];
+		const tempPath = `${plan.fromPath}.cdx-chores-tmp-${process.pid}-${index}`;
+		await rename(plan.fromPath, tempPath);
+		tempMoves.push({
+			tempPath,
+			finalPath: plan.toPath
+		});
+	}
+	for (const move of tempMoves) await rename(move.tempPath, move.finalPath);
+}
+
+//#endregion
+//#region src/cli/actions.ts
+function printLine(stream, line = "") {
+	stream.write(`${line}\n`);
+}
+function assertNonEmpty(value, label) {
+	const next = value?.trim() ?? "";
+	if (!next) throw new CliError(`${label} is required.`, {
+		code: "INVALID_INPUT",
+		exitCode: 2
+	});
+	return next;
+}
+async function ensureFileExists(path, label) {
+	try {
+		if (!(await stat(path)).isFile()) throw new Error("not a file");
+	} catch {
+		throw new CliError(`${label} file not found: ${path}`, {
+			code: "FILE_NOT_FOUND",
+			exitCode: 2
+		});
+	}
+}
+async function actionDoctor(runtime, options = {}) {
+	const [pandoc, ffmpeg] = await Promise.all([inspectCommand("pandoc", runtime.platform), inspectCommand("ffmpeg", runtime.platform)]);
+	const capabilities = {
+		"md.to-docx": pandoc.available,
+		"video.convert": ffmpeg.available,
+		"video.resize": ffmpeg.available,
+		"video.gif": ffmpeg.available
+	};
+	if (options.json) {
+		const payload = {
+			generatedAt: runtime.now().toISOString(),
+			platform: runtime.platform,
+			nodeVersion: process.version,
+			tools: {
+				pandoc,
+				ffmpeg
+			},
+			capabilities
+		};
+		printLine(runtime.stdout, JSON.stringify(payload, null, 2));
+		return;
+	}
+	printLine(runtime.stdout, "cdx-chores doctor");
+	printLine(runtime.stdout, `Platform: ${runtime.platform}`);
+	printLine(runtime.stdout, `Node.js: ${process.version}`);
+	printLine(runtime.stdout);
+	for (const item of [pandoc, ffmpeg]) {
+		printLine(runtime.stdout, `- ${item.name}: ${item.available ? `available (${item.version ?? "unknown version"})` : "missing"}`);
+		if (!item.available) printLine(runtime.stdout, `  Install suggestion: ${item.installHint}`);
+	}
+	printLine(runtime.stdout);
+	printLine(runtime.stdout, "Capabilities:");
+	for (const [capability, available] of Object.entries(capabilities)) printLine(runtime.stdout, `- ${capability}: ${available ? "available" : "unavailable"}`);
+}
+function normalizeRowsFromJson(input) {
+	if (Array.isArray(input)) {
+		if (input.length === 0) return [];
+		if (input.every((item) => item !== null && typeof item === "object" && !Array.isArray(item))) return input;
+		return input.map((item) => ({ value: item }));
+	}
+	if (input !== null && typeof input === "object") return [input];
+	return [{ value: input }];
+}
+async function actionJsonToCsv(runtime, options) {
+	const inputPath = resolveFromCwd(runtime, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolveFromCwd(runtime, options.output?.trim() || defaultOutputPath(inputPath, ".csv"));
+	await ensureFileExists(inputPath, "Input");
+	const raw = await readTextFileRequired(inputPath);
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new CliError(`Invalid JSON: ${error instanceof Error ? error.message : String(error)}`, {
+			code: "INVALID_JSON",
+			exitCode: 2
+		});
+	}
+	const rows = normalizeRowsFromJson(parsed);
+	await writeTextFileSafe(outputPath, stringifyCsv(rows), { overwrite: options.overwrite });
+	printLine(runtime.stdout, `Wrote CSV: ${outputPath}`);
+	printLine(runtime.stdout, `Rows: ${rows.length}`);
+}
+async function actionCsvToJson(runtime, options) {
+	const inputPath = resolveFromCwd(runtime, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolveFromCwd(runtime, options.output?.trim() || defaultOutputPath(inputPath, ".json"));
+	await ensureFileExists(inputPath, "Input");
+	const records = csvRowsToObjects(parseCsv(await readTextFileRequired(inputPath)));
+	await writeTextFileSafe(outputPath, `${JSON.stringify(records, null, options.pretty ? 2 : 0)}\n`, { overwrite: options.overwrite });
+	printLine(runtime.stdout, `Wrote JSON: ${outputPath}`);
+	printLine(runtime.stdout, `Rows: ${records.length}`);
+}
+async function actionMdToDocx(runtime, options) {
+	const inputPath = resolveFromCwd(runtime, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolveFromCwd(runtime, options.output?.trim() || defaultOutputPath(inputPath, ".docx"));
+	await ensureFileExists(inputPath, "Input");
+	await requireCommandAvailable("pandoc", runtime.platform);
+	if (!options.overwrite) try {
+		await stat(outputPath);
+		throw new CliError(`Output file already exists: ${outputPath}. Use --overwrite to replace it.`, {
+			code: "OUTPUT_EXISTS",
+			exitCode: 2
+		});
+	} catch (error) {
+		if (error instanceof CliError) throw error;
+	}
+	const result = await execCommand("pandoc", [
+		inputPath,
+		"-o",
+		outputPath
+	], { cwd: runtime.cwd });
+	if (!result.ok) throw new CliError(`pandoc failed (${result.code ?? "unknown"}): ${result.stderr || result.stdout}`.trim(), {
+		code: "PROCESS_FAILED",
+		exitCode: 1
+	});
+	printLine(runtime.stdout, `Wrote DOCX: ${outputPath}`);
+}
+function formatRenamePreviewLine(plan) {
+	const fromName = basename(plan.fromPath);
+	const toName = basename(plan.toPath);
+	return plan.changed ? `- ${fromName} -> ${toName}` : `- ${fromName} (unchanged)`;
+}
+async function actionRenameBatch(runtime, options) {
+	const { directoryPath, plans } = await planBatchRename(runtime, assertNonEmpty(options.directory, "Directory path"), {
+		prefix: options.prefix,
+		now: runtime.now()
+	});
+	const totalCount = plans.length;
+	const changedCount = plans.filter((plan) => plan.changed).length;
+	printLine(runtime.stdout, `Directory: ${directoryPath}`);
+	printLine(runtime.stdout, `Files found: ${totalCount}`);
+	printLine(runtime.stdout, `Files to rename: ${changedCount}`);
+	printLine(runtime.stdout);
+	for (const plan of plans) printLine(runtime.stdout, formatRenamePreviewLine(plan));
+	if (options.dryRun ?? false) {
+		printLine(runtime.stdout);
+		printLine(runtime.stdout, "Dry run only. No files were renamed.");
+		return {
+			changedCount,
+			totalCount,
+			directoryPath
+		};
+	}
+	await applyPlannedRenames(plans);
+	printLine(runtime.stdout);
+	printLine(runtime.stdout, `Renamed ${changedCount} file(s).`);
+	return {
+		changedCount,
+		totalCount,
+		directoryPath
+	};
+}
+async function runFfmpeg(runtime, args) {
+	await requireCommandAvailable("ffmpeg", runtime.platform);
+	const result = await execCommand("ffmpeg", args, { cwd: runtime.cwd });
+	if (!result.ok) throw new CliError(`ffmpeg failed (${result.code ?? "unknown"}): ${result.stderr || result.stdout}`.trim(), {
+		code: "PROCESS_FAILED",
+		exitCode: 1
+	});
+}
+async function actionVideoConvert(runtime, options) {
+	const inputPath = resolve(runtime.cwd, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolve(runtime.cwd, assertNonEmpty(options.output, "Output path"));
+	await ensureFileExists(inputPath, "Input");
+	await runFfmpeg(runtime, [
+		options.overwrite ? "-y" : "-n",
+		"-i",
+		inputPath,
+		outputPath
+	]);
+	printLine(runtime.stdout, `Wrote video: ${outputPath}`);
+}
+async function actionVideoResize(runtime, options) {
+	const inputPath = resolve(runtime.cwd, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolve(runtime.cwd, assertNonEmpty(options.output, "Output path"));
+	if (!Number.isFinite(options.width) || options.width <= 0) throw new CliError("Width must be a positive number.", {
+		code: "INVALID_INPUT",
+		exitCode: 2
+	});
+	if (!Number.isFinite(options.height) || options.height <= 0) throw new CliError("Height must be a positive number.", {
+		code: "INVALID_INPUT",
+		exitCode: 2
+	});
+	await ensureFileExists(inputPath, "Input");
+	await runFfmpeg(runtime, [
+		options.overwrite ? "-y" : "-n",
+		"-i",
+		inputPath,
+		"-vf",
+		`scale=${Math.trunc(options.width)}:${Math.trunc(options.height)}`,
+		outputPath
+	]);
+	printLine(runtime.stdout, `Wrote resized video: ${outputPath}`);
+}
+async function actionVideoGif(runtime, options) {
+	const inputPath = resolve(runtime.cwd, assertNonEmpty(options.input, "Input path"));
+	const outputPath = resolve(runtime.cwd, options.output?.trim() || defaultOutputPath(inputPath, ".gif"));
+	await ensureFileExists(inputPath, "Input");
+	const fps = Number.isFinite(options.fps) && (options.fps ?? 0) > 0 ? Math.trunc(options.fps) : 10;
+	const width = Number.isFinite(options.width) && (options.width ?? 0) > 0 ? Math.trunc(options.width) : 480;
+	await runFfmpeg(runtime, [
+		options.overwrite ? "-y" : "-n",
+		"-i",
+		inputPath,
+		"-vf",
+		`fps=${fps},scale=${width}:-1:flags=lanczos`,
+		outputPath
+	]);
+	printLine(runtime.stdout, `Wrote GIF: ${outputPath}`);
+}
+async function actionDeferred(runtime, label) {
+	throw new CliError(`${label} is not implemented in the initial launch phase yet.`, {
+		code: "DEFERRED_FEATURE",
+		exitCode: 2
+	});
+}
+
+//#endregion
+//#region src/cli/interactive.ts
+async function promptPath(message) {
+	return await input({
+		message,
+		validate: (value) => value.trim().length > 0 ? true : "Required"
+	});
+}
+async function runInteractiveMode(runtime) {
+	const action = await select({
+		message: "Choose a command",
+		choices: [
+			{
+				name: "doctor",
+				value: "doctor",
+				description: "Check dependencies and capabilities"
+			},
+			{
+				name: "data json-to-csv",
+				value: "data:json-to-csv"
+			},
+			{
+				name: "data csv-to-json",
+				value: "data:csv-to-json"
+			},
+			{
+				name: "md to-docx",
+				value: "md:to-docx"
+			},
+			{
+				name: "rename batch",
+				value: "rename:batch"
+			},
+			{
+				name: "video convert",
+				value: "video:convert"
+			},
+			{
+				name: "video resize",
+				value: "video:resize"
+			},
+			{
+				name: "video gif",
+				value: "video:gif"
+			},
+			{
+				name: "cancel",
+				value: "cancel"
+			}
+		]
+	});
+	if (action === "cancel") {
+		runtime.stdout.write("Cancelled.\n");
+		return;
+	}
+	if (action === "doctor") {
+		await actionDoctor(runtime, { json: await confirm({
+			message: "Output as JSON?",
+			default: false
+		}) });
+		return;
+	}
+	if (action === "data:json-to-csv") {
+		const inputPath = await promptPath("Input JSON file");
+		const outputPath = await input({ message: "Output CSV file (optional)" });
+		const overwrite = await confirm({
+			message: "Overwrite if exists?",
+			default: false
+		});
+		await actionJsonToCsv(runtime, {
+			input: inputPath,
+			output: outputPath || void 0,
+			overwrite
+		});
+		return;
+	}
+	if (action === "data:csv-to-json") {
+		const inputPath = await promptPath("Input CSV file");
+		const outputPath = await input({ message: "Output JSON file (optional)" });
+		const pretty = await confirm({
+			message: "Pretty-print JSON?",
+			default: true
+		});
+		const overwrite = await confirm({
+			message: "Overwrite if exists?",
+			default: false
+		});
+		await actionCsvToJson(runtime, {
+			input: inputPath,
+			output: outputPath || void 0,
+			pretty,
+			overwrite
+		});
+		return;
+	}
+	if (action === "md:to-docx") {
+		const inputPath = await promptPath("Input Markdown file");
+		const outputPath = await input({ message: "Output DOCX file (optional)" });
+		const overwrite = await confirm({
+			message: "Overwrite if exists?",
+			default: false
+		});
+		await actionMdToDocx(runtime, {
+			input: inputPath,
+			output: outputPath || void 0,
+			overwrite
+		});
+		return;
+	}
+	if (action === "rename:batch") {
+		const directory = await promptPath("Target directory");
+		const prefix = await input({
+			message: "Filename prefix",
+			default: "file"
+		});
+		const dryRun = await confirm({
+			message: "Dry run only?",
+			default: true
+		});
+		const result = await actionRenameBatch(runtime, {
+			directory,
+			prefix,
+			dryRun
+		});
+		if (!dryRun && result.changedCount > 0) return;
+		if (dryRun && result.changedCount > 0) {
+			if (await confirm({
+				message: "Apply these renames now?",
+				default: false
+			})) await actionRenameBatch(runtime, {
+				directory,
+				prefix,
+				dryRun: false
+			});
+		}
+		return;
+	}
+	if (action === "video:convert") {
+		await actionVideoConvert(runtime, {
+			input: await promptPath("Input video file"),
+			output: await promptPath("Output video file"),
+			overwrite: await confirm({
+				message: "Overwrite if exists?",
+				default: false
+			})
+		});
+		return;
+	}
+	if (action === "video:resize") {
+		await actionVideoResize(runtime, {
+			input: await promptPath("Input video file"),
+			output: await promptPath("Output video file"),
+			width: Number(await promptPath("Width (px)")),
+			height: Number(await promptPath("Height (px)")),
+			overwrite: await confirm({
+				message: "Overwrite if exists?",
+				default: false
+			})
+		});
+		return;
+	}
+	if (action === "video:gif") {
+		const inputPath = await promptPath("Input video file");
+		const outputPath = await input({ message: "Output GIF file (optional)" });
+		const widthInput = await input({
+			message: "Width in px (optional)",
+			default: "480"
+		});
+		const fpsInput = await input({
+			message: "FPS (optional)",
+			default: "10"
+		});
+		const overwrite = await confirm({
+			message: "Overwrite if exists?",
+			default: false
+		});
+		await actionVideoGif(runtime, {
+			input: inputPath,
+			output: outputPath || void 0,
+			width: widthInput.trim() ? Number(widthInput) : void 0,
+			fps: fpsInput.trim() ? Number(fpsInput) : void 0,
+			overwrite
+		});
+	}
+}
+
+//#endregion
+//#region src/command.ts
+function createRuntime(options) {
+	return {
+		cwd: options.cwd ?? process.cwd(),
+		now: options.now ?? (() => /* @__PURE__ */ new Date()),
+		platform: options.platform ?? process.platform,
+		stdout: options.stdout ?? process.stdout,
+		stderr: options.stderr ?? process.stderr,
+		stdin: options.stdin ?? process.stdin
+	};
+}
+function applyCommonFileOptions(command) {
+	command.option("-o, --output <path>", "Output file path").option("--overwrite", "Overwrite output file if it already exists", false);
+}
+async function runCli(argv = process.argv, runtime = {}) {
+	const cliRuntime = createRuntime(runtime);
+	if (argv.slice(2).length === 0) {
+		if (!process.stdin.isTTY) {
+			cliRuntime.stderr.write("No arguments provided and interactive mode requires a TTY. Use --help for commands.\n");
+			process.exitCode = 2;
+			return;
+		}
+		try {
+			await runInteractiveMode(cliRuntime);
+		} catch (error) {
+			const cliError = toCliError(error);
+			cliRuntime.stderr.write(`${cliError.message}\n`);
+			process.exitCode = cliError.exitCode;
+		}
+		return;
+	}
+	const program = new Command();
+	program.name("cdx-chores").description("CLI chores toolkit for file/media/document workflow helpers").showHelpAfterError().version("0.0.1");
+	program.command("interactive").description("Start interactive mode").action(async () => {
+		await runInteractiveMode(cliRuntime);
+	});
+	program.command("doctor").description("Check tool availability and current feature capabilities").option("--json", "Output machine-readable JSON", false).action(async (options) => {
+		await actionDoctor(cliRuntime, { json: options.json });
+	});
+	const dataCommand = program.command("data").description("Data conversion utilities");
+	applyCommonFileOptions(dataCommand.command("json-to-csv").description("Convert JSON file to CSV").requiredOption("-i, --input <path>", "Input JSON file").action(async (options) => {
+		await actionJsonToCsv(cliRuntime, options);
+	}));
+	dataCommand.command("csv-to-json").description("Convert CSV file to JSON").requiredOption("-i, --input <path>", "Input CSV file").option("-o, --output <path>", "Output JSON file path").option("--overwrite", "Overwrite output file if it already exists", false).option("--pretty", "Pretty-print JSON output", false).action(async (options) => {
+		await actionCsvToJson(cliRuntime, options);
+	});
+	applyCommonFileOptions(program.command("md").description("Markdown utilities").command("to-docx").description("Convert Markdown to DOCX using pandoc").requiredOption("-i, --input <path>", "Input Markdown file").action(async (options) => {
+		await actionMdToDocx(cliRuntime, options);
+	}));
+	program.command("docx").description("DOCX utilities").command("to-pdf").description("Convert DOCX to PDF (deferred)").action(async () => {
+		await actionDeferred(cliRuntime, "docx to-pdf");
+	});
+	const pdfCommand = program.command("pdf").description("PDF utilities (deferred in initial phase)");
+	for (const [name, description] of [
+		["to-images", "Convert PDF pages to images (deferred)"],
+		["from-images", "Build PDF from image sequence (deferred)"],
+		["merge", "Merge PDF files (deferred)"],
+		["split", "Split PDF file (deferred)"]
+	]) pdfCommand.command(name).description(description).action(async () => {
+		await actionDeferred(cliRuntime, `pdf ${name}`);
+	});
+	program.command("rename").description("Rename helpers").command("batch").description("Batch rename files in a directory").argument("<directory>", "Target directory").option("--prefix <value>", "Filename prefix", "file").option("--dry-run", "Preview rename plan only", false).action(async (directory, options) => {
+		await actionRenameBatch(cliRuntime, {
+			directory,
+			prefix: options.prefix,
+			dryRun: options.dryRun
+		});
+	});
+	program.command("batch-rename").description("Alias for `rename batch`").argument("<directory>", "Target directory").option("--prefix <value>", "Filename prefix", "file").option("--dry-run", "Preview rename plan only", false).action(async (directory, options) => {
+		await actionRenameBatch(cliRuntime, {
+			directory,
+			prefix: options.prefix,
+			dryRun: options.dryRun
+		});
+	});
+	const videoCommand = program.command("video").description("Video utilities (ffmpeg-backed)");
+	videoCommand.command("convert").description("Convert a video file to another format via ffmpeg").requiredOption("-i, --input <path>", "Input video file").requiredOption("-o, --output <path>", "Output video file").option("--overwrite", "Overwrite output file if it already exists", false).action(async (options) => {
+		await actionVideoConvert(cliRuntime, options);
+	});
+	videoCommand.command("resize").description("Resize video dimensions via ffmpeg").requiredOption("-i, --input <path>", "Input video file").requiredOption("-o, --output <path>", "Output video file").requiredOption("--width <px>", "Output width", (value) => Number(value)).requiredOption("--height <px>", "Output height", (value) => Number(value)).option("--overwrite", "Overwrite output file if it already exists", false).action(async (options) => {
+		await actionVideoResize(cliRuntime, options);
+	});
+	videoCommand.command("gif").description("Convert video to GIF via ffmpeg").requiredOption("-i, --input <path>", "Input video file").option("-o, --output <path>", "Output GIF file path").option("--width <px>", "GIF width", (value) => Number(value)).option("--fps <value>", "GIF frames per second", (value) => Number(value)).option("--overwrite", "Overwrite output file if it already exists", false).action(async (options) => {
+		await actionVideoGif(cliRuntime, options);
+	});
+	try {
+		await program.parseAsync(argv);
+	} catch (error) {
+		const cliError = toCliError(error);
+		cliRuntime.stderr.write(`${cliError.message}\n`);
+		process.exitCode = cliError.exitCode;
+	}
+}
+
+//#endregion
+export { runCli };