@gilbert_oliveira/commit-wizard 2.12.2-canary.1 → 2.12.3-canary.2

package/src/providers/openai.ts

@@ -0,0 +1,367 @@
+import type { Config } from '../config/index';
+import type { CommitlintRules } from '../commitlint/index';
+import type { AIProvider } from './types';
+import { buildPrompt } from '../prompt/builder';
+import { buildSystemMessage } from '../prompt/system';
+import { shouldIgnoreFile } from '../git/diff-filter';
+
+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;
+}
+
+/**
+ * Prioriza e trunca diffs para caber no limite de tokens da IA.
+ * Deprioritiza lockfiles e arquivos de build (delegando detecção ao diff-filter.ts).
+ * Para filtragem completa de arquivos irrelevantes, use filterDiff() antes desta função.
+ */
+export function smartFilterDiff(diff: string, maxLength: number): string {
+  if (diff.length <= maxLength) {
+    return diff;
+  }
+
+  const fileDiffs = diff.split(/(?=^diff --git)/m).filter((block) => block.trim());
+
+  const highPriorityDiffs: string[] = [];
+  const lowPriorityDiffs: string[] = [];
+
+  fileDiffs.forEach((fileDiff) => {
+    const headerMatch = fileDiff.match(/^diff --git a\/(.*?) b\//m);
+    const filename = headerMatch ? headerMatch[1]! : '';
+    if (shouldIgnoreFile(filename)) {
+      lowPriorityDiffs.push(fileDiff);
+    } else {
+      highPriorityDiffs.push(fileDiff);
+    }
+  });
+
+  let result = '';
+  let remainingLength = maxLength;
+
+  for (const fileDiff of highPriorityDiffs) {
+    if (fileDiff.length <= remainingLength) {
+      result += fileDiff;
+      remainingLength -= fileDiff.length;
+    } else if (remainingLength > 200) {
+      result += fileDiff.substring(0, remainingLength - 50);
+      remainingLength = maxLength - result.length;
+      break;
+    } else {
+      break;
+    }
+  }
+
+  if (!result && lowPriorityDiffs.length > 0 && remainingLength > 0) {
+    for (const fileDiff of lowPriorityDiffs) {
+      if (fileDiff.length <= remainingLength) {
+        result += fileDiff;
+        remainingLength -= fileDiff.length;
+      } else if (remainingLength > 200) {
+        result += fileDiff.substring(0, remainingLength - 50);
+        remainingLength = maxLength - result.length;
+        break;
+      } else {
+        break;
+      }
+    }
+  }
+
+  const optimizationMessage = '\n... (diff otimizado para focar em mudanças principais)';
+  if (remainingLength > 200 && lowPriorityDiffs.length > 0) {
+    const lowPrioritySummary = `\n\n... (${lowPriorityDiffs.length} arquivo(s) de dependências/build omitido(s): ${lowPriorityDiffs
+      .map((d) => {
+        const match = d.match(/^diff --git a\/(.*?) b\//);
+        return match ? match[1] : '';
+      })
+      .filter(Boolean)
+      .join(', ')})`;
+
+    const availableSpace = remainingLength - optimizationMessage.length;
+    if (lowPrioritySummary.length < availableSpace) {
+      result += lowPrioritySummary;
+    }
+  }
+
+  const wasFiltered = result.trim() !== diff.trim();
+
+  return wasFiltered
+    ? result + optimizationMessage
+    : result;
+}
+
+/**
+ * Extrai o tipo de commit da mensagem gerada pela OpenAI
+ */
+export function extractCommitTypeFromMessage(
+  message: string
+): CommitSuggestion['type'] | null {
+  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();
+
+  if (
+    filesStr.includes('test') ||
+    filesStr.includes('spec') ||
+    diffLower.includes('test(')
+  ) {
+    return 'test';
+  }
+
+  if (
+    filesStr.includes('readme') ||
+    filesStr.includes('.md') ||
+    filesStr.includes('docs')
+  ) {
+    return 'docs';
+  }
+
+  if (
+    filesStr.includes('package.json') ||
+    filesStr.includes('dockerfile') ||
+    filesStr.includes('.yml') ||
+    filesStr.includes('.yaml') ||
+    filesStr.includes('webpack') ||
+    filesStr.includes('tsconfig')
+  ) {
+    return 'build';
+  }
+
+  if (
+    filesStr.includes('.css') ||
+    filesStr.includes('.scss') ||
+    diffLower.includes('style') ||
+    diffLower.includes('format')
+  ) {
+    return 'style';
+  }
+
+  if (
+    diffLower.includes('fix') ||
+    diffLower.includes('bug') ||
+    diffLower.includes('error') ||
+    diffLower.includes('issue')
+  ) {
+    return 'fix';
+  }
+
+  if (
+    diffLower.includes('add') ||
+    diffLower.includes('new') ||
+    diffLower.includes('create') ||
+    diffLower.includes('implement')
+  ) {
+    return 'feat';
+  }
+
+  if (
+    diffLower.includes('refactor') ||
+    diffLower.includes('restructure') ||
+    diffLower.includes('rename')
+  ) {
+    return 'refactor';
+  }
+
+  return 'chore';
+}
+
+/**
+ * Processa a mensagem retornada pela OpenAI removendo formatação desnecessária
+ */
+export function processOpenAIMessage(message: string): string {
+  if (message.startsWith('```')) {
+    const blockWithBodyMatch = message.match(/^```[^\n`]*\n([\s\S]*?)\n\s*```([\s\S]*)$/);
+    if (blockWithBodyMatch) {
+      const codeContent = blockWithBodyMatch[1].trim();
+      const afterBlock = blockWithBodyMatch[2].trim();
+      message = afterBlock ? `${codeContent}\n\n${afterBlock}` : codeContent;
+    } else if (message.match(/^```[\s\S]*```$/)) {
+      message = message
+        .replace(/^```(?:plaintext|javascript|typescript|python|java|html|css|json|xml|yaml|yml|bash|shell|text)?\s*/, '')
+        .replace(/\s*```$/, '');
+    }
+  }
+
+  message = message.trim();
+
+  return message;
+}
+
+/**
+ * OpenAIProvider implements the AIProvider interface for the OpenAI API.
+ */
+export class OpenAIProvider implements AIProvider {
+  constructor(private config: Config) {}
+
+  async generate(prompt: string, systemMessage: string | null): Promise<string> {
+    if (!this.config.openai.apiKey) {
+      throw new Error(
+        'Chave da OpenAI não encontrada. Configure OPENAI_API_KEY nas variáveis de ambiente.'
+      );
+    }
+
+    const messages: Array<{ role: string; content: string }> = [];
+    if (systemMessage) {
+      messages.push({ role: 'system', content: systemMessage });
+    }
+    messages.push({ role: 'user', content: prompt });
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.config.openai.timeout
+    );
+
+    try {
+      const response = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.config.openai.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: this.config.openai.model,
+          messages,
+          max_tokens: Math.min(this.config.openai.maxTokens, 150),
+          temperature: this.config.openai.temperature,
+        }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as any;
+        throw new Error(
+          `Erro da OpenAI (${response.status}): ${errorData.error?.message || 'Erro desconhecido'}`
+        );
+      }
+
+      const data = (await response.json()) as any;
+      const message = data.choices?.[0]?.message?.content?.trim();
+
+      if (!message) {
+        throw new Error('OpenAI retornou resposta vazia');
+      }
+
+      return message;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
+/**
+ * Consome a API da OpenAI para gerar mensagem de commit
+ */
+export async function generateCommitMessage(
+  diff: string,
+  config: Config,
+  filenames: string[],
+  commitlintRules?: CommitlintRules | null
+): Promise<OpenAIResponse> {
+  try {
+    const provider = new OpenAIProvider(config);
+
+    // Filter diff before building the prompt
+    const maxDiffLength = 6000;
+    const filteredDiff = smartFilterDiff(diff, maxDiffLength);
+
+    const prompt = buildPrompt(filteredDiff, config, filenames, commitlintRules);
+    const systemMessage = buildSystemMessage(config, commitlintRules);
+
+    const rawMessage = await provider.generate(prompt, systemMessage);
+    const message = processOpenAIMessage(rawMessage);
+
+    const extractedType = extractCommitTypeFromMessage(message);
+    const fallbackType = detectCommitType(diff, filenames);
+
+    return {
+      success: true,
+      suggestion: {
+        message,
+        type: extractedType || fallbackType,
+        confidence: 0.8,
+      },
+    };
+  } 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,
+  commitlintRules?: CommitlintRules | null
+): Promise<OpenAIResponse> {
+  let lastError = '';
+
+  for (let i = 0; i < maxRetries; i++) {
+    const result = await generateCommitMessage(diff, config, filenames, commitlintRules);
+
+    if (result.success) {
+      return result;
+    }
+
+    lastError = result.error || 'Erro desconhecido';
+
+    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}`,
+  };
+}

package/src/providers/types.ts

@@ -0,0 +1,11 @@
+export interface AIProvider {
+  generate(prompt: string, systemMessage: string | null): Promise<string>;
+}
+
+export interface ProviderConfig {
+  model: string;
+  maxTokens: number;
+  temperature: number;
+  timeout: number;
+  apiKey: string;
+}

package/src/types/clack.d.ts

@@ -1,9 +1,54 @@
 declare module '@clack/prompts' {
-  export const intro: (message: string) => void;
-  export const outro: (message: string) => void;
+  export const intro: (message?: string) => void;
+  export const outro: (message?: string) => void;
+  export const cancel: (message?: string) => void;
+  export const note: (message?: string, title?: string) => void;
+  export function isCancel(value: unknown): value is symbol;
+
   export const log: {
-    error: (message: string) => void;
+    message: (message?: string) => void;
     info: (message: string) => void;
     success: (message: string) => void;
+    step: (message: string) => void;
+    warn: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+  };
+
+  export function text(opts: {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+  }): Promise<string | symbol>;
+
+  export function confirm(opts: {
+    message: string;
+    active?: string;
+    inactive?: string;
+    initialValue?: boolean;
+  }): Promise<boolean | symbol>;
+
+  export function select<Value>(opts: {
+    message: string;
+    options: Array<{ value: Value; label?: string; hint?: string }>;
+    initialValue?: Value;
+    maxItems?: number;
+  }): Promise<Value | symbol>;
+
+  export function multiselect<Value>(opts: {
+    message: string;
+    options: Array<{ value: Value; label?: string; hint?: string }>;
+    initialValues?: Value[];
+    maxItems?: number;
+    required?: boolean;
+    cursorAt?: Value;
+  }): Promise<Value[] | symbol>;
+
+  export function spinner(opts?: { indicator?: 'dots' | 'timer' }): {
+    start: (msg?: string) => void;
+    stop: (msg?: string, code?: number) => void;
+    message: (msg?: string) => void;
   };
-} 
+}

