@snapcommit/cli 1.0.0

package/dist/repl/interpreter.js

@@ -0,0 +1,524 @@
+"use strict";
+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.executeNaturalLanguageCommand = executeNaturalLanguageCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const git_interpreter_1 = require("../ai/git-interpreter");
+const gemini_client_1 = require("../ai/gemini-client");
+const quick_1 = require("../commands/quick");
+const stats_1 = require("../commands/stats");
+const readline_1 = __importDefault(require("readline"));
+const github = __importStar(require("../lib/github"));
+const gitAdvanced = __importStar(require("../commands/git-advanced"));
+/**
+ * Execute a natural language command in the REPL
+ */
+async function executeNaturalLanguageCommand(input, context) {
+    // Normalize input (handle references like "that", "it", etc.)
+    const normalizedInput = normalizeInput(input, context);
+    // Check for clarification needs
+    const clarification = await (0, gemini_client_1.needsClarificationGemini)(normalizedInput);
+    if (clarification.needsClarification && clarification.options) {
+        const choice = await askForClarification(clarification.options);
+        if (!choice) {
+            console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+            return;
+        }
+        // Re-execute with clarified intent
+        await executeNaturalLanguageCommand(choice, context);
+        return;
+    }
+    // Get Git context
+    const gitContext = getGitContext();
+    // Pattern matching for common commands (fast path)
+    const handled = await tryQuickCommands(normalizedInput, context);
+    if (handled) {
+        return;
+    }
+    // AI interpretation
+    console.log(chalk_1.default.gray('\n🤖 Understanding your request...\n'));
+    try {
+        const intent = await (0, git_interpreter_1.interpretGitCommand)(normalizedInput, gitContext);
+        // Show what we'll do
+        console.log(chalk_1.default.bold(intent.action));
+        console.log(chalk_1.default.gray(intent.explanation));
+        // Safety warning for high-risk operations
+        if (intent.riskLevel === 'high' && intent.safetyWarning) {
+            console.log(chalk_1.default.yellow(`\n⚠️  ${intent.safetyWarning}`));
+        }
+        // Show commands (learning mode)
+        if (intent.gitCommands.length > 0) {
+            console.log(chalk_1.default.gray(`\n💡 Commands: ${intent.gitCommands.join(' && ')}`));
+        }
+        // Ask for confirmation for medium/high risk operations
+        if (intent.riskLevel === 'medium' || intent.riskLevel === 'high') {
+            const confirmed = await askForConfirmation();
+            if (!confirmed) {
+                console.log(chalk_1.default.gray('\n🚫 Cancelled\n'));
+                return;
+            }
+        }
+        // Execute commands
+        if (intent.gitCommands.length > 0) {
+            console.log('');
+            for (const cmd of intent.gitCommands) {
+                try {
+                    console.log(chalk_1.default.gray(`  Running: ${cmd}`));
+                    (0, child_process_1.execSync)(cmd, { stdio: 'inherit' });
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(`\n❌ Command failed: ${cmd}`));
+                    // Try smart problem solving
+                    console.log(chalk_1.default.gray('\n🤔 Let me try to fix this...\n'));
+                    const solution = await (0, gemini_client_1.solveGitProblemGemini)(normalizedInput, {
+                        currentBranch: gitContext.currentBranch,
+                        gitStatus: gitContext.gitStatus || '',
+                        recentError: String(error),
+                    });
+                    if (solution.success && solution.gitCommands) {
+                        console.log(chalk_1.default.cyan(`💡 ${solution.message}\n`));
+                        for (const fixCmd of solution.gitCommands) {
+                            console.log(chalk_1.default.gray(`  Running: ${fixCmd}`));
+                            (0, child_process_1.execSync)(fixCmd, { stdio: 'inherit' });
+                        }
+                    }
+                    else {
+                        console.log(chalk_1.default.red(`\n❌ ${solution.message}\n`));
+                        return;
+                    }
+                }
+            }
+            console.log(chalk_1.default.green('\n✅ Done!\n'));
+            // Update context
+            updateContext(context, intent, normalizedInput);
+        }
+        else {
+            console.log(chalk_1.default.yellow('\n⚠️  No commands to execute\n'));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Error: ${error.message}\n`));
+    }
+}
+/**
+ * Normalize user input (handle "that", "it", etc.)
+ */
+function normalizeInput(input, context) {
+    let normalized = input;
+    // Replace "that" with last context
+    if (normalized.includes('that') && context.lastBranch) {
+        normalized = normalized.replace(/\bthat\b/gi, context.lastBranch);
+    }
+    // Replace "it" with last action
+    if (normalized.includes('it') && context.lastBranch) {
+        normalized = normalized.replace(/\bit\b/gi, context.lastBranch);
+    }
+    return normalized;
+}
+/**
+ * Try to handle common commands quickly (pattern matching)
+ */
+async function tryQuickCommands(input, context) {
+    const lower = input.toLowerCase();
+    // Commit commands
+    if (lower === 'commit' ||
+        lower === 'commit my changes' ||
+        lower === 'commit my work' ||
+        lower.startsWith('commit ')) {
+        await (0, quick_1.quickCommand)();
+        context.lastAction = 'commit';
+        return true;
+    }
+    // Stats commands
+    if (lower === 'stats' ||
+        lower === 'show me my stats' ||
+        lower === 'show stats' ||
+        lower === 'show me my progress' ||
+        lower === 'show progress') {
+        (0, stats_1.statsCommand)();
+        return true;
+    }
+    // Push commands
+    if (lower === 'push' || lower === 'push it' || lower === 'push that') {
+        try {
+            console.log(chalk_1.default.gray('\n📤 Pushing to remote...\n'));
+            (0, child_process_1.execSync)('git push', { stdio: 'inherit' });
+            console.log(chalk_1.default.green('\n✅ Pushed!\n'));
+            context.lastAction = 'push';
+            return true;
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('\n❌ Push failed\n'));
+            return true;
+        }
+    }
+    // Pull commands
+    if (lower === 'pull' || lower === 'pull latest' || lower === 'pull changes') {
+        try {
+            console.log(chalk_1.default.gray('\n📥 Pulling from remote...\n'));
+            (0, child_process_1.execSync)('git pull', { stdio: 'inherit' });
+            console.log(chalk_1.default.green('\n✅ Pulled!\n'));
+            context.lastAction = 'pull';
+            return true;
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('\n❌ Pull failed\n'));
+            return true;
+        }
+    }
+    // Status commands
+    if (lower === 'status' || lower === 'show status' || lower === 'what changed') {
+        try {
+            console.log('');
+            (0, child_process_1.execSync)('git status', { stdio: 'inherit' });
+            console.log('');
+            return true;
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('\n❌ Failed to get status\n'));
+            return true;
+        }
+    }
+    // GitHub: Create PR
+    if (lower === 'create pr' ||
+        lower === 'create a pr' ||
+        lower === 'make a pr' ||
+        lower === 'open pr' ||
+        lower === 'create pull request' ||
+        lower.includes('create pr')) {
+        await handleCreatePR(context);
+        return true;
+    }
+    // GitHub: Check CI
+    if (lower === 'check ci' ||
+        lower === 'ci status' ||
+        lower === 'check status' ||
+        lower === 'did ci pass' ||
+        lower === 'check if ci passed') {
+        await handleCheckCI();
+        return true;
+    }
+    // GitHub: List PRs
+    if (lower === 'list prs' ||
+        lower === 'show prs' ||
+        lower === 'my prs' ||
+        lower === 'pull requests') {
+        await handleListPRs();
+        return true;
+    }
+    // GitHub: Merge PR
+    const mergePRMatch = lower.match(/merge pr (\d+)/);
+    if (mergePRMatch) {
+        await handleMergePR(parseInt(mergePRMatch[1], 10));
+        return true;
+    }
+    // Git Advanced: Stash
+    if (lower === 'stash' ||
+        lower === 'stash my changes' ||
+        lower === 'stash changes' ||
+        lower === 'save my work' ||
+        lower.startsWith('stash ')) {
+        const messageMatch = input.match(/stash (?:my changes |changes )?(.+)/i);
+        await gitAdvanced.stashChanges(messageMatch ? messageMatch[1] : undefined);
+        context.lastAction = 'stash';
+        return true;
+    }
+    // Git Advanced: List stash
+    if (lower === 'list stash' || lower === 'show stash' || lower === 'stash list') {
+        gitAdvanced.listStash();
+        return true;
+    }
+    // Git Advanced: Apply stash
+    if (lower === 'apply stash' || lower === 'pop stash' || lower.includes('unstash')) {
+        if (lower.includes('pop')) {
+            await gitAdvanced.popStash();
+        }
+        else {
+            await gitAdvanced.applyStash();
+        }
+        context.lastAction = 'apply_stash';
+        return true;
+    }
+    // Git Advanced: Create branch
+    const createBranchMatch = input.match(/(?:create|make|new) (?:a )?branch (?:called )?(.+)/i);
+    if (createBranchMatch) {
+        const branchName = createBranchMatch[1].trim();
+        await gitAdvanced.createBranch(branchName);
+        context.lastBranch = branchName;
+        context.lastAction = 'create_branch';
+        return true;
+    }
+    // Git Advanced: Switch branch
+    const switchBranchMatch = input.match(/(?:switch to|checkout|go to) (?:branch )?(.+)/i);
+    if (switchBranchMatch && !lower.includes('main') && !lower.includes('master')) {
+        const branchName = switchBranchMatch[1].trim();
+        await gitAdvanced.switchBranch(branchName);
+        context.lastBranch = branchName;
+        context.lastAction = 'switch_branch';
+        return true;
+    }
+    // Git Advanced: Merge branch
+    const mergeBranchMatch = input.match(/merge (?:branch )?(.+?)(?: into| to)?/i);
+    if (mergeBranchMatch && !lower.includes('pr')) {
+        const branchName = mergeBranchMatch[1].trim();
+        await gitAdvanced.mergeBranch(branchName);
+        context.lastAction = 'merge';
+        return true;
+    }
+    // Git Advanced: Delete branch
+    const deleteBranchMatch = input.match(/delete (?:branch )?(.+)/i);
+    if (deleteBranchMatch) {
+        const branchName = deleteBranchMatch[1].trim();
+        await gitAdvanced.deleteBranch(branchName);
+        context.lastAction = 'delete_branch';
+        return true;
+    }
+    // Git Advanced: Rebase
+    const rebaseMatch = input.match(/rebase (?:onto )?(.+)/i);
+    if (rebaseMatch) {
+        const targetBranch = rebaseMatch[1].trim();
+        await gitAdvanced.rebaseOnto(targetBranch);
+        context.lastAction = 'rebase';
+        return true;
+    }
+    // Git Advanced: Cherry-pick
+    const cherryPickMatch = input.match(/cherry[- ]?pick (.+)/i);
+    if (cherryPickMatch) {
+        const commitHash = cherryPickMatch[1].trim();
+        await gitAdvanced.cherryPick(commitHash);
+        context.lastAction = 'cherry_pick';
+        return true;
+    }
+    // Git Advanced: Amend
+    if (lower === 'amend' || lower === 'amend commit' || lower === 'fix commit') {
+        await gitAdvanced.amendCommit();
+        context.lastAction = 'amend';
+        return true;
+    }
+    // Git Advanced: Show log
+    if (lower === 'log' ||
+        lower === 'show log' ||
+        lower === 'history' ||
+        lower === 'show history' ||
+        lower.includes('last commits')) {
+        gitAdvanced.showLog();
+        return true;
+    }
+    // Git Advanced: Show diff
+    if (lower === 'diff' || lower === 'show diff' || lower === 'what changed' || lower === 'changes') {
+        gitAdvanced.showDiff();
+        return true;
+    }
+    return false;
+}
+/**
+ * Handle creating a PR
+ */
+async function handleCreatePR(context) {
+    try {
+        console.log(chalk_1.default.gray('\n🔄 Creating pull request...\n'));
+        const pr = await github.createPullRequest({});
+        console.log(chalk_1.default.green(`✅ PR #${pr.number} created: ${pr.title}`));
+        console.log(chalk_1.default.gray(`   URL: ${pr.html_url}\n`));
+        context.lastAction = 'create_pr';
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to create PR: ${error.message}\n`));
+    }
+}
+/**
+ * Handle checking CI status
+ */
+async function handleCheckCI() {
+    try {
+        console.log(chalk_1.default.gray('\n🔍 Checking CI/CD status...\n'));
+        const { status, checks } = await github.getCommitStatus();
+        console.log(chalk_1.default.bold('⏳ CI Status:\n'));
+        // Show overall status
+        if (status.state === 'success') {
+            console.log(chalk_1.default.green(`   ✅ All checks passed`));
+        }
+        else if (status.state === 'pending') {
+            console.log(chalk_1.default.yellow(`   ⏳ Checks running...`));
+        }
+        else if (status.state === 'failure') {
+            console.log(chalk_1.default.red(`   ❌ Some checks failed`));
+        }
+        // Show individual checks
+        if (checks.length > 0) {
+            console.log('');
+            checks.forEach((check) => {
+                const icon = check.status === 'completed' && check.conclusion === 'success'
+                    ? chalk_1.default.green('✅')
+                    : check.status === 'in_progress'
+                        ? chalk_1.default.yellow('⏳')
+                        : chalk_1.default.red('❌');
+                console.log(`   ${icon} ${check.name}`);
+            });
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to check CI: ${error.message}\n`));
+    }
+}
+/**
+ * Handle listing PRs
+ */
+async function handleListPRs() {
+    try {
+        console.log(chalk_1.default.gray('\n🔍 Fetching pull requests...\n'));
+        const prs = await github.listPullRequests({ limit: 5 });
+        if (prs.length === 0) {
+            console.log(chalk_1.default.gray('   No open pull requests\n'));
+            return;
+        }
+        console.log(chalk_1.default.bold('📋 Open Pull Requests:\n'));
+        prs.forEach((pr) => {
+            console.log(chalk_1.default.cyan(`   #${pr.number}`) + ` ${pr.title}`);
+            console.log(chalk_1.default.gray(`      ${pr.user.login} → ${pr.base.ref}`));
+        });
+        console.log('');
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to list PRs: ${error.message}\n`));
+    }
+}
+/**
+ * Handle merging a PR
+ */
+async function handleMergePR(prNumber) {
+    try {
+        console.log(chalk_1.default.gray(`\n🔄 Merging PR #${prNumber}...\n`));
+        const result = await github.mergePullRequest(prNumber);
+        console.log(chalk_1.default.green(`✅ PR #${prNumber} merged!`));
+        console.log(chalk_1.default.gray(`   SHA: ${result.sha}\n`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to merge PR: ${error.message}\n`));
+    }
+}
+/**
+ * Get current Git context
+ */
+function getGitContext() {
+    try {
+        const currentBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+        const gitStatus = (0, child_process_1.execSync)('git status', { encoding: 'utf-8' }).trim();
+        const hasUncommittedChanges = gitStatus.includes('Changes not staged') || gitStatus.includes('Changes to be committed');
+        let lastCommitHash;
+        try {
+            lastCommitHash = (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+        }
+        catch {
+            lastCommitHash = undefined;
+        }
+        return {
+            currentBranch,
+            hasUncommittedChanges,
+            lastCommitHash,
+            gitStatus,
+        };
+    }
+    catch (error) {
+        return {
+            currentBranch: 'unknown',
+            hasUncommittedChanges: false,
+            gitStatus: '',
+        };
+    }
+}
+/**
+ * Ask user for confirmation
+ */
+async function askForConfirmation() {
+    return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(chalk_1.default.cyan('\nContinue? (y/N): '), (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+/**
+ * Ask user for clarification
+ */
+async function askForClarification(options) {
+    return new Promise((resolve) => {
+        console.log(chalk_1.default.yellow('\n🤔 I need clarification:\n'));
+        options.forEach((opt, i) => {
+            console.log(chalk_1.default.cyan(`  ${i + 1}) ${opt.label}`));
+        });
+        console.log('');
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(chalk_1.default.cyan('Choose (1-' + options.length + ') or (c)ancel: '), (answer) => {
+            rl.close();
+            if (answer.toLowerCase() === 'c' || answer.toLowerCase() === 'cancel') {
+                resolve(null);
+                return;
+            }
+            const choice = parseInt(answer, 10);
+            if (choice >= 1 && choice <= options.length) {
+                resolve(options[choice - 1].value);
+            }
+            else {
+                console.log(chalk_1.default.red('\n❌ Invalid choice\n'));
+                resolve(null);
+            }
+        });
+    });
+}
+/**
+ * Update context after successful command
+ */
+function updateContext(context, intent, input) {
+    // Extract branch names from commands
+    const branchMatch = intent.gitCommands.join(' ').match(/(?:checkout|branch|switch) (\S+)/);
+    if (branchMatch) {
+        context.lastBranch = branchMatch[1];
+    }
+    // Store last action
+    context.lastAction = intent.action;
+}

package/dist/utils/analytics.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Privacy-focused analytics tracking
+ * Stores locally for insights, no external tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENTS = void 0;
+exports.trackEvent = trackEvent;
+const database_1 = require("../db/database");
+/**
+ * Track an event (privacy-friendly, local only)
+ */
+function trackEvent(eventData) {
+    try {
+        (0, database_1.logAnalyticsEvent)(eventData.event, eventData.data || {});
+    }
+    catch (error) {
+        // Silent fail - don't break user experience for analytics
+    }
+}
+/**
+ * Get common event types (for consistency)
+ */
+exports.EVENTS = {
+    COMMIT_SUCCESS: 'commit_success',
+    COMMIT_ERROR: 'commit_error',
+    COMMIT_BLOCKED: 'commit_blocked',
+    RATE_LIMITED: 'rate_limited',
+    TRIAL_STARTED: 'trial_started',
+    PRO_ACTIVATED: 'pro_activated',
+    NATURAL_COMMAND_SUCCESS: 'natural_command_success',
+    NATURAL_COMMAND_ERROR: 'natural_command_error',
+    CONFLICT_RESOLVED: 'conflict_resolved',
+    ONBOARDING_COMPLETED: 'onboarding_completed',
+    SETUP_COMPLETED: 'setup_completed',
+};

package/dist/utils/auth-storage.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Auth token storage utilities
+ * Stores Supabase auth tokens securely in local database
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveAuthToken = saveAuthToken;
+exports.getAuthToken = getAuthToken;
+exports.clearAuthToken = clearAuthToken;
+const database_1 = require("../db/database");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Save auth tokens to local database
+ */
+async function saveAuthToken(accessToken, refreshToken) {
+    try {
+        const db = (0, database_1.getDB)();
+        db.prepare(`
+      INSERT OR REPLACE INTO auth_tokens (id, access_token, refresh_token, updated_at)
+      VALUES (1, ?, ?, ?)
+    `).run(accessToken, refreshToken || null, Date.now());
+        return true;
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to save auth token:'), error.message);
+        return false;
+    }
+}
+/**
+ * Get auth tokens from local database
+ */
+function getAuthToken() {
+    try {
+        const db = (0, database_1.getDB)();
+        const row = db.prepare(`
+      SELECT access_token, refresh_token FROM auth_tokens WHERE id = 1
+    `).get();
+        if (!row)
+            return null;
+        return {
+            accessToken: row.access_token,
+            refreshToken: row.refresh_token || undefined,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Clear auth tokens from local database
+ */
+async function clearAuthToken() {
+    try {
+        const db = (0, database_1.getDB)();
+        db.prepare('DELETE FROM auth_tokens').run();
+        return true;
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Failed to clear auth token:'), error.message);
+        return false;
+    }
+}