mediacript 1.0.0

package/QUICK_START.md

@@ -0,0 +1,154 @@
+# 🚀 Quick Start Guide
+
+## First Time
+
+1. **Install dependencies**:
+   ```bash
+   npm install
+   ```
+
+2. **Run the CLI**:
+   ```bash
+   npm start
+   ```
+
+3. **Configure your API Keys** (when prompted):
+   - Groq (recommended): https://console.groq.com
+   - OpenAI: https://platform.openai.com
+
+## Available Workflows
+
+### 🎬 For Videos
+
+#### Complete Pipeline
+```
+Convert video → Extract audio → Transcribe
+```
+Best for: Fully processing a video, optimizing and transcribing
+
+#### Extract and Transcribe
+```
+Extract audio → Transcribe
+```
+Best for: Transcribing videos without converting them
+
+#### Only Convert
+```
+Convert video (H.264/AAC)
+```
+Best for: Optimizing videos for web/streaming
+
+#### Only Extract Audio
+```
+Extract audio (MP3)
+```
+Best for: Extracting soundtrack from videos
+
+### 🎵 For Audio
+
+#### Convert and Transcribe
+```
+Convert audio → Transcribe
+```
+Best for: Processing audio in non-optimized format
+
+#### Only Transcribe
+```
+Transcribe audio
+```
+Best for: Transcribing podcasts, interviews, etc.
+
+#### Only Convert
+```
+Convert audio (MP3)
+```
+Best for: Standardizing audio format
+
+## Practical Examples
+
+### Transcribe a lecture video
+```bash
+# Place lecture_video.mp4 in the folder
+npm start
+# Select: "Extract audio from video + Transcribe"
+# Result: lecture_video_audio.mp3 and lecture_video_audio.txt
+```
+
+### Convert podcast and transcribe
+```bash
+# Place podcast.wav in the folder
+npm start
+# Select: "Convert audio + Transcribe"
+# Result: podcast_converted.mp3 and podcast_converted.txt
+```
+
+### Complete video pipeline
+```bash
+# Place presentation.mkv in the folder
+npm start
+# Select: "Convert video + Extract audio + Transcribe"
+# Result:
+#   - presentation_converted.mp4 (optimized video)
+#   - presentation_converted_audio.mp3
+#   - presentation_converted_audio.txt
+```
+
+## Tips
+
+### 💡 Transcription
+- **Groq is faster** and cheaper than OpenAI
+- Configure both keys to have automatic fallback
+- Transcription works best with clear audio
+
+### 📊 Tracking
+- Progress is displayed in real-time
+- Each step shows elapsed time
+- State is saved in `.workflow-state.json`
+
+### 🗂️ Organization
+- Generated files stay in the same directory as the original
+- Suffixes are automatically added:
+  - `_converted` for conversions
+  - `_audio` for extracted audio
+  - `.txt` for transcriptions
+
+### ⚡ Performance
+- Video conversions can take time (depends on size)
+- Audio extraction is fast
+- Transcription depends on audio size and service
+
+## Useful Commands
+
+```bash
+# Development mode (auto-reload)
+npm run dev
+
+# Compile for production
+npm run build
+
+# Simple converter (old)
+npm run convert
+```
+
+## Troubleshooting
+
+### "FFmpeg not found"
+- Install FFmpeg following the README instructions
+- Restart the terminal after installing
+
+### "No API key configured"
+- Run again and configure when prompted
+- Or manually edit: `~/.config/ffmpeg-simple-converter/config.json`
+
+### Transcription failed
+- Check if you have credits/quota in the API
+- Try the other service (Groq or OpenAI)
+- Check internet connection
+
+### File doesn't appear in the list
+- Check if the extension is supported
+- Make sure you're in the correct directory
+
+## 📚 More Information
+
+See the complete [README.md](README.md) for technical details and advanced topics.

package/README.md

