@misaelabanto/commita 0.1.2

package/install.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+REPO="misaelabanto/commita"
+BINARY_NAME="commita"
+INSTALL_DIR="/usr/local/bin"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+info()    { echo -e "${CYAN}[commita]${NC} $*"; }
+success() { echo -e "${GREEN}[commita]${NC} $*"; }
+warn()    { echo -e "${YELLOW}[commita]${NC} $*"; }
+error()   { echo -e "${RED}[commita]${NC} $*" >&2; exit 1; }
+
+# Detect OS
+detect_os() {
+  local os
+  os=$(uname -s | tr '[:upper:]' '[:lower:]')
+  case "$os" in
+    darwin)  echo "darwin" ;;
+    linux)   echo "linux" ;;
+    msys*|mingw*|cygwin*) echo "windows" ;;
+    *) error "Unsupported OS: $os" ;;
+  esac
+}
+
+# Detect architecture
+detect_arch() {
+  local arch
+  arch=$(uname -m)
+  case "$arch" in
+    x86_64|amd64)   echo "amd64" ;;
+    arm64|aarch64)  echo "arm64" ;;
+    *) error "Unsupported architecture: $arch" ;;
+  esac
+}
+
+# Check for required tools
+check_deps() {
+  for cmd in curl; do
+    if ! command -v "$cmd" &>/dev/null; then
+      error "'$cmd' is required but not installed."
+    fi
+  done
+}
+
+# Get latest release tag from GitHub API
+get_latest_tag() {
+  local tag
+  tag=$(curl -fsSL "https://api.github.com/repos/${REPO}/releases/latest" \
+    | grep '"tag_name"' \
+    | sed -E 's/.*"([^"]+)".*/\1/')
+
+  if [ -z "$tag" ]; then
+    error "Failed to fetch the latest release tag. Check your internet connection or visit https://github.com/${REPO}/releases."
+  fi
+
+  echo "$tag"
+}
+
+main() {
+  check_deps
+
+  local os arch
+  os=$(detect_os)
+  arch=$(detect_arch)
+
+  # Windows is not supported via this script — direct users to releases
+  if [ "$os" = "windows" ]; then
+    error "Windows is not supported by this install script. Please download the binary manually from: https://github.com/${REPO}/releases"
+  fi
+
+  local tag
+  tag=$(get_latest_tag)
+
+  local binary_file="${BINARY_NAME}-${os}-${arch}"
+  local download_url="https://github.com/${REPO}/releases/download/${tag}/${binary_file}"
+  local tmp_file
+  tmp_file=$(mktemp)
+
+  info "Detected platform: ${os}/${arch}"
+  info "Latest version:    ${tag}"
+  info "Downloading ${binary_file}..."
+
+  if ! curl -fsSL --progress-bar "$download_url" -o "$tmp_file"; then
+    rm -f "$tmp_file"
+    error "Download failed. Please check: ${download_url}"
+  fi
+
+  chmod +x "$tmp_file"
+
+  # Install to INSTALL_DIR, using sudo if needed
+  if [ -w "$INSTALL_DIR" ]; then
+    mv "$tmp_file" "${INSTALL_DIR}/${BINARY_NAME}"
+  else
+    warn "Installing to ${INSTALL_DIR} requires elevated privileges."
+    sudo mv "$tmp_file" "${INSTALL_DIR}/${BINARY_NAME}"
+  fi
+
+  success "${BINARY_NAME} ${tag} installed to ${INSTALL_DIR}/${BINARY_NAME}"
+  echo ""
+  echo "  Get started:  commita --help"
+  echo "  Docs:         https://github.com/${REPO}#readme"
+  echo ""
+}
+
+main "$@"

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@misaelabanto/commita",
+  "version": "0.1.2",
+  "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);
+}
+