@gilbert_oliveira/commit-wizard 1.2.2 → 2.0.1

package/src/git/index.ts

@@ -0,0 +1,177 @@
+import { execSync } from 'child_process';
+
+export interface GitStatus {
+  hasStaged: boolean;
+  stagedFiles: string[];
+  diff: string;
+}
+
+export interface GitCommitResult {
+  success: boolean;
+  hash?: string;
+  message?: string;
+  error?: string;
+}
+
+/**
+ * Verifica se estamos em um repositório Git
+ */
+export function isGitRepository(): boolean {
+  try {
+    execSync('git rev-parse --git-dir', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Obtém o status dos arquivos staged e o diff
+ */
+export function getGitStatus(): GitStatus {
+  try {
+    // Verificar arquivos staged
+    const stagedOutput = execSync('git diff --cached --name-only', {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+
+    const stagedFiles = stagedOutput
+      .trim()
+      .split('\n')
+      .filter((file) => file.length > 0);
+
+    // Obter diff dos arquivos staged
+    const diff =
+      stagedFiles.length > 0
+        ? execSync('git diff --cached', { encoding: 'utf-8', stdio: 'pipe' })
+        : '';
+
+    return {
+      hasStaged: stagedFiles.length > 0,
+      stagedFiles,
+      diff: diff.trim(),
+    };
+  } catch (error) {
+    throw new Error(
+      `Erro ao obter status do Git: ${error instanceof Error ? error.message : 'Erro desconhecido'}`
+    );
+  }
+}
+
+/**
+ * Obtém o diff de um arquivo específico
+ */
+export function getFileDiff(filename: string): string {
+  try {
+    return execSync(`git diff --cached -- "${filename}"`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+  } catch (error) {
+    throw new Error(
+      `Erro ao obter diff do arquivo ${filename}: ${error instanceof Error ? error.message : 'Erro desconhecido'}`
+    );
+  }
+}
+
+/**
+ * Executa um commit com a mensagem fornecida
+ */
+export function executeCommit(message: string): GitCommitResult {
+  try {
+    // Executar commit
+    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+      stdio: 'pipe',
+    });
+
+    // Obter hash do commit
+    const hash = execSync('git rev-parse HEAD', {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    }).trim();
+
+    return {
+      success: true,
+      hash,
+      message,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error:
+        error instanceof Error
+          ? error.message
+          : 'Erro desconhecido ao executar commit',
+    };
+  }
+}
+
+/**
+ * Executa commit de arquivo específico
+ */
+export function executeFileCommit(
+  filename: string,
+  message: string
+): GitCommitResult {
+  try {
+    // Commit apenas do arquivo específico
+    execSync(`git commit "${filename}" -m "${message.replace(/"/g, '\\"')}"`, {
+      stdio: 'pipe',
+    });
+
+    // Obter hash do commit
+    const hash = execSync('git rev-parse HEAD', {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    }).trim();
+
+    return {
+      success: true,
+      hash,
+      message,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error:
+        error instanceof Error
+          ? error.message
+          : 'Erro desconhecido ao executar commit do arquivo',
+    };
+  }
+}
+
+/**
+ * Obtém estatísticas do diff (linhas adicionadas/removidas)
+ */
+export function getDiffStats(): {
+  added: number;
+  removed: number;
+  files: number;
+} {
+  try {
+    const output = execSync('git diff --cached --numstat', {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+
+    const lines = output
+      .trim()
+      .split('\n')
+      .filter((line) => line.length > 0);
+    let added = 0;
+    let removed = 0;
+
+    lines.forEach((line) => {
+      const [addedStr, removedStr] = line.split('\t');
+      if (addedStr && addedStr !== '-') added += parseInt(addedStr) || 0;
+      if (removedStr && removedStr !== '-')
+        removed += parseInt(removedStr) || 0;
+    });
+
+    return { added, removed, files: lines.length };
+  } catch {
+    return { added: 0, removed: 0, files: 0 };
+  }
+}

package/src/ui/index.ts

@@ -0,0 +1,204 @@
+import {
+  text,
+  select,
+  confirm,
+  log,
+  note,
+  cancel,
+  isCancel,
+} from '@clack/prompts';
+import clipboardy from 'clipboardy';
+import type { CommitSuggestion } from '../core/openai.ts';
+
+export interface UIAction {
+  action: 'commit' | 'edit' | 'copy' | 'cancel';
+  message?: string;
+}
+
+/**
+ * Exibe a mensagem gerada e permite interação do usuário
+ */
+export async function showCommitPreview(
+  suggestion: CommitSuggestion
+): Promise<UIAction> {
+  // Exibir preview da mensagem
+  note(
+    `Tipo: ${suggestion.type}\nMensagem: "${suggestion.message}"`,
+    '💭 Sugestão de Commit'
+  );
+
+  // Opções disponíveis
+  const action = await select({
+    message: 'O que você gostaria de fazer?',
+    options: [
+      {
+        value: 'commit',
+        label: '✅ Fazer commit com esta mensagem',
+        hint: 'Executar git commit imediatamente',
+      },
+      {
+        value: 'edit',
+        label: '✏️  Editar mensagem',
+        hint: 'Modificar a mensagem antes de commitar',
+      },
+      {
+        value: 'copy',
+        label: '📋 Copiar para clipboard',
+        hint: 'Copiar mensagem e sair sem commitar',
+      },
+      {
+        value: 'cancel',
+        label: '❌ Cancelar',
+        hint: 'Sair sem fazer nada',
+      },
+    ],
+  });
+
+  if (isCancel(action)) {
+    return { action: 'cancel' };
+  }
+
+  return { action: action as UIAction['action'] };
+}
+
+/**
+ * Permite edição da mensagem de commit
+ */
+export async function editCommitMessage(
+  originalMessage: string
+): Promise<UIAction> {
+  const editedMessage = await text({
+    message: 'Edite a mensagem do commit:',
+    initialValue: originalMessage,
+    placeholder: 'Digite a mensagem do commit...',
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return 'A mensagem não pode estar vazia';
+      }
+      if (value.trim().length > 72) {
+        return 'A mensagem está muito longa (máximo 72 caracteres recomendado)';
+      }
+    },
+  });
+
+  if (isCancel(editedMessage)) {
+    return { action: 'cancel' };
+  }
+
+  const confirmEdit = await confirm({
+    message: `Confirma a mensagem editada: "${editedMessage}"?`,
+  });
+
+  if (isCancel(confirmEdit) || !confirmEdit) {
+    return { action: 'cancel' };
+  }
+
+  return {
+    action: 'commit',
+    message: editedMessage,
+  };
+}
+
+/**
+ * Copia mensagem para clipboard
+ */
+export async function copyToClipboard(message: string): Promise<boolean> {
+  try {
+    await clipboardy.write(message);
+    log.success('✅ Mensagem copiada para a área de transferência!');
+    return true;
+  } catch (error) {
+    log.error(
+      `❌ Erro ao copiar: ${error instanceof Error ? error.message : 'Erro desconhecido'}`
+    );
+    return false;
+  }
+}
+
+/**
+ * Confirma execução do commit
+ */
+export async function confirmCommit(message: string): Promise<boolean> {
+  note(`"${message}"`, '🚀 Confirmar Commit');
+
+  const confirmed = await confirm({
+    message: 'Executar o commit agora?',
+  });
+
+  if (isCancel(confirmed)) {
+    return false;
+  }
+
+  return confirmed;
+}
+
+/**
+ * Exibe resultado do commit
+ */
+export function showCommitResult(
+  success: boolean,
+  hash?: string,
+  error?: string
+) {
+  if (success && hash) {
+    log.success(`✅ Commit realizado com sucesso!`);
+    log.info(`🔗 Hash: ${hash.substring(0, 8)}`);
+  } else {
+    log.error(`❌ Erro ao realizar commit: ${error || 'Erro desconhecido'}`);
+  }
+}
+
+/**
+ * Interface para modo split (múltiplos commits)
+ */
+export async function selectFilesForCommit(files: string[]): Promise<string[]> {
+  log.info('📋 Modo Split: Selecione os arquivos para este commit');
+
+  const selectedFiles: string[] = [];
+
+  for (const file of files) {
+    const include = await confirm({
+      message: `Incluir "${file}" neste commit?`,
+    });
+
+    if (isCancel(include)) {
+      break;
+    }
+
+    if (include) {
+      selectedFiles.push(file);
+    }
+  }
+
+  return selectedFiles;
+}
+
+/**
+ * Confirma se usuário quer continuar com mais commits
+ */
+export async function askContinueCommits(
+  remainingFiles: string[]
+): Promise<boolean> {
+  if (remainingFiles.length === 0) {
+    return false;
+  }
+
+  log.info(`📄 Arquivos restantes: ${remainingFiles.join(', ')}`);
+
+  const continueCommits = await confirm({
+    message: 'Gerar commit para os arquivos restantes?',
+  });
+
+  if (isCancel(continueCommits)) {
+    return false;
+  }
+
+  return continueCommits;
+}
+
+/**
+ * Exibe mensagem de cancelamento
+ */
+export function showCancellation() {
+  cancel('Operação cancelada pelo usuário');
+}

package/src/ui/smart-split.ts

@@ -0,0 +1,141 @@
+import { select, confirm, log, note, isCancel } from '@clack/prompts';
+import type { FileGroup } from '../core/smart-split.ts';
+
+export interface SmartSplitAction {
+  action: 'proceed' | 'manual' | 'cancel';
+  groups?: FileGroup[];
+}
+
+/**
+ * Interface para escolher entre smart split e split manual
+ */
+export async function chooseSplitMode(): Promise<SmartSplitAction> {
+  const mode = await select({
+    message: 'Como você gostaria de organizar os commits?',
+    options: [
+      {
+        value: 'smart',
+        label: '🧠 Smart Split (Recomendado)',
+        hint: 'IA analisa contexto e agrupa automaticamente',
+      },
+      {
+        value: 'manual',
+        label: '✋ Split Manual',
+        hint: 'Você escolhe arquivos manualmente',
+      },
+      {
+        value: 'cancel',
+        label: '❌ Cancelar',
+        hint: 'Voltar ao modo normal',
+      },
+    ],
+  });
+
+  if (isCancel(mode)) {
+    return { action: 'cancel' };
+  }
+
+  if (mode === 'manual') {
+    return { action: 'manual' };
+  }
+
+  if (mode === 'smart') {
+    return { action: 'proceed' };
+  }
+
+  return { action: 'cancel' };
+}
+
+/**
+ * Exibe os grupos identificados pela IA
+ */
+export async function showSmartSplitGroups(
+  groups: FileGroup[]
+): Promise<SmartSplitAction> {
+  note(
+    `Identificamos ${groups.length} grupo(s) lógico(s) para seus commits:\n\n` +
+      groups
+        .map(
+          (group, index) =>
+            `${index + 1}. **${group.name}**\n` +
+            `   📄 ${group.files.join(', ')}\n` +
+            `   💡 ${group.description}\n` +
+            `   🎯 Confiança: ${Math.round(group.confidence * 100)}%`
+        )
+        .join('\n\n'),
+    '🧠 Análise de Contexto'
+  );
+
+  const action = await select({
+    message: 'O que você gostaria de fazer?',
+    options: [
+      {
+        value: 'proceed',
+        label: '✅ Prosseguir com esta organização',
+        hint: 'Usar os grupos como sugeridos pela IA',
+      },
+      {
+        value: 'manual',
+        label: '✋ Fazer split manual',
+        hint: 'Escolher arquivos manualmente',
+      },
+      {
+        value: 'cancel',
+        label: '❌ Cancelar',
+        hint: 'Voltar ao modo normal',
+      },
+    ],
+  });
+
+  if (isCancel(action)) {
+    return { action: 'cancel' };
+  }
+
+  if (action === 'proceed') {
+    return { action: 'proceed', groups };
+  }
+
+  return { action: action as 'manual' | 'cancel' };
+}
+
+/**
+ * Interface para confirmar commit de um grupo
+ */
+export async function confirmGroupCommit(
+  group: FileGroup,
+  message: string
+): Promise<boolean> {
+  note(
+    `**Grupo:** ${group.name}\n` +
+      `**Arquivos:** ${group.files.join(', ')}\n` +
+      `**Mensagem:** "${message}"`,
+    '🚀 Confirmar Commit do Grupo'
+  );
+
+  const confirmed = await confirm({
+    message: `Fazer commit para "${group.name}"?`,
+  });
+
+  if (isCancel(confirmed)) {
+    return false;
+  }
+
+  return confirmed;
+}
+
+/**
+ * Interface para mostrar progresso do smart split
+ */
+export function showSmartSplitProgress(
+  current: number,
+  total: number,
+  groupName: string
+): void {
+  const progress = Math.round((current / total) * 100);
+  const bar =
+    '█'.repeat(Math.floor(progress / 10)) +
+    '░'.repeat(10 - Math.floor(progress / 10));
+
+  log.info(`🔄 Progresso: [${bar}] ${progress}% (${current}/${total})`);
+  log.info(`📋 Processando: ${groupName}`);
+}

package/src/utils/args.ts

@@ -0,0 +1,56 @@
+export interface CLIArgs {
+  silent: boolean;
+  yes: boolean;
+  auto: boolean;
+  split: boolean;
+  smartSplit: boolean;
+  dryRun: boolean;
+  help: boolean;
+  version: boolean;
+}
+
+export function parseArgs(args: string[]): CLIArgs {
+  return {
+    silent: args.includes('--silent') || args.includes('-s'),
+    yes: args.includes('--yes') || args.includes('-y'),
+    auto: args.includes('--auto') || args.includes('-a'),
+    split: args.includes('--split'),
+    smartSplit: args.includes('--smart-split'),
+    dryRun: args.includes('--dry-run') || args.includes('-n'),
+    help: args.includes('--help') || args.includes('-h'),
+    version: args.includes('--version') || args.includes('-v'),
+  };
+}
+
+export function showHelp(): void {
+  console.log(`
+🧙‍♂️ Commit Wizard - Gerador inteligente de mensagens de commit
+
+USAGE:
+  commit-wizard [OPTIONS]
+
+OPTIONS:
+  -s, --silent         Modo silencioso (sem logs detalhados)
+  -y, --yes            Confirmar automaticamente sem prompts
+  -a, --auto           Modo automático (--yes + --silent)
+  --split              Modo split manual (commits separados por arquivo)
+  --smart-split        Modo smart split (IA agrupa por contexto)
+  -n, --dry-run        Visualizar mensagem sem fazer commit
+  -h, --help           Mostrar esta ajuda
+  -v, --version        Mostrar versão
+
+EXAMPLES:
+  commit-wizard                    # Modo interativo padrão
+  commit-wizard --yes              # Commit automático
+  commit-wizard --split            # Split manual por arquivo
+  commit-wizard --smart-split      # Smart split com IA
+  commit-wizard --dry-run          # Apenas visualizar mensagem
+  commit-wizard --auto             # Modo totalmente automático
+
+Para mais informações, visite: https://github.com/user/commit-wizard
+`);
+}
+
+export function showVersion(): void {
+  console.log('commit-wizard v1.0.0');
+}

package/src/utils/polyfill.ts

@@ -0,0 +1,82 @@
+/**
+ * Polyfill para stripVTControlCharacters para compatibilidade com Bun/Node.js
+ * 
+ * Este polyfill resolve problemas de compatibilidade onde o Bun não mapeia
+ * corretamente a função stripVTControlCharacters do módulo util do Node.js.
+ * A função foi adicionada ao Node.js v16.14.0+ mas pode não estar disponível
+ * em todos os ambientes ou ter problemas de mapping no Bun.
+ */
+
+/**
+ * Remove caracteres de controle VT de uma string
+ * Implementação baseada na função nativa do Node.js
+ * 
+ * @param str - String da qual remover os caracteres de controle
+ * @returns String limpa sem caracteres de controle VT/ANSI
+ */
+function stripVTControlCharacters(str: string): string {
+  if (typeof str !== 'string') {
+    throw new TypeError('The "str" argument must be of type string');
+  }
+
+  // Regex para caracteres de controle ANSI/VT
+  // Baseada na implementação oficial do Node.js
+  const esc = String.fromCharCode(27); // ESC character (\u001B)
+  const csi = String.fromCharCode(155); // CSI character (\u009B)
+  const ansiRegex = new RegExp(`[${esc}${csi}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`, 'g');
+  
+  return str.replace(ansiRegex, '');
+}
+
+// Interceptar require/import do módulo util antes de qualquer outra coisa
+ 
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+
+Module.prototype.require = function(id: string) {
+  const result = originalRequire.apply(this, arguments);
+  
+  // Se estiver importando o módulo util e stripVTControlCharacters não existe, adicionar
+  if (id === 'util' && result && !result.stripVTControlCharacters) {
+    result.stripVTControlCharacters = stripVTControlCharacters;
+    // Tornar a propriedade não enumerável para não interferir em iterações
+    Object.defineProperty(result, 'stripVTControlCharacters', {
+      value: stripVTControlCharacters,
+      writable: false,
+      enumerable: true,
+      configurable: false,
+    });
+  }
+  
+  return result;
+};
+
+ 
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace NodeJS {
+    interface Global {
+      stripVTControlCharacters?: typeof stripVTControlCharacters;
+    }
+  }
+}
+
+// Disponibilizar globalmente também como fallback
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+if (typeof globalThis !== 'undefined' && !(globalThis as any).stripVTControlCharacters) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  (globalThis as any).stripVTControlCharacters = stripVTControlCharacters;
+}
+
+// Tentar aplicar diretamente ao módulo util se possível
+try {
+   
+  const util = require('util');
+  if (!util.stripVTControlCharacters) {
+    util.stripVTControlCharacters = stripVTControlCharacters;
+  }
+} catch {
+  // Ignorar se não conseguir aplicar
+}
+
+export { stripVTControlCharacters };

package/dist/ai-service.d.ts

@@ -1,44 +0,0 @@
-import { Config } from './config.js';
-export interface AIResponse {
-    content: string;
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}
-/**
- * Serviço para interação com APIs de IA
- */
-export declare class AIService {
-    private config;
-    constructor(config: Config);
-    /**
-     * Gera prompt do sistema baseado no modo e linguagem
-     */
-    private getSystemPrompt;
-    /**
-     * Gera prompt para mensagem de commit
-     */
-    private getCommitPrompt;
-    /**
-     * Realiza chamada para a API da OpenAI
-     */
-    callOpenAI(prompt: string, mode?: 'commit' | 'summary'): Promise<AIResponse>;
-    /**
-     * Limpa a resposta da API removendo conteúdo inválido
-     */
-    private cleanApiResponse;
-    /**
-     * Valida se a mensagem de commit é válida
-     */
-    private validateCommitMessage;
-    /**
-     * Gera resumo de um chunk de diff
-     */
-    generateSummary(chunk: string): Promise<string>;
-    /**
-     * Gera mensagem de commit baseada no diff ou resumo
-     */
-    generateCommitMessage(diffOrSummary: string): Promise<AIResponse>;
-}