package/src/ui/format.ts

@@ -0,0 +1,33 @@
+import { COLORS } from './theme';
+
+const TYPE_COLORS: Record<string, string> = {
+  feat: COLORS.success,
+  fix: COLORS.error,
+  docs: COLORS.info,
+  style: COLORS.info,
+  refactor: COLORS.warning,
+  perf: COLORS.warning,
+  test: COLORS.info,
+  chore: COLORS.dim,
+  ci: COLORS.dim,
+  build: COLORS.dim,
+};
+
+/**
+ * Adiciona cor ANSI ao tipo de commit no header (feat, fix, docs, etc.).
+ * Preserva o restante da mensagem sem alteração.
+ */
+export function formatCommitPreview(message: string): string {
+  const lines = message.split('\n');
+  const header = lines[0];
+
+  const typeMatch = header.match(/^(\w+)(\([^)]+\))?:/);
+  if (typeMatch) {
+    const type = typeMatch[1];
+    const color = TYPE_COLORS[type] ?? COLORS.reset;
+    const coloredHeader = header.replace(type, `${color}${type}${COLORS.reset}`);
+    return [coloredHeader, ...lines.slice(1)].join('\n');
+  }
+
+  return message;
+}

package/src/ui/index.ts

@@ -62,21 +62,25 @@ export async function showCommitPreview(
 }
 
 /**
- * Permite edição da mensagem de commit
+ * Permite edição da mensagem de commit com contador de caracteres opcional.
+ * @param maxLength - limite de caracteres para o header (primeira linha)
  */
 export async function editCommitMessage(
-  originalMessage: string
+  originalMessage: string,
+  maxLength?: number
 ): Promise<UIAction> {
+  const limit = maxLength ?? 72;
   const editedMessage = await text({
-    message: 'Edite a mensagem do commit:',
+    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)';
+      const headerLength = value.split('\n')[0].length;
+      if (headerLength > limit) {
+        return `Header muito longo: ${headerLength}/${limit} caracteres`;
       }
     },
   });

