@misaelabanto/commita 1.0.1

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@misaelabanto/commita",
+  "version": "1.0.1",
+  "description": "AI-powered git auto-commit tool that intelligently groups your changes and generates meaningful commit messages",
+  "module": "index.ts",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "commita": "./index.ts"
+  },
+  "scripts": {
+    "dev": "bun run index.ts",
+    "build": "bun build index.ts --outdir dist --target bun",
+    "commita": "bun run index.ts"
+  },
+  "author": "Misael Abanto",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/misaelabanto/commita.git"
+  },
+  "homepage": "https://github.com/misaelabanto/commita#readme",
+  "dependencies": {
+    "@ai-sdk/google": "^2.0.28",
+    "@ai-sdk/openai": "^2.0.62",
+    "ai": "^5.0.87",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.7",
+    "minimatch": "^10.0.1",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/minimatch": "^5.1.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/src/ai/ai.service.ts

@@ -0,0 +1,124 @@
+import { CommitTypeAnalyzer } from '@/ai/commit-type-analyzer.ts';
+import { EmojiMapper } from '@/ai/emoji-mapper.ts';
+import type { CommitaConfig } from '@/config/config.types.ts';
+import { PROMPT_TEMPLATES } from '@/config/prompt-templates.ts';
+import { openai, createOpenAI } from '@ai-sdk/openai';
+import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
+import { generateText } from 'ai';
+
+export class AIService {
+  private config: CommitaConfig;
+  private typeAnalyzer: CommitTypeAnalyzer;
+  private emojiMapper: EmojiMapper;
+
+  constructor(config: CommitaConfig) {
+    this.config = config;
+    this.typeAnalyzer = new CommitTypeAnalyzer();
+    this.emojiMapper = new EmojiMapper();
+
+    this.validateConfig();
+  }
+
+  private validateConfig(): void {
+    if (this.config.provider === 'openai' && !this.config.openaiApiKey) {
+      throw new Error('OpenAI API key is required. Set it in .commita file or OPENAI_API_KEY env var.');
+    }
+
+    if (this.config.provider === 'gemini' && !this.config.geminiApiKey) {
+      throw new Error('Gemini API key is required. Set it in .commita file or GEMINI_API_KEY env var.');
+    }
+  }
+
+  async generateCommitMessage(diff: string, files: string[], scope: string): Promise<string> {
+    const prompt = this.buildPrompt(diff);
+
+    try {
+      const provider = this.getProvider();
+      const model = provider(this.config.model);
+
+      const { text } = await generateText({
+        model,
+        system: 'You are a helpful assistant that generates concise git commit messages. The response should be plain text without any markdown formatting.',
+        prompt,
+        temperature: 0.7,
+        maxTokens: 500,
+      });
+
+      let message = text.replace(/^```\n*((.*\n*)+)```$/, '$1').trim() || '';
+
+      if (!message) {
+        const commitType = this.typeAnalyzer.analyzeFromDiff(diff, files);
+        message = `${commitType}(${scope}): update files`;
+      }
+
+      if (this.config.commitStyle === 'emoji') {
+        message = this.emojiMapper.replaceTypeWithEmoji(message);
+      }
+
+      return message;
+    } catch (error) {
+      console.error('Error generating commit message:', error);
+      const commitType = this.typeAnalyzer.analyzeFromDiff(diff, files);
+      let fallbackMessage = `${commitType}(${scope}): update files`;
+
+      if (this.config.commitStyle === 'emoji') {
+        fallbackMessage = this.emojiMapper.replaceTypeWithEmoji(fallbackMessage);
+      }
+
+      return fallbackMessage;
+    }
+  }
+
+  private getProvider() {
+    if (this.config.provider === 'gemini') {
+      if (this.config.geminiApiKey) {
+        return createGoogleGenerativeAI({
+          apiKey: this.config.geminiApiKey,
+        });
+      }
+      return google;
+    }
+
+    if (this.config.openaiApiKey) {
+      return createOpenAI({
+        apiKey: this.config.openaiApiKey,
+      });
+    }
+
+    return openai;
+  }
+
+  private buildPrompt(diff: string): string {
+    let template: string;
+
+    if (this.config.promptStyle === 'custom') {
+      template = this.config.customPrompt || this.config.promptTemplate || PROMPT_TEMPLATES.default;
+    } else {
+      template = PROMPT_TEMPLATES[this.config.promptStyle];
+    }
+
+    return template.replace('{diff}', this.truncateDiff(diff));
+  }
+
+  private truncateDiff(diff: string, maxLength: number = 8000): string {
+    if (diff.length <= maxLength) {
+      return diff;
+    }
+
+    const lines = diff.split('\n');
+    const truncated: string[] = [];
+    let currentLength = 0;
+
+    for (const line of lines) {
+      if (currentLength + line.length > maxLength) {
+        truncated.push('\n... (diff truncated for brevity) ...');
+        break;
+      }
+      truncated.push(line);
+      currentLength += line.length + 1;
+    }
+
+    return truncated.join('\n');
+  }
+}
+

package/src/ai/commit-type-analyzer.ts

@@ -0,0 +1,103 @@
+export type CommitType = 'feat' | 'fix' | 'refactor' | 'chore' | 'docs' | 'style' | 'test' | 'perf';
+
+export class CommitTypeAnalyzer {
+  analyzeFromDiff(diff: string, files: string[]): CommitType {
+    const lowerDiff = diff.toLowerCase();
+    const filePaths = files.map(f => f.toLowerCase());
+
+    if (this.isTest(filePaths, lowerDiff)) return 'test';
+    if (this.isDocs(filePaths, lowerDiff)) return 'docs';
+    if (this.isChore(filePaths, lowerDiff)) return 'chore';
+    if (this.isStyle(lowerDiff)) return 'style';
+    if (this.isPerf(lowerDiff)) return 'perf';
+    if (this.isFix(lowerDiff)) return 'fix';
+    if (this.isFeat(diff, lowerDiff)) return 'feat';
+
+    return 'refactor';
+  }
+
+  private isTest(files: string[], diff: string): boolean {
+    const testPatterns = ['.test.', '.spec.', '__tests__', '/tests/', '/test/'];
+    return files.some(f => testPatterns.some(p => f.includes(p))) ||
+      diff.includes('test(') || diff.includes('describe(') || diff.includes('it(');
+  }
+
+  private isDocs(files: string[], diff: string): boolean {
+    const docPatterns = ['readme', '.md', 'documentation', '/docs/'];
+    return files.some(f => docPatterns.some(p => f.includes(p)));
+  }
+
+  private isChore(files: string[], diff: string): boolean {
+    const chorePatterns = [
+      'package.json',
+      'package-lock.json',
+      'yarn.lock',
+      'bun.lock',
+      '.gitignore',
+      'tsconfig',
+      'webpack',
+      'vite.config',
+      '.eslint',
+      '.prettier',
+    ];
+    return files.some(f => chorePatterns.some(p => f.includes(p)));
+  }
+
+  private isStyle(diff: string): boolean {
+    const styleKeywords = ['formatting', 'whitespace', 'indent', 'prettier', 'eslint'];
+    const hasStyleKeywords = styleKeywords.some(k => diff.includes(k));
+
+    const hasCodeChanges = diff.includes('function') ||
+      diff.includes('class') ||
+      diff.includes('const') ||
+      diff.includes('import');
+
+    return hasStyleKeywords && !hasCodeChanges;
+  }
+
+  private isPerf(diff: string): boolean {
+    const perfKeywords = [
+      'performance',
+      'optimize',
+      'cache',
+      'memoize',
+      'debounce',
+      'throttle',
+      'lazy',
+      'async',
+      'usememo',
+      'usecallback',
+    ];
+    return perfKeywords.some(k => diff.includes(k));
+  }
+
+  private isFix(diff: string): boolean {
+    const fixKeywords = [
+      'fix',
+      'bug',
+      'issue',
+      'error',
+      'crash',
+      'problem',
+      'resolve',
+      'correct',
+      'patch',
+      'hotfix',
+    ];
+    return fixKeywords.some(k => diff.includes(k));
+  }
+
+  private isFeat(diff: string, lowerDiff: string): boolean {
+    const hasNewFiles = diff.includes('new file mode');
+    const hasNewFunctions = lowerDiff.includes('+function') ||
+      lowerDiff.includes('+export') ||
+      lowerDiff.includes('+const') ||
+      lowerDiff.includes('+class');
+
+    const featKeywords = ['add', 'create', 'implement', 'feature', 'new'];
+    const hasFeatKeywords = featKeywords.some(k => lowerDiff.includes(k));
+
+    return hasNewFiles || (hasNewFunctions && hasFeatKeywords);
+  }
+}
+

package/src/ai/emoji-mapper.ts

@@ -0,0 +1,29 @@
+import type { CommitType } from '@/ai/commit-type-analyzer.ts';
+
+export class EmojiMapper {
+  private emojiMap: Record<CommitType, string> = {
+    feat: '✨',
+    fix: '🐛',
+    refactor: '♻️',
+    chore: '🔧',
+    docs: '📝',
+    style: '💄',
+    test: '✅',
+    perf: '⚡',
+  };
+
+  getEmoji(type: CommitType): string {
+    return this.emojiMap[type];
+  }
+
+  replaceTypeWithEmoji(commitMessage: string): string {
+    for (const [type, emoji] of Object.entries(this.emojiMap)) {
+      const pattern = new RegExp(`^${type}`, 'i');
+      if (pattern.test(commitMessage)) {
+        return commitMessage.replace(pattern, emoji);
+      }
+    }
+    return commitMessage;
+  }
+}
+

package/src/cli/commit-handler.ts

@@ -0,0 +1,185 @@
+import { AIService } from '@/ai/ai.service.ts';
+import type { CommitaConfig } from '@/config/config.types.ts';
+import { FileGrouper } from '@/git/file-grouper.ts';
+import type { FileChange } from '@/git/git.service.ts';
+import { GitService } from '@/git/git.service.ts';
+import { ProjectDetector } from '@/git/project-detector.ts';
+import { PatternMatcher } from '@/utils/pattern-matcher.ts';
+import chalk from 'chalk';
+
+export interface CommitOptions {
+  all: boolean;
+  ignore: string;
+  push: boolean;
+  config?: string;
+}
+
+export class CommitHandler {
+  private gitService: GitService;
+  private fileGrouper: FileGrouper;
+  private aiService: AIService;
+  private config: CommitaConfig;
+
+  constructor(config: CommitaConfig) {
+    this.config = config;
+    this.gitService = new GitService();
+    this.fileGrouper = new FileGrouper();
+    this.aiService = new AIService(config);
+  }
+
+  async execute(options: CommitOptions): Promise<void> {
+    console.log(chalk.blue('🤖 Commita - AI-powered auto-commit\n'));
+
+    await this.gitService.init();
+
+    const boundaries = ProjectDetector.detect(this.gitService.getRootDir());
+    this.fileGrouper = new FileGrouper(boundaries);
+
+    const patternMatcher = new PatternMatcher(
+      PatternMatcher.parsePatterns(options.ignore)
+    );
+
+    try {
+      const stagedChanges = await this.gitService.getStagedChanges();
+
+      if (!options.all && stagedChanges.length === 0) {
+        console.error(chalk.red('❌ Error: No staged changes found.\n'));
+        console.log(chalk.yellow('Either stage some changes or use the --all flag to process all changes.\n'));
+        console.log(chalk.gray('Examples:'));
+        console.log(chalk.gray('  git add <files>       # Stage specific files'));
+        console.log(chalk.gray('  commita --all         # Process all changes\n'));
+        process.exit(1);
+      }
+
+      if (stagedChanges.length > 0 && !options.all) {
+        console.log(chalk.yellow('📦 Found staged changes. Grouping and processing them...\n'));
+        await this.processGroupedStagedChanges(stagedChanges);
+      } else if (stagedChanges.length > 0 && options.all) {
+        console.log(chalk.yellow('⚠️  Ignoring staged changes due to --all flag\n'));
+      }
+
+      if (options.all) {
+        await this.processAllChanges(patternMatcher);
+      }
+
+      if (options.push) {
+        await this.pushChanges();
+      }
+
+      console.log(chalk.green('\n✨ Done!\n'));
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+      } else {
+        console.error(chalk.red('\n❌ An unknown error occurred\n'));
+      }
+      process.exit(1);
+    }
+  }
+
+  private async _processChangesInGroups(changes: FileChange[], isStaged: boolean): Promise<void> {
+    if (changes.length === 0) {
+      console.log(chalk.yellow(`No ${isStaged ? 'staged' : 'unstaged'} changes found to group. Skipping...`));
+      return;
+    }
+
+    if (isStaged) {
+      const allFiles = changes.map(f => f.path);
+      await this.gitService.unstageFiles(allFiles);
+    }
+
+    const groups = this.fileGrouper.groupByPath(changes);
+    const optimizedGroups = this.fileGrouper.optimizeGroups(groups);
+
+    console.log(chalk.blue(`Found ${optimizedGroups.length} group(s) of ${isStaged ? 'staged' : 'unstaged'} changes:\n`));
+
+    for (const [index, group] of optimizedGroups.entries()) {
+      console.log(chalk.cyan(`\n[${index + 1}/${optimizedGroups.length}] Processing ${isStaged ? 'staged' : 'unstaged'}: ${group.scope}`));
+      console.log(chalk.gray(`Files: ${group.files.map(f => f.path).join(', ')}\n`));
+
+      const files = group.files.map(f => f.path);
+      const diff = await this.gitService.getDiff(files, false);
+
+      if (!diff) {
+        console.log(chalk.yellow(`  No diff found for this ${isStaged ? 'staged' : 'unstaged'} group. Skipping...`));
+        continue;
+      }
+
+      console.log(chalk.cyan('  Generating commit message...'));
+      const message = await this.aiService.generateCommitMessage(diff, files, group.scope);
+
+      console.log(chalk.gray('  Commit message:'));
+      console.log(chalk.white(`  ${message.replace(/\n/g, '\n  ')}`));
+      console.log();
+
+      await this.gitService.stageFiles(files);
+      await this.gitService.commit(message);
+      console.log(chalk.green(`  \u2713 Committed ${files.length} ${isStaged ? 'staged' : 'unstaged'} file(s)`));
+    }
+  }
+
+  private async processGroupedStagedChanges(stagedChanges: FileChange[]): Promise<void> {
+    await this._processChangesInGroups(stagedChanges, true);
+  }
+
+  private async processAllChanges(patternMatcher: PatternMatcher): Promise<void> {
+    const unstagedChanges = await this.gitService.getUnstagedChanges();
+
+    if (unstagedChanges.length === 0) {
+      console.log(chalk.yellow('No unstaged changes found.'));
+      return;
+    }
+
+    const filteredChanges = patternMatcher.filterFiles(unstagedChanges);
+
+    if (filteredChanges.length === 0) {
+      console.log(chalk.yellow('All files were filtered out by ignore patterns.'));
+      return;
+    }
+
+    await this._processChangesInGroups(filteredChanges, false);
+  }
+
+  private async pushChanges(): Promise<void> {
+    const hasRemote = await this.gitService.hasRemote();
+
+    if (!hasRemote) {
+      console.log(chalk.yellow('\n⚠️  No remote repository configured. Skipping push.'));
+      return;
+    }
+
+    console.log(chalk.blue('\n📤 Pushing changes...'));
+
+    try {
+      await this.gitService.push();
+      console.log(chalk.green('✓ Changes pushed successfully'));
+    } catch (error) {
+      console.log(chalk.yellow('⚠️  Failed to push changes. You may need to push manually.'));
+      if (error instanceof Error) {
+        console.log(chalk.gray(`   Reason: ${error.message}`));
+      }
+    }
+  }
+
+  private extractScopeFromFiles(files: string[]): string {
+    if (files.length === 0) return 'root';
+
+    const firstFile = files[0];
+    if (!firstFile) return 'root';
+
+    const parts = firstFile.split('/');
+
+    if (parts.length === 1) return 'root';
+    if (parts.length === 2) return parts[0] || 'root';
+
+    const commonDirs = ['src', 'lib', 'app'];
+    const srcIndex = parts.findIndex(p => commonDirs.includes(p));
+
+    if (srcIndex !== -1 && srcIndex + 1 < parts.length) {
+      return parts[srcIndex + 1] || 'root';
+    }
+
+    return parts[0] || 'root';
+  }
+}
+

