mediacript 1.0.0

package/src/config/index.ts

@@ -0,0 +1,136 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import inquirer from 'inquirer'
+import { Config } from '../types/index.js'
+
+/**
+ * Retorna o diretório de configuração baseado no sistema operacional
+ * Linux/Mac: ~/.config/ffmpeg-simple-converter
+ * Windows: %APPDATA%/ffmpeg-simple-converter
+ */
+function getConfigDir(): string {
+  const homeDir = os.homedir()
+  
+  if (process.platform === 'win32') {
+    // Windows
+    const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming')
+    return path.join(appData, 'ffmpeg-simple-converter')
+  } else {
+    // Linux/Mac
+    return path.join(homeDir, '.config', 'ffmpeg-simple-converter')
+  }
+}
+
+function getConfigFilePath(): string {
+  return path.join(getConfigDir(), 'config.json')
+}
+
+/**
+ * Carrega a configuração salva
+ */
+export function loadConfig(): Config {
+  try {
+    const configPath = getConfigFilePath()
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, 'utf-8')
+      return JSON.parse(data)
+    }
+  } catch (error) {
+    console.warn('Erro ao carregar configuração:', error)
+  }
+  return {}
+}
+
+/**
+ * Salva a configuração
+ */
+export function saveConfig(config: Config): void {
+  try {
+    const configDir = getConfigDir()
+    const configPath = getConfigFilePath()
+    
+    // Cria o diretório se não existir
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true })
+    }
+    
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8')
+    console.log(`✓ Configuração salva em: ${configPath}`)
+  } catch (error) {
+    console.error('Erro ao salvar configuração:', error)
+  }
+}
+
+/**
+ * Solicita as API keys ao usuário (interativo)
+ */
+export async function promptApiKeys(): Promise<Config> {
+  console.log('\n🔑 Configure suas API keys (opcional - pressione Enter para pular)\n')
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'groqApiKey',
+      message: 'Groq API Key (recomendado - mais rápido):',
+      default: ''
+    },
+    {
+      type: 'input',
+      name: 'openaiApiKey',
+      message: 'OpenAI API Key:',
+      default: ''
+    }
+  ])
+  
+  const config: Config = {}
+  
+  if (answers.groqApiKey.trim()) {
+    config.groqApiKey = answers.groqApiKey.trim()
+  }
+  
+  if (answers.openaiApiKey.trim()) {
+    config.openaiApiKey = answers.openaiApiKey.trim()
+  }
+  
+  return config
+}
+
+/**
+ * Verifica se há pelo menos uma API key configurada
+ */
+export function hasApiKey(config: Config): boolean {
+  return !!(config.openaiApiKey || config.groqApiKey)
+}
+
+/**
+ * Obtém a configuração, solicitando ao usuário se necessário
+ */
+export async function ensureConfig(): Promise<Config> {
+  let config = loadConfig()
+  
+  // Se não tem nenhuma API key, pergunta ao usuário
+  if (!hasApiKey(config)) {
+    console.log('\n⚠️  Nenhuma API key encontrada.')
+    
+    const { shouldConfigure } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'shouldConfigure',
+        message: 'Deseja configurar suas API keys agora?',
+        default: true
+      }
+    ])
+    
+    if (shouldConfigure) {
+      const newConfig = await promptApiKeys()
+      
+      if (hasApiKey(newConfig)) {
+        config = { ...config, ...newConfig }
+        saveConfig(config)
+      }
+    }
+  }
+  
+  return config
+}