@@ -0,0 +1,240 @@
+# FFmpeg Simple Converter
+
+Powerful and flexible CLI for converting videos/audio and AI transcription, working on Linux, Mac, and Windows.
+
+## 🌟 Features
+
+- ✅ **Cross-platform**: Works on Linux, macOS, and Windows
+- 🔄 **Multi-Step Workflow**: Combine multiple operations in a single flow
+- 🎙️ **AI Transcription**: Support for Groq (fast) and OpenAI Whisper
+- 💾 **State Management**: Saves progress of each workflow step
+- 🔑 **Persistent Configuration**: API keys saved locally and securely
+- 📊 **Visual Progress**: Track each step of the process
+
+## 📋 Requirements
+
+- **Node.js** `>= 16`
+- **FFmpeg** installed and available in PATH
+
+### Installing FFmpeg
+
+#### Windows
+```bash
+# With Chocolatey
+choco install ffmpeg
+
+# With Scoop
+scoop install ffmpeg
+```
+
+#### macOS
+```bash
+brew install ffmpeg
+```
+
+#### Linux
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt install ffmpeg
+
+# Fedora
+sudo dnf install ffmpeg
+
+# Arch Linux
+sudo pacman -S ffmpeg
+```
+
+Verify installation:
+```bash
+ffmpeg -version
+```
+
+## 🚀 Installation
+
+```bash
+npm install
+```
+
+## 💡 Usage
+
+### Interactive Mode (Recommended)
+
+```bash
+npm start
+```
+
+The CLI will:
+1. ✅ Check if FFmpeg is installed
+2. 🔑 Request API keys on first run (optional)
+3. 📁 List media files in the current directory
+4. 🎯 Allow you to choose the desired workflow
+
+### Available Workflows
+
+#### For Videos 🎬
+- **Convert video + Extract audio + Transcribe**: Complete pipeline
+- **Extract audio from video + Transcribe**: To transcribe videos
+- **Only convert video**: Optimize video (H.264/AAC)
+- **Only extract audio from video**: Extract audio as MP3
+
+#### For Audio 🎵
+- **Convert audio + Transcribe**: Convert and transcribe
+- **Only transcribe audio**: Direct transcription
+- **Only convert audio**: Convert to MP3
+
+## 🔑 API Keys Configuration
+
+### First Run
+
+The first time you run it, you'll be asked if you want to configure your API keys:
+
+```
+⚠️  No API key found.
+? Do you want to configure your API keys now? (Y/n)
+
+🔑 Configure your API keys (optional - press Enter to skip)
+
+? Groq API Key (recommended - faster): sk-proj-...
+? OpenAI API Key: sk-...
+```
+
+### Where Keys Are Saved
+
+- **Linux/Mac**: `~/.config/ffmpeg-simple-converter/config.json`
+- **Windows**: `%APPDATA%/ffmpeg-simple-converter/config.json`
+
+### Getting API Keys
+
+#### Groq (Recommended - Faster and Cheaper)
+1. Visit: https://console.groq.com
+2. Create a free account
+3. Generate an API key in "API Keys"
+
+#### OpenAI
+1. Visit: https://platform.openai.com
+2. Create an account
+3. Add credits
+4. Generate an API key in "API Keys"
+
+### Transcription Priority
+
+The system automatically tries in the following order:
+1. **Groq** (if configured) - faster and cheaper
+2. **OpenAI** (fallback) - if Groq fails or is not configured
+
+## 📊 Usage Example
+
+```bash
+$ npm start
+
+🎬 FFmpeg Simple Converter - Multi-Step Workflow
+
+✓ FFmpeg is installed (version: 6.0)
+
+📁 Found 3 media file(s)
+
+? Select file:
+  🎬 lecture_video.mp4
+❯ 🎵 podcast.mp3
+  🎬 presentation.mkv
+
+? Select what you want to do:
+❯ 🎬 Convert video + Extract audio + Transcribe
+  🎬 Extract audio from video + Transcribe
+  🎵 Convert audio + Transcribe
+  🎙️  Only transcribe audio
+
+🚀 Starting workflow: Convert video + Extract audio + Transcribe
+📁 Input file: lecture_video.mp4
+
+[1/3] Convert video...
+🎬 Converting video to optimized format...
+✓ Video converted: lecture_video_converted.mp4
+
+[2/3] Extract audio...
+🎵 Extracting audio from video...
+✓ Audio extracted: lecture_video_converted_audio.mp3
+
+[3/3] Transcribe audio...
+🎙️  Transcribing: lecture_video_converted_audio.mp3
+📡 Trying Groq Whisper (fast)...
+✓ Transcription completed with Groq
+✓ Transcription saved: lecture_video_converted_audio.txt
+
+📊 Workflow Progress:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✓ 1. Convert video (12.3s)
+✓ 2. Extract audio (3.1s)
+✓ 3. Transcribe audio (8.7s)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📦 Generated files:
+  • Video: lecture_video_converted.mp4
+  • Audio: lecture_video_converted_audio.mp3
+  • Transcription: lecture_video_converted_audio.txt
+```
+
+## 🗂️ Project Structure
+
+```
+src/
+├── config/          # Configuration and API keys management
+├── transcript/      # Transcription modules (Groq and OpenAI)
+├── types/           # TypeScript definitions
+├── utils/           # Utilities (ffmpeg, files, etc)
+├── workflow/        # Workflow management system
+└── index.ts         # Main CLI
+```
+
+## 🔧 Available Scripts
+
+```bash
+npm start           # Run the interactive CLI
+npm run build       # Compile TypeScript to JavaScript
+npm run dev         # Development mode with watch
+npm run convert     # Run the old converter (convert.js)
+```
+
+## 📦 Supported Formats
+
+### Audio
+`.ogg`, `.wav`, `.mp3`, `.m4a`, `.aac`, `.flac`
+
+### Video
+`.mp4`, `.mov`, `.mkv`, `.webm`, `.avi`
+
+## 🛠️ State Management
+
+Each workflow saves its state to `.workflow-state.json` in the output directory:
+
+```json
+{
+  "steps": [
+    {
+      "id": "step-0",
+      "name": "Convert video",
+      "status": "completed",
+      "startTime": 1675436400000,
+      "endTime": 1675436412300
+    }
+  ],
+  "intermediateFiles": {
+    "convertedVideo": "video_converted.mp4",
+    "extractedAudio": "video_audio.mp3",
+    "transcriptionText": "video_audio.txt"
+  }
+}
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Feel free to open issues and pull requests.
+
+## 📄 License
+
+MIT
+
+## 🙏 Acknowledgments
+
+- FFmpeg for the amazing tool
+- OpenAI and Groq for transcription services

