gent-cli 1.0.0 → 1.2.0

package/QUICKSTART.md

@@ -0,0 +1,198 @@
+# Quick Start Guide - Gent CLI
+
+## Installation & Setup
+
+```bash
+# Navigate to the CLI directory
+cd apps/Cli
+
+# Install dependencies
+npm install
+
+# Test the CLI
+node src/index.js --help
+```
+
+## Make it Globally Available (Optional)
+
+```bash
+# Link the CLI globally
+npm link
+
+# Now you can use 'gent' from anywhere
+gent --help
+```
+
+## Your First Repository
+
+### 1. Initialize
+```bash
+# Create a new directory
+mkdir my-project
+cd my-project
+
+# Initialize gent repository
+gent init
+```
+
+You'll be prompted for:
+- Your name
+- Your email
+- Repository name
+- Repository description
+
+Or skip prompts with `-y`:
+```bash
+gent init -y
+```
+
+### 2. Add Files
+```bash
+# Create some files
+echo "console.log('Hello');" > index.js
+
+# Add to staging area
+gent add index.js
+
+# Or add all files
+gent add .
+```
+
+### 3. Check Status
+```bash
+gent status
+```
+
+### 4. Commit Changes
+```bash
+# With message flag
+gent commit -m "Initial commit"
+
+# Or interactive
+gent commit
+```
+
+### 5. View History
+```bash
+# See all commits
+gent log
+
+# Compact view
+gent log --oneline
+
+# Limit commits shown
+gent log -n 5
+```
+
+## Working with Branches
+
+### Create a Branch
+```bash
+gent branch feature-name
+```
+
+### Switch to Branch
+```bash
+gent checkout feature-name
+```
+
+### Create and Switch
+```bash
+gent checkout -b new-feature
+```
+
+### List Branches
+```bash
+gent branch
+```
+
+### Delete Branch
+```bash
+gent branch -d old-feature
+```
+
+## Common Workflows
+
+### Feature Development
+```bash
+# Start a new feature
+gent checkout -b feature-login
+
+# Make changes
+echo "// Login code" > login.js
+gent add login.js
+gent commit -m "Add login feature"
+
+# View your work
+gent log
+
+# Switch back to main
+gent checkout main
+```
+
+### Quick Commit All
+```bash
+# Stage and commit all changes
+gent add .
+gent commit -m "Update all files"
+```
+
+### Check What Changed
+```bash
+# See status
+gent status
+
+# Short format
+gent status -s
+```
+
+## Tips & Tricks
+
+1. **Use .gentignore** - Exclude files like `node_modules/`
+2. **Commit Often** - Small commits are easier to track
+3. **Descriptive Messages** - Write clear commit messages
+4. **Branch for Features** - Keep main branch stable
+5. **Check Status** - Always review before committing
+
+## Running the Demo
+
+See the CLI in action:
+
+```bash
+chmod +x demo.sh
+./demo.sh
+```
+
+## Troubleshooting
+
+**Not a gent repository error?**
+```bash
+# Make sure you initialized
+gent init
+```
+
+**No changes to commit?**
+```bash
+# Add files first
+gent add <files>
+```
+
+**Command not found?**
+```bash
+# Use node directly
+node src/index.js <command>
+
+# Or link globally
+npm link
+```
+
+## Next Steps
+
+- Read the full [README.md](README.md)
+- Explore the [source code](src/)
+- Try the [demo script](demo.sh)
+- Build your own commands!
+
+---
+
+**Happy coding with Gent! 🚀**

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "gent-cli",
-  "version": "1.0.0",
-  "description": "A Git-like version control CLI tool",
+  "version": "1.2.0",
+  "description": "A Git-like version control CLI tool with cloud authentication",
   "main": "src/index.js",
   "bin": {
-    "gent": "./src/index.js"
+    "gent": "src/index.js"
   },
   "scripts": {
     "start": "node src/index.js",
     "test": "echo \"Error: no test specified\" && exit 1",
     "demo": "bash demo.sh",
     "link": "npm link",
-    "unlink": "npm unlink"
+    "unlink": "npm unlink",
+    "prepublishOnly": "echo 'Ready to publish gent-cli!'"
   },
   "keywords": [
     "cli",
     "version-control",
     "git-like",
-    "gent"
+    "gent",
+    "authentication",
+    "jwt",
+    "api",
+    "command-line",
+    "developer-tools"
   ],
   "author": "Abdalrahman Kanawati <kanawatiabdalrahman@gmail.com>",
   "license": "ISC",