package/src/index.ts

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+import inquirer from 'inquirer'
+import { verifyFfmpeg } from './utils/ffmpegCheck.js'
+import { ensureConfig, loadConfig, hasApiKey } from './config/index.js'
+import { listMediaFiles, detectFileType } from './utils/fileHelpers.js'
+import { convertVideo, extractAudio, convertAudio } from './utils/ffmpegOperations.js'
+import { transcribeAudio, saveTranscription } from './transcript/index.js'
+import {
+  createWorkflowState,
+  updateStepStatus,
+  nextStep,
+  printWorkflowProgress,
+  saveWorkflowState,
+  getCurrentStep
+} from './workflow/state.js'
+import path from 'path'
+
+interface WorkflowOption {
+  name: string
+  value: string
+  steps: string[]
+  requiresType: 'video' | 'audio' | 'any'
+}
+
+const WORKFLOW_OPTIONS: WorkflowOption[] = [
+  {
+    name: '🎬 Converter vídeo + Extrair áudio + Transcrever',
+    value: 'video-full',
+    steps: ['Converter vídeo', 'Extrair áudio', 'Transcrever áudio'],
+    requiresType: 'video'
+  },
+  {
+    name: '🎬 Extrair áudio do vídeo + Transcrever',
+    value: 'video-extract-transcribe',
+    steps: ['Extrair áudio', 'Transcrever áudio'],
+    requiresType: 'video'
+  },
+  {
+    name: '🎵 Converter áudio + Transcrever',
+    value: 'audio-convert-transcribe',
+    steps: ['Converter áudio', 'Transcrever áudio'],
+    requiresType: 'audio'
+  },
+  {
+    name: '🎙️  Apenas transcrever áudio',
+    value: 'audio-transcribe',
+    steps: ['Transcrever áudio'],
+    requiresType: 'audio'
+  },
+  {
+    name: '🎬 Apenas converter vídeo',
+    value: 'video-convert',
+    steps: ['Converter vídeo'],
+    requiresType: 'video'
+  },
+  {
+    name: '🎵 Apenas converter áudio',
+    value: 'audio-convert',
+    steps: ['Converter áudio'],
+    requiresType: 'audio'
+  },
+  {
+    name: '🎵 Apenas extrair áudio do vídeo',
+    value: 'video-extract',
+    steps: ['Extrair áudio'],
+    requiresType: 'video'
+  }
+]
+
+async function executeWorkflow(
+  workflow: WorkflowOption,
+  inputFile: string,
+  config: any
+): Promise<void> {
+  const state = createWorkflowState(inputFile, workflow.steps)
+  const outputDir = path.dirname(inputFile)
+
+  console.log(`\n🚀 Iniciando workflow: ${workflow.name}`)
+  console.log(`📁 Arquivo de entrada: ${path.basename(inputFile)}\n`)
+
+  let currentFile = inputFile
+  let audioFile: string | undefined
+  let transcriptionFile: string | undefined
+
+  for (let i = 0; i < state.steps.length; i++) {
+    const step = getCurrentStep(state)
+    if (!step) break
+
+    updateStepStatus(state, i, 'running')
+    console.log(`\n[${ i + 1}/${state.steps.length}] ${step.name}...`)
+
+    try {
+      switch (step.name) {
+        case 'Converter vídeo':
+          currentFile = await convertVideo(currentFile, outputDir)
+          state.intermediateFiles.convertedVideo = currentFile
+          updateStepStatus(state, i, 'completed', { outputFile: currentFile })
+          break
+
+        case 'Extrair áudio':
+          audioFile = await extractAudio(currentFile, outputDir)
+          state.intermediateFiles.extractedAudio = audioFile
+          currentFile = audioFile
+          updateStepStatus(state, i, 'completed', { outputFile: audioFile })
+          break
+
+        case 'Converter áudio':
+          audioFile = await convertAudio(currentFile, outputDir)
+          currentFile = audioFile
+          updateStepStatus(state, i, 'completed', { outputFile: audioFile })
+          break
+
+        case 'Transcrever áudio':
+          // Usa o arquivo de áudio atual ou o arquivo de entrada se for áudio
+          const fileToTranscribe = audioFile || currentFile
+          
+          // Verifica se há API key
+          if (!hasApiKey(config)) {
+            console.log('\n⚠️  Pulando transcrição - nenhuma API key configurada')
+            updateStepStatus(state, i, 'skipped')
+            break
+          }
+
+          const transcription = await transcribeAudio(fileToTranscribe, config)
+          
+          if (transcription) {
+            transcriptionFile = saveTranscription(fileToTranscribe, transcription)
+            state.intermediateFiles.transcriptionText = transcriptionFile
+            console.log(`✓ Transcrição salva: ${path.basename(transcriptionFile)}`)
+            updateStepStatus(state, i, 'completed', { outputFile: transcriptionFile })
+          } else {
+            throw new Error('Falha ao transcrever áudio')
+          }
+          break
+
+        default:
+          throw new Error(`Step desconhecido: ${step.name}`)
+      }
+
+      nextStep(state)
+    } catch (error: any) {
+      console.error(`\n❌ Erro no step "${step.name}":`, error.message)
+      updateStepStatus(state, i, 'failed', undefined, error.message)
+      break
+    }
+  }
+
+  // Salva o estado final
+  saveWorkflowState(state, outputDir)
+
+  // Exibe resumo
+  printWorkflowProgress(state)
+
+  // Exibe arquivos gerados
+  console.log('\n📦 Arquivos gerados:')
+  if (state.intermediateFiles.convertedVideo) {
+    console.log(`  • Vídeo: ${path.basename(state.intermediateFiles.convertedVideo)}`)
+  }
+  if (state.intermediateFiles.extractedAudio) {
+    console.log(`  • Áudio: ${path.basename(state.intermediateFiles.extractedAudio)}`)
+  }
+  if (state.intermediateFiles.transcriptionText) {
+    console.log(`  • Transcrição: ${path.basename(state.intermediateFiles.transcriptionText)}`)
+  }
+  console.log('')
+}
+
+async function main() {
+  console.log('🎬 FFmpeg Simple Converter - Workflow Multi-Step\n')
+
+  // Verifica o ffmpeg
+  const ffmpegInstalled = verifyFfmpeg()
+  if (!ffmpegInstalled) {
+    process.exit(1)
+  }
+
+  console.log('')
+
+  // Garante que há configuração (mesmo que sem API keys)
+  const config = await ensureConfig()
+
+  // Lista arquivos
+  const currentDir = process.cwd()
+  const mediaFiles = listMediaFiles(currentDir)
+
+  if (mediaFiles.length === 0) {
+    console.log('\n⚠️  Nenhum arquivo de mídia encontrado no diretório atual.')
+    console.log('Formatos suportados:')
+    console.log('  • Áudio: .ogg, .wav, .mp3, .m4a, .aac, .flac')
+    console.log('  • Vídeo: .mp4, .mov, .mkv, .webm, .avi\n')
+    process.exit(0)
+  }
+
+  console.log(`\n📁 Encontrados ${mediaFiles.length} arquivo(s) de mídia\n`)
+
+  // Seleção do arquivo
+  const { selectedFile } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedFile',
+      message: 'Selecione o arquivo:',
+      choices: mediaFiles.map((f) => ({
+        name: `${f.type === 'video' ? '🎬' : '🎵'} ${f.name}`,
+        value: f.fullPath
+      }))
+    }
+  ])
+
+  const fileType = detectFileType(selectedFile)
+
+  // Filtra workflows compatíveis com o tipo de arquivo
+  const availableWorkflows = WORKFLOW_OPTIONS.filter((w) => {
+    if (w.requiresType === 'any') return true
+    return w.requiresType === fileType
+  })
+
+  // Marca workflows que requerem API key
+  const workflowChoices = availableWorkflows.map((w) => {
+    const requiresTranscription = w.steps.some(s => s.includes('Transcrever'))
+    const hasKey = hasApiKey(config)
+    
+    let name = w.name
+    if (requiresTranscription && !hasKey) {
+      name += ' ⚠️  (requer API key)'
+    }
+    
+    return {
+      name,
+      value: w.value
+    }
+  })
+
+  // Seleção do workflow
+  const { selectedWorkflow } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedWorkflow',
+      message: 'Selecione o que deseja fazer:',
+      choices: workflowChoices
+    }
+  ])
+
+  const workflow = availableWorkflows.find((w) => w.value === selectedWorkflow)
+  if (!workflow) {
+    console.error('❌ Workflow inválido')
+    process.exit(1)
+  }
+
+  // Aviso se workflow requer transcrição mas não há API key
+  const requiresTranscription = workflow.steps.some(s => s.includes('Transcrever'))
+  if (requiresTranscription && !hasApiKey(config)) {
+    console.log('\n⚠️  Este workflow inclui transcrição, mas nenhuma API key está configurada.')
+    console.log('A transcrição será pulada. Configure uma API key para habilitar transcrição.\n')
+    
+    const { confirm } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Continuar mesmo assim?',
+        default: true
+      }
+    ])
+    
+    if (!confirm) {
+      process.exit(0)
+    }
+  }
+
+  // Executa o workflow
+  await executeWorkflow(workflow, selectedFile, config)
+}
+
+// Executa
+main().catch((error) => {
+  console.error('\n❌ Erro:', error.message)
+  process.exit(1)
+})

