gent-cli 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A Git-like version control CLI tool with cloud authentication",
   "main": "src/index.js",
   "bin": {

package/src/commands/commit.js

@@ -8,6 +8,7 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const ora = require('ora');
 const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const authStorage = require('../utils/auth-storage');
 const { STAGING_FILE, COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
 const { generateCommitHash, getFileHash } = require('../utils/helpers');
 
@@ -49,17 +50,41 @@ async function commit(options) {
 
         const spinner = ora('Creating commit...').start();
 
-        // Read config and repository
         const config = await readJSON(path.join(gentPath, CONFIG_FILE));
         const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
 
+        // Resolve author identity
+        let authorName = config.user.name;
+        let authorEmail = config.user.email;
+
+        // Fallback to global auth if local config is empty
+        if (!authorName || !authorEmail) {
+            const globalUser = await authStorage.getUser();
+            if (globalUser) {
+                if (!authorName) {
+                    authorName = [globalUser.first_name, globalUser.last_name].filter(Boolean).join(' ');
+                }
+                if (!authorEmail) {
+                    authorEmail = globalUser.email;
+                }
+            }
+        }
+
+        // Fail if still no identity
+        if (!authorName || !authorEmail) {
+            spinner.stop();
+            console.error(chalk.red('Author identity unknown'));
+            console.log(chalk.yellow('Please run "gent login" to set your identity globally'));
+            return;
+        }
+
         // Create commit object
         const commit = {
             hash: generateCommitHash(),
             message: message,
             author: {
-                name: config.user.name,
-                email: config.user.email
+                name: authorName,
+                email: authorEmail
             },
             timestamp: new Date().toISOString(),
             parent: repository.branches[repository.currentBranch] || null,

package/src/commands/init.js

@@ -6,10 +6,8 @@
 const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
-const inquirer = require('inquirer');
-const ora = require('ora');
-const boxen = require('boxen');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
+const authStorage = require('../utils/auth-storage');
 const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
 
 /**
@@ -17,8 +15,6 @@ const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/
  * @param {Object} options - Command options
  */
 async function init(options) {
-    const spinner = ora('Initializing gent repository...').start();
-
     try {
         const cwd = process.cwd();
         const gentPath = path.join(cwd, GENT_DIR);
@@ -26,28 +22,31 @@ async function init(options) {
 
         // Check if already initialized
         if (await pathExists(gentPath)) {
-            spinner.stop();
-            const { reinitialize } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'reinitialize',
-                    message: 'Gent repository already exists. Re-initialize? (This preserves your history)',
-                    default: true
-                }
-            ]);
+            isReinit = true;
+        }
+
+        // Get authenticated user profile if available
+        let defaultName = '';
+        let defaultEmail = '';
 
-            if (!reinitialize) {
-                console.log(chalk.yellow('\nℹ Use gent status to see the current state'));
-                return;
+        try {
+            const user = await authStorage.getUser();
+            if (user) {
+                if (user.first_name || user.last_name) {
+                    defaultName = [user.first_name, user.last_name].filter(Boolean).join(' ');
+                }
+                if (user.email) {
+                    defaultEmail = user.email;
+                }
             }
-            isReinit = true;
+        } catch (error) {
+            // Ignore auth errors
         }
 
-        // Get user configuration if not using defaults
         let config = {
             user: {
-                name: 'Anonymous',
-                email: 'anonymous@example.com'
+                name: defaultName,
+                email: defaultEmail
             },
             repository: {
                 name: path.basename(cwd),
@@ -56,48 +55,6 @@ async function init(options) {
             }
         };
 
-        if (!options.yes) {
-            spinner.stop(); // Ensure spinner is stopped before prompt
-
-            const answers = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'userName',
-                    message: 'Enter your name:',
-                    default: 'Anonymous'
-                },
-                {
-                    type: 'input',
-                    name: 'userEmail',
-                    message: 'Enter your email:',
-                    default: 'anonymous@example.com',
-                    validate: (input) => {
-                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-                        return emailRegex.test(input) || 'Please enter a valid email';
-                    }
-                },
-                {
-                    type: 'input',
-                    name: 'repoName',
-                    message: 'Repository name:',
-                    default: path.basename(cwd)
-                },
-                {
-                    type: 'input',
-                    name: 'repoDescription',
-                    message: 'Repository description:',
-                    default: 'A gent repository'
-                }
-            ]);
-
-            config.user.name = answers.userName;
-            config.user.email = answers.userEmail;
-            config.repository.name = answers.repoName;
-            config.repository.description = answers.repoDescription;
-
-            spinner.start(isReinit ? 'Re-initializing repository...' : 'Creating repository structure...');
-        }
-
         // Create directory structure
         await ensureDir(gentPath);
         await ensureDir(path.join(gentPath, 'objects'));
@@ -105,28 +62,37 @@ async function init(options) {
         await ensureDir(path.join(gentPath, 'refs', 'tags'));
 
         // Create/Update configuration
-        await writeJSON(path.join(gentPath, CONFIG_FILE), config);
+        // Only write config if it doesn't exist OR if we have valid user info to update
+        const configPath = path.join(gentPath, CONFIG_FILE);
+        if (!(await pathExists(configPath)) || (defaultName && defaultEmail)) {
+            // If re-init, we might want to preserve existing config unless we have better info?
+            // Git re-init doesn't overwrite config usually.
+            // But for now, let's write ensuring we have a config file.
+            if (!isReinit || !(await pathExists(configPath))) {
+                await writeJSON(configPath, config);
+            }
+        }
 
-        // Create initial files only if they don't exist (preserve history on re-init)
+        // Create initial files only if they don't exist
         const stagingPath = path.join(gentPath, STAGING_FILE);
-        if (!isReinit || !(await pathExists(stagingPath))) {
+        if (!(await pathExists(stagingPath))) {
             await writeJSON(stagingPath, { files: [] });
         }
 
         const commitsPath = path.join(gentPath, COMMITS_FILE);
-        if (!isReinit || !(await pathExists(commitsPath))) {
+        if (!(await pathExists(commitsPath))) {
             await writeJSON(commitsPath, { commits: [], branches: { main: null }, currentBranch: 'main' });
         }
 
         // Create HEAD file only if it doesn't exist
         const headPath = path.join(gentPath, 'HEAD');
-        if (!isReinit || !(await pathExists(headPath))) {
+        if (!(await pathExists(headPath))) {
             await fs.writeFile(headPath, 'ref: refs/heads/main\n');
         }
 
         // Create .gentignore only if it doesn't exist
         const ignorePath = path.join(cwd, '.gentignore');
-        if (!isReinit || !(await pathExists(ignorePath))) {
+        if (!(await pathExists(ignorePath))) {
             const gentignore = `# Gent ignore patterns
 node_modules/
 .DS_Store
@@ -138,33 +104,14 @@ node_modules/
         }
 
         if (isReinit) {
-            spinner.succeed(chalk.green('✓ Gent repository re-initialized successfully!'));
+            console.log(chalk.gray(`Reinitialized existing Gent repository in ${gentPath}`));
         } else {
-            spinner.succeed(chalk.green('✓ Gent repository initialized successfully!'));
+            console.log(chalk.gray(`Initialized empty Gent repository in ${gentPath}`));
         }
 
-        // Display success message
-        const message = chalk.white(`
-${chalk.bold('Repository:')} ${config.repository.name}
-${chalk.bold('User:')} ${config.user.name} <${config.user.email}>
-${chalk.bold('Branch:')} main
-
-${chalk.cyan('Next steps:')}
-  ${chalk.gray('•')} gent add <files>     - Add files to staging
-  ${chalk.gray('•')} gent commit          - Commit your changes
-  ${chalk.gray('•')} gent status          - View repository status
-    `);
-
-        console.log(boxen(message, {
-            padding: 1,
-            margin: 1,
-            borderStyle: 'round',
-            borderColor: 'cyan'
-        }));
-
     } catch (error) {
-        spinner.fail(chalk.red('Failed to initialize repository'));
-        console.error(chalk.red('\nError:'), error.message);
+        console.error(chalk.red('Failed to initialize repository'));
+        console.error(chalk.red('Error:'), error.message);
         process.exit(1);
     }
 }

package/src/utils/auth-storage.js

@@ -5,6 +5,7 @@
 
 const fs = require('fs').promises;
 const path = require('path');
+const os = require('os');
 const CryptoJS = require('crypto-js');
 const { GENT_DIR, AUTH_FILE } = require('./constants');
 
@@ -16,7 +17,7 @@ const ENCRYPTION_KEY = 'gent-cli-secret-key-v1';
  * @returns {string} Path to auth.json file
  */
 function getAuthFilePath() {
-    return path.join(process.cwd(), GENT_DIR, AUTH_FILE);
+    return path.join(os.homedir(), GENT_DIR, AUTH_FILE);
 }
 
 /**
@@ -48,7 +49,7 @@ function decrypt(encryptedData) {
  */
 async function saveTokens(accessToken, refreshToken, user) {
     const authFilePath = getAuthFilePath();
-    const gentDir = path.join(process.cwd(), GENT_DIR);
+    const gentDir = path.join(os.homedir(), GENT_DIR);
 
     const authData = {
         accessToken,
@@ -149,7 +150,7 @@ async function updateAccessToken(newAccessToken) {
     authData.timestamp = new Date().toISOString();
 
     const authFilePath = getAuthFilePath();
-    const gentDir = path.join(process.cwd(), GENT_DIR);
+    const gentDir = path.join(os.homedir(), GENT_DIR);
     const encryptedData = encrypt(authData);
 
     // Ensure .gent directory exists