@snapcommit/cli 1.0.0

package/dist/utils/rate-limit.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Rate limiting to prevent API abuse and control costs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRateLimit = checkRateLimit;
+exports.trackRateLimit = trackRateLimit;
+exports.formatResetTime = formatResetTime;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const DB_PATH = path_1.default.join(os_1.default.homedir(), '.snapcommit', 'snapcommit.db');
+const db = new better_sqlite3_1.default(DB_PATH);
+// Ensure rate_limit table exists
+db.exec(`
+  CREATE TABLE IF NOT EXISTS rate_limit (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    action TEXT NOT NULL,
+    timestamp INTEGER NOT NULL
+  );
+`);
+const RATE_LIMITS = {
+    free: { limit: 10, windowMs: 60 * 60 * 1000 }, // 10 per hour
+    pro: { limit: 100, windowMs: 60 * 60 * 1000 }, // 100 per hour
+};
+function checkRateLimit(plan) {
+    const config = RATE_LIMITS[plan];
+    const now = Date.now();
+    const windowStart = now - config.windowMs;
+    // Count recent actions
+    const count = db.prepare(`
+    SELECT COUNT(*) as count FROM rate_limit
+    WHERE action = 'commit' AND timestamp >= ?
+  `).get(windowStart);
+    const remaining = Math.max(0, config.limit - count.count);
+    const allowed = remaining > 0;
+    // Calculate reset time (start of next window)
+    const oldestInWindow = db.prepare(`
+    SELECT MIN(timestamp) as oldest FROM rate_limit
+    WHERE action = 'commit' AND timestamp >= ?
+  `).get(windowStart);
+    const resetAt = oldestInWindow?.oldest
+        ? oldestInWindow.oldest + config.windowMs
+        : now + config.windowMs;
+    return { allowed, remaining, resetAt };
+}
+function trackRateLimit(action = 'commit') {
+    db.prepare(`
+    INSERT INTO rate_limit (action, timestamp)
+    VALUES (?, ?)
+  `).run(action, Date.now());
+    // Cleanup old entries (keep last 7 days)
+    const sevenDaysAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
+    db.prepare('DELETE FROM rate_limit WHERE timestamp < ?').run(sevenDaysAgo);
+}
+function formatResetTime(resetAt) {
+    const seconds = Math.floor((resetAt - Date.now()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m`;
+}

package/dist/utils/retry.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Retry utility with exponential backoff
+ * For handling transient API errors gracefully
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryWithBackoff = retryWithBackoff;
+async function retryWithBackoff(fn, options = {}) {
+    const { maxAttempts = 3, initialDelay = 1000, maxDelay = 10000, backoffMultiplier = 2, } = options;
+    let lastError;
+    let delay = initialDelay;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry on certain errors (e.g., auth failures, invalid requests)
+            if (isNonRetryableError(error)) {
+                throw error;
+            }
+            // If this was the last attempt, throw
+            if (attempt === maxAttempts) {
+                throw error;
+            }
+            // Wait before retrying
+            await sleep(Math.min(delay, maxDelay));
+            delay *= backoffMultiplier;
+        }
+    }
+    throw lastError;
+}
+function isNonRetryableError(error) {
+    // Don't retry on 4xx errors (client errors)
+    if (error.status && error.status >= 400 && error.status < 500) {
+        return true;
+    }
+    // Don't retry on authentication errors
+    if (error.message?.includes('authentication') || error.message?.includes('API key')) {
+        return true;
+    }
+    return false;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/utils/ui.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Beautiful terminal UI utilities
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPINNER_FRAMES = void 0;
+exports.createBox = createBox;
+exports.createProgressBar = createProgressBar;
+exports.createSpinner = createSpinner;
+exports.formatNumber = formatNumber;
+exports.formatDuration = formatDuration;
+exports.createTable = createTable;
+exports.displaySuccess = displaySuccess;
+exports.displayError = displayError;
+exports.displayWarning = displayWarning;
+exports.displayInfo = displayInfo;
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Create a beautiful box around text
+ */
+function createBox(title, lines, width = 50) {
+    const border = '─'.repeat(width);
+    let box = chalk_1.default.gray(`┌${border}┐\n`);
+    box += chalk_1.default.white.bold(`│ ${title.padEnd(width - 2)} │\n`);
+    box += chalk_1.default.gray(`├${border}┤\n`);
+    lines.forEach(line => {
+        box += chalk_1.default.gray(`│ `) + line.padEnd(width - 2) + chalk_1.default.gray(` │\n`);
+    });
+    box += chalk_1.default.gray(`└${border}┘`);
+    return box;
+}
+/**
+ * Create a progress bar
+ */
+function createProgressBar(current, total, width = 20) {
+    const percentage = Math.min(100, (current / total) * 100);
+    const filled = Math.floor((percentage / 100) * width);
+    const empty = width - filled;
+    const bar = chalk_1.default.green('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+    return `${bar} ${percentage.toFixed(0)}%`;
+}
+/**
+ * Spinner animation frames
+ */
+exports.SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Create a spinner
+ */
+function createSpinner(message = 'Loading...') {
+    let intervalId = null;
+    let frame = 0;
+    let currentMessage = message;
+    const start = () => {
+        frame = 0;
+        intervalId = setInterval(() => {
+            process.stdout.write(chalk_1.default.blue(`\r${exports.SPINNER_FRAMES[frame++ % exports.SPINNER_FRAMES.length]} ${currentMessage}`));
+        }, 100);
+    };
+    const stop = () => {
+        if (intervalId) {
+            clearInterval(intervalId);
+            intervalId = null;
+            process.stdout.write('\r' + ' '.repeat(currentMessage.length + 5) + '\r');
+        }
+    };
+    const update = (msg) => {
+        currentMessage = msg;
+    };
+    return { start, stop, update };
+}
+/**
+ * Format large numbers
+ */
+function formatNumber(num) {
+    if (num >= 1000000) {
+        return (num / 1000000).toFixed(1) + 'M';
+    }
+    if (num >= 1000) {
+        return (num / 1000).toFixed(1) + 'K';
+    }
+    return num.toString();
+}
+/**
+ * Format time duration
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ${minutes % 60}m`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ${hours % 24}h`;
+}
+/**
+ * Create a table
+ */
+function createTable(headers, rows) {
+    const colWidths = headers.map((header, i) => {
+        const maxWidth = Math.max(header.length, ...rows.map(row => (row[i] || '').length));
+        return maxWidth + 2; // Add padding
+    });
+    let table = '';
+    // Header
+    table += chalk_1.default.gray('┌');
+    table += colWidths.map(w => chalk_1.default.gray('─'.repeat(w))).join(chalk_1.default.gray('┬'));
+    table += chalk_1.default.gray('┐\n');
+    table += chalk_1.default.gray('│');
+    headers.forEach((header, i) => {
+        table += chalk_1.default.white.bold(` ${header.padEnd(colWidths[i] - 1)}`);
+        table += chalk_1.default.gray('│');
+    });
+    table += '\n';
+    table += chalk_1.default.gray('├');
+    table += colWidths.map(w => chalk_1.default.gray('─'.repeat(w))).join(chalk_1.default.gray('┼'));
+    table += chalk_1.default.gray('┤\n');
+    // Rows
+    rows.forEach(row => {
+        table += chalk_1.default.gray('│');
+        row.forEach((cell, i) => {
+            table += chalk_1.default.white(` ${cell.padEnd(colWidths[i] - 1)}`);
+            table += chalk_1.default.gray('│');
+        });
+        table += '\n';
+    });
+    table += chalk_1.default.gray('└');
+    table += colWidths.map(w => chalk_1.default.gray('─'.repeat(w))).join(chalk_1.default.gray('┴'));
+    table += chalk_1.default.gray('┘');
+    return table;
+}
+/**
+ * Display a success message
+ */
+function displaySuccess(message, details) {
+    console.log();
+    console.log(chalk_1.default.green.bold(`✅ ${message}`));
+    if (details && details.length > 0) {
+        details.forEach(detail => {
+            console.log(chalk_1.default.gray(`   ${detail}`));
+        });
+    }
+    console.log();
+}
+/**
+ * Display an error message
+ */
+function displayError(message, details) {
+    console.log();
+    console.log(chalk_1.default.red.bold(`❌ ${message}`));
+    if (details && details.length > 0) {
+        details.forEach(detail => {
+            console.log(chalk_1.default.gray(`   ${detail}`));
+        });
+    }
+    console.log();
+}
+/**
+ * Display a warning message
+ */
+function displayWarning(message, details) {
+    console.log();
+    console.log(chalk_1.default.yellow.bold(`⚠️  ${message}`));
+    if (details && details.length > 0) {
+        details.forEach(detail => {
+            console.log(chalk_1.default.gray(`   ${detail}`));
+        });
+    }
+    console.log();
+}
+/**
+ * Display an info message
+ */
+function displayInfo(message, details) {
+    console.log();
+    console.log(chalk_1.default.blue.bold(`ℹ️  ${message}`));
+    if (details && details.length > 0) {
+        details.forEach(detail => {
+            console.log(chalk_1.default.gray(`   ${detail}`));
+        });
+    }
+    console.log();
+}

package/dist/utils/version.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Version checking and auto-update notifications
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CACHE_FILE = path_1.default.join(os_1.default.homedir(), '.snapcommit', 'version-cache.json');
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+async function checkForUpdates() {
+    try {
+        // Read current version from package.json
+        const packageJsonPath = path_1.default.join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const currentVersion = packageJson.version;
+        // Check cache
+        let cache = null;
+        if (fs_1.default.existsSync(CACHE_FILE)) {
+            cache = JSON.parse(fs_1.default.readFileSync(CACHE_FILE, 'utf-8'));
+            if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL) {
+                // Use cached version
+                return {
+                    hasUpdate: isNewerVersion(cache.latestVersion, currentVersion),
+                    currentVersion,
+                    latestVersion: cache.latestVersion,
+                };
+            }
+        }
+        // Fetch latest version from npm
+        const latestVersion = await getLatestVersionFromNpm('snapcommit');
+        // Update cache
+        const newCache = {
+            lastCheck: Date.now(),
+            latestVersion,
+        };
+        fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(newCache));
+        return {
+            hasUpdate: isNewerVersion(latestVersion, currentVersion),
+            currentVersion,
+            latestVersion,
+        };
+    }
+    catch (error) {
+        // Silent fail - don't interrupt user
+        return null;
+    }
+}
+function getLatestVersionFromNpm(packageName) {
+    return new Promise((resolve, reject) => {
+        https_1.default.get(`https://registry.npmjs.org/${packageName}/latest`, (res) => {
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version);
+                }
+                catch {
+                    reject(new Error('Failed to parse npm response'));
+                }
+            });
+        }).on('error', reject);
+    });
+}
+function isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map(Number);
+    const currentParts = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (latestParts[i] > currentParts[i])
+            return true;
+        if (latestParts[i] < currentParts[i])
+            return false;
+    }
+    return false;
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@snapcommit/cli",
+  "version": "1.0.0",
+  "description": "Instant AI commits. Beautiful progress tracking. Never write commit messages again.",
+  "main": "dist/index.js",
+  "bin": {
+    "snapcommit": "./dist/index.js",
+    "snap": "./dist/index.js",
+    "sc": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Tests coming soon\""
+  },
+  "keywords": [
+    "cli",
+    "terminal",
+    "ai",
+    "git",
+    "commit",
+    "claude",
+    "gemini",
+    "productivity",
+    "developer-tools",
+    "automation",
+    "progress-tracking"
+  ],
+  "author": "SnapCommit",
+  "license": "MIT",
+  "homepage": "https://snapcommit.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Arjun0606/snapcommit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Arjun0606/snapcommit/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.1",
+    "@google/generative-ai": "^0.21.0",
+    "@supabase/supabase-js": "^2.78.0",
+    "better-sqlite3": "^11.5.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "ink": "^5.0.1",
+    "node-pty": "^1.0.0",
+    "open": "^10.2.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "@types/node": "^22.8.7",
+    "@types/react": "^18.3.12",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}