package/src/transcript/groq.ts

@@ -0,0 +1,50 @@
+import FormData from 'form-data'
+import fs from 'fs'
+import axios from 'axios'
+
+/**
+ * Transcreve um arquivo de áudio usando Groq Whisper
+ * https://console.groq.com/docs/speech-to-text
+ * @param audioLocalFilePath - Caminho local do arquivo de áudio
+ * @param apiKey - API Key do Groq
+ * @returns Texto transcrito ou null em caso de erro
+ */
+export const groqTranscriptAudio = async (
+  audioLocalFilePath: string,
+  apiKey: string
+): Promise<string | null> => {
+  
+  if (!apiKey) {
+    console.error('❌ Groq API Key não fornecida')
+    return null
+  }
+
+  try {
+    const formData = new FormData()
+    
+    // Add the file from local path
+    formData.append('file', fs.createReadStream(audioLocalFilePath))
+    formData.append('model', 'whisper-large-v3')
+    formData.append('response_format', 'verbose_json')
+    formData.append('temperature', '0')
+    // formData.append('language', 'pt')
+
+    const { data } = await axios.post(
+      'https://api.groq.com/openai/v1/audio/transcriptions',
+      formData,
+      {
+        timeout: 60000,
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          ...formData.getHeaders()
+        }
+      }
+    )
+
+    return data?.text?.trim() || null
+
+  } catch (error: any) {
+    console.error('Erro ao transcrever áudio com Groq:', error.response?.data || error.message)
+    return null
+  }
+}

