@snapcommit/cli 1.0.0

package/dist/db/database.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logActivity = logActivity;
+exports.logCommit = logCommit;
+exports.getStats = getStats;
+exports.logAnalyticsEvent = logAnalyticsEvent;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const DB_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit');
+const DB_PATH = path_1.default.join(DB_DIR, 'snapcommit.db');
+// Ensure directory exists
+if (!fs_1.default.existsSync(DB_DIR)) {
+    fs_1.default.mkdirSync(DB_DIR, { recursive: true });
+}
+const db = new better_sqlite3_1.default(DB_PATH);
+// Initialize database schema
+db.exec(`
+  CREATE TABLE IF NOT EXISTS activities (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    type TEXT NOT NULL,
+    command TEXT,
+    description TEXT,
+    timestamp INTEGER NOT NULL,
+    duration INTEGER,
+    metadata TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_activities_timestamp ON activities(timestamp);
+  CREATE INDEX IF NOT EXISTS idx_activities_type ON activities(type);
+
+  CREATE TABLE IF NOT EXISTS commits (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    message TEXT NOT NULL,
+    hash TEXT,
+    files_changed INTEGER,
+    insertions INTEGER,
+    deletions INTEGER,
+    timestamp INTEGER NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_commits_timestamp ON commits(timestamp);
+`);
+function logActivity(activity) {
+    const stmt = db.prepare(`
+    INSERT INTO activities (type, command, description, timestamp, duration, metadata)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(activity.type, activity.command || null, activity.description || null, activity.timestamp, activity.duration || null, activity.metadata ? JSON.stringify(activity.metadata) : null);
+}
+function logCommit(commit) {
+    const stmt = db.prepare(`
+    INSERT INTO commits (message, hash, files_changed, insertions, deletions, timestamp)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(commit.message, commit.hash || null, commit.files_changed || null, commit.insertions || null, commit.deletions || null, commit.timestamp);
+}
+function getStats(daysBack = 7) {
+    const since = Date.now() - daysBack * 24 * 60 * 60 * 1000;
+    const totalCommits = db
+        .prepare('SELECT COUNT(*) as count FROM commits WHERE timestamp > ?')
+        .get(since);
+    const totalCommands = db
+        .prepare('SELECT COUNT(*) as count FROM activities WHERE type = "command" AND timestamp > ?')
+        .get(since);
+    const recentCommits = db
+        .prepare('SELECT * FROM commits WHERE timestamp > ? ORDER BY timestamp DESC LIMIT 10')
+        .all(since);
+    const totalInsertions = db
+        .prepare('SELECT SUM(insertions) as sum FROM commits WHERE timestamp > ?')
+        .get(since);
+    const totalDeletions = db
+        .prepare('SELECT SUM(deletions) as sum FROM commits WHERE timestamp > ?')
+        .get(since);
+    return {
+        totalCommits: totalCommits.count,
+        totalCommands: totalCommands.count,
+        totalInsertions: totalInsertions.sum || 0,
+        totalDeletions: totalDeletions.sum || 0,
+        recentCommits,
+    };
+}
+// Analytics
+function logAnalyticsEvent(event, data = {}) {
+    try {
+        db.prepare(`
+      INSERT INTO activities (type, command, description, timestamp, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `).run('analytics', event, JSON.stringify(data), Date.now(), null);
+    }
+    catch (error) {
+        // Silent fail - don't break user experience
+    }
+}
+exports.default = db;

package/dist/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = require("dotenv");
+const path_1 = __importDefault(require("path"));
+const version_1 = require("./utils/version");
+const commit_1 = require("./commands/commit");
+const stats_1 = require("./commands/stats");
+const setup_1 = require("./commands/setup");
+const quick_1 = require("./commands/quick");
+const doctor_1 = require("./commands/doctor");
+const activate_1 = require("./commands/activate");
+const onboard_1 = require("./commands/onboard");
+const login_1 = require("./commands/login");
+const natural_1 = require("./commands/natural");
+const conflict_1 = require("./commands/conflict");
+const uninstall_1 = require("./commands/uninstall");
+const repl_1 = require("./repl");
+// Load environment variables from root .env
+(0, dotenv_1.config)({ path: path_1.default.join(__dirname, '../../.env') });
+const program = new commander_1.Command();
+// Check for updates (async, non-blocking)
+(0, version_1.checkForUpdates)().then((result) => {
+    if (result && result.hasUpdate) {
+        console.log(chalk_1.default.yellow(`\n⚠️  Update available: ${result.currentVersion} → ${result.latestVersion}`));
+        console.log(chalk_1.default.gray('   Run: npm install -g builderos\n'));
+    }
+}).catch(() => {
+    // Silent fail
+});
+program
+    .name('snapcommit')
+    .description('Snap. Commit. Track. - Instant AI commits with beautiful stats')
+    .version('1.0.0');
+// Command: devflow commit
+program
+    .command('commit')
+    .alias('c')
+    .description('Generate AI-powered commit message (interactive)')
+    .action(async () => {
+    await (0, commit_1.commitCommand)();
+});
+// Command: devflow quick
+program
+    .command('quick')
+    .alias('q')
+    .description('Quick commit (stage all + AI commit, no prompts)')
+    .action(async () => {
+    await (0, quick_1.quickCommand)();
+});
+// Command: devflow stats
+program
+    .command('stats')
+    .alias('s')
+    .description('Show your coding stats')
+    .action(() => {
+    (0, stats_1.statsCommand)();
+});
+// Command: devflow setup
+program
+    .command('setup')
+    .description('Set up DevFlow shell integration')
+    .action(() => {
+    (0, setup_1.setupCommand)();
+});
+// Command: snapcommit doctor
+program
+    .command('doctor')
+    .alias('check')
+    .description('Check if SnapCommit is set up correctly')
+    .action(() => {
+    (0, doctor_1.doctorCommand)();
+});
+// Command: snapcommit activate
+program
+    .command('activate [license-key]')
+    .description('Activate your Pro license')
+    .action(async (licenseKey) => {
+    await (0, activate_1.activateCommand)(licenseKey);
+});
+// Command: snapcommit status
+program
+    .command('status')
+    .description('Check your license status')
+    .action(() => {
+    (0, activate_1.statusCommand)();
+});
+// Command: snapcommit onboard
+program
+    .command('onboard')
+    .alias('welcome')
+    .description('Interactive onboarding tour')
+    .action(async () => {
+    await (0, onboard_1.onboardCommand)();
+});
+// Command: snapcommit login
+program
+    .command('login')
+    .description('Sign in or sign up to SnapCommit')
+    .action(async () => {
+    await (0, login_1.loginCommand)();
+});
+// Command: snapcommit logout
+program
+    .command('logout')
+    .description('Sign out from SnapCommit')
+    .action(async () => {
+    await (0, login_1.logoutCommand)();
+});
+// Command: snapcommit conflict
+program
+    .command('conflict')
+    .alias('resolve')
+    .description('AI-powered conflict resolution wizard')
+    .action(async () => {
+    await (0, conflict_1.conflictCommand)();
+});
+// Command: snapcommit uninstall
+program
+    .command('uninstall')
+    .description('Remove SnapCommit shell integration')
+    .action(async () => {
+    await (0, uninstall_1.uninstallCommand)();
+});
+// Command: snapcommit <natural language>
+// This catches any non-matching command and treats it as natural language
+program
+    .command('* <words...>')
+    .description('Natural language Git commands (e.g., "undo that", "merge feature")')
+    .action(async (words) => {
+    const userInput = words.join(' ');
+    await (0, natural_1.naturalCommand)(userInput);
+});
+// Default action - Start REPL if no command is given
+program.action(async () => {
+    // If user just types "snapcommit" or "snap", enter REPL mode
+    await (0, repl_1.startREPL)();
+});
+program.parse();

package/dist/lib/auth.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthenticated = isAuthenticated;
+exports.getAuthConfig = getAuthConfig;
+exports.clearAuth = clearAuth;
+exports.promptAuth = promptAuth;
+exports.ensureAuth = ensureAuth;
+exports.getToken = getToken;
+exports.logout = logout;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = __importDefault(require("readline"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.snapcommit');
+const AUTH_FILE = path_1.default.join(CONFIG_DIR, 'auth.json');
+// API URL - defaults to production, can be overridden for development
+const API_BASE_URL = process.env.SNAPCOMMIT_API_URL || 'https://snapcommit.dev';
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Check if user is authenticated
+ */
+function isAuthenticated() {
+    return fs_1.default.existsSync(AUTH_FILE);
+}
+/**
+ * Get stored authentication config
+ */
+function getAuthConfig() {
+    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 (error) {
+        return null;
+    }
+}
+/**
+ * Save authentication config
+ */
+function saveAuthConfig(config) {
+    ensureConfigDir();
+    fs_1.default.writeFileSync(AUTH_FILE, JSON.stringify(config, null, 2));
+}
+/**
+ * Clear authentication
+ */
+function clearAuth() {
+    if (fs_1.default.existsSync(AUTH_FILE)) {
+        fs_1.default.unlinkSync(AUTH_FILE);
+    }
+}
+/**
+ * Ask a question and return the answer
+ */
+function askQuestion(query) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+/**
+ * Verify token with backend
+ */
+async function verifyToken(token) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/auth/token?token=${encodeURIComponent(token)}`);
+        const data = await response.json();
+        if (response.ok && data.valid) {
+            return { valid: true, user: data.user };
+        }
+        return { valid: false };
+    }
+    catch (error) {
+        throw new Error('Failed to verify token. Please check your internet connection.');
+    }
+}
+/**
+ * Prompt user to authenticate
+ */
+async function promptAuth() {
+    console.log(chalk_1.default.bold.cyan('\n🔐 Welcome to SnapCommit!\n'));
+    console.log(chalk_1.default.gray('To use SnapCommit, you need to authenticate.\n'));
+    console.log(chalk_1.default.bold('Step 1:') + chalk_1.default.gray(' Sign up or log in at:'));
+    console.log(chalk_1.default.cyan.underline('  👉 https://snapcommit.dev/login\n'));
+    console.log(chalk_1.default.bold('Step 2:') + chalk_1.default.gray(' Generate a token from your dashboard'));
+    console.log(chalk_1.default.gray('  (You\'ll see a "Generate Token" button)\n'));
+    const token = await askQuestion(chalk_1.default.yellow('Step 3: Paste your token here: '));
+    if (!token || token.trim().length === 0) {
+        console.log(chalk_1.default.red('\n❌ No token provided. Authentication cancelled.\n'));
+        return false;
+    }
+    console.log(chalk_1.default.gray('\n🔄 Verifying token...\n'));
+    try {
+        const result = await verifyToken(token.trim());
+        if (result.valid && result.user) {
+            const config = {
+                token: token.trim(),
+                userId: result.user.id,
+                email: result.user.email,
+                name: result.user.name || 'Developer',
+            };
+            saveAuthConfig(config);
+            console.log(chalk_1.default.green(`✅ Authenticated successfully! Welcome, ${chalk_1.default.bold(config.name)}!\n`));
+            console.log(chalk_1.default.gray('💎 SnapCommit Pro - Unlimited AI commits'));
+            console.log(chalk_1.default.gray('🔥 Your coding journey starts now!\n'));
+            console.log(chalk_1.default.gray('Try: snap quick (in any git repo)\n'));
+            return true;
+        }
+        else {
+            console.log(chalk_1.default.red('\n❌ Invalid token. Please try again.\n'));
+            console.log(chalk_1.default.gray('Make sure you copied the entire token from your dashboard.\n'));
+            return false;
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ ${error.message}\n`));
+        return false;
+    }
+}
+/**
+ * Ensure user is authenticated (prompt if not)
+ */
+async function ensureAuth() {
+    if (isAuthenticated()) {
+        return getAuthConfig();
+    }
+    const success = await promptAuth();
+    if (success) {
+        return getAuthConfig();
+    }
+    return null;
+}
+/**
+ * Get authentication token for API calls
+ */
+function getToken() {
+    const config = getAuthConfig();
+    return config?.token || null;
+}
+/**
+ * Logout command
+ */
+async function logout() {
+    if (!isAuthenticated()) {
+        console.log(chalk_1.default.gray('\n  Not currently logged in.\n'));
+        return;
+    }
+    const config = getAuthConfig();
+    console.log(chalk_1.default.yellow(`\n  Logging out ${config?.email}...\n`));
+    clearAuth();
+    console.log(chalk_1.default.green('  ✅ Logged out successfully!\n'));
+    console.log(chalk_1.default.gray('  Run "snapcommit" again to log back in.\n'));
+}

