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

package/src/pipeline/types.ts

@@ -0,0 +1,26 @@
+import type { Config } from '../config/index';
+import type { CommitlintRules } from '../commitlint/index';
+import type { CommitSuggestion } from '../providers/openai';
+
+export interface EnforceResult {
+  message: string;
+  enforced: boolean;
+  violations: string[];
+}
+
+export interface GenerateOptions {
+  diff: string;
+  files: string[];
+  config: Config;
+  rules?: CommitlintRules | null;
+  maxRetries?: number;
+}
+
+export interface GenerateResult {
+  success: boolean;
+  message?: string;
+  type?: CommitSuggestion['type'];
+  enforced: boolean;
+  retries: number;
+  error?: string;
+}

package/src/prompt/builder.ts

@@ -0,0 +1,61 @@
+import type { Config } from '../config/index';
+import type { CommitlintRules } from '../commitlint/index';
+import type { PromptParts } from './types';
+import { getStyleInstructions, getStyleInstructionsFromRules } from './templates';
+import { buildSystemMessage } from './system';
+
+/**
+ * Builds the user prompt for the AI based on diff and configuration.
+ *
+ * Note: diff filtering (smartFilterDiff) is handled by the caller before
+ * passing the diff in, or by the provider layer.
+ */
+export function buildPrompt(
+  diff: string,
+  config: Config,
+  filenames: string[],
+  commitlintRules?: CommitlintRules | null
+): string {
+  const language = config.language === 'pt' ? 'português' : 'english';
+  const styleInstructions =
+    commitlintRules != null
+      ? getStyleInstructionsFromRules(
+          config.commitStyle,
+          config.language,
+          commitlintRules
+        )
+      : getStyleInstructions(config.commitStyle, config.language);
+
+  const fileList =
+    filenames.length > 10
+      ? `${filenames.length} arquivos: ${filenames.slice(0, 5).join(', ')}...`
+      : filenames.join(', ');
+
+  return `Gere mensagem de commit em ${language} (${config.commitStyle}).
+
+Arquivos: ${fileList}
+
+${styleInstructions}
+
+Diff:
+\`\`\`
+${diff}
+\`\`\`
+
+Mensagem:`;
+}
+
+/**
+ * Builds both user and system prompt parts in a single call.
+ */
+export function buildPromptParts(
+  diff: string,
+  config: Config,
+  filenames: string[],
+  commitlintRules?: CommitlintRules | null
+): PromptParts {
+  return {
+    user: buildPrompt(diff, config, filenames, commitlintRules),
+    system: buildSystemMessage(config, commitlintRules),
+  };
+}

package/src/prompt/system.ts