package/src/transcript/index.ts

@@ -0,0 +1,60 @@
+import path from 'path'
+import fs from 'fs'
+import { Config } from '../types/index.js'
+import { groqTranscriptAudio } from './groq.js'
+import { openaiTranscriptAudio } from './openai.js'
+
+/**
+ * Transcreve um arquivo de áudio tentando primeiro Groq, depois OpenAI
+ * @param audioFilePath - Caminho do arquivo de áudio
+ * @param config - Configuração com API keys
+ * @returns Texto transcrito ou null
+ */
+export async function transcribeAudio(
+  audioFilePath: string,
+  config: Config
+): Promise<string | null> {
+  
+  console.log(`\n🎙️  Transcrevendo: ${path.basename(audioFilePath)}`)
+  
+  // Tenta Groq primeiro (mais rápido e barato)
+  if (config.groqApiKey) {
+    console.log('📡 Tentando Groq Whisper (rápido)...')
+    const result = await groqTranscriptAudio(audioFilePath, config.groqApiKey)
+    if (result) {
+      console.log('✓ Transcrição concluída com Groq')
+      return result
+    }
+    console.log('⚠️  Falha com Groq, tentando OpenAI...')
+  }
+  
+  // Se Groq falhou ou não está configurado, tenta OpenAI
+  if (config.openaiApiKey) {
+    console.log('📡 Tentando OpenAI Whisper...')
+    const result = await openaiTranscriptAudio(audioFilePath, config.openaiApiKey)
+    if (result) {
+      console.log('✓ Transcrição concluída com OpenAI')
+      return result
+    }
+  }
+  
+  // Se chegou aqui, nenhum serviço funcionou
+  if (!config.groqApiKey && !config.openaiApiKey) {
+    console.error('❌ Nenhuma API key configurada para transcrição')
+  } else {
+    console.error('❌ Falha ao transcrever com todos os serviços disponíveis')
+  }
+  
+  return null
+}
+
+/**
+ * Salva a transcrição em arquivo
+ */
+export function saveTranscription(audioPath: string, transcription: string): string {
+  const outputFileName = path.basename(audioPath, path.extname(audioPath)) + '.txt'
+  const outputPath = path.join(path.dirname(audioPath), outputFileName)
+  
+  fs.writeFileSync(outputPath, transcription, 'utf-8')
+  return outputPath
+}

package/src/transcript/openai.ts

