@snapcommit/cli 1.0.0

package/README.md

@@ -0,0 +1,162 @@
+# SnapCommit
+
+**Snap. Commit. Track.**
+
+Instant AI commits. Beautiful progress tracking. Never write commit messages again.
+
+[![npm version](https://badge.fury.io/js/snapcommit.svg)](https://www.npmjs.com/package/snapcommit)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## What is SnapCommit?
+
+SnapCommit is a CLI tool that makes Git & GitHub effortless:
+
+1. **⚡ Instant AI Commits** - Professional messages in one command (`snap`)
+2. **🌍 Natural Language** - Just say what you want: "create a PR", "merge main"
+3. **📊 Beautiful Stats** - Track your coding journey with gorgeous analytics
+4. **🔥 Streak Tracking** - Gamification to keep you motivated
+5. **🚀 Universal** - Works everywhere (any IDE, any terminal, any OS)
+
+## Quick Start
+
+```bash
+# Install globally
+npm install -g snapcommit
+
+# Set up (adds aliases)
+snapcommit setup
+
+# Make your first commit
+snap  # That's it!
+```
+
+## Installation
+
+### Option 1: npm (Recommended)
+
+```bash
+npm install -g snapcommit
+```
+
+### Option 2: Install Scripts
+
+**macOS / Linux:**
+```bash
+curl -fsSL https://snapcommit.dev/install.sh | bash
+```
+
+**Windows (PowerShell):**
+```powershell
+iwr https://snapcommit.dev/install.ps1 | iex
+```
+
+## Setup
+
+After installation, run setup to integrate with your shell:
+
+```bash
+snapcommit setup
+```
+
+This adds `snap` and `sc` aliases. Restart your terminal and you're ready!
+
+## Usage
+
+### Interactive Mode
+
+Type `snap` to enter interactive mode:
+
+```bash
+$ snap
+⚡ SnapCommit Interactive Mode
+
+snap> commit my authentication work
+✅ feat(auth): implement user authentication system
+
+snap> create a PR
+✅ PR #42 created
+
+snap> check ci
+✅ All checks passed
+```
+
+### Just Talk to It 💬
+
+SnapCommit is **Cursor for Git** - no commands to memorize. Just describe what you want:
+
+```bash
+snap> commit my authentication work
+✅ feat(auth): implement user authentication system
+
+snap> I messed up, go back to how it was before
+✅ Reverted last commit
+
+snap> open a pull request for this feature
+✅ PR #42 created
+
+snap> did the tests pass?
+✅ All CI checks passed
+```
+
+**That's the whole point** - talk naturally, like you would to a teammate. SnapCommit figures out what you mean.
+
+## Authentication
+
+**SnapCommit includes built-in AI models!** No API keys needed.
+
+1. **Sign up at:** https://snapcommit.dev/login
+2. **Subscribe:** $9.99/month or $100/year
+3. **Get your token:** From your dashboard
+4. **Authenticate CLI:** Enter token when prompted
+
+After installing, the CLI will guide you through authentication on first use.
+
+## Features
+
+- ✅ **AI Commit Messages** - Claude 4.5 Sonnet generates perfect commits
+- ✅ **Natural Language Git** - No more memorizing commands
+- ✅ **GitHub Integration** - PRs, CI checks, workflows, releases
+- ✅ **Progress Tracking** - Streaks, heatmaps, milestones
+- ✅ **Multi-Repo Support** - Switch between projects seamlessly
+- ✅ **Conflict Resolution** - AI-guided merge conflict solving
+- ✅ **Smart Error Handling** - Auto-retry with intelligent fixes
+- ✅ **Privacy First** - Local-first, minimal data sent to AI
+- ✅ **Cross-Platform** - macOS, Linux, Windows
+
+## Pricing
+
+- **Monthly:** $9.99/month - Unlimited AI commits, all features
+- **Yearly:** $100/year - Save 17% (best value!)
+
+## Supported Platforms
+
+- ✅ macOS (zsh, bash, fish)
+- ✅ Linux (zsh, bash, fish)
+- ✅ Windows (PowerShell, Git Bash, WSL)
+- ✅ Any terminal, any IDE
+
+## Requirements
+
+- Node.js 18+
+- Git installed
+- API keys (we'll help you get them)
+
+## Documentation
+
+Full docs at [snapcommit.dev/docs](https://snapcommit.dev/docs)
+
+## Support
+
+- 🐦 [Follow on X/Twitter](https://x.com/Arjun06061)
+- 📧 [Email support](mailto:support@snapcommit.dev)
+- 💡 [Suggestions & Feedback](https://x.com/Arjun06061)
+
+## License
+
+MIT © SnapCommit Team
+
+---
+
+**Made with ❤️ for developers who want to focus on building, not git messages.**
+
+[Website](https://snapcommit.dev) • [X/Twitter](https://x.com/Arjun06061)

package/dist/ai/anthropic-client.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommitMessage = generateCommitMessage;
+exports.analyzeCommand = analyzeCommand;
+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 generateCommitMessage(diff) {
+    try {
+        // Try Claude first, fallback to Gemini if it fails
+        const message = await (0, retry_1.retryWithBackoff)(() => client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 500,
+            temperature: 0.3,
+            messages: [
+                {
+                    role: 'user',
+                    content: `You are an expert software engineer writing commit messages. 
+
+Analyze this git diff and generate a professional conventional commit message.
+
+Rules:
+1. Use conventional commits format: type(scope): message
+2. Types: feat, fix, docs, style, refactor, test, chore
+3. Keep first line under 72 characters
+4. Be specific and clear
+5. If multiple changes, use the most significant one
+6. Don't mention file names unless critical
+7. Focus on WHAT changed and WHY, not HOW
+
+Git Diff:
+\`\`\`
+${diff}
+\`\`\`
+
+Reply with ONLY the commit message, nothing else.`,
+                },
+            ],
+        }), {
+            maxAttempts: 3,
+            initialDelay: 1000,
+            maxDelay: 5000,
+        });
+        const content = message.content[0];
+        if (content.type === 'text') {
+            return content.text.trim();
+        }
+        throw new Error('Unexpected response format from Claude');
+    }
+    catch (error) {
+        throw new Error(`Claude API error: ${error.message}`);
+    }
+}
+async function analyzeCommand(naturalLanguage) {
+    try {
+        const message = await client.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 200,
+            temperature: 0.2,
+            messages: [
+                {
+                    role: 'user',
+                    content: `You are a terminal command expert. Convert this natural language request into a precise terminal command.
+
+Request: "${naturalLanguage}"
+
+Rules:
+1. Reply with ONLY the command, nothing else
+2. No explanations, no markdown, no backticks
+3. If multiple commands needed, separate with &&
+4. Use common Unix commands (works on Mac/Linux)
+5. Be safe - no destructive commands without confirmation
+
+Reply with the command:`,
+                },
+            ],
+        });
+        const content = message.content[0];
+        if (content.type === 'text') {
+            return content.text.trim();
+        }
+        throw new Error('Unexpected response format from Claude');
+    }
+    catch (error) {
+        throw new Error(`Claude API error: ${error.message}`);
+    }
+}

package/dist/ai/commit-generator.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Enhanced commit message generator
+ * Generates multiple options for user to choose from
+ */
+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.generateCommitOptions = generateCommitOptions;
+exports.displayCommitOptions = displayCommitOptions;
+exports.editCommitMessage = editCommitMessage;
+const anthropic_client_1 = require("./anthropic-client");
+const gemini_client_1 = require("./gemini-client");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Generate multiple commit message options
+ * Gives user choice of styles
+ */
+async function generateCommitOptions(diff) {
+    try {
+        // Generate 3 different styles in parallel
+        const [detailed, concise, conventional] = await Promise.all([
+            generateDetailedCommit(diff),
+            generateConciseCommit(diff),
+            generateConventionalCommit(diff),
+        ]);
+        return [
+            {
+                message: conventional,
+                description: 'Conventional Commits format (recommended)',
+                style: 'conventional',
+            },
+            {
+                message: detailed,
+                description: 'Detailed with full context',
+                style: 'detailed',
+            },
+            {
+                message: concise,
+                description: 'Short and simple',
+                style: 'concise',
+            },
+        ];
+    }
+    catch (error) {
+        // Fallback to single generation
+        const message = await (0, anthropic_client_1.generateCommitMessage)(diff);
+        return [{
+                message,
+                description: 'AI-generated',
+                style: 'conventional',
+            }];
+    }
+}
+/**
+ * Generate detailed commit message
+ */
+async function generateDetailedCommit(diff) {
+    const prompt = `You are an expert software engineer writing a detailed commit message.
+
+Analyze this git diff and generate a comprehensive conventional commit message.
+
+Requirements:
+1. Use conventional commits format: type(scope): subject
+2. Include a detailed body explaining WHAT changed and WHY
+3. List key changes as bullet points
+4. Be specific and thorough
+5. Keep subject line under 72 characters
+
+Git Diff:
+\`\`\`
+${diff}
+\`\`\`
+
+Reply with ONLY the commit message (subject + body), nothing else.`;
+    try {
+        return await (0, anthropic_client_1.generateCommitMessage)(diff);
+    }
+    catch {
+        return await (0, gemini_client_1.generateCommitMessageGemini)(diff);
+    }
+}
+/**
+ * Generate concise commit message
+ */
+async function generateConciseCommit(diff) {
+    const prompt = `You are an expert software engineer writing a concise commit message.
+
+Analyze this git diff and generate a SHORT conventional commit message.
+
+Requirements:
+1. Use conventional commits format: type(scope): subject
+2. Keep it to ONE line only (subject only, no body)
+3. Be specific but brief
+4. Under 72 characters total
+
+Git Diff:
+\`\`\`
+${diff}
+\`\`\`
+
+Reply with ONLY the one-line commit message, nothing else.`;
+    try {
+        // For concise, we need a different AI call with specific instructions
+        const message = await (0, anthropic_client_1.generateCommitMessage)(diff);
+        // Extract just the first line
+        return message.split('\n')[0];
+    }
+    catch {
+        const message = await (0, gemini_client_1.generateCommitMessageGemini)(diff);
+        return message.split('\n')[0];
+    }
+}
+/**
+ * Generate conventional commit message (our standard)
+ */
+async function generateConventionalCommit(diff) {
+    return await (0, anthropic_client_1.generateCommitMessage)(diff);
+}
+/**
+ * Display commit options to user
+ */
+function displayCommitOptions(options) {
+    console.log(chalk_1.default.white.bold('\n✨ AI-Generated Commit Messages:\n'));
+    options.forEach((option, index) => {
+        const number = index + 1;
+        const badge = index === 0 ? chalk_1.default.green(' (Recommended)') : '';
+        console.log(chalk_1.default.cyan.bold(`Option ${number}:`) + chalk_1.default.gray(` ${option.description}`) + badge);
+        console.log();
+        // Display the commit message with nice formatting
+        const lines = option.message.split('\n');
+        lines.forEach((line, i) => {
+            if (i === 0) {
+                // Subject line - bold
+                console.log(chalk_1.default.white.bold(`   ${line}`));
+            }
+            else if (line.trim()) {
+                // Body lines - gray
+                console.log(chalk_1.default.gray(`   ${line}`));
+            }
+            else {
+                console.log();
+            }
+        });
+        console.log();
+    });
+}
+/**
+ * Let user edit a commit message
+ */
+async function editCommitMessage(original) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    console.log(chalk_1.default.yellow('\n📝 Edit your commit message:'));
+    console.log(chalk_1.default.gray('Current:'));
+    console.log(chalk_1.default.white(`   ${original}\n`));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(chalk_1.default.cyan('New message: '), (answer) => {
+            rl.close();
+            resolve(answer.trim() || original);
+        });
+    });
+}

