@snapcommit/cli 1.0.0

package/dist/auth/supabase-client.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Supabase authentication client for CLI
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supabase = void 0;
+exports.saveAuthTokens = saveAuthTokens;
+exports.loadAuthTokens = loadAuthTokens;
+exports.clearAuthTokens = clearAuthTokens;
+exports.isAuthenticated = isAuthenticated;
+exports.getCurrentSession = getCurrentSession;
+exports.signInWithEmail = signInWithEmail;
+exports.signUpWithEmail = signUpWithEmail;
+exports.signInWithGitHub = signInWithGitHub;
+exports.signOut = signOut;
+exports.getAuthenticatedClient = getAuthenticatedClient;
+exports.syncCommitToCloud = syncCommitToCloud;
+const supabase_js_1 = require("@supabase/supabase-js");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const SUPABASE_URL = process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || '';
+// Supabase is optional - CLI works offline without it
+// Only throw error when trying to use auth features
+const hasSupabaseConfig = SUPABASE_URL && SUPABASE_ANON_KEY;
+exports.supabase = hasSupabaseConfig
+    ? (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY)
+    : null;
+// Helper to ensure Supabase is configured
+function ensureSupabaseConfigured() {
+    if (!hasSupabaseConfig || !exports.supabase) {
+        throw new Error('Supabase not configured. Cloud sync features require NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY in .env');
+    }
+    return exports.supabase;
+}
+// Auth token storage
+const AUTH_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit');
+const AUTH_FILE = path_1.default.join(AUTH_DIR, 'auth.json');
+/**
+ * Save auth tokens to local storage
+ */
+function saveAuthTokens(data) {
+    if (!fs_1.default.existsSync(AUTH_DIR)) {
+        fs_1.default.mkdirSync(AUTH_DIR, { recursive: true });
+    }
+    fs_1.default.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2));
+    // Secure the file (Unix only)
+    try {
+        fs_1.default.chmodSync(AUTH_FILE, 0o600);
+    }
+    catch {
+        // Windows doesn't support chmod
+    }
+}
+/**
+ * Load auth tokens from local storage
+ */
+function loadAuthTokens() {
+    if (!fs_1.default.existsSync(AUTH_FILE)) {
+        return null;
+    }
+    try {
+        const data = fs_1.default.readFileSync(AUTH_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Clear auth tokens (logout)
+ */
+function clearAuthTokens() {
+    if (fs_1.default.existsSync(AUTH_FILE)) {
+        fs_1.default.unlinkSync(AUTH_FILE);
+    }
+}
+/**
+ * Check if user is authenticated
+ */
+async function isAuthenticated() {
+    const tokens = loadAuthTokens();
+    if (!tokens) {
+        return false;
+    }
+    // Check if token is expired
+    if (Date.now() > tokens.expires_at) {
+        // Try to refresh
+        const refreshed = await refreshAuthToken(tokens.refresh_token);
+        return refreshed !== null;
+    }
+    return true;
+}
+/**
+ * Refresh auth token
+ */
+async function refreshAuthToken(refreshToken) {
+    try {
+        const sb = ensureSupabaseConfigured();
+        const { data, error } = await sb.auth.refreshSession({
+            refresh_token: refreshToken,
+        });
+        if (error || !data.session) {
+            clearAuthTokens();
+            return null;
+        }
+        const authData = {
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+            user_id: data.session.user.id,
+            email: data.session.user.email,
+            expires_at: Date.now() + (data.session.expires_in * 1000),
+        };
+        saveAuthTokens(authData);
+        return authData;
+    }
+    catch {
+        clearAuthTokens();
+        return null;
+    }
+}
+/**
+ * Get current user session
+ */
+async function getCurrentSession() {
+    const tokens = loadAuthTokens();
+    if (!tokens) {
+        return null;
+    }
+    // Refresh if expired
+    if (Date.now() > tokens.expires_at) {
+        return await refreshAuthToken(tokens.refresh_token);
+    }
+    return tokens;
+}
+/**
+ * Sign in with email and password
+ */
+async function signInWithEmail(email, password) {
+    try {
+        const sb = ensureSupabaseConfigured();
+        const { data, error } = await sb.auth.signInWithPassword({
+            email,
+            password,
+        });
+        if (error) {
+            return { success: false, error: error.message };
+        }
+        if (!data.session) {
+            return { success: false, error: 'No session returned' };
+        }
+        const authData = {
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+            user_id: data.session.user.id,
+            email: data.session.user.email,
+            expires_at: Date.now() + (data.session.expires_in * 1000),
+        };
+        saveAuthTokens(authData);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Sign up with email and password
+ */
+async function signUpWithEmail(email, password) {
+    try {
+        const sb = ensureSupabaseConfigured();
+        const { data, error } = await sb.auth.signUp({
+            email,
+            password,
+        });
+        if (error) {
+            return { success: false, error: error.message };
+        }
+        if (!data.session) {
+            // Email confirmation might be required
+            return {
+                success: true,
+                error: 'Check your email to confirm your account'
+            };
+        }
+        const authData = {
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+            user_id: data.session.user.id,
+            email: data.session.user.email,
+            expires_at: Date.now() + (data.session.expires_in * 1000),
+        };
+        saveAuthTokens(authData);
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Sign in with GitHub OAuth
+ * Opens browser for OAuth flow
+ */
+async function signInWithGitHub() {
+    try {
+        const sb = ensureSupabaseConfigured();
+        const { data, error } = await sb.auth.signInWithOAuth({
+            provider: 'github',
+            options: {
+                redirectTo: 'http://localhost:54321/auth/callback', // Local callback server
+            },
+        });
+        if (error) {
+            return { success: false, error: error.message };
+        }
+        return { success: true, url: data.url };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Sign out
+ */
+async function signOut() {
+    const tokens = loadAuthTokens();
+    if (tokens && hasSupabaseConfig && exports.supabase) {
+        // Revoke the session on the server
+        await exports.supabase.auth.signOut();
+    }
+    clearAuthTokens();
+}
+/**
+ * Get authenticated Supabase client
+ * (for making API calls with user's token)
+ */
+async function getAuthenticatedClient() {
+    const sb = ensureSupabaseConfigured();
+    const session = await getCurrentSession();
+    if (!session) {
+        return null;
+    }
+    return (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY, {
+        global: {
+            headers: {
+                Authorization: `Bearer ${session.access_token}`,
+            },
+        },
+    });
+}
+/**
+ * Sync commit to cloud (if authenticated)
+ */
+async function syncCommitToCloud(commit) {
+    if (!hasSupabaseConfig) {
+        return { success: false, error: 'not_configured' };
+    }
+    const session = await getCurrentSession();
+    if (!session) {
+        return { success: false, error: 'not_authenticated' };
+    }
+    try {
+        const client = await getAuthenticatedClient();
+        if (!client) {
+            return { success: false, error: 'no_client' };
+        }
+        const { error } = await client.from('commits').insert({
+            user_id: session.user_id,
+            message: commit.message,
+            hash: commit.hash,
+            files_changed: commit.files_changed,
+            insertions: commit.insertions,
+            deletions: commit.deletions,
+            timestamp: new Date(commit.timestamp).toISOString(),
+        });
+        if (error) {
+            return { success: false, error: error.message };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}

package/dist/commands/activate.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateCommand = activateCommand;
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const manager_1 = require("../license/manager");
+const readline_1 = __importDefault(require("readline"));
+async function activateCommand(licenseKey) {
+    console.log(chalk_1.default.blue.bold('\n🔐 SnapCommit License Activation\n'));
+    // If no key provided, prompt for it
+    if (!licenseKey) {
+        licenseKey = await askQuestion(chalk_1.default.cyan('Enter your license key: '));
+    }
+    if (!licenseKey || !licenseKey.trim()) {
+        console.log(chalk_1.default.red('❌ No license key provided'));
+        process.exit(1);
+    }
+    licenseKey = licenseKey.trim();
+    // Validate format (basic check)
+    if (licenseKey.length < 10) {
+        console.log(chalk_1.default.red('❌ Invalid license key format'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.gray('Validating license key...'));
+    // TODO: Validate against API in production
+    // For now, accept any key that looks valid
+    let plan;
+    if (licenseKey.toLowerCase().includes('yearly') || licenseKey.toLowerCase().includes('annual')) {
+        plan = 'pro_yearly';
+    }
+    else {
+        plan = 'pro_monthly';
+    }
+    try {
+        (0, manager_1.activateLicense)(licenseKey, undefined, plan);
+        console.log(chalk_1.default.green('\n✅ License activated successfully!\n'));
+        const license = (0, manager_1.getCurrentLicense)();
+        if (license) {
+            console.log(chalk_1.default.white.bold('License Details:'));
+            console.log(chalk_1.default.gray(`  Plan: ${license.plan === 'pro_monthly' ? 'Pro Monthly ($9.99/mo)' : 'Pro Yearly ($100/yr)'}`));
+            console.log(chalk_1.default.gray(`  Status: ${license.status}`));
+            if (license.expires_at) {
+                const expiresDate = new Date(license.expires_at);
+                console.log(chalk_1.default.gray(`  Expires: ${expiresDate.toLocaleDateString()}`));
+            }
+        }
+        console.log();
+        console.log(chalk_1.default.green('🎉 You now have unlimited AI commits!'));
+        console.log(chalk_1.default.gray('   Try: ') + chalk_1.default.cyan('snapcommit quick'));
+        console.log();
+    }
+    catch (error) {
+        console.log(chalk_1.default.red('\n❌ Failed to activate license'));
+        console.log(chalk_1.default.gray(`   ${error.message}`));
+        process.exit(1);
+    }
+}
+function statusCommand() {
+    console.log(chalk_1.default.blue.bold('\n📊 SnapCommit License Status\n'));
+    const license = (0, manager_1.getCurrentLicense)();
+    if (!license) {
+        console.log(chalk_1.default.yellow('⚠️  No license found'));
+        console.log(chalk_1.default.gray('   You have a 7-day free trial'));
+        console.log();
+        console.log(chalk_1.default.cyan('Upgrade to Pro:'));
+        console.log(chalk_1.default.gray('   • Unlimited AI commits'));
+        console.log(chalk_1.default.gray('   • Advanced stats'));
+        console.log(chalk_1.default.gray('   • Priority support'));
+        console.log();
+        console.log(chalk_1.default.white('Visit: ') + chalk_1.default.cyan('https://snapcommit.dev/pricing'));
+        console.log();
+        return;
+    }
+    const info = (0, manager_1.getLicenseInfo)();
+    console.log(chalk_1.default.white.bold('Current License:'));
+    console.log(chalk_1.default.gray(`  ${info}`));
+    console.log();
+    if (license.plan === 'free') {
+        const usage = require('../license/manager').getTrialStatus();
+        if (usage.isExpired) {
+            console.log(chalk_1.default.red('❌ Your trial has expired!'));
+            console.log(chalk_1.default.white('Upgrade: ') + chalk_1.default.cyan('https://snapcommit.dev/pricing'));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`💡 ${usage.daysRemaining} day${usage.daysRemaining === 1 ? '' : 's'} left in your trial!`));
+            console.log(chalk_1.default.white('Upgrade: ') + chalk_1.default.cyan('https://snapcommit.dev/pricing'));
+        }
+    }
+    else {
+        console.log(chalk_1.default.green('✅ You have Pro access!'));
+    }
+    console.log();
+}
+function askQuestion(query) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}

package/dist/commands/commit.js

@@ -0,0 +1,255 @@
+"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.commitCommand = commitCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const git_1 = require("../utils/git");
+const database_1 = require("../db/database");
+const manager_1 = require("../license/manager");
+const rate_limit_1 = require("../utils/rate-limit");
+const analytics_1 = require("../utils/analytics");
+const readline_1 = __importDefault(require("readline"));
+async function commitCommand() {
+    // Check license before proceeding
+    const { allowed, reason, usage } = (0, manager_1.canUseCommit)();
+    if (!allowed) {
+        console.log(chalk_1.default.red('\n❌ ' + reason));
+        if (usage) {
+            console.log(chalk_1.default.gray(`   Your 7-day trial has ended`));
+        }
+        console.log();
+        console.log(chalk_1.default.yellow('⭐ Upgrade to Pro to keep using SnapCommit!'));
+        console.log(chalk_1.default.gray('   • $9.99/month or $100/year'));
+        console.log(chalk_1.default.gray('   • Unlimited AI commits'));
+        console.log();
+        console.log(chalk_1.default.white('Visit: ') + chalk_1.default.cyan('https://snapcommit.dev/pricing'));
+        console.log();
+        process.exit(1);
+    }
+    // Check rate limit (prevent abuse)
+    const userPlan = (0, manager_1.isProUser)() ? 'pro' : 'free';
+    const rateLimit = (0, rate_limit_1.checkRateLimit)(userPlan);
+    if (!rateLimit.allowed) {
+        (0, analytics_1.trackEvent)({ event: analytics_1.EVENTS.RATE_LIMITED });
+        console.log(chalk_1.default.red('\n❌ Rate limit exceeded'));
+        console.log(chalk_1.default.gray(`   Too many commits in the last hour`));
+        console.log(chalk_1.default.gray(`   Limit resets in ${(0, rate_limit_1.formatResetTime)(rateLimit.resetAt)}`));
+        console.log();
+        if (userPlan === 'free') {
+            console.log(chalk_1.default.yellow('💡 Pro users have 10x higher limits!'));
+            console.log(chalk_1.default.white('   Visit: ') + chalk_1.default.cyan('https://snapcommit.dev/pricing'));
+        }
+        console.log();
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue('🔍 Analyzing your changes...\n'));
+    // Check if we're in a git repo
+    if (!(0, git_1.isGitRepo)()) {
+        console.log(chalk_1.default.red('❌ Not a git repository'));
+        console.log(chalk_1.default.gray('   Run this command inside a git repo'));
+        process.exit(1);
+    }
+    // Get status
+    let status;
+    try {
+        status = (0, git_1.getGitStatus)();
+    }
+    catch (error) {
+        console.log(chalk_1.default.red('❌ Failed to get git status'));
+        console.log(chalk_1.default.gray(`   ${error.message}`));
+        process.exit(1);
+    }
+    // If nothing staged, ask if they want to stage all
+    if (status.staged === 0 && (status.unstaged > 0 || status.untracked > 0)) {
+        console.log(chalk_1.default.yellow('⚠️  No staged changes found'));
+        console.log(chalk_1.default.gray(`   ${status.unstaged} modified, ${status.untracked} untracked`));
+        console.log();
+        const answer = await askQuestion(chalk_1.default.cyan('   Stage all changes? (Y/n): '));
+        if (answer.toLowerCase() !== 'n') {
+            try {
+                (0, git_1.stageAllChanges)();
+                console.log(chalk_1.default.green('✓ Staged all changes\n'));
+                status = (0, git_1.getGitStatus)();
+            }
+            catch (error) {
+                console.log(chalk_1.default.red('❌ Failed to stage changes'));
+                console.log(chalk_1.default.gray(`   ${error.message}`));
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(chalk_1.default.gray('   Cancelled. Stage files with: git add <files>'));
+            process.exit(0);
+        }
+    }
+    if (status.staged === 0) {
+        console.log(chalk_1.default.yellow('⚠️  No changes to commit'));
+        console.log(chalk_1.default.gray('   Make some changes and stage them with git add'));
+        process.exit(0);
+    }
+    // Get the diff
+    let diff;
+    try {
+        diff = (0, git_1.getGitDiff)(true);
+    }
+    catch (error) {
+        console.log(chalk_1.default.red('❌ Failed to get git diff'));
+        console.log(chalk_1.default.gray(`   ${error.message}`));
+        process.exit(1);
+    }
+    // Check if diff is too large (>50KB)
+    if (diff.length > 50000) {
+        console.log(chalk_1.default.yellow('⚠️  Large diff detected'));
+        console.log(chalk_1.default.gray(`   ${Math.round(diff.length / 1024)}KB of changes`));
+        console.log(chalk_1.default.gray('   This might take a moment...\n'));
+        // Truncate diff for AI (keep first 40KB)
+        diff = diff.substring(0, 40000) + '\n\n... (diff truncated for AI processing)';
+    }
+    // Show status
+    const branch = (0, git_1.getCurrentBranch)();
+    console.log(chalk_1.default.gray(`   Branch: ${branch}`));
+    console.log(chalk_1.default.gray(`   Files: ${status.staged} staged`));
+    console.log();
+    // Generate multiple commit message options with AI
+    console.log(chalk_1.default.blue('🤖 Analyzing changes and generating commit messages...'));
+    console.log();
+    const { generateCommitOptions, displayCommitOptions, editCommitMessage } = await Promise.resolve().then(() => __importStar(require('../ai/commit-generator')));
+    let options;
+    try {
+        options = await generateCommitOptions(diff);
+    }
+    catch (error) {
+        console.log(chalk_1.default.red('❌ Failed to generate commit message'));
+        console.log(chalk_1.default.gray(`   ${error.message}`));
+        console.log();
+        console.log(chalk_1.default.yellow('💡 Tip: Check your ANTHROPIC_API_KEY in .env'));
+        process.exit(1);
+    }
+    // Display all options
+    displayCommitOptions(options);
+    // Ask user to choose
+    const choice = await askQuestion(chalk_1.default.cyan('Choose option (1/2/3) or ') +
+        chalk_1.default.gray('(e)dit / (c)ancel: '));
+    let message;
+    if (choice.toLowerCase() === 'c' || choice.toLowerCase() === 'cancel') {
+        console.log(chalk_1.default.gray('\nCancelled.'));
+        process.exit(0);
+    }
+    else if (choice.toLowerCase() === 'e' || choice.toLowerCase() === 'edit') {
+        // Let user edit the first option
+        message = await editCommitMessage(options[0].message);
+    }
+    else {
+        // User chose a number
+        const optionIndex = parseInt(choice) - 1;
+        if (optionIndex >= 0 && optionIndex < options.length) {
+            message = options[optionIndex].message;
+        }
+        else {
+            // Default to first option
+            message = options[0].message;
+        }
+    }
+    // Commit
+    let hash;
+    try {
+        hash = (0, git_1.commitWithMessage)(message);
+        console.log(chalk_1.default.green('\n✅ Committed successfully!\n'));
+        // Get commit stats
+        const stats = (0, git_1.getCommitStats)(hash);
+        console.log(chalk_1.default.gray(`   Hash: ${hash.substring(0, 7)}`));
+        console.log(chalk_1.default.gray(`   Files: ${stats.files}`));
+        console.log(chalk_1.default.gray(`   +${stats.insertions} -${stats.deletions}`));
+        console.log();
+        // Track usage
+        (0, manager_1.trackCommit)();
+        (0, analytics_1.trackEvent)({ event: analytics_1.EVENTS.COMMIT_SUCCESS });
+        // Log to database
+        (0, database_1.logCommit)({
+            message,
+            hash,
+            files_changed: stats.files,
+            insertions: stats.insertions,
+            deletions: stats.deletions,
+            timestamp: Date.now(),
+        });
+        // Sync to cloud (non-blocking, silent fail)
+        try {
+            const { syncCommitToCloud } = await Promise.resolve().then(() => __importStar(require('../auth/supabase-client')));
+            const syncResult = await syncCommitToCloud({
+                message,
+                hash,
+                files_changed: stats.files,
+                insertions: stats.insertions,
+                deletions: stats.deletions,
+                timestamp: Date.now(),
+            });
+            if (syncResult.success) {
+                console.log(chalk_1.default.gray('   ☁️  Synced to cloud\n'));
+            }
+        }
+        catch (error) {
+            // Silent fail - cloud sync is optional
+        }
+        // Show dopamine stats
+        const { displayQuickDopamine } = await Promise.resolve().then(() => __importStar(require('../utils/dopamine')));
+        displayQuickDopamine();
+        // Show upgrade message for trial users (last 2 days)
+        if (!(0, manager_1.isProUser)() && usage && !usage.isExpired && usage.daysRemaining <= 2) {
+            console.log(chalk_1.default.yellow(`⚠️  Only ${usage.daysRemaining} day${usage.daysRemaining === 1 ? '' : 's'} left in your trial!`));
+            console.log(chalk_1.default.gray('   Upgrade to Pro: https://snapcommit.dev/pricing\n'));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red('❌ Commit failed'));
+        console.log(chalk_1.default.gray(`   ${error.message}`));
+        process.exit(1);
+    }
+}
+function askQuestion(query) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}