@gitset-dev/cli 1.0.0 → 1.2.0

package/README.md

@@ -1 +1,191 @@
-# gitset-cli
+<div align="center">
+    <img src="https://github.com/imprvhub/gitset/blob/main/public/favicon-192.png" alt="GitSet CLI" />
+    <br>
+    <a href="https://badge.fury.io/js/@gitset-dev%2Fcli">
+        <img src="https://img.shields.io/npm/v/@gitset-dev/cli?color=%237BFEF5" alt="npm version" />
+    </a>
+    <a href="https://opensource.org/licenses/MPL-2.0">
+        <img src="https://img.shields.io/badge/License-MPL_2.0-%237BFEF5" alt="License: MPL 2.0" />
+    </a>
+    <br>
+    <br>
+    <h3>
+        GitSet CLI - AI-Driven Commit Message Generation
+    </h3>
+</div>
+
+## Overview
+
+GitSet CLI is an integral component of the GitSet.dev ecosystem, designed to enhance Git workflow automation through AI-driven commit message generation. By leveraging Google's Gemini Pro AI technology, it provides intelligent analysis of staged changes to generate contextually appropriate commit messages, supporting both semantic and personalized formatting styles.
+
+## Key Capabilities
+
+The GitSet CLI enhances repository management through:
+
+- **AI-Powered Analysis**: Utilizes advanced AI processing to analyze staged changes and generate contextually appropriate commit messages
+- **Semantic Versioning Support**: Implements conventional commit standards for maintaining structured version control
+- **Style Adaptation**: Analyzes existing commit patterns to match personal or team commit message conventions
+- **Efficient Processing**: Provides rapid analysis and suggestion generation while maintaining minimal resource utilization
+- **Cross-Platform Architecture**: Ensures consistent operation across various operating systems and environments
+- **License Management**: Flexible licensing system with both free and pro tiers for different usage needs
+- **Usage Tracking**: Built-in monitoring of API usage and license status
+
+## System Requirements
+
+- Node.js Runtime Environment (Version 18.0.0 or higher)
+- Git (Installed and configured)
+- Active internet connection for AI processing
+
+## Installation Process
+
+Install the GitSet CLI globally via npm:
+
+```bash
+npm install -g @gitset-dev/cli
+```
+
+## Implementation Guide
+
+### Basic Usage
+
+1. Stage your modifications:
+```bash
+git add .
+```
+
+2. Generate commit message suggestions:
+```bash
+# Semantic versioning format (default)
+gitset suggest
+
+# Custom formatting style
+gitset suggest --mode custom
+```
+
+3. Implement the generated message:
+```bash
+git commit -m "generated_message"
+```
+
+### License Management
+
+Activate your GitSet license:
+```bash
+# Activate with license key
+gitset activate <license-key>
+
+# Check license status and usage
+gitset status
+
+# Remove current license
+gitset deactivate
+```
+
+### Operational Modes
+
+#### Semantic Mode (Default Implementation)
+Implements conventional commit standards to generate structured, semantic commit messages. This mode is optimized for maintaining consistent and professional Git history in enterprise environments.
+
+Example output:
+```bash
+$ gitset suggest
+✨ Generated Suggestion:
+------------------------
+feat: Implement JWT authentication system
+
+- Add token generation and validation mechanisms
+- Integrate login and registration endpoints
+- Configure route protection middleware
+```
+
+#### Custom Mode
+Analyzes existing commit patterns to generate messages that align with established conventions:
+
+- Evaluates recent commit history (default: 20 commits) for pattern recognition
+- Adapts to existing formatting conventions and structural patterns
+- Maintains sequential naming conventions if detected
+- Preserves emoji usage patterns and placement
+- Replicates capitalization and punctuation styles
+- Balances descriptive content with stylistic consistency
+
+Example of style adaptation:
+```bash
+# Given existing commit pattern:
+FEATURE_123: Enhanced login interface 🚀
+FEATURE_124: Updated navigation system ✨
+FEATURE_125: Resolved routing conflicts 🔧
+
+# Generated suggestion maintains consistency:
+FEATURE_126: Implemented user preferences 🎯
+```
+
+## Configuration Reference
+
+### Command Structure
+
+Available commands:
+- `gitset suggest` - Initiates commit message generation based on staged changes
+- `gitset activate` - Activates GitSet with a license key
+- `gitset status` - Checks current license status and usage
+- `gitset deactivate` - Removes current license configuration
+- `gitset help` - Displays detailed usage information
+
+### Available Parameters
+
+For suggest command:
+- `--mode <mode>` - Specifies generation mode ('semantic' or 'custom')
+- `--commit-count <count>` - Defines number of commits to analyze (default: 20)
+- `--version` - Displays CLI version information
+- `--help` - Provides command usage information
+
+## Plans and Pricing
+
+- **Basic (Free)**
+  - 10 requests per month
+  - Basic commit message generation
+  - Semantic and custom modes support
+
+- **Pro**
+  - Unlimited requests
+  - Advanced features and priority support
+  - Visit https://gitset.dev/pricing for details
+
+## Development Contribution
+
+We welcome contributions to enhance the GitSet CLI. Please follow these steps:
+
+1. Fork the repository
+2. Create a feature branch:
+   ```bash
+   git checkout -b feature/enhancement-description
+   ```
+3. Implement modifications:
+   ```bash
+   git commit -m 'feat: Add enhancement description'
+   ```
+4. Push changes:
+   ```bash
+   git push origin feature/enhancement-description
+   ```
+5. Submit a Pull Request
+
+## License Information
+
+This project operates under the Mozilla Public License 2.0 - refer to [LICENSE.md](LICENSE.md) for detailed terms.
+
+## Support Channels
+
+- Technical Support: support@gitset.dev
+- Contact Form: https://gitset.dev/contact
+- Issue Tracking: https://github.com/gitset-dev/gitset-cli/issues
+- Account Management: https://gitset.dev/account
+
+## Acknowledgments
+
+- Contributors who have helped improve this tool
+- Commander.js for CLI framework support
+- Google's Gemini Pro for AI capabilities
+
+---
+
+Part of the [GitSet.dev](https://gitset.dev) ecosystem - Smart AI Documentation & Version Control for GitHub Repositories.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitset-dev/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Generate semantic commit messages using AI-driven analysis of staged code changes.",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -1,11 +1,31 @@
-#!/usr/bin/env node 
+#!/usr/bin/env node
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import fetch from 'node-fetch';
 import { program } from 'commander';
 import path from 'path';
+import os from 'os';
+import fs from 'fs/promises';
+import crypto from 'crypto';
 
 const execAsync = promisify(exec);
+const API_URL = 'https://gitset-commit-messages.vercel.app';
+
+const CONFIG_LOCATIONS = {
+    global: {
+        dir: path.join(os.homedir(), '.config', 'gitset'),
+        file: 'credentials.json'
+    },
+    local: {
+        dir: path.join(process.cwd(), '.gitset'),
+        file: 'credentials.json'
+    },
+    system: {
+        darwin: path.join(os.homedir(), 'Library', 'Application Support', 'GitSet'),
+        win32: path.join(process.env.APPDATA || '', 'GitSet'),
+        linux: path.join(os.homedir(), '.local', 'share', 'gitset')
+    }
+};
 
 const colors = {
     reset: '\x1b[0m',
@@ -27,60 +47,115 @@ function log(step, message, isError = false) {
     console.log(`${prefix} ${colors.reset}[${timestamp}] ${stepColor}${step}${colors.reset}: ${message}`);
 }
 
-async function getGitDiff(file) {
+function getConfigPath() {
+    const localPath = path.join(CONFIG_LOCATIONS.local.dir, CONFIG_LOCATIONS.local.file);
     try {
-        log('Diff', `Getting differences for ${file}...`);
-        const { stdout: lastCommit } = await execAsync('git rev-parse HEAD');
-        
-        let previousContent = '';
-        try {
-            const { stdout } = await execAsync(`git show ${lastCommit.trim()}:${file}`);
-            const lineCount = stdout.split('\n').length;
-            if (lineCount > MAX_LINES) {
-                log('Diff', `Skipping ${file}: exceeds ${MAX_LINES} lines (has ${lineCount} lines)`, true);
-                return null;
-            }
-            previousContent = stdout;
-            log('Diff', `✓ Retrieved previous content (${stdout.length} bytes, ${lineCount} lines)`);
-        } catch (e) {
-            log('Diff', `New file detected: ${file}`);
+        if (fs.existsSync(localPath)) {
+            return localPath;
         }
+    } catch (error) {}
 
-        const { stdout: currentContent } = await execAsync(`git show :${file}`);
-        const currentLineCount = currentContent.split('\n').length;
-        if (currentLineCount > MAX_LINES) {
-            log('Diff', `Skipping ${file}: exceeds ${MAX_LINES} lines (has ${currentLineCount} lines)`, true);
-            return null;
+    const globalPath = path.join(CONFIG_LOCATIONS.global.dir, CONFIG_LOCATIONS.global.file);
+    try {
+        if (fs.existsSync(globalPath)) {
+            return globalPath;
         }
-        log('Diff', `✓ Retrieved current content (${currentContent.length} bytes, ${currentLineCount} lines)`);
+    } catch (error) {}
 
-        return {
-            previous: previousContent,
-            current: currentContent
-        };
+    const systemDir = CONFIG_LOCATIONS.system[process.platform] || CONFIG_LOCATIONS.system.linux;
+    return path.join(systemDir, CONFIG_LOCATIONS.local.file);
+}
+
+async function ensureConfigDir() {
+    const configPath = getConfigPath();
+    const configDir = path.dirname(configPath);
+    try {
+        await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
     } catch (error) {
-        log('Diff', `Error processing ${file}: ${error.message}`, true);
-        return null;
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
     }
+    return configPath;
 }
 
-async function getRepoInfo() {
+async function saveConfig(config) {
+    const configPath = await ensureConfigDir();
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+async function loadConfig() {
+    const storedConfig = {
+        licenseKey: null,
+        lastValidation: null,
+        installationId: null
+    };
+
     try {
-        log('Repo', 'Retrieving repository information...');
-        const { stdout: remoteUrl } = await execAsync('git config --get remote.origin.url');
-        const repoPath = remoteUrl.trim()
-            .replace('git@github.com:', '')
-            .replace('https://github.com/', '')
-            .replace('.git', '');
-        log('Repo', `✓ Repository identified: ${repoPath}`);
-        return repoPath;
+        const configPath = getConfigPath();
+        const configData = await fs.readFile(configPath, 'utf8');
+        const parsedConfig = JSON.parse(configData);
+
+        if (!parsedConfig.installationId) {
+            parsedConfig.installationId = crypto.randomUUID();
+            await saveConfig(parsedConfig);
+        }
+
+        return parsedConfig;
     } catch (error) {
-        log('Repo', `Error: ${error.message}`, true);
-        return '';
+        if (error.code === 'ENOENT') {
+
+            storedConfig.installationId = crypto.randomUUID();
+            await saveConfig(storedConfig);
+            return storedConfig;
+        }
+        throw error;
+    }
+}
+
+async function makeApiRequest(endpoint, data) {
+    const config = await loadConfig();
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+
+    if (config.licenseKey) {
+        headers['X-License-Key'] = config.licenseKey;
+    }
+
+    if (!config.installationId) {
+        config.installationId = crypto.randomUUID();
+        await saveConfig(config);
     }
+
+    headers['X-Installation-Id'] = config.installationId;
+    
+    const response = await fetch(`${API_URL}${endpoint}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(data)
+    });
+
+    if (!response.ok) {
+        const errorData = await response.json();
+        
+        if (response.status === 429 && errorData.status === 'quota_exceeded') {
+            log('Quota', 'Monthly request limit reached:', true);
+            log('Info', errorData.message);
+            log('Info', `Next reset date: ${new Date(errorData.next_reset_date).toLocaleDateString()}`);
+            log('Info', `Remaining days: ${errorData.days_until_reset}`);
+            log('Upgrade', 'To remove limits, activate a pro license:');
+            log('Command', '  gitset activate <license-key>');
+            log('Purchase', 'Visit https://gitset.dev/pricing to get a license');
+            process.exit(1);
+        }
+        
+        throw new Error(errorData.message || 'Failed to make request');
+    }
+
+    return response.json();
 }
 
-// Files that should typically be ignored
 const IGNORED_FILES = [
     'package-lock.json',
     'yarn.lock',
@@ -96,8 +171,6 @@ const IGNORED_FILES = [
     'coverage'
 ];
 
-const MAX_LINES = 3000;
-
 function shouldIgnoreFile(filePath) {
     return IGNORED_FILES.some(ignored => 
         filePath === ignored || 
@@ -108,9 +181,49 @@ function shouldIgnoreFile(filePath) {
     );
 }
 
+async function getLastCommits(count = 20) {
+    try {
+        log('History', `Fetching last ${count} commits...`);
+        const { stdout } = await execAsync(`git log -${count} --pretty=format:"%s"`);
+        const commits = stdout.split('\n');
+        log('History', `✓ Retrieved ${commits.length} commits`);
+        return commits;
+    } catch (error) {
+        log('History', `Error fetching commit history: ${error.message}`, true);
+        return [];
+    }
+}
+
+async function getGitDiff(file) {
+    try {
+        log('Diff', `Getting differences for ${file}...`);
+        const { stdout: lastCommit } = await execAsync('git rev-parse HEAD');
+        
+        let previousContent = '';
+        try {
+            const { stdout } = await execAsync(`git show ${lastCommit.trim()}:${file}`);
+            previousContent = stdout;
+            log('Diff', `✓ Retrieved previous content`);
+        } catch (e) {
+            log('Diff', `New file detected: ${file}`);
+        }
+
+        const { stdout: currentContent } = await execAsync(`git show :${file}`);
+        log('Diff', `✓ Retrieved current content`);
+
+        return {
+            previous: previousContent,
+            current: currentContent
+        };
+    } catch (error) {
+        log('Diff', `Error processing ${file}: ${error.message}`, true);
+        return null;
+    }
+}
+
 async function getStagedFiles() {
     try {
-        log('Git', 'Looking for staged files...');
+        log('Git', 'Retrieving staged files...');
         const { stdout } = await execAsync('git diff --cached --name-status');
         const files = stdout.split('\n')
             .filter(line => line)
@@ -129,9 +242,26 @@ async function getStagedFiles() {
     }
 }
 
-async function generateCommitMessage() {
+async function getRepoInfo() {
+    try {
+        log('Repo', 'Retrieving repository information...');
+        const { stdout: remoteUrl } = await execAsync('git config --get remote.origin.url');
+        const repoPath = remoteUrl.trim()
+            .replace('git@github.com:', '')
+            .replace('https://github.com/', '')
+            .replace('.git', '');
+        log('Repo', `✓ Repository identified: ${repoPath}`);
+        return repoPath;
+    } catch (error) {
+        log('Repo', `Error: ${error.message}`, true);
+        return '';
+    }
+}
+
+async function generateCommitMessage(options) {
     try {
         log('Start', 'Starting commit message generation process...');
+        const { mode = 'semantic', commitCount = 20 } = options;
 
         const files = await getStagedFiles();
         if (files.length === 0) {
@@ -149,71 +279,52 @@ async function generateCommitMessage() {
             console.log(`   ${statusText}${colors.reset}: ${file}`);
         });
 
-        const fileChanges = (await Promise.all(
-            files.map(async ({ status, file }) => {
-                const diffResult = await getGitDiff(file);
-                if (!diffResult) return null;
-                
-                const { previous, current } = diffResult;
-                const extension = path.extname(file).toLowerCase();
-
-                return {
-                    name: path.basename(file),
-                    path: file,
-                    changeType: status === 'A' ? 'added' : status === 'M' ? 'modified' : 'deleted',
-                    contentType: ['.jpg', '.png', '.gif', '.pdf'].includes(extension) ? 'binary' : 'text',
-                    changes: {
-                        before: previous,
-                        after: current
-                    }
-                };
-            })
-        )).filter(change => change !== null);
-
-        const repoName = await getRepoInfo();
-        log('API', 'Processing diffs with AI...');
-        log('NOTE', `The following commit message is a general reference and may not be fully accurate. If it doesn't meet your expectations, try again or suggest improvements here: https://gitset.dev/contact`)
-        const response = await fetch('https://gitset-commit-messages.vercel.app/generate-commit-message', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                repo_name: repoName,
-                file_changes: fileChanges
-            })
-        });
+        const fileChanges = [];
+        for (const { status, file } of files) {
+            const diffResult = await getGitDiff(file);
+            if (!diffResult) continue;
 
-        if (!response.ok) {
-            const errorData = await response.text();
-            let errorMessage;
-            
-            try {
-                const parsedError = JSON.parse(errorData);
-                if (response.status === 500 && parsedError.message?.includes('429')) {
-                    errorMessage = `${colors.yellow}The API rate limit has been reached. Please try again in a few minutes.${colors.reset}`;
-                } else {
-                    errorMessage = `Server error (${response.status}): ${parsedError.message || errorData}`;
+            fileChanges.push({
+                name: path.basename(file),
+                path: file,
+                changeType: status === 'A' ? 'added' : status === 'M' ? 'modified' : 'deleted',
+                contentType: 'text',
+                changes: {
+                    before: diffResult.previous,
+                    after: diffResult.current
                 }
-            } catch {
-                errorMessage = `Server error (${response.status}): ${errorData}`;
-            }
-            
-            throw new Error(errorMessage);
+            });
         }
 
-        const { commit_message } = await response.json();
+        const repoName = await getRepoInfo();
+        const commitHistory = mode === 'custom' ? await getLastCommits(parseInt(commitCount)) : [];
+        
+        log('API', `Processing diffs with AI using ${mode} mode...`);
+        
+        const response = await makeApiRequest('/generate-commit-message', {
+            repo_name: repoName,
+            file_changes: fileChanges,
+            mode: mode,
+            commit_history: commitHistory
+        });
+
         log('Success', '✨ Commit message generated\n');
+
         function formatCommitMessage(message) {
             const [title, ...descriptionParts] = message.split('\n');
             const description = descriptionParts.join('\n');
             return `${colors.bright}${colors.customCyan}${title}${colors.reset}${description ? `\n${colors.darkCyan}${description}${colors.reset}` : ''}`;
         }
 
-        console.log(`${colors.bright}📝 Suggested message:${colors.reset}`);
+        console.log(`${colors.bright}📝 Suggested message (${mode} mode):${colors.reset}`);
         console.log(`${colors.yellow}------------------${colors.reset}`);
-        console.log(formatCommitMessage(commit_message));
+        console.log(formatCommitMessage(response.commit_message));
 
     } catch (error) {
         log('Error', error.message, true);
+        if (error.message.includes('permission denied')) {
+            log('Help', 'Make sure you have the necessary permissions and are in a git repository.');
+        }
         process.exit(1);
     }
 }
@@ -221,11 +332,174 @@ async function generateCommitMessage() {
 program
     .name('gitset')
     .description('Smart AI Docs & Versioning for GitHub Repositories.')
-    .version('1.0.0');
+    .version('1.1.0');
 
 program
+    .command('activate')
+    .description('Activate GitSet with a license key')
+    .argument('[licenseKey]', 'Your GitSet license key')
+    .action(async (licenseKey) => {
+        try {
+            if (!licenseKey) {
+                const config = await loadConfig();
+                if (config.licenseKey) {
+                    log('License', 'Current license status:');
+                    const status = await makeApiRequest('/validate-license', { licenseKey: config.licenseKey });
+                    log('Status', `Plan: ${status.data.product_name}`);
+                    log('Status', `Valid until: ${new Date(status.data.renews_at).toLocaleDateString()}`);
+                } else {
+                    log('License', 'No license key configured', true);
+                    log('Info', 'You can use GitSet with limited features (10 requests/month)');
+                    log('Info', 'To unlock unlimited usage, activate a pro license:');
+                    log('Command', '  gitset activate <license-key>');
+                    log('Purchase', 'Visit https://gitset.dev/pricing to get a license');
+                }
+                return;
+            }
+
+            const response = await makeApiRequest('/validate-license', { licenseKey });
+            const config = await loadConfig();
+            await saveConfig({
+                ...config,  // Mantiene el installationId existente
+                licenseKey,
+                lastValidation: new Date().toISOString(),
+                subscriptionData: response.data
+            });
+            log('Success', '✨ License activated successfully!');
+            log('Plan', response.data.product_name);
+            log('Info', 'You now have unlimited access to all features');
+            
+        } catch (error) {
+            log('Error', error.message, true);
+            process.exit(1);
+        }
+    });
+
+    program
     .command('suggest')
-    .description('Generate semantic commit messages using AI-driven analysis of staged code changes.')
+    .description('Generate commit messages using AI-driven analysis of staged code changes.')
+    .option('-m, --mode <mode>', 'Commit message mode (semantic or custom)', 'semantic')
+    .option('-c, --commit-count <count>', 'Number of previous commits to analyze for custom mode', '20')
     .action(generateCommitMessage);
 
+program
+    .command('status')
+    .description('Check your GitSet license status and usage')
+    .action(async () => {
+        try {
+            const config = await loadConfig();
+            
+            if (!config.licenseKey) {
+                log('License', 'No license key configured');
+                log('Info', 'You are using GitSet with limited features (10 requests/month)');
+                log('Info', 'To unlock unlimited usage, activate a pro license:');
+                log('Command', '  gitset activate <license-key>');
+                log('Purchase', 'Visit https://gitset.dev/pricing to get a license');
+                return;
+            }
+
+            const response = await makeApiRequest('/validate-license', { licenseKey: config.licenseKey });
+            
+            log('License', 'License is active and valid ✨');
+            log('Plan', response.data.product_name);
+            log('Status', response.data.status);
+            if (response.data.renews_at) {
+                log('Renewal', `Next renewal: ${new Date(response.data.renews_at).toLocaleDateString()}`);
+            }
+
+            if (!response.data.product_name.toLowerCase().includes('pro')) {
+                log('Usage', 'Request limits (Basic Plan):');
+                const usageResponse = await makeApiRequest('/usage-info', { licenseKey: config.licenseKey });
+                log('Info', `Used ${usageResponse.current_usage} of ${usageResponse.limit} monthly requests`);
+                log('Info', `Reset date: ${new Date(usageResponse.next_reset_date).toLocaleDateString()}`);
+            } else {
+                log('Usage', 'Unlimited requests (Pro Plan)');
+            }
+            
+        } catch (error) {
+            log('Error', error.message, true);
+            if (error.message.includes('validation')) {
+                log('Help', 'Your license might have expired or been deactivated');
+                log('Info', 'You can check your subscription status at https://gitset.dev/account');
+            }
+        }
+    });
+
+program
+    .command('deactivate')
+    .description('Deactivate and remove current license key')
+    .action(async () => {
+        try {
+            const config = await loadConfig();
+            
+            if (!config.licenseKey) {
+                log('Info', 'No active license found');
+                return;
+            }
+
+            await saveConfig({
+                ...config,
+                licenseKey: null,
+                lastValidation: null,
+                subscriptionData: null,
+            });
+            log('Success', 'License deactivated successfully');
+            log('Info', 'Switched to basic plan (10 requests/month)');
+            log('Info', 'You can reactivate your license anytime with:');
+            log('Command', '  gitset activate <license-key>');
+            
+        } catch (error) {
+            log('Error', error.message, true);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('help')
+    .description('Show detailed help and usage information')
+    .action(() => {
+        console.log(`
+${colors.bright}GitSet CLI - Smart AI Commit Messages${colors.reset}
+
+${colors.cyan}Usage:${colors.reset}
+  gitset suggest              Generate a commit message for staged changes
+  gitset activate <key>       Activate GitSet with a license key
+  gitset status              Check license status and usage
+  gitset deactivate          Remove current license key
+  gitset help                Show this help message
+
+${colors.cyan}Options for 'suggest':${colors.reset}
+  -m, --mode <mode>         Commit message mode (semantic or custom)
+  -c, --commit-count <n>    Number of commits to analyze in custom mode
+
+${colors.cyan}Plans:${colors.reset}
+  Basic (Free)              10 requests per month
+  Pro                       Unlimited requests
+
+${colors.cyan}Examples:${colors.reset}
+  $ gitset suggest                    Generate semantic commit message
+  $ gitset suggest -m custom          Generate message matching your style
+  $ gitset activate ABC123...         Activate pro license
+  $ gitset status                     Check current license status
+
+${colors.cyan}Learn more:${colors.reset}
+  Visit https://gitset.dev for documentation and pricing
+  Report issues at https://github.com/gitset/cli/issues
+        `);
+    });
+
+program.exitOverride((err) => {
+    if (err.code === 'commander.help') {
+        process.exit(0);
+    }
+    
+    log('Error', err.message, true);
+    
+    if (err.code === 'commander.unknownCommand') {
+        log('Help', 'Run "gitset help" to see available commands');
+    }
+    
+    process.exit(1);
+});
+
 program.parse();