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

package/src/commitlint/index.ts

@@ -0,0 +1,253 @@
+import { existsSync, writeFileSync, readFileSync } from 'fs';
+import { join, extname, basename } from 'path';
+import { spawnSync } from 'child_process';
+
+export interface CommitlintResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+const COMMITLINT_CONFIG_FILES = [
+  'commitlint.config.js',
+  'commitlint.config.ts',
+  'commitlint.config.mjs',
+  'commitlint.config.cjs',
+  '.commitlintrc',
+  '.commitlintrc.js',
+  '.commitlintrc.json',
+  '.commitlintrc.yml',
+  '.commitlintrc.yaml',
+];
+
+export interface CommitlintRules {
+  typeEnum?: string[];
+  headerMaxLength?: number;
+  subjectCase?: { severity: number; condition: string; cases: string[] };
+  subjectFullStop?: { severity: number; condition: string; value: string };
+  bodyLeadingBlank?: boolean;
+  scopeEnum?: string[];
+}
+
+function extractRulesFromConfig(config: unknown): CommitlintRules {
+  const rules: CommitlintRules = {};
+  const rawRules =
+    (config as { rules?: Record<string, unknown[]> })?.rules ?? {};
+
+  const typeEnumRule = rawRules['type-enum'];
+  if (Array.isArray(typeEnumRule) && Array.isArray(typeEnumRule[2])) {
+    rules.typeEnum = typeEnumRule[2] as string[];
+  }
+
+  const headerMaxLengthRule = rawRules['header-max-length'];
+  if (
+    Array.isArray(headerMaxLengthRule) &&
+    typeof headerMaxLengthRule[2] === 'number'
+  ) {
+    rules.headerMaxLength = headerMaxLengthRule[2];
+  }
+
+  const subjectCaseRule = rawRules['subject-case'];
+  if (Array.isArray(subjectCaseRule)) {
+    const [severity, condition, cases] = subjectCaseRule;
+    if (Array.isArray(cases)) {
+      rules.subjectCase = {
+        severity: severity as number,
+        condition: condition as string,
+        cases: cases as string[],
+      };
+    } else if (typeof cases === 'string') {
+      rules.subjectCase = {
+        severity: severity as number,
+        condition: condition as string,
+        cases: [cases],
+      };
+    }
+  }
+
+  const subjectFullStopRule = rawRules['subject-full-stop'];
+  if (Array.isArray(subjectFullStopRule)) {
+    const [severity, condition, value] = subjectFullStopRule;
+    rules.subjectFullStop = {
+      severity: severity as number,
+      condition: condition as string,
+      value: (value as string) ?? '.',
+    };
+  }
+
+  const bodyLeadingBlankRule = rawRules['body-leading-blank'];
+  if (Array.isArray(bodyLeadingBlankRule)) {
+    rules.bodyLeadingBlank = bodyLeadingBlankRule[1] === 'always';
+  }
+
+  const scopeEnumRule = rawRules['scope-enum'];
+  if (Array.isArray(scopeEnumRule) && Array.isArray(scopeEnumRule[2])) {
+    rules.scopeEnum = scopeEnumRule[2] as string[];
+  }
+
+  return rules;
+}
+
+/**
+ * Reads and parses a commitlint config file, returning the extracted rules.
+ * Returns null if the file cannot be parsed or the format is unsupported.
+ */
+export function parseCommitlintRules(configPath: string): CommitlintRules | null {
+  try {
+    const ext = extname(configPath).toLowerCase();
+    const base = basename(configPath);
+
+    // JSON format: .commitlintrc.json or .commitlintrc (extensionless, try JSON)
+    if (ext === '.json' || (ext === '' && base === '.commitlintrc')) {
+      try {
+        const content = readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content) as unknown;
+        return extractRulesFromConfig(config);
+      } catch {
+        return null;
+      }
+    }
+
+    // JS / MJS / CJS: use a Node.js subprocess to evaluate the config
+    if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+      // Try ESM dynamic import first (handles export default)
+      const esmScript = [
+        "import { pathToFileURL } from 'url';",
+        `const mod = await import(pathToFileURL(${JSON.stringify(configPath)}).href);`,
+        'const cfg = mod.default ?? mod;',
+        'process.stdout.write(JSON.stringify(cfg));',
+      ].join('\n');
+
+      const esmResult = spawnSync(process.execPath, ['--input-type=module'], {
+        input: esmScript,
+        encoding: 'utf-8',
+        timeout: 5000,
+      });
+
+      if (esmResult.status === 0 && esmResult.stdout) {
+        try {
+          const config = JSON.parse(esmResult.stdout) as unknown;
+          return extractRulesFromConfig(config);
+        } catch {
+          // JSON parse error – fall through to CJS
+        }
+      }
+
+      // Fallback: try CommonJS require
+      const cjsScript = [
+        'try {',
+        `  const c = require(${JSON.stringify(configPath)});`,
+        '  process.stdout.write(JSON.stringify(c.default ?? c));',
+        '} catch (e) {',
+        '  process.exit(1);',
+        '}',
+      ].join('\n');
+      const cjsResult = spawnSync(process.execPath, ['-e', cjsScript], {
+        encoding: 'utf-8',
+        timeout: 5000,
+      });
+
+      if (cjsResult.status === 0 && cjsResult.stdout) {
+        try {
+          const config = JSON.parse(cjsResult.stdout) as unknown;
+          return extractRulesFromConfig(config);
+        } catch {
+          // JSON parse error
+        }
+      }
+    }
+
+    // Unsupported format (e.g. YAML, TypeScript): return null gracefully
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function findCommitlintConfig(cwd?: string): string | null {
+  const dir = cwd || process.cwd();
+  for (const file of COMMITLINT_CONFIG_FILES) {
+    const fullPath = join(dir, file);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+export function isCommitlintInstalled(cwd?: string): boolean {
+  const dir = cwd || process.cwd();
+  const binPath = join(dir, 'node_modules', '.bin', 'commitlint');
+  return existsSync(binPath);
+}
+
+export function validateCommitMessage(
+  message: string,
+  cwd?: string
+): CommitlintResult {
+  const dir = cwd || process.cwd();
+  const binPath = join(dir, 'node_modules', '.bin', 'commitlint');
+
+  const result = spawnSync(binPath, [], {
+    input: message,
+    encoding: 'utf-8',
+    cwd: dir,
+  });
+
+  if (result.status === 0) {
+    return { valid: true, errors: [], warnings: [] };
+  }
+
+  const output = (result.stdout || '') + (result.stderr || '');
+  const lines = output.split('\n');
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith('✖') || trimmed.includes('[error]')) {
+      errors.push(trimmed);
+    } else if (trimmed.startsWith('⚠') || trimmed.includes('[warning]')) {
+      warnings.push(trimmed);
+    }
+  }
+
+  // If we couldn't parse individual errors, extract meaningful lines only
+  // (skip stack trace noise: file paths, `at ...` frames, `throw err;`, etc.)
+  if (errors.length === 0 && result.status !== 0) {
+    const rawErrors = lines
+      .map((l) => l.trim())
+      .filter((l) => {
+        if (!l.length) return false;
+        if (l.startsWith('⧗') || l.startsWith('✔')) return false;
+        // Skip Node.js stack trace lines
+        if (l.startsWith('at ')) return false;
+        if (l.startsWith('file:///') || l.match(/^[^:]+\.(?:js|ts|mjs|cjs):\d+$/)) return false;
+        if (l === '^' || l === 'throw err;') return false;
+        if (l.startsWith('Node.js v')) return false;
+        return true;
+      });
+    errors.push(...rawErrors);
+  }
+
+  return { valid: false, errors, warnings };
+}
+
+export function initCommitlintConfig(cwd?: string): void {
+  const dir = cwd || process.cwd();
+  const configPath = join(dir, 'commitlint.config.js');
+
+  if (existsSync(configPath)) {
+    throw new Error(
+      'commitlint.config.js já existe neste diretório. Remova-o antes de continuar.'
+    );
+  }
+
+  const content = `export default {
+  extends: ['@commitlint/config-conventional'],
+};
+`;
+
+  writeFileSync(configPath, content, 'utf-8');
+}

