noupload 1.0.0

package/src/commands/audio/merge.ts

@@ -0,0 +1,109 @@
+import { spawn } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { defineCommand } from 'citty';
+import { checkFFmpeg } from '../../lib/audio/ffmpeg';
+import { detectFFmpeg } from '../../utils/detect';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const merge = defineCommand({
+  meta: {
+    name: 'merge',
+    description: 'Merge multiple audio files into one',
+  },
+  args: {
+    files: {
+      type: 'positional',
+      description: 'Audio files to merge',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const output = requireArg(args.output, 'output');
+      const files = args._ as string[];
+
+      if (!files || files.length < 2) {
+        throw new Error('At least 2 audio files are required to merge');
+      }
+
+      // Validate all files exist
+      for (const file of files) {
+        const resolved = resolvePath(file);
+        if (!existsSync(resolved)) {
+          throw new FileNotFoundError(file);
+        }
+      }
+
+      const outputPath = resolvePath(output);
+      ensureDir(outputPath);
+
+      const ffmpeg = await detectFFmpeg();
+      if (!ffmpeg.available || !ffmpeg.path) {
+        throw new Error('FFmpeg not found');
+      }
+      const ffmpegPath = ffmpeg.path;
+
+      await withSpinner(
+        `Merging ${files.length} audio files...`,
+        async () => {
+          // Create a temporary file list for FFmpeg concat
+          const listPath = join(dirname(outputPath), `.merge-list-${Date.now()}.txt`);
+          const listContent = files.map((f) => `file '${resolvePath(f)}'`).join('\n');
+          writeFileSync(listPath, listContent);
+
+          try {
+            await new Promise<void>((resolve, reject) => {
+              const proc = spawn(
+                ffmpegPath,
+                ['-y', '-f', 'concat', '-safe', '0', '-i', listPath, '-c', 'copy', outputPath],
+                {
+                  stdio: ['pipe', 'pipe', 'pipe'],
+                }
+              );
+
+              proc.on('close', (code) => {
+                if (code === 0) resolve();
+                else reject(new Error(`FFmpeg failed with code ${code}`));
+              });
+
+              proc.on('error', reject);
+            });
+          } finally {
+            // Clean up temp file
+            try {
+              unlinkSync(listPath);
+            } catch {}
+          }
+        },
+        'Audio files merged successfully'
+      );
+
+      const totalInputSize = files.reduce((sum, file) => {
+        return sum + getFileSize(resolvePath(file));
+      }, 0);
+
+      info(`Merged ${files.length} files`);
+
+      fileResult(`${files.length} files`, outputPath, {
+        before: totalInputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio files merged');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/normalize.ts

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const normalize = defineCommand({
+  meta: {
+    name: 'normalize',
+    description: 'Normalize audio volume levels',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    mode: {
+      type: 'string',
+      alias: 'm',
+      description: 'Normalization mode: peak, rms, ebu (default: peak)',
+      default: 'peak',
+    },
+    target: {
+      type: 'string',
+      alias: 't',
+      description: 'Target level in dB (default: -1 for peak, -23 for EBU R128)',
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-normalized');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const mode = (args.mode || 'peak').toLowerCase();
+
+      let ffmpegArgs: string[] = [];
+      let description = '';
+
+      switch (mode) {
+        case 'peak': {
+          // Peak normalization - normalize to peak level
+          const targetPeak = args.target ? Number.parseFloat(args.target) : -1;
+          // Use loudnorm for better results, or dynaudnorm for simpler peak normalization
+          ffmpegArgs = ['-filter:a', `loudnorm=I=-16:TP=${targetPeak}:LRA=11:print_format=none`];
+          description = `Peak normalization (target: ${targetPeak}dB)`;
+          break;
+        }
+
+        case 'rms': {
+          // RMS normalization using dynaudnorm
+          ffmpegArgs = ['-filter:a', 'dynaudnorm=f=150:g=15:p=0.95:m=10:r=0.9:n=1:c=1'];
+          description = 'RMS/Dynamic normalization';
+          break;
+        }
+
+        case 'ebu': {
+          // EBU R128 loudness normalization
+          const targetLoudness = args.target ? Number.parseFloat(args.target) : -23;
+          ffmpegArgs = ['-filter:a', `loudnorm=I=${targetLoudness}:TP=-1:LRA=11:print_format=none`];
+          description = `EBU R128 normalization (target: ${targetLoudness} LUFS)`;
+          break;
+        }
+
+        default:
+          throw new Error(`Unknown normalization mode: ${mode}. Use 'peak', 'rms', or 'ebu'`);
+      }
+
+      await withSpinner(
+        'Normalizing audio levels...',
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ffmpegArgs,
+          });
+        },
+        'Audio normalized successfully'
+      );
+
+      info(description);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio normalized');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/reverse.ts

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const reverse = defineCommand({
+  meta: {
+    name: 'reverse',
+    description: 'Reverse audio playback',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-reversed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Reversing audio...',
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ['-filter:a', 'areverse'],
+          });
+        },
+        'Audio reversed successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio reversed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/speed.ts

@@ -0,0 +1,101 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const speed = defineCommand({
+  meta: {
+    name: 'speed',
+    description: 'Change audio playback speed',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    factor: {
+      type: 'string',
+      alias: 'f',
+      description: 'Speed factor (0.5 = half speed, 2.0 = double speed)',
+      required: true,
+    },
+    preservePitch: {
+      type: 'boolean',
+      alias: 'p',
+      description: 'Preserve original pitch (default: true)',
+      default: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+      const factor = Number.parseFloat(requireArg(args.factor, 'factor'));
+
+      if (Number.isNaN(factor) || factor <= 0 || factor > 100) {
+        throw new Error('Speed factor must be between 0.01 and 100');
+      }
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const suffix = factor > 1 ? '-fast' : '-slow';
+      const outputPath = generateOutputPath(inputPath, args.output, suffix);
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      // atempo filter only accepts values between 0.5 and 2.0
+      // For values outside this range, we need to chain multiple atempo filters
+      const atempoFilters: string[] = [];
+      let remaining = factor;
+
+      while (remaining > 2.0) {
+        atempoFilters.push('atempo=2.0');
+        remaining /= 2.0;
+      }
+      while (remaining < 0.5) {
+        atempoFilters.push('atempo=0.5');
+        remaining /= 0.5;
+      }
+      atempoFilters.push(`atempo=${remaining.toFixed(4)}`);
+
+      const filterStr = atempoFilters.join(',');
+
+      await withSpinner(
+        `Changing speed to ${factor}x...`,
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ['-filter:a', filterStr],
+          });
+        },
+        'Speed changed successfully'
+      );
+
+      info(`Speed factor: ${factor}x${args.preservePitch !== false ? ' (pitch preserved)' : ''}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio speed changed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/trim.ts

@@ -0,0 +1,98 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, parseTime, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const trim = defineCommand({
+  meta: {
+    name: 'trim',
+    description: 'Trim an audio file',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    start: {
+      type: 'string',
+      alias: 's',
+      description: 'Start time (e.g., "00:30" or "30")',
+      required: true,
+    },
+    end: {
+      type: 'string',
+      alias: 'e',
+      description: 'End time (e.g., "02:00" or "120")',
+    },
+    duration: {
+      type: 'string',
+      alias: 'd',
+      description: 'Duration in seconds (alternative to end)',
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+      const start = requireArg(args.start, 'start');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-trimmed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const startTime = parseTime(start);
+
+      const ffmpegArgs = ['-ss', String(startTime)];
+
+      if (args.end) {
+        const endTime = parseTime(args.end);
+        const duration = endTime - startTime;
+        ffmpegArgs.push('-t', String(duration));
+      } else if (args.duration) {
+        ffmpegArgs.push('-t', args.duration);
+      }
+
+      ffmpegArgs.push('-c', 'copy'); // Copy without re-encoding
+
+      await withSpinner(
+        'Trimming audio...',
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ffmpegArgs,
+          });
+        },
+        'Audio trimmed successfully'
+      );
+
+      info(
+        `Start: ${start}${args.end ? `, End: ${args.end}` : ''}${args.duration ? `, Duration: ${args.duration}s` : ''}`
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio trimmed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/volume.ts

@@ -0,0 +1,91 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const volume = defineCommand({
+  meta: {
+    name: 'volume',
+    description: 'Adjust audio volume',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    level: {
+      type: 'string',
+      alias: 'l',
+      description: 'Volume level (e.g., "1.5" for 150%, "0.5" for 50%, or "3dB", "-6dB")',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+      const level = requireArg(args.level, 'level');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-volume');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      // Parse volume level - can be a multiplier or dB value
+      let volumeArg = level;
+      let displayLevel = level;
+
+      if (level.toLowerCase().endsWith('db')) {
+        // Already in dB format
+        volumeArg = level;
+        displayLevel = level;
+      } else {
+        const numLevel = Number.parseFloat(level);
+        if (Number.isNaN(numLevel) || numLevel < 0) {
+          throw new Error(
+            'Volume level must be a positive number or dB value (e.g., "1.5" or "-6dB")'
+          );
+        }
+        displayLevel = `${Math.round(numLevel * 100)}%`;
+      }
+
+      await withSpinner(
+        `Adjusting volume to ${displayLevel}...`,
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ['-filter:a', `volume=${volumeArg}`],
+          });
+        },
+        'Volume adjusted successfully'
+      );
+
+      info(`Volume: ${displayLevel}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Audio volume adjusted');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/audio/waveform.ts

@@ -0,0 +1,117 @@
+import { existsSync } from 'node:fs';
+import { basename, dirname, extname, join } from 'node:path';
+import { defineCommand } from 'citty';
+import { checkFFmpeg, runFFmpeg } from '../../lib/audio/ffmpeg';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const waveform = defineCommand({
+  meta: {
+    name: 'waveform',
+    description: 'Generate waveform visualization image from audio',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input audio file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output image file (default: input-waveform.png)',
+    },
+    width: {
+      type: 'string',
+      alias: 'w',
+      description: 'Image width in pixels (default: 1920)',
+      default: '1920',
+    },
+    height: {
+      type: 'string',
+      alias: 'h',
+      description: 'Image height in pixels (default: 200)',
+      default: '200',
+    },
+    color: {
+      type: 'string',
+      alias: 'c',
+      description: 'Waveform color (default: "0x00ff00" green)',
+      default: '0x00ff00',
+    },
+    background: {
+      type: 'string',
+      alias: 'b',
+      description: 'Background color (default: "0x000000" black)',
+      default: '0x000000',
+    },
+    scale: {
+      type: 'string',
+      description: 'Amplitude scale: lin, log, sqrt, cbrt (default: lin)',
+      default: 'lin',
+    },
+    split: {
+      type: 'boolean',
+      alias: 's',
+      description: 'Split channels vertically',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    try {
+      if (!(await checkFFmpeg())) return;
+
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      // Generate output path for image
+      let outputPath: string;
+      if (args.output) {
+        outputPath = resolvePath(args.output);
+      } else {
+        const dir = dirname(inputPath);
+        const name = basename(inputPath, extname(inputPath));
+        outputPath = join(dir, `${name}-waveform.png`);
+      }
+      ensureDir(outputPath);
+
+      const width = Number.parseInt(args.width || '1920', 10);
+      const height = Number.parseInt(args.height || '200', 10);
+      const color = args.color || '0x00ff00';
+      const scale = args.scale || 'lin';
+      const split = args.split ? 1 : 0;
+
+      // Build showwavespic filter
+      const filter = `showwavespic=s=${width}x${height}:colors=${color}:scale=${scale}:split_channels=${split}`;
+
+      await withSpinner(
+        'Generating waveform image...',
+        async () => {
+          await runFFmpeg({
+            input: inputPath,
+            output: outputPath,
+            args: ['-filter_complex', `[0:a]${filter}[v]`, '-map', '[v]', '-frames:v', '1'],
+          });
+        },
+        'Waveform generated successfully'
+      );
+
+      info(`Size: ${width}x${height}, Scale: ${scale}`);
+
+      fileResult(inputPath, outputPath, {
+        before: getFileSize(inputPath),
+        after: getFileSize(outputPath),
+      });
+
+      success('Waveform image created');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});