package/dist/ai/gemini-client.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Google Gemini AI Client (Fallback)
+ * Used when Claude is unavailable or for cost optimization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommitMessageGemini = generateCommitMessageGemini;
+exports.interpretGitCommandGemini = interpretGitCommandGemini;
+exports.needsClarificationGemini = needsClarificationGemini;
+exports.solveGitProblemGemini = solveGitProblemGemini;
+const generative_ai_1 = require("@google/generative-ai");
+const retry_1 = require("../utils/retry");
+const genAI = new generative_ai_1.GoogleGenerativeAI(process.env.GOOGLE_AI_API_KEY || '');
+async function generateCommitMessageGemini(diff) {
+    try {
+        const model = genAI.getGenerativeModel({ model: 'gemini-2.0-flash-exp' });
+        const prompt = `You are an expert software engineer writing commit messages.
+
+Analyze this git diff and generate a professional conventional commit message.
+
+Rules:
+1. Use conventional commits format: type(scope): message
+2. Types: feat, fix, docs, style, refactor, test, chore
+3. Keep first line under 72 characters
+4. Be specific and clear
+5. If multiple changes, use the most significant one
+6. Don't mention file names unless critical
+7. Focus on WHAT changed and WHY, not HOW
+
+Git Diff:
+\`\`\`
+${diff}
+\`\`\`
+
+Reply with ONLY the commit message, nothing else.`;
+        const result = await (0, retry_1.retryWithBackoff)(() => model.generateContent(prompt), {
+            maxAttempts: 3,
+            initialDelay: 1000,
+            maxDelay: 5000,
+        });
+        const response = await result.response;
+        const text = response.text();
+        if (!text) {
+            throw new Error('Empty response from Gemini');
+        }
+        return text.trim();
+    }
+    catch (error) {
+        throw new Error(`Gemini API error: ${error.message}`);
+    }
+}
+async function interpretGitCommandGemini(userInput, context) {
+    try {
+        const model = genAI.getGenerativeModel({ model: 'gemini-2.0-flash-exp' });
+        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'}
+
+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)
+
+Respond with ONLY the JSON object, no other text.`;
+        const result = await model.generateContent(prompt);
+        const response = await result.response;
+        const text = response.text();
+        // Clean up markdown if present
+        let jsonText = text.trim();
+        if (jsonText.startsWith('```json')) {
+            jsonText = jsonText.replace(/```json\n?/, '').replace(/```\n?$/, '');
+        }
+        else if (jsonText.startsWith('```')) {
+            jsonText = jsonText.replace(/```\n?/, '').replace(/```\n?$/, '');
+        }
+        const intent = JSON.parse(jsonText);
+        // Validate
+        if (!intent.action || !intent.explanation || !intent.gitCommands) {
+            throw new Error('Invalid intent structure from Gemini');
+        }
+        return intent;
+    }
+    catch (error) {
+        throw new Error(`Gemini API error: ${error.message}`);
+    }
+}
+/**
+ * Check if user input needs clarification
+ */
+async function needsClarificationGemini(userInput) {
+    try {
+        const model = genAI.getGenerativeModel({ model: 'gemini-2.0-flash-exp' });
+        const prompt = `You are a helpful Git assistant. Determine if this user request is ambiguous and requires clarification.
+
+User request: "${userInput}"
+
+Return a JSON object:
+{
+  "needsClarification": true|false,
+  "options": [
+    { "label": "Description of option 1", "value": "clarified command 1" },
+    { "label": "Description of option 2", "value": "clarified command 2" }
+  ]
+}
+
+Examples of ambiguous requests:
+- "undo that" → could mean: undo last commit, undo last change, undo last push
+- "go back" → could mean: go back 1 commit, discard changes, switch branch
+- "clean up" → could mean: clean untracked files, delete merged branches, remove stale changes
+
+If the request is clear and unambiguous, return: { "needsClarification": false }
+
+Respond with ONLY the JSON object, no other text.`;
+        const result = await model.generateContent(prompt);
+        const response = await result.response;
+        let text = response.text().trim();
+        // Clean up markdown
+        if (text.startsWith('```json')) {
+            text = text.replace(/```json\n?/, '').replace(/```\n?$/, '');
+        }
+        else if (text.startsWith('```')) {
+            text = text.replace(/```\n?/, '').replace(/```\n?$/, '');
+        }
+        return JSON.parse(text);
+    }
+    catch (error) {
+        // If clarification check fails, assume no clarification needed
+        return { needsClarification: false };
+    }
+}
+/**
+ * Try to solve a Git problem using AI
+ */
+async function solveGitProblemGemini(userInput, context) {
+    try {
+        const model = genAI.getGenerativeModel({ model: 'gemini-2.0-flash-exp' });
+        const prompt = `You are an expert Git problem solver. A user encountered an issue.
+
+User's problem: "${userInput}"
+
+Current context:
+- Branch: ${context.currentBranch}
+- Git status:
+\`\`\`
+${context.gitStatus}
+\`\`\`
+${context.recentError ? `- Recent error: ${context.recentError}` : ''}
+
+Your goal is to provide a solution. Return a JSON object:
+{
+  "success": true,
+  "message": "A clear explanation of what went wrong and how you fixed it",
+  "gitCommands": ["git command 1", "git command 2"]
+}
+
+OR if you cannot solve it:
+{
+  "success": false,
+  "message": "Explanation of why you couldn't solve it or what more information is needed"
+}
+
+Prioritize safe, non-destructive commands. If a destructive command is necessary, clearly state its implications in the message.
+
+Respond with ONLY the JSON object, no other text.`;
+        const result = await model.generateContent(prompt);
+        const response = await result.response;
+        let text = response.text().trim();
+        // Clean up markdown
+        if (text.startsWith('```json')) {
+            text = text.replace(/```json\n?/, '').replace(/```\n?$/, '');
+        }
+        else if (text.startsWith('```')) {
+            text = text.replace(/```\n?/, '').replace(/```\n?$/, '');
+        }
+        return JSON.parse(text);
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `AI problem solver failed: ${error.message}`,
+        };
+    }
+}