package/dist/lib/github.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentRepo = getCurrentRepo;
+exports.getCurrentBranch = getCurrentBranch;
+exports.createPullRequest = createPullRequest;
+exports.listPullRequests = listPullRequests;
+exports.getPullRequest = getPullRequest;
+exports.mergePullRequest = mergePullRequest;
+exports.getCommitStatus = getCommitStatus;
+exports.listWorkflowRuns = listWorkflowRuns;
+exports.triggerWorkflow = triggerWorkflow;
+exports.createIssue = createIssue;
+exports.listIssues = listIssues;
+exports.closeIssue = closeIssue;
+exports.createRelease = createRelease;
+exports.getRepoInfo = getRepoInfo;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+const GITHUB_API = 'https://api.github.com';
+if (!GITHUB_TOKEN) {
+    console.warn(chalk_1.default.yellow('⚠️  GitHub token not found. GitHub features will be disabled.'));
+}
+/**
+ * Get current repository info from git remote
+ */
+function getCurrentRepo() {
+    try {
+        const remote = (0, child_process_1.execSync)('git remote get-url origin', { encoding: 'utf-8' }).trim();
+        // Parse GitHub URL (supports both HTTPS and SSH)
+        let match;
+        if (remote.startsWith('https://')) {
+            // https://github.com/owner/repo.git
+            match = remote.match(/github\.com[/:]([\w-]+)\/([\w-]+?)(\.git)?$/);
+        }
+        else {
+            // git@github.com:owner/repo.git
+            match = remote.match(/github\.com[/:]([\w-]+)\/([\w-]+?)(\.git)?$/);
+        }
+        if (match) {
+            return {
+                owner: match[1],
+                name: match[2],
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Get current branch name
+ */
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+    }
+    catch (error) {
+        return 'main';
+    }
+}
+/**
+ * GitHub API request helper
+ */
+async function githubRequest(endpoint, options = {}) {
+    if (!GITHUB_TOKEN) {
+        throw new Error('GitHub token not configured. Please set GITHUB_TOKEN in your .env file.');
+    }
+    const url = `${GITHUB_API}${endpoint}`;
+    const headers = {
+        Authorization: `Bearer ${GITHUB_TOKEN}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        'Content-Type': 'application/json',
+        ...options.headers,
+    };
+    const response = await fetch(url, {
+        ...options,
+        headers,
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`GitHub API error: ${error.message || response.statusText}`);
+    }
+    return response.json();
+}
+/**
+ * Create a Pull Request
+ */
+async function createPullRequest(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    const currentBranch = options.head || getCurrentBranch();
+    const baseBranch = options.base || 'main';
+    // Get last commit message for default title
+    let defaultTitle = 'Update from ' + currentBranch;
+    try {
+        defaultTitle = (0, child_process_1.execSync)('git log -1 --pretty=%s', { encoding: 'utf-8' }).trim();
+    }
+    catch (error) {
+        // Use default
+    }
+    const title = options.title || defaultTitle;
+    const body = options.body || '';
+    const pr = await githubRequest(`/repos/${repo.owner}/${repo.name}/pulls`, {
+        method: 'POST',
+        body: JSON.stringify({
+            title,
+            body,
+            head: currentBranch,
+            base: baseBranch,
+        }),
+    });
+    return pr;
+}
+/**
+ * List Pull Requests
+ */
+async function listPullRequests(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    const state = options?.state || 'open';
+    const limit = options?.limit || 10;
+    const prs = await githubRequest(`/repos/${repo.owner}/${repo.name}/pulls?state=${state}&per_page=${limit}`);
+    return prs;
+}
+/**
+ * Get PR by number
+ */
+async function getPullRequest(prNumber) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}/pulls/${prNumber}`);
+}
+/**
+ * Merge a Pull Request
+ */
+async function mergePullRequest(prNumber, options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    const mergeMethod = options?.mergeMethod || 'merge';
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}/pulls/${prNumber}/merge`, {
+        method: 'PUT',
+        body: JSON.stringify({
+            merge_method: mergeMethod,
+            commit_title: options?.commitTitle,
+            commit_message: options?.commitMessage,
+        }),
+    });
+}
+/**
+ * Check CI/CD status for a commit or PR
+ */
+async function getCommitStatus(commitSha) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    // Get current commit SHA if not provided
+    const sha = commitSha || (0, child_process_1.execSync)('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+    const status = await githubRequest(`/repos/${repo.owner}/${repo.name}/commits/${sha}/status`);
+    const checks = await githubRequest(`/repos/${repo.owner}/${repo.name}/commits/${sha}/check-runs`);
+    return {
+        status,
+        checks: checks.check_runs || [],
+    };
+}
+/**
+ * List workflow runs
+ */
+async function listWorkflowRuns(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    const limit = options?.limit || 10;
+    const endpoint = options?.workflowId
+        ? `/repos/${repo.owner}/${repo.name}/actions/workflows/${options.workflowId}/runs?per_page=${limit}`
+        : `/repos/${repo.owner}/${repo.name}/actions/runs?per_page=${limit}`;
+    return await githubRequest(endpoint);
+}
+/**
+ * Trigger a workflow
+ */
+async function triggerWorkflow(workflowId, ref = 'main', inputs) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    await githubRequest(`/repos/${repo.owner}/${repo.name}/actions/workflows/${workflowId}/dispatches`, {
+        method: 'POST',
+        body: JSON.stringify({
+            ref,
+            inputs,
+        }),
+    });
+}
+/**
+ * Create an issue
+ */
+async function createIssue(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}/issues`, {
+        method: 'POST',
+        body: JSON.stringify(options),
+    });
+}
+/**
+ * List issues
+ */
+async function listIssues(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    const state = options?.state || 'open';
+    const limit = options?.limit || 10;
+    let endpoint = `/repos/${repo.owner}/${repo.name}/issues?state=${state}&per_page=${limit}`;
+    if (options?.labels && options.labels.length > 0) {
+        endpoint += `&labels=${options.labels.join(',')}`;
+    }
+    return await githubRequest(endpoint);
+}
+/**
+ * Close an issue
+ */
+async function closeIssue(issueNumber) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}/issues/${issueNumber}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ state: 'closed' }),
+    });
+}
+/**
+ * Create a release
+ */
+async function createRelease(options) {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}/releases`, {
+        method: 'POST',
+        body: JSON.stringify({
+            tag_name: options.tagName,
+            name: options.name || options.tagName,
+            body: options.body || '',
+            draft: options.draft || false,
+            prerelease: options.prerelease || false,
+        }),
+    });
+}
+/**
+ * Get repository info
+ */
+async function getRepoInfo() {
+    const repo = getCurrentRepo();
+    if (!repo) {
+        throw new Error('Not a GitHub repository');
+    }
+    return await githubRequest(`/repos/${repo.owner}/${repo.name}`);
+}