@snapcommit/cli 1.0.0

package/dist/utils/dopamine.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Dopamine-inducing features
+ * Streaks, milestones, achievements, motivational messages
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateStreak = calculateStreak;
+exports.getMotivationalMessage = getMotivationalMessage;
+exports.getMilestone = getMilestone;
+exports.getFireEmoji = getFireEmoji;
+exports.getDopamineStats = getDopamineStats;
+exports.displayDopamineStats = displayDopamineStats;
+exports.displayQuickDopamine = displayQuickDopamine;
+const database_1 = require("../db/database");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Calculate streak (consecutive days with commits)
+ */
+function calculateStreak() {
+    const stats = (0, database_1.getStats)(365); // Get last year
+    if (stats.recentCommits.length === 0) {
+        return { current: 0, longest: 0 };
+    }
+    // Sort by timestamp (newest first)
+    const commits = [...stats.recentCommits].sort((a, b) => b.timestamp - a.timestamp);
+    // Group by day
+    const dayBuckets = new Map();
+    commits.forEach((commit) => {
+        const date = new Date(commit.timestamp);
+        const dayKey = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+        dayBuckets.set(dayKey, (dayBuckets.get(dayKey) || 0) + 1);
+    });
+    const today = new Date();
+    const todayKey = `${today.getFullYear()}-${today.getMonth() + 1}-${today.getDate()}`;
+    // Calculate current streak
+    let currentStreak = 0;
+    let checkDate = new Date(today);
+    while (true) {
+        const dayKey = `${checkDate.getFullYear()}-${checkDate.getMonth() + 1}-${checkDate.getDate()}`;
+        if (dayBuckets.has(dayKey)) {
+            currentStreak++;
+            checkDate.setDate(checkDate.getDate() - 1);
+        }
+        else {
+            // Allow 1-day gap if we're not checking today (give grace period)
+            if (dayKey === todayKey) {
+                checkDate.setDate(checkDate.getDate() - 1);
+                const yesterdayKey = `${checkDate.getFullYear()}-${checkDate.getMonth() + 1}-${checkDate.getDate()}`;
+                if (!dayBuckets.has(yesterdayKey)) {
+                    break;
+                }
+            }
+            else {
+                break;
+            }
+        }
+    }
+    // Calculate longest streak (simple version)
+    let longestStreak = currentStreak;
+    let tempStreak = 0;
+    let lastDate = null;
+    const sortedDays = Array.from(dayBuckets.keys()).sort().reverse();
+    sortedDays.forEach(dayKey => {
+        const [year, month, day] = dayKey.split('-').map(Number);
+        const date = new Date(year, month - 1, day);
+        if (lastDate) {
+            const diffDays = Math.floor((lastDate.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+            if (diffDays === 1) {
+                tempStreak++;
+            }
+            else {
+                longestStreak = Math.max(longestStreak, tempStreak);
+                tempStreak = 1;
+            }
+        }
+        else {
+            tempStreak = 1;
+        }
+        lastDate = date;
+    });
+    longestStreak = Math.max(longestStreak, tempStreak);
+    return { current: currentStreak, longest: longestStreak };
+}
+/**
+ * Get motivational message based on stats
+ */
+function getMotivationalMessage(stats) {
+    const { currentStreak, weeklyCommits, totalCommits } = stats;
+    // Streak-based messages
+    if (currentStreak >= 30) {
+        return "🔥 LEGENDARY! 30+ day streak!";
+    }
+    if (currentStreak >= 14) {
+        return "💪 Beast mode! 2 weeks straight!";
+    }
+    if (currentStreak >= 7) {
+        return "⚡ On fire! 1 week streak!";
+    }
+    if (currentStreak >= 3) {
+        return "🚀 Momentum building!";
+    }
+    // Commit-based messages
+    if (weeklyCommits >= 50) {
+        return "🤯 Insane productivity this week!";
+    }
+    if (weeklyCommits >= 25) {
+        return "💯 Crushing it this week!";
+    }
+    if (weeklyCommits >= 10) {
+        return "👏 Great week of coding!";
+    }
+    // Milestone messages
+    if (totalCommits >= 1000) {
+        return "🏆 1000+ commits! You're a legend!";
+    }
+    if (totalCommits >= 500) {
+        return "🎉 500+ commits milestone!";
+    }
+    if (totalCommits >= 100) {
+        return "🌟 100+ commits! Keep going!";
+    }
+    // Default encouragement
+    if (totalCommits === 0) {
+        return "🌱 Let's start your coding journey!";
+    }
+    if (totalCommits < 10) {
+        return "🎯 Getting started! Keep it up!";
+    }
+    return "💻 Keep building amazing things!";
+}
+/**
+ * Get milestone (if any)
+ */
+function getMilestone(totalCommits) {
+    const milestones = [10, 25, 50, 100, 250, 500, 1000];
+    for (const milestone of milestones) {
+        if (totalCommits === milestone) {
+            return `🎉 ${milestone} COMMITS MILESTONE!`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Get fire emoji intensity based on streak
+ */
+function getFireEmoji(streak) {
+    if (streak >= 30)
+        return '🔥🔥🔥';
+    if (streak >= 14)
+        return '🔥🔥';
+    if (streak >= 7)
+        return '🔥';
+    if (streak >= 3)
+        return '⚡';
+    return '🌱';
+}
+/**
+ * Get complete dopamine stats
+ */
+function getDopamineStats() {
+    const stats7d = (0, database_1.getStats)(7);
+    const statsAll = (0, database_1.getStats)(365);
+    const streak = calculateStreak();
+    const dopamineStats = {
+        currentStreak: streak.current,
+        longestStreak: streak.longest,
+        totalCommits: statsAll.totalCommits,
+        weeklyCommits: stats7d.totalCommits,
+        linesThisWeek: stats7d.totalInsertions + stats7d.totalDeletions,
+        milestone: getMilestone(statsAll.totalCommits),
+        motivationalMessage: '',
+        fireEmoji: getFireEmoji(streak.current),
+    };
+    dopamineStats.motivationalMessage = getMotivationalMessage(dopamineStats);
+    return dopamineStats;
+}
+/**
+ * Display dopamine stats in a beautiful way
+ */
+function displayDopamineStats() {
+    const stats = getDopamineStats();
+    console.log();
+    console.log(chalk_1.default.yellow.bold(`${stats.fireEmoji} ${stats.motivationalMessage}`));
+    if (stats.currentStreak > 0) {
+        console.log(chalk_1.default.gray(`   ${stats.currentStreak}-day streak${stats.longestStreak > stats.currentStreak ? ` (best: ${stats.longestStreak})` : ' 🏆'}`));
+    }
+    console.log(chalk_1.default.gray(`   ${stats.weeklyCommits} commits this week`));
+    if (stats.linesThisWeek > 0) {
+        console.log(chalk_1.default.gray(`   ${stats.linesThisWeek.toLocaleString()} lines changed`));
+    }
+    if (stats.milestone) {
+        console.log();
+        console.log(chalk_1.default.green.bold(`   ${stats.milestone}`));
+    }
+    console.log();
+}
+/**
+ * Display quick dopamine hit (for after commits)
+ */
+function displayQuickDopamine() {
+    const stats = getDopamineStats();
+    if (stats.currentStreak >= 3) {
+        console.log(chalk_1.default.yellow(`${stats.fireEmoji} ${stats.currentStreak}-day streak!`));
+    }
+    if (stats.milestone) {
+        console.log(chalk_1.default.green.bold(stats.milestone));
+    }
+}

package/dist/utils/errors.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Production-ready error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitError = exports.LicenseError = exports.APIError = exports.SnapCommitError = void 0;
+exports.handleError = handleError;
+class SnapCommitError extends Error {
+    code;
+    userMessage;
+    helpUrl;
+    constructor(message, code, userMessage, helpUrl) {
+        super(message);
+        this.code = code;
+        this.userMessage = userMessage;
+        this.helpUrl = helpUrl;
+        this.name = 'SnapCommitError';
+    }
+}
+exports.SnapCommitError = SnapCommitError;
+class APIError extends SnapCommitError {
+    provider;
+    constructor(message, provider, userMessage) {
+        super(message, 'API_ERROR', userMessage || 'AI service temporarily unavailable. Please try again.', 'https://builderos.dev/docs/errors#api-error');
+        this.provider = provider;
+    }
+}
+exports.APIError = APIError;
+class LicenseError extends SnapCommitError {
+    constructor(message, userMessage) {
+        super(message, 'LICENSE_ERROR', userMessage || 'License validation failed.', 'https://builderos.dev/docs/errors#license-error');
+    }
+}
+exports.LicenseError = LicenseError;
+class GitError extends SnapCommitError {
+    constructor(message, userMessage) {
+        super(message, 'GIT_ERROR', userMessage || 'Git operation failed.', 'https://builderos.dev/docs/errors#git-error');
+    }
+}
+exports.GitError = GitError;
+function handleError(error) {
+    if (error instanceof SnapCommitError) {
+        console.error(`\n❌ ${error.userMessage}`);
+        if (error.helpUrl) {
+            console.error(`   Help: ${error.helpUrl}`);
+        }
+        process.exit(1);
+    }
+    if (error instanceof Error) {
+        console.error(`\n❌ Unexpected error: ${error.message}`);
+        console.error('   Please report this at: https://github.com/Arjun0606/builderOS/issues');
+        process.exit(1);
+    }
+    console.error('\n❌ An unknown error occurred');
+    process.exit(1);
+}

package/dist/utils/git.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitDiff = getGitDiff;
+exports.getGitStatus = getGitStatus;
+exports.isGitRepo = isGitRepo;
+exports.stageAllChanges = stageAllChanges;
+exports.commitWithMessage = commitWithMessage;
+exports.getCommitStats = getCommitStats;
+exports.getCurrentBranch = getCurrentBranch;
+const child_process_1 = require("child_process");
+function getGitDiff(staged = true) {
+    try {
+        if (staged) {
+            // Get staged changes
+            const diff = (0, child_process_1.execSync)('git diff --cached', {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024 // 10MB buffer for large diffs
+            });
+            return diff;
+        }
+        else {
+            // Get unstaged changes
+            const diff = (0, child_process_1.execSync)('git diff', {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024
+            });
+            return diff;
+        }
+    }
+    catch (error) {
+        throw new Error(`Git error: ${error.message}`);
+    }
+}
+function getGitStatus() {
+    try {
+        const status = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf-8' });
+        const lines = status.trim().split('\n').filter(Boolean);
+        let staged = 0;
+        let unstaged = 0;
+        let untracked = 0;
+        lines.forEach((line) => {
+            const statusCode = line.substring(0, 2);
+            if (statusCode[0] !== ' ' && statusCode[0] !== '?')
+                staged++;
+            if (statusCode[1] !== ' ')
+                unstaged++;
+            if (statusCode[0] === '?' && statusCode[1] === '?')
+                untracked++;
+        });
+        return { staged, unstaged, untracked };
+    }
+    catch (error) {
+        throw new Error(`Git error: ${error.message}`);
+    }
+}
+function isGitRepo() {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function stageAllChanges() {
+    try {
+        (0, child_process_1.execSync)('git add -A', { stdio: 'inherit' });
+    }
+    catch (error) {
+        throw new Error(`Git add failed: ${error.message}`);
+    }
+}
+function commitWithMessage(message) {
+    try {
+        (0, child_process_1.execSync)(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+        // Get the commit hash
+        const hash = (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+        return hash;
+    }
+    catch (error) {
+        throw new Error(`Git commit failed: ${error.message}`);
+    }
+}
+function getCommitStats(hash) {
+    try {
+        const stats = (0, child_process_1.execSync)(`git show --stat --format="" ${hash}`, { encoding: 'utf-8' });
+        const match = stats.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+        return {
+            files: match?.[1] ? parseInt(match[1]) : 0,
+            insertions: match?.[2] ? parseInt(match[2]) : 0,
+            deletions: match?.[3] ? parseInt(match[3]) : 0,
+        };
+    }
+    catch {
+        return { files: 0, insertions: 0, deletions: 0 };
+    }
+}
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git branch --show-current', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}

package/dist/utils/heatmap.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * GitHub-style contribution heatmap for terminal
+ * Shows coding activity over last 12 weeks
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHeatmap = generateHeatmap;
+exports.getActivitySummary = getActivitySummary;
+exports.displayHeatmap = displayHeatmap;
+const chalk_1 = __importDefault(require("chalk"));
+const database_1 = require("../db/database");
+/**
+ * Generate terminal heatmap (GitHub-style)
+ */
+function generateHeatmap(weeks = 12) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    // Get all commits from the timeframe
+    const stats = (0, database_1.getStats)(weeks * 7);
+    // Group commits by date
+    const commitsByDate = new Map();
+    stats.recentCommits.forEach((commit) => {
+        const date = new Date(commit.timestamp);
+        date.setHours(0, 0, 0, 0);
+        const dateKey = date.toISOString().split('T')[0];
+        commitsByDate.set(dateKey, (commitsByDate.get(dateKey) || 0) + 1);
+    });
+    // Generate grid (7 days x N weeks)
+    const grid = [];
+    // Start from the most recent Sunday
+    const startDate = new Date(today);
+    const dayOfWeek = startDate.getDay(); // 0 = Sunday
+    startDate.setDate(startDate.getDate() - dayOfWeek - (weeks * 7) + 7);
+    for (let week = 0; week < weeks; week++) {
+        const weekData = [];
+        for (let day = 0; day < 7; day++) {
+            const date = new Date(startDate);
+            date.setDate(date.getDate() + (week * 7) + day);
+            const dateKey = date.toISOString().split('T')[0];
+            const commits = commitsByDate.get(dateKey) || 0;
+            weekData.push({ date, commits });
+        }
+        grid.push(weekData);
+    }
+    // Render heatmap
+    return renderHeatmap(grid, commitsByDate);
+}
+/**
+ * Render the heatmap with colors
+ */
+function renderHeatmap(grid, commitsByDate) {
+    const maxCommits = Math.max(...Array.from(commitsByDate.values()), 1);
+    let output = '';
+    // Header
+    output += chalk_1.default.white.bold('\n📈 Contribution Graph (Last 12 Weeks)\n\n');
+    // Month labels (top row)
+    output += '     ';
+    const monthLabels = [];
+    let lastMonth = -1;
+    grid.forEach((week, weekIndex) => {
+        const monthNum = week[0].date.getMonth();
+        if (monthNum !== lastMonth && weekIndex % 4 === 0) {
+            const monthName = week[0].date.toLocaleString('default', { month: 'short' });
+            monthLabels.push(monthName);
+            lastMonth = monthNum;
+        }
+        else {
+            monthLabels.push('');
+        }
+    });
+    // Print month labels (every 4 weeks roughly)
+    for (let i = 0; i < grid.length; i++) {
+        if (i % 4 === 0 && i < grid.length - 3) {
+            const month = grid[i][0].date.toLocaleString('default', { month: 'short' });
+            output += chalk_1.default.gray(month.padEnd(4));
+            i += 3; // Skip next 3 weeks
+        }
+        else {
+            output += '  ';
+        }
+    }
+    output += '\n';
+    // Day labels + grid
+    const dayLabels = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    for (let day = 0; day < 7; day++) {
+        // Only show labels for Mon, Wed, Fri
+        if (day === 1 || day === 3 || day === 5) {
+            output += chalk_1.default.gray(dayLabels[day].substring(0, 3).padEnd(5));
+        }
+        else {
+            output += '     ';
+        }
+        // Render each week for this day
+        for (let week = 0; week < grid.length; week++) {
+            const dayData = grid[week][day];
+            const intensity = getIntensity(dayData.commits, maxCommits);
+            const cell = getColoredCell(intensity, dayData.date);
+            output += cell + ' ';
+        }
+        output += '\n';
+    }
+    // Legend
+    output += '\n     ';
+    output += chalk_1.default.gray('Less  ');
+    output += getColoredCell(0) + ' ';
+    output += getColoredCell(1) + ' ';
+    output += getColoredCell(2) + ' ';
+    output += getColoredCell(3) + ' ';
+    output += getColoredCell(4) + ' ';
+    output += chalk_1.default.gray('  More');
+    output += '\n';
+    return output;
+}
+/**
+ * Get intensity level (0-4) based on commit count
+ */
+function getIntensity(commits, maxCommits) {
+    if (commits === 0)
+        return 0;
+    if (maxCommits === 1)
+        return 4; // If max is 1, show as full
+    const percentage = commits / maxCommits;
+    if (percentage >= 0.75)
+        return 4; // Darkest
+    if (percentage >= 0.50)
+        return 3;
+    if (percentage >= 0.25)
+        return 2;
+    if (percentage > 0)
+        return 1; // Lightest
+    return 0;
+}
+/**
+ * Get colored cell based on intensity
+ */
+function getColoredCell(intensity, date) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const isToday = date && date.getTime() === today.getTime();
+    const isFuture = date && date > today;
+    // Future dates (gray, empty)
+    if (isFuture) {
+        return chalk_1.default.gray('·');
+    }
+    // Today gets a special highlight
+    if (isToday) {
+        switch (intensity) {
+            case 0: return chalk_1.default.yellow('◯'); // No commits today yet
+            case 1: return chalk_1.default.cyan('◉');
+            case 2: return chalk_1.default.cyan('◉');
+            case 3: return chalk_1.default.green('◉');
+            case 4: return chalk_1.default.green('◉');
+            default: return chalk_1.default.gray('·');
+        }
+    }
+    // Regular cells (GitHub-style green gradient)
+    switch (intensity) {
+        case 0: return chalk_1.default.gray('·'); // No activity
+        case 1: return chalk_1.default.rgb(14, 68, 41)('■'); // Light green
+        case 2: return chalk_1.default.rgb(0, 109, 50)('■'); // Medium green
+        case 3: return chalk_1.default.rgb(38, 166, 65)('■'); // Green
+        case 4: return chalk_1.default.rgb(57, 211, 83)('■'); // Bright green
+        default: return chalk_1.default.gray('·');
+    }
+}
+/**
+ * Get activity summary for heatmap
+ */
+function getActivitySummary(weeks = 12) {
+    const stats = (0, database_1.getStats)(weeks * 7);
+    const commitsByDate = new Map();
+    stats.recentCommits.forEach((commit) => {
+        const date = new Date(commit.timestamp);
+        date.setHours(0, 0, 0, 0);
+        const dateKey = date.toISOString().split('T')[0];
+        commitsByDate.set(dateKey, (commitsByDate.get(dateKey) || 0) + 1);
+    });
+    const activeDays = commitsByDate.size;
+    const totalDays = weeks * 7;
+    const averagePerDay = totalDays > 0 ? stats.recentCommits.length / totalDays : 0;
+    // Find most productive day
+    let mostProductiveDay = { date: '', commits: 0 };
+    commitsByDate.forEach((commits, date) => {
+        if (commits > mostProductiveDay.commits) {
+            mostProductiveDay = { date, commits };
+        }
+    });
+    // Calculate streaks (simple version)
+    let currentStreak = 0;
+    let longestStreak = 0;
+    let tempStreak = 0;
+    const sortedDates = Array.from(commitsByDate.keys()).sort().reverse();
+    let lastDate = null;
+    sortedDates.forEach(dateStr => {
+        const date = new Date(dateStr);
+        if (lastDate) {
+            const diffDays = Math.floor((lastDate.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+            if (diffDays === 1) {
+                tempStreak++;
+            }
+            else {
+                longestStreak = Math.max(longestStreak, tempStreak);
+                tempStreak = 1;
+            }
+        }
+        else {
+            // Check if most recent date is today or yesterday
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const diffFromToday = Math.floor((today.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
+            if (diffFromToday <= 1) {
+                currentStreak = 1;
+                tempStreak = 1;
+            }
+        }
+        lastDate = date;
+    });
+    longestStreak = Math.max(longestStreak, tempStreak);
+    if (currentStreak > 0) {
+        currentStreak = tempStreak;
+    }
+    return {
+        totalCommits: stats.recentCommits.length,
+        activeDays,
+        longestStreak,
+        currentStreak,
+        averagePerDay: Math.round(averagePerDay * 10) / 10,
+        mostProductiveDay,
+    };
+}
+/**
+ * Display heatmap with summary stats
+ */
+function displayHeatmap(weeks = 12) {
+    const heatmap = generateHeatmap(weeks);
+    const summary = getActivitySummary(weeks);
+    console.log(heatmap);
+    // Summary stats below heatmap
+    console.log(chalk_1.default.white.bold('\n📊 Activity Summary:\n'));
+    const stats = [
+        { label: 'Total commits', value: summary.totalCommits, emoji: '💻' },
+        { label: 'Active days', value: `${summary.activeDays}/${weeks * 7}`, emoji: '📅' },
+        { label: 'Current streak', value: `${summary.currentStreak} days`, emoji: '🔥' },
+        { label: 'Longest streak', value: `${summary.longestStreak} days`, emoji: '🏆' },
+        { label: 'Avg per day', value: summary.averagePerDay.toFixed(1), emoji: '📈' },
+    ];
+    stats.forEach(stat => {
+        console.log(chalk_1.default.gray(`  ${stat.emoji} ${stat.label}:`.padEnd(25)) +
+            chalk_1.default.cyan(stat.value.toString()));
+    });
+    if (summary.mostProductiveDay.commits > 0) {
+        const date = new Date(summary.mostProductiveDay.date);
+        const formattedDate = date.toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric'
+        });
+        console.log(chalk_1.default.gray(`  🌟 Most productive:`.padEnd(25)) +
+            chalk_1.default.cyan(`${summary.mostProductiveDay.commits} commits on ${formattedDate}`));
+    }
+    console.log();
+}