mediacript 1.0.0

package/src/utils/ffmpegOperations.ts

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

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

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

@@ -0,0 +1,21 @@
+{
+  "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"
+  }
+}