s41r4j
1790 lines
59 KiB
JavaScript
Executable File
1790 lines
59 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 { Intelligence } = require('./lib/utils/intelligence');
|
|
const { VersionCommand } = require('./lib/commands/version');
|
|
const { WhoAmICommand } = require('./lib/commands/whoami');
|
|
|
|
const program = new Command();
|
|
const git = simpleGit();
|
|
|
|
// Initialize enhanced components
|
|
const configManager = new ConfigManager();
|
|
const gitAnalyzer = new GitAnalyzer(git);
|
|
let aiProvider;
|
|
let interactive;
|
|
let versionCmd;
|
|
let whoAmI;
|
|
|
|
// ... (getOpts function remains) ...
|
|
|
|
function initializeComponents() {
|
|
const config = configManager.load();
|
|
aiProvider = new AIProviderManager(config);
|
|
interactive = new InteractiveCommands(git, aiProvider, gitAnalyzer);
|
|
versionCmd = new VersionCommand(git, configManager);
|
|
whoAmI = new WhoAmICommand(git);
|
|
}
|
|
|
|
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,
|
|
};
|
|
}
|
|
|
|
|
|
|
|
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, '--version', 'Output the version number') // Removed -v
|
|
.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('quick-help').alias('q')
|
|
.description('Show quick reference for main commands')
|
|
.action(() => {
|
|
console.log(color.bold('🚀 GIMS Quick Reference\n'));
|
|
|
|
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();
|
|
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('push')
|
|
.description('Push commits to remote')
|
|
.action(async () => {
|
|
await ensureRepo();
|
|
try {
|
|
Progress.info('Pushing to remote...');
|
|
await git.push();
|
|
Progress.success('Pushed to remote');
|
|
}
|
|
catch (e) { handleError('Push 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('version').alias('v')
|
|
.description('Manage S4 version (smart bump by default)')
|
|
.argument('[type]', 'bump type: major, minor, patch, auto', 'auto')
|
|
.option('-s, --stage <stage>', 'Set prerelease stage (dev, alpha, beta, rc, stable)')
|
|
.option('-n, --dry-run', 'Show next version without applying')
|
|
.option('-i, --info', 'Show info about current version')
|
|
.option('--list', 'List S4 tags (hides dev tags by default)')
|
|
.option('--prune', 'Prune old dev tags (keeps last 10)')
|
|
.option('--all', 'Show all tags (including dev) when listing')
|
|
.option('-u, --undo', 'Undo the last version bump (delete latest tag)')
|
|
.action(async (type, options) => {
|
|
await ensureRepo();
|
|
if (!versionCmd) initializeComponents();
|
|
try {
|
|
await versionCmd.run(type, options);
|
|
} catch (e) {
|
|
handleError('Version error', e);
|
|
}
|
|
});
|
|
|
|
program.command('whoami').alias('w')
|
|
.description('Show system and tool identity status')
|
|
.action(async () => {
|
|
try {
|
|
if (!whoAmI) initializeComponents();
|
|
await whoAmI.run();
|
|
} catch (e) {
|
|
handleError('WhoAmI 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('rs')
|
|
.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);
|
|
}
|
|
});
|
|
|
|
// ===== 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.start('🤖 Asking AI for the best strategy...');
|
|
|
|
// Gather rich context for the AI
|
|
let aiContext = `Situation: I am on branch '${branch}'.\n`;
|
|
aiContext += `Remote '${remoteBranch}' exists.\n`;
|
|
aiContext += `Status: ${ahead} commits ahead, ${behind} commits behind.\n`;
|
|
aiContext += `Uncommitted changes: ${hasLocalChanges ? 'Yes' : 'No'}.\n\n`;
|
|
|
|
if (behind > 0) {
|
|
try {
|
|
const behindLog = await git.log({ from: branch, to: remoteBranch, maxCount: 5 });
|
|
aiContext += `Incoming commits (latest 5):\n${behindLog.all.map(c => `- ${c.message}`).join('\n')}\n\n`;
|
|
} catch (e) { }
|
|
}
|
|
|
|
if (ahead > 0) {
|
|
try {
|
|
const aheadLog = await git.log({ from: remoteBranch, to: branch, maxCount: 5 });
|
|
aiContext += `My outgoing commits (latest 5):\n${aheadLog.all.map(c => `- ${c.message}`).join('\n')}\n`;
|
|
} catch (e) { }
|
|
}
|
|
|
|
const prompt = `
|
|
As a Git expert, analyze this situation and recommend the best command to sync my repo.
|
|
|
|
${aiContext}
|
|
|
|
Explain "Why" briefly, then provide the exact command to run.
|
|
Output format:
|
|
Reasoning: <brief explanation>
|
|
Recommended Command: <command>
|
|
`;
|
|
|
|
// Use preferred provider or auto-resolve
|
|
const provider = aiProvider.resolveProvider(opts.provider);
|
|
if (provider === 'none') {
|
|
Progress.stop('');
|
|
console.log(color.yellow('No AI provider configured. Falling back to simple heuristics.'));
|
|
// ... heuristic fallback ...
|
|
let rec = '';
|
|
if (ahead > 0 && behind === 0) rec = 'Push (g push)';
|
|
else if (behind > 0 && ahead === 0) rec = 'Pull (g pull)';
|
|
else rec = 'Rebase (g fix --rebase)';
|
|
console.log(`Recommendation: ${rec}`);
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const response = await aiProvider.generateWithProvider(provider, prompt, { temperature: 0.3 }); // Use generic provider method
|
|
|
|
Progress.stop('');
|
|
console.log(`\n${color.bold('🤖 AI Analysis:')}`);
|
|
console.log(response.trim());
|
|
} catch (e) {
|
|
Progress.stop('');
|
|
console.log(color.yellow('AI Analysis failed, falling back to heuristics.'));
|
|
// ... heuristic fallback code ...
|
|
let rec = '';
|
|
if (ahead > 0 && behind === 0) rec = 'Push (g push)';
|
|
else if (behind > 0 && ahead === 0) rec = 'Pull (g pull)';
|
|
else rec = 'Rebase (g fix --rebase)';
|
|
console.log(`Recommendation: ${rec}`);
|
|
}
|
|
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);
|
|
|