package/src/cli/index.ts

@@ -0,0 +1,58 @@
+import type { CommitOptions } from '@/cli/commit-handler.ts';
+import { CommitHandler } from '@/cli/commit-handler.ts';
+import type { SetOptions } from '@/cli/set-handler.ts';
+import { SetHandler } from '@/cli/set-handler.ts';
+import { ConfigLoader } from '@/config/config.loader.ts';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import packageJson from '../../package.json' with { type: 'json' };
+
+export async function runCLI() {
+  const program = new Command();
+
+  program
+    .name('commita')
+    .description('AI-powered git auto-commit tool')
+    .version(packageJson.version, '-v, --version', 'Show version number')
+    .option('-a, --all', 'Process all changes grouped by folders', false)
+    .option('-i, --ignore <patterns>', 'Comma-separated patterns to exclude', '')
+    .option('--no-push', 'Skip pushing after commit')
+    .option('-c, --config <path>', 'Path to custom config file')
+    .action(async (options: CommitOptions) => {
+      try {
+        const configLoader = new ConfigLoader();
+        const config = await configLoader.load(options.config);
+
+        const handler = new CommitHandler(config);
+        await handler.execute(options);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(chalk.red(`\n❌ Fatal error: ${error.message}\n`));
+        } else {
+          console.error(chalk.red('\n❌ An unknown fatal error occurred\n'));
+        }
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('set <key-value>')
+    .description('Set configuration value (format: KEY=value or KEY to prompt)')
+    .option('-l, --local', 'Set in project .commita file instead of global ~/.commita')
+    .action(async (keyValue: string, options: SetOptions) => {
+      try {
+        const handler = new SetHandler();
+        await handler.execute(keyValue, options);
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+        } else {
+          console.error(chalk.red('\n❌ An unknown error occurred\n'));
+        }
+        process.exit(1);
+      }
+    });
+
+  await program.parseAsync(process.argv);
+}
+

package/src/cli/set-handler.ts

@@ -0,0 +1,134 @@
+import { ConfigWriter } from '@/config/config.writer.ts';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface SetOptions {
+  local?: boolean;
+}
+
+const SENSITIVE_KEYS = ['OPENAI_API_KEY', 'GEMINI_API_KEY'];
+
+export class SetHandler {
+  private configWriter: ConfigWriter;
+
+  constructor() {
+    this.configWriter = new ConfigWriter();
+  }
+
+  async execute(keyValue: string, options: SetOptions): Promise<void> {
+    const { key, value } = this.parseKeyValue(keyValue);
+
+    let finalValue = value;
+    if (!finalValue) {
+      finalValue = await this.promptForValue(key);
+    }
+
+    const configPath = this.getConfigPath(options.local || false);
+    await this.configWriter.set(key, finalValue, configPath);
+
+    console.log(chalk.green('\n✓ Configuration updated successfully'));
+    console.log(`  ${chalk.cyan(key)}=${chalk.green(this.maskSensitiveValue(key, finalValue))} set in ${chalk.gray(configPath)}\n`);
+  }
+
+  private parseKeyValue(keyValue: string): { key: string; value?: string } {
+    const eqIndex = keyValue.indexOf('=');
+
+    if (eqIndex === -1) {
+      // No value provided, will prompt interactively
+      return {
+        key: keyValue.trim(),
+        value: undefined,
+      };
+    }
+
+    const key = keyValue.substring(0, eqIndex).trim();
+    const value = keyValue.substring(eqIndex + 1).trim();
+
+    if (!key) {
+      throw new Error('Key cannot be empty');
+    }
+
+    return { key, value };
+  }
+
+  private getConfigPath(isLocal: boolean): string {
+    if (isLocal) {
+      return join(process.cwd(), '.commita');
+    }
+    return join(homedir(), '.commita');
+  }
+
+  private async promptForValue(key: string): Promise<string> {
+    if (!process.stdin.isTTY) {
+      throw new Error(`Value required for key '${key}'. Use format: commita set KEY=value`);
+    }
+
+    const isSensitive = this.isSensitiveKey(key);
+    const prompt = `Enter value for ${chalk.cyan(key)}${isSensitive ? ' (hidden)' : ''}: `;
+
+    return new Promise((resolve, reject) => {
+      const readline = createInterface({
+        input: process.stdin,
+        output: isSensitive ? process.stderr : process.stdout,
+        terminal: true,
+      });
+
+      if (isSensitive) {
+        // Hide input for sensitive keys
+        process.stdin.setRawMode?.(true);
+        process.stderr.write(prompt);
+      } else {
+        readline.question(prompt, () => {});
+      }
+
+      let value = '';
+
+      process.stdin.on('data', (buffer) => {
+        const char = buffer.toString();
+
+        if (char === '\n' || char === '\r') {
+          if (isSensitive) {
+            process.stdin.setRawMode?.(false);
+            process.stderr.write('\n');
+          }
+          readline.close();
+          resolve(value);
+        } else if (char === '\u0003') {
+          // Handle Ctrl+C
+          if (isSensitive) {
+            process.stdin.setRawMode?.(false);
+          }
+          readline.close();
+          reject(new Error('Input cancelled'));
+        } else if (char === '\u007f') {
+          // Handle backspace
+          value = value.slice(0, -1);
+        } else {
+          value += char;
+        }
+      });
+
+      readline.once('close', () => {
+        if (!value) {
+          reject(new Error('No value provided'));
+        }
+      });
+    });
+  }
+
+  private isSensitiveKey(key: string): boolean {
+    return SENSITIVE_KEYS.includes(key.toUpperCase());
+  }
+
+  private maskSensitiveValue(key: string, value: string): string {
+    if (!this.isSensitiveKey(key)) {
+      return value;
+    }
+    if (value.length <= 4) {
+      return '*'.repeat(value.length);
+    }
+    return value.substring(0, 2) + '*'.repeat(value.length - 4) + value.substring(value.length - 2);
+  }
+}