@gilbert_oliveira/commit-wizard 1.2.2 → 2.0.1

package/package.json

@@ -1,86 +1,93 @@
 {
   "name": "@gilbert_oliveira/commit-wizard",
-  "version": "1.2.2",
-  "description": "🧙‍♂️ Gerador inteligente de mensagens de commit usando IA",
-  "main": "dist/index.js",
+  "displayName": "Commit Wizard",
+  "publisher": "gilbert-oliveira",
+  "description": "CLI inteligente para gerar mensagens de commit usando OpenAI",
+  "version": "2.0.1",
+  "categories": [
+    "Other",
+    "SCM Providers"
+  ],
+  "main": "dist/commit-wizard.js",
+  "module": "index.ts",
   "type": "module",
   "bin": {
-    "commit-wizard": "dist/index.js"
-  },
-  "publishConfig": {
-    "access": "public"
+    "commit-wizard": "./dist/commit-wizard.js"
   },
   "scripts": {
-    "start": "node dist/index.js",
-    "dev": "tsc --watch",
-    "build": "npm run lint && tsc",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "lint": "eslint src/**/*.ts",
-    "lint:fix": "eslint src/**/*.ts --fix",
-    "format": "prettier --write src/**/*.ts",
-    "format:check": "prettier --check src/**/*.ts",
-    "prepare": "npm run build",
-    "prepack": "npm run build",
-    "clean": "rimraf dist"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gilbert-oliveira/commit-wizard.git"
+    "dev": "bun run bin/commit-wizard.ts",
+    "build": "bun build bin/commit-wizard.ts --outdir=dist --target=bun --minify",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test && node scripts/generate-lcov.js",
+    "test:coverage:report": "c8 --reporter=html --reporter=text --include='src/**/*.ts' --exclude='**/*.test.ts' bun test && open coverage/lcov-report/index.html",
+    "test:coverage:upload": "bun test && node scripts/generate-lcov.js && node scripts/upload-codecov.js",
+    "prepublishOnly": "bun run build && bun test",
+    "start": "bun run bin/commit-wizard.ts",
+    "ci:test": "bun test --reporter=verbose",
+    "ci:build": "bun run build",
+    "ci:lint": "bun run tsc --noEmit",
+    "ci:security": "bun audit",
+    "ci:integration": "bun test tests/integration.test.ts tests/smart-split.test.ts",
+    "release:patch": "./scripts/release.sh patch",
+    "release:minor": "./scripts/release.sh minor",
+    "release:major": "./scripts/release.sh major",
+    "type-check": "bun run tsc --noEmit",
+    "lint": "bun run eslint --fix",
+    "format": "bun run prettier --write ."
   },
   "keywords": [
-    "commit",
-    "wizard",
-    "conventional",
-    "commits",
-    "conventional-commits",
-    "commitizen",
-    "commitlint",
-    "husky",
-    "lint-staged",
     "git",
+    "commit",
     "ai",
     "openai",
-    "gpt"
+    "cli",
+    "automation",
+    "conventional-commits"
   ],
-  "author": "Gilbert Oliveira <contato@gilbert.dev.br>",
-  "engines": {
-    "node": ">=18.0.0"
-  },
+  "author": "Gilbert <contato@gilbert.dev.br>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gilbert-oliveira/commit-wizard.git"
+  },
   "bugs": {
     "url": "https://github.com/gilbert-oliveira/commit-wizard/issues"
   },
   "homepage": "https://github.com/gilbert-oliveira/commit-wizard#readme",
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "dist/",
+    "README.md",
+    "LICENSE",
+    ".commit-wizardrc"
+  ],
   "dependencies": {
-    "@types/node": "^22.14.1",
-    "chalk": "^5.3.0",
-    "cli-progress": "^3.12.0",
-    "gpt-tokenizer": "^1.0.0",
-    "inquirer": "^12.5.2",
-    "ora": "^8.2.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3"
+    "@clack/prompts": "^0.11.0",
+    "clipboardy": "^4.0.0",
+    "simple-git": "^3.25.0",
+    "dotenv": "^17.2.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.0.0",
-    "@types/cli-progress": "^3.11.6",
-    "@types/inquirer": "^9.0.7",
-    "@types/jest": "^29.5.12",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "@typescript-eslint/parser": "^8.0.0",
-    "eslint": "^9.0.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "jest": "^29.7.0",
-    "prettier": "^3.2.5",
-    "rimraf": "^5.0.5",
-    "ts-jest": "^29.1.2"
+    "@types/bun": "latest",
+    "@types/node": "^24.0.13",
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "c8": "^10.1.3",
+    "chalk": "^5.3.0",
+    "eslint": "^9.30.1",
+    "prettier": "^3.6.2"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ]
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "preferGlobal": true,
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/config/index.ts