@@ -0,0 +1,69 @@
+import type { Config } from '../config/index';
+import type { CommitlintRules } from '../commitlint/index';
+import { DEFAULT_COMMIT_TYPES } from './templates';
+
+/**
+ * Builds a system-role message that strictly enforces commitlint rules.
+ * System messages carry higher precedence than user messages, making the AI
+ * more reliably follow hard constraints like header-max-length.
+ *
+ * Returns null when no commitlint rules are provided or no rules apply.
+ */
+export function buildSystemMessage(
+  config: Config,
+  commitlintRules?: CommitlintRules | null
+): string | null {
+  if (!commitlintRules) return null;
+
+  const isPt = config.language === 'pt';
+  const rules: string[] = [];
+
+  if (config.commitStyle === 'conventional') {
+    const types = commitlintRules.typeEnum?.join(', ') ?? DEFAULT_COMMIT_TYPES;
+    rules.push(isPt ? `- Formato: tipo(escopo): descrição` : `- Format: type(scope): description`);
+    rules.push(isPt ? `- Tipos permitidos: ${types}` : `- Allowed types: ${types}`);
+  }
+
+  if (commitlintRules.headerMaxLength != null) {
+    const maxLen = commitlintRules.headerMaxLength;
+    rules.push(
+      isPt
+        ? `- CRÍTICO: o header (primeira linha) NÃO PODE exceder ${maxLen} caracteres. Conte os caracteres antes de responder.`
+        : `- CRITICAL: the header (first line) MUST NOT exceed ${maxLen} characters. Count characters before responding.`
+    );
+  }
+
+  if (commitlintRules.scopeEnum && commitlintRules.scopeEnum.length > 0) {
+    rules.push(
+      isPt
+        ? `- Escopos permitidos: ${commitlintRules.scopeEnum.join(', ')}`
+        : `- Allowed scopes: ${commitlintRules.scopeEnum.join(', ')}`
+    );
+  }
+
+  if (commitlintRules.subjectCase) {
+    const { condition, cases } = commitlintRules.subjectCase;
+    const caseList = cases.join(', ');
+    if (condition === 'never') {
+      rules.push(isPt ? `- Subject nunca em: ${caseList}` : `- Subject must never be: ${caseList}`);
+    } else if (condition === 'always') {
+      rules.push(isPt ? `- Subject deve estar em: ${caseList}` : `- Subject must be in: ${caseList}`);
+    }
+  }
+
+  if (commitlintRules.subjectFullStop) {
+    const { condition, value } = commitlintRules.subjectFullStop;
+    const char = value ?? '.';
+    if (condition === 'never') {
+      rules.push(isPt ? `- Não termine o subject com "${char}"` : `- Do not end subject with "${char}"`);
+    }
+  }
+
+  if (rules.length === 0) return null;
+
+  const intro = isPt
+    ? 'Você é um gerador de mensagens de commit. Siga ESTRITAMENTE as seguintes regras do commitlint do projeto. Responda APENAS com a mensagem de commit, sem explicações adicionais.'
+    : 'You are a commit message generator. STRICTLY follow the project commitlint rules below. Respond with ONLY the commit message, no additional explanation.';
+
+  return `${intro}\n\n${rules.join('\n')}`;
+}

package/src/prompt/templates.ts

