commitect 1.0.0

package/src/commands/commit.ts

@@ -0,0 +1,48 @@
+import { isGitRepository, getGitDiff, hasChanges, executeCommit } from '../utils/git.js';
+import { generateCommitMessage } from '../services/llm.js';
+import chalk from 'chalk';
+
+export async function commitCommand(): Promise<void> {
+  try {
+    // Validate git repository
+    if (!isGitRepository()) {
+      console.error(chalk.red('❌ Not a git repository'));
+      process.exit(1);
+    }
+
+    // Check for changes
+    if (!hasChanges()) {
+      console.log(chalk.yellow('⚠ No changes to commit'));
+      process.exit(0);
+    }
+
+    // Get diff
+    const diff = getGitDiff();
+    
+    if (!diff.trim()) {
+      console.log(chalk.yellow('⚠ No changes to commit'));
+      process.exit(0);
+    }
+
+    // Generate commit message
+    console.log(chalk.blue('🔍 Generating commit message...'));
+    const suggestion = await generateCommitMessage(diff);
+
+    // Build commit message as "intent: message"
+    const commitMessage = `${suggestion.intent}: ${suggestion.message}`;
+
+    // Execute git commit
+    console.log(chalk.blue('💾 Committing changes...'));
+    executeCommit(commitMessage);
+
+    console.log(chalk.green('✔ Committed: ') + commitMessage);
+
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red('❌ ' + error.message));
+    } else {
+      console.error(chalk.red('❌ An unexpected error occurred'));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/copy.ts

@@ -0,0 +1,48 @@
+import { isGitRepository, getGitDiff, hasChanges } from '../utils/git.js';
+import { generateCommitMessage } from '../services/llm.js';
+import clipboardy from 'clipboardy';
+import chalk from 'chalk';
+
+export async function copyCommand(): Promise<void> {
+  try {
+    // Validate git repository
+    if (!isGitRepository()) {
+      console.error(chalk.red('❌ Not a git repository'));
+      process.exit(1);
+    }
+
+    // Check for changes
+    if (!hasChanges()) {
+      console.log(chalk.yellow('⚠ No changes detected'));
+      process.exit(0);
+    }
+
+    // Get diff
+    const diff = getGitDiff();
+    
+    if (!diff.trim()) {
+      console.log(chalk.yellow('⚠ No changes to analyze'));
+      process.exit(0);
+    }
+
+    // Generate commit message
+    console.log(chalk.blue('🔍 Generating commit message...'));
+    const suggestion = await generateCommitMessage(diff);
+
+    // Build commit message as "intent: message"
+    const commitMessage = `${suggestion.intent}: ${suggestion.message}`;
+
+    // Copy to clipboard
+    await clipboardy.write(commitMessage);
+
+    console.log(chalk.green('✔ Commit message copied to clipboard'));
+
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red('❌ ' + error.message));
+    } else {
+      console.error(chalk.red('❌ An unexpected error occurred'));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/help.ts

@@ -0,0 +1,143 @@
+import chalk from 'chalk';
+
+const VERSION = '1.0.0';
+const GITHUB_REPO = 'https://github.com/Mohammed_3tef/CommiTect_CLI';
+const ISSUES_URL = GITHUB_REPO + '/issues';
+
+export function helpCommand(): void {
+  console.log('');
+  console.log(chalk.bold.cyan('╔══════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan('║                      ') + chalk.bold.white('CommiTect') + chalk.bold.cyan('                           ║'));
+  console.log(chalk.bold.cyan('║            ') + chalk.gray('Zero-config Git Commit Assistant') + chalk.bold.cyan('              ║'));
+  console.log(chalk.bold.cyan('╚══════════════════════════════════════════════════════════╝'));
+  console.log('');
+
+  // COMMANDS SECTION
+  console.log(chalk.bold.yellow('📋 AVAILABLE COMMANDS'));
+  console.log('');
+
+  // ANALYZE
+  console.log(chalk.bold.green('  commitect analyze'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  ├─ ') + 'Analyzes your git changes and suggests a commit message');
+  console.log(chalk.gray('  ├─ ') + 'Displays both intent and message on the terminal');
+  console.log(chalk.gray('  └─ ') + 'Does NOT modify your git repository');
+  console.log('');
+  console.log(chalk.dim('     Example output:'));
+  console.log(chalk.dim('     Feature: Add user authentication with JWT'));
+  console.log('');
+
+  // COPY
+  console.log(chalk.bold.green('  commitect copy'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  ├─ ') + 'Generates a commit message from your changes');
+  console.log(chalk.gray('  ├─ ') + 'Copies ONLY the message (not intent) to clipboard');
+  console.log(chalk.gray('  └─ ') + 'Perfect for manual commits with custom flags');
+  console.log('');
+  console.log(chalk.dim('     Usage:'));
+  console.log(chalk.dim('     $ commitect copy'));
+  console.log(chalk.dim('     $ git commit -m "<paste>" --no-verify'));
+  console.log('');
+
+  // COMMIT
+  console.log(chalk.bold.green('  commitect commit'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  ├─ ') + 'Generates a commit message from your changes');
+  console.log(chalk.gray('  ├─ ') + 'Automatically executes: git commit -m "<message>"');
+  console.log(chalk.gray('  └─ ') + 'Fastest way to commit with AI-generated messages');
+  console.log('');
+  console.log(chalk.dim('     Warning: Make sure you have staged your changes first!'));
+  console.log(chalk.dim('     $ git add .'));
+  console.log(chalk.dim('     $ commitect commit'));
+  console.log('');
+
+  // HISTORY
+  console.log(chalk.bold.green('  commitect history'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  ├─ ') + 'Shows all cached commit messages');
+  console.log(chalk.gray('  ├─ ') + 'Displays timestamp and time ago for each entry');
+  console.log(chalk.gray('  └─ ') + 'Useful for reviewing past suggestions');
+  console.log('');
+
+  // CLEAR-CACHE
+  console.log(chalk.bold.green('  commitect clear-cache'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  ├─ ') + 'Clears all cached commit messages');
+  console.log(chalk.gray('  ├─ ') + 'Cache location: ~/.commitect/cache.json');
+  console.log(chalk.gray('  └─ ') + 'Use when you want fresh suggestions');
+  console.log('');
+
+  // HELP
+  console.log(chalk.bold.green('  commitect help'));
+  console.log(chalk.gray('  │'));
+  console.log(chalk.gray('  └─ ') + 'Shows this help message');
+  console.log('');
+
+  // HOW IT WORKS
+  console.log(chalk.bold.yellow('⚙️  HOW IT WORKS'));
+  console.log('');
+  console.log(chalk.gray('  1. ') + '📖 Reads your git diff (staged + unstaged changes)');
+  console.log(chalk.gray('  2. ') + '🔍 Checks cache for previously analyzed diffs');
+  console.log(chalk.gray('  3. ') + '🤖 Sends to AI API if not cached (with auto-retry)');
+  console.log(chalk.gray('  4. ') + '💾 Caches result for 30 days');
+  console.log(chalk.gray('  5. ') + '✨ Returns professional commit message');
+  console.log('');
+
+  // WORKFLOW
+  console.log(chalk.bold.yellow('🔄 TYPICAL WORKFLOW'));
+  console.log('');
+  console.log(chalk.gray('  # Make your changes'));
+  console.log(chalk.white('  $ vim src/auth.ts'));
+  console.log('');
+  console.log(chalk.gray('  # Stage files'));
+  console.log(chalk.white('  $ git add .'));
+  console.log('');
+  console.log(chalk.gray('  # Option 1: Preview message'));
+  console.log(chalk.white('  $ commitect analyze'));
+  console.log('');
+  console.log(chalk.gray('  # Option 2: Copy to clipboard'));
+  console.log(chalk.white('  $ commitect copy'));
+  console.log(chalk.white('  $ git commit -m "<paste>"'));
+  console.log('');
+  console.log(chalk.gray('  # Option 3: Auto-commit (fastest)'));
+  console.log(chalk.white('  $ commitect commit'));
+  console.log('');
+
+  // FEATURES
+  console.log(chalk.bold.yellow('✨ KEY FEATURES'));
+  console.log('');
+  console.log(chalk.green('  ✓ ') + 'Zero configuration required');
+  console.log(chalk.green('  ✓ ') + 'Smart caching (instant responses for same diffs)');
+  console.log(chalk.green('  ✓ ') + 'Auto-retry on API failures (up to 3 attempts)');
+  console.log(chalk.green('  ✓ ') + 'Ignores: node_modules/, dist/, build/, .git/');
+  console.log(chalk.green('  ✓ ') + 'Professional messages (imperative, <70 chars)');
+  console.log(chalk.green('  ✓ ') + 'Works with any git repository');
+  console.log('');
+
+  // TIPS
+  console.log(chalk.bold.yellow('💡 PRO TIPS'));
+  console.log('');
+  console.log(chalk.cyan('  • ') + 'Use ' + chalk.bold('analyze') + ' when you want to review before committing');
+  console.log(chalk.cyan('  • ') + 'Use ' + chalk.bold('copy') + ' when you need custom git flags');
+  console.log(chalk.cyan('  • ') + 'Use ' + chalk.bold('commit') + ' for quick, everyday commits');
+  console.log(chalk.cyan('  • ') + 'Use ' + chalk.bold('history') + ' to review all your cached messages');
+  console.log(chalk.cyan('  • ') + 'Run ' + chalk.bold('clear-cache') + ' if suggestions seem outdated');
+  console.log(chalk.cyan('  • ') + 'Cache saves time and reduces API costs significantly');
+  console.log('');
+
+  // REQUIREMENTS
+  console.log(chalk.bold.yellow('📦 REQUIREMENTS'));
+  console.log('');
+  console.log(chalk.gray('  • Node.js >= 16'));
+  console.log(chalk.gray('  • Git repository (initialized)'));
+  console.log(chalk.gray('  • Internet connection (unless result is cached)'));
+  console.log('');
+
+  // FOOTER
+  console.log(chalk.bold.cyan('─'.repeat(63)));
+  console.log(chalk.gray('  Version: ') + chalk.white(VERSION));
+  console.log(chalk.gray('  Docs: ') + chalk.white(GITHUB_REPO));
+  console.log(chalk.gray('  Issues: ') + chalk.white(ISSUES_URL));
+  console.log(chalk.bold.cyan('─'.repeat(63)));
+  console.log('');
+}

package/src/commands/history.ts

@@ -0,0 +1,62 @@
+import { commitCache } from '../utils/cache.js';
+import chalk from 'chalk';
+
+export function historyCommand(): void {
+  try {
+    const history = commitCache.getHistory();
+
+    if (history.length === 0) {
+      console.log(chalk.yellow('ℹ No commit history found'));
+      console.log(chalk.gray('  Generate some commits first using commitect analyze/copy/commit'));
+      return;
+    }
+
+    console.log('');
+    console.log(chalk.bold.cyan('📜 COMMIT HISTORY'));
+    console.log(chalk.gray('─'.repeat(70)));
+    console.log('');
+
+    history.forEach((entry, index) => {
+      const date = new Date(entry.timestamp);
+      const timeAgo = getTimeAgo(entry.timestamp);
+      
+      // Format: [1] Feature: Add user authentication
+      console.log(chalk.bold.white(`[${index + 1}]`) + ' ' + chalk.green(`${entry.intent}: ${entry.message}`));
+      console.log(chalk.gray(`    📁 ${entry.folder}`));
+      console.log(chalk.gray(`    🕒 ${date.toLocaleString()} (${timeAgo})`));
+      console.log('');
+    });
+
+    console.log(chalk.gray('─'.repeat(70)));
+    console.log(chalk.gray(`Total: ${history.length} cached commit message${history.length !== 1 ? 's' : ''}`));
+    console.log('');
+
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk.red('❌ ' + error.message));
+    } else {
+      console.error(chalk.red('❌ Failed to load history'));
+    }
+    process.exit(1);
+  }
+}
+
+function getTimeAgo(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp;
+
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+
+  if (days > 0) {
+    return `${days} day${days !== 1 ? 's' : ''} ago`;
+  } else if (hours > 0) {
+    return `${hours} hour${hours !== 1 ? 's' : ''} ago`;
+  } else if (minutes > 0) {
+    return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`;
+  } else {
+    return 'just now';
+  }
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { analyzeCommand } from './commands/analyze.js';
+import { copyCommand } from './commands/copy.js';
+import { commitCommand } from './commands/commit.js';
+import { clearCacheCommand } from './commands/clear-cache.js';
+import { historyCommand } from './commands/history.js';
+import { helpCommand } from './commands/help.js';
+
+const program = new Command();
+
+program
+  .name('commitect')
+  .description('Zero-config Git Commit Assistant')
+  .version('1.0.0');
+
+program
+  .command('analyze')
+  .description('Analyze changes and suggest a commit message')
+  .action(analyzeCommand);
+
+program
+  .command('copy')
+  .description('Generate commit message and copy to clipboard')
+  .action(copyCommand);
+
+program
+  .command('commit')
+  .description('Generate and execute git commit')
+  .action(commitCommand);
+
+program
+  .command('history')
+  .description('Show cached commit message history')
+  .action(historyCommand);
+
+program
+  .command('clear-cache')
+  .description('Clear the commit message cache')
+  .action(clearCacheCommand);
+
+program
+  .command('help')
+  .description('Show detailed help and examples')
+  .action(helpCommand);
+
+// Show help by default if no command is provided
+if (process.argv.length === 2) {
+  helpCommand();
+  process.exit(0);
+}
+
+program.parse();

package/src/services/llm.ts

@@ -0,0 +1,123 @@
+import axios, { AxiosError } from 'axios';
+import { commitCache } from '../utils/cache.js';
+
+export interface CommitSuggestion {
+  intent: string;
+  message: string;
+}
+
+const API_ENDPOINT = 'http://commitintentdetector.runasp.net/api/Commit/analyze';
+
+export async function generateCommitMessage(diff: string): Promise<CommitSuggestion> {
+  // Check cache first
+  const cached = commitCache.get(diff);
+  if (cached) {
+    return cached;
+  }
+  const maxRetries = 3;
+  let lastError: Error | null = null;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await axios.post(
+        API_ENDPOINT,
+        { diff },
+        {
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          timeout: 30000 // 30 second timeout
+        }
+      );
+
+      // API returns: { intent: "Intent: Feature\nMessage: Add subtraction support function" }
+      const data = response.data;
+      
+      if (!data || !data.intent) {
+        throw new Error('Invalid response format from API');
+      }
+
+      const result = parseResponse(data.intent);
+      
+      // Cache the result
+      commitCache.set(diff, result.intent, result.message);
+
+      return result;
+
+    } catch (error) {
+      lastError = error as Error;
+
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError;
+        
+        // Handle rate limiting (429)
+        if (axiosError.response?.status === 429) {
+          if (attempt < maxRetries) {
+            await sleep(1000 * attempt); // Exponential backoff
+            continue;
+          }
+          throw new Error('API rate limit reached. Please try again later.');
+        }
+
+        // Handle server errors (5xx) - retry
+        if (axiosError.response?.status && axiosError.response.status >= 500) {
+          if (attempt < maxRetries) {
+            await sleep(1000 * attempt);
+            continue;
+          }
+        }
+
+        // Handle network errors - retry
+        if (axiosError.code === 'ECONNREFUSED' || axiosError.code === 'ETIMEDOUT') {
+          if (attempt < maxRetries) {
+            await sleep(1000 * attempt);
+            continue;
+          }
+          throw new Error('Unable to connect to API. Please check your network connection.');
+        }
+      }
+
+      // Don't retry on client errors (4xx) except 429
+      if (axios.isAxiosError(error) && error.response?.status && error.response.status < 500 && error.response.status !== 429) {
+        break;
+      }
+
+      // Retry on other errors
+      if (attempt < maxRetries) {
+        await sleep(1000 * attempt);
+        continue;
+      }
+    }
+  }
+
+  throw new Error('Failed to generate commit message. Please check your API configuration.');
+}
+
+function parseResponse(response: string): CommitSuggestion {
+  const lines = response.trim().split('\n');
+  
+  let intent = '';
+  let message = '';
+
+  for (const line of lines) {
+    if (line.startsWith('Intent:')) {
+      intent = line.replace('Intent:', '').trim();
+    } else if (line.startsWith('Message:')) {
+      message = line.replace('Message:', '').trim();
+    }
+  }
+
+  if (!intent || !message) {
+    throw new Error('Invalid response format from LLM');
+  }
+
+  if (message.length > 70) {
+    message = message.substring(0, 67) + '...';
+  }
+
+  return { intent, message };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/utils/cache.ts

@@ -0,0 +1,170 @@
+import { createHash } from 'crypto';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, basename } from 'path';
+
+interface CacheEntry {
+  hash: string;
+  intent: string;
+  message: string;
+  timestamp: number;
+  folder: string;
+}
+
+const CACHE_DIR = join(homedir(), '.commitect');
+const CACHE_FILE = join(CACHE_DIR, 'cache.json');
+const CACHE_MAX_AGE = 30 * 24 * 60 * 60 * 1000; // 30 days in milliseconds
+
+class CommitCache {
+  private cache: Map<string, CacheEntry>;
+
+  constructor() {
+    this.cache = new Map();
+    this.loadCache();
+  }
+
+  /**
+   * Generate a hash from the git diff
+   */
+  private hashDiff(diff: string): string {
+    return createHash('sha256').update(diff.trim()).digest('hex');
+  }
+
+  /**
+   * Get current folder name
+   */
+  private getCurrentFolder(): string {
+    return basename(process.cwd());
+  }
+
+  /**
+   * Load cache from disk
+   */
+  private loadCache(): void {
+    try {
+      if (!existsSync(CACHE_DIR)) {
+        mkdirSync(CACHE_DIR, { recursive: true });
+      }
+
+      if (existsSync(CACHE_FILE)) {
+        const data = readFileSync(CACHE_FILE, 'utf-8');
+        const entries: CacheEntry[] = JSON.parse(data);
+        
+        // Load valid entries (not expired)
+        const now = Date.now();
+        entries.forEach(entry => {
+          if (now - entry.timestamp < CACHE_MAX_AGE) {
+            this.cache.set(entry.hash, entry);
+          }
+        });
+      }
+    } catch (error) {
+      // If cache is corrupted, start fresh
+      this.cache.clear();
+    }
+  }
+
+  /**
+   * Save cache to disk
+   */
+  private saveCache(): void {
+    try {
+      if (!existsSync(CACHE_DIR)) {
+        mkdirSync(CACHE_DIR, { recursive: true });
+      }
+
+      const entries = Array.from(this.cache.values());
+      writeFileSync(CACHE_FILE, JSON.stringify(entries, null, 2), 'utf-8');
+    } catch (error) {
+      // Silently fail - caching is optional
+      console.warn('Warning: Failed to save cache');
+    }
+  }
+
+  /**
+   * Get cached commit message for a diff
+   */
+  get(diff: string): { intent: string; message: string; folder: string } | null {
+    const hash = this.hashDiff(diff);
+    const entry = this.cache.get(hash);
+
+    if (!entry) {
+      return null;
+    }
+
+    // Check if entry is still valid
+    const now = Date.now();
+    if (now - entry.timestamp > CACHE_MAX_AGE) {
+      this.cache.delete(hash);
+      this.saveCache();
+      return null;
+    }
+
+    return {
+      intent: entry.intent,
+      message: entry.message,
+      folder: entry.folder
+    };
+  }
+
+  /**
+   * Store a commit message in cache
+   */
+  set(diff: string, intent: string, message: string): void {
+    const hash = this.hashDiff(diff);
+    
+    this.cache.set(hash, {
+      hash,
+      intent,
+      message,
+      timestamp: Date.now(),
+      folder: this.getCurrentFolder()
+    });
+
+    this.saveCache();
+  }
+
+  /**
+   * Clear all cache
+   */
+  clear(): void {
+    this.cache.clear();
+    this.saveCache();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats(): { size: number; oldestEntry: number | null } {
+    const entries = Array.from(this.cache.values());
+    const oldestEntry = entries.length > 0 
+      ? Math.min(...entries.map(e => e.timestamp))
+      : null;
+
+    return {
+      size: this.cache.size,
+      oldestEntry
+    };
+  }
+
+  /**
+   * Get all cache entries sorted by timestamp (newest first)
+   */
+  getHistory(): CacheEntry[] {
+    const entries = Array.from(this.cache.values());
+    return entries.sort((a, b) => b.timestamp - a.timestamp);
+  }
+
+  /**
+   * Get cache entries for a specific folder
+   */
+  getHistoryByFolder(folder: string): CacheEntry[] {
+    const entries = Array.from(this.cache.values());
+    return entries
+      .filter(entry => entry.folder === folder)
+      .sort((a, b) => b.timestamp - a.timestamp);
+  }
+}
+
+// Singleton instance
+export const commitCache = new CommitCache();