qasai 0.0.1

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "qasai",
+  "version": "0.0.1",
+  "description": "Image compression CLI with lossless and lossy options",
+  "type": "module",
+  "bin": {
+    "qasai": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "image",
+    "compression",
+    "cli",
+    "optimize",
+    "jpg",
+    "png",
+    "svg",
+    "webp"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "commander": "^12.1.0",
+    "execa": "^9.5.2",
+    "gifsicle": "^7.0.1",
+    "glob": "^11.0.0",
+    "jpegtran-bin": "^7.0.0",
+    "mozjpeg": "^8.0.0",
+    "optipng-bin": "^8.0.0",
+    "ora": "^8.1.1",
+    "picocolors": "^1.1.1",
+    "pngquant-bin": "^9.0.0",
+    "sharp": "^0.33.5",
+    "svgo": "^3.3.2"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "gifsicle",
+      "jpegtran-bin",
+      "mozjpeg",
+      "optipng-bin",
+      "pngquant-bin",
+      "sharp"
+    ]
+  }
+}

package/src/commands/compress.ts

@@ -0,0 +1,115 @@
+import { glob } from 'glob';
+import { stat, mkdir } from 'fs/promises';
+import { join, dirname, basename, relative, resolve } from 'path';
+import ora from 'ora';
+import pc from 'picocolors';
+import { compressImage, isSupportedFormat, formatBytes } from '../utils/compressor.js';
+import type { CompressOptions, CompressionResult } from '../utils/types.js';
+
+async function findImages(input: string, recursive: boolean): Promise<string[]> {
+	const inputStat = await stat(input);
+
+	if (inputStat.isFile()) {
+		return isSupportedFormat(input) ? [input] : [];
+	}
+
+	const pattern = recursive
+		? '**/*.{jpg,jpeg,png,webp,avif,gif,tiff,svg,JPG,JPEG,PNG,WEBP,AVIF,GIF,TIFF,SVG}'
+		: '*.{jpg,jpeg,png,webp,avif,gif,tiff,svg,JPG,JPEG,PNG,WEBP,AVIF,GIF,TIFF,SVG}';
+
+	return glob(pattern, { cwd: input, absolute: true, nodir: true });
+}
+
+function getOutputPath(
+	inputFile: string,
+	inputDir: string,
+	outputDir: string,
+	inPlace: boolean
+): string {
+	if (inPlace) {
+		return inputFile;
+	}
+
+	const relativePath = relative(inputDir, inputFile);
+	return join(outputDir, relativePath);
+}
+
+export async function compress(input: string, options: CompressOptions): Promise<void> {
+	const inputPath = resolve(input);
+	const inputStat = await stat(inputPath).catch(() => null);
+
+	if (!inputStat) {
+		console.error(pc.red(`Error: Path not found: ${inputPath}`));
+		process.exit(1);
+	}
+
+	const inputDir = inputStat.isDirectory() ? inputPath : dirname(inputPath);
+	const outputDir = options.inPlace
+		? inputDir
+		: options.output
+			? resolve(options.output)
+			: join(inputDir, 'Kasai');
+
+	const spinner = ora('Finding images...').start();
+
+	const images = await findImages(inputPath, options.recursive || false);
+
+	if (images.length === 0) {
+		spinner.fail('No supported images found');
+		return;
+	}
+
+	spinner.succeed(`Found ${images.length} image${images.length > 1 ? 's' : ''}`);
+
+	if (!options.inPlace) {
+		await mkdir(outputDir, { recursive: true });
+	}
+
+	const results: CompressionResult[] = [];
+	let totalOriginal = 0;
+	let totalCompressed = 0;
+
+	for (let i = 0; i < images.length; i++) {
+		const image = images[i];
+		const outputPath = getOutputPath(image, inputDir, outputDir, options.inPlace || false);
+		const fileName = basename(image);
+
+		const progress = pc.dim(`[${i + 1}/${images.length}]`);
+		const compressSpinner = ora(`${progress} Compressing ${fileName}...`).start();
+
+		try {
+			const result = await compressImage(image, outputPath, options);
+			results.push(result);
+			totalOriginal += result.originalSize;
+			totalCompressed += result.compressedSize;
+
+			const savedStr =
+				result.saved > 0
+					? pc.green(`-${result.savedPercent.toFixed(1)}%`)
+					: pc.yellow(`+${Math.abs(result.savedPercent).toFixed(1)}%`);
+
+			compressSpinner.succeed(
+				`${progress} ${fileName} ${pc.dim(formatBytes(result.originalSize))} → ${pc.dim(formatBytes(result.compressedSize))} ${savedStr}`
+			);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+			compressSpinner.fail(`${progress} ${fileName} - ${pc.red(errorMessage)}`);
+		}
+	}
+
+	console.log('');
+	const totalSaved = totalOriginal - totalCompressed;
+	const totalPercent = totalOriginal > 0 ? (totalSaved / totalOriginal) * 100 : 0;
+
+	console.log(pc.bold('Summary:'));
+	console.log(`  Files processed: ${pc.cyan(results.length.toString())}`);
+	console.log(`  Original size:   ${pc.dim(formatBytes(totalOriginal))}`);
+	console.log(`  Compressed size: ${pc.dim(formatBytes(totalCompressed))}`);
+	console.log(
+		`  Total saved:     ${totalSaved > 0 ? pc.green(`${formatBytes(totalSaved)} (${totalPercent.toFixed(1)}%)`) : pc.yellow('0 B')}`
+	);
+
+	if (!options.inPlace) {
+		console.log(`  Output:          ${pc.cyan(outputDir)}`);
+	}
+}

