@snapcommit/cli 1.0.0

package/dist/commands/conflict.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Conflict resolution wizard
+ * Helps users resolve merge conflicts with AI assistance
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conflictCommand = conflictCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const analytics_1 = require("../utils/analytics");
+const anthropic = new sdk_1.default({
+    apiKey: process.env.ANTHROPIC_API_KEY || '',
+});
+function askQuestion(query) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => rl.question(query, ans => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+async function conflictCommand() {
+    console.log(chalk_1.default.blue.bold('\n🔧 Conflict Resolution Wizard\n'));
+    // Check for conflicts
+    let conflictFiles;
+    try {
+        const output = (0, child_process_1.execSync)('git diff --name-only --diff-filter=U', { encoding: 'utf-8' });
+        conflictFiles = output.trim().split('\n').filter(Boolean);
+    }
+    catch {
+        conflictFiles = [];
+    }
+    if (conflictFiles.length === 0) {
+        console.log(chalk_1.default.green('✅ No conflicts detected!\n'));
+        return;
+    }
+    console.log(chalk_1.default.yellow(`Found ${conflictFiles.length} file(s) with conflicts:\n`));
+    conflictFiles.forEach((file, i) => {
+        console.log(chalk_1.default.white(`  ${i + 1}. ${file}`));
+    });
+    console.log();
+    // Offer AI assistance
+    console.log(chalk_1.default.blue('🤖 I can help you resolve these conflicts with AI.\n'));
+    const choice = await askQuestion(chalk_1.default.yellow('Choose an option:\n') +
+        chalk_1.default.gray('  1. AI-assisted resolution (recommended)\n') +
+        chalk_1.default.gray('  2. Manual resolution (open in editor)\n') +
+        chalk_1.default.gray('  3. Abort merge\n') +
+        chalk_1.default.yellow('Your choice (1/2/3): '));
+    if (choice === '3') {
+        console.log(chalk_1.default.yellow('\n⚠️  Aborting merge...\n'));
+        (0, child_process_1.execSync)('git merge --abort');
+        console.log(chalk_1.default.green('✅ Merge aborted. You\'re back to a clean state.\n'));
+        return;
+    }
+    if (choice === '2') {
+        console.log(chalk_1.default.blue('\n📝 Opening files for manual resolution...\n'));
+        console.log(chalk_1.default.gray('After resolving conflicts:'));
+        console.log(chalk_1.default.cyan('  git add <file>'));
+        console.log(chalk_1.default.cyan('  git commit'));
+        console.log();
+        return;
+    }
+    // AI-assisted resolution
+    for (const filePath of conflictFiles) {
+        await resolveConflictWithAI(filePath);
+    }
+    // Final commit
+    console.log(chalk_1.default.blue('\n✅ All conflicts resolved!\n'));
+    const shouldCommit = await askQuestion(chalk_1.default.yellow('Commit the merge? (Y/n): '));
+    if (shouldCommit.toLowerCase() !== 'n') {
+        try {
+            (0, child_process_1.execSync)('git add -A');
+            (0, child_process_1.execSync)('git commit --no-edit');
+            console.log(chalk_1.default.green('\n✅ Merge committed successfully!\n'));
+            (0, analytics_1.trackEvent)({ event: 'conflict_resolved', data: { filesCount: conflictFiles.length } });
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`\n❌ Commit failed: ${error.message}\n`));
+        }
+    }
+}
+async function resolveConflictWithAI(filePath) {
+    console.log(chalk_1.default.blue(`\n🔍 Analyzing ${chalk_1.default.white.bold(filePath)}...\n`));
+    // Read file content
+    const content = fs_1.default.readFileSync(filePath, 'utf-8');
+    // Extract conflict markers
+    const conflicts = extractConflicts(content);
+    console.log(chalk_1.default.yellow(`Found ${conflicts.length} conflict(s) in this file.\n`));
+    for (let i = 0; i < conflicts.length; i++) {
+        const conflict = conflicts[i];
+        console.log(chalk_1.default.white.bold(`Conflict ${i + 1}/${conflicts.length}:`));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log(chalk_1.default.green('<<<<<<< YOURS (current branch)'));
+        console.log(chalk_1.default.white(conflict.ours));
+        console.log(chalk_1.default.yellow('======='));
+        console.log(chalk_1.default.white(conflict.theirs));
+        console.log(chalk_1.default.blue('>>>>>>> THEIRS (incoming branch)'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log();
+        // Get AI suggestion
+        console.log(chalk_1.default.blue('🤖 Getting AI suggestion...\n'));
+        const suggestion = await getAISuggestion(conflict, filePath);
+        console.log(chalk_1.default.green('AI Suggestion:'));
+        console.log(chalk_1.default.white(suggestion.resolution));
+        console.log();
+        console.log(chalk_1.default.gray('Reasoning: ' + suggestion.explanation));
+        console.log();
+        const choice = await askQuestion(chalk_1.default.yellow('Choose:\n') +
+            chalk_1.default.gray('  1. Use AI suggestion\n') +
+            chalk_1.default.gray('  2. Keep yours\n') +
+            chalk_1.default.gray('  3. Keep theirs\n') +
+            chalk_1.default.gray('  4. Skip (manual edit)\n') +
+            chalk_1.default.yellow('Your choice (1/2/3/4): '));
+        let resolution;
+        if (choice === '1') {
+            resolution = suggestion.resolution;
+        }
+        else if (choice === '2') {
+            resolution = conflict.ours;
+        }
+        else if (choice === '3') {
+            resolution = conflict.theirs;
+        }
+        else {
+            console.log(chalk_1.default.yellow('Skipped. Resolve manually.\n'));
+            continue;
+        }
+        // Replace conflict in content
+        const conflictBlock = `<<<<<<< HEAD\n${conflict.ours}\n=======\n${conflict.theirs}\n>>>>>>> ${conflict.branch || 'MERGE_HEAD'}`;
+        const newContent = content.replace(conflictBlock, resolution);
+        fs_1.default.writeFileSync(filePath, newContent);
+        console.log(chalk_1.default.green('✅ Resolved!\n'));
+    }
+    // Stage the file
+    (0, child_process_1.execSync)(`git add "${filePath}"`);
+    console.log(chalk_1.default.green(`✅ Staged ${filePath}\n`));
+}
+function extractConflicts(content) {
+    const conflicts = [];
+    const lines = content.split('\n');
+    let inConflict = false;
+    let ours = [];
+    let theirs = [];
+    let inTheirs = false;
+    let branch;
+    for (const line of lines) {
+        if (line.startsWith('<<<<<<<')) {
+            inConflict = true;
+            ours = [];
+            theirs = [];
+            inTheirs = false;
+        }
+        else if (line.startsWith('=======')) {
+            inTheirs = true;
+        }
+        else if (line.startsWith('>>>>>>>')) {
+            inConflict = false;
+            branch = line.substring(8).trim();
+            conflicts.push({
+                ours: ours.join('\n'),
+                theirs: theirs.join('\n'),
+                branch,
+            });
+        }
+        else if (inConflict) {
+            if (inTheirs) {
+                theirs.push(line);
+            }
+            else {
+                ours.push(line);
+            }
+        }
+    }
+    return conflicts;
+}
+async function getAISuggestion(conflict, filePath) {
+    try {
+        const response = await anthropic.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 1000,
+            messages: [
+                {
+                    role: 'user',
+                    content: `You are an expert software engineer resolving a Git merge conflict.
+
+File: ${filePath}
+
+CURRENT BRANCH (ours):
+\`\`\`
+${conflict.ours}
+\`\`\`
+
+INCOMING BRANCH (theirs):
+\`\`\`
+${conflict.theirs}
+\`\`\`
+
+Analyze both versions and suggest the best resolution. Consider:
+1. Are they compatible? Can both changes be kept?
+2. Which version is more correct/better?
+3. Are there bugs or issues in either version?
+
+Respond with JSON (no markdown, just JSON):
+{
+  "resolution": "the merged code",
+  "explanation": "why this is the best resolution"
+}`,
+                },
+            ],
+        });
+        const text = response.content[0];
+        if (text.type !== 'text') {
+            throw new Error('Unexpected response');
+        }
+        const result = JSON.parse(text.text);
+        return result;
+    }
+    catch (error) {
+        // Fallback: suggest keeping both
+        return {
+            resolution: `${conflict.ours}\n${conflict.theirs}`,
+            explanation: 'AI suggestion failed. Keeping both versions (you may need to clean up).',
+        };
+    }
+}

