git-creeper 1.0.1

package/src/index.js

@@ -0,0 +1,1235 @@
+const simpleGit = require('simple-git');
+const chalk = require('chalk');
+const { t } = require('./i18n');
+
+const git = simpleGit();
+
+async function timeline(options) {
+  const days = parseInt(options.days);
+  const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+  const title = `${t('timeline.title')} (${t('timeline.last')} ${days} ${t('stats.days')})`;
+  const titlePadding = Math.floor((60 - title.length) / 2);
+  
+  console.log(chalk.bold.cyan('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan(`║${' '.repeat(titlePadding)}${title}${' '.repeat(60 - title.length - titlePadding)}║`));
+  console.log(chalk.bold.cyan('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.log({
+    '--since': since.toISOString()
+  });
+
+  const commits = log.all;
+  
+  if (commits.length === 0) {
+    console.log(chalk.gray('No commits found in this time range.'));
+    return;
+  }
+
+  commits.forEach((commit, index) => {
+    const date = new Date(commit.date);
+    const timeAgo = getTimeAgo(date);
+    const type = commit.message.startsWith('feat') ? 'FEAT' : 
+                 commit.message.startsWith('fix') ? 'FIX' : 
+                 commit.message.startsWith('docs') ? 'DOCS' : 'OTHER';
+    
+    const typeColor = type === 'FEAT' ? chalk.green : 
+                      type === 'FIX' ? chalk.red : 
+                      type === 'DOCS' ? chalk.blue : chalk.gray;
+    
+    console.log(`${typeColor('[' + type.padEnd(5) + ']')} ${chalk.bold(commit.message)}`);
+    console.log(`         ${chalk.gray('Hash:')} ${chalk.white(commit.hash.substring(0, 7))}`);
+    console.log(`         ${chalk.gray('Author:')} ${chalk.cyan(commit.author_name)}`);
+    console.log(`         ${chalk.gray('Time:')} ${chalk.yellow(timeAgo)}`);
+    
+    if (index < commits.length - 1) {
+      console.log(chalk.gray('         │'));
+    } else {
+      console.log();
+    }
+  });
+}
+
+function getTimeAgo(date) {
+  const seconds = Math.floor((new Date() - date) / 1000);
+  const intervals = {
+    year: 31536000,
+    month: 2592000,
+    week: 604800,
+    day: 86400,
+    hour: 3600,
+    minute: 60
+  };
+  
+  for (const [unit, secondsInUnit] of Object.entries(intervals)) {
+    const interval = Math.floor(seconds / secondsInUnit);
+    if (interval >= 1) {
+      return `${interval} ${unit}${interval > 1 ? 's' : ''} ago`;
+    }
+  }
+  return 'just now';
+}
+
+async function hotspots(options) {
+  const limit = parseInt(options.limit);
+  const title = `${t('hotspots.title')} (${t('hotspots.top')} ${limit})`;
+  const titlePadding = Math.floor((60 - title.length) / 2);
+  
+  console.log(chalk.bold.red('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.red(`║${' '.repeat(titlePadding)}${title}${' '.repeat(60 - title.length - titlePadding)}║`));
+  console.log(chalk.bold.red('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.raw(['log', '--name-only', '--pretty=format:']);
+  const files = log.split('\n').filter(f => f.trim());
+  
+  const frequency = {};
+  files.forEach(file => {
+    frequency[file] = (frequency[file] || 0) + 1;
+  });
+  
+  const sorted = Object.entries(frequency)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, limit);
+  
+  const maxCount = sorted[0]?.[1] || 1;
+  
+  console.log(chalk.bold('RANK  FILE                                    CHANGES    IMPACT'));
+  console.log(chalk.gray('─'.repeat(60)));
+  
+  sorted.forEach(([file, count], i) => {
+    const barLength = Math.floor((count / maxCount) * 30);
+    const bar = '█'.repeat(barLength);
+    const percentage = ((count / maxCount) * 100).toFixed(0);
+    const rank = (i + 1).toString().padStart(4);
+    const fileShort = file.length > 35 ? '...' + file.slice(-32) : file.padEnd(35);
+    const countStr = count.toString().padStart(7);
+    
+    console.log(`${chalk.yellow(rank)}  ${chalk.cyan(fileShort)} ${chalk.white(countStr)}    ${chalk.red(bar)} ${chalk.gray(percentage + '%')}`);
+  });
+  console.log();
+}
+
+async function changelog(options) {
+  console.log(chalk.bold.green('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.green('║  📝  Smart Changelog                                       ║'));
+  console.log(chalk.bold.green('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const range = options.from ? `${options.from}..${options.to}` : options.to;
+  const log = await git.log([range]);
+  
+  const categories = {
+    feat: [],
+    fix: [],
+    docs: [],
+    other: []
+  };
+  
+  log.all.forEach(commit => {
+    const msg = commit.message;
+    if (msg.startsWith('feat')) categories.feat.push(msg);
+    else if (msg.startsWith('fix')) categories.fix.push(msg);
+    else if (msg.startsWith('docs')) categories.docs.push(msg);
+    else categories.other.push(msg);
+  });
+  
+  if (categories.feat.length) {
+    console.log(chalk.bold.green('┌─ ✨ Features'));
+    categories.feat.forEach((m, i) => {
+      const prefix = i === categories.feat.length - 1 ? '└─' : '├─';
+      console.log(chalk.green(`${prefix} ${m.replace('feat: ', '').replace('feat:', '')}`));
+    });
+    console.log();
+  }
+  
+  if (categories.fix.length) {
+    console.log(chalk.bold.red('┌─ 🐛 Bug Fixes'));
+    categories.fix.forEach((m, i) => {
+      const prefix = i === categories.fix.length - 1 ? '└─' : '├─';
+      console.log(chalk.red(`${prefix} ${m.replace('fix: ', '').replace('fix:', '')}`));
+    });
+    console.log();
+  }
+  
+  if (categories.docs.length) {
+    console.log(chalk.bold.blue('┌─ 📚 Documentation'));
+    categories.docs.forEach((m, i) => {
+      const prefix = i === categories.docs.length - 1 ? '└─' : '├─';
+      console.log(chalk.blue(`${prefix} ${m.replace('docs: ', '').replace('docs:', '')}`));
+    });
+    console.log();
+  }
+  
+  if (categories.other.length) {
+    console.log(chalk.bold.gray('┌─ 🔧 Other Changes'));
+    categories.other.forEach((m, i) => {
+      const prefix = i === categories.other.length - 1 ? '└─' : '├─';
+      console.log(chalk.gray(`${prefix} ${m}`));
+    });
+    console.log();
+  }
+}
+
+async function blameAnalysis(file) {
+  console.log(chalk.bold.magenta(`\n🔍 Blame Analysis: ${file}\n`));
+  
+  try {
+    const blame = await git.raw(['blame', '--line-porcelain', file]);
+    const lines = blame.split('\n');
+    
+    const authors = {};
+    let currentAuthor = null;
+    
+    lines.forEach(line => {
+      if (line.startsWith('author ')) {
+        currentAuthor = line.substring(7);
+        authors[currentAuthor] = (authors[currentAuthor] || 0) + 1;
+      }
+    });
+    
+    const sorted = Object.entries(authors).sort((a, b) => b[1] - a[1]);
+    const total = sorted.reduce((sum, [, count]) => sum + count, 0);
+    
+    console.log(chalk.bold('Contributors:\n'));
+    sorted.forEach(([author, lines]) => {
+      const percentage = ((lines / total) * 100).toFixed(1);
+      const bar = '█'.repeat(Math.floor(percentage / 2));
+      console.log(`${chalk.cyan(author)}`);
+      console.log(`  ${chalk.green(bar)} ${lines} lines (${percentage}%)\n`);
+    });
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+  }
+}
+
+
+
+function showHelp() {
+  const chalk = require('chalk');
+
+  console.log(chalk.bold.magenta('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta('║                     �️  GIT CREEPER v1.0.0                 ║'));
+  console.log(chalk.bold.magenta('║        Creep on your Git History with Smart Insights      ║'));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════════════════════════╝\n'));
+
+  console.log(chalk.bold('🚀 CORE COMMANDS:\n'));
+
+  console.log(chalk.cyan('  timeline') + chalk.gray('      View project evolution over time'));
+  console.log(chalk.gray('                git-creeper timeline --days 60\n'));
+
+  console.log(chalk.cyan('  stats') + chalk.gray('         Comprehensive repository statistics'));
+  console.log(chalk.gray('                git-creeper stats\n'));
+
+  console.log(chalk.cyan('  hotspots') + chalk.gray('      Find frequently changed files'));
+  console.log(chalk.gray('                git-creeper hotspots --limit 20\n'));
+
+  console.log(chalk.cyan('  contributors') + chalk.gray('  Analyze team member contributions'));
+  console.log(chalk.gray('                git-creeper contributors\n'));
+
+  console.log(chalk.bold('🔍 ANALYSIS TOOLS:\n'));
+
+  console.log(chalk.cyan('  changelog') + chalk.gray('     Generate organized changelog'));
+  console.log(chalk.gray('                git-creeper changelog --from v1.0.0 --to v2.0.0\n'));
+
+  console.log(chalk.cyan('  compare') + chalk.gray('       Compare branches or commits'));
+  console.log(chalk.gray('                git-creeper compare --from main --to develop\n'));
+
+  console.log(chalk.cyan('  search') + chalk.gray('        Search commits with filters'));
+  console.log(chalk.gray('                git-creeper search "bug" --author "John"\n'));
+
+  console.log(chalk.cyan('  blame-smart') + chalk.gray('   Analyze file contributors'));
+  console.log(chalk.gray('                git-creeper blame-smart src/index.js\n'));
+
+  console.log(chalk.bold('🤖 SMART FEATURES:\n'));
+
+  console.log(chalk.cyan('  smart-commit') + chalk.gray('   Get smart commit message suggestions'));
+  console.log(chalk.gray('                git-creeper smart-commit\n'));
+
+  console.log(chalk.cyan('  review') + chalk.gray('        Pattern-based code review'));
+  console.log(chalk.gray('                git-creeper review\n'));
+
+  console.log(chalk.cyan('  bug-risk') + chalk.gray('      Predict files with high bug risk'));
+  console.log(chalk.gray('                git-creeper bug-risk\n'));
+
+  console.log(chalk.cyan('  refactor') + chalk.gray('      Get code quality suggestions'));
+  console.log(chalk.gray('                git-creeper refactor\n'));
+
+  console.log(chalk.bold('📊 INSIGHTS & REPORTS:\n'));
+
+  console.log(chalk.cyan('  insights') + chalk.gray('      Get smart recommendations'));
+  console.log(chalk.gray('                git-creeper insights\n'));
+
+  console.log(chalk.cyan('  visualize') + chalk.gray('     Show ASCII visualizations'));
+  console.log(chalk.gray('                git-creeper visualize --type heatmap\n'));
+
+  console.log(chalk.cyan('  export') + chalk.gray('        Export data to file'));
+  console.log(chalk.gray('                git-creeper export --format markdown\n'));
+
+  console.log(chalk.cyan('  lang') + chalk.gray('          Set default language (en, tr)'));
+  console.log(chalk.gray('                git-creeper lang tr\n'));
+
+  console.log(chalk.bold('⚙️  OPTIONS:\n'));
+  console.log(chalk.gray('  -v, --version    Display version number'));
+  console.log(chalk.gray('  -h, --help       Show command help\n'));
+
+  console.log(chalk.bold('💡 TIPS:\n'));
+  console.log(chalk.gray('  • Use conventional commits (feat:, fix:, docs:) for better results'));
+  console.log(chalk.gray('  • Run "git-creeper insights" regularly for code quality recommendations'));
+  console.log(chalk.gray('  • Try smart features: smart-commit, review, bug-risk, refactor'));
+  console.log(chalk.gray('  • Export reports for team meetings and stakeholder updates'));
+  console.log(chalk.gray('  • Set your preferred language once with "git-creeper lang tr"\n'));
+
+  console.log(chalk.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.dim('Made with ❤️  by @levantedev | MIT License'));
+  console.log(chalk.dim('npm: npmjs.com/package/git-creeper'));
+  console.log(chalk.dim('GitHub: github.com/levantedev/git-creeper\n'));
+}
+
+
+
+module.exports = { timeline, hotspots, changelog, blameAnalysis, showHelp };
+
+async function stats() {
+  const title = t('stats.title');
+  const titlePadding = Math.floor((60 - title.length) / 2);
+  
+  console.log(chalk.bold.blue('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.blue(`║${' '.repeat(titlePadding)}${title}${' '.repeat(60 - title.length - titlePadding)}║`));
+  console.log(chalk.bold.blue('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.log();
+  const commits = log.all;
+  
+  if (commits.length === 0) {
+    console.log(chalk.gray(t('timeline.noCommits')));
+    return;
+  }
+  
+  // Date range
+  const firstCommit = new Date(commits[commits.length - 1].date);
+  const lastCommit = new Date(commits[0].date);
+  const daysDiff = Math.floor((lastCommit - firstCommit) / (1000 * 60 * 60 * 24));
+  
+  // Average message length
+  const avgMessageLength = commits.reduce((sum, c) => sum + c.message.length, 0) / commits.length;
+  
+  // Contributors
+  const contributors = {};
+  commits.forEach(c => {
+    contributors[c.author_name] = (contributors[c.author_name] || 0) + 1;
+  });
+  
+  // Commit types
+  const types = { feat: 0, fix: 0, docs: 0, other: 0 };
+  commits.forEach(c => {
+    if (c.message.startsWith('feat')) types.feat++;
+    else if (c.message.startsWith('fix')) types.fix++;
+    else if (c.message.startsWith('docs')) types.docs++;
+    else types.other++;
+  });
+  
+  // Activity by day and hour
+  const days = {};
+  const hours = {};
+  const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+  
+  commits.forEach(c => {
+    const date = new Date(c.date);
+    const day = dayNames[date.getDay()];
+    const hour = date.getHours();
+    days[day] = (days[day] || 0) + 1;
+    hours[hour] = (hours[hour] || 0) + 1;
+  });
+  
+  const mostActiveDay = Object.entries(days).sort((a, b) => b[1] - a[1])[0];
+  const peakHour = Object.entries(hours).sort((a, b) => b[1] - a[1])[0];
+  const topContributor = Object.entries(contributors).sort((a, b) => b[1] - a[1])[0];
+  
+  // Display in clean table format
+  console.log(chalk.bold(t('stats.overview')));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  ${t('stats.totalCommits').padEnd(25)} ${chalk.cyan(commits.length.toString().padStart(10))}`);
+  console.log(`  ${t('stats.repoAge').padEnd(25)} ${chalk.cyan((daysDiff + ' ' + t('stats.days')).padStart(10))}`);
+  console.log(`  ${t('stats.commitsPerDay').padEnd(25)} ${chalk.cyan((commits.length / Math.max(daysDiff, 1)).toFixed(2).padStart(10))}`);
+  console.log(`  ${t('stats.avgMessageLength').padEnd(25)} ${chalk.cyan((avgMessageLength.toFixed(0) + ' ' + t('stats.chars')).padStart(10))}`);
+  console.log();
+  
+  console.log(chalk.bold(t('stats.contributors')));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  ${t('stats.totalContributors').padEnd(25)} ${chalk.cyan(Object.keys(contributors).length.toString().padStart(10))}`);
+  console.log(`  ${t('stats.mostProductive').padEnd(25)} ${chalk.cyan(topContributor[0].padStart(10))}`);
+  console.log(`  ${t('stats.theirCommits').padEnd(25)} ${chalk.cyan(topContributor[1].toString().padStart(10))}`);
+  console.log();
+  
+  console.log(chalk.bold(t('stats.commitTypes')));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  ${t('stats.features').padEnd(25)} ${chalk.green(types.feat.toString().padStart(10))}`);
+  console.log(`  ${t('stats.bugFixes').padEnd(25)} ${chalk.red(types.fix.toString().padStart(10))}`);
+  console.log(`  ${t('stats.documentation').padEnd(25)} ${chalk.blue(types.docs.toString().padStart(10))}`);
+  console.log(`  ${t('stats.other').padEnd(25)} ${chalk.gray(types.other.toString().padStart(10))}`);
+  console.log();
+  
+  console.log(chalk.bold(t('stats.activityPatterns')));
+  console.log(chalk.gray('─'.repeat(60)));
+  console.log(`  ${t('stats.mostActiveDay').padEnd(25)} ${chalk.yellow(mostActiveDay[0].padStart(10))} (${mostActiveDay[1]} ${t('stats.commits')})`);
+  console.log(`  ${t('stats.peakHour').padEnd(25)} ${chalk.yellow((peakHour[0] + ':00').padStart(10))} (${peakHour[1]} ${t('stats.commits')})`);
+  console.log();
+}
+
+async function contributors() {
+  const title = t('contributors.title');
+  const titlePadding = Math.floor((60 - title.length) / 2);
+  
+  console.log(chalk.bold.magenta('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta(`║${' '.repeat(titlePadding)}${title}${' '.repeat(60 - title.length - titlePadding)}║`));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.log();
+  const commits = log.all;
+  
+  const contributorData = {};
+  
+  // Get commit data
+  commits.forEach(c => {
+    if (!contributorData[c.author_name]) {
+      contributorData[c.author_name] = {
+        commits: 0,
+        firstCommit: c.date,
+        lastCommit: c.date,
+        insertions: 0,
+        deletions: 0
+      };
+    }
+    contributorData[c.author_name].commits++;
+    contributorData[c.author_name].lastCommit = c.date;
+  });
+  
+  const sorted = Object.entries(contributorData).sort((a, b) => b[1].commits - a[1].commits);
+  const totalCommits = commits.length;
+  
+  console.log(chalk.bold('RANK  CONTRIBUTOR              COMMITS    SHARE      LAST ACTIVE'));
+  console.log(chalk.gray('─'.repeat(60)));
+  
+  sorted.forEach(([name, data], i) => {
+    const percentage = ((data.commits / totalCommits) * 100).toFixed(1);
+    const barLength = Math.floor((data.commits / sorted[0][1].commits) * 20);
+    const bar = '█'.repeat(barLength);
+    const rank = (i + 1).toString().padStart(4);
+    const nameShort = name.length > 20 ? name.substring(0, 17) + '...' : name.padEnd(20);
+    const commitStr = data.commits.toString().padStart(7);
+    const shareStr = (percentage + '%').padStart(7);
+    const lastActive = getTimeAgo(new Date(data.lastCommit));
+    
+    console.log(`${chalk.yellow(rank)}  ${chalk.cyan(nameShort)} ${chalk.white(commitStr)}    ${chalk.magenta(bar)}${shareStr.padStart(10 - barLength)}    ${chalk.gray(lastActive)}`);
+  });
+  console.log();
+}
+
+async function compare(options) {
+  const from = options.from || 'HEAD~10';
+  const to = options.to || 'HEAD';
+  
+  console.log(chalk.bold.yellow('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.yellow(`║  🔄  Compare: ${from} → ${to}`.padEnd(61) + '║'));
+  console.log(chalk.bold.yellow('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  try {
+    const diff = await git.diffSummary([from, to]);
+    const log = await git.log([`${from}..${to}`]);
+    
+    console.log(chalk.bold('📊 Summary:'));
+    console.log(`   Files Changed: ${chalk.cyan(diff.files.length)}`);
+    console.log(`   Insertions: ${chalk.green('+' + diff.insertions)}`);
+    console.log(`   Deletions: ${chalk.red('-' + diff.deletions)}`);
+    console.log(`   Commits: ${chalk.yellow(log.all.length)}\n`);
+    
+    // Who did what
+    console.log(chalk.bold('👥 Contributors:\n'));
+    const authorChanges = {};
+    log.all.forEach(commit => {
+      if (!authorChanges[commit.author_name]) {
+        authorChanges[commit.author_name] = 0;
+      }
+      authorChanges[commit.author_name]++;
+    });
+    
+    Object.entries(authorChanges).sort((a, b) => b[1] - a[1]).forEach(([author, count]) => {
+      console.log(`   ${chalk.cyan(author)}: ${chalk.yellow(count + ' commits')}`);
+    });
+    console.log();
+    
+    console.log(chalk.bold('📁 Changed Files:\n'));
+    
+    diff.files.slice(0, 15).forEach(file => {
+      const changes = file.insertions + file.deletions;
+      const barLength = Math.min(Math.floor(changes / 2), 30);
+      const bar = '█'.repeat(barLength);
+      
+      console.log(chalk.cyan(file.file));
+      console.log(`   ${chalk.green('+' + file.insertions)} ${chalk.red('-' + file.deletions)} ${chalk.gray(bar)}\n`);
+    });
+    
+    if (diff.files.length > 15) {
+      console.log(chalk.gray(`   ... and ${diff.files.length - 15} more files\n`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+  }
+}
+
+async function search(query, options) {
+  console.log(chalk.bold.green('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.green(`║  🔍  Search: "${query}"`.padEnd(61) + '║'));
+  console.log(chalk.bold.green('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const logOptions = ['--all', '--grep=' + query, '-i'];
+  if (options.author) logOptions.push('--author=' + options.author);
+  if (options.since) logOptions.push('--since=' + options.since);
+  
+  const log = await git.log(logOptions);
+  const commits = log.all;
+  
+  if (commits.length === 0) {
+    console.log(chalk.gray('No commits found matching your search.\n'));
+    return;
+  }
+  
+  console.log(chalk.bold(`Found ${chalk.cyan(commits.length)} commits:\n`));
+  
+  commits.slice(0, 20).forEach(commit => {
+    const icon = commit.message.startsWith('feat') ? '✨' : 
+                 commit.message.startsWith('fix') ? '🐛' : 
+                 commit.message.startsWith('docs') ? '📚' : '🔧';
+    
+    console.log(`${icon} ${chalk.bold(commit.message)}`);
+    console.log(`   ${chalk.gray(commit.hash.substring(0, 7))} by ${chalk.cyan(commit.author_name)} - ${chalk.yellow(getTimeAgo(new Date(commit.date)))}`);
+    
+    // Show files changed in this commit
+    console.log(chalk.gray(`   Files: ${commit.diff?.files?.length || 'N/A'}\n`));
+  });
+  
+  if (commits.length > 20) {
+    console.log(chalk.gray(`... and ${commits.length - 20} more results\n`));
+  }
+  
+  // Search in specific file if needed
+  console.log(chalk.dim('💡 Tip: Use --author "name" or --since "2 weeks ago" to filter results\n'));
+}
+
+async function insights() {
+  console.log(chalk.bold.magenta('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta('║  💡  Smart Insights                                        ║'));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.log();
+  const commits = log.all;
+  
+  const insights = [];
+  
+  // Check recent activity
+  const lastCommit = new Date(commits[0].date);
+  const daysSinceLastCommit = Math.floor((new Date() - lastCommit) / (1000 * 60 * 60 * 24));
+  
+  if (daysSinceLastCommit > 7) {
+    insights.push({
+      type: 'warning',
+      icon: '⚠️',
+      message: `No commits in the last ${daysSinceLastCommit} days. Project might be inactive.`
+    });
+  } else if (daysSinceLastCommit === 0) {
+    insights.push({
+      type: 'success',
+      icon: '✅',
+      message: 'Active development! Commits made today.'
+    });
+  }
+  
+  // Check hotspots
+  const fileLog = await git.raw(['log', '--name-only', '--pretty=format:']);
+  const files = fileLog.split('\n').filter(f => f.trim());
+  const frequency = {};
+  files.forEach(file => {
+    frequency[file] = (frequency[file] || 0) + 1;
+  });
+  
+  const hotFiles = Object.entries(frequency).filter(([, count]) => count > 10);
+  if (hotFiles.length > 0) {
+    insights.push({
+      type: 'info',
+      icon: '🔥',
+      message: `${hotFiles.length} files changed more than 10 times. Consider refactoring.`
+    });
+  }
+  
+  // Check commit message quality
+  const shortMessages = commits.filter(c => c.message.length < 10).length;
+  if (shortMessages > commits.length * 0.3) {
+    insights.push({
+      type: 'warning',
+      icon: '📝',
+      message: `${((shortMessages / commits.length) * 100).toFixed(0)}% of commits have short messages. Use descriptive commit messages.`
+    });
+  }
+  
+  // Check conventional commits
+  const conventionalCommits = commits.filter(c => 
+    c.message.startsWith('feat') || 
+    c.message.startsWith('fix') || 
+    c.message.startsWith('docs')
+  ).length;
+  
+  if (conventionalCommits < commits.length * 0.5) {
+    insights.push({
+      type: 'info',
+      icon: '💡',
+      message: 'Consider using conventional commits (feat:, fix:, docs:) for better changelogs.'
+    });
+  } else {
+    insights.push({
+      type: 'success',
+      icon: '🎉',
+      message: `${((conventionalCommits / commits.length) * 100).toFixed(0)}% of commits follow conventional format. Great job!`
+    });
+  }
+  
+  // Display insights
+  insights.forEach(insight => {
+    const color = insight.type === 'warning' ? chalk.yellow :
+                  insight.type === 'success' ? chalk.green :
+                  chalk.blue;
+    
+    console.log(`${insight.icon}  ${color(insight.message)}\n`);
+  });
+  
+  if (insights.length === 0) {
+    console.log(chalk.green('✨ Everything looks good! Keep up the great work.\n'));
+  }
+}
+
+module.exports = { 
+  timeline, 
+  hotspots, 
+  changelog, 
+  blameAnalysis, 
+  showHelp,
+  stats,
+  contributors,
+  compare,
+  search,
+  insights,
+  exportData,
+  visualize,
+  setLang
+};
+
+async function setLang(locale) {
+  const chalk = require('chalk');
+  const { setLanguage } = require('./config');
+  const { setLocale } = require('./i18n');
+  
+  const validLocales = ['en', 'tr', 'auto'];
+  
+  if (!validLocales.includes(locale)) {
+    console.log(chalk.red(`\n✗ Invalid language: ${locale}`));
+    console.log(chalk.gray(`  Valid options: ${validLocales.join(', ')}\n`));
+    return;
+  }
+  
+  if (setLanguage(locale)) {
+    if (locale === 'auto') {
+      console.log(chalk.green('\n✓ Language set to auto-detect'));
+    } else {
+      setLocale(locale);
+      console.log(chalk.green(`\n✓ Language set to: ${locale}`));
+    }
+    console.log(chalk.gray(`  Config saved to: ~/.git-creeper/config.json\n`));
+  } else {
+    console.log(chalk.red('\n✗ Failed to save language preference\n'));
+  }
+}
+
+async function exportData(options) {
+  const format = options.format || 'json';
+  const output = options.output || 'git-creeper-report';
+  
+  console.log(chalk.bold.cyan(`\n📦 Exporting data to ${format.toUpperCase()} format...\n`));
+  
+  const log = await git.log();
+  const commits = log.all;
+  
+  // Gather all data
+  const data = {
+    summary: {
+      totalCommits: commits.length,
+      firstCommit: commits[commits.length - 1]?.date,
+      lastCommit: commits[0]?.date,
+      contributors: {}
+    },
+    commits: commits.slice(0, 100).map(c => ({
+      hash: c.hash,
+      message: c.message,
+      author: c.author_name,
+      date: c.date
+    }))
+  };
+  
+  commits.forEach(c => {
+    data.summary.contributors[c.author_name] = (data.summary.contributors[c.author_name] || 0) + 1;
+  });
+  
+  const fs = require('fs');
+  
+  if (format === 'json') {
+    const filename = `${output}.json`;
+    fs.writeFileSync(filename, JSON.stringify(data, null, 2));
+    console.log(chalk.green(`✅ Exported to ${filename}\n`));
+  } else if (format === 'markdown') {
+    const filename = `${output}.md`;
+    let md = `# Git-Creeper Report\n\n`;
+    md += `## Summary\n\n`;
+    md += `- Total Commits: ${data.summary.totalCommits}\n`;
+    md += `- Contributors: ${Object.keys(data.summary.contributors).length}\n\n`;
+    md += `## Top Contributors\n\n`;
+    Object.entries(data.summary.contributors)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 10)
+      .forEach(([name, count]) => {
+        md += `- ${name}: ${count} commits\n`;
+      });
+    md += `\n## Recent Commits\n\n`;
+    data.commits.slice(0, 20).forEach(c => {
+      md += `- **${c.message}** (${c.hash.substring(0, 7)}) by ${c.author}\n`;
+    });
+    fs.writeFileSync(filename, md);
+    console.log(chalk.green(`✅ Exported to ${filename}\n`));
+  } else if (format === 'html') {
+    const filename = `${output}.html`;
+    let html = `<!DOCTYPE html>
+<html>
+<head>
+  <title>Git Story Report</title>
+  <style>
+    body { font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; background: #f5f5f5; }
+    h1 { color: #333; }
+    .summary { background: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; }
+    .commit { background: white; padding: 15px; border-radius: 8px; margin-bottom: 10px; }
+    .hash { color: #666; font-family: monospace; }
+    .author { color: #0066cc; }
+  </style>
+</head>
+<body>
+  <h1>📖 Git Story Report</h1>
+  <div class="summary">
+    <h2>Summary</h2>
+    <p>Total Commits: <strong>${data.summary.totalCommits}</strong></p>
+    <p>Contributors: <strong>${Object.keys(data.summary.contributors).length}</strong></p>
+  </div>
+  <h2>Recent Commits</h2>`;
+    data.commits.slice(0, 20).forEach(c => {
+      html += `
+  <div class="commit">
+    <strong>${c.message}</strong><br>
+    <span class="hash">${c.hash.substring(0, 7)}</span> by <span class="author">${c.author}</span>
+  </div>`;
+    });
+    html += `
+</body>
+</html>`;
+    fs.writeFileSync(filename, html);
+    console.log(chalk.green(`✅ Exported to ${filename}\n`));
+  }
+}
+
+async function visualize(options) {
+  const type = options.type || 'frequency';
+  
+  console.log(chalk.bold.magenta('\n╔════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.bold.magenta(`║  📊  Visualization: ${type}`.padEnd(61) + '║'));
+  console.log(chalk.bold.magenta('╚════════════════════════════════════════════════════════════╝\n'));
+  
+  const log = await git.log();
+  const commits = log.all;
+  
+  if (type === 'frequency') {
+    // Commit frequency over last 30 days
+    console.log(chalk.bold('📈 Commit Frequency (Last 30 Days)\n'));
+    
+    const days = 30;
+    const frequency = Array(days).fill(0);
+    const now = new Date();
+    
+    commits.forEach(c => {
+      const commitDate = new Date(c.date);
+      const daysAgo = Math.floor((now - commitDate) / (1000 * 60 * 60 * 24));
+      if (daysAgo < days) {
+        frequency[days - 1 - daysAgo]++;
+      }
+    });
+    
+    const maxFreq = Math.max(...frequency, 1);
+    
+    frequency.forEach((count, i) => {
+      const daysAgo = days - i;
+      const barLength = Math.floor((count / maxFreq) * 40);
+      const bar = '█'.repeat(barLength);
+      const color = count === 0 ? chalk.gray : count > maxFreq * 0.7 ? chalk.green : chalk.yellow;
+      console.log(`${String(daysAgo).padStart(2)}d ago: ${color(bar)} ${count}`);
+    });
+    console.log();
+    
+  } else if (type === 'heatmap') {
+    // Contributor activity heatmap
+    console.log(chalk.bold('🔥 Contributor Activity Heatmap (Last 7 Days)\n'));
+    
+    const contributors = {};
+    const days = 7;
+    const now = new Date();
+    
+    commits.forEach(c => {
+      const commitDate = new Date(c.date);
+      const daysAgo = Math.floor((now - commitDate) / (1000 * 60 * 60 * 24));
+      if (daysAgo < days) {
+        if (!contributors[c.author_name]) {
+          contributors[c.author_name] = Array(days).fill(0);
+        }
+        contributors[c.author_name][days - 1 - daysAgo]++;
+      }
+    });
+    
+    const dayLabels = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+    console.log('         ' + dayLabels.map(d => d.padEnd(4)).join(''));
+    
+    Object.entries(contributors).forEach(([name, activity]) => {
+      const nameShort = name.substring(0, 8).padEnd(8);
+      const heatmap = activity.map(count => {
+        if (count === 0) return chalk.gray('░░░░');
+        if (count <= 2) return chalk.yellow('▒▒▒▒');
+        if (count <= 5) return chalk.yellow('▓▓▓▓');
+        return chalk.red('████');
+      }).join('');
+      console.log(`${nameShort} ${heatmap}`);
+    });
+    console.log();
+    
+  } else if (type === 'trends') {
+    // File change trends
+    console.log(chalk.bold('📁 File Change Trends (Top 10 Files)\n'));
+    
+    const fileLog = await git.raw(['log', '--name-only', '--pretty=format:']);
+    const files = fileLog.split('\n').filter(f => f.trim());
+    const frequency = {};
+    
+    files.forEach(file => {
+      frequency[file] = (frequency[file] || 0) + 1;
+    });
+    
+    const sorted = Object.entries(frequency).sort((a, b) => b[1] - a[1]).slice(0, 10);
+    const maxCount = sorted[0]?.[1] || 1;
+    
+    sorted.forEach(([file, count]) => {
+      const barLength = Math.floor((count / maxCount) * 40);
+      const bar = '█'.repeat(barLength);
+      const fileShort = file.length > 30 ? '...' + file.slice(-27) : file.padEnd(30);
+      console.log(`${chalk.cyan(fileShort)} ${chalk.red(bar)} ${count}`);
+    });
+    console.log();
+  }
+  
+  console.log(chalk.dim('💡 Try: --type frequency, --type heatmap, or --type trends\n'));
+}
+
+// AI-Powered Features
+async function smartCommitMessage() {
+  const { t } = require('./i18n');
+
+  try {
+    const git = simpleGit();
+    const status = await git.status();
+
+    if (status.files.length === 0) {
+      console.log(chalk.yellow(t('ai.noChanges')));
+      return;
+    }
+
+    console.log(chalk.blue.bold(t('ai.smartCommitTitle')));
+    console.log('─'.repeat(60));
+
+    // Analyze changed files
+    const changedFiles = status.files;
+    const suggestions = await analyzeChangesForCommit(changedFiles);
+
+    console.log(chalk.green('📝 ' + t('ai.suggestedMessages') + ':'));
+    suggestions.forEach((msg, index) => {
+      console.log(chalk.cyan(`${index + 1}. ${msg}`));
+    });
+
+    console.log('\n' + chalk.gray(t('ai.commitTip')));
+
+  } catch (error) {
+    console.error(chalk.red(t('error') + ':'), error.message);
+  }
+}
+
+
+async function analyzeChangesForCommit(files) {
+  const suggestions = [];
+
+  // Analyze file patterns
+  const hasNewFiles = files.some(f => f.index === 'A');
+  const hasDeletedFiles = files.some(f => f.working_dir === 'D');
+  const hasModifiedFiles = files.some(f => f.working_dir === 'M');
+
+  // Check file types
+  const jsFiles = files.filter(f => f.path.endsWith('.js') || f.path.endsWith('.ts'));
+  const cssFiles = files.filter(f => f.path.endsWith('.css') || f.path.endsWith('.scss'));
+  const configFiles = files.filter(f => f.path.includes('config') || f.path.includes('package.json'));
+  const testFiles = files.filter(f => f.path.includes('test') || f.path.includes('spec'));
+
+  // Generate smart suggestions
+  if (testFiles.length > 0) {
+    suggestions.push('test: add unit tests for new features');
+    suggestions.push('test: update test cases');
+  }
+
+  if (configFiles.length > 0) {
+    suggestions.push('config: update project configuration');
+    suggestions.push('chore: update dependencies');
+  }
+
+  if (hasNewFiles && jsFiles.length > 0) {
+    suggestions.push('feat: add new component/module');
+    suggestions.push('feat: implement new functionality');
+  }
+
+  if (hasModifiedFiles && jsFiles.length > 0) {
+    suggestions.push('fix: resolve bug in core functionality');
+    suggestions.push('refactor: improve code structure');
+    suggestions.push('perf: optimize performance');
+  }
+
+  if (cssFiles.length > 0) {
+    suggestions.push('style: update UI components');
+    suggestions.push('style: improve responsive design');
+  }
+
+  if (hasDeletedFiles) {
+    suggestions.push('refactor: remove unused code');
+    suggestions.push('cleanup: remove deprecated files');
+  }
+
+  // Default suggestions
+  if (suggestions.length === 0) {
+    suggestions.push('feat: add new feature');
+    suggestions.push('fix: resolve issue');
+    suggestions.push('docs: update documentation');
+    suggestions.push('refactor: improve code quality');
+  }
+
+  return suggestions.slice(0, 5); // Return top 5 suggestions
+}
+
+async function codeReviewAssistant() {
+  const { t } = require('./i18n');
+
+  try {
+    const git = simpleGit();
+    const diff = await git.diff(['--cached']);
+
+    if (!diff) {
+      console.log(chalk.yellow(t('noStagedChanges')));
+      return;
+    }
+
+    console.log(chalk.blue.bold(t('codeReviewTitle')));
+    console.log('─'.repeat(60));
+
+    const issues = await analyzeCodeForReview(diff);
+
+    if (issues.length === 0) {
+      console.log(chalk.green('✅ ' + t('noIssuesFound')));
+      return;
+    }
+
+    console.log(chalk.yellow('⚠️  ' + t('foundIssues') + ':'));
+    issues.forEach((issue, index) => {
+      console.log(chalk.red(`${index + 1}. ${issue.type}: ${issue.message}`));
+      if (issue.suggestion) {
+        console.log(chalk.gray(`   💡 ${issue.suggestion}`));
+      }
+    });
+
+  } catch (error) {
+    console.error(chalk.red(t('error') + ':'), error.message);
+  }
+}
+
+async function analyzeCodeForReview(diff) {
+  const issues = [];
+  const lines = diff.split('\n');
+
+  lines.forEach((line, index) => {
+    if (line.startsWith('+')) {
+      const code = line.substring(1).trim();
+
+      // Check for common issues
+      if (code.includes('console.log')) {
+        issues.push({
+          type: 'Debug Code',
+          message: 'Console.log statement found',
+          suggestion: 'Remove debug statements before commit'
+        });
+      }
+
+      if (code.includes('TODO') || code.includes('FIXME')) {
+        issues.push({
+          type: 'TODO/FIXME',
+          message: 'Unresolved TODO or FIXME comment',
+          suggestion: 'Complete the task or create an issue'
+        });
+      }
+
+      if (code.length > 120) {
+        issues.push({
+          type: 'Long Line',
+          message: 'Line exceeds 120 characters',
+          suggestion: 'Break long lines for better readability'
+        });
+      }
+
+      if (code.includes('var ')) {
+        issues.push({
+          type: 'Deprecated Syntax',
+          message: 'Use of var instead of let/const',
+          suggestion: 'Use let or const for better scoping'
+        });
+      }
+
+      if (code.includes('==') && !code.includes('===')) {
+        issues.push({
+          type: 'Loose Equality',
+          message: 'Use of == instead of ===',
+          suggestion: 'Use strict equality (===) for type safety'
+        });
+      }
+    }
+  });
+
+  return issues;
+}
+
+async function bugPrediction() {
+  const { t } = require('./i18n');
+
+  try {
+    const git = simpleGit();
+    const logs = await git.log(['--since=3 months ago', '--pretty=format:%H|%s|%an|%ad']);
+
+    console.log(chalk.blue.bold(t('bugPredictionTitle')));
+    console.log('─'.repeat(60));
+
+    const riskAnalysis = await analyzeBugRisk(logs.all);
+
+    console.log(chalk.red('🚨 ' + t('highRiskFiles') + ':'));
+    riskAnalysis.highRisk.forEach(file => {
+      console.log(chalk.red(`  • ${file.path} (Risk: ${file.score}%)`));
+      console.log(chalk.gray(`    ${file.reason}`));
+    });
+
+    console.log('\n' + chalk.yellow('⚠️  ' + t('mediumRiskFiles') + ':'));
+    riskAnalysis.mediumRisk.forEach(file => {
+      console.log(chalk.yellow(`  • ${file.path} (Risk: ${file.score}%)`));
+      console.log(chalk.gray(`    ${file.reason}`));
+    });
+
+  } catch (error) {
+    console.error(chalk.red(t('error') + ':'), error.message);
+  }
+}
+
+async function analyzeBugRisk(commits) {
+  const fileStats = {};
+  const bugKeywords = ['fix', 'bug', 'error', 'issue', 'problem', 'crash'];
+
+  // Analyze commit patterns
+  for (const commit of commits) {
+    const message = commit.message.toLowerCase();
+    const isBugFix = bugKeywords.some(keyword => message.includes(keyword));
+
+    if (isBugFix) {
+      try {
+        const git = simpleGit();
+        const files = await git.show(['--name-only', commit.hash]);
+        const changedFiles = files.split('\n').filter(f => f.trim());
+
+        changedFiles.forEach(file => {
+          if (!fileStats[file]) {
+            fileStats[file] = { bugFixes: 0, totalChanges: 0 };
+          }
+          fileStats[file].bugFixes++;
+          fileStats[file].totalChanges++;
+        });
+      } catch (error) {
+        // Skip if commit not accessible
+      }
+    }
+  }
+
+  // Calculate risk scores
+  const riskFiles = Object.entries(fileStats)
+    .map(([path, stats]) => ({
+      path,
+      score: Math.round((stats.bugFixes / stats.totalChanges) * 100),
+      reason: `${stats.bugFixes} bug fixes out of ${stats.totalChanges} changes`
+    }))
+    .sort((a, b) => b.score - a.score);
+
+  return {
+    highRisk: riskFiles.filter(f => f.score >= 50),
+    mediumRisk: riskFiles.filter(f => f.score >= 25 && f.score < 50)
+  };
+}
+
+async function refactorSuggestions() {
+  const { t } = require('./i18n');
+
+  try {
+    console.log(chalk.blue.bold(t('refactorTitle')));
+    console.log('─'.repeat(60));
+
+    const suggestions = await analyzeCodeQuality();
+
+    if (suggestions.length === 0) {
+      console.log(chalk.green('✅ ' + t('codeQualityGood')));
+      return;
+    }
+
+    console.log(chalk.yellow('💡 ' + t('refactorSuggestions') + ':'));
+    suggestions.forEach((suggestion, index) => {
+      console.log(chalk.cyan(`${index + 1}. ${suggestion.title}`));
+      console.log(chalk.gray(`   📁 ${suggestion.file}`));
+      console.log(chalk.gray(`   📝 ${suggestion.description}`));
+      console.log(chalk.gray(`   🎯 ${suggestion.benefit}`));
+      console.log('');
+    });
+
+  } catch (error) {
+    console.error(chalk.red(t('error') + ':'), error.message);
+  }
+}
+
+async function analyzeCodeQuality() {
+  const suggestions = [];
+  const fs = require('fs');
+  const path = require('path');
+
+  // Find JavaScript/TypeScript files
+  const findFiles = (dir, fileList = []) => {
+    const files = fs.readdirSync(dir);
+
+    files.forEach(file => {
+      const filePath = path.join(dir, file);
+      const stat = fs.statSync(filePath);
+
+      if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+        findFiles(filePath, fileList);
+      } else if (file.endsWith('.js') || file.endsWith('.ts')) {
+        fileList.push(filePath);
+      }
+    });
+
+    return fileList;
+  };
+
+  try {
+    const files = findFiles('.');
+
+    for (const file of files) {
+      const content = fs.readFileSync(file, 'utf8');
+      const lines = content.split('\n');
+
+      // Check file size
+      if (lines.length > 300) {
+        suggestions.push({
+          title: 'Large File Detected',
+          file: file,
+          description: `File has ${lines.length} lines, consider splitting into smaller modules`,
+          benefit: 'Improves maintainability and readability'
+        });
+      }
+
+      // Check for long functions
+      let functionLines = 0;
+      let inFunction = false;
+
+      lines.forEach(line => {
+        if (line.includes('function') || line.includes('=>')) {
+          inFunction = true;
+          functionLines = 0;
+        }
+        if (inFunction) functionLines++;
+        if (line.includes('}') && inFunction && functionLines > 50) {
+          suggestions.push({
+            title: 'Long Function Detected',
+            file: file,
+            description: `Function has ${functionLines} lines, consider breaking it down`,
+            benefit: 'Improves testability and code reuse'
+          });
+          inFunction = false;
+        }
+      });
+
+      // Check for code duplication patterns
+      const duplicateLines = findDuplicateLines(lines);
+      if (duplicateLines.length > 0) {
+        suggestions.push({
+          title: 'Code Duplication Found',
+          file: file,
+          description: `${duplicateLines.length} duplicate code blocks detected`,
+          benefit: 'Reduces maintenance overhead and bugs'
+        });
+      }
+    }
+  } catch (error) {
+    // Skip files that can't be read
+  }
+
+  return suggestions.slice(0, 10); // Return top 10 suggestions
+}
+
+function findDuplicateLines(lines) {
+  const lineCount = {};
+  const duplicates = [];
+
+  lines.forEach(line => {
+    const trimmed = line.trim();
+    if (trimmed.length > 10 && !trimmed.startsWith('//') && !trimmed.startsWith('*')) {
+      lineCount[trimmed] = (lineCount[trimmed] || 0) + 1;
+    }
+  });
+
+  Object.entries(lineCount).forEach(([line, count]) => {
+    if (count > 1) {
+      duplicates.push(line);
+    }
+  });
+
+  return duplicates;
+}
+
+module.exports = {
+  timeline,
+  hotspots,
+  changelog,
+  blameAnalysis,
+  showHelp,
+  stats,
+  contributors,
+  compare,
+  search,
+  insights,
+  exportData,
+  visualize,
+  setLang,
+  smartCommitMessage,
+  codeReviewAssistant,
+  bugPrediction,
+  refactorSuggestions
+};