@@ -0,0 +1,237 @@
+import { existsSync, readFileSync } from 'fs';
+import fs from 'fs';
+import { join } from 'path';
+import dotenv from 'dotenv';
+
+// Carregar variáveis de ambiente
+dotenv.config();
+
+export interface Config {
+  openai: {
+    model: string;
+    maxTokens: number;
+    temperature: number;
+    apiKey?: string;
+    timeout: number;
+    retries: number;
+  };
+  language: string;
+  commitStyle: 'conventional' | 'simple' | 'detailed';
+  autoCommit: boolean;
+  splitCommits: boolean;
+  dryRun: boolean;
+  smartSplit: {
+    enabled: boolean;
+    minGroupSize: number;
+    maxGroups: number;
+    confidenceThreshold: number;
+  };
+  cache: {
+    enabled: boolean;
+    ttl: number; // Time to live em minutos
+    maxSize: number; // Número máximo de entradas
+  };
+}
+
+const DEFAULT_CONFIG: Config = {
+  openai: {
+    model: 'gpt-4o',
+    maxTokens: 150,
+    temperature: 0.7,
+    timeout: 30000, // 30 segundos
+    retries: 2,
+  },
+  language: 'pt',
+  commitStyle: 'conventional',
+  autoCommit: false,
+  splitCommits: false,
+  dryRun: false,
+  smartSplit: {
+    enabled: true,
+    minGroupSize: 1,
+    maxGroups: 5,
+    confidenceThreshold: 0.7,
+  },
+  cache: {
+    enabled: true,
+    ttl: 60, // 1 hora
+    maxSize: 100,
+  },
+};
+
+// Adicionar interface para userConfig
+interface UserConfig {
+  openai?: Partial<Config['openai']>;
+  language?: string;
+  commitStyle?: Config['commitStyle'];
+  autoCommit?: boolean;
+  splitCommits?: boolean;
+  dryRun?: boolean;
+  smartSplit?: Partial<Config['smartSplit']>;
+  cache?: Partial<Config['cache']>;
+}
+
+export function loadConfig(configPath?: string): Config {
+  // Usar um caminho mais seguro para ambientes CI
+  let defaultConfigPath: string;
+  try {
+    defaultConfigPath = join(process.cwd(), '.commit-wizardrc');
+  } catch {
+    // Fallback para ambientes onde process.cwd() falha
+    defaultConfigPath = '/tmp/.commit-wizardrc';
+  }
+
+  const globalConfigPath = join(
+    process.env.HOME || process.env.USERPROFILE || '/tmp',
+    '.commit-wizardrc'
+  );
+
+  let config = { ...DEFAULT_CONFIG };
+
+  // Carregar configuração global primeiro
+  try {
+    if (existsSync(globalConfigPath)) {
+      const fileContent = readFileSync(globalConfigPath, 'utf-8');
+      const globalConfig = JSON.parse(fileContent);
+      config = mergeConfig(config, globalConfig);
+    }
+  } catch {
+    console.warn(`⚠️  Erro ao ler configuração global: Erro desconhecido`);
+  }
+
+  // Carregar configuração local (sobrescreve a global)
+  const actualConfigPath = configPath || defaultConfigPath;
+  try {
+    if (existsSync(actualConfigPath)) {
+      const fileContent = readFileSync(actualConfigPath, 'utf-8');
+      const userConfig = JSON.parse(fileContent);
+      config = mergeConfig(config, userConfig);
+    }
+  } catch {
+    console.warn(`⚠️  Erro ao ler .commit-wizardrc: Erro desconhecido`);
+  }
+
+  // Adicionar chave da OpenAI das variáveis de ambiente
+  config.openai.apiKey = process.env.OPENAI_API_KEY;
+
+  // Aplicar configurações de ambiente
+  if (process.env.COMMIT_WIZARD_DEBUG === 'true') {
+    // config.advanced.enableDebug = true; // Removed advanced options
+    // config.advanced.logLevel = 'debug'; // Removed advanced options
+  }
+
+  if (process.env.COMMIT_WIZARD_DRY_RUN === 'true') {
+    config.dryRun = true;
+  }
+
+  return config;
+}
+
+function mergeConfig(defaultConfig: Config, userConfig: UserConfig): Config {
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    openai: {
+      ...defaultConfig.openai,
+      ...userConfig.openai,
+    },
+    smartSplit: {
+      ...defaultConfig.smartSplit,
+      ...userConfig.smartSplit,
+    },
+    cache: {
+      ...defaultConfig.cache,
+      ...userConfig.cache,
+    },
+  };
+}
+
+export function validateConfig(config: Config): string[] {
+  const errors: string[] = [];
+
+  // Validação básica
+  if (!config.openai.apiKey) {
+    errors.push('OPENAI_API_KEY não encontrada nas variáveis de ambiente');
+  }
+
+  if (config.openai.maxTokens < 10 || config.openai.maxTokens > 4000) {
+    errors.push('maxTokens deve estar entre 10 e 4000');
+  }
+
+  if (config.openai.temperature < 0 || config.openai.temperature > 2) {
+    errors.push('temperature deve estar entre 0 e 2');
+  }
+
+  if (
+    !['pt', 'en', 'es', 'fr', 'de', 'it', 'ja', 'ko', 'zh'].includes(
+      config.language
+    )
+  ) {
+    errors.push(
+      'language deve ser um idioma suportado (pt, en, es, fr, de, it, ja, ko, zh)'
+    );
+  }
+
+  if (!['conventional', 'simple', 'detailed'].includes(config.commitStyle)) {
+    errors.push('commitStyle deve ser conventional, simple ou detailed');
+  }
+
+  // Validação Smart Split
+  if (config.smartSplit.minGroupSize < 1) {
+    errors.push('smartSplit.minGroupSize deve ser pelo menos 1');
+  }
+
+  if (config.smartSplit.maxGroups < 1 || config.smartSplit.maxGroups > 10) {
+    errors.push('smartSplit.maxGroups deve estar entre 1 e 10');
+  }
+
+  if (
+    config.smartSplit.confidenceThreshold < 0 ||
+    config.smartSplit.confidenceThreshold > 1
+  ) {
+    errors.push('smartSplit.confidenceThreshold deve estar entre 0 e 1');
+  }
+
+  // Validação Cache
+  if (config.cache.ttl < 1) {
+    errors.push('cache.ttl deve ser pelo menos 1 minuto');
+  }
+
+  if (config.cache.maxSize < 1) {
+    errors.push('cache.maxSize deve ser pelo menos 1');
+  }
+
+  return errors;
+}
+
+/**
+ * Cria um arquivo de configuração exemplo
+ */
+export function createExampleConfig(path: string = '.commit-wizardrc'): void {
+  const exampleConfig = {
+    language: 'pt',
+    commitStyle: 'conventional',
+    autoCommit: false,
+    splitCommits: true,
+    openai: {
+      model: 'gpt-4o',
+      maxTokens: 200,
+      temperature: 0.7,
+      timeout: 30000,
+      retries: 2,
+    },
+    smartSplit: {
+      enabled: true,
+      minGroupSize: 1,
+      maxGroups: 5,
+      confidenceThreshold: 0.7,
+    },
+    cache: {
+      enabled: true,
+      ttl: 60,
+      maxSize: 100,
+    },
+  };
+
+  fs.writeFileSync(path, JSON.stringify(exampleConfig, null, 2));
+}

package/src/core/cache.ts

@@ -0,0 +1,210 @@
+import type { Config } from '../config/index.ts';
+import type { FileGroup } from './smart-split.ts';
+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;
+}