package/dist/commands/doctor.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Doctor command - checks if everything is set up correctly
+ */
+function doctorCommand() {
+    console.log(chalk_1.default.blue.bold('\n🔍 SnapCommit Health Check\n'));
+    let allGood = true;
+    // Check 1: Git installed
+    console.log(chalk_1.default.white('Checking Git...'));
+    try {
+        const gitVersion = (0, child_process_1.execSync)('git --version', { encoding: 'utf-8' }).trim();
+        console.log(chalk_1.default.green(`  ✓ ${gitVersion}`));
+    }
+    catch {
+        console.log(chalk_1.default.red('  ✗ Git not found'));
+        console.log(chalk_1.default.gray('    Install: https://git-scm.com'));
+        allGood = false;
+    }
+    // Check 2: Node.js version
+    console.log(chalk_1.default.white('\nChecking Node.js...'));
+    const nodeVersion = process.version;
+    const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+    if (majorVersion >= 18) {
+        console.log(chalk_1.default.green(`  ✓ ${nodeVersion} (good)`));
+    }
+    else {
+        console.log(chalk_1.default.yellow(`  ⚠ ${nodeVersion} (recommend v18+)`));
+    }
+    // Check 3: API Keys
+    console.log(chalk_1.default.white('\nChecking API Keys...'));
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    if (anthropicKey && anthropicKey.startsWith('sk-ant')) {
+        console.log(chalk_1.default.green('  ✓ ANTHROPIC_API_KEY set'));
+    }
+    else {
+        console.log(chalk_1.default.red('  ✗ ANTHROPIC_API_KEY missing or invalid'));
+        console.log(chalk_1.default.gray('    Get key: https://console.anthropic.com'));
+        allGood = false;
+    }
+    const geminiKey = process.env.GOOGLE_AI_API_KEY;
+    if (geminiKey && geminiKey.startsWith('AIza')) {
+        console.log(chalk_1.default.green('  ✓ GOOGLE_AI_API_KEY set'));
+    }
+    else {
+        console.log(chalk_1.default.yellow('  ⚠ GOOGLE_AI_API_KEY missing'));
+        console.log(chalk_1.default.gray('    Optional for now, needed for autocomplete'));
+    }
+    // Check 4: Shell integration
+    console.log(chalk_1.default.white('\nChecking Shell Integration...'));
+    const shell = process.env.SHELL || '';
+    const homeDir = os_1.default.homedir();
+    let shellConfigPath = '';
+    if (shell.includes('zsh')) {
+        shellConfigPath = path_1.default.join(homeDir, '.zshrc');
+    }
+    else if (shell.includes('bash')) {
+        shellConfigPath = path_1.default.join(homeDir, '.bashrc');
+    }
+    if (shellConfigPath && fs_1.default.existsSync(shellConfigPath)) {
+        const content = fs_1.default.readFileSync(shellConfigPath, 'utf-8');
+        if (content.includes('SnapCommit Integration')) {
+            console.log(chalk_1.default.green('  ✓ Shell integration installed'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('  ⚠ Shell integration not installed'));
+            console.log(chalk_1.default.gray('    Run: snapcommit setup'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.gray('  - Shell config not found'));
+    }
+    // Check 5: Database
+    console.log(chalk_1.default.white('\nChecking Database...'));
+    const dbPath = path_1.default.join(homeDir, '.builderos', 'builderos.db');
+    if (fs_1.default.existsSync(dbPath)) {
+        const stats = fs_1.default.statSync(dbPath);
+        const sizeKB = (stats.size / 1024).toFixed(2);
+        console.log(chalk_1.default.green(`  ✓ Database exists (${sizeKB} KB)`));
+    }
+    else {
+        console.log(chalk_1.default.gray('  - Database will be created on first use'));
+    }
+    // Check 6: Git repo (current directory)
+    console.log(chalk_1.default.white('\nChecking Current Directory...'));
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { stdio: 'ignore' });
+        const branch = (0, child_process_1.execSync)('git branch --show-current', { encoding: 'utf-8' }).trim();
+        console.log(chalk_1.default.green(`  ✓ Git repository (${branch})`));
+    }
+    catch {
+        console.log(chalk_1.default.gray('  - Not in a git repository'));
+    }
+    // Summary
+    console.log();
+    if (allGood) {
+        console.log(chalk_1.default.green.bold('✅ All systems go! SnapCommit is ready.\n'));
+        console.log(chalk_1.default.gray('Try: ') + chalk_1.default.cyan('snapcommit quick') + chalk_1.default.gray(' to make your first commit'));
+    }
+    else {
+        console.log(chalk_1.default.yellow.bold('⚠️  Some issues found. Fix them to get started.\n'));
+    }
+    console.log();
+}

package/dist/commands/git-advanced.js

@@ -0,0 +1,311 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stashChanges = stashChanges;
+exports.listStash = listStash;
+exports.applyStash = applyStash;
+exports.popStash = popStash;
+exports.dropStash = dropStash;
+exports.rebaseOnto = rebaseOnto;
+exports.interactiveRebase = interactiveRebase;
+exports.cherryPick = cherryPick;
+exports.amendCommit = amendCommit;
+exports.resetToCommit = resetToCommit;
+exports.createBranch = createBranch;
+exports.deleteBranch = deleteBranch;
+exports.switchBranch = switchBranch;
+exports.mergeBranch = mergeBranch;
+exports.showLog = showLog;
+exports.showDiff = showDiff;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = __importDefault(require("readline"));
+/**
+ * Stash current changes
+ */
+async function stashChanges(message) {
+    try {
+        console.log(chalk_1.default.gray('\n💾 Stashing changes...\n'));
+        if (message) {
+            (0, child_process_1.execSync)(`git stash push -m "${message}"`, { stdio: 'inherit' });
+        }
+        else {
+            (0, child_process_1.execSync)('git stash', { stdio: 'inherit' });
+        }
+        console.log(chalk_1.default.green('\n✅ Changes stashed!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to stash: ${error.message}\n`));
+    }
+}
+/**
+ * List stashed changes
+ */
+function listStash() {
+    try {
+        console.log(chalk_1.default.bold('\n📦 Stashed Changes:\n'));
+        (0, child_process_1.execSync)('git stash list', { stdio: 'inherit' });
+        console.log('');
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to list stash: ${error.message}\n`));
+    }
+}
+/**
+ * Apply stashed changes
+ */
+async function applyStash(stashIndex) {
+    try {
+        console.log(chalk_1.default.gray('\n📂 Applying stashed changes...\n'));
+        if (stashIndex !== undefined) {
+            (0, child_process_1.execSync)(`git stash apply stash@{${stashIndex}}`, { stdio: 'inherit' });
+        }
+        else {
+            (0, child_process_1.execSync)('git stash apply', { stdio: 'inherit' });
+        }
+        console.log(chalk_1.default.green('\n✅ Stash applied!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to apply stash: ${error.message}\n`));
+    }
+}
+/**
+ * Pop stashed changes (apply and remove)
+ */
+async function popStash() {
+    try {
+        console.log(chalk_1.default.gray('\n📂 Popping stashed changes...\n'));
+        (0, child_process_1.execSync)('git stash pop', { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\n✅ Stash popped!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to pop stash: ${error.message}\n`));
+    }
+}
+/**
+ * Drop stashed changes
+ */
+async function dropStash(stashIndex) {
+    try {
+        const confirmed = await confirmAction('This will permanently delete the stashed changes. Continue?');
+        if (!confirmed) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        console.log(chalk_1.default.gray('\n🗑️  Dropping stash...\n'));
+        if (stashIndex !== undefined) {
+            (0, child_process_1.execSync)(`git stash drop stash@{${stashIndex}}`, { stdio: 'inherit' });
+        }
+        else {
+            (0, child_process_1.execSync)('git stash drop', { stdio: 'inherit' });
+        }
+        console.log(chalk_1.default.green('\n✅ Stash dropped!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to drop stash: ${error.message}\n`));
+    }
+}
+/**
+ * Rebase current branch onto another
+ */
+async function rebaseOnto(targetBranch) {
+    try {
+        const confirmed = await confirmAction(`This will rebase your current branch onto ${targetBranch}. This rewrites history. Continue?`);
+        if (!confirmed) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        console.log(chalk_1.default.gray(`\n🔄 Rebasing onto ${targetBranch}...\n`));
+        (0, child_process_1.execSync)(`git rebase ${targetBranch}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\n✅ Rebase complete!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Rebase failed. You may need to resolve conflicts.\n`));
+        console.log(chalk_1.default.yellow('Run "git rebase --abort" to cancel, or resolve conflicts and "git rebase --continue"\n'));
+    }
+}
+/**
+ * Interactive rebase
+ */
+async function interactiveRebase(commits = 5) {
+    try {
+        const confirmed = await confirmAction(`This will start an interactive rebase for the last ${commits} commits. Continue?`);
+        if (!confirmed) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        console.log(chalk_1.default.gray(`\n🔄 Starting interactive rebase...\n`));
+        (0, child_process_1.execSync)(`git rebase -i HEAD~${commits}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\n✅ Interactive rebase complete!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Interactive rebase failed or cancelled.\n`));
+    }
+}
+/**
+ * Cherry-pick a commit
+ */
+async function cherryPick(commitHash) {
+    try {
+        console.log(chalk_1.default.gray(`\n🍒 Cherry-picking commit ${commitHash}...\n`));
+        (0, child_process_1.execSync)(`git cherry-pick ${commitHash}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\n✅ Cherry-pick complete!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Cherry-pick failed. You may need to resolve conflicts.\n`));
+        console.log(chalk_1.default.yellow('Run "git cherry-pick --abort" to cancel, or resolve conflicts and "git cherry-pick --continue"\n'));
+    }
+}
+/**
+ * Amend last commit
+ */
+async function amendCommit(message) {
+    try {
+        console.log(chalk_1.default.gray('\n✏️  Amending last commit...\n'));
+        if (message) {
+            (0, child_process_1.execSync)(`git commit --amend -m "${message}"`, { stdio: 'inherit' });
+        }
+        else {
+            (0, child_process_1.execSync)('git commit --amend --no-edit', { stdio: 'inherit' });
+        }
+        console.log(chalk_1.default.green('\n✅ Commit amended!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to amend commit: ${error.message}\n`));
+    }
+}
+/**
+ * Reset to a specific commit
+ */
+async function resetToCommit(commitHash, mode = 'mixed') {
+    try {
+        const warnings = {
+            soft: 'This will undo commits but keep all changes staged.',
+            mixed: 'This will undo commits and unstage changes, but keep them in working directory.',
+            hard: '⚠️  This will PERMANENTLY delete all changes! Cannot be undone!',
+        };
+        const confirmed = await confirmAction(`${warnings[mode]} Continue?`);
+        if (!confirmed) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        console.log(chalk_1.default.gray(`\n🔄 Resetting to ${commitHash} (--${mode})...\n`));
+        (0, child_process_1.execSync)(`git reset --${mode} ${commitHash}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\n✅ Reset complete!\n'));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to reset: ${error.message}\n`));
+    }
+}
+/**
+ * Create and checkout a new branch
+ */
+async function createBranch(branchName, fromBranch) {
+    try {
+        console.log(chalk_1.default.gray(`\n🌿 Creating branch ${branchName}...\n`));
+        if (fromBranch) {
+            (0, child_process_1.execSync)(`git checkout -b ${branchName} ${fromBranch}`, { stdio: 'inherit' });
+        }
+        else {
+            (0, child_process_1.execSync)(`git checkout -b ${branchName}`, { stdio: 'inherit' });
+        }
+        console.log(chalk_1.default.green(`\n✅ Created and switched to ${branchName}!\n`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to create branch: ${error.message}\n`));
+    }
+}
+/**
+ * Delete a branch
+ */
+async function deleteBranch(branchName, force = false) {
+    try {
+        const confirmed = await confirmAction(`This will delete the branch "${branchName}". Continue?`);
+        if (!confirmed) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        console.log(chalk_1.default.gray(`\n🗑️  Deleting branch ${branchName}...\n`));
+        const flag = force ? '-D' : '-d';
+        (0, child_process_1.execSync)(`git branch ${flag} ${branchName}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green(`\n✅ Branch ${branchName} deleted!\n`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to delete branch: ${error.message}\n`));
+        if (!force) {
+            console.log(chalk_1.default.yellow('💡 Use force delete if branch has unmerged changes\n'));
+        }
+    }
+}
+/**
+ * Switch to a branch
+ */
+async function switchBranch(branchName) {
+    try {
+        console.log(chalk_1.default.gray(`\n🔄 Switching to ${branchName}...\n`));
+        (0, child_process_1.execSync)(`git checkout ${branchName}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green(`\n✅ Switched to ${branchName}!\n`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to switch branch: ${error.message}\n`));
+    }
+}
+/**
+ * Merge a branch
+ */
+async function mergeBranch(branchName, noFastForward = false) {
+    try {
+        console.log(chalk_1.default.gray(`\n🔀 Merging ${branchName}...\n`));
+        const flag = noFastForward ? '--no-ff' : '';
+        (0, child_process_1.execSync)(`git merge ${flag} ${branchName}`, { stdio: 'inherit' });
+        console.log(chalk_1.default.green(`\n✅ Merged ${branchName}!\n`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Merge failed. You may need to resolve conflicts.\n`));
+        console.log(chalk_1.default.yellow('Run "git merge --abort" to cancel, or resolve conflicts and commit\n'));
+    }
+}
+/**
+ * Show commit log
+ */
+function showLog(limit = 10) {
+    try {
+        console.log(chalk_1.default.bold(`\n📜 Last ${limit} Commits:\n`));
+        (0, child_process_1.execSync)(`git log --oneline --graph --decorate -${limit}`, { stdio: 'inherit' });
+        console.log('');
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to show log: ${error.message}\n`));
+    }
+}
+/**
+ * Show diff
+ */
+function showDiff(cached = false) {
+    try {
+        const flag = cached ? '--cached' : '';
+        console.log(chalk_1.default.bold('\n📊 Changes:\n'));
+        (0, child_process_1.execSync)(`git diff ${flag}`, { stdio: 'inherit' });
+        console.log('');
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to show diff: ${error.message}\n`));
+    }
+}
+/**
+ * Helper: Confirm action
+ */
+async function confirmAction(message) {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(chalk_1.default.yellow(`\n⚠️  ${message} (y/N): `), (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}