package/src/config/index.ts

@@ -5,7 +5,10 @@ import { join } from 'path';
 
 // Removido: dotenv.config();
 
+export type ProviderType = 'openai';
+
 export interface Config {
+  provider: ProviderType;
   openai: {
     model: string;
     maxTokens: number;
@@ -30,9 +33,13 @@ export interface Config {
     ttl: number; // Time to live em minutos
     maxSize: number; // Número máximo de entradas
   };
+  commitlint: {
+    enabled: boolean;
+  };
 }
 
 const DEFAULT_CONFIG: Config = {
+  provider: 'openai',
   openai: {
     model: 'gpt-4o',
     maxTokens: 150,
@@ -56,10 +63,14 @@ const DEFAULT_CONFIG: Config = {
     ttl: 60, // 1 hora
     maxSize: 100,
   },
+  commitlint: {
+    enabled: true,
+  },
 };
 
 // Adicionar interface para userConfig
 interface UserConfig {
+  provider?: ProviderType;
   openai?: Partial<Config['openai']>;
   language?: string;
   commitStyle?: Config['commitStyle'];
@@ -68,6 +79,7 @@ interface UserConfig {
   dryRun?: boolean;
   smartSplit?: Partial<Config['smartSplit']>;
   cache?: Partial<Config['cache']>;
+  commitlint?: Partial<Config['commitlint']>;
 }
 
 export function loadConfig(configPath?: string): Config {
@@ -142,12 +154,25 @@ function mergeConfig(defaultConfig: Config, userConfig: UserConfig): Config {
       ...defaultConfig.cache,
       ...userConfig.cache,
     },
+    commitlint: {
+      ...defaultConfig.commitlint,
+      ...userConfig.commitlint,
+    },
   };
 }
 
+const SUPPORTED_PROVIDERS: ProviderType[] = ['openai'];
+
 export function validateConfig(config: Config): string[] {
   const errors: string[] = [];
 
+  // Validação de provider
+  if (!SUPPORTED_PROVIDERS.includes(config.provider)) {
+    errors.push(
+      `provider deve ser um dos suportados: ${SUPPORTED_PROVIDERS.join(', ')}`
+    );
+  }
+
   // Validação básica
   if (!config.openai.apiKey) {
     errors.push('OPENAI_API_KEY não encontrada nas variáveis de ambiente');

package/src/core/cache.ts

@@ -1,210 +1,14 @@
-import type { Config } from '../config/index';
-import type { FileGroup } from './smart-split';
-import crypto from 'crypto';
-
-export interface CacheEntry {
-  groups: FileGroup[];
-  timestamp: number;
-  hash: string;
-}
-
-export interface CacheResult {
-  hit: boolean;
-  groups?: FileGroup[];
-}
-
-class AnalysisCache {
-  private cache: Map<string, CacheEntry> = new Map();
-  private config: Config;
-
-  constructor(config: Config) {
-    this.config = config;
-  }
-
-  /**
-   * Gera hash do contexto para identificar análises similares
-   */
-  private generateHash(files: string[], overallDiff: string): string {
-    const context = {
-      files: files.sort(), // Ordenar para consistência
-      diff: overallDiff.substring(0, 1000), // Limitar tamanho do diff
-      model: this.config.openai.model,
-      temperature: this.config.openai.temperature,
-    };
-
-    return crypto
-      .createHash('md5')
-      .update(JSON.stringify(context))
-      .digest('hex');
-  }
-
-  /**
-   * Verifica se há cache válido para o contexto
-   */
-  get(files: string[], overallDiff: string): CacheResult {
-    if (!this.config.cache.enabled) {
-      return { hit: false };
-    }
-
-    const hash = this.generateHash(files, overallDiff);
-    const entry = this.cache.get(hash);
-
-    if (!entry) {
-      return { hit: false };
-    }
-
-    // Verificar se o cache expirou
-    const now = Date.now();
-    const ttlMs = this.config.cache.ttl * 60 * 1000; // Converter minutos para ms
-
-    if (now - entry.timestamp > ttlMs) {
-      this.cache.delete(hash);
-      return { hit: false };
-    }
-
-    return { hit: true, groups: entry.groups };
-  }
-
-  /**
-   * Armazena resultado no cache
-   */
-  set(files: string[], overallDiff: string, groups: FileGroup[]): void {
-    if (!this.config.cache.enabled) {
-      return;
-    }
-
-    // Limpar cache se exceder tamanho máximo
-    if (this.cache.size >= this.config.cache.maxSize) {
-      this.cleanup();
-    }
-
-    // Se ainda exceder após cleanup, não adicionar
-    if (this.cache.size >= this.config.cache.maxSize) {
-      return;
-    }
-
-    const hash = this.generateHash(files, overallDiff);
-    const entry: CacheEntry = {
-      groups,
-      timestamp: Date.now(),
-      hash,
-    };
-
-    this.cache.set(hash, entry);
-  }
-
-  /**
-   * Limpa cache expirado e reduz tamanho se necessário
-   */
-  private cleanup(): void {
-    const now = Date.now();
-    const ttlMs = this.config.cache.ttl * 60 * 1000;
-
-    // Remover entradas expiradas
-    for (const [hash, entry] of this.cache.entries()) {
-      if (now - entry.timestamp > ttlMs) {
-        this.cache.delete(hash);
-      }
-    }
-
-    // Se ainda exceder tamanho máximo, remover entradas mais antigas
-    if (this.cache.size >= this.config.cache.maxSize) {
-      const entries = Array.from(this.cache.entries()).sort(
-        (a, b) => a[1].timestamp - b[1].timestamp
-      );
-
-      // Remover 50% das entradas mais antigas para garantir espaço
-      const toRemove = entries.slice(
-        0,
-        Math.ceil(this.config.cache.maxSize * 0.5)
-      );
-      for (const [hash] of toRemove) {
-        this.cache.delete(hash);
-      }
-    }
-  }
-
-  /**
-   * Limpa todo o cache
-   */
-  clear(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Retorna estatísticas do cache
-   */
-  getStats(): { size: number; maxSize: number; enabled: boolean } {
-    return {
-      size: this.cache.size,
-      maxSize: this.config.cache.maxSize,
-      enabled: this.config.cache.enabled,
-    };
-  }
-}
-
-// Instância global do cache
-let globalCache: AnalysisCache | null = null;
-
 /**
- * Inicializa o cache global
- */
-export function initializeCache(config: Config): void {
-  globalCache = new AnalysisCache(config);
-}
-
-/**
- * Obtém o cache global
- */
-export function getCache(): AnalysisCache | null {
-  return globalCache;
-}
-
-/**
- * Verifica se há cache válido para o contexto
- */
-export function getCachedAnalysis(
-  files: string[],
-  overallDiff: string
-): CacheResult {
-  const cache = getCache();
-  return cache ? cache.get(files, overallDiff) : { hit: false };
-}
-
-/**
- * Armazena resultado no cache
- */
-export function setCachedAnalysis(
-  files: string[],
-  overallDiff: string,
-  groups: FileGroup[]
-): void {
-  const cache = getCache();
-  if (cache) {
-    cache.set(files, overallDiff, groups);
-  }
-}
-
-/**
- * Retorna estatísticas do cache
- */
-export function getCacheStats(): {
-  size: number;
-  maxSize: number;
-  enabled: boolean;
-} | null {
-  const cache = getCache();
-  return cache ? cache.getStats() : null;
-}
-
-/**
- * Limpa o cache global
- */
-export function clearCache(): void {
-  const cache = getCache();
-  if (cache) {
-    cache.clear();
-  }
-  // Resetar a instância global
-  globalCache = null;
-}
+ * Re-exports from src/cache/analysis.ts for backwards compatibility.
+ * This file is kept as a shim during the v3 migration.
+ * Consumers should migrate to importing directly from ../cache/analysis.
+ */
+export type { CacheEntry, CacheResult } from '../cache/analysis';
+export {
+  initializeCache,
+  getCache,
+  getCachedAnalysis,
+  setCachedAnalysis,
+  getCacheStats,
+  clearCache,
+} from '../cache/analysis';