gims 0.6.6 → 0.8.1

package/bin/lib/utils/intelligence.js

@@ -0,0 +1,421 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Intelligence utilities for smart git operations
+ */
+class Intelligence {
+  constructor(git) {
+    this.git = git;
+  }
+
+  /**
+   * Get file type emoji based on file extension
+   */
+  static getFileEmoji(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    const name = path.basename(filename).toLowerCase();
+    
+    // Special files
+    if (name === 'package.json' || name === 'package-lock.json') return '📦';
+    if (name === 'readme.md' || name === 'readme') return '📚';
+    if (name === '.gitignore') return '🙈';
+    if (name === '.env' || name.startsWith('.env.')) return '🔐';
+    if (name === 'dockerfile' || name === 'docker-compose.yml') return '🐳';
+    if (name.includes('config') || name.includes('rc')) return '⚙️';
+    if (name === 'license' || name === 'license.md') return '📜';
+    
+    // Test files
+    if (filename.includes('.test.') || filename.includes('.spec.') || filename.includes('__tests__')) return '🧪';
+    
+    // By extension
+    const emojiMap = {
+      '.js': '📄', '.jsx': '⚛️', '.ts': '📘', '.tsx': '⚛️',
+      '.css': '🎨', '.scss': '🎨', '.sass': '🎨', '.less': '🎨',
+      '.html': '🌐', '.htm': '🌐',
+      '.json': '📋', '.yaml': '📋', '.yml': '📋', '.toml': '📋',
+      '.md': '📝', '.mdx': '📝', '.txt': '📄',
+      '.py': '🐍', '.rb': '💎', '.go': '🔷', '.rs': '🦀', '.java': '☕',
+      '.sh': '🐚', '.bash': '🐚', '.zsh': '🐚',
+      '.sql': '🗃️', '.graphql': '🔗', '.gql': '🔗',
+      '.png': '🖼️', '.jpg': '🖼️', '.jpeg': '🖼️', '.gif': '🖼️', '.svg': '🎯',
+      '.mp3': '🎵', '.wav': '🎵', '.mp4': '🎬', '.mov': '🎬',
+      '.zip': '📦', '.tar': '📦', '.gz': '📦',
+      '.lock': '🔒',
+    };
+    
+    return emojiMap[ext] || '📄';
+  }
+
+  /**
+   * Analyze user's commit patterns from history
+   */
+  async analyzeCommitPatterns(limit = 50) {
+    try {
+      const log = await this.git.log({ maxCount: limit });
+      const commits = log.all;
+      
+      if (commits.length === 0) {
+        return { hasHistory: false };
+      }
+
+      // Analyze patterns
+      const conventionalPattern = /^(feat|fix|docs|style|refactor|test|chore|perf|build|ci|revert)(\(.+\))?:/i;
+      const conventionalCommits = commits.filter(c => conventionalPattern.test(c.message));
+      
+      // Calculate average message length
+      const avgLength = Math.round(commits.reduce((sum, c) => sum + c.message.split('\n')[0].length, 0) / commits.length);
+      
+      // Detect common scopes
+      const scopes = {};
+      commits.forEach(c => {
+        const match = c.message.match(/^\w+\(([^)]+)\)/);
+        if (match) {
+          scopes[match[1]] = (scopes[match[1]] || 0) + 1;
+        }
+      });
+      const topScopes = Object.entries(scopes)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([scope]) => scope);
+
+      // Detect if user uses emojis
+      const emojiPattern = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]/u;
+      const usesEmojis = commits.some(c => emojiPattern.test(c.message));
+
+      // Detect commit message style (imperative vs past tense)
+      const imperativeWords = ['add', 'fix', 'update', 'remove', 'change', 'implement', 'refactor'];
+      const pastTenseWords = ['added', 'fixed', 'updated', 'removed', 'changed', 'implemented', 'refactored'];
+      
+      let imperativeCount = 0;
+      let pastTenseCount = 0;
+      commits.forEach(c => {
+        const firstWord = c.message.split(/[\s(:]/)[0].toLowerCase();
+        if (imperativeWords.includes(firstWord)) imperativeCount++;
+        if (pastTenseWords.includes(firstWord)) pastTenseCount++;
+      });
+
+      return {
+        hasHistory: true,
+        totalAnalyzed: commits.length,
+        conventionalRatio: (conventionalCommits.length / commits.length * 100).toFixed(0),
+        usesConventional: conventionalCommits.length > commits.length * 0.5,
+        avgMessageLength: avgLength,
+        topScopes,
+        usesEmojis,
+        style: imperativeCount >= pastTenseCount ? 'imperative' : 'past-tense',
+        authors: [...new Set(commits.map(c => c.author_name))],
+      };
+    } catch (error) {
+      return { hasHistory: false, error: error.message };
+    }
+  }
+
+  /**
+   * Detect semantic meaning of changes
+   */
+  async detectSemanticChanges(diff) {
+    const changes = {
+      type: 'misc',
+      labels: [],
+      suggestions: [],
+      breakingChange: false,
+    };
+
+    if (!diff || !diff.trim()) return changes;
+
+    const lines = diff.split('\n');
+    const addedLines = lines.filter(l => l.startsWith('+') && !l.startsWith('+++'));
+    const removedLines = lines.filter(l => l.startsWith('-') && !l.startsWith('---'));
+
+    // Detect breaking changes
+    if (removedLines.some(l => l.includes('export ') && l.includes('function ')) ||
+        removedLines.some(l => l.includes('module.exports'))) {
+      changes.labels.push('⚠️ Potential breaking change');
+      changes.breakingChange = true;
+    }
+
+    // Detect new features
+    if (addedLines.some(l => l.includes('export ') && l.includes('function ')) ||
+        addedLines.some(l => l.includes('class ')) ||
+        addedLines.some(l => l.includes('async function '))) {
+      changes.labels.push('✨ New functionality');
+      changes.type = 'feat';
+    }
+
+    // Detect bug fixes
+    if (addedLines.some(l => l.includes('catch') || l.includes('try {')) ||
+        addedLines.some(l => l.includes('|| null') || l.includes('?? ') || l.includes('?.'))) {
+      changes.labels.push('🐛 Error handling');
+      if (changes.type === 'misc') changes.type = 'fix';
+    }
+
+    // Detect refactoring
+    if (addedLines.length > 20 && removedLines.length > 20 && 
+        Math.abs(addedLines.length - removedLines.length) < 10) {
+      changes.labels.push('♻️ Refactoring');
+      if (changes.type === 'misc') changes.type = 'refactor';
+    }
+
+    // Detect documentation
+    if (addedLines.some(l => l.includes('/**') || l.includes('* @') || l.includes('// '))) {
+      changes.labels.push('📝 Documentation');
+      if (changes.type === 'misc') changes.type = 'docs';
+    }
+
+    // Detect test changes
+    if (diff.includes('.test.') || diff.includes('.spec.') || 
+        addedLines.some(l => l.includes('describe(') || l.includes('it(') || l.includes('test('))) {
+      changes.labels.push('🧪 Tests');
+      if (changes.type === 'misc') changes.type = 'test';
+    }
+
+    // Detect dependency changes
+    if (diff.includes('package.json') && (diff.includes('"dependencies"') || diff.includes('"devDependencies"'))) {
+      changes.labels.push('📦 Dependencies');
+    }
+
+    // Detect style/formatting
+    if (addedLines.every(l => l.trim().length < 3 || l.includes('  ') || l === '+')) {
+      changes.labels.push('🎨 Formatting');
+      if (changes.type === 'misc') changes.type = 'style';
+    }
+
+    return changes;
+  }
+
+  /**
+   * Suggest how to split a large changeset
+   */
+  async suggestCommitSplit(status) {
+    const files = status.files || [];
+    if (files.length < 5) return null;
+
+    const groups = {
+      tests: [],
+      config: [],
+      docs: [],
+      styles: [],
+      core: [],
+    };
+
+    files.forEach(file => {
+      const f = typeof file === 'string' ? file : file.path;
+      if (!f) return;
+      
+      if (f.includes('.test.') || f.includes('.spec.') || f.includes('__tests__')) {
+        groups.tests.push(f);
+      } else if (f.includes('config') || f.endsWith('.json') || f.endsWith('.yml') || f.endsWith('.yaml') || f.includes('rc')) {
+        groups.config.push(f);
+      } else if (f.endsWith('.md') || f.includes('docs/') || f.includes('README')) {
+        groups.docs.push(f);
+      } else if (f.endsWith('.css') || f.endsWith('.scss') || f.endsWith('.sass')) {
+        groups.styles.push(f);
+      } else {
+        groups.core.push(f);
+      }
+    });
+
+    const suggestions = [];
+    if (groups.tests.length > 0) suggestions.push({ type: 'test', files: groups.tests, message: 'test: add/update tests' });
+    if (groups.config.length > 0) suggestions.push({ type: 'chore', files: groups.config, message: 'chore: update configuration' });
+    if (groups.docs.length > 0) suggestions.push({ type: 'docs', files: groups.docs, message: 'docs: update documentation' });
+    if (groups.styles.length > 0) suggestions.push({ type: 'style', files: groups.styles, message: 'style: update styles' });
+    if (groups.core.length > 0) suggestions.push({ type: 'feat', files: groups.core, message: 'feat: update core functionality' });
+
+    return suggestions.length > 1 ? suggestions : null;
+  }
+
+  /**
+   * Get session statistics
+   */
+  async getSessionStats() {
+    try {
+      const log = await this.git.log({ maxCount: 1 });
+      const lastCommit = log.all[0];
+      
+      let timeSinceLastCommit = 'No commits yet';
+      let lastCommitMessage = null;
+      
+      if (lastCommit) {
+        const lastCommitDate = new Date(lastCommit.date);
+        const now = new Date();
+        const diffMs = now - lastCommitDate;
+        const diffMins = Math.floor(diffMs / 60000);
+        const diffHours = Math.floor(diffMins / 60);
+        const diffDays = Math.floor(diffHours / 24);
+        
+        if (diffDays > 0) {
+          timeSinceLastCommit = `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+        } else if (diffHours > 0) {
+          timeSinceLastCommit = `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+        } else if (diffMins > 0) {
+          timeSinceLastCommit = `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`;
+        } else {
+          timeSinceLastCommit = 'Just now';
+        }
+        
+        lastCommitMessage = lastCommit.message.split('\n')[0];
+      }
+
+      // Get today's commits
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      const todayLog = await this.git.log({ '--since': today.toISOString() });
+      const todayCommits = todayLog.all.length;
+
+      return {
+        timeSinceLastCommit,
+        lastCommitMessage,
+        commitsToday: todayCommits,
+      };
+    } catch (error) {
+      return {
+        timeSinceLastCommit: 'Unknown',
+        lastCommitMessage: null,
+        commitsToday: 0,
+      };
+    }
+  }
+
+  /**
+   * Detect branch context for smarter commit messages
+   */
+  async detectBranchContext() {
+    try {
+      const branch = await this.git.branch();
+      const currentBranch = branch.current;
+      
+      // Common patterns: feat/xyz, fix/xyz, feature/xyz, bugfix/xyz, hotfix/xyz
+      const patterns = [
+        { regex: /^feat(?:ure)?\/(.+)$/i, type: 'feat', scope: null },
+        { regex: /^fix\/(.+)$/i, type: 'fix', scope: null },
+        { regex: /^bugfix\/(.+)$/i, type: 'fix', scope: null },
+        { regex: /^hotfix\/(.+)$/i, type: 'fix', scope: null },
+        { regex: /^docs?\/(.+)$/i, type: 'docs', scope: null },
+        { regex: /^refactor\/(.+)$/i, type: 'refactor', scope: null },
+        { regex: /^test\/(.+)$/i, type: 'test', scope: null },
+        { regex: /^chore\/(.+)$/i, type: 'chore', scope: null },
+        { regex: /^style\/(.+)$/i, type: 'style', scope: null },
+      ];
+
+      for (const pattern of patterns) {
+        const match = currentBranch.match(pattern.regex);
+        if (match) {
+          // Extract potential scope and description from branch name
+          const branchPart = match[1].replace(/-/g, ' ').replace(/_/g, ' ');
+          return {
+            branch: currentBranch,
+            type: pattern.type,
+            description: branchPart,
+            detected: true,
+          };
+        }
+      }
+
+      // Check for issue references like PROJ-123 or #123
+      const issueMatch = currentBranch.match(/([A-Z]+-\d+|#\d+)/i);
+      if (issueMatch) {
+        return {
+          branch: currentBranch,
+          issueRef: issueMatch[1],
+          detected: true,
+        };
+      }
+
+      return {
+        branch: currentBranch,
+        detected: false,
+      };
+    } catch (error) {
+      return { branch: 'unknown', detected: false };
+    }
+  }
+
+  /**
+   * Get commit statistics for the user
+   */
+  async getCommitStats(days = 30) {
+    try {
+      const since = new Date();
+      since.setDate(since.getDate() - days);
+      
+      const log = await this.git.log({ '--since': since.toISOString() });
+      const commits = log.all;
+      
+      if (commits.length === 0) {
+        return { totalCommits: 0, hasData: false };
+      }
+
+      // Group by day
+      const byDay = {};
+      commits.forEach(c => {
+        const day = new Date(c.date).toLocaleDateString();
+        byDay[day] = (byDay[day] || 0) + 1;
+      });
+
+      // Calculate streaks
+      const sortedDays = Object.keys(byDay).sort((a, b) => new Date(b) - new Date(a));
+      let currentStreak = 0;
+      let longestStreak = 0;
+      let tempStreak = 0;
+      
+      const today = new Date().toLocaleDateString();
+      const yesterday = new Date(Date.now() - 86400000).toLocaleDateString();
+      
+      // Check if today or yesterday has commits
+      if (byDay[today] || byDay[yesterday]) {
+        sortedDays.forEach((day, i) => {
+          if (i === 0) {
+            tempStreak = 1;
+          } else {
+            const prevDate = new Date(sortedDays[i - 1]);
+            const currDate = new Date(day);
+            const diffDays = Math.round((prevDate - currDate) / 86400000);
+            if (diffDays === 1) {
+              tempStreak++;
+            } else {
+              if (tempStreak > longestStreak) longestStreak = tempStreak;
+              tempStreak = 1;
+            }
+          }
+        });
+        if (tempStreak > longestStreak) longestStreak = tempStreak;
+        currentStreak = byDay[today] ? tempStreak : (byDay[yesterday] ? tempStreak : 0);
+      }
+
+      // Commit types breakdown
+      const typeBreakdown = { feat: 0, fix: 0, docs: 0, style: 0, refactor: 0, test: 0, chore: 0, other: 0 };
+      const conventionalPattern = /^(feat|fix|docs|style|refactor|test|chore|perf|build|ci|revert)/i;
+      
+      commits.forEach(c => {
+        const match = c.message.match(conventionalPattern);
+        if (match) {
+          const type = match[1].toLowerCase();
+          if (typeBreakdown.hasOwnProperty(type)) {
+            typeBreakdown[type]++;
+          } else {
+            typeBreakdown.other++;
+          }
+        } else {
+          typeBreakdown.other++;
+        }
+      });
+
+      return {
+        hasData: true,
+        totalCommits: commits.length,
+        daysActive: Object.keys(byDay).length,
+        avgPerDay: (commits.length / days).toFixed(1),
+        currentStreak,
+        longestStreak,
+        typeBreakdown,
+        topDay: Object.entries(byDay).sort((a, b) => b[1] - a[1])[0],
+      };
+    } catch (error) {
+      return { hasData: false, error: error.message };
+    }
+  }
+}
+
+module.exports = { Intelligence };

package/bin/lib/utils/progress.js

@@ -7,8 +7,11 @@ class Progress {
   static spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
   static current = 0;
   static interval = null;
+  static startTime = null;
 
   static start(message) {
+    this.startTime = Date.now();
+    this.lastMessage = message;
     process.stdout.write(`${message} ${this.spinner[0]}`);
     this.interval = setInterval(() => {
       this.current = (this.current + 1) % this.spinner.length;
@@ -21,7 +24,25 @@ class Progress {
       clearInterval(this.interval);
       this.interval = null;
     }
-    process.stdout.write(`\r${finalMessage}\n`);
+    const elapsed = this.getElapsed();
+    const elapsedStr = elapsed ? ` ${color.dim(`(${elapsed})`)}` : '';
+    // Clear the entire line before writing final message
+    const clearLine = '\r\x1b[K'; // Carriage return + clear to end of line
+    if (finalMessage) {
+      process.stdout.write(`${clearLine}${finalMessage}${elapsedStr}\n`);
+    } else {
+      // Just clear the spinner line completely
+      process.stdout.write(`${clearLine}`);
+    }
+    this.startTime = null;
+    this.lastMessage = null;
+  }
+
+  static getElapsed() {
+    if (!this.startTime) return null;
+    const ms = Date.now() - this.startTime;
+    if (ms < 1000) return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
   }
 
   static success(message) {
@@ -44,6 +65,54 @@ class Progress {
     const progress = `[${step}/${total}]`;
     console.log(`${color.dim(progress)} ${message}`);
   }
+
+  static cached(message) {
+    console.log(`${color.magenta('⚡')} ${message} ${color.dim('(cached)')}`);
+  }
+
+  static tip(message) {
+    console.log(`${color.blue('💡')} ${color.dim('Tip:')} ${message}`);
+  }
+
+  static box(title, lines) {
+    const maxLen = Math.max(title.length, ...lines.map(l => l.replace(/\x1b\[[0-9;]*m/g, '').length));
+    const top = `┌${'─'.repeat(maxLen + 2)}┐`;
+    const bottom = `└${'─'.repeat(maxLen + 2)}┘`;
+    const titleLine = `│ ${color.bold(title.padEnd(maxLen))} │`;
+
+    console.log(top);
+    console.log(titleLine);
+    console.log(`├${'─'.repeat(maxLen + 2)}┤`);
+    lines.forEach(line => {
+      const plainLen = line.replace(/\x1b\[[0-9;]*m/g, '').length;
+      const padding = ' '.repeat(maxLen - plainLen);
+      console.log(`│ ${line}${padding} │`);
+    });
+    console.log(bottom);
+  }
+
+  // Random tips for contextual help
+  static tips = [
+    'Use `g int` for interactive commit wizard with multiple AI suggestions',
+    'Use `g o` to commit and push in one command',
+    'Use `g sg --multiple` to get 3 different commit message suggestions',
+    'Configure your preferences with `g config --set key=value`',
+    'Use `--all` flag to auto-stage all changes',
+    'Use `g a` to amend your last commit',
+    'Use `g sync --rebase` for cleaner history',
+    'Set GEMINI_API_KEY for free AI-powered commits',
+    'Use `g wip` for quick work-in-progress commits',
+    'Use `g stats` to see your commit statistics',
+  ];
+
+  static showRandomTip() {
+    const shouldShow = Math.random() < 0.15; // 15% chance
+    if (shouldShow) {
+      const tip = this.tips[Math.floor(Math.random() * this.tips.length)];
+      console.log();
+      this.tip(tip);
+    }
+  }
 }
 
 module.exports = { Progress };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gims",
-  "version": "0.6.6",
-  "description": "Git Made Simple – AI‑powered git helper using Gemini / OpenAI",
+  "version": "0.8.1",
+  "description": "Git Made Simple – AI‑powered git helper with smart insights, stats & code review",
   "author": "S41R4J",
   "license": "MIT",
   "bin": {
@@ -43,4 +43,4 @@
     "test": "echo \"Enhanced GIMS v$(node -p \"require('./package.json').version\") - All systems operational!\"",
     "postinstall": "echo \"🚀 GIMS installed! Quick start: 'g setup --api-key gemini' then 'g s' to see status. Full help: 'g --help'\""
   }
-}
+}