package/src/ui/smart-split.ts

@@ -1,5 +1,5 @@
 import { select, confirm, log, note, isCancel } from '@clack/prompts';
-import type { FileGroup } from '../core/smart-split';
+import type { FileGroup } from '../pipeline/split';
 
 export interface SmartSplitAction {
   action: 'proceed' | 'manual' | 'cancel';

package/src/ui/spinner.ts

@@ -0,0 +1,23 @@
+import { spinner } from '@clack/prompts';
+
+/**
+ * Envolve uma chamada assíncrona com spinner animado.
+ * Exibe tempo estimado opcional e ícone de sucesso/erro ao finalizar.
+ */
+export async function withSpinner<T>(
+  message: string,
+  fn: () => Promise<T>,
+  estimatedTime?: number
+): Promise<T> {
+  const s = spinner();
+  s.start(estimatedTime ? `${message} (~${estimatedTime}s)` : message);
+
+  try {
+    const result = await fn();
+    s.stop(`${message} ✅`);
+    return result;
+  } catch (error) {
+    s.stop(`${message} ❌`);
+    throw error;
+  }
+}

package/src/ui/theme.ts

@@ -0,0 +1,17 @@
+export const COLORS = {
+  success: '\x1b[32m',
+  warning: '\x1b[33m',
+  error: '\x1b[31m',
+  info: '\x1b[36m',
+  dim: '\x1b[2m',
+  reset: '\x1b[0m',
+};
+
+export const ICONS = {
+  success: '✅',
+  warning: '⚠️',
+  error: '❌',
+  info: 'ℹ️',
+  rocket: '🚀',
+  wizard: '🧙',
+};

package/src/utils/args.ts

@@ -7,6 +7,8 @@ export interface CLIArgs {
   dryRun: boolean;
   help: boolean;
   version: boolean;
+  validate: boolean;
+  initCommitlint: boolean;
 }
 
 export function parseArgs(args: string[]): CLIArgs {
@@ -19,6 +21,8 @@ export function parseArgs(args: string[]): CLIArgs {
     dryRun: args.includes('--dry-run') || args.includes('-n'),
     help: args.includes('--help') || args.includes('-h'),
     version: args.includes('--version') || args.includes('-v'),
+    validate: args.includes('--validate'),
+    initCommitlint: args.includes('--init-commitlint'),
   };
 }
 
@@ -30,14 +34,16 @@ 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
+  -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
+  --validate             Habilitar validação com commitlint
+  --init-commitlint      Criar configuração padrão do commitlint
+  -h, --help             Mostrar esta ajuda
+  -v, --version          Mostrar versão
 
 EXAMPLES:
   commit-wizard                    # Modo interativo padrão
@@ -46,6 +52,8 @@ EXAMPLES:
   commit-wizard --smart-split      # Smart split com IA
   commit-wizard --dry-run          # Apenas visualizar mensagem
   commit-wizard --auto             # Modo totalmente automático
+  commit-wizard --validate         # Habilitar validação com commitlint
+  commit-wizard --init-commitlint  # Criar configuração padrão do commitlint
 
 Para mais informações, visite: https://github.com/user/commit-wizard
 `);

package/src/utils/hash.ts

@@ -0,0 +1,9 @@
+import { createHash } from 'crypto';
+
+/**
+ * Gera um hash SHA-256 hexadecimal de uma string.
+ * Usado principalmente para gerar chaves de cache a partir de diffs do git.
+ */
+export function hashString(content: string): string {
+  return createHash('sha256').update(content).digest('hex');
+}

package/src/utils/version.ts

@@ -1,19 +1,24 @@
 import { readFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
 /**
  * Lê a versão do package.json dinamicamente
  */
 export function getVersion(): string {
   try {
+    // Resolver __dirname de forma compatível com ESM e CJS
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+
     // Tentar diferentes caminhos para encontrar o package.json
     const possiblePaths = [
-      // Caminho relativo ao arquivo atual (para desenvolvimento)
-      join(process.cwd(), 'package.json'),
-      // Caminho relativo ao binário compilado (para produção)
-      join(process.cwd(), '..', 'package.json'),
-      // Caminho absoluto baseado no __dirname
+      // Caminho absoluto baseado no __dirname (prioridade máxima - para instalação global)
+      join(__dirname, '..', 'package.json'),
+      // Fallback para estrutura de desenvolvimento/build alternativa
       join(__dirname, '..', '..', 'package.json'),
+      // Último recurso: diretório atual
+      join(process.cwd(), 'package.json'),
     ];
 
     for (const packagePath of possiblePaths) {