mediacript 1.0.0 → 1.0.2

package/src/types/index.ts

@@ -1,34 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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
-  }
-}

package/src/utils/ffmpegOperations.ts

@@ -1,144 +0,0 @@
-import { spawn } from 'child_process'
-import path from 'path'
-import fs from 'fs'
-
-/**
- * Gera um caminho único para o arquivo de saída
- */
-export function uniqueOutputPath(dir: string, baseName: string, extWithDot: string): string {
-  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('Não foi possível gerar um nome de saída único.')
-}
-
-/**
- * Executa um comando ffmpeg
- */
-export function runFfmpegCommand(args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const ffmpeg = spawn('ffmpeg', args, {
-      stdio: ['ignore', 'pipe', 'pipe']
-    })
-
-    let stdout = ''
-    let stderr = ''
-
-    ffmpeg.stdout.on('data', (data) => {
-      stdout += data.toString()
-    })
-
-    ffmpeg.stderr.on('data', (data) => {
-      stderr += data.toString()
-      // FFmpeg envia progresso para stderr
-      const lines = stderr.split('\n')
-      const lastLine = lines[lines.length - 2] || ''
-      
-      // Exibe progresso se tiver informação de tempo
-      if (lastLine.includes('time=')) {
-        process.stdout.write(`\r${lastLine.trim()}`)
-      }
-    })
-
-    ffmpeg.on('close', (code) => {
-      process.stdout.write('\r')
-      if (code === 0) {
-        resolve(stdout)
-      } else {
-        reject(new Error(`FFmpeg falhou com código ${code}\n${stderr}`))
-      }
-    })
-
-    ffmpeg.on('error', (err) => {
-      reject(err)
-    })
-  })
-}
-
-/**
- * Converte vídeo para formato performático (H.264/AAC)
- */
-export async function convertVideo(
-  inputPath: string,
-  outputDir?: string
-): Promise<string> {
-  const dir = outputDir || path.dirname(inputPath)
-  const baseName = path.basename(inputPath, path.extname(inputPath))
-  const outputPath = uniqueOutputPath(dir, `${baseName}_converted`, '.mp4')
-
-  console.log(`\n🎬 Convertendo vídeo para formato performático...`)
-
-  const args = [
-    '-i', inputPath,
-    '-c:v', 'libx264',
-    '-preset', 'medium',
-    '-crf', '23',
-    '-c:a', 'aac',
-    '-b:a', '128k',
-    '-movflags', '+faststart',
-    '-y',
-    outputPath
-  ]
-
-  await runFfmpegCommand(args)
-  console.log(`\n✓ Vídeo convertido: ${path.basename(outputPath)}`)
-  return outputPath
-}
-
-/**
- * Extrai áudio de um vídeo
- */
-export async function extractAudio(
-  inputPath: string,
-  outputDir?: string
-): Promise<string> {
-  const dir = outputDir || path.dirname(inputPath)
-  const baseName = path.basename(inputPath, path.extname(inputPath))
-  const outputPath = uniqueOutputPath(dir, `${baseName}_audio`, '.mp3')
-
-  console.log(`\n🎵 Extraindo áudio do vídeo...`)
-
-  const args = [
-    '-i', inputPath,
-    '-vn',
-    '-acodec', 'libmp3lame',
-    '-b:a', '192k',
-    '-y',
-    outputPath
-  ]
-
-  await runFfmpegCommand(args)
-  console.log(`\n✓ Áudio extraído: ${path.basename(outputPath)}`)
-  return outputPath
-}
-
-/**
- * Converte áudio para formato performático
- */
-export async function convertAudio(
-  inputPath: string,
-  outputDir?: string
-): Promise<string> {
-  const dir = outputDir || path.dirname(inputPath)
-  const baseName = path.basename(inputPath, path.extname(inputPath))
-  const outputPath = uniqueOutputPath(dir, `${baseName}_converted`, '.mp3')
-
-  console.log(`\n🎵 Convertendo áudio para MP3...`)
-
-  const args = [
-    '-i', inputPath,
-    '-acodec', 'libmp3lame',
-    '-b:a', '192k',
-    '-y',
-    outputPath
-  ]
-
-  await runFfmpegCommand(args)
-  console.log(`\n✓ Áudio convertido: ${path.basename(outputPath)}`)
-  return outputPath
-}

package/src/utils/fileHelpers.ts

