@snapcommit/cli 1.0.0

package/dist/ai/git-interpreter.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Natural Language Git Command Interpreter
+ * Uses Claude to understand user intent and map to Git operations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretGitCommand = interpretGitCommand;
+exports.suggestNextActions = suggestNextActions;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const retry_1 = require("../utils/retry");
+const client = new sdk_1.default({
+    apiKey: process.env.ANTHROPIC_API_KEY || '',
+});
+async function interpretGitCommand(userInput, context) {
+    const prompt = `You are a Git expert assistant. Interpret the user's natural language request into a structured Git operation.
+
+User request: "${userInput}"
+
+Current context:
+- Branch: ${context.currentBranch}
+- Uncommitted changes: ${context.hasUncommittedChanges}
+- Last commit: ${context.lastCommitHash || 'none'}
+- Remote: ${context.remoteBranch || 'none'}
+
+Respond with a JSON object (and ONLY JSON, no markdown):
+{
+  "action": "commit|revert|merge|branch|reset|stash|push|pull|rebase|cherry-pick|etc",
+  "target": "specific target if any (branch, commit, file)",
+  "options": {"key": "value"},
+  "confidence": 0.95,
+  "explanation": "This will undo your last commit but keep all your changes staged",
+  "gitCommands": ["git reset --soft HEAD~1", "git status"],
+  "riskLevel": "safe|medium|high",
+  "needsConfirmation": true,
+  "educationalTip": "The --soft flag keeps your changes staged. Use --hard to discard changes entirely (dangerous!)"
+}
+
+Risk levels:
+- safe: Read-only, undo-able (status, log, diff)
+- medium: Changes state but recoverable (commit, stash, branch)
+- high: Destructive, affects remote, or hard to undo (push --force, reset --hard, delete branch)
+
+Common patterns:
+- "commit" / "save" / "commit this" → action: "commit"
+- "undo" / "go back" → action: "reset" (if uncommitted) or "revert" (if committed)
+- "push" / "send" / "upload" → action: "push"
+- "merge X" → action: "merge", target: "X"
+- "create branch X" → action: "branch", target: "X"
+- "switch to X" → action: "checkout", target: "X"
+- "delete branch X" → action: "delete_branch", target: "X"
+
+Be smart about context:
+- If user says "undo that" and last action was commit → revert
+- If user says "merge" without target → suggest merging current branch to main
+- If user says "fix conflicts" → action: "resolve_conflicts"
+
+Respond with ONLY the JSON object, no other text.`;
+    try {
+        const response = await (0, retry_1.retryWithBackoff)(() => client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 1000,
+            messages: [{ role: 'user', content: prompt }],
+        }));
+        const text = response.content[0];
+        if (text.type !== 'text') {
+            throw new Error('Unexpected response type');
+        }
+        // Parse JSON response
+        const intent = JSON.parse(text.text.trim());
+        // Validate
+        if (!intent.action || !intent.explanation || !intent.gitCommands) {
+            throw new Error('Invalid intent structure');
+        }
+        return intent;
+    }
+    catch (error) {
+        // Try Gemini fallback
+        try {
+            const { interpretGitCommandGemini } = await Promise.resolve().then(() => __importStar(require('./gemini-client')));
+            return await interpretGitCommandGemini(userInput, context);
+        }
+        catch (geminiError) {
+            // Ultimate fallback: simple pattern matching
+            return getFallbackIntent(userInput, context);
+        }
+    }
+}
+/**
+ * Fallback intent parser for common commands (if AI fails)
+ */
+function getFallbackIntent(userInput, context) {
+    const input = userInput.toLowerCase().trim();
+    // Common patterns
+    if (input.includes('commit') || input === 'save' || input === 'snap') {
+        return {
+            action: 'commit',
+            confidence: 0.9,
+            explanation: 'This will commit all your changes with an AI-generated message',
+            gitCommands: ['git add -A', 'git commit -m "[AI generated]"'],
+            riskLevel: 'medium',
+            needsConfirmation: false,
+            educationalTip: 'git add -A stages all changes (new, modified, deleted files)',
+        };
+    }
+    if (input.includes('undo') || input.includes('go back')) {
+        if (context.hasUncommittedChanges) {
+            return {
+                action: 'reset',
+                confidence: 0.8,
+                explanation: 'This will discard all uncommitted changes',
+                gitCommands: ['git reset --hard HEAD'],
+                riskLevel: 'high',
+                needsConfirmation: true,
+                educationalTip: '⚠️  --hard permanently deletes changes. Use --soft to keep changes.',
+            };
+        }
+        else {
+            return {
+                action: 'revert',
+                confidence: 0.8,
+                explanation: 'This will revert your last commit',
+                gitCommands: ['git revert HEAD'],
+                riskLevel: 'medium',
+                needsConfirmation: true,
+                educationalTip: 'git revert creates a new commit that undoes changes (safe for pushed commits)',
+            };
+        }
+    }
+    if (input.includes('push') || input.includes('send')) {
+        return {
+            action: 'push',
+            confidence: 0.9,
+            explanation: `This will push your commits to remote (${context.currentBranch})`,
+            gitCommands: [`git push origin ${context.currentBranch}`],
+            riskLevel: 'medium',
+            needsConfirmation: false,
+            educationalTip: 'git push uploads your local commits to GitHub/remote',
+        };
+    }
+    // Default: show help
+    return {
+        action: 'help',
+        confidence: 0.5,
+        explanation: 'I\'m not sure what you want to do. Try being more specific.',
+        gitCommands: ['git status'],
+        riskLevel: 'safe',
+        needsConfirmation: false,
+        educationalTip: 'Try commands like: "commit", "push", "undo", "merge", "create branch"',
+    };
+}
+/**
+ * Generate suggestions for next actions
+ */
+function suggestNextActions(lastAction, context) {
+    const suggestions = [];
+    if (lastAction === 'commit') {
+        suggestions.push('push - Send to remote');
+        suggestions.push('amend - Fix the commit');
+        suggestions.push('undo - Undo the commit');
+    }
+    if (lastAction === 'push') {
+        suggestions.push('create PR - Open pull request');
+        if (context.currentBranch !== 'main') {
+            suggestions.push('merge to main - Merge this branch');
+        }
+    }
+    if (context.hasUncommittedChanges) {
+        suggestions.push('commit - Save changes');
+        suggestions.push('stash - Temporarily save changes');
+        suggestions.push('discard - Throw away changes');
+    }
+    return suggestions;
+}