@@ -0,0 +1,172 @@
+import type { CommitlintRules } from '../commitlint/index';
+
+export const DEFAULT_COMMIT_TYPES = 'feat, fix, docs, style, refactor, test, chore, build, ci';
+
+/**
+ * Builds style instructions dynamically from parsed commitlint rules.
+ * Falls back to sensible defaults for any rules not explicitly configured.
+ */
+export function getStyleInstructionsFromRules(
+  style: string,
+  language: string,
+  rules: CommitlintRules
+): string {
+  const isPt = language === 'pt';
+  const lines: string[] = [];
+
+  if (style === 'conventional') {
+    lines.push(
+      isPt
+        ? '- Use formato: tipo(escopo): descrição'
+        : '- Use format: type(scope): description'
+    );
+
+    const types = rules.typeEnum?.join(', ') ?? DEFAULT_COMMIT_TYPES;
+    lines.push(
+      isPt ? `- Tipos válidos: ${types}` : `- Valid types: ${types}`
+    );
+
+    const maxLen = rules.headerMaxLength ?? 72;
+    lines.push(
+      isPt
+        ? `- OBRIGATÓRIO: primeira linha deve ter no máximo ${maxLen} caracteres (regra header-max-length do commitlint)`
+        : `- REQUIRED: first line must not exceed ${maxLen} characters (commitlint header-max-length rule)`
+    );
+
+    const exampleType = rules.typeEnum?.[0] ?? 'feat';
+    const examplePt = `${exampleType}(auth): adicionar validação de email`;
+    const exampleEn = `${exampleType}(auth): add email validation`;
+    if (isPt && examplePt.length <= maxLen) {
+      lines.push(`- Exemplo: "${examplePt}"`);
+    } else if (!isPt && exampleEn.length <= maxLen) {
+      lines.push(`- Example: "${exampleEn}"`);
+    }
+
+    if (rules.subjectCase) {
+      const { condition, cases } = rules.subjectCase;
+      const caseList = cases.join(', ');
+      if (condition === 'never') {
+        lines.push(
+          isPt
+            ? `- Subject nunca em: ${caseList}`
+            : `- Subject must never be: ${caseList}`
+        );
+      } else if (condition === 'always') {
+        lines.push(
+          isPt
+            ? `- Subject deve estar em: ${caseList}`
+            : `- Subject must be in: ${caseList}`
+        );
+      }
+    }
+
+    if (rules.subjectFullStop) {
+      const { condition, value } = rules.subjectFullStop;
+      const char = value ?? '.';
+      if (condition === 'never') {
+        lines.push(
+          isPt
+            ? `- Não termine o subject com "${char}"`
+            : `- Do not end subject with "${char}"`
+        );
+      } else if (condition === 'always') {
+        lines.push(
+          isPt
+            ? `- Termine o subject com "${char}"`
+            : `- End subject with "${char}"`
+        );
+      }
+    }
+
+    if (rules.bodyLeadingBlank === true) {
+      lines.push(
+        isPt
+          ? '- Adicione uma linha em branco entre o header e o body'
+          : '- Add a blank line between header and body'
+      );
+    }
+
+    if (rules.scopeEnum && rules.scopeEnum.length > 0) {
+      lines.push(
+        isPt
+          ? `- Escopos permitidos: ${rules.scopeEnum.join(', ')}`
+          : `- Allowed scopes: ${rules.scopeEnum.join(', ')}`
+      );
+    }
+  } else if (style === 'simple') {
+    const maxLen = rules.headerMaxLength ?? 50;
+    if (isPt) {
+      lines.push('- Use formato simples e direto');
+      lines.push('- Comece com verbo no infinitivo');
+      lines.push('- Exemplo: "corrigir validação de formulário"');
+      lines.push(`- Máximo ${maxLen} caracteres`);
+    } else {
+      lines.push('- Use simple and direct format');
+      lines.push('- Start with imperative verb');
+      lines.push('- Example: "fix form validation"');
+      lines.push(`- Maximum ${maxLen} characters`);
+    }
+  } else {
+    // detailed
+    const maxLen = rules.headerMaxLength ?? 72;
+    if (isPt) {
+      lines.push(`- Primeira linha: resumo em até ${maxLen} caracteres`);
+      lines.push('- Se necessário, adicione corpo explicativo');
+      lines.push('- Use presente do indicativo');
+      lines.push('- Seja descritivo mas conciso');
+    } else {
+      lines.push(`- First line: summary under ${maxLen} characters`);
+      lines.push('- Add explanatory body if needed');
+      lines.push('- Use imperative mood');
+      lines.push('- Be descriptive but concise');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Returns style instructions based on commit style and language (no commitlint rules).
+ */
+export function getStyleInstructions(style: string, language: string): string {
+  const instructions = {
+    pt: {
+      conventional: `- Use formato: tipo(escopo): descrição
+- Tipos válidos: ${DEFAULT_COMMIT_TYPES}
+- 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: ${DEFAULT_COMMIT_TYPES}
+- 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
+  );
+}

package/src/prompt/types.ts

@@ -0,0 +1,4 @@
+export interface PromptParts {
+  user: string;
+  system: string | null;
+}

package/src/providers/factory.ts

@@ -0,0 +1,18 @@
+import type { Config } from '../config/index';
+import type { AIProvider } from './types';
+import { OpenAIProvider } from './openai';
+
+/**
+ * Factory que instancia o provider correto baseado em config.provider.
+ * Para adicionar novo provider: implementar AIProvider e adicionar case aqui.
+ */
+export function createProvider(config: Config): AIProvider {
+  switch (config.provider) {
+    case 'openai':
+      return new OpenAIProvider(config);
+    default: {
+      const _exhaustive: never = config.provider;
+      throw new Error(`Provider '${_exhaustive}' não suportado`);
+    }
+  }
+}