@gilbert_oliveira/commit-wizard 1.2.2 → 2.0.0

package/src/core/index.ts

@@ -0,0 +1,381 @@
+import { log } from '@clack/prompts';
+import { loadConfig, validateConfig } from '../config/index.ts';
+import {
+  isGitRepository,
+  getGitStatus,
+  getDiffStats,
+  executeCommit,
+  executeFileCommit,
+} from '../git/index.ts';
+import { generateWithRetry } from './openai.ts';
+import {
+  showCommitPreview,
+  editCommitMessage,
+  copyToClipboard,
+  showCommitResult,
+  showCancellation,
+  selectFilesForCommit,
+  askContinueCommits,
+} from '../ui/index.ts';
+import { chooseSplitMode } from '../ui/smart-split.ts';
+import { handleSmartSplitMode } from './smart-split.ts';
+import { initializeCache } from './cache.ts';
+import type { CLIArgs } from '../utils/args.ts';
+import type { Config } from '../config/index.ts';
+
+export async function main(
+  args: CLIArgs = {
+    silent: false,
+    yes: false,
+    auto: false,
+    split: false,
+    smartSplit: false,
+    dryRun: false,
+    help: false,
+    version: false,
+  }
+) {
+  if (!args.silent) {
+    log.info('🚀 Commit Wizard iniciado!');
+  }
+
+  // Verificar se estamos em um repositório Git
+  if (!isGitRepository()) {
+    log.error('❌ Não foi encontrado um repositório Git neste diretório.');
+    if (!args.silent) {
+      log.info(
+        '💡 Execute o comando em um diretório com repositório Git inicializado.'
+      );
+    }
+    process.exit(1);
+  }
+
+  // Carregar e validar configuração
+  if (!args.silent) {
+    log.info('⚙️  Carregando configuração...');
+  }
+  const config = loadConfig();
+
+  // Inicializar cache global
+  initializeCache(config);
+
+  // Sobrescrever configuração com argumentos CLI
+  if (args.split) {
+    config.splitCommits = true;
+  }
+  if (args.dryRun) {
+    config.dryRun = true;
+  }
+
+  const configErrors = validateConfig(config);
+
+  if (configErrors.length > 0) {
+    log.error('❌ Erros na configuração:');
+    configErrors.forEach((error) => log.error(`  • ${error}`));
+    process.exit(1);
+  }
+
+  if (!args.silent) {
+    log.success(
+      `✅ Configuração carregada (modelo: ${config.openai.model}, idioma: ${config.language})`
+    );
+  }
+
+  // Verificar arquivos staged
+  if (!args.silent) {
+    log.info('📋 Verificando arquivos staged...');
+  }
+  const gitStatus = getGitStatus();
+
+  if (!gitStatus.hasStaged) {
+    log.warn('⚠️  Nenhum arquivo foi encontrado no stage.');
+    if (!args.silent) {
+      log.info(
+        '💡 Use `git add <arquivo>` para adicionar arquivos ao stage antes de gerar o commit.'
+      );
+    }
+    process.exit(0);
+  }
+
+  const diffStats = getDiffStats();
+  if (!args.silent) {
+    log.success(
+      `✅ Encontrados ${gitStatus.stagedFiles.length} arquivo(s) staged:`
+    );
+    gitStatus.stagedFiles.forEach((file) => log.info(`  📄 ${file}`));
+    log.info(
+      `📊 Estatísticas: +${diffStats.added} -${diffStats.removed} linhas`
+    );
+  }
+
+  // Modo Split: escolher entre smart split e split manual
+  if (config.splitCommits || args.smartSplit) {
+    if (args.yes) {
+      // Modo automático: usar smart split
+      return await handleSmartSplitMode(gitStatus, config, args);
+    } else {
+      // Modo interativo: perguntar qual tipo de split
+      const splitAction = await chooseSplitMode();
+
+      switch (splitAction.action) {
+        case 'proceed':
+          return await handleSmartSplitMode(gitStatus, config, args);
+        case 'manual':
+          return await handleSplitMode(gitStatus, config, args);
+        case 'cancel':
+          showCancellation();
+          return;
+      }
+    }
+  }
+
+  // Gerar mensagem de commit com OpenAI
+  if (!args.silent) {
+    log.info('🤖 Gerando mensagem de commit com IA...');
+  }
+
+  const result = await generateWithRetry(
+    gitStatus.diff,
+    config,
+    gitStatus.stagedFiles
+  );
+
+  if (!result.success) {
+    log.error(`❌ Erro ao gerar commit: ${result.error}`);
+    process.exit(1);
+  }
+
+  if (!result.suggestion) {
+    log.error('❌ Nenhuma sugestão foi gerada');
+    process.exit(1);
+  }
+
+  if (!args.silent) {
+    log.success('✨ Mensagem de commit gerada!');
+  }
+
+  // Modo Dry Run: apenas mostrar mensagem
+  if (config.dryRun) {
+    log.info('🔍 Modo Dry Run - Mensagem gerada:');
+    log.info(`"${result.suggestion.message}"`);
+    log.info('💡 Execute sem --dry-run para fazer o commit');
+    return;
+  }
+
+  // Modo automático: commit direto
+  if (args.yes) {
+    const commitResult = executeCommit(result.suggestion.message);
+    showCommitResult(
+      commitResult.success,
+      commitResult.hash,
+      commitResult.error
+    );
+    return;
+  }
+
+  // Interface interativa
+  while (true) {
+    const uiAction = await showCommitPreview(result.suggestion);
+
+    switch (uiAction.action) {
+      case 'commit': {
+        // Commit direto com mensagem gerada
+        const commitResult = executeCommit(result.suggestion.message);
+        showCommitResult(
+          commitResult.success,
+          commitResult.hash,
+          commitResult.error
+        );
+        return;
+      }
+      case 'edit': {
+        // Editar mensagem
+        const editAction = await editCommitMessage(result.suggestion.message);
+        if (editAction.action === 'cancel') {
+          showCancellation();
+          return;
+        }
+        if (editAction.action === 'commit' && editAction.message) {
+          const editCommitResult = executeCommit(editAction.message);
+          showCommitResult(
+            editCommitResult.success,
+            editCommitResult.hash,
+            editCommitResult.error
+          );
+          return;
+        }
+        break;
+      }
+      case 'copy': {
+        // Copiar para clipboard
+        await copyToClipboard(result.suggestion.message);
+        if (!args.silent) {
+          log.info(
+            '🎯 Você pode usar a mensagem copiada com: git commit -m "mensagem"'
+          );
+        }
+        return;
+      }
+      case 'cancel': {
+        // Cancelar operação
+        showCancellation();
+        return;
+      }
+    }
+  }
+}
+
+async function handleSplitMode(gitStatus: any, config: any, args: CLIArgs) {
+  if (!args.silent) {
+    log.info('🔄 Modo Split ativado - Commits separados por arquivo');
+  }
+
+  let remainingFiles = [
+    ...(gitStatus as { stagedFiles: string[] }).stagedFiles,
+  ];
+
+  while (remainingFiles.length > 0) {
+    // Selecionar arquivos para este commit
+    const selectedFiles = args.yes
+      ? [remainingFiles[0]] // Modo automático: um arquivo por vez
+      : await selectFilesForCommit(remainingFiles);
+
+    if (selectedFiles.length === 0) {
+      if (!args.silent) {
+        log.info('❌ Nenhum arquivo selecionado');
+      }
+      break;
+    }
+
+    // Gerar diff apenas dos arquivos selecionados
+    const { getFileDiff } = await import('../git/index.ts');
+    const fileDiffs = selectedFiles
+      .filter((file): file is string => file !== undefined)
+      .map((file) => {
+        try {
+          return getFileDiff(file);
+        } catch (error) {
+          log.error(
+            `❌ Erro ao obter diff do arquivo ${file}: ${error instanceof Error ? error.message : 'Erro desconhecido'}`
+          );
+          return '';
+        }
+      })
+      .filter((diff) => diff.length > 0)
+      .join('\n');
+
+    if (!fileDiffs) {
+      if (!args.silent) {
+        log.warn('⚠️  Nenhum diff encontrado para os arquivos selecionados');
+      }
+      remainingFiles = remainingFiles.filter(
+        (file) => !selectedFiles.includes(file)
+      );
+      continue;
+    }
+
+    if (!args.silent) {
+      log.info(`🤖 Gerando commit para: ${selectedFiles.join(', ')}`);
+    }
+
+    const result = await generateWithRetry(fileDiffs, config, selectedFiles.filter((file): file is string => file !== undefined));
+
+    if (!result.success) {
+      log.error(`❌ Erro ao gerar commit: ${result.error}`);
+      remainingFiles = remainingFiles.filter(
+        (file) => !selectedFiles.includes(file)
+      );
+      continue;
+    }
+
+    if (!result.suggestion) {
+      log.error('❌ Nenhuma sugestão foi gerada');
+      remainingFiles = remainingFiles.filter(
+        (file) => !selectedFiles.includes(file)
+      );
+      continue;
+    }
+
+    // Modo Dry Run: apenas mostrar mensagem
+    if ((config as Config).dryRun) {
+      log.info(`🔍 Dry Run - Mensagem para ${selectedFiles.join(', ')}:`);
+      log.info(`"${result.suggestion.message}"`);
+      remainingFiles = remainingFiles.filter(
+        (file) => !selectedFiles.includes(file)
+      );
+      continue;
+    }
+
+    // Modo automático: commit direto
+    if (args.yes) {
+      // Para múltiplos arquivos, usar commit normal
+      // Para arquivo único, usar executeFileCommit
+      const commitResult =
+        selectedFiles.length === 1 && selectedFiles[0]
+          ? await executeFileCommit(selectedFiles[0], result.suggestion.message)
+          : await executeCommit(result.suggestion.message);
+
+      showCommitResult(
+        commitResult.success,
+        commitResult.hash,
+        commitResult.error
+      );
+    } else {
+      // Interface interativa para este commit
+      const uiAction = await showCommitPreview(result.suggestion);
+
+      if (uiAction.action === 'commit') {
+        const commitResult =
+          selectedFiles.length === 1 && selectedFiles[0]
+            ? await executeFileCommit(
+                selectedFiles[0],
+                result.suggestion.message
+              )
+            : await executeCommit(result.suggestion.message);
+        showCommitResult(
+          commitResult.success,
+          commitResult.hash,
+          commitResult.error
+        );
+      } else if (uiAction.action === 'edit') {
+        const editAction = await editCommitMessage(result.suggestion.message);
+        if (editAction.action === 'commit' && editAction.message) {
+          const commitResult =
+            selectedFiles.length === 1 && selectedFiles[0]
+              ? await executeFileCommit(selectedFiles[0], editAction.message)
+              : await executeCommit(editAction.message);
+          showCommitResult(
+            commitResult.success,
+            commitResult.hash,
+            commitResult.error
+          );
+        }
+      } else if (uiAction.action === 'copy') {
+        await copyToClipboard(result.suggestion.message);
+        if (!args.silent) {
+          log.info('🎯 Mensagem copiada para clipboard');
+        }
+      } else if (uiAction.action === 'cancel') {
+        showCancellation();
+        return;
+      }
+    }
+
+    // Remover arquivos processados
+    remainingFiles = remainingFiles.filter(
+      (file) => !selectedFiles.includes(file)
+    );
+
+    // Perguntar se quer continuar (exceto em modo automático)
+    if (remainingFiles.length > 0 && !args.yes) {
+      const continueCommits = await askContinueCommits(remainingFiles);
+      if (!continueCommits) {
+        break;
+      }
+    }
+  }
+
+  if (!args.silent) {
+    log.success('✅ Modo Split concluído!');
+  }
+}