@@ -0,0 +1,34 @@
+import fs from 'fs'
+import OpenAI from 'openai'
+
+/**
+ * Transcreve um arquivo de áudio usando OpenAI Whisper
+ * @param audioLocalFilePath - Caminho local do arquivo de áudio
+ * @param apiKey - API Key da OpenAI
+ * @returns Texto transcrito ou null em caso de erro
+ */
+export const openaiTranscriptAudio = async (
+  audioLocalFilePath: string,
+  apiKey: string
+): Promise<string | null> => {
+  
+  if (!apiKey) {
+    console.error('❌ OpenAI API Key não fornecida')
+    return null
+  }
+
+  try {
+    const openai = new OpenAI({ apiKey })
+    
+    const transcription = await openai.audio.transcriptions.create({
+      file: fs.createReadStream(audioLocalFilePath),
+      model: 'whisper-1',
+    })
+  
+    return transcription.text ?? null
+
+  } catch (error: any) {
+    console.error('Erro ao transcrever áudio com OpenAI:', error.response?.data || error.message)
+    return null
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,34 @@
+export interface Config {
+  openaiApiKey?: string
+  groqApiKey?: string
+}
+
+export interface WorkflowStep {
+  id: string
+  name: string
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped'
+  result?: any
+  error?: string
+  startTime?: number
+  endTime?: number
+}
+
+export interface WorkflowState {
+  steps: WorkflowStep[]
+  currentStepIndex: number
+  inputFile: string
+  intermediateFiles: {
+    convertedVideo?: string
+    extractedAudio?: string
+    transcriptionText?: string
+  }
+}
+
+export type OperationType = 'convert-video' | 'extract-audio' | 'convert-audio' | 'transcribe'
+
+export interface Operation {
+  type: OperationType
+  name: string
+  description: string
+  requiresInput: 'video' | 'audio' | 'any'
+}

package/src/utils/ffmpegCheck.ts

@@ -0,0 +1,78 @@
+import { execSync } from 'child_process'
+
+/**
+ * Verifica se o ffmpeg está instalado e disponível no PATH
+ */
+export function checkFfmpegInstalled(): { installed: boolean; version?: string; error?: string } {
+  try {
+    const output = execSync('ffmpeg -version', { 
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    })
+    
+    // Extrai a versão da primeira linha
+    const versionMatch = output.match(/ffmpeg version ([^\s]+)/)
+    const version = versionMatch ? versionMatch[1] : 'unknown'
+    
+    return {
+      installed: true,
+      version
+    }
+  } catch (error: any) {
+    return {
+      installed: false,
+      error: error.message
+    }
+  }
+}
+
+/**
+ * Exibe instruções de instalação do ffmpeg baseado no sistema operacional
+ */
+export function showFfmpegInstallInstructions(): void {
+  const platform = process.platform
+  
+  console.log('\n⚠️  FFmpeg não está instalado ou não está disponível no PATH\n')
+  console.log('📦 Instruções de instalação:\n')
+  
+  if (platform === 'win32') {
+    console.log('Windows:')
+    console.log('  1. Usando Chocolatey:')
+    console.log('     choco install ffmpeg')
+    console.log('\n  2. Usando Scoop:')
+    console.log('     scoop install ffmpeg')
+    console.log('\n  3. Download manual:')
+    console.log('     - Baixe de: https://ffmpeg.org/download.html')
+    console.log('     - Extraia e adicione ao PATH do sistema')
+  } else if (platform === 'darwin') {
+    console.log('macOS:')
+    console.log('  Usando Homebrew:')
+    console.log('     brew install ffmpeg')
+  } else {
+    console.log('Linux:')
+    console.log('  Ubuntu/Debian:')
+    console.log('     sudo apt update && sudo apt install ffmpeg')
+    console.log('\n  Fedora:')
+    console.log('     sudo dnf install ffmpeg')
+    console.log('\n  Arch Linux:')
+    console.log('     sudo pacman -S ffmpeg')
+  }
+  
+  console.log('\n💡 Após a instalação, reinicie o terminal e tente novamente.\n')
+}
+
+/**
+ * Verifica e informa sobre a instalação do ffmpeg
+ * Retorna true se instalado, false caso contrário
+ */
+export function verifyFfmpeg(): boolean {
+  const result = checkFfmpegInstalled()
+  
+  if (result.installed) {
+    console.log(`✓ FFmpeg está instalado (versão: ${result.version})`)
+    return true
+  } else {
+    showFfmpegInstallInstructions()
+    return false
+  }
+}