@@ -1,60 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-const AUDIO_EXTS = new Set(['.ogg', '.wav', '.mp3', '.m4a', '.aac', '.flac'])
-const VIDEO_EXTS = new Set(['.mp4', '.mov', '.mkv', '.webm', '.avi'])
-
-export type FileType = 'audio' | 'video' | 'unknown'
-
-/**
- * Detecta o tipo de arquivo pela extensão
- */
-export function detectFileType(filePath: string): FileType {
-  const ext = path.extname(filePath).toLowerCase()
-  
-  if (AUDIO_EXTS.has(ext)) return 'audio'
-  if (VIDEO_EXTS.has(ext)) return 'video'
-  return 'unknown'
-}
-
-/**
- * Lista arquivos de áudio/vídeo no diretório
- */
-export function listMediaFiles(dir: string): Array<{ name: string; fullPath: string; type: FileType }> {
-  try {
-    return fs
-      .readdirSync(dir)
-      .filter((name) => {
-        const fullPath = path.join(dir, name)
-        try {
-          return fs.statSync(fullPath).isFile()
-        } catch {
-          return false
-        }
-      })
-      .map((name) => {
-        const fullPath = path.join(dir, name)
-        return {
-          name,
-          fullPath,
-          type: detectFileType(name)
-        }
-      })
-      .filter((f) => f.type !== 'unknown')
-      .sort((a, b) => a.name.localeCompare(b.name))
-  } catch (error) {
-    console.error('Erro ao listar arquivos:', error)
-    return []
-  }
-}
-
-/**
- * Verifica se um arquivo existe
- */
-export function fileExists(filePath: string): boolean {
-  try {
-    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
-  } catch {
-    return false
-  }
-}

package/src/workflow/state.ts

@@ -1,140 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { WorkflowState, WorkflowStep } from '../types/index.js'
-
-/**
- * Cria um novo workflow state
- */
-export function createWorkflowState(inputFile: string, stepNames: string[]): WorkflowState {
-  return {
-    steps: stepNames.map((name, index) => ({
-      id: `step-${index}`,
-      name,
-      status: 'pending'
-    })),
-    currentStepIndex: 0,
-    inputFile,
-    intermediateFiles: {}
-  }
-}
-
-/**
- * Atualiza o status de um step
- */
-export function updateStepStatus(
-  state: WorkflowState,
-  stepIndex: number,
-  status: WorkflowStep['status'],
-  result?: any,
-  error?: string
-): void {
-  if (stepIndex >= 0 && stepIndex < state.steps.length) {
-    const step = state.steps[stepIndex]
-    step.status = status
-    
-    if (status === 'running') {
-      step.startTime = Date.now()
-    } else if (status === 'completed' || status === 'failed') {
-      step.endTime = Date.now()
-    }
-    
-    if (result !== undefined) {
-      step.result = result
-    }
-    
-    if (error) {
-      step.error = error
-    }
-  }
-}
-
-/**
- * Obtém o step atual
- */
-export function getCurrentStep(state: WorkflowState): WorkflowStep | null {
-  if (state.currentStepIndex < state.steps.length) {
-    return state.steps[state.currentStepIndex]
-  }
-  return null
-}
-
-/**
- * Avança para o próximo step
- */
-export function nextStep(state: WorkflowState): boolean {
-  if (state.currentStepIndex < state.steps.length - 1) {
-    state.currentStepIndex++
-    return true
-  }
-  return false
-}
-
-/**
- * Verifica se o workflow está completo
- */
-export function isWorkflowComplete(state: WorkflowState): boolean {
-  return state.steps.every(step => 
-    step.status === 'completed' || step.status === 'skipped'
-  )
-}
-
-/**
- * Verifica se houve algum erro no workflow
- */
-export function hasWorkflowErrors(state: WorkflowState): boolean {
-  return state.steps.some(step => step.status === 'failed')
-}
-
-/**
- * Exibe o progresso do workflow
- */
-export function printWorkflowProgress(state: WorkflowState): void {
-  console.log('\n📊 Progresso do Workflow:')
-  console.log('━'.repeat(50))
-  
-  state.steps.forEach((step, index) => {
-    let icon = '⏳'
-    if (step.status === 'completed') icon = '✓'
-    else if (step.status === 'failed') icon = '✗'
-    else if (step.status === 'running') icon = '⚡'
-    else if (step.status === 'skipped') icon = '⊘'
-    
-    const duration = step.startTime && step.endTime 
-      ? ` (${((step.endTime - step.startTime) / 1000).toFixed(1)}s)`
-      : ''
-    
-    console.log(`${icon} ${index + 1}. ${step.name}${duration}`)
-    
-    if (step.error) {
-      console.log(`   └─ Erro: ${step.error}`)
-    }
-  })
-  
-  console.log('━'.repeat(50))
-}
-
-/**
- * Salva o estado do workflow em arquivo
- */
-export function saveWorkflowState(state: WorkflowState, outputDir: string): void {
-  const stateFile = path.join(outputDir, '.workflow-state.json')
-  fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf-8')
-}
-
-/**
- * Carrega o estado do workflow de arquivo
- */
-export function loadWorkflowState(outputDir: string): WorkflowState | null {
-  const stateFile = path.join(outputDir, '.workflow-state.json')
-  
-  try {
-    if (fs.existsSync(stateFile)) {
-      const data = fs.readFileSync(stateFile, 'utf-8')
-      return JSON.parse(data)
-    }
-  } catch (error) {
-    console.warn('Erro ao carregar estado do workflow:', error)
-  }
-  
-  return null
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ES2020",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"],
-  "ts-node": {
-    "esm": true,
-    "experimentalSpecifierResolution": "node"
-  }
-}