package/cli.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// Importa e executa o CLI compilado
+import('../dist/index.js').catch((error) => {
+  console.error('Erro ao carregar o CLI:', error)
+  process.exit(1)
+})

package/convert.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const inquirer = require('inquirer');
+
+const AUDIO_EXTS = new Set(['.ogg', '.wav', '.mp3', '.m4a', '.aac', '.flac']);
+const VIDEO_EXTS = new Set(['.mp4', '.mov', '.mkv', '.webm', '.avi']);
+
+function isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function detectKindByExt(ext) {
+  const lower = ext.toLowerCase();
+  if (AUDIO_EXTS.has(lower)) return 'audio';
+  if (VIDEO_EXTS.has(lower)) return 'video';
+  return 'unknown';
+}
+
+function listCandidateFiles(dir) {
+  return fs
+    .readdirSync(dir)
+    .map((name) => ({ name, fullPath: path.join(dir, name) }))
+    .filter((f) => isFile(f.fullPath))
+    .filter((f) => {
+      const ext = path.extname(f.name).toLowerCase();
+      return AUDIO_EXTS.has(ext) || VIDEO_EXTS.has(ext);
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function uniqueOutputPath(dir, baseName, extWithDot) {
+  let candidate = path.join(dir, `${baseName}${extWithDot}`);
+  if (!fs.existsSync(candidate)) return candidate;
+
+  for (let i = 1; i < 10_000; i++) {
+    candidate = path.join(dir, `${baseName}_${i}${extWithDot}`);
+    if (!fs.existsSync(candidate)) return candidate;
+  }
+
+  throw new Error('Nao foi possivel gerar um nome de saida unico.');
+}
+
+function buildPresets() {
+  /**
+   * Preset shape:
+   * - id: string
+   * - label: string
+   * - kinds: Array<'audio'|'video'>
+   * - build({ inputPath, outputPath }): { cmd: 'ffmpeg', args: string[] }
+   */
+  return [
+    {
+      id: 'audio_mp3_q2',
+      label: 'Audio → MP3 (boa qualidade, q:a 2)',
+      kinds: ['audio'],
+      outputExt: '.mp3',
+      build: ({ inputPath, outputPath }) => ({
+        cmd: 'ffmpeg',
+        args: ['-hide_banner', '-n', '-i', inputPath, '-c:a', 'libmp3lame', '-q:a', '2', outputPath]
+      })
+    },
+    {
+      id: 'audio_mp3_small',
+      label: 'Audio → MP3 (menor, q:a 5)',
+      kinds: ['audio'],
+      outputExt: '.mp3',
+      build: ({ inputPath, outputPath }) => ({
+        cmd: 'ffmpeg',
+        args: ['-hide_banner', '-n', '-i', inputPath, '-c:a', 'libmp3lame', '-q:a', '5', outputPath]
+      })
+    },
+    {
+      id: 'video_1080p_medium',
+      label: 'Video → MP4 1080p (razoavel/menor: preset medium, CRF 28)',
+      kinds: ['video'],
+      outputExt: '.mp4',
+      build: ({ inputPath, outputPath }) => ({
+        cmd: 'ffmpeg',
+        args: [
+          '-hide_banner',
+          '-n',
+          '-i',
+          inputPath,
+          '-vf',
+          "scale='min(1080,iw)':-2",
+          '-c:v',
+          'libx264',
+          '-profile:v',
+          'baseline',
+          '-level',
+          '3.1',
+          '-preset',
+          'medium',
+          '-crf',
+          '28',
+          '-r',
+          '30',
+          '-c:a',
+          'aac',
+          '-b:a',
+          '128k',
+          '-movflags',
+          '+faststart',
+          outputPath
+        ]
+      })
+    },
+    {
+      id: 'video_1080p_better',
+      label: 'Video → MP4 1080p (melhor/maior: preset slow, CRF 23)',
+      kinds: ['video'],
+      outputExt: '.mp4',
+      build: ({ inputPath, outputPath }) => ({
+        cmd: 'ffmpeg',
+        args: [
+          '-hide_banner',
+          '-n',
+          '-i',
+          inputPath,
+          '-vf',
+          "scale='min(1080,iw)':-2",
+          '-c:v',
+          'libx264',
+          '-profile:v',
+          'baseline',
+          '-level',
+          '3.1',
+          '-preset',
+          'slow',
+          '-crf',
+          '23',
+          '-r',
+          '30',
+          '-c:a',
+          'aac',
+          '-b:a',
+          '128k',
+          '-movflags',
+          '+faststart',
+          outputPath
+        ]
+      })
+    }
+  ];
+}
+
+function spawnAndStream(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} saiu com codigo ${code}`));
+    });
+  });
+}
+
+async function main() {
+  const cwd = process.cwd();
+  const files = listCandidateFiles(cwd);
+
+  if (files.length === 0) {
+    console.log('Nenhum arquivo de audio/video suportado encontrado na pasta atual.');
+    console.log('Extensoes de audio:', Array.from(AUDIO_EXTS).join(', '));
+    console.log('Extensoes de video:', Array.from(VIDEO_EXTS).join(', '));
+    process.exit(1);
+  }
+
+  const { selectedFiles } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedFiles',
+      message: 'Selecione os arquivos para converter:',
+      pageSize: 15,
+      choices: files.map((f) => ({
+        name: f.name,
+        value: f.fullPath
+      })),
+      validate: (arr) => (arr && arr.length > 0 ? true : 'Selecione pelo menos 1 arquivo.')
+    }
+  ]);
+
+  const presets = buildPresets();
+
+  const kindByInput = new Map();
+  const selectedKinds = new Set();
+  for (const inputPath of selectedFiles) {
+    const kind = detectKindByExt(path.extname(inputPath));
+    kindByInput.set(inputPath, kind);
+    selectedKinds.add(kind);
+  }
+
+  if (selectedKinds.has('unknown')) {
+    console.log('Selecao contem arquivos com extensao nao suportada.');
+    process.exit(1);
+  }
+
+  // Escolhe 1 preset por tipo detectado (audio/video)
+  const presetByKind = new Map();
+  for (const kind of selectedKinds) {
+    const applicable = presets.filter((p) => p.kinds.includes(kind));
+    if (applicable.length === 0) {
+      console.log(`Nao ha presets disponiveis para tipo: ${kind}`);
+      process.exit(1);
+    }
+
+    const { presetId } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'presetId',
+        message: `Selecione o preset para ${kind}:`,
+        choices: applicable.map((p) => ({ name: p.label, value: p.id }))
+      }
+    ]);
+
+    const preset = presets.find((p) => p.id === presetId);
+    if (!preset) throw new Error('Preset selecionado nao encontrado.');
+    presetByKind.set(kind, preset);
+  }
+
+  for (const inputPath of selectedFiles) {
+    const parsed = path.parse(inputPath);
+    const inputExt = parsed.ext.toLowerCase();
+    const baseName = parsed.name;
+
+    const kind = kindByInput.get(inputPath);
+    const preset = presetByKind.get(kind);
+    if (!preset) throw new Error(`Preset nao encontrado para tipo: ${kind}`);
+
+    // Evita sobrescrever quando a extensao final for igual
+    const outputBase = inputExt === preset.outputExt ? `${baseName}_converted` : baseName;
+    const outputPath = uniqueOutputPath(parsed.dir, outputBase, preset.outputExt);
+
+    const { cmd, args } = preset.build({ inputPath, outputPath });
+
+    console.log('\n----------------------------------------');
+    console.log('Entrada:', path.basename(inputPath));
+    console.log('Saida  :', path.basename(outputPath));
+    console.log('Comando:', [cmd, ...args].join(' '));
+
+    await spawnAndStream(cmd, args);
+  }
+
+  console.log('\nConcluido.');
+}
+
+main().catch((err) => {
+  console.error('\nErro:', err && err.message ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mediacript",
+  "version": "1.0.0",
+  "description": "CLI to convert media files to performat formats and extract text using Groq and OpenAI's Whisper API",
+  "type": "module",
+  "bin": {
+    "mediacript": "./cli.mjs",
+    "mediacript-convert": "./convert.js"
+  },
+  "scripts": {
+    "convert": "node convert.js",
+    "start": "node --loader ts-node/esm src/index.ts",
+    "build": "tsc && chmod +x dist/index.js && chmod +x cli.mjs",
+    "dev": "node --loader ts-node/esm --watch src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "axios": "^1.13.4",
+    "dotenv": "^17.2.3",
+    "form-data": "^4.0.5",
+    "inquirer": "^8.2.6",
+    "openai": "^4.104.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.12",
+    "@types/node": "^25.0.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}