s41r4j
5846c77f51
- Remove 72-char limit on AI-generated commit messages (no more ... truncation) - Add [Y/n] confirmation prompt when using local heuristics (no AI provider) - Default to Y (press Enter to accept) - Clearly warns user about local heuristics vs AI - Bypass with --yes flag for automation - Enhanced transparency: users now know when AI is used vs local pattern matching - Safer commits when API keys are not configured - Bumped version to 0.6.6
975 lines
32 KiB
JavaScript
Executable File
975 lines
32 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
/*
|
|
gims (Git Made Simple) CLI - Enhanced Version
|
|
*/
|
|
const { Command } = require('commander');
|
|
const simpleGit = require('simple-git');
|
|
const clipboard = require('clipboardy');
|
|
const process = require('process');
|
|
|
|
// 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();
|
|
|
|
// Initialize enhanced components
|
|
const configManager = new ConfigManager();
|
|
const gitAnalyzer = new GitAnalyzer(git);
|
|
let aiProvider;
|
|
let interactive;
|
|
|
|
function getOpts() {
|
|
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 || cfg.autoStage,
|
|
noClipboard: !!cli.noClipboard || cfg.copy === false,
|
|
body: !!cli.body,
|
|
conventional: !!cli.conventional || cfg.conventional,
|
|
dryRun: !!cli.dryRun,
|
|
verbose: !!cli.verbose,
|
|
json: !!cli.json,
|
|
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) {
|
|
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);
|
|
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);
|
|
}
|
|
|
|
// Safe log: returns { all: [] } on empty repo
|
|
async function safeLog() {
|
|
try {
|
|
return await git.log();
|
|
} catch (e) {
|
|
if (/does not have any commits/.test(e.message)) return { all: [] };
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
async function generateCommitMessage(rawDiff, options = {}) {
|
|
const result = await aiProvider.generateCommitMessage(rawDiff, options);
|
|
// Return both message and whether local heuristics were used
|
|
return result;
|
|
}
|
|
|
|
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,
|
|
output: process.stdout
|
|
});
|
|
|
|
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();
|
|
const trimmed = answer.trim().toLowerCase();
|
|
// Default to 'yes' if empty (just Enter pressed)
|
|
resolve(trimmed === '' || trimmed === 'y' || trimmed === 'yes');
|
|
});
|
|
});
|
|
}
|
|
|
|
async function resolveCommit(input) {
|
|
if (/^\d+$/.test(input)) {
|
|
const { all } = await safeLog();
|
|
// Align with list/largelist which show oldest -> newest
|
|
const ordered = [...all].reverse();
|
|
const idx = Number(input) - 1;
|
|
if (idx < 0 || idx >= ordered.length) throw new Error('Index out of range');
|
|
return ordered[idx].hash;
|
|
}
|
|
return input;
|
|
}
|
|
|
|
async function hasChanges() {
|
|
const status = await git.status();
|
|
return status.files.length > 0;
|
|
}
|
|
|
|
program
|
|
.name('gims')
|
|
.alias('g')
|
|
.version(require('../package.json').version)
|
|
.option('--provider <name>', 'AI provider: auto|openai|gemini|groq|none')
|
|
.option('--model <name>', 'Model identifier for provider')
|
|
.option('--staged-only', 'Use only staged changes (default for suggest)')
|
|
.option('--all', 'Stage all changes before running')
|
|
.option('--no-clipboard', 'Do not copy suggestions to clipboard')
|
|
.option('--body', 'Generate a commit body in addition to subject')
|
|
.option('--conventional', 'Format messages using Conventional Commits')
|
|
.option('--dry-run', 'Do not perform writes (no commit or push)')
|
|
.option('--verbose', 'Verbose logging')
|
|
.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')
|
|
.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('int')
|
|
.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')} 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`);
|
|
});
|
|
|
|
program.command('init').alias('i')
|
|
.description('Initialize a new Git repository')
|
|
.action(async () => {
|
|
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); }
|
|
});
|
|
|
|
program.command('clone <repo>').alias('c')
|
|
.description('Clone a Git repository')
|
|
.action(async (repo) => {
|
|
try { await git.clone(repo); console.log(`Cloned ${repo}`); }
|
|
catch (e) { handleError('Clone error', e); }
|
|
});
|
|
|
|
program.command('suggest').alias('sg')
|
|
.description('Suggest commit message and copy to clipboard')
|
|
.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('.');
|
|
}
|
|
|
|
// Use staged changes only; do not auto-stage unless --all
|
|
const rawDiff = await git.diff(['--cached', '--no-ext-diff']);
|
|
if (!rawDiff.trim()) {
|
|
if (opts.all) {
|
|
Progress.warning('No changes to suggest');
|
|
return;
|
|
}
|
|
Progress.warning('No staged changes. Use --all to stage everything or stage files manually');
|
|
return;
|
|
}
|
|
|
|
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 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'));
|
|
}
|
|
|
|
if (opts.json) {
|
|
const out = { message: msg, usedLocalHeuristics: usedLocal };
|
|
console.log(JSON.stringify(out));
|
|
return;
|
|
}
|
|
|
|
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);
|
|
}
|
|
});
|
|
|
|
program.command('local').alias('l')
|
|
.description('AI-powered local commit')
|
|
.action(async () => {
|
|
await ensureRepo();
|
|
const opts = getOpts();
|
|
|
|
try {
|
|
if (!(await hasChanges()) && !opts.all) {
|
|
Progress.warning('No changes to commit');
|
|
return;
|
|
}
|
|
|
|
if (opts.all) {
|
|
Progress.info('Staging all changes...');
|
|
await git.add('.');
|
|
}
|
|
|
|
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 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;
|
|
|
|
if (opts.dryRun) {
|
|
console.log(color.yellow('[dry-run] Would commit with message:'));
|
|
console.log(msg);
|
|
return;
|
|
}
|
|
|
|
// Ask for confirmation if using local heuristics (unless --yes flag is set)
|
|
if (usedLocal && !opts.yes) {
|
|
const confirmed = await confirmCommit(msg, true);
|
|
if (!confirmed) {
|
|
Progress.info('Commit cancelled');
|
|
return;
|
|
}
|
|
}
|
|
|
|
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}"`);
|
|
}
|
|
} catch (e) {
|
|
handleError('Local commit error', e);
|
|
}
|
|
});
|
|
|
|
program.command('online').alias('o')
|
|
.description('AI commit + push')
|
|
.action(async () => {
|
|
await ensureRepo();
|
|
const opts = getOpts();
|
|
|
|
try {
|
|
if (!(await hasChanges()) && !opts.all) {
|
|
Progress.warning('No changes to commit');
|
|
return;
|
|
}
|
|
|
|
if (opts.all) {
|
|
Progress.info('Staging all changes...');
|
|
await git.add('.');
|
|
}
|
|
|
|
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 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;
|
|
|
|
if (opts.dryRun) {
|
|
console.log(color.yellow('[dry-run] Would commit & push with message:'));
|
|
console.log(msg);
|
|
return;
|
|
}
|
|
|
|
// Ask for confirmation if using local heuristics (unless --yes flag is set)
|
|
if (usedLocal && !opts.yes) {
|
|
const confirmed = await confirmCommit(msg, true);
|
|
if (!confirmed) {
|
|
Progress.info('Commit cancelled');
|
|
return;
|
|
}
|
|
}
|
|
|
|
Progress.info('Committing changes...');
|
|
if (opts.amend) {
|
|
await git.raw(['commit', '--amend', '-m', msg]);
|
|
} else {
|
|
await git.commit(msg);
|
|
}
|
|
|
|
try {
|
|
Progress.info('Pushing to remote...');
|
|
await git.push();
|
|
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]);
|
|
Progress.success(`Committed & pushed (upstream set to origin/${branch}): "${msg}"`);
|
|
} else {
|
|
Progress.warning('Current branch has no upstream. Use --set-upstream to set origin/<branch> automatically');
|
|
}
|
|
} else {
|
|
throw pushErr;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
handleError('Online commit error', e);
|
|
}
|
|
});
|
|
|
|
program.command('commit <message...>').alias('m')
|
|
.description('Commit with a custom message (no AI)')
|
|
.action(async (messageParts) => {
|
|
await ensureRepo();
|
|
const opts = getOpts();
|
|
|
|
try {
|
|
const msg = (messageParts || []).join(' ').trim();
|
|
if (!msg) { console.log('Provide a commit message.'); return; }
|
|
|
|
if (!(await hasChanges()) && !opts.all) {
|
|
console.log('No changes to commit.');
|
|
return;
|
|
}
|
|
|
|
if (opts.all) await git.add('.');
|
|
|
|
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:'));
|
|
console.log(msg);
|
|
return;
|
|
}
|
|
|
|
if (opts.amend) {
|
|
await git.raw(['commit', '--amend', '-m', msg]);
|
|
} else {
|
|
await git.commit(msg);
|
|
}
|
|
console.log(`Committed locally: "${msg}"`);
|
|
} catch (e) {
|
|
handleError('Commit error', e);
|
|
}
|
|
});
|
|
|
|
program.command('pull')
|
|
.description('Pull latest changes')
|
|
.action(async () => {
|
|
await ensureRepo();
|
|
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 (keeps message)')
|
|
.option('--edit', 'Generate new AI commit message')
|
|
.action(async (cmdOptions) => {
|
|
await ensureRepo();
|
|
try {
|
|
const { all } = await safeLog();
|
|
if (!all || all.length === 0) {
|
|
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()) {
|
|
Progress.warning('No staged changes to amend');
|
|
return;
|
|
}
|
|
|
|
if (cmdOptions.edit) {
|
|
// Generate new message for amend
|
|
const opts = getOpts();
|
|
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);
|
|
if (!confirmed) {
|
|
Progress.info('Amend cancelled');
|
|
return;
|
|
}
|
|
}
|
|
|
|
await git.raw(['commit', '--amend', '-m', newMessage]);
|
|
Progress.success(`Amended commit: "${newMessage}"`);
|
|
} else {
|
|
// Default: Keep existing message (--no-edit)
|
|
await git.raw(['commit', '--amend', '--no-edit']);
|
|
Progress.success('Amended last commit with staged changes (kept original message)');
|
|
}
|
|
} catch (e) {
|
|
handleError('Amend error', e);
|
|
}
|
|
});
|
|
|
|
program.command('list').alias('ls')
|
|
.description('Short numbered git log (oldest → newest)')
|
|
.option('--limit <n>', 'Limit number of commits', '20')
|
|
.action(async (cmdOptions) => {
|
|
await ensureRepo();
|
|
try {
|
|
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}`);
|
|
});
|
|
|
|
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('largelist').alias('ll')
|
|
.description('Detailed numbered git log (oldest → newest)')
|
|
.option('--limit <n>', 'Limit number of commits', '20')
|
|
.action(async (cmdOptions) => {
|
|
await ensureRepo();
|
|
try {
|
|
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}`);
|
|
});
|
|
|
|
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);
|
|
}
|
|
});
|
|
|
|
program.command('history').alias('h')
|
|
.description('Numbered git log (alias for list)')
|
|
.option('--limit <n>', 'Limit number of commits', '20')
|
|
.action(async (cmdOptions) => {
|
|
await ensureRepo();
|
|
try {
|
|
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}`);
|
|
});
|
|
|
|
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);
|
|
}
|
|
});
|
|
|
|
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}`); }
|
|
catch (e) { handleError('Branch error', e); }
|
|
});
|
|
|
|
program.command('reset <c>').alias('r')
|
|
.description('Reset branch to commit/index')
|
|
.option('--hard','hard reset')
|
|
.action(async (c, optsCmd) => {
|
|
await ensureRepo();
|
|
try {
|
|
const sha = await resolveCommit(c);
|
|
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.`));
|
|
process.exit(1);
|
|
}
|
|
await git.raw(['reset', mode, sha]);
|
|
console.log(`Reset (${mode}) to ${sha}`);
|
|
}
|
|
catch (e) { handleError('Reset error', e); }
|
|
});
|
|
|
|
program.command('revert <c>').alias('rv')
|
|
.description('Revert commit/index safely')
|
|
.action(async (c) => {
|
|
await ensureRepo();
|
|
try {
|
|
const sha = await resolveCommit(c);
|
|
const opts = getOpts();
|
|
if (!opts.yes) {
|
|
console.log(color.yellow(`About to run: git revert ${sha}. Use --yes to confirm.`));
|
|
process.exit(1);
|
|
}
|
|
await git.revert(sha);
|
|
console.log(`Reverted ${sha}`);
|
|
}
|
|
catch (e) { handleError('Revert error', e); }
|
|
});
|
|
|
|
program.command('undo').alias('u')
|
|
.description('Undo last commit (soft reset to HEAD~1)')
|
|
.option('--hard', 'Hard reset instead (destructive)')
|
|
.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 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']);
|
|
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);
|