@snapcommit/cli 3.3.1 → 3.5.0

package/dist/commands/cursor-style.js

@@ -292,16 +292,90 @@ async function executeCommitWithAI(intent) {
     // Push if requested
     const shouldPush = intent.shouldPush || intent.gitCommands?.some((cmd) => cmd.includes('push'));
     if (shouldPush) {
+        // STEP 1: Pull first to avoid conflicts (like Cursor does!)
+        try {
+            const currentBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+            const hasRemote = (0, child_process_1.execSync)(`git ls-remote --heads origin ${currentBranch}`, { encoding: 'utf-8' }).trim();
+            if (hasRemote) {
+                console.log(chalk_1.default.blue('⚡ Syncing with remote...'));
+                try {
+                    (0, child_process_1.execSync)('git pull --rebase', { encoding: 'utf-8', stdio: 'pipe' });
+                    console.log(chalk_1.default.green('✓ Synced'));
+                }
+                catch (pullError) {
+                    // Handle rebase conflicts
+                    if (pullError.message.includes('conflict')) {
+                        console.log(chalk_1.default.yellow('\n⚠️  Merge conflicts detected - resolving...'));
+                        // Try to auto-resolve conflicts
+                        const resolved = await tryAdvancedConflictResolution();
+                        if (resolved) {
+                            console.log(chalk_1.default.green('✓ Conflicts resolved'));
+                        }
+                        else {
+                            console.log(chalk_1.default.red('\n❌ Cannot auto-resolve conflicts'));
+                            console.log(chalk_1.default.white('\nConflicted files:'));
+                            const conflicts = (0, child_process_1.execSync)('git diff --name-only --diff-filter=U', { encoding: 'utf-8' });
+                            conflicts.split('\n').filter(f => f.trim()).forEach(file => {
+                                console.log(chalk_1.default.red(`  ✗ ${file}`));
+                            });
+                            console.log(chalk_1.default.cyan('\nTo resolve manually:'));
+                            console.log(chalk_1.default.gray('  1. Fix conflicts in the files above'));
+                            console.log(chalk_1.default.gray('  2. Run: ') + chalk_1.default.cyan('git add <files>'));
+                            console.log(chalk_1.default.gray('  3. Run: ') + chalk_1.default.cyan('git rebase --continue'));
+                            console.log(chalk_1.default.gray('  4. Then try: ') + chalk_1.default.cyan('snap') + chalk_1.default.gray(' and ') + chalk_1.default.cyan('push changes\n'));
+                            return;
+                        }
+                    }
+                    else {
+                        // Other pull errors
+                        console.log(chalk_1.default.yellow(`⚠️  Sync issue: ${pullError.message}`));
+                    }
+                }
+            }
+        }
+        catch {
+            // No remote or other issues - continue with push
+        }
+        // STEP 2: Now push
         try {
             (0, child_process_1.execSync)('git push', { encoding: 'utf-8', stdio: 'pipe' });
             console.log(chalk_1.default.green('✓ Pushed\n'));
         }
-        catch (error) {
-            if (error.message.includes('no configured push destination')) {
+        catch (pushError) {
+            const errorMsg = pushError.message.toLowerCase();
+            if (errorMsg.includes('no configured push destination')) {
                 console.log(chalk_1.default.gray('✓ Committed locally (no remote)\n'));
             }
+            else if (errorMsg.includes('rejected') && errorMsg.includes('non-fast-forward')) {
+                // Need force push - but be safe!
+                console.log(chalk_1.default.yellow('\n⚠️  Remote has changes that would be overwritten'));
+                console.log(chalk_1.default.white('This requires force push, which can be dangerous.\n'));
+                const rlForce = await Promise.resolve().then(() => __importStar(require('readline')));
+                const rlForcePush = rlForce.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const confirmForce = await new Promise((resolve) => {
+                    rlForcePush.question(chalk_1.default.cyan('Force push? ') + chalk_1.default.gray('(yes/no): '), (ans) => {
+                        setImmediate(() => rlForcePush.close());
+                        resolve(ans.trim().toLowerCase());
+                    });
+                });
+                if (confirmForce === 'yes') {
+                    try {
+                        (0, child_process_1.execSync)('git push --force-with-lease', { encoding: 'utf-8', stdio: 'pipe' });
+                        console.log(chalk_1.default.green('✓ Force pushed (safely)\n'));
+                    }
+                    catch (forceError) {
+                        console.log(chalk_1.default.red(`\n❌ Force push failed: ${forceError.message}\n`));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.gray('\n✗ Push cancelled\n'));
+                }
+            }
             else {
-                console.log(chalk_1.default.yellow(`⚠️  Push failed: ${error.message}\n`));
+                console.log(chalk_1.default.yellow(`\n⚠️  Push failed: ${pushError.message}\n`));
             }
         }
     }
@@ -309,8 +383,154 @@ async function executeCommitWithAI(intent) {
         console.log();
     }
 }
+/**
+ * AI-POWERED conflict resolution - intelligently resolves merge conflicts!
+ */
+async function tryAdvancedConflictResolution() {
+    try {
+        // Get conflicted files
+        const conflictedFiles = (0, child_process_1.execSync)('git diff --name-only --diff-filter=U', { encoding: 'utf-8' })
+            .split('\n')
+            .filter(f => f.trim());
+        if (conflictedFiles.length === 0)
+            return false;
+        console.log(chalk_1.default.white(`\n📋 Analyzing ${conflictedFiles.length} conflicted file(s)...\n`));
+        // For each conflicted file, use AI to resolve
+        for (const file of conflictedFiles) {
+            try {
+                // Read the conflicted file
+                const conflictContent = (0, child_process_1.execSync)(`git show :1:${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                const oursContent = (0, child_process_1.execSync)(`git show :2:${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                const theirsContent = (0, child_process_1.execSync)(`git show :3:${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                // Ask AI to resolve the conflict
+                console.log(chalk_1.default.blue(`🤖 AI analyzing: ${file}...`));
+                const resolution = await resolveConflictWithAI(file, conflictContent, oursContent, theirsContent);
+                if (resolution) {
+                    console.log(chalk_1.default.green(`✓ AI resolved: ${file}`));
+                    // Write the resolved content
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+                    fs.writeFileSync(file, resolution);
+                    (0, child_process_1.execSync)(`git add ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                }
+                else {
+                    // Fallback: ask user which version to keep
+                    console.log(chalk_1.default.yellow(`\n⚠️  ${file} - Choose resolution:`));
+                    console.log(chalk_1.default.gray('  1. Keep your changes (ours)'));
+                    console.log(chalk_1.default.gray('  2. Keep their changes (theirs)'));
+                    console.log(chalk_1.default.gray('  3. Skip (resolve manually later)\n'));
+                    const rlConflict = await Promise.resolve().then(() => __importStar(require('readline')));
+                    const rlChoice = rlConflict.createInterface({
+                        input: process.stdin,
+                        output: process.stdout,
+                    });
+                    const choice = await new Promise((resolve) => {
+                        rlChoice.question(chalk_1.default.cyan('Choice (1/2/3): '), (ans) => {
+                            setImmediate(() => rlChoice.close());
+                            resolve(ans.trim());
+                        });
+                    });
+                    if (choice === '1') {
+                        (0, child_process_1.execSync)(`git checkout --ours ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                        (0, child_process_1.execSync)(`git add ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                        console.log(chalk_1.default.green(`✓ Kept your changes: ${file}`));
+                    }
+                    else if (choice === '2') {
+                        (0, child_process_1.execSync)(`git checkout --theirs ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                        (0, child_process_1.execSync)(`git add ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                        console.log(chalk_1.default.green(`✓ Kept their changes: ${file}`));
+                    }
+                    else {
+                        console.log(chalk_1.default.gray(`⊘ Skipped: ${file}`));
+                        return false; // User wants to resolve manually
+                    }
+                }
+            }
+            catch (fileError) {
+                console.log(chalk_1.default.yellow(`⚠️  Couldn't auto-resolve ${file}`));
+                // Fallback: ask user
+                const rlFallback = await Promise.resolve().then(() => __importStar(require('readline')));
+                const rlFallbackChoice = rlFallback.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const fallbackChoice = await new Promise((resolve) => {
+                    rlFallbackChoice.question(chalk_1.default.cyan(`Keep (1) yours or (2) theirs? [1/2]: `), (ans) => {
+                        setImmediate(() => rlFallbackChoice.close());
+                        resolve(ans.trim());
+                    });
+                });
+                if (fallbackChoice === '1') {
+                    (0, child_process_1.execSync)(`git checkout --ours ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                    (0, child_process_1.execSync)(`git add ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                }
+                else if (fallbackChoice === '2') {
+                    (0, child_process_1.execSync)(`git checkout --theirs ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                    (0, child_process_1.execSync)(`git add ${file}`, { encoding: 'utf-8', stdio: 'pipe' });
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        // Continue the rebase
+        try {
+            (0, child_process_1.execSync)('git rebase --continue', { encoding: 'utf-8', stdio: 'pipe' });
+            return true;
+        }
+        catch (continueError) {
+            // If rebase fails, might need to commit first
+            try {
+                (0, child_process_1.execSync)('git commit --no-edit', { encoding: 'utf-8', stdio: 'pipe' });
+                (0, child_process_1.execSync)('git rebase --continue', { encoding: 'utf-8', stdio: 'pipe' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`❌ Conflict resolution failed: ${error.message}`));
+        try {
+            (0, child_process_1.execSync)('git rebase --abort', { encoding: 'utf-8', stdio: 'pipe' });
+        }
+        catch { }
+        return false;
+    }
+}
+/**
+ * Use AI to intelligently resolve merge conflicts
+ */
+async function resolveConflictWithAI(filename, base, ours, theirs) {
+    try {
+        const axios = (await Promise.resolve().then(() => __importStar(require('axios')))).default;
+        // Get the backend URL from env or default
+        const backendUrl = process.env.SNAPCOMMIT_BACKEND_URL || 'https://snapcommit.dev';
+        const response = await axios.post(`${backendUrl}/api/ai/resolve-conflict`, {
+            filename,
+            base,
+            ours,
+            theirs,
+        }, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            timeout: 30000, // 30 second timeout
+        });
+        if (response.data?.resolution) {
+            return response.data.resolution;
+        }
+        return null;
+    }
+    catch (error) {
+        // AI resolution failed - fall back to manual choice
+        return null;
+    }
+}
 /**
  * Execute Git commands - Cursor-style (clean, fast, auto-fix)
+ * NOW SUPPORTS: commits, pushes, pulls, merges, rebases, cherry-picks, stash,
+ * resets, reverts, blame, bisect, tags, reflog, and MORE!
  */
 async function executeGitCommands(commands) {
     for (const cmd of commands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapcommit/cli",
-  "version": "3.3.1",
+  "version": "3.5.0",
   "description": "Instant AI commits. Beautiful progress tracking. Never write commit messages again.",
   "main": "dist/index.js",
   "bin": {