gims 0.6.7 → 0.8.1

package/bin/gims.js

@@ -15,6 +15,7 @@ const { ConfigManager } = require('./lib/config/manager');
 const { GitAnalyzer } = require('./lib/git/analyzer');
 const { AIProviderManager } = require('./lib/ai/providers');
 const { InteractiveCommands } = require('./lib/commands/interactive');
+const { Intelligence } = require('./lib/utils/intelligence');
 
 const program = new Command();
 const git = simpleGit();
@@ -64,7 +65,7 @@ async function ensureRepo() {
 function handleError(prefix, err) {
   const msg = err && err.message ? err.message : String(err);
   Progress.error(`${prefix}: ${msg}`);
-  
+
   // Provide helpful suggestions based on error type
   if (msg.includes('not found') || msg.includes('does not exist')) {
     console.log(`\nTip: Check if the file/branch exists with: ${color.cyan('g status')}`);
@@ -73,7 +74,7 @@ function handleError(prefix, err) {
   } else if (msg.includes('merge') || msg.includes('conflict')) {
     console.log(`\nTip: Resolve conflicts and try again`);
   }
-  
+
   process.exit(1);
 }
 
@@ -97,7 +98,7 @@ async function generateCommitMessage(rawDiff, options = {}) {
 
 async function confirmCommit(message, isLocalHeuristic) {
   if (!isLocalHeuristic) return true; // No confirmation needed for AI-generated messages
-  
+
   const readline = require('readline');
   const rl = readline.createInterface({
     input: process.stdin,
@@ -106,7 +107,7 @@ async function confirmCommit(message, isLocalHeuristic) {
 
   console.log(color.yellow('\n⚠️  No AI provider configured - using local heuristics'));
   console.log(`Suggested commit: "${message}"`);
-  
+
   return new Promise((resolve) => {
     rl.question('Proceed with this commit? [Y/n]: ', (answer) => {
       rl.close();
@@ -184,10 +185,10 @@ async function setupApiKey(provider) {
   });
 
   console.log(color.bold(`\n🔑 ${provider.toUpperCase()} API Key Setup\n`));
-  
+
   const envVars = {
     'openai': 'OPENAI_API_KEY',
-    'gemini': 'GEMINI_API_KEY', 
+    'gemini': 'GEMINI_API_KEY',
     'groq': 'GROQ_API_KEY'
   };
 
@@ -211,7 +212,7 @@ async function setupApiKey(provider) {
   }
 
   const apiKey = await question(`\nEnter your ${provider.toUpperCase()} API key: `);
-  
+
   if (!apiKey) {
     console.log(color.yellow('No API key provided. Setup cancelled.'));
     rl.close();
@@ -226,12 +227,12 @@ async function setupApiKey(provider) {
   console.log(color.cyan(`export ${envVar}="${apiKey}"`));
   console.log('\nOr add it to your shell profile (~/.bashrc, ~/.zshrc, etc.):');
   console.log(color.cyan(`echo 'export ${envVar}="${apiKey}"' >> ~/.zshrc`));
-  
+
   // Set provider in config
   const config = configManager.load();
   config.provider = provider;
   configManager.save(config);
-  
+
   console.log(`\n${color.green('✓')} Provider set to ${provider} in local config`);
   console.log('\nRestart your terminal and try:');
   console.log(`  ${color.cyan('g sg')} - Get AI suggestions`);
@@ -245,7 +246,7 @@ program.command('status').alias('s')
     try {
       const enhancedStatus = await gitAnalyzer.getEnhancedStatus();
       console.log(gitAnalyzer.formatStatusOutput(enhancedStatus));
-      
+
       // Show commit history summary
       const history = await gitAnalyzer.analyzeCommitHistory(5);
       if (history.totalCommits > 0) {
@@ -325,38 +326,41 @@ program.command('quick-help').alias('q')
   .description('Show quick reference for main commands')
   .action(() => {
     console.log(color.bold('🚀 GIMS Quick Reference\n'));
-    
-    console.log(color.bold('Single-Letter Workflow:'));
-    console.log(`  ${color.cyan('g s')}    Status - Enhanced git status with AI insights`);
-    console.log(`  ${color.cyan('g i')}    Init - Initialize a new Git repository`);
-    console.log(`  ${color.cyan('g p')}    Preview - See what will be committed`);
-    console.log(`  ${color.cyan('g l')}    Local - AI commit locally`);
-    console.log(`  ${color.cyan('g o')}    Online - AI commit + push`);
-    console.log(`  ${color.cyan('g ls')}   List - Short commit history`);
-    console.log(`  ${color.cyan('g ll')}   Large List - Detailed commit history`);
-    console.log(`  ${color.cyan('g h')}    History - Alias for list`);
-    console.log(`  ${color.cyan('g a')}    Amend - Merge changes to previous commit (keeps message)`);
-    console.log(`  ${color.cyan('g u')}    Undo - Undo last commit\n`);
-    
-    console.log(color.bold('Quick Setup:'));
-    console.log(`  ${color.cyan('g setup --api-key gemini')}    🚀 gemini-2.5-flash (recommended)`);
-    console.log(`  ${color.cyan('g setup --api-key openai')}    💎 gpt-5 (high quality)`);
-    console.log(`  ${color.cyan('g setup --api-key groq')}      ⚡ groq/compound (ultra fast)\n`);
-    
-    console.log(color.bold('Essential Workflow:'));
-    console.log(`  ${color.cyan('g s')}              Check what's changed`);
-    console.log(`  ${color.cyan('g int')} or ${color.cyan('g o')}      Commit with AI (interactive or online)`);
-    console.log(`  ${color.cyan('g ls')} or ${color.cyan('g h')}      View history\n`);
-    
-    console.log(`For full help: ${color.cyan('g --help')}`);
-    console.log(`For detailed docs: See README.md`);
+
+    console.log(color.bold('Core Workflow:'));
+    console.log(`  ${color.cyan('g s')}      Status with AI insights`);
+    console.log(`  ${color.cyan('g o')}      AI commit + push`);
+    console.log(`  ${color.cyan('g l')}      AI commit locally`);
+    console.log(`  ${color.cyan('g wip')}    Quick WIP commit\n`);
+
+    console.log(color.bold('Sync & Fix:'));
+    console.log(`  ${color.cyan('g sp')}     Safe pull (stash → pull → pop)`);
+    console.log(`  ${color.cyan('g fix')}    Fix branch sync issues`);
+    console.log(`  ${color.cyan('g main')}   Switch to main + pull\n`);
+
+    console.log(color.bold('Stash:'));
+    console.log(`  ${color.cyan('g ss')}     Quick stash save`);
+    console.log(`  ${color.cyan('g pop')}    Pop latest stash`);
+    console.log(`  ${color.cyan('g us')}     Unstage all files\n`);
+
+    console.log(color.bold('Smart Commands:'));
+    console.log(`  ${color.cyan('g r')}      AI code review`);
+    console.log(`  ${color.cyan('g t')}      Today's commits`);
+    console.log(`  ${color.cyan('g last')}   Last commit details\n`);
+
+    console.log(color.bold('History:'));
+    console.log(`  ${color.cyan('g ls')}     Commit history`);
+    console.log(`  ${color.cyan('g a')}      Amend last commit`);
+    console.log(`  ${color.cyan('g u')}      Undo last commit\n`);
+
+    console.log(`Full help: ${color.cyan('g --help')}`);
   });
 
 program.command('init').alias('i')
   .description('Initialize a new Git repository')
-  .action(async () => { 
-    try { 
-      await git.init(); 
+  .action(async () => {
+    try {
+      await git.init();
       Progress.success('Initialized git repository');
       console.log(`\nNext steps:`);
       console.log(`  ${color.cyan('g setup')} - Configure GIMS`);
@@ -400,17 +404,17 @@ program.command('suggest').alias('sg')
         if (opts.progressIndicators) Progress.start('🤖 Generating multiple suggestions');
         const suggestions = await aiProvider.generateMultipleSuggestions(rawDiff, opts, 3);
         if (opts.progressIndicators) Progress.stop('');
-        
+
         console.log(color.bold('\n📝 Suggested commit messages:\n'));
         suggestions.forEach((msg, i) => {
           console.log(`${color.cyan((i + 1).toString())}. ${msg}`);
         });
-        
+
         if (!opts.noClipboard && suggestions.length > 0) {
-          try { 
-            clipboard.writeSync(suggestions[0]); 
+          try {
+            clipboard.writeSync(suggestions[0]);
             console.log(`\n${color.green('✓')} First suggestion copied to clipboard`);
-          } catch (_) { 
+          } catch (_) {
             console.log(`\n${color.yellow('⚠')} Clipboard copy failed`);
           }
         }
@@ -418,10 +422,10 @@ program.command('suggest').alias('sg')
         if (opts.progressIndicators) Progress.start('🤖 Analyzing changes');
         const result = await generateCommitMessage(rawDiff, opts);
         if (opts.progressIndicators) Progress.stop('');
-        
+
         const msg = result.message || result; // Handle both old and new format
         const usedLocal = result.usedLocal || false;
-        
+
         // Warn if using local heuristics
         if (usedLocal) {
           console.log(color.yellow('⚠️  No AI provider configured - using local heuristics'));
@@ -434,10 +438,10 @@ program.command('suggest').alias('sg')
         }
 
         if (!opts.noClipboard) {
-          try { 
-            clipboard.writeSync(msg); 
+          try {
+            clipboard.writeSync(msg);
             Progress.success(`"${msg}" (copied to clipboard)`);
-          } catch (_) { 
+          } catch (_) {
             console.log(`Suggested: "${msg}" ${color.yellow('(clipboard copy failed)')}`);
           }
         } else {
@@ -471,16 +475,16 @@ program.command('local').alias('l')
         Progress.info('No staged changes found; staging all changes...');
         await git.add('.');
         rawDiff = await git.diff(['--cached', '--no-ext-diff']);
-        if (!rawDiff.trim()) { 
-          Progress.warning('No changes to commit'); 
-          return; 
+        if (!rawDiff.trim()) {
+          Progress.warning('No changes to commit');
+          return;
         }
       }
 
       if (opts.progressIndicators) Progress.start('🤖 Generating commit message');
       const result = await generateCommitMessage(rawDiff, opts);
       if (opts.progressIndicators) Progress.stop('');
-      
+
       const msg = result.message || result; // Handle both old and new format
       const usedLocal = result.usedLocal || false;
 
@@ -533,16 +537,16 @@ program.command('online').alias('o')
         Progress.info('No staged changes found; staging all changes...');
         await git.add('.');
         rawDiff = await git.diff(['--cached', '--no-ext-diff']);
-        if (!rawDiff.trim()) { 
-          Progress.warning('No changes to commit'); 
-          return; 
+        if (!rawDiff.trim()) {
+          Progress.warning('No changes to commit');
+          return;
         }
       }
 
       if (opts.progressIndicators) Progress.start('🤖 Generating commit message');
       const result = await generateCommitMessage(rawDiff, opts);
       if (opts.progressIndicators) Progress.stop('');
-      
+
       const msg = result.message || result; // Handle both old and new format
       const usedLocal = result.usedLocal || false;
 
@@ -640,9 +644,9 @@ program.command('pull')
   .description('Pull latest changes')
   .action(async () => {
     await ensureRepo();
-    try { 
+    try {
       Progress.info('Pulling latest changes...');
-      await git.pull(); 
+      await git.pull();
       Progress.success('Pulled latest changes');
     }
     catch (e) { handleError('Pull error', e); }
@@ -667,27 +671,27 @@ program.command('sync')
     await ensureRepo();
     try {
       const status = await git.status();
-      
+
       if (status.files.length > 0) {
         Progress.warning('You have uncommitted changes. Commit or stash them first.');
         return;
       }
-      
+
       Progress.info('Fetching latest changes...');
       await git.fetch();
-      
+
       const currentBranch = (await git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
       const remoteBranch = `origin/${currentBranch}`;
-      
+
       try {
         const behind = await git.raw(['rev-list', '--count', `${currentBranch}..${remoteBranch}`]);
         const ahead = await git.raw(['rev-list', '--count', `${remoteBranch}..${currentBranch}`]);
-        
+
         if (parseInt(behind.trim()) === 0) {
           Progress.success('Already up to date');
           return;
         }
-        
+
         if (parseInt(ahead.trim()) > 0) {
           Progress.info(`Branch is ${ahead.trim()} commits ahead and ${behind.trim()} commits behind`);
           if (cmdOptions.rebase) {
@@ -713,8 +717,8 @@ program.command('sync')
           throw error;
         }
       }
-    } catch (e) { 
-      handleError('Sync error', e); 
+    } catch (e) {
+      handleError('Sync error', e);
     }
   });
 
@@ -732,7 +736,7 @@ program.command('stash')
           Progress.info('No stashes found');
           return;
         }
-        
+
         console.log(color.bold('Stashes:'));
         stashes.all.forEach((stash, i) => {
           console.log(`${color.cyan((i).toString())}. ${stash.message}`);
@@ -751,15 +755,15 @@ program.command('stash')
           Progress.warning('No changes to stash');
           return;
         }
-        
+
         Progress.start('🤖 Generating stash description');
         const diff = await git.diff();
-        const description = await aiProvider.generateCommitMessage(diff, { 
-          conventional: false, 
-          body: false 
+        const description = await aiProvider.generateCommitMessage(diff, {
+          conventional: false,
+          body: false
         });
         Progress.stop('');
-        
+
         await git.stash(['push', '-m', `WIP: ${description}`]);
         Progress.success(`Stashed changes: "${description}"`);
       }
@@ -795,10 +799,10 @@ program.command('amend').alias('a')
         Progress.start('🤖 Generating updated commit message');
         const result = await generateCommitMessage(rawDiff, opts);
         Progress.stop('');
-        
+
         const newMessage = result.message || result; // Handle both old and new format
         const usedLocal = result.usedLocal || false;
-        
+
         // Ask for confirmation if using local heuristics (unless --yes flag is set)
         if (usedLocal && !opts.yes) {
           const confirmed = await confirmCommit(newMessage, true);
@@ -807,7 +811,7 @@ program.command('amend').alias('a')
             return;
           }
         }
-        
+
         await git.raw(['commit', '--amend', '-m', newMessage]);
         Progress.success(`Amended commit: "${newMessage}"`);
       } else {
@@ -829,21 +833,21 @@ program.command('list').alias('ls')
       const limit = parseInt(cmdOptions.limit) || 20;
       const log = await git.log({ maxCount: limit });
       const commits = [...log.all].reverse();
-      
+
       if (commits.length === 0) {
         Progress.info('No commits found');
         return;
       }
-      
+
       commits.forEach((c, i) => {
-        console.log(`${color.cyan((i+1).toString())}. ${color.yellow(c.hash.slice(0,7))} ${c.message}`);
+        console.log(`${color.cyan((i + 1).toString())}. ${color.yellow(c.hash.slice(0, 7))} ${c.message}`);
       });
-      
+
       if (log.all.length >= limit) {
         console.log(color.dim(`\n... showing last ${limit} commits (use --limit to see more)`));
       }
-    } catch (e) { 
-      handleError('List error', e); 
+    } catch (e) {
+      handleError('List error', e);
     }
   });
 
@@ -856,22 +860,22 @@ program.command('largelist').alias('ll')
       const limit = parseInt(cmdOptions.limit) || 20;
       const log = await git.log({ maxCount: limit });
       const commits = [...log.all].reverse();
-      
+
       if (commits.length === 0) {
         Progress.info('No commits found');
         return;
       }
-      
+
       commits.forEach((c, i) => {
         const date = new Date(c.date).toLocaleString();
-        console.log(`${color.cyan((i+1).toString())}. ${color.yellow(c.hash.slice(0,7))} | ${color.dim(date)} | ${color.green(c.author_name)} → ${c.message}`);
+        console.log(`${color.cyan((i + 1).toString())}. ${color.yellow(c.hash.slice(0, 7))} | ${color.dim(date)} | ${color.green(c.author_name)} → ${c.message}`);
       });
-      
+
       if (log.all.length >= limit) {
         console.log(color.dim(`\n... showing last ${limit} commits (use --limit to see more)`));
       }
-    } catch (e) { 
-      handleError('Largelist error', e); 
+    } catch (e) {
+      handleError('Largelist error', e);
     }
   });
 
@@ -884,21 +888,21 @@ program.command('history').alias('h')
       const limit = parseInt(cmdOptions.limit) || 20;
       const log = await git.log({ maxCount: limit });
       const commits = [...log.all].reverse();
-      
+
       if (commits.length === 0) {
         Progress.info('No commits found');
         return;
       }
-      
+
       commits.forEach((c, i) => {
-        console.log(`${color.cyan((i+1).toString())}. ${color.yellow(c.hash.slice(0,7))} ${c.message}`);
+        console.log(`${color.cyan((i + 1).toString())}. ${color.yellow(c.hash.slice(0, 7))} ${c.message}`);
       });
-      
+
       if (log.all.length >= limit) {
         console.log(color.dim(`\n... showing last ${limit} commits (use --limit to see more)`));
       }
-    } catch (e) { 
-      handleError('History error', e); 
+    } catch (e) {
+      handleError('History error', e);
     }
   });
 
@@ -906,18 +910,18 @@ program.command('branch <c> [name]').alias('b')
   .description('Branch from commit/index')
   .action(async (c, name) => {
     await ensureRepo();
-    try { const sha = await resolveCommit(c); const br = name || `branch-${sha.slice(0,7)}`; await git.checkout(['-b', br, sha]); console.log(`Switched to branch ${br} at ${sha}`); }
+    try { const sha = await resolveCommit(c); const br = name || `branch-${sha.slice(0, 7)}`; await git.checkout(['-b', br, sha]); console.log(`Switched to branch ${br} at ${sha}`); }
     catch (e) { handleError('Branch error', e); }
   });
 
-program.command('reset <c>').alias('r')
+program.command('reset <c>').alias('rs')
   .description('Reset branch to commit/index')
-  .option('--hard','hard reset')
+  .option('--hard', 'hard reset')
   .action(async (c, optsCmd) => {
     await ensureRepo();
     try {
       const sha = await resolveCommit(c);
-      const mode = optsCmd.hard? '--hard':'--soft';
+      const mode = optsCmd.hard ? '--hard' : '--soft';
       const opts = getOpts();
       if (!opts.yes) {
         console.log(color.yellow(`About to run: git reset ${mode} ${sha}. Use --yes to confirm.`));
@@ -957,11 +961,11 @@ program.command('undo').alias('u')
         Progress.warning('No commits to undo');
         return;
       }
-      
+
       const lastCommit = all[0];
       const mode = cmd.hard ? '--hard' : '--soft';
       const opts = getOpts();
-      
+
       if (!opts.yes) {
         console.log(color.yellow(`About to undo: "${lastCommit.message}"`));
         console.log(color.yellow(`This will run: git reset ${mode} HEAD~1`));
@@ -971,16 +975,743 @@ program.command('undo').alias('u')
         console.log('Use --yes to confirm.');
         process.exit(1);
       }
-      
+
       await git.raw(['reset', mode, 'HEAD~1']);
       Progress.success(`Undone commit: "${lastCommit.message}" (${mode} reset)`);
-      
+
       if (mode === '--soft') {
         Progress.info('Changes are now staged. Use "g status" to see them.');
       }
-    } catch (e) { 
-      handleError('Undo error', e); 
+    } catch (e) {
+      handleError('Undo error', e);
+    }
+  });
+
+// ===== NEW INTELLIGENT COMMANDS =====
+
+program.command('wip')
+  .description('Quick work-in-progress commit')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+      if (status.files.length === 0) {
+        Progress.warning('No changes to commit');
+        return;
+      }
+
+      Progress.info('Staging all changes...');
+      await git.add('.');
+
+      const fileCount = status.files.length;
+      const message = `WIP: ${fileCount} file${fileCount > 1 ? 's' : ''} changed`;
+
+      await git.commit(message);
+      Progress.success(`Committed: "${message}"`);
+      Progress.tip('Use `g a` to amend this commit when ready, or `g undo` to undo');
+    } catch (e) {
+      handleError('WIP error', e);
+    }
+  });
+
+program.command('today').alias('t')
+  .description('Show commits made today')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const commits = await gitAnalyzer.getTodayCommits();
+
+      if (commits.length === 0) {
+        console.log(color.dim('No commits today yet.'));
+        Progress.tip('Start your day with `g o` to commit and push!');
+        return;
+      }
+
+      console.log(color.bold(`📅 Today's Commits (${commits.length})\n`));
+      commits.forEach((commit, i) => {
+        console.log(gitAnalyzer.formatCommit(commit, i));
+      });
+    } catch (e) {
+      handleError('Today error', e);
+    }
+  });
+
+program.command('stats')
+  .description('Your personal commit statistics')
+  .option('--days <n>', 'Number of days to analyze', '30')
+  .action(async (cmdOptions) => {
+    await ensureRepo();
+    try {
+      const days = parseInt(cmdOptions.days) || 30;
+      const intelligence = new Intelligence(git);
+
+      Progress.start('📊 Analyzing your commit history');
+      const stats = await intelligence.getCommitStats(days);
+      const patterns = await intelligence.analyzeCommitPatterns();
+      Progress.stop('');
+
+      if (!stats.hasData) {
+        Progress.info('Not enough commit history to analyze');
+        return;
+      }
+
+      console.log(color.bold(`\n📊 Your Git Stats (last ${days} days)\n`));
+
+      // Overview
+      console.log(color.cyan('Overview:'));
+      console.log(`  Total commits: ${color.bold(stats.totalCommits.toString())}`);
+      console.log(`  Days active: ${stats.daysActive}`);
+      console.log(`  Average: ${stats.avgPerDay} commits/day`);
+      console.log(`  Current streak: ${color.green(stats.currentStreak + ' days')}`);
+      if (stats.longestStreak > stats.currentStreak) {
+        console.log(`  Longest streak: ${stats.longestStreak} days`);
+      }
+
+      // Commit types breakdown
+      if (patterns.usesConventional) {
+        console.log(`\n${color.cyan('Commit Types:')}`);
+        const types = stats.typeBreakdown;
+        const total = Object.values(types).reduce((a, b) => a + b, 0);
+        Object.entries(types).forEach(([type, count]) => {
+          if (count > 0) {
+            const pct = Math.round(count / total * 100);
+            const bar = '█'.repeat(Math.ceil(pct / 5)) + '░'.repeat(20 - Math.ceil(pct / 5));
+            console.log(`  ${type.padEnd(8)} ${bar} ${pct}%`);
+          }
+        });
+      }
+
+      // Style insights
+      if (patterns.hasHistory) {
+        console.log(`\n${color.cyan('Your Style:')}`);
+        console.log(`  Conventional commits: ${patterns.conventionalRatio}%`);
+        console.log(`  Message style: ${patterns.style}`);
+        console.log(`  Avg message length: ${patterns.avgMessageLength} chars`);
+        if (patterns.topScopes.length > 0) {
+          console.log(`  Common scopes: ${patterns.topScopes.join(', ')}`);
+        }
+      }
+
+      Progress.showRandomTip();
+    } catch (e) {
+      handleError('Stats error', e);
+    }
+  });
+
+program.command('review').alias('r')
+  .description('AI code review before committing')
+  .action(async () => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      let diff = await git.diff(['--cached', '--no-ext-diff']);
+
+      if (!diff.trim()) {
+        // Try unstaged changes
+        diff = await git.diff(['--no-ext-diff']);
+        if (!diff.trim()) {
+          Progress.warning('No changes to review');
+          return;
+        }
+        console.log(color.dim('(Reviewing unstaged changes)\n'));
+      } else {
+        console.log(color.dim('(Reviewing staged changes)\n'));
+      }
+
+      const intelligence = new Intelligence(git);
+
+      // Analyze complexity
+      const complexity = await gitAnalyzer.getChangeComplexity(diff);
+      console.log(color.bold('📋 Change Summary'));
+      console.log(`  Complexity: ${complexity.emoji} ${complexity.complexity}`);
+      console.log(`  Files: ${complexity.files}`);
+      console.log(`  Changes: ${color.green('+' + complexity.additions)} ${color.red('-' + complexity.deletions)}`);
+
+      // Detect semantic changes
+      const semantic = await intelligence.detectSemanticChanges(diff);
+      if (semantic.labels.length > 0) {
+        console.log(`\n${color.bold('🔍 Detected Patterns')}`);
+        semantic.labels.forEach(label => {
+          console.log(`  ${label}`);
+        });
+      }
+
+      // Get AI suggestions
+      if (opts.progressIndicators) Progress.start('🤖 Generating AI review');
+      const message = await aiProvider.generateCommitMessage(diff, { ...opts, body: true });
+      if (opts.progressIndicators) Progress.stop('');
+
+      console.log(`\n${color.bold('💬 Suggested Commit Message')}`);
+      console.log(`  ${color.green(message.message || message)}`);
+
+      // Actionable next steps
+      console.log(`\n${color.bold('📌 Next Steps')}`);
+      console.log(`  ${color.cyan('g o')}    Commit and push with AI message`);
+      console.log(`  ${color.cyan('g l')}    Commit locally with AI message`);
+      console.log(`  ${color.cyan('g int')}  Interactive commit with options`);
+
+    } catch (e) {
+      handleError('Review error', e);
+    }
+  });
+
+program.command('split')
+  .description('Suggest how to split a large changeset')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+
+      if (status.files.length === 0) {
+        Progress.info('No changes to split');
+        return;
+      }
+
+      if (status.files.length < 5) {
+        Progress.info('Changeset is small enough - no need to split');
+        console.log(`\nYou have ${status.files.length} file${status.files.length > 1 ? 's' : ''} changed.`);
+        console.log(`Use ${color.cyan('g o')} to commit them all at once.`);
+        return;
+      }
+
+      const intelligence = new Intelligence(git);
+      const suggestions = await intelligence.suggestCommitSplit(status);
+
+      if (!suggestions) {
+        Progress.info('All changes look related - commit them together');
+        return;
+      }
+
+      console.log(color.bold(`\n📦 Suggested Commit Split\n`));
+      console.log(color.dim(`Your ${status.files.length} files could be split into ${suggestions.length} commits:\n`));
+
+      suggestions.forEach((group, i) => {
+        console.log(`${color.cyan((i + 1).toString())}. ${color.bold(group.message)}`);
+        group.files.slice(0, 5).forEach(file => {
+          const emoji = Intelligence.getFileEmoji(file);
+          console.log(`   ${emoji} ${file}`);
+        });
+        if (group.files.length > 5) {
+          console.log(color.dim(`   ... and ${group.files.length - 5} more`));
+        }
+        console.log();
+      });
+
+      console.log(color.bold('💡 How to split:'));
+      console.log(`  1. Stage specific files: ${color.cyan('git add <file>')}`);
+      console.log(`  2. Commit them: ${color.cyan('g l')} or ${color.cyan('g o')}`);
+      console.log(`  3. Repeat for remaining files`);
+
+    } catch (e) {
+      handleError('Split error', e);
+    }
+  });
+
+// ===== WORKFLOW SHORTHAND COMMANDS =====
+
+program.command('safe-pull').alias('sp')
+  .description('Safe pull: stash → pull → stash pop')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+      const hasChanges = status.files.length > 0;
+
+      if (hasChanges) {
+        Progress.info('Stashing changes...');
+        await git.stash(['push', '-m', 'GIMS: auto-stash before pull']);
+      }
+
+      Progress.info('Pulling latest changes...');
+      await git.pull();
+
+      if (hasChanges) {
+        Progress.info('Restoring stashed changes...');
+        await git.stash(['pop']);
+      }
+
+      Progress.success('Safe pull complete');
+    } catch (e) {
+      handleError('Safe pull error', e);
+    }
+  });
+
+program.command('main')
+  .description('Switch to main/master and pull latest')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      // Detect main branch name
+      let mainBranch = 'main';
+      try {
+        await git.raw(['rev-parse', '--verify', 'main']);
+      } catch {
+        try {
+          await git.raw(['rev-parse', '--verify', 'master']);
+          mainBranch = 'master';
+        } catch {
+          Progress.error('No main or master branch found');
+          return;
+        }
+      }
+
+      const status = await git.status();
+      if (status.files.length > 0) {
+        Progress.warning('You have uncommitted changes. Commit or stash them first.');
+        console.log(`Tip: Use ${color.cyan('g sp')} to safe-pull with auto-stash`);
+        return;
+      }
+
+      Progress.info(`Switching to ${mainBranch}...`);
+      await git.checkout(mainBranch);
+
+      Progress.info('Pulling latest...');
+      await git.pull();
+
+      Progress.success(`On ${mainBranch} with latest changes`);
+    } catch (e) {
+      handleError('Main error', e);
+    }
+  });
+
+program.command('unstage').alias('us')
+  .description('Unstage all staged files')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+      if (status.staged.length === 0) {
+        Progress.info('Nothing is staged');
+        return;
+      }
+
+      await git.reset([]);
+      Progress.success(`Unstaged ${status.staged.length} file${status.staged.length > 1 ? 's' : ''}`);
+    } catch (e) {
+      handleError('Unstage error', e);
+    }
+  });
+
+program.command('discard').alias('x')
+  .description('Discard all changes (with confirmation)')
+  .action(async () => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      const status = await git.status();
+      if (status.files.length === 0) {
+        Progress.info('No changes to discard');
+        return;
+      }
+
+      if (!opts.yes) {
+        console.log(color.yellow(`⚠️  About to discard ALL changes in ${status.files.length} file(s)`));
+        console.log(color.red('This cannot be undone!'));
+        console.log('Use --yes to confirm.');
+        return;
+      }
+
+      // Discard tracked file changes
+      await git.checkout(['--', '.']);
+
+      // Remove untracked files
+      if (status.not_added.length > 0) {
+        await git.clean('fd');
+      }
+
+      Progress.success('All changes discarded');
+    } catch (e) {
+      handleError('Discard error', e);
+    }
+  });
+
+program.command('stash-save').alias('ss')
+  .description('Quick stash: stage all and stash')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+      if (status.files.length === 0) {
+        Progress.info('No changes to stash');
+        return;
+      }
+
+      await git.add('.');
+
+      // Generate a descriptive stash name
+      const fileCount = status.files.length;
+      const timestamp = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      const message = `WIP: ${fileCount} file${fileCount > 1 ? 's' : ''} at ${timestamp}`;
+
+      await git.stash(['push', '-m', message]);
+      Progress.success(`Stashed: "${message}"`);
+    } catch (e) {
+      handleError('Stash save error', e);
+    }
+  });
+
+program.command('stash-pop').alias('pop')
+  .description('Pop the latest stash')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const stashList = await git.stashList();
+      if (stashList.all.length === 0) {
+        Progress.info('No stashes to pop');
+        return;
+      }
+
+      const latestStash = stashList.all[0];
+      await git.stash(['pop']);
+      Progress.success(`Popped: "${latestStash.message}"`);
+    } catch (e) {
+      handleError('Stash pop error', e);
+    }
+  });
+
+program.command('delete-branch').alias('del')
+  .description('Delete branch locally and remotely')
+  .argument('<branch>', 'Branch name to delete')
+  .action(async (branch) => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      const current = (await git.branch()).current;
+      if (branch === current) {
+        Progress.error(`Cannot delete current branch. Switch to another branch first.`);
+        return;
+      }
+
+      if (branch === 'main' || branch === 'master') {
+        Progress.error('Cannot delete main/master branch');
+        return;
+      }
+
+      if (!opts.yes) {
+        console.log(color.yellow(`⚠️  About to delete branch: ${branch}`));
+        console.log('This will delete both local and remote copies.');
+        console.log('Use --yes to confirm.');
+        return;
+      }
+
+      // Delete local
+      Progress.info('Deleting local branch...');
+      try {
+        await git.branch(['-D', branch]);
+      } catch (e) {
+        Progress.warning(`Local branch not found or already deleted`);
+      }
+
+      // Delete remote
+      Progress.info('Deleting remote branch...');
+      try {
+        await git.push(['origin', '--delete', branch]);
+      } catch (e) {
+        Progress.warning(`Remote branch not found or already deleted`);
+      }
+
+      Progress.success(`Deleted branch: ${branch}`);
+    } catch (e) {
+      handleError('Delete branch error', e);
+    }
+  });
+
+program.command('cleanup').alias('clean')
+  .description('Remove local branches that no longer exist on remote')
+  .action(async () => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      Progress.info('Fetching and pruning...');
+      await git.fetch(['--prune']);
+
+      // Find gone branches
+      const branchOutput = await git.raw(['branch', '-vv']);
+      const goneBranches = branchOutput
+        .split('\n')
+        .filter(line => line.includes(': gone]'))
+        .map(line => line.trim().split(/\s+/)[0].replace('*', '').trim())
+        .filter(b => b && b !== 'main' && b !== 'master');
+
+      if (goneBranches.length === 0) {
+        Progress.success('No dead branches to clean up');
+        return;
+      }
+
+      console.log(color.bold(`\nFound ${goneBranches.length} dead branch(es):`));
+      goneBranches.forEach(b => console.log(`  ${color.dim('•')} ${b}`));
+
+      if (!opts.yes) {
+        console.log(`\nUse ${color.cyan('g clean --yes')} to delete them`);
+        return;
+      }
+
+      for (const branch of goneBranches) {
+        try {
+          await git.branch(['-D', branch]);
+          Progress.success(`Deleted: ${branch}`);
+        } catch (e) {
+          Progress.warning(`Could not delete: ${branch}`);
+        }
+      }
+
+      Progress.success(`Cleaned up ${goneBranches.length} branch(es)`);
+    } catch (e) {
+      handleError('Cleanup error', e);
+    }
+  });
+
+program.command('last')
+  .description('Show last commit details and diff')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const log = await git.log({ maxCount: 1 });
+      if (log.all.length === 0) {
+        Progress.info('No commits yet');
+        return;
+      }
+
+      const commit = log.all[0];
+      console.log(color.bold('\n📝 Last Commit\n'));
+      console.log(`  ${color.yellow(commit.hash.substring(0, 7))} ${commit.message.split('\n')[0]}`);
+      console.log(`  ${color.dim(`by ${commit.author_name} • ${new Date(commit.date).toLocaleString()}`)}`);
+
+      // Show diff stats
+      const diff = await git.diff(['HEAD~1', '--stat']);
+      if (diff.trim()) {
+        console.log(`\n${color.bold('Changes:')}`);
+        console.log(color.dim(diff));
+      }
+    } catch (e) {
+      handleError('Last error', e);
+    }
+  });
+
+// ===== SMART SYNC FIX COMMAND =====
+
+program.command('fix')
+  .description('Smart fix for branch sync issues (diverged, behind, ahead)')
+  .option('--local', 'Keep local changes, force push to remote')
+  .option('--remote', 'Keep remote changes, discard local')
+  .option('--merge', 'Merge remote into local')
+  .option('--rebase', 'Rebase local onto remote')
+  .option('--ai', 'Get AI recommendation for best approach')
+  .action(async (cmdOptions) => {
+    await ensureRepo();
+    const opts = getOpts();
+
+    try {
+      // Fetch latest
+      Progress.info('Fetching remote status...');
+      await git.fetch();
+
+      const branch = (await git.branch()).current;
+      const remoteBranch = `origin/${branch}`;
+
+      // Check if remote exists
+      let remoteExists = true;
+      try {
+        await git.raw(['rev-parse', '--verify', remoteBranch]);
+      } catch {
+        remoteExists = false;
+      }
+
+      if (!remoteExists) {
+        console.log(color.bold(`\n📍 Branch Status: ${color.cyan(branch)}\n`));
+        console.log(`Remote branch ${color.yellow(remoteBranch)} doesn't exist yet.`);
+        console.log(`\nOptions:`);
+        console.log(`  ${color.cyan('g push --set-upstream')}  Push and create remote branch`);
+        return;
+      }
+
+      // Get ahead/behind counts
+      const ahead = parseInt((await git.raw(['rev-list', '--count', `${remoteBranch}..${branch}`])).trim());
+      const behind = parseInt((await git.raw(['rev-list', '--count', `${branch}..${remoteBranch}`])).trim());
+
+      // Get local changes status
+      const status = await git.status();
+      const hasLocalChanges = status.files.length > 0;
+
+      console.log(color.bold(`\n📍 Branch Status: ${color.cyan(branch)}\n`));
+
+      // Determine situation
+      let situation = '';
+      if (ahead === 0 && behind === 0) {
+        Progress.success('Branch is up to date with remote!');
+        if (hasLocalChanges) {
+          console.log(`\nYou have ${status.files.length} uncommitted change(s).`);
+          console.log(`Use ${color.cyan('g o')} to commit and push them.`);
+        }
+        return;
+      } else if (ahead > 0 && behind === 0) {
+        situation = 'ahead';
+        console.log(`  ${color.green('↑')} ${ahead} commit(s) ahead of remote`);
+        console.log(`  ${color.dim('Your local has commits not on remote')}\n`);
+      } else if (ahead === 0 && behind > 0) {
+        situation = 'behind';
+        console.log(`  ${color.yellow('↓')} ${behind} commit(s) behind remote`);
+        console.log(`  ${color.dim('Remote has commits you don\'t have')}\n`);
+      } else {
+        situation = 'diverged';
+        console.log(`  ${color.red('⚡')} Branch has diverged!`);
+        console.log(`  ${color.green('↑')} ${ahead} commit(s) ahead`);
+        console.log(`  ${color.yellow('↓')} ${behind} commit(s) behind\n`);
+      }
+
+      if (hasLocalChanges) {
+        console.log(color.yellow(`⚠️  You have ${status.files.length} uncommitted file(s)`));
+        console.log(`${color.dim('Commit or stash them before fixing sync issues')}\n`);
+      }
+
+      // If specific option provided, execute it
+      if (cmdOptions.local) {
+        if (!opts.yes) {
+          console.log(color.red('⚠️  This will FORCE PUSH and overwrite remote!'));
+          console.log(`Use ${color.cyan('g fix --local --yes')} to confirm.`);
+          return;
+        }
+        Progress.info('Force pushing local to remote...');
+        await git.push(['--force']);
+        Progress.success('Force pushed! Remote now matches local.');
+        return;
+      }
+
+      if (cmdOptions.remote) {
+        if (!opts.yes) {
+          console.log(color.red('⚠️  This will DISCARD local commits!'));
+          console.log(`Use ${color.cyan('g fix --remote --yes')} to confirm.`);
+          return;
+        }
+        Progress.info('Resetting to remote...');
+        await git.reset(['--hard', remoteBranch]);
+        Progress.success('Reset! Local now matches remote.');
+        return;
+      }
+
+      if (cmdOptions.merge) {
+        Progress.info('Merging remote into local...');
+        try {
+          await git.merge([remoteBranch]);
+          Progress.success('Merged successfully!');
+        } catch (e) {
+          Progress.error('Merge conflict! Resolve conflicts then run: g o');
+        }
+        return;
+      }
+
+      if (cmdOptions.rebase) {
+        Progress.info('Rebasing local onto remote...');
+        try {
+          await git.rebase([remoteBranch]);
+          Progress.success('Rebased successfully!');
+          console.log(`Now run ${color.cyan('g push --force')} to update remote.`);
+        } catch (e) {
+          Progress.error('Rebase conflict! Resolve conflicts then run: git rebase --continue');
+        }
+        return;
+      }
+
+      // AI recommendation
+      if (cmdOptions.ai) {
+        Progress.info('Analyzing best approach...');
+        let recommendation = '';
+
+        if (situation === 'ahead') {
+          recommendation = `Your local is ${ahead} commits ahead. Simply push to sync.`;
+          console.log(`\n${color.bold('🤖 AI Recommendation:')}`);
+          console.log(`  ${recommendation}`);
+          console.log(`\n  Run: ${color.cyan('g push')}`);
+        } else if (situation === 'behind') {
+          recommendation = `Remote has ${behind} new commits. Pull to get them.`;
+          console.log(`\n${color.bold('🤖 AI Recommendation:')}`);
+          console.log(`  ${recommendation}`);
+          console.log(`\n  Run: ${color.cyan('g pull')} or ${color.cyan('g sp')} (if you have changes)`);
+        } else {
+          // Diverged - more complex
+          if (ahead <= 2 && behind > ahead) {
+            recommendation = `Small local changes (${ahead}), larger remote (${behind}). Rebase recommended for clean history.`;
+            console.log(`\n${color.bold('🤖 AI Recommendation:')}`);
+            console.log(`  ${recommendation}`);
+            console.log(`\n  Run: ${color.cyan('g fix --rebase')}`);
+          } else if (behind <= 2 && ahead > behind) {
+            recommendation = `Large local changes (${ahead}), small remote (${behind}). Merge is safe.`;
+            console.log(`\n${color.bold('🤖 AI Recommendation:')}`);
+            console.log(`  ${recommendation}`);
+            console.log(`\n  Run: ${color.cyan('g fix --merge')}`);
+          } else {
+            recommendation = `Significant divergence. Review changes first, then choose merge or rebase.`;
+            console.log(`\n${color.bold('🤖 AI Recommendation:')}`);
+            console.log(`  ${recommendation}`);
+            console.log(`\n  View remote changes: ${color.cyan(`git log ${branch}..${remoteBranch} --oneline`)}`);
+            console.log(`  View local changes:  ${color.cyan(`git log ${remoteBranch}..${branch} --oneline`)}`);
+          }
+        }
+        return;
+      }
+
+      // Show interactive menu
+      console.log(color.bold('🔧 Fix Options:\n'));
+
+      if (situation === 'ahead') {
+        console.log(`  ${color.cyan('g push')}           Push your commits to remote`);
+      } else if (situation === 'behind') {
+        console.log(`  ${color.cyan('g pull')}           Get remote commits (fast-forward)`);
+        console.log(`  ${color.cyan('g sp')}             Safe pull (stash → pull → pop)`);
+      } else {
+        // Diverged
+        console.log(`  ${color.cyan('g fix --merge')}    Merge remote into local (creates merge commit)`);
+        console.log(`  ${color.cyan('g fix --rebase')}   Rebase local onto remote (linear history)`);
+        console.log(color.dim('  ─────────────────'));
+        console.log(`  ${color.cyan('g fix --local')}    ${color.yellow('⚠')} Force push local, overwrite remote`);
+        console.log(`  ${color.cyan('g fix --remote')}   ${color.yellow('⚠')} Reset to remote, discard local commits`);
+      }
+
+      console.log(color.dim('  ─────────────────'));
+      console.log(`  ${color.cyan('g fix --ai')}       Get AI recommendation`);
+
+    } catch (e) {
+      handleError('Fix error', e);
+    }
+  });
+
+program.command('conflicts')
+  .description('Show and help resolve merge conflicts')
+  .action(async () => {
+    await ensureRepo();
+    try {
+      const status = await git.status();
+      const conflicts = status.conflicted || [];
+
+      if (conflicts.length === 0) {
+        Progress.success('No merge conflicts!');
+        return;
+      }
+
+      console.log(color.bold(`\n⚠️  ${conflicts.length} Conflicted File(s):\n`));
+      conflicts.forEach((file, i) => {
+        const emoji = Intelligence.getFileEmoji(file);
+        console.log(`  ${i + 1}. ${emoji} ${color.red(file)}`);
+      });
+
+      console.log(color.bold('\n🔧 How to resolve:\n'));
+      console.log(`  1. Edit each file and resolve the conflict markers`);
+      console.log(`     ${color.dim('<<<<<<< HEAD')}`);
+      console.log(`     ${color.dim('your changes')}`);
+      console.log(`     ${color.dim('=======')}`);
+      console.log(`     ${color.dim('their changes')}`);
+      console.log(`     ${color.dim('>>>>>>> branch')}`);
+      console.log(`  2. Stage resolved files: ${color.cyan('git add <file>')}`);
+      console.log(`  3. Complete the merge: ${color.cyan('g o')} or ${color.cyan('git merge --continue')}`);
+
+      console.log(color.bold('\n⚡ Quick options:\n'));
+      console.log(`  ${color.cyan('git checkout --ours <file>')}   Keep YOUR version`);
+      console.log(`  ${color.cyan('git checkout --theirs <file>')} Keep THEIR version`);
+
+    } catch (e) {
+      handleError('Conflicts error', e);
     }
   });
 
 program.parse(process.argv);
+