package/dist/ai/smart-solver.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Smart Git Problem Solver
+ * Handles ANY Git problem, no matter how complex
+ * Self-healing retry system with multiple strategies
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveGitProblem = solveGitProblem;
+exports.needsClarification = needsClarification;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const retry_1 = require("../utils/retry");
+const client = new sdk_1.default({
+    apiKey: process.env.ANTHROPIC_API_KEY || '',
+});
+/**
+ * Intelligently solve ANY Git problem
+ * Tries multiple strategies until one succeeds
+ */
+async function solveGitProblem(problemDescription, context, maxAttempts = 5) {
+    console.log(chalk_1.default.blue('🧠 Analyzing your problem...\n'));
+    // Get multiple solution strategies from AI
+    const strategies = await getSolutionStrategies(problemDescription, context);
+    if (strategies.length === 0) {
+        return {
+            success: false,
+            error: 'Could not find a solution. Please describe the problem differently.',
+        };
+    }
+    // Show the strategies to the user
+    console.log(chalk_1.default.white.bold('Possible solutions:\n'));
+    strategies.forEach((strategy, i) => {
+        const riskColor = strategy.riskLevel === 'safe' ? chalk_1.default.green :
+            strategy.riskLevel === 'medium' ? chalk_1.default.yellow :
+                chalk_1.default.red;
+        console.log(chalk_1.default.gray(`${i + 1}. `) + chalk_1.default.white(strategy.approach));
+        console.log(chalk_1.default.gray(`   ${strategy.explanation}`));
+        console.log(riskColor(`   Risk: ${strategy.riskLevel}`) + chalk_1.default.gray(` | Confidence: ${(strategy.confidence * 100).toFixed(0)}%`));
+        console.log();
+    });
+    // Try each strategy in order of confidence
+    const sortedStrategies = strategies.sort((a, b) => b.confidence - a.confidence);
+    for (let i = 0; i < Math.min(sortedStrategies.length, maxAttempts); i++) {
+        const strategy = sortedStrategies[i];
+        console.log(chalk_1.default.blue(`\n🔧 Trying approach ${i + 1}: ${strategy.approach}`));
+        console.log(chalk_1.default.gray('─'.repeat(60)));
+        // Execute the strategy
+        const result = await executeStrategy(strategy);
+        if (result.success) {
+            console.log(chalk_1.default.green.bold('\n✅ Success!'));
+            console.log(chalk_1.default.gray(`   ${strategy.explanation}\n`));
+            return {
+                success: true,
+                strategy,
+                output: result.output,
+                attemptNumber: i + 1,
+            };
+        }
+        else {
+            console.log(chalk_1.default.red(`❌ Approach ${i + 1} failed: ${result.error}`));
+            // If we have more strategies, try to learn from this error
+            if (i < sortedStrategies.length - 1) {
+                console.log(chalk_1.default.yellow('💡 Trying a different approach...\n'));
+                // Ask AI for alternative based on this error
+                const alternative = await getAlternativeStrategy(problemDescription, context, strategy, result.error || 'Unknown error');
+                if (alternative) {
+                    sortedStrategies.splice(i + 1, 0, alternative);
+                }
+            }
+        }
+    }
+    // All strategies failed
+    console.log(chalk_1.default.red.bold('\n❌ Could not solve the problem automatically.\n'));
+    console.log(chalk_1.default.yellow('💡 Suggestions:'));
+    console.log(chalk_1.default.gray('   • Try describing the problem differently'));
+    console.log(chalk_1.default.gray('   • Check if you have uncommitted changes (git status)'));
+    console.log(chalk_1.default.gray('   • Try "snapcommit doctor" to check your Git setup'));
+    console.log();
+    return {
+        success: false,
+        error: 'All solution strategies failed. Manual intervention may be required.',
+    };
+}
+/**
+ * Get multiple solution strategies from AI
+ */
+async function getSolutionStrategies(problemDescription, context) {
+    try {
+        const prompt = `You are an expert Git problem solver. A user has described a Git problem and you need to provide multiple solution strategies.
+
+User's problem: "${problemDescription}"
+
+Context:
+- Current branch: ${context.currentBranch || 'unknown'}
+- Git status: ${context.gitStatus || 'unknown'}
+- Recent error: ${context.recentError || 'none'}
+
+Provide 3-5 solution strategies, ordered by safety and likelihood of success.
+
+For each strategy, provide:
+1. A brief approach name
+2. The exact Git commands to run
+3. An explanation of what it does
+4. Risk level (safe/medium/high)
+5. Confidence level (0-1)
+
+Respond with a JSON array (and ONLY JSON, no markdown):
+[
+  {
+    "approach": "Soft reset to undo commit",
+    "commands": ["git reset --soft HEAD~1"],
+    "explanation": "Undoes the last commit but keeps your changes staged",
+    "riskLevel": "safe",
+    "confidence": 0.95
+  },
+  ...
+]
+
+Rules:
+- Start with the safest approach
+- Include progressively more aggressive strategies
+- Always check for uncommitted changes first if relevant
+- Prefer stashing over discarding changes
+- For destructive operations, warn the user`;
+        const response = await (0, retry_1.retryWithBackoff)(() => client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 2000,
+            messages: [{ role: 'user', content: prompt }],
+        }));
+        const text = response.content[0];
+        if (text.type !== 'text') {
+            throw new Error('Unexpected response type');
+        }
+        // Parse JSON response
+        const strategies = JSON.parse(text.text.trim());
+        return strategies;
+    }
+    catch (error) {
+        console.error('AI strategy generation failed:', error.message);
+        return [];
+    }
+}
+/**
+ * Get an alternative strategy after a failure
+ */
+async function getAlternativeStrategy(originalProblem, context, failedStrategy, errorMessage) {
+    try {
+        const prompt = `A Git solution strategy failed. Suggest an alternative approach.
+
+Original problem: "${originalProblem}"
+Failed approach: "${failedStrategy.approach}"
+Commands that failed: ${failedStrategy.commands.join(', ')}
+Error message: "${errorMessage}"
+
+Suggest ONE alternative strategy that might work better.
+
+Respond with JSON (no markdown):
+{
+  "approach": "Alternative approach name",
+  "commands": ["git", "commands"],
+  "explanation": "Why this might work",
+  "riskLevel": "safe|medium|high",
+  "confidence": 0.8
+}`;
+        const response = await (0, retry_1.retryWithBackoff)(() => client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 1000,
+            messages: [{ role: 'user', content: prompt }],
+        }));
+        const text = response.content[0];
+        if (text.type !== 'text')
+            return null;
+        const alternative = JSON.parse(text.text.trim());
+        return alternative;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Execute a solution strategy
+ */
+async function executeStrategy(strategy) {
+    try {
+        const outputs = [];
+        for (const command of strategy.commands) {
+            console.log(chalk_1.default.gray(`   $ ${command}`));
+            try {
+                const output = (0, child_process_1.execSync)(command, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+                if (output.trim()) {
+                    console.log(chalk_1.default.gray(`   ${output.trim()}`));
+                    outputs.push(output.trim());
+                }
+            }
+            catch (cmdError) {
+                // Command failed
+                throw new Error(cmdError.stderr?.trim() || cmdError.message);
+            }
+        }
+        return {
+            success: true,
+            output: outputs.join('\n'),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Ask clarifying questions if the problem is ambiguous
+ */
+async function needsClarification(problemDescription) {
+    try {
+        const prompt = `Analyze this Git problem description and determine if you need more information.
+
+Problem: "${problemDescription}"
+
+If the description is ambiguous or could mean multiple things, provide clarifying questions or options.
+
+Respond with JSON (no markdown):
+{
+  "needsClarification": true,
+  "questions": ["What specific state do you want to undo?"],
+  "options": [
+    {"label": "Undo last commit (keep changes)", "value": "reset_soft"},
+    {"label": "Undo last commit (discard changes)", "value": "reset_hard"},
+    {"label": "Undo all uncommitted changes", "value": "restore_all"}
+  ]
+}
+
+Or if clear:
+{
+  "needsClarification": false
+}`;
+        const response = await (0, retry_1.retryWithBackoff)(() => client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 500,
+            messages: [{ role: 'user', content: prompt }],
+        }));
+        const text = response.content[0];
+        if (text.type !== 'text') {
+            return { needsClarification: false };
+        }
+        const result = JSON.parse(text.text.trim());
+        return result;
+    }
+    catch (error) {
+        return { needsClarification: false };
+    }
+}