package/src/core/openai.ts

@@ -0,0 +1,336 @@
+import type { Config } from '../config/index.ts';
+
+export interface CommitSuggestion {
+  message: string;
+  type:
+    | 'feat'
+    | 'fix'
+    | 'docs'
+    | 'style'
+    | 'refactor'
+    | 'test'
+    | 'chore'
+    | 'build'
+    | 'ci';
+  confidence: number;
+}
+
+export interface OpenAIResponse {
+  success: boolean;
+  suggestion?: CommitSuggestion;
+  error?: string;
+}
+
+/**
+ * Constrói o prompt para a OpenAI baseado no diff e configurações (otimizado)
+ */
+export function buildPrompt(
+  diff: string,
+  config: Config,
+  filenames: string[]
+): string {
+  const language = config.language === 'pt' ? 'português' : 'english';
+  const styleInstructions = getStyleInstructions(
+    config.commitStyle,
+    config.language
+  );
+
+  // Limitar tamanho do diff para economizar tokens
+  const maxDiffLength = 6000;
+  const truncatedDiff = diff.length > maxDiffLength 
+    ? diff.substring(0, maxDiffLength) + '\n... (diff truncado)'
+    : diff;
+
+  // Simplificar lista de arquivos se houver muitos
+  const fileList = filenames.length > 10 
+    ? `${filenames.length} arquivos: ${filenames.slice(0, 5).join(', ')}...`
+    : filenames.join(', ');
+
+  const prompt = `Gere mensagem de commit em ${language} (${config.commitStyle}).
+
+Arquivos: ${fileList}
+
+${styleInstructions}
+
+Diff:
+\`\`\`
+${truncatedDiff}
+\`\`\`
+
+Mensagem:`;
+
+  return prompt;
+}
+
+/**
+ * Obtém instruções específicas baseadas no estilo de commit
+ */
+function getStyleInstructions(style: string, language: string): string {
+  const instructions = {
+    pt: {
+      conventional: `- Use formato: tipo(escopo): descrição
+- Tipos válidos: feat, fix, docs, style, refactor, test, chore, build, ci
+- Exemplo: "feat(auth): adicionar validação de email"
+- Mantenha a primeira linha com até 50 caracteres`,
+
+      simple: `- Use formato simples e direto
+- Comece com verbo no infinitivo
+- Exemplo: "corrigir validação de formulário"
+- Máximo 50 caracteres`,
+
+      detailed: `- Primeira linha: resumo em até 50 caracteres
+- Se necessário, adicione corpo explicativo
+- Use presente do indicativo
+- Seja descritivo mas conciso`,
+    },
+    en: {
+      conventional: `- Use format: type(scope): description
+- Valid types: feat, fix, docs, style, refactor, test, chore, build, ci
+- Example: "feat(auth): add email validation"
+- Keep first line under 50 characters`,
+
+      simple: `- Use simple and direct format
+- Start with imperative verb
+- Example: "fix form validation"
+- Maximum 50 characters`,
+
+      detailed: `- First line: summary under 50 characters
+- Add explanatory body if needed
+- Use imperative mood
+- Be descriptive but concise`,
+    },
+  };
+
+  const lang = language === 'pt' ? 'pt' : 'en';
+  return (
+    instructions[lang][style as keyof typeof instructions.pt] ||
+    instructions[lang].conventional
+  );
+}
+
+/**
+ * Extrai o tipo de commit da mensagem gerada pela OpenAI
+ */
+export function extractCommitTypeFromMessage(
+  message: string
+): CommitSuggestion['type'] | null {
+  // Padrões para detectar tipos de commit
+  const typePatterns = {
+    feat: /^(feat|feature)(\([^)]+\))?:/i,
+    fix: /^(fix|bugfix)(\([^)]+\))?:/i,
+    docs: /^(docs|documentation)(\([^)]+\))?:/i,
+    style: /^(style|format)(\([^)]+\))?:/i,
+    refactor: /^(refactor|refactoring)(\([^)]+\))?:/i,
+    test: /^(test|testing)(\([^)]+\))?:/i,
+    chore: /^(chore|maintenance)(\([^)]+\))?:/i,
+    build: /^(build|ci)(\([^)]+\))?:/i,
+    ci: /^(ci|continuous-integration)(\([^)]+\))?:/i,
+  };
+
+  for (const [type, pattern] of Object.entries(typePatterns)) {
+    if (pattern.test(message)) {
+      return type as CommitSuggestion['type'];
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detecta o tipo de commit baseado no diff
+ */
+export function detectCommitType(
+  diff: string,
+  filenames: string[]
+): CommitSuggestion['type'] {
+  const diffLower = diff.toLowerCase();
+  const filesStr = filenames.join(' ').toLowerCase();
+
+  // Testes
+  if (
+    filesStr.includes('test') ||
+    filesStr.includes('spec') ||
+    diffLower.includes('test(')
+  ) {
+    return 'test';
+  }
+
+  // Documentação
+  if (
+    filesStr.includes('readme') ||
+    filesStr.includes('.md') ||
+    filesStr.includes('docs')
+  ) {
+    return 'docs';
+  }
+
+  // Build/CI
+  if (
+    filesStr.includes('package.json') ||
+    filesStr.includes('dockerfile') ||
+    filesStr.includes('.yml') ||
+    filesStr.includes('.yaml') ||
+    filesStr.includes('webpack') ||
+    filesStr.includes('tsconfig')
+  ) {
+    return 'build';
+  }
+
+  // Styles
+  if (
+    filesStr.includes('.css') ||
+    filesStr.includes('.scss') ||
+    diffLower.includes('style') ||
+    diffLower.includes('format')
+  ) {
+    return 'style';
+  }
+
+  // Fixes
+  if (
+    diffLower.includes('fix') ||
+    diffLower.includes('bug') ||
+    diffLower.includes('error') ||
+    diffLower.includes('issue')
+  ) {
+    return 'fix';
+  }
+
+  // Features (padrão para novas funcionalidades)
+  if (
+    diffLower.includes('add') ||
+    diffLower.includes('new') ||
+    diffLower.includes('create') ||
+    diffLower.includes('implement')
+  ) {
+    return 'feat';
+  }
+
+  // Refactor
+  if (
+    diffLower.includes('refactor') ||
+    diffLower.includes('restructure') ||
+    diffLower.includes('rename')
+  ) {
+    return 'refactor';
+  }
+
+  // Default
+  return 'chore';
+}
+
+/**
+ * Consome a API da OpenAI para gerar mensagem de commit
+ */
+export async function generateCommitMessage(
+  diff: string,
+  config: Config,
+  filenames: string[]
+): Promise<OpenAIResponse> {
+  try {
+    if (!config.openai.apiKey) {
+      return {
+        success: false,
+        error:
+          'Chave da OpenAI não encontrada. Configure OPENAI_API_KEY nas variáveis de ambiente.',
+      };
+    }
+
+    const prompt = buildPrompt(diff, config, filenames);
+
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${config.openai.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: config.openai.model,
+        messages: [
+          {
+            role: 'user',
+            content: prompt,
+          },
+        ],
+        max_tokens: Math.min(config.openai.maxTokens, 150), // Limitar para economizar tokens
+        temperature: config.openai.temperature,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorData = (await response.json().catch(() => ({}))) as any;
+      return {
+        success: false,
+        error: `Erro da OpenAI (${response.status}): ${errorData.error?.message || 'Erro desconhecido'}`,
+      };
+    }
+
+    const data = (await response.json()) as any;
+    let message = data.choices?.[0]?.message?.content?.trim();
+
+    if (!message) {
+      return {
+        success: false,
+        error: 'OpenAI retornou resposta vazia',
+      };
+    }
+
+    // Remover backticks se presentes
+    message = message.replace(/^```\s*/, '').replace(/\s*```$/, '');
+
+    // Remover quebras de linha extras
+    message = message.trim();
+
+    // Extrair tipo da mensagem gerada pela OpenAI
+    const extractedType = extractCommitTypeFromMessage(message);
+    const fallbackType = detectCommitType(diff, filenames);
+
+    return {
+      success: true,
+      suggestion: {
+        message,
+        type: extractedType || fallbackType,
+        confidence: 0.8, // Placeholder - pode ser melhorado
+      },
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Erro ao conectar com OpenAI: ${error instanceof Error ? error.message : 'Erro desconhecido'}`,
+    };
+  }
+}
+
+/**
+ * Gera mensagem com retry em caso de falha
+ */
+export async function generateWithRetry(
+  diff: string,
+  config: Config,
+  filenames: string[],
+  maxRetries: number = 3
+): Promise<OpenAIResponse> {
+  let lastError = '';
+
+  for (let i = 0; i < maxRetries; i++) {
+    const result = await generateCommitMessage(diff, config, filenames);
+
+    if (result.success) {
+      return result;
+    }
+
+    lastError = result.error || 'Erro desconhecido';
+
+    // Aguardar antes de tentar novamente (exponential backoff)
+    if (i < maxRetries - 1) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, Math.pow(2, i) * 1000)
+      );
+    }
+  }
+
+  return {
+    success: false,
+    error: `Falha após ${maxRetries} tentativas. Último erro: ${lastError}`,
+  };
+}