package/src/commands/interactive.ts

@@ -0,0 +1,318 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { resolve } from 'path';
+import { statSync } from 'fs';
+import { compress } from './compress.js';
+import type { CompressOptions } from '../utils/types.js';
+
+export async function interactive(): Promise<void> {
+	p.intro(pc.bgCyan(pc.black(' QASAI Image Compression ')));
+
+	const input = await p.text({
+		message: 'Enter the path to compress',
+		placeholder: './images or ./photo.jpg',
+		defaultValue: '.',
+		validate: (value) => {
+			try {
+				const path = resolve(value);
+				statSync(path);
+				return undefined;
+			} catch {
+				return 'Path does not exist';
+			}
+		}
+	});
+
+	if (p.isCancel(input)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	const outputMode = await p.select({
+		message: 'Where should compressed images be saved?',
+		options: [
+			{ value: 'kasai', label: 'Kasai folder', hint: 'Creates a Kasai folder in the input directory' },
+			{ value: 'custom', label: 'Custom folder', hint: 'Specify a custom output directory' },
+			{ value: 'inplace', label: 'In place', hint: 'Overwrites original files (destructive)' }
+		]
+	});
+
+	if (p.isCancel(outputMode)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	let output: string | undefined;
+	let inPlace = false;
+
+	if (outputMode === 'custom') {
+		const customOutput = await p.text({
+			message: 'Enter output directory path',
+			placeholder: './compressed'
+		});
+
+		if (p.isCancel(customOutput)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		output = customOutput;
+	} else if (outputMode === 'inplace') {
+		const confirm = await p.confirm({
+			message: 'This will overwrite original files. Are you sure?',
+			initialValue: false
+		});
+
+		if (p.isCancel(confirm) || !confirm) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		inPlace = true;
+	}
+
+	const compressionType = await p.select({
+		message: 'Compression type',
+		options: [
+			{ value: 'lossy', label: 'Lossy', hint: 'Smaller files, slight quality loss (recommended)' },
+			{ value: 'lossless', label: 'Lossless', hint: 'No quality loss, larger files' }
+		]
+	});
+
+	if (p.isCancel(compressionType)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	let quality = '80';
+	if (compressionType === 'lossy') {
+		const qualityInput = await p.text({
+			message: 'Quality level (1-100)',
+			placeholder: '80',
+			defaultValue: '80',
+			validate: (value) => {
+				const num = parseInt(value);
+				if (isNaN(num) || num < 1 || num > 100) {
+					return 'Please enter a number between 1 and 100';
+				}
+				return undefined;
+			}
+		});
+
+		if (p.isCancel(qualityInput)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		quality = qualityInput;
+	}
+
+	const engineConfig = await p.confirm({
+		message: 'Configure compression engines? (defaults are optimal)',
+		initialValue: false
+	});
+
+	if (p.isCancel(engineConfig)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	let jpegEngine: 'mozjpeg' | 'jpegtran' | 'sharp' = 'mozjpeg';
+	let pngEngine: 'pngquant' | 'optipng' | 'sharp' = 'pngquant';
+	let gifEngine: 'gifsicle' | 'sharp' = 'gifsicle';
+
+	if (engineConfig) {
+		const jpegEngineChoice = await p.select({
+			message: 'JPEG compression engine',
+			options: [
+				{ value: 'mozjpeg', label: 'MozJPEG', hint: 'Best compression, recommended' },
+				{ value: 'jpegtran', label: 'jpegtran', hint: 'Lossless optimization only' },
+				{ value: 'sharp', label: 'Sharp', hint: 'Fast, good compression' }
+			]
+		});
+
+		if (p.isCancel(jpegEngineChoice)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		jpegEngine = jpegEngineChoice as typeof jpegEngine;
+
+		const pngEngineChoice = await p.select({
+			message: 'PNG compression engine',
+			options: [
+				{ value: 'pngquant', label: 'pngquant', hint: 'Best lossy compression, recommended' },
+				{ value: 'optipng', label: 'OptiPNG', hint: 'Lossless optimization' },
+				{ value: 'sharp', label: 'Sharp', hint: 'Fast, good compression' }
+			]
+		});
+
+		if (p.isCancel(pngEngineChoice)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		pngEngine = pngEngineChoice as typeof pngEngine;
+
+		const gifEngineChoice = await p.select({
+			message: 'GIF compression engine',
+			options: [
+				{ value: 'gifsicle', label: 'Gifsicle', hint: 'Best for animated GIFs, recommended' },
+				{ value: 'sharp', label: 'Sharp', hint: 'Fast, basic compression' }
+			]
+		});
+
+		if (p.isCancel(gifEngineChoice)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		gifEngine = gifEngineChoice as typeof gifEngine;
+	}
+
+	const advancedOptions = await p.multiselect({
+		message: 'Additional options',
+		options: [
+			{ value: 'recursive', label: 'Process subdirectories', hint: 'Include images in subfolders' },
+			{ value: 'keepMetadata', label: 'Keep metadata', hint: 'Preserve EXIF and other metadata' },
+			{ value: 'resize', label: 'Resize images', hint: 'Set maximum dimensions' }
+		],
+		required: false
+	});
+
+	if (p.isCancel(advancedOptions)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	const options: CompressOptions = {
+		output,
+		inPlace,
+		quality,
+		lossless: compressionType === 'lossless',
+		recursive: advancedOptions.includes('recursive'),
+		keepMetadata: advancedOptions.includes('keepMetadata'),
+		progressive: true,
+		jpegEngine,
+		pngEngine,
+		gifEngine
+	};
+
+	if (advancedOptions.includes('resize')) {
+		const resizeType = await p.select({
+			message: 'Resize method',
+			options: [
+				{ value: 'maxWidth', label: 'Maximum width', hint: 'Maintains aspect ratio' },
+				{ value: 'maxHeight', label: 'Maximum height', hint: 'Maintains aspect ratio' },
+				{ value: 'dimensions', label: 'Specific dimensions', hint: 'e.g., 800x600' },
+				{ value: 'percent', label: 'Percentage', hint: 'e.g., 50%' }
+			]
+		});
+
+		if (p.isCancel(resizeType)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+
+		if (resizeType === 'maxWidth') {
+			const maxWidth = await p.text({
+				message: 'Maximum width in pixels',
+				placeholder: '1920',
+				validate: (value) => {
+					const num = parseInt(value);
+					if (isNaN(num) || num < 1) {
+						return 'Please enter a valid number';
+					}
+					return undefined;
+				}
+			});
+
+			if (p.isCancel(maxWidth)) {
+				p.cancel('Operation cancelled');
+				process.exit(0);
+			}
+			options.maxWidth = maxWidth;
+		} else if (resizeType === 'maxHeight') {
+			const maxHeight = await p.text({
+				message: 'Maximum height in pixels',
+				placeholder: '1080',
+				validate: (value) => {
+					const num = parseInt(value);
+					if (isNaN(num) || num < 1) {
+						return 'Please enter a valid number';
+					}
+					return undefined;
+				}
+			});
+
+			if (p.isCancel(maxHeight)) {
+				p.cancel('Operation cancelled');
+				process.exit(0);
+			}
+			options.maxHeight = maxHeight;
+		} else if (resizeType === 'dimensions') {
+			const dimensions = await p.text({
+				message: 'Dimensions (WIDTHxHEIGHT)',
+				placeholder: '800x600',
+				validate: (value) => {
+					if (!/^\d+x\d+$/.test(value)) {
+						return 'Please use format: WIDTHxHEIGHT (e.g., 800x600)';
+					}
+					return undefined;
+				}
+			});
+
+			if (p.isCancel(dimensions)) {
+				p.cancel('Operation cancelled');
+				process.exit(0);
+			}
+			options.resize = dimensions;
+		} else if (resizeType === 'percent') {
+			const percent = await p.text({
+				message: 'Resize percentage',
+				placeholder: '50',
+				validate: (value) => {
+					const num = parseInt(value);
+					if (isNaN(num) || num < 1 || num > 100) {
+						return 'Please enter a number between 1 and 100';
+					}
+					return undefined;
+				}
+			});
+
+			if (p.isCancel(percent)) {
+				p.cancel('Operation cancelled');
+				process.exit(0);
+			}
+			options.resize = `${percent}%`;
+		}
+	}
+
+	const convertFormat = await p.confirm({
+		message: 'Convert images to a different format?',
+		initialValue: false
+	});
+
+	if (p.isCancel(convertFormat)) {
+		p.cancel('Operation cancelled');
+		process.exit(0);
+	}
+
+	if (convertFormat) {
+		const format = await p.select({
+			message: 'Convert to format',
+			options: [
+				{ value: 'webp', label: 'WebP', hint: 'Modern format, great compression' },
+				{ value: 'avif', label: 'AVIF', hint: 'Best compression, newer format' },
+				{ value: 'jpg', label: 'JPEG', hint: 'Universal compatibility' },
+				{ value: 'png', label: 'PNG', hint: 'Lossless, supports transparency' }
+			]
+		});
+
+		if (p.isCancel(format)) {
+			p.cancel('Operation cancelled');
+			process.exit(0);
+		}
+		options.format = format as 'jpg' | 'png' | 'webp' | 'avif';
+	}
+
+	console.log('');
+	p.outro(pc.dim('Starting compression...'));
+	console.log('');
+
+	await compress(input, options);
+}

package/src/index.ts

@@ -0,0 +1,61 @@
+import { Command, Option } from 'commander';
+import { createRequire } from 'module';
+import { compress } from './commands/compress.js';
+import { interactive } from './commands/interactive.js';
+import { banner } from './utils/banner.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+const program = new Command();
+
+program
+	.name('qasai')
+	.description('Image compression CLI with lossless and lossy options')
+	.version(pkg.version, '-v, --version')
+	.helpOption('-h, --help', 'Display help information');
+
+program
+	.command('compress')
+	.description('Compress images in a directory')
+	.argument('[input]', 'Input directory or file', '.')
+	.option('-o, --output <dir>', 'Output directory (default: Kasai folder in input dir)')
+	.option('-i, --in-place', 'Compress images in place (overwrites originals)')
+	.option('-q, --quality <number>', 'Quality level 1-100 (default: 80)', '80')
+	.option('-l, --lossless', 'Use lossless compression')
+	.option('--resize <dimensions>', 'Resize images (e.g., 800x600, 50%)')
+	.option('--max-width <pixels>', 'Maximum width (maintains aspect ratio)')
+	.option('--max-height <pixels>', 'Maximum height (maintains aspect ratio)')
+	.option('-f, --format <format>', 'Convert to format (jpg, png, webp, avif)')
+	.option('-r, --recursive', 'Process subdirectories recursively')
+	.option('--keep-metadata', 'Preserve image metadata (EXIF, etc.)')
+	.option('--no-progressive', 'Disable progressive encoding for JPEGs')
+	.addOption(new Option('--effort <level>', 'Compression effort 1-10 (higher = slower but smaller)').default('6'))
+	.addOption(
+		new Option('--jpeg-engine <engine>', 'JPEG compression engine')
+			.choices(['mozjpeg', 'jpegtran', 'sharp'])
+			.default('mozjpeg')
+	)
+	.addOption(
+		new Option('--png-engine <engine>', 'PNG compression engine')
+			.choices(['pngquant', 'optipng', 'sharp'])
+			.default('pngquant')
+	)
+	.addOption(
+		new Option('--gif-engine <engine>', 'GIF compression engine')
+			.choices(['gifsicle', 'sharp'])
+			.default('gifsicle')
+	)
+	.option('--png-quality <range>', 'PNG quality range for pngquant (e.g., 65-80)', '65-80')
+	.option('--colors <number>', 'Max colors for PNG/GIF (2-256)', '256')
+	.action(compress);
+
+program
+	.command('interactive', { isDefault: true })
+	.description('Run in interactive mode')
+	.action(async () => {
+		banner();
+		await interactive();
+	});
+
+program.parse();

package/src/types/bins.d.ts

@@ -0,0 +1,24 @@
+declare module 'mozjpeg' {
+	const mozjpeg: string;
+	export default mozjpeg;
+}
+
+declare module 'jpegtran-bin' {
+	const jpegtran: string;
+	export default jpegtran;
+}
+
+declare module 'pngquant-bin' {
+	const pngquant: string;
+	export default pngquant;
+}
+
+declare module 'optipng-bin' {
+	const optipng: string;
+	export default optipng;
+}
+
+declare module 'gifsicle' {
+	const gifsicle: string;
+	export default gifsicle;
+}

package/src/utils/banner.ts

@@ -0,0 +1,23 @@
+import pc from 'picocolors';
+
+export function banner() {
+	const terminalWidth = process.stdout.columns || 80;
+	const isSmall = terminalWidth < 60;
+
+	const bigArt = `
+${pc.white('  ██████╗  █████╗ ███████╗ █████╗ ██╗')}
+${pc.white(' ██╔═══██╗██╔══██╗██╔════╝██╔══██╗██║')}
+${pc.gray(' ██║   ██║███████║███████╗███████║██║')}
+${pc.gray(' ██║▄▄ ██║██╔══██║╚════██║██╔══██║██║')}
+${pc.dim(' ╚██████╔╝██║  ██║███████║██║  ██║██║')}
+${pc.dim('  ╚══▀▀═╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝')}
+`;
+
+	const smallArt = `
+${pc.white('█▀█▄▀██▀▄▀██')}
+${pc.gray('▀▀██▀█▄██▀██')}
+`;
+
+	console.log(isSmall ? smallArt : bigArt);
+	console.log(pc.dim('  Image Compression CLI\n'));
+}