@@ -30,14 +36,21 @@
     "url": "https://github.com/SaadShaya7/gent/issues"
   },
   "dependencies": {
-    "commander": "^11.1.0",
+    "axios": "^1.6.0",
+    "boxen": "^5.1.2",
     "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "crypto-js": "^4.2.0",
+    "date-fns": "^2.30.0",
     "inquirer": "^8.2.5",
-    "ora": "^5.4.1",
-    "boxen": "^5.1.2",
-    "date-fns": "^2.30.0"
+    "ora": "^5.4.1"
   },
   "engines": {
     "node": ">=14.0.0"
-  }
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "QUICKSTART.md"
+  ]
 }

package/src/commands/login.js

@@ -0,0 +1,85 @@
+/**
+ * Login Command - Authenticate user
+ * Handles user login with email and password
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const boxen = require('boxen');
+const authService = require('../services/auth-service');
+
+/**
+ * Login user
+ * @param {Object} options - Command options
+ */
+async function login(options) {
+    console.log(chalk.cyan('\n🔐 Login to your Gent account\n'));
+
+    try {
+        let email = options.email;
+        let password = options.password;
+
+        // If credentials not provided via flags, prompt for them
+        if (!email || !password) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'email',
+                    message: 'Email address:',
+                    when: !email,
+                    validate: (input) => {
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        return emailRegex.test(input) || 'Please enter a valid email address';
+                    }
+                },
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Password:',
+                    when: !password,
+                    mask: '*'
+                }
+            ]);
+
+            email = email || answers.email;
+            password = password || answers.password;
+        }
+
+        const spinner = ora('Logging in...').start();
+
+        // Login user
+        const user = await authService.login(email, password);
+
+        spinner.succeed(chalk.green('✓ Login successful!'));
+
+        // Display welcome message
+        const message = chalk.white(`
+${chalk.bold('Welcome back!')}
+
+${chalk.bold('Email:')} ${user.email}
+${chalk.bold('Name:')} ${user.first_name || ''} ${user.last_name || ''}
+
+${chalk.cyan('You are now logged in!')}
+
+${chalk.bold('Commands:')}
+  ${chalk.gray('•')} gent whoami         - View your profile
+  ${chalk.gray('•')} gent init           - Initialize a repository
+  ${chalk.gray('•')} gent help          - See all commands
+        `);
+
+        console.log(boxen(message, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        }));
+
+    } catch (error) {
+        console.error(chalk.red('\n✗ Login failed'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exit(1);
+    }
+}
+
+module.exports = login;

package/src/commands/logout.js

@@ -0,0 +1,40 @@
+/**
+ * Logout Command - End user session
+ * Handles user logout and clearing authentication data
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const authService = require('../services/auth-service');
+const authStorage = require('../utils/auth-storage');
+
+/**
+ * Logout user
+ * @param {Object} options - Command options
+ */
+async function logout(options) {
+    try {
+        // Check if user is authenticated
+        const isAuth = await authStorage.isAuthenticated();
+
+        if (!isAuth) {
+            console.log(chalk.yellow('\nℹ You are not logged in\n'));
+            return;
+        }
+
+        const spinner = ora('Logging out...').start();
+
+        // Logout user (calls API and clears local storage)
+        await authService.logout();
+
+        spinner.succeed(chalk.green('✓ Logged out successfully!'));
+        console.log(chalk.gray('Your session has been ended.\n'));
+
+    } catch (error) {
+        console.error(chalk.red('\n✗ Logout failed'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exit(1);
+    }
+}
+
+module.exports = logout;

package/src/commands/register.js

@@ -0,0 +1,109 @@
+/**
+ * Register Command - Create a new user account
+ * Handles user registration with email and password
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const boxen = require('boxen');
+const authService = require('../services/auth-service');
+
+/**
+ * Register a new user
+ * @param {Object} options - Command options
+ */
+async function register(options) {
+    console.log(chalk.cyan('\n🚀 Create your Gent account\n'));
+
+    try {
+        // Prompt for user information
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'email',
+                message: 'Email address:',
+                validate: (input) => {
+                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                    return emailRegex.test(input) || 'Please enter a valid email address';
+                }
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Password:',
+                mask: '*',
+                validate: (input) => {
+                    if (input.length < 8) {
+                        return 'Password must be at least 8 characters long';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'password',
+                name: 'passwordConfirm',
+                message: 'Confirm password:',
+                mask: '*',
+                validate: (input, answers) => {
+                    return input === answers.password || 'Passwords do not match';
+                }
+            },
+            {
+                type: 'input',
+                name: 'firstName',
+                message: 'First name:',
+                default: ''
+            },
+            {
+                type: 'input',
+                name: 'lastName',
+                message: 'Last name:',
+                default: ''
+            }
+        ]);
+
+        const spinner = ora('Creating your account...').start();
+
+        // Register user
+        const user = await authService.register(
+            answers.email,
+            answers.password,
+            answers.passwordConfirm,
+            answers.firstName,
+            answers.lastName
+        );
+
+        spinner.succeed(chalk.green('✓ Account created successfully!'));
+
+        // Display success message
+        const message = chalk.white(`
+${chalk.bold('Welcome to Gent!')}
+
+${chalk.bold('Email:')} ${user.email}
+${chalk.bold('Name:')} ${user.first_name || ''} ${user.last_name || ''}
+${chalk.bold('Account created:')} ${new Date(user.date_joined).toLocaleDateString()}
+
+${chalk.cyan('You are now logged in!')}
+
+${chalk.bold('Next steps:')}
+  ${chalk.gray('•')} gent init           - Initialize a repository
+  ${chalk.gray('•')} gent whoami         - View your profile
+  ${chalk.gray('•')} gent help          - See all commands
+        `);
+
+        console.log(boxen(message, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'green'
+        }));
+
+    } catch (error) {
+        console.error(chalk.red('\n✗ Registration failed'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+        process.exit(1);
+    }
+}
+
+module.exports = register;

package/src/commands/whoami.js

@@ -0,0 +1,69 @@
+/**
+ * Whoami Command - Display current user information
+ * Shows authenticated user profile
+ */
+
+const chalk = require('chalk');
+const boxen = require('boxen');
+const ora = require('ora');
+const { formatDistanceToNow } = require('date-fns');
+const authStorage = require('../utils/auth-storage');
+const authService = require('../services/auth-service');
+
+/**
+ * Display current user information
+ * @param {Object} options - Command options
+ */
+async function whoami(options) {
+    try {
+        // Check if user is authenticated
+        const isAuth = await authStorage.isAuthenticated();
+
+        if (!isAuth) {
+            console.log(chalk.yellow('\nℹ You are not logged in'));
+            console.log(chalk.gray('Use "gent login" or "gent register" to authenticate\n'));
+            return;
+        }
+
+        const spinner = ora('Fetching user profile...').start();
+
+        // Get user profile from API (this will also test token validity)
+        const user = await authService.getProfile();
+
+        spinner.stop();
+
+        // Format date
+        const joinedDate = new Date(user.date_joined);
+        const joinedAgo = formatDistanceToNow(joinedDate, { addSuffix: true });
+
+        // Display user information
+        const message = chalk.white(`
+${chalk.bold.cyan('👤 User Profile')}
+
+${chalk.bold('Email:')} ${user.email}
+${chalk.bold('Name:')} ${user.first_name || 'N/A'} ${user.last_name || ''}
+${chalk.bold('Account ID:')} ${user.id}
+${chalk.bold('Joined:')} ${joinedDate.toLocaleDateString()} ${chalk.gray(`(${joinedAgo})`)}
+${chalk.bold('Status:')} ${user.is_active ? chalk.green('Active') : chalk.red('Inactive')}
+        `);
+
+        console.log(boxen(message, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        }));
+
+    } catch (error) {
+        console.error(chalk.red('\n✗ Failed to fetch user profile'));
+        console.error(chalk.red(`Error: ${error.message}\n`));
+
+        if (error.message.includes('login')) {
+            console.log(chalk.gray('Use "gent login" to authenticate\n'));
+        }
+
+        process.exit(1);
+    }
+}
+
+module.exports = whoami;

package/src/index.js

@@ -21,6 +21,12 @@ const logCommand = require('./commands/log');
 const branchCommand = require('./commands/branch');
 const checkoutCommand = require('./commands/checkout');
 
+// Import auth commands
+const registerCommand = require('./commands/register');
+const loginCommand = require('./commands/login');
+const logoutCommand = require('./commands/logout');
+const whoamiCommand = require('./commands/whoami');
+
 // Configure CLI
 program
     .name('gent')
@@ -74,6 +80,29 @@ program
     .option('-b, --create', 'Create a new branch')
     .action(checkoutCommand);
 
+// Authentication commands
+program
+    .command('register')
+    .description('Create a new user account')
+    .action(registerCommand);
+
+program
+    .command('login')
+    .description('Login to your account')
+    .option('-e, --email <email>', 'Email address')
+    .option('-p, --password <password>', 'Password')
+    .action(loginCommand);
+
+program
+    .command('logout')
+    .description('Logout from your account')
+    .action(logoutCommand);
+
+program
+    .command('whoami')
+    .description('Display current user information')
+    .action(whoamiCommand);
+
 // Help command
 program
     .command('help [command]')

package/src/services/auth-service.js

@@ -0,0 +1,177 @@
+/**
+ * Auth Service - Authentication operations
+ * Handles registration, login, logout, and token management
+ */
+
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+const { API_ENDPOINTS } = require('../utils/constants');
+
+/**
+ * Register a new user
+ * @param {string} email - User email
+ * @param {string} password - User password
+ * @param {string} passwordConfirm - Password confirmation
+ * @param {string} firstName - User first name
+ * @param {string} lastName - User last name
+ * @returns {Promise<Object>} User data
+ */
+async function register(email, password, passwordConfirm, firstName, lastName) {
+    try {
+        const payload = {
+            email,
+            password,
+            password_confirm: passwordConfirm,
+            first_name: firstName,
+            last_name: lastName
+        };
+
+        const response = await apiClient.post(API_ENDPOINTS.REGISTER, payload);
+
+        // API returns { message, user: {...}, tokens: { access, refresh } }
+        const { tokens, user } = response;
+
+        // Store tokens
+        await authStorage.saveTokens(tokens.access, tokens.refresh, user);
+
+        return user;
+    } catch (error) {
+        if (error.response?.data) {
+            // Extract API error messages
+            const errors = error.response.data;
+            const errorMessages = [];
+
+            for (const [field, messages] of Object.entries(errors)) {
+                if (Array.isArray(messages)) {
+                    errorMessages.push(...messages);
+                } else {
+                    errorMessages.push(messages);
+                }
+            }
+
+            throw new Error(errorMessages.join(', '));
+        }
+
+        throw new Error(error.message || 'Registration failed');
+    }
+}
+
+/**
+ * Login user
+ * @param {string} email - User email
+ * @param {string} password - User password
+ * @returns {Promise<Object>} User data
+ */
+async function login(email, password) {
+    try {
+        const payload = { email, password };
+
+        const response = await apiClient.post(API_ENDPOINTS.LOGIN, payload);
+
+        // API returns { message, user: {...}, tokens: { access, refresh } }
+        const { tokens, user } = response;
+
+        // Store tokens
+        await authStorage.saveTokens(tokens.access, tokens.refresh, user);
+
+        return user;
+    } catch (error) {
+        if (error.response?.status === 401) {
+            throw new Error('Invalid email or password');
+        }
+
+        if (error.response?.data) {
+            const errors = error.response.data;
+            const errorMessages = [];
+
+            for (const [field, messages] of Object.entries(errors)) {
+                if (Array.isArray(messages)) {
+                    errorMessages.push(...messages);
+                } else {
+                    errorMessages.push(messages);
+                }
+            }
+
+            throw new Error(errorMessages.join(', '));
+        }
+
+        throw new Error(error.message || 'Login failed');
+    }
+}
+
+/**
+ * Logout user
+ * @returns {Promise<void>}
+ */
+async function logout() {
+    try {
+        const refreshToken = await authStorage.getRefreshToken();
+
+        if (refreshToken) {
+            // Call logout endpoint to blacklist refresh token
+            await apiClient.post(API_ENDPOINTS.LOGOUT, {
+                refresh: refreshToken
+            });
+        }
+    } catch (error) {
+        // Even if API call fails, clear local auth
+        console.error('Logout API call failed:', error.message);
+    } finally {
+        // Always clear local authentication
+        await authStorage.clearAuth();
+    }
+}
+
+/**
+ * Refresh access token
+ * @returns {Promise<string>} New access token
+ */
+async function refreshToken() {
+    try {
+        const refreshToken = await authStorage.getRefreshToken();
+
+        if (!refreshToken) {
+            throw new Error('No refresh token available');
+        }
+
+        const response = await apiClient.post(API_ENDPOINTS.REFRESH, {
+            refresh: refreshToken
+        });
+
+        const { access } = response;
+
+        // Update only access token
+        await authStorage.updateAccessToken(access);
+
+        return access;
+    } catch (error) {
+        // If refresh fails, clear auth
+        await authStorage.clearAuth();
+        throw new Error('Session expired. Please login again.');
+    }
+}
+
+/**
+ * Get current user profile
+ * @returns {Promise<Object>} User profile data
+ */
+async function getProfile() {
+    try {
+        const response = await apiClient.get(API_ENDPOINTS.PROFILE);
+        return response;
+    } catch (error) {
+        if (error.response?.status === 401) {
+            throw new Error('Not authenticated. Please login first.');
+        }
+
+        throw new Error(error.message || 'Failed to fetch profile');
+    }
+}
+
+module.exports = {
+    register,
+    login,
+    logout,
+    refreshToken,
+    getProfile
+};

package/src/utils/api-client.js

@@ -0,0 +1,179 @@
+/**
+ * API Client - HTTP client for making authenticated API requests
+ * Handles request/response interceptors and automatic token refresh
+ */
+
+const axios = require('axios');
+const { API_BASE_URL } = require('./constants');
+const authStorage = require('./auth-storage');
+
+// Create axios instance with base configuration
+const apiClient = axios.create({
+    baseURL: API_BASE_URL,
+    headers: {
+        'Content-Type': 'application/json'
+    },
+    timeout: 60000 // 60 seconds
+});
+
+// Track if we're currently refreshing token to avoid multiple refresh requests
+let isRefreshing = false;
+let failedRequestsQueue = [];
+
+/**
+ * Process queued requests after token refresh
+ * @param {Error|null} error - Error if refresh failed
+ * @param {string|null} token - New access token if refresh succeeded
+ */
+function processQueue(error, token = null) {
+    failedRequestsQueue.forEach(promise => {
+        if (error) {
+            promise.reject(error);
+        } else {
+            promise.resolve(token);
+        }
+    });
+
+    failedRequestsQueue = [];
+}
+
+// Request interceptor - Add JWT token to headers
+apiClient.interceptors.request.use(
+    async (config) => {
+        const token = await authStorage.getAccessToken();
+
+        if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+
+        return config;
+    },
+    (error) => {
+        return Promise.reject(error);
+    }
+);
+
+// Response interceptor - Handle 401 errors and refresh token
+apiClient.interceptors.response.use(
+    (response) => {
+        return response;
+    },
+    async (error) => {
+        const originalRequest = error.config;
+
+        // If error is 401 and we haven't tried to refresh yet
+        if (error.response?.status === 401 && !originalRequest._retry) {
+            if (isRefreshing) {
+                // If already refreshing, queue this request
+                return new Promise((resolve, reject) => {
+                    failedRequestsQueue.push({ resolve, reject });
+                })
+                    .then(token => {
+                        originalRequest.headers.Authorization = `Bearer ${token}`;
+                        return apiClient(originalRequest);
+                    })
+                    .catch(err => {
+                        return Promise.reject(err);
+                    });
+            }
+
+            originalRequest._retry = true;
+            isRefreshing = true;
+
+            try {
+                const refreshToken = await authStorage.getRefreshToken();
+
+                if (!refreshToken) {
+                    // No refresh token, user needs to login again
+                    await authStorage.clearAuth();
+                    throw new Error('Session expired. Please login again.');
+                }
+
+                // Call refresh endpoint
+                const response = await axios.post(
+                    `${API_BASE_URL}/api/auth/token/refresh/`,
+                    { refresh: refreshToken }
+                );
+
+                const { access } = response.data;
+
+                // Update stored access token
+                await authStorage.updateAccessToken(access);
+
+                // Update authorization header
+                originalRequest.headers.Authorization = `Bearer ${access}`;
+
+                // Process queued requests
+                processQueue(null, access);
+
+                isRefreshing = false;
+
+                // Retry original request
+                return apiClient(originalRequest);
+
+            } catch (refreshError) {
+                // Refresh failed, clear auth and reject
+                processQueue(refreshError, null);
+                isRefreshing = false;
+                await authStorage.clearAuth();
+                return Promise.reject(refreshError);
+            }
+        }
+
+        return Promise.reject(error);
+    }
+);
+
+/**
+ * Make GET request
+ * @param {string} url - Endpoint URL
+ * @param {Object} config - Axios config
+ * @returns {Promise} Response data
+ */
+async function get(url, config = {}) {
+    const response = await apiClient.get(url, config);
+    return response.data;
+}
+
+/**
+ * Make POST request
+ * @param {string} url - Endpoint URL
+ * @param {Object} data - Request payload
+ * @param {Object} config - Axios config
+ * @returns {Promise} Response data
+ */
+async function post(url, data = {}, config = {}) {
+    const response = await apiClient.post(url, data, config);
+    return response.data;
+}
+
+/**
+ * Make PUT request
+ * @param {string} url - Endpoint URL
+ * @param {Object} data - Request payload
+ * @param {Object} config - Axios config
+ * @returns {Promise} Response data
+ */
+async function put(url, data = {}, config = {}) {
+    const response = await apiClient.put(url, data, config);
+    return response.data;
+}
+
+/**
+ * Make DELETE request
+ * @param {string} url - Endpoint URL
+ * @param {Object} config - Axios config
+ * @returns {Promise} Response data
+ */
+async function del(url, config = {}) {
+    const response = await apiClient.delete(url, config);
+    return response.data;
+}
+
+module.exports = {
+    get,
+    post,
+    put,
+    delete: del,
+    apiClient // Export raw client if needed
+};

package/src/utils/auth-storage.js

@@ -0,0 +1,168 @@
+/**
+ * Auth Storage - Secure token and user data storage
+ * Handles encryption and persistence of authentication data
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const CryptoJS = require('crypto-js');
+const { GENT_DIR, AUTH_FILE } = require('./constants');
+
+// Simple encryption key (in production, use environment variable or OS keychain)
+const ENCRYPTION_KEY = 'gent-cli-secret-key-v1';
+
+/**
+ * Get the auth file path
+ * @returns {string} Path to auth.json file
+ */
+function getAuthFilePath() {
+    return path.join(process.cwd(), GENT_DIR, AUTH_FILE);
+}
+
+/**
+ * Encrypt data
+ * @param {Object} data - Data to encrypt
+ * @returns {string} Encrypted string
+ */
+function encrypt(data) {
+    const jsonString = JSON.stringify(data);
+    return CryptoJS.AES.encrypt(jsonString, ENCRYPTION_KEY).toString();
+}
+
+/**
+ * Decrypt data
+ * @param {string} encryptedData - Encrypted string
+ * @returns {Object} Decrypted data
+ */
+function decrypt(encryptedData) {
+    const bytes = CryptoJS.AES.decrypt(encryptedData, ENCRYPTION_KEY);
+    const decryptedString = bytes.toString(CryptoJS.enc.Utf8);
+    return JSON.parse(decryptedString);
+}
+
+/**
+ * Save authentication tokens and user data
+ * @param {string} accessToken - JWT access token
+ * @param {string} refreshToken - JWT refresh token
+ * @param {Object} user - User profile data
+ */
+async function saveTokens(accessToken, refreshToken, user) {
+    const authFilePath = getAuthFilePath();
+    const gentDir = path.join(process.cwd(), GENT_DIR);
+
+    const authData = {
+        accessToken,
+        refreshToken,
+        user,
+        timestamp: new Date().toISOString()
+    };
+
+    const encryptedData = encrypt(authData);
+
+    try {
+        // Ensure .gent directory exists
+        await fs.mkdir(gentDir, { recursive: true });
+        await fs.writeFile(authFilePath, JSON.stringify({ data: encryptedData }), 'utf8');
+    } catch (error) {
+        throw new Error(`Failed to save authentication data: ${error.message}`);
+    }
+}
+
+/**
+ * Read authentication data from file
+ * @returns {Object|null} Decrypted auth data or null if not found
+ */
+async function readAuthData() {
+    const authFilePath = getAuthFilePath();
+
+    try {
+        const fileContent = await fs.readFile(authFilePath, 'utf8');
+        const { data } = JSON.parse(fileContent);
+        return decrypt(data);
+    } catch (error) {
+        // File doesn't exist or is corrupted
+        return null;
+    }
+}
+
+/**
+ * Get access token
+ * @returns {string|null} Access token or null
+ */
+async function getAccessToken() {
+    const authData = await readAuthData();
+    return authData ? authData.accessToken : null;
+}
+
+/**
+ * Get refresh token
+ * @returns {string|null} Refresh token or null
+ */
+async function getRefreshToken() {
+    const authData = await readAuthData();
+    return authData ? authData.refreshToken : null;
+}
+
+/**
+ * Get user profile
+ * @returns {Object|null} User data or null
+ */
+async function getUser() {
+    const authData = await readAuthData();
+    return authData ? authData.user : null;
+}
+
+/**
+ * Check if user is authenticated
+ * @returns {boolean} True if authenticated
+ */
+async function isAuthenticated() {
+    const authData = await readAuthData();
+    return authData !== null && authData.accessToken !== null;
+}
+
+/**
+ * Clear authentication data
+ */
+async function clearAuth() {
+    const authFilePath = getAuthFilePath();
+
+    try {
+        await fs.unlink(authFilePath);
+    } catch (error) {
+        // File doesn't exist, nothing to clear
+    }
+}
+
+/**
+ * Update only the access token (used after refresh)
+ * @param {string} newAccessToken - New access token
+ */
+async function updateAccessToken(newAccessToken) {
+    const authData = await readAuthData();
+
+    if (!authData) {
+        throw new Error('No authentication data found');
+    }
+
+    authData.accessToken = newAccessToken;
+    authData.timestamp = new Date().toISOString();
+
+    const authFilePath = getAuthFilePath();
+    const gentDir = path.join(process.cwd(), GENT_DIR);
+    const encryptedData = encrypt(authData);
+
+    // Ensure .gent directory exists
+    await fs.mkdir(gentDir, { recursive: true });
+    await fs.writeFile(authFilePath, JSON.stringify({ data: encryptedData }), 'utf8');
+}
+
+module.exports = {
+    saveTokens,
+    getAccessToken,
+    getRefreshToken,
+    getUser,
+    isAuthenticated,
+    clearAuth,
+    updateAccessToken
+};

package/src/utils/constants.js

@@ -10,6 +10,17 @@ module.exports = {
     STAGING_FILE: 'staging.json',
     COMMITS_FILE: 'commits.json',
     HEAD_FILE: 'HEAD',
+    AUTH_FILE: 'auth.json',
+
+    // API Configuration
+    API_BASE_URL: 'https://gent-api.onrender.com',
+    API_ENDPOINTS: {
+        LOGIN: '/api/auth/login/',
+        REGISTER: '/api/auth/register/',
+        LOGOUT: '/api/auth/logout/',
+        REFRESH: '/api/auth/token/refresh/',
+        PROFILE: '/api/auth/profile/'
+    },
 
     // Default ignore patterns
     DEFAULT_IGNORE_PATTERNS: [

package/commands-reference.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Gent CLI - Command Summary
- * Quick reference for all available commands
- */
-
-const chalk = require('chalk');
-const boxen = require('boxen');
-
-const commands = [
-    {
-        name: 'init',
-        description: 'Initialize a new gent repository',
-        usage: 'gent init [options]',
-        options: ['-y, --yes  Skip prompts and use defaults'],
-        examples: ['gent init', 'gent init -y']
-    },
-    {
-        name: 'status',
-        description: 'Show the working tree status',
-        usage: 'gent status [options]',
-        options: ['-s, --short  Give output in short format'],
-        examples: ['gent status', 'gent status -s']
-    },
-    {
-        name: 'add',
-        description: 'Add file contents to the staging area',
-        usage: 'gent add <files...> [options]',
-        options: ['-A, --all  Add all files'],
-        examples: ['gent add file.js', 'gent add .', 'gent add --all']
-    },
-    {
-        name: 'commit',
-        description: 'Record changes to the repository',
-        usage: 'gent commit [options]',
-        options: [
-            '-m, --message <message>  Commit message',
-            '-a, --all               Auto stage modified files'
-        ],
-        examples: ['gent commit -m "Fix bug"', 'gent commit', 'gent commit -a -m "Update all"']
-    },
-    {
-        name: 'log',
-        description: 'Show commit logs',
-        usage: 'gent log [options]',
-        options: [
-            '-n, --number <count>  Limit commits (default: 10)',
-            '--oneline             Show each commit on one line'
-        ],
-        examples: ['gent log', 'gent log -n 5', 'gent log --oneline']
-    },
-    {
-        name: 'branch',
-        description: 'List, create, or delete branches',
-        usage: 'gent branch [name] [options]',
-        options: [
-            '-d, --delete <name>  Delete a branch',
-            '-a, --all            List all branches'
-        ],
-        examples: ['gent branch', 'gent branch feature-x', 'gent branch -d old-feature']
-    },
-    {
-        name: 'checkout',
-        description: 'Switch branches',
-        usage: 'gent checkout <branch> [options]',
-        options: ['-b, --create  Create a new branch'],
-        examples: ['gent checkout main', 'gent checkout -b new-feature']
-    }
-];
-
-console.log(chalk.bold.cyan('\n🚀 Gent CLI - Command Reference\n'));
-
-commands.forEach((cmd, index) => {
-    console.log(chalk.yellow.bold(`${index + 1}. ${cmd.name.toUpperCase()}`));
-    console.log(chalk.white(`   ${cmd.description}`));
-    console.log(chalk.gray(`   Usage: ${cmd.usage}`));
-
-    if (cmd.options.length > 0) {
-        console.log(chalk.gray('   Options:'));
-        cmd.options.forEach(opt => {
-            console.log(chalk.gray(`     ${opt}`));
-        });
-    }
-
-    console.log(chalk.cyan('   Examples:'));
-    cmd.examples.forEach(ex => {
-        console.log(chalk.green(`     $ ${ex}`));
-    });
-
-    console.log();
-});
-
-const tips = `
-${chalk.bold('💡 Quick Tips:')}
-
-${chalk.cyan('•')} Always run ${chalk.yellow('gent init')} first in a new project
-${chalk.cyan('•')} Use ${chalk.yellow('gent status')} to see what changed
-${chalk.cyan('•')} Stage files with ${chalk.yellow('gent add')} before committing
-${chalk.cyan('•')} Create branches for new features
-${chalk.cyan('•')} Check ${chalk.yellow('gent log')} to view history
-
-${chalk.bold('📚 Documentation:')}
-${chalk.gray('• README.md     - Complete documentation')}
-${chalk.gray('• QUICKSTART.md - Quick start guide')}
-${chalk.gray('• demo.sh       - Interactive demo')}
-`;
-
-console.log(boxen(tips, {
-    padding: 1,
-    margin: 1,
-    borderStyle: 'round',
-    borderColor: 'cyan'
-}));
-
-console.log(chalk.gray('Run'), chalk.yellow('gent --help'), chalk.gray('for more information\n'));