gims 0.5.3 → 0.6.1

package/bin/gims.js

@@ -1,64 +1,38 @@
 #!/usr/bin/env node
 
 /*
-  gims (Git Made Simple) CLI
+  gims (Git Made Simple) CLI - Enhanced Version
 */
 const { Command } = require('commander');
 const simpleGit = require('simple-git');
 const clipboard = require('clipboardy');
 const process = require('process');
-const { OpenAI } = require('openai');
-const { GoogleGenAI } = require('@google/genai');
-const fs = require('fs');
-const path = require('path');
+
+// Enhanced modular imports
+const { color } = require('./lib/utils/colors');
+const { Progress } = require('./lib/utils/progress');
+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 program = new Command();
 const git = simpleGit();
 
-// Utility: ANSI colors without extra deps
-const color = {
-  green: (s) => `\x1b[32m${s}\x1b[0m`,
-  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
-  red: (s) => `\x1b[31m${s}\x1b[0m`,
-  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
-  bold: (s) => `\x1b[1m${s}\x1b[0m`,
-};
-
-// Load simple config from .gimsrc (JSON) in cwd or home and env vars
-function loadConfig() {
-  const defaults = {
-    provider: process.env.GIMS_PROVIDER || 'auto', // auto | openai | gemini | groq | none
-    model: process.env.GIMS_MODEL || '',
-    conventional: !!(process.env.GIMS_CONVENTIONAL === '1'),
-    copy: process.env.GIMS_COPY !== '0',
-  };
-  const tryFiles = [
-    path.join(process.cwd(), '.gimsrc'),
-    path.join(process.env.HOME || process.cwd(), '.gimsrc'),
-  ];
-  for (const fp of tryFiles) {
-    try {
-      if (fs.existsSync(fp)) {
-        const txt = fs.readFileSync(fp, 'utf8');
-        const json = JSON.parse(txt);
-        return { ...defaults, ...json };
-      }
-    } catch (_) {
-      // ignore malformed config
-    }
-  }
-  return defaults;
-}
+// Initialize enhanced components
+const configManager = new ConfigManager();
+const gitAnalyzer = new GitAnalyzer(git);
+let aiProvider;
+let interactive;
 
 function getOpts() {
-  // Merge precedence: CLI > config > env handled in loadConfig
-  const cfg = loadConfig();
+  const cfg = configManager.load();
   const cli = program.opts();
   return {
     provider: cli.provider || cfg.provider,
     model: cli.model || cfg.model,
     stagedOnly: !!cli.stagedOnly,
-    all: !!cli.all,
+    all: !!cli.all || cfg.autoStage,
     noClipboard: !!cli.noClipboard || cfg.copy === false,
     body: !!cli.body,
     conventional: !!cli.conventional || cfg.conventional,
@@ -68,20 +42,38 @@ function getOpts() {
     yes: !!cli.yes,
     amend: !!cli.amend,
     setUpstream: !!cli.setUpstream,
+    progressIndicators: cfg.progressIndicators !== false,
   };
 }
 
+function initializeComponents() {
+  const config = configManager.load();
+  aiProvider = new AIProviderManager(config);
+  interactive = new InteractiveCommands(git, aiProvider, gitAnalyzer);
+}
+
 async function ensureRepo() {
   const isRepo = await git.checkIsRepo();
   if (!isRepo) {
-    console.error(color.red('Not a git repository (or any of the parent directories).'));
+    Progress.error('Not a git repository (or any of the parent directories).');
+    console.log(`\nTo initialize a new repository, run: ${color.cyan('g init')}`);
     process.exit(1);
   }
 }
 
 function handleError(prefix, err) {
   const msg = err && err.message ? err.message : String(err);
-  console.error(color.red(`${prefix}: ${msg}`));
+  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')}`);
+  } else if (msg.includes('permission') || msg.includes('access')) {
+    console.log(`\nTip: Check file permissions or authentication`);
+  } else if (msg.includes('merge') || msg.includes('conflict')) {
+    console.log(`\nTip: Resolve conflicts and try again`);
+  }
+  
   process.exit(1);
 }
 
@@ -95,226 +87,10 @@ async function safeLog() {
   }
 }
 
-// Clean up AI-generated commit message
-function cleanCommitMessage(message, { body = false } = {}) {
-  if (!message) return 'Update project code';
-  // Remove markdown code blocks and formatting
-  let cleaned = message
-    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
-    .replace(/`([^`]+)`/g, '$1')    // Remove inline code formatting
-    .replace(/^\s*[-*+]\s*/gm, '')  // Remove bullet points
-    .replace(/^\s*\d+\.\s*/gm, '')  // Remove numbered lists
-    .replace(/^\s*#+\s*/gm, '')     // Remove headers
-    .replace(/\*\*(.*?)\*\*/g, '$1') // Remove bold formatting
-    .replace(/\*(.*?)\*/g, '$1')     // Remove italic formatting
-    .replace(/[\u{1F300}-\u{1FAFF}]/gu, '') // strip most emojis
-    .replace(/[\t\r]+/g, ' ')
-    .trim();
-
-  // If a body is allowed, split subject/body, otherwise keep first line only
-  const lines = cleaned.split('\n').map(l => l.trim()).filter(Boolean);
-  let subject = (lines[0] || '').replace(/\s{2,}/g, ' ').replace(/[\s:,.!;]+$/g, '').trim();
-  if (subject.length === 0) subject = 'Update project code';
-  // Enforce concise subject
-  if (subject.length > 72) subject = subject.substring(0, 69) + '...';
-
-  if (!body) return subject;
-
-  const bodyLines = lines.slice(1).filter(l => l.length > 0);
-  const bodyText = bodyLines.join('\n').trim();
-  return bodyText ? `${subject}\n\n${bodyText}` : subject;
-}
-
-// Estimate tokens (rough approximation: 1 token ≈ 4 characters)
-function estimateTokens(text) {
-  return Math.ceil((text || '').length / 4);
-}
-
-function resolveProvider(pref) {
-  // pref: auto|openai|gemini|groq|none
-  if (pref === 'none') return 'none';
-  if (pref === 'openai') return process.env.OPENAI_API_KEY ? 'openai' : 'none';
-  if (pref === 'gemini') return process.env.GEMINI_API_KEY ? 'gemini' : 'none';
-  if (pref === 'groq') return process.env.GROQ_API_KEY ? 'groq' : 'none';
-  // auto
-  if (process.env.GEMINI_API_KEY) return 'gemini';
-  if (process.env.OPENAI_API_KEY) return 'openai';
-  if (process.env.GROQ_API_KEY) return 'groq';
-  return 'none';
-}
 
-async function getHumanReadableChanges(limitPerList = 10) {
-  try {
-    const status = await git.status();
-    const modified = status.modified.slice(0, limitPerList);
-    const created = status.created.slice(0, limitPerList);
-    const deleted = status.deleted.slice(0, limitPerList);
-    const renamed = status.renamed.map(r => `${r.from}→${r.to}`).slice(0, limitPerList);
-    const parts = [];
-    if (created.length) parts.push(`Added: ${created.join(', ')}`);
-    if (modified.length) parts.push(`Modified: ${modified.join(', ')}`);
-    if (deleted.length) parts.push(`Deleted: ${deleted.join(', ')}`);
-    if (renamed.length) parts.push(`Renamed: ${renamed.join(', ')}`);
-    return parts.join('\n');
-  } catch (_) {
-    return 'Multiple file changes.';
-  }
-}
 
-function localHeuristicMessage(status, { conventional = false } = {}) {
-  const created = status.created.length;
-  const modified = status.modified.length;
-  const deleted = status.deleted.length;
-  const total = created + modified + deleted + status.renamed.length;
-
-  const listFew = (arr) => arr.slice(0, 3).join(', ') + (arr.length > 3 ? ` and ${arr.length - 3} more` : '');
-
-  let type = 'chore';
-  let subject = 'update files';
-  if (created > 0 && modified === 0 && deleted === 0) {
-    type = 'feat';
-    subject = created <= 3 ? `add ${listFew(status.created)}` : `add ${created} files`;
-  } else if (deleted > 0 && created === 0 && modified === 0) {
-    type = 'chore';
-    subject = deleted <= 3 ? `remove ${listFew(status.deleted)}` : `remove ${deleted} files`;
-  } else if (modified > 0 && created === 0 && deleted === 0) {
-    type = 'chore';
-    subject = modified <= 3 ? `update ${listFew(status.modified)}` : `update ${modified} files`;
-  } else if (created > 0 || deleted > 0 || modified > 0) {
-    type = 'chore';
-    subject = `update ${total} files`;
-  }
-  const msg = conventional ? `${type}: ${subject}` : subject.charAt(0).toUpperCase() + subject.slice(1);
-  return msg;
-}
-
-// Generate commit message with multiple fallback strategies
 async function generateCommitMessage(rawDiff, options = {}) {
-  const { conventional = false, body = false, provider: prefProvider = 'auto', model = '', verbose = false } = options;
-  const MAX_TOKENS = 100000; // Conservative limit (well below 128k)
-  const MAX_CHARS = MAX_TOKENS * 4;
-
-  let content = rawDiff;
-  let strategy = 'full';
-
-  const logv = (m) => { if (verbose) console.log(color.cyan(`[gims] ${m}`)); };
-
-  // Strategy 1: Check if full diff is too large
-  if (estimateTokens(rawDiff) > MAX_TOKENS) {
-    strategy = 'summary';
-    try {
-      const summary = await git.diffSummary();
-      content = summary.files
-        .map(f => `${f.file}: +${f.insertions} -${f.deletions}`)
-        .join('\n');
-    } catch (e) {
-      strategy = 'fallback';
-      content = 'Large changes across multiple files';
-    }
-  }
-
-  // Strategy 2: If summary is still too large, use status
-  if (strategy === 'summary' && estimateTokens(content) > MAX_TOKENS) {
-    strategy = 'status';
-    try {
-      const status = await git.status();
-      const modified = status.modified.slice(0, 10);
-      const created = status.created.slice(0, 10);
-      const deleted = status.deleted.slice(0, 10);
-      const renamed = status.renamed.map(r => `${r.from}→${r.to}`).slice(0, 10);
-
-      content = [
-        modified.length > 0 ? `Modified: ${modified.join(', ')}` : '',
-        created.length > 0 ? `Added: ${created.join(', ')}` : '',
-        deleted.length > 0 ? `Deleted: ${deleted.join(', ')}` : '',
-        renamed.length > 0 ? `Renamed: ${renamed.join(', ')}` : '',
-      ].filter(Boolean).join('\n');
-
-      if (status.files.length > 30) {
-        content += `\n... and ${status.files.length - 30} more files`;
-      }
-    } catch (e) {
-      strategy = 'fallback';
-      content = 'Large changes across multiple files';
-    }
-  }
-
-  // Strategy 3: If still too large, truncate
-  if (estimateTokens(content) > MAX_TOKENS) {
-    strategy = 'truncated';
-    content = content.substring(0, MAX_CHARS - 1000) + '\n... (truncated)';
-  }
-
-  const prompts = {
-    full: 'Write a concise git commit message for these changes:',
-    summary: 'Changes are large; using summary. Write a concise git commit message for these changes:',
-    status: 'Many files changed. Write a concise git commit message based on these file changes:',
-    truncated: 'Large diff truncated. Write a concise git commit message for these changes:',
-    fallback: 'Write a concise git commit message for:',
-  };
-
-  const style = conventional ? 'Use Conventional Commits (e.g., feat:, fix:, chore:) for the subject.' : 'Subject must be a single short line.';
-  const bodyInstr = body ? 'Provide a short subject line followed by an optional body separated by a blank line.' : 'Return only a short subject line without extra quotes.';
-  const prompt = `${prompts[strategy]}\n${content}\n\n${style} ${bodyInstr}`;
-
-  // Final safety check
-  if (estimateTokens(prompt) > MAX_TOKENS) {
-    console.warn(color.yellow('Changes too large for AI analysis, using default message'));
-    return cleanCommitMessage('Update multiple files', { body });
-  }
-
-  let message = 'Update project code'; // Default fallback
-  const provider = resolveProvider(prefProvider);
-  logv(`strategy=${strategy}, provider=${provider}${model ? `, model=${model}` : ''}`);
-
-  try {
-    if (provider === 'gemini') {
-      const genai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
-      const res = await genai.models.generateContent({
-        model: model || 'gemini-2.0-flash',
-        contents: prompt,
-      });
-      message = (await res.response.text()).trim();
-    } else if (provider === 'openai') {
-      const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-      const res = await openai.chat.completions.create({
-        model: model || 'gpt-4o-mini',
-        messages: [{ role: 'user', content: prompt }],
-        temperature: 0.3,
-        max_tokens: body ? 200 : 80,
-      });
-      message = (res.choices[0] && res.choices[0].message && res.choices[0].message.content || '').trim();
-    } else if (provider === 'groq') {
-      // Use OpenAI-compatible API via baseURL
-      const groq = new OpenAI({ apiKey: process.env.GROQ_API_KEY, baseURL: process.env.GROQ_BASE_URL || 'https://api.groq.com/openai/v1' });
-      const res = await groq.chat.completions.create({
-        model: model || 'llama-3.1-8b-instant',
-        messages: [{ role: 'user', content: prompt }],
-        temperature: 0.3,
-        max_tokens: body ? 200 : 80,
-      });
-      message = (res.choices[0] && res.choices[0].message && res.choices[0].message.content || '').trim();
-    } else {
-      // Local heuristic fallback
-      const status = await git.status();
-      message = localHeuristicMessage(status, { conventional });
-      const human = await getHumanReadableChanges();
-      if (body) message = `${message}\n\n${human}`;
-    }
-  } catch (error) {
-    if (error && error.code === 'context_length_exceeded') {
-      console.warn(color.yellow('Content still too large for AI, using default message'));
-      return cleanCommitMessage('Update multiple files', { body });
-    }
-    console.warn(color.yellow(`AI generation failed: ${error && error.message ? error.message : error}`));
-    // fallback to local heuristic
-    const status = await git.status();
-    message = localHeuristicMessage(status, { conventional });
-    const human = await getHumanReadableChanges();
-    if (body) message = `${message}\n\n${human}`;
-  }
-
-  return cleanCommitMessage(message, { body });
+  return await aiProvider.generateCommitMessage(rawDiff, options);
 }
 
 async function resolveCommit(input) {
@@ -350,12 +126,216 @@ program
   .option('--json', 'JSON output for suggest')
   .option('--yes', 'Assume yes for confirmations')
   .option('--amend', 'Amend the last commit instead of creating a new one')
-  .option('--set-upstream', 'Set upstream on push if missing');
+  .option('--set-upstream', 'Set upstream on push if missing')
+  .hook('preAction', () => {
+    initializeComponents();
+  });
+
+program.command('setup')
+  .description('Run interactive setup wizard')
+  .option('--api-key <provider>', 'Quick API key setup (openai|gemini|groq)')
+  .action(async (options) => {
+    try {
+      if (options.apiKey) {
+        await setupApiKey(options.apiKey);
+      } else {
+        await configManager.runSetupWizard();
+      }
+    } catch (e) {
+      handleError('Setup error', e);
+    }
+  });
+
+async function setupApiKey(provider) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const question = (prompt) => new Promise(resolve => {
+    rl.question(prompt, answer => {
+      resolve(answer.trim());
+    });
+  });
+
+  console.log(color.bold(`\n🔑 ${provider.toUpperCase()} API Key Setup\n`));
+  
+  const envVars = {
+    'openai': 'OPENAI_API_KEY',
+    'gemini': 'GEMINI_API_KEY', 
+    'groq': 'GROQ_API_KEY'
+  };
+
+  const envVar = envVars[provider.toLowerCase()];
+  if (!envVar) {
+    console.log(color.red('Invalid provider. Use: openai, gemini, or groq'));
+    rl.close();
+    return;
+  }
+
+  console.log(`To get your ${provider.toUpperCase()} API key:`);
+  if (provider === 'openai') {
+    console.log('1. Go to: https://platform.openai.com/api-keys');
+    console.log('2. Create a new API key');
+  } else if (provider === 'gemini') {
+    console.log('1. Go to: https://aistudio.google.com/app/apikey');
+    console.log('2. Create a new API key');
+  } else if (provider === 'groq') {
+    console.log('1. Go to: https://console.groq.com/keys');
+    console.log('2. Create a new API key');
+  }
+
+  const apiKey = await question(`\nEnter your ${provider.toUpperCase()} API key: `);
+  
+  if (!apiKey) {
+    console.log(color.yellow('No API key provided. Setup cancelled.'));
+    rl.close();
+    return;
+  }
+
+  rl.close();
+
+  // Show how to set the environment variable
+  console.log(`\n${color.green('✓')} API key received!`);
+  console.log('\nTo use this API key, set the environment variable:');
+  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`);
+  console.log(`  ${color.cyan('g o')} - AI commit and push`);
+}
+
+program.command('status').alias('s')
+  .description('Enhanced git status with AI insights')
+  .action(async () => {
+    await ensureRepo();
+    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) {
+        console.log(`\n${color.bold('Recent Activity:')}`);
+        console.log(`${history.recentActivity.last24h} commits in last 24h, ${history.recentActivity.lastWeek} in last week`);
+        if (history.conventionalCommits > 0) {
+          const percentage = Math.round((history.conventionalCommits / history.totalCommits) * 100);
+          console.log(`${percentage}% of recent commits use Conventional Commits format`);
+        }
+      }
+    } catch (e) {
+      handleError('Status error', e);
+    }
+  });
+
+program.command('interactive').alias('i')
+  .description('Interactive commit wizard')
+  .action(async () => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      await interactive.runInteractiveCommit(opts);
+    } catch (e) {
+      handleError('Interactive commit error', e);
+    }
+  });
+
+program.command('preview').alias('p')
+  .description('Preview commit with AI-generated message')
+  .action(async () => {
+    await ensureRepo();
+    const opts = getOpts();
+    try {
+      await interactive.showCommitPreview(opts);
+    } catch (e) {
+      handleError('Preview error', e);
+    }
+  });
+
+program.command('config')
+  .description('Manage GIMS configuration')
+  .option('--set <key=value>', 'Set configuration value')
+  .option('--get <key>', 'Get configuration value')
+  .option('--list', 'List all configuration')
+  .option('--global', 'Use global configuration')
+  .action(async (options) => {
+    try {
+      if (options.set) {
+        const [key, value] = options.set.split('=');
+        if (!key || value === undefined) {
+          console.log('Usage: --set key=value');
+          return;
+        }
+        const result = configManager.set(key, value, options.global);
+        Progress.success(`Set ${result.key}=${result.value} in ${result.savedPath}`);
+      } else if (options.get) {
+        const value = configManager.get(options.get);
+        console.log(value !== undefined ? value : 'Not set');
+      } else if (options.list) {
+        const config = configManager.get();
+        console.log(color.bold('Current Configuration:'));
+        Object.entries(config).forEach(([key, value]) => {
+          if (key !== '_source') {
+            console.log(`  ${color.cyan(key)}: ${value}`);
+          }
+        });
+        console.log(`\n${color.dim('Source: ' + config._source)}`);
+      } else {
+        console.log('Use --set, --get, or --list');
+      }
+    } catch (e) {
+      handleError('Config error', e);
+    }
+  });
+
+program.command('help-quick').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')}    Interactive - Guided commit wizard`);
+    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 h')}    History - Numbered commit log`);
+    console.log(`  ${color.cyan('g a')}    Amend - Smart amend with AI`);
+    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')}    🚀 Fast & free (recommended)`);
+    console.log(`  ${color.cyan('g setup --api-key openai')}    💎 High quality`);
+    console.log(`  ${color.cyan('g setup --api-key groq')}      ⚡ Ultra fast\n`);
+    
+    console.log(color.bold('Essential Workflow:'));
+    console.log(`  ${color.cyan('g s')}              Check what's changed`);
+    console.log(`  ${color.cyan('g i')} or ${color.cyan('g o')}        Commit with AI`);
+    console.log(`  ${color.cyan('g h')}              View history\n`);
+    
+    console.log(`For full help: ${color.cyan('g --help')}`);
+    console.log(`For detailed docs: See README.md`);
+  });
 
-program.command('init').alias('i')
+program.command('init')
   .description('Initialize a new Git repository')
   .action(async () => { 
-    try { await git.init(); console.log('Initialized repo.'); }
+    try { 
+      await git.init(); 
+      Progress.success('Initialized git repository');
+      console.log(`\nNext steps:`);
+      console.log(`  ${color.cyan('g setup')} - Configure GIMS`);
+      console.log(`  ${color.cyan('g s')} - Check repository status`);
+    }
     catch (e) { handleError('Init error', e); }
   });
 
@@ -366,14 +346,16 @@ program.command('clone <repo>').alias('c')
     catch (e) { handleError('Clone error', e); }
   });
 
-program.command('suggest').alias('s')
+program.command('suggest').alias('sg')
   .description('Suggest commit message and copy to clipboard')
-  .action(async () => {
+  .option('--multiple', 'Generate multiple suggestions')
+  .action(async (cmdOptions) => {
     await ensureRepo();
     const opts = getOpts();
 
     try {
       if (opts.all) {
+        Progress.info('Staging all changes...');
         await git.add('.');
       }
 
@@ -381,26 +363,52 @@ program.command('suggest').alias('s')
       const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
       if (!rawDiff.trim()) {
         if (opts.all) {
-          console.log('No changes to suggest.');
+          Progress.warning('No changes to suggest');
           return;
         }
-        console.log('No staged changes. Use --all to stage everything or stage files manually.');
+        Progress.warning('No staged changes. Use --all to stage everything or stage files manually');
         return;
       }
 
-      const msg = await generateCommitMessage(rawDiff, opts);
+      if (cmdOptions.multiple) {
+        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]); 
+            console.log(`\n${color.green('✓')} First suggestion copied to clipboard`);
+          } catch (_) { 
+            console.log(`\n${color.yellow('⚠')} Clipboard copy failed`);
+          }
+        }
+      } else {
+        if (opts.progressIndicators) Progress.start('🤖 Analyzing changes');
+        const msg = await generateCommitMessage(rawDiff, opts);
+        if (opts.progressIndicators) Progress.stop('');
 
-      if (opts.json) {
-        const out = { message: msg };
-        console.log(JSON.stringify(out));
-        return;
-      }
+        if (opts.json) {
+          const out = { message: msg };
+          console.log(JSON.stringify(out));
+          return;
+        }
 
-      if (!opts.noClipboard) {
-        try { clipboard.writeSync(msg); console.log(`Suggested: "${msg}" ${color.green('(copied to clipboard)')}`); }
-        catch (_) { console.log(`Suggested: "${msg}" ${color.yellow('(clipboard copy failed)')}`); }
-      } else {
-        console.log(`Suggested: "${msg}"`);
+        if (!opts.noClipboard) {
+          try { 
+            clipboard.writeSync(msg); 
+            Progress.success(`"${msg}" (copied to clipboard)`);
+          } catch (_) { 
+            console.log(`Suggested: "${msg}" ${color.yellow('(clipboard copy failed)')}`);
+          }
+        } else {
+          console.log(`Suggested: "${msg}"`);
+        }
       }
     } catch (e) {
       handleError('Suggest error', e);
@@ -415,16 +423,29 @@ program.command('local').alias('l')
 
     try {
       if (!(await hasChanges()) && !opts.all) {
-        console.log('No changes to commit.');
+        Progress.warning('No changes to commit');
         return;
       }
 
-      if (opts.all) await git.add('.');
+      if (opts.all) {
+        Progress.info('Staging all changes...');
+        await git.add('.');
+      }
 
-      const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
-      if (!rawDiff.trim()) { console.log('No staged changes to commit.'); return; }
+      let rawDiff = await git.diff(['--cached', '--no-ext-diff']);
+      if (!rawDiff.trim()) {
+        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 (opts.progressIndicators) Progress.start('🤖 Generating commit message');
       const msg = await generateCommitMessage(rawDiff, opts);
+      if (opts.progressIndicators) Progress.stop('');
 
       if (opts.dryRun) {
         console.log(color.yellow('[dry-run] Would commit with message:'));
@@ -434,10 +455,11 @@ program.command('local').alias('l')
 
       if (opts.amend) {
         await git.raw(['commit', '--amend', '-m', msg]);
+        Progress.success(`Amended commit: "${msg}"`);
       } else {
         await git.commit(msg);
+        Progress.success(`Committed locally: "${msg}"`);
       }
-      console.log(`Committed locally: "${msg}"`);
     } catch (e) {
       handleError('Local commit error', e);
     }
@@ -451,16 +473,29 @@ program.command('online').alias('o')
 
     try {
       if (!(await hasChanges()) && !opts.all) {
-        console.log('No changes to commit.');
+        Progress.warning('No changes to commit');
         return;
       }
 
-      if (opts.all) await git.add('.');
+      if (opts.all) {
+        Progress.info('Staging all changes...');
+        await git.add('.');
+      }
 
-      const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
-      if (!rawDiff.trim()) { console.log('No staged changes to commit.'); return; }
+      let rawDiff = await git.diff(['--cached', '--no-ext-diff']);
+      if (!rawDiff.trim()) {
+        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 (opts.progressIndicators) Progress.start('🤖 Generating commit message');
       const msg = await generateCommitMessage(rawDiff, opts);
+      if (opts.progressIndicators) Progress.stop('');
 
       if (opts.dryRun) {
         console.log(color.yellow('[dry-run] Would commit & push with message:'));
@@ -468,6 +503,7 @@ program.command('online').alias('o')
         return;
       }
 
+      Progress.info('Committing changes...');
       if (opts.amend) {
         await git.raw(['commit', '--amend', '-m', msg]);
       } else {
@@ -475,18 +511,20 @@ program.command('online').alias('o')
       }
 
       try {
+        Progress.info('Pushing to remote...');
         await git.push();
-        console.log(`Committed & pushed: "${msg}"`);
+        Progress.success(`Committed & pushed: "${msg}"`);
       } catch (pushErr) {
         const msgErr = pushErr && pushErr.message ? pushErr.message : String(pushErr);
         if (/no upstream|set the remote as upstream|have no upstream/.test(msgErr)) {
           // Try to set upstream if requested
           if (opts.setUpstream) {
+            Progress.info('Setting upstream branch...');
             const branch = (await git.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
             await git.push(['--set-upstream', 'origin', branch]);
-            console.log(`Committed & pushed (upstream set to origin/${branch}): "${msg}"`);
+            Progress.success(`Committed & pushed (upstream set to origin/${branch}): "${msg}"`);
           } else {
-            console.log(color.yellow('Current branch has no upstream. Use --set-upstream to set origin/<branch> automatically.'));
+            Progress.warning('Current branch has no upstream. Use --set-upstream to set origin/<branch> automatically');
           }
         } else {
           throw pushErr;
@@ -514,8 +552,14 @@ program.command('commit <message...>').alias('m')
 
       if (opts.all) await git.add('.');
 
-      const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
-      if (!rawDiff.trim()) { console.log('No staged changes to commit.'); return; }
+      let rawDiff = await git.diff(['--cached', '--no-ext-diff']);
+      if (!rawDiff.trim()) {
+        // Auto-stage all changes by default when nothing is staged
+        console.log(color.yellow('No staged changes found; staging all changes (git add .).'));
+        await git.add('.');
+        rawDiff = await git.diff(['--cached', '--no-ext-diff']);
+        if (!rawDiff.trim()) { console.log('No changes to commit.'); return; }
+      }
 
       if (opts.dryRun) {
         console.log(color.yellow('[dry-run] Would commit with custom message:'));
@@ -534,61 +578,195 @@ program.command('commit <message...>').alias('m')
     }
   });
 
-program.command('pull').alias('p')
+program.command('pull')
   .description('Pull latest changes')
   .action(async () => {
     await ensureRepo();
-    try { await git.pull(); console.log('Pulled latest.'); }
+    try { 
+      Progress.info('Pulling latest changes...');
+      await git.pull(); 
+      Progress.success('Pulled latest changes');
+    }
     catch (e) { handleError('Pull error', e); }
   });
 
+program.command('sync')
+  .description('Smart sync: pull + rebase/merge')
+  .option('--rebase', 'Use rebase instead of merge')
+  .action(async (cmdOptions) => {
+    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) {
+            Progress.info('Rebasing...');
+            await git.rebase([remoteBranch]);
+            Progress.success('Rebased successfully');
+          } else {
+            Progress.info('Merging...');
+            await git.merge([remoteBranch]);
+            Progress.success('Merged successfully');
+          }
+        } else {
+          Progress.info('Fast-forwarding...');
+          await git.merge([remoteBranch]);
+          Progress.success('Fast-forwarded successfully');
+        }
+      } catch (error) {
+        if (error.message.includes('unknown revision')) {
+          Progress.info('No remote tracking branch, pulling...');
+          await git.pull();
+          Progress.success('Pulled latest changes');
+        } else {
+          throw error;
+        }
+      }
+    } catch (e) { 
+      handleError('Sync error', e); 
+    }
+  });
+
+program.command('stash')
+  .description('Enhanced stash with AI descriptions')
+  .option('--list', 'List stashes')
+  .option('--pop', 'Pop latest stash')
+  .option('--apply <n>', 'Apply stash by index')
+  .action(async (cmdOptions) => {
+    await ensureRepo();
+    try {
+      if (cmdOptions.list) {
+        const stashes = await git.stashList();
+        if (stashes.all.length === 0) {
+          Progress.info('No stashes found');
+          return;
+        }
+        
+        console.log(color.bold('Stashes:'));
+        stashes.all.forEach((stash, i) => {
+          console.log(`${color.cyan((i).toString())}. ${stash.message}`);
+        });
+      } else if (cmdOptions.pop) {
+        await git.stash(['pop']);
+        Progress.success('Popped latest stash');
+      } else if (cmdOptions.apply !== undefined) {
+        const index = parseInt(cmdOptions.apply);
+        await git.stash(['apply', `stash@{${index}}`]);
+        Progress.success(`Applied stash ${index}`);
+      } else {
+        // Create new stash with AI description
+        const status = await git.status();
+        if (status.files.length === 0) {
+          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 
+        });
+        Progress.stop('');
+        
+        await git.stash(['push', '-m', `WIP: ${description}`]);
+        Progress.success(`Stashed changes: "${description}"`);
+      }
+    } catch (e) {
+      handleError('Stash error', e);
+    }
+  });
+
 program.command('amend').alias('a')
-  .description('Stage all changes and amend last commit (no message edit)')
-  .action(async () => {
+  .description('Stage all changes and amend last commit')
+  .option('--no-edit', 'Keep existing commit message')
+  .action(async (cmdOptions) => {
     await ensureRepo();
     try {
       const { all } = await safeLog();
       if (!all || all.length === 0) {
-        console.log('No commits to amend. Make an initial commit first.');
+        Progress.warning('No commits to amend. Make an initial commit first');
         return;
       }
 
+      Progress.info('Staging all changes...');
       await git.add('.');
 
       const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
       if (!rawDiff.trim()) {
-        console.log('No staged changes to amend.');
+        Progress.warning('No staged changes to amend');
         return;
       }
 
-      await git.raw(['commit', '--amend', '--no-edit']);
-      console.log('Amended last commit with staged changes.');
+      if (cmdOptions.noEdit) {
+        await git.raw(['commit', '--amend', '--no-edit']);
+        Progress.success('Amended last commit with staged changes');
+      } else {
+        // Generate new message for amend
+        Progress.start('🤖 Generating updated commit message');
+        const newMessage = await generateCommitMessage(rawDiff, getOpts());
+        Progress.stop('');
+        
+        await git.raw(['commit', '--amend', '-m', newMessage]);
+        Progress.success(`Amended commit: "${newMessage}"`);
+      }
     } catch (e) {
       handleError('Amend error', e);
     }
   });
 
-program.command('list').alias('ls')
-  .description('Short numbered git log (oldest → newest)')
-  .action(async () => {
+program.command('list').alias('h')
+  .description('Numbered git log (oldest → newest)')
+  .option('--detailed', 'Show detailed information')
+  .option('--limit <n>', 'Limit number of commits', '20')
+  .action(async (cmdOptions) => {
     await ensureRepo();
     try {
-      const { all } = await safeLog();
-      [...all].reverse().forEach((c, i) => console.log(`${i+1}. ${c.hash.slice(0,7)} ${c.message}`));
-    } catch (e) { handleError('List error', e); }
-  });
-
-program.command('largelist').alias('ll')
-  .description('Full numbered git log (oldest → newest)')
-  .action(async () => {
-    await ensureRepo();
-    try {
-      const { all } = await safeLog();
-      [...all].reverse().forEach((c, i) => {
-        const date = new Date(c.date).toLocaleString();
-        console.log(`${i+1}. ${c.hash.slice(0,7)} | ${date} | ${c.author_name} → ${c.message}`);
+      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) => {
+        if (cmdOptions.detailed) {
+          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}`);
+        } else {
+          console.log(`${color.cyan((i+1).toString())}. ${color.yellow(c.hash.slice(0,7))} ${c.message}`);
+        }
       });
-    } catch (e) { handleError('Largelist error', e); }
+      
+      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); 
+    }
   });
 
 program.command('branch <c> [name]').alias('b')
@@ -641,15 +819,35 @@ program.command('undo').alias('u')
   .action(async (cmd) => {
     await ensureRepo();
     try {
+      const { all } = await safeLog();
+      if (!all || all.length === 0) {
+        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 run: git reset ${mode} HEAD~1. Use --yes to confirm.`));
+        console.log(color.yellow(`About to undo: "${lastCommit.message}"`));
+        console.log(color.yellow(`This will run: git reset ${mode} HEAD~1`));
+        if (mode === '--hard') {
+          console.log(color.red('WARNING: Hard reset will permanently delete uncommitted changes!'));
+        }
+        console.log('Use --yes to confirm.');
         process.exit(1);
       }
+      
       await git.raw(['reset', mode, 'HEAD~1']);
-      console.log(`Reset (${mode}) to HEAD~1`);
-    } catch (e) { handleError('Undo error', e); }
+      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); 
+    }
   });
 
 program.parse(process.argv);