gent-cli 1.6.0 → 1.8.0

package/src/services/repo-service.js

@@ -0,0 +1,283 @@
+/**
+ * Repository Service - Handles all cloud repository operations
+ * Provides methods for creating, managing, and syncing repositories with the cloud
+ */
+
+const apiClient = require('../utils/api-client');
+const { API_ENDPOINTS } = require('../utils/constants');
+
+/**
+ * Build URL with path parameters
+ * @param {string} template - URL template with placeholders
+ * @param {Object} params - Parameters to replace
+ * @returns {string} Built URL
+ */
+function buildUrl(template, params = {}) {
+    let url = template;
+    Object.keys(params).forEach(key => {
+        url = url.replace(`{${key}}`, params[key]);
+    });
+    return url;
+}
+
+/**
+ * Create a new repository
+ * @param {string} name - Repository name
+ * @param {string} description - Repository description
+ * @param {boolean} isPrivate - Whether the repository is private
+ * @param {string} defaultBranch - Default branch name
+ * @returns {Promise<Object>} Created repository data
+ */
+async function createRepository(name, description = '', isPrivate = false, defaultBranch = 'main') {
+    try {
+        const response = await apiClient.post(API_ENDPOINTS.REPOS_CREATE, {
+            name,
+            description,
+            is_private: isPrivate,
+            default_branch: defaultBranch
+        });
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to create repository: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * List all repositories owned by the authenticated user
+ * @returns {Promise<Array>} List of repositories
+ */
+async function listRepositories() {
+    try {
+        const response = await apiClient.get(API_ENDPOINTS.REPOS_LIST);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to list repositories: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Get repository details
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Object>} Repository data
+ */
+async function getRepository(ownerId, repoName) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.REPOS_GET, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to get repository: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Delete a repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Object>} Delete response
+ */
+async function deleteRepository(ownerId, repoName) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.REPOS_DELETE, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.delete(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to delete repository: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Create a blob (file content) in the repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} content - File content
+ * @param {string} encoding - Encoding type (utf-8 or base64)
+ * @returns {Promise<Object>} Created blob data
+ */
+async function createBlob(ownerId, repoName, content, encoding = 'utf-8') {
+    try {
+        const url = buildUrl(API_ENDPOINTS.BLOB_CREATE, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.post(url, {
+            content,
+            encoding
+        });
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to create blob: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Get a blob by SHA
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} sha - Blob SHA
+ * @returns {Promise<Object>} Blob data
+ */
+async function getBlob(ownerId, repoName, sha) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.BLOB_GET, { owner_id: ownerId, repo_name: repoName, sha });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to get blob: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Create a tree (directory structure) in the repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {Array} entries - Tree entries
+ * @returns {Promise<Object>} Created tree data
+ */
+async function createTree(ownerId, repoName, entries) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.TREE_CREATE, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.post(url, {
+            entries
+        });
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to create tree: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Get a tree by SHA
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} sha - Tree SHA
+ * @returns {Promise<Object>} Tree data
+ */
+async function getTree(ownerId, repoName, sha) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.TREE_GET, { owner_id: ownerId, repo_name: repoName, sha });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to get tree: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Create a commit in the repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {Object} commitData - Commit data (message, tree_sha, parent_shas, author_name, author_email, branch)
+ * @returns {Promise<Object>} Created commit data
+ */
+async function createCommit(ownerId, repoName, commitData) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.COMMITS_CREATE, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.post(url, commitData);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to create commit: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * List all commits in a repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Array>} List of commits
+ */
+async function listCommits(ownerId, repoName) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.COMMITS_LIST, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to list commits: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Get a commit by SHA
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} sha - Commit SHA
+ * @returns {Promise<Object>} Commit data
+ */
+async function getCommit(ownerId, repoName, sha) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.COMMITS_GET, { owner_id: ownerId, repo_name: repoName, sha });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to get commit: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Create a branch in the repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} branchName - Branch name
+ * @param {string} commitSha - Commit SHA to point the branch to
+ * @returns {Promise<Object>} Created branch data
+ */
+async function createBranch(ownerId, repoName, branchName, commitSha) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.BRANCHES_CREATE, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.post(url, {
+            name: branchName,
+            commit_sha: commitSha
+        });
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to create branch: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * List all branches in a repository
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Array>} List of branches
+ */
+async function listBranches(ownerId, repoName) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.BRANCHES_LIST, { owner_id: ownerId, repo_name: repoName });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to list branches: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+/**
+ * Get a branch by name
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} branchName - Branch name
+ * @returns {Promise<Object>} Branch data
+ */
+async function getBranch(ownerId, repoName, branchName) {
+    try {
+        const url = buildUrl(API_ENDPOINTS.BRANCHES_GET, { owner_id: ownerId, repo_name: repoName, branch_name: branchName });
+        const response = await apiClient.get(url);
+        return response;
+    } catch (error) {
+        throw new Error(`Failed to get branch: ${error.response?.data?.message || error.message}`);
+    }
+}
+
+module.exports = {
+    createRepository,
+    listRepositories,
+    getRepository,
+    deleteRepository,
+    createBlob,
+    getBlob,
+    createTree,
+    getTree,
+    createCommit,
+    listCommits,
+    getCommit,
+    createBranch,
+    listBranches,
+    getBranch
+};

package/src/utils/cloud-sync.js

@@ -0,0 +1,322 @@
+/**
+ * Cloud Sync Utilities - Handles synchronization between local and cloud repositories
+ * Provides functions for uploading and downloading commits, blobs, and trees
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const repoService = require('../services/repo-service');
+const { GENT_DIR, OBJECTS_DIR } = require('./constants');
+const { readJSON, writeJSON, pathExists } = require('./fileSystem');
+
+/**
+ * Upload blobs (file contents) to cloud
+ * @param {Array} files - Array of file objects with path and content
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Object>} Map of file paths to blob SHAs
+ */
+async function uploadBlobs(files, ownerId, repoName) {
+    const spinner = ora('Uploading file contents...').start();
+    const blobMap = {};
+
+    try {
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            spinner.text = `Uploading ${file.path} (${i + 1}/${files.length})`;
+
+            const blob = await repoService.createBlob(
+                ownerId,
+                repoName,
+                file.content,
+                'utf-8'
+            );
+
+            blobMap[file.path] = blob.sha;
+        }
+
+        spinner.succeed(`Uploaded ${files.length} file(s)`);
+        return blobMap;
+    } catch (error) {
+        spinner.fail('Failed to upload files');
+        throw error;
+    }
+}
+
+/**
+ * Download blobs from cloud
+ * @param {Array} shas - Array of blob SHAs to download
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Object>} Map of SHAs to content
+ */
+async function downloadBlobs(shas, ownerId, repoName) {
+    const spinner = ora('Downloading file contents...').start();
+    const blobMap = {};
+
+    try {
+        for (let i = 0; i < shas.length; i++) {
+            const sha = shas[i];
+            spinner.text = `Downloading blob ${sha.substring(0, 7)} (${i + 1}/${shas.length})`;
+
+            const blob = await repoService.getBlob(ownerId, repoName, sha);
+            blobMap[sha] = blob.content;
+        }
+
+        spinner.succeed(`Downloaded ${shas.length} blob(s)`);
+        return blobMap;
+    } catch (error) {
+        spinner.fail('Failed to download blobs');
+        throw error;
+    }
+}
+
+/**
+ * Build tree structure from file list
+ * @param {Array} files - Array of file objects with path and SHA
+ * @returns {Array} Tree entries
+ */
+function buildTreeEntries(files) {
+    return files.map(file => ({
+        path: file.path,
+        mode: '100644', // Regular file
+        type: 'blob',
+        sha: file.sha
+    }));
+}
+
+/**
+ * Upload a tree structure to cloud
+ * @param {Array} files - Array of file objects with path and SHA
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @returns {Promise<Object>} Created tree data
+ */
+async function uploadTree(files, ownerId, repoName) {
+    const spinner = ora('Creating tree structure...').start();
+
+    try {
+        const entries = buildTreeEntries(files);
+        const tree = await repoService.createTree(ownerId, repoName, entries);
+
+        spinner.succeed(`Created tree ${tree.sha.substring(0, 7)}`);
+        return tree;
+    } catch (error) {
+        spinner.fail('Failed to create tree');
+        throw error;
+    }
+}
+
+/**
+ * Upload a commit to cloud
+ * @param {Object} commit - Local commit object
+ * @param {string} treeSha - Tree SHA
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} branchName - Branch name
+ * @returns {Promise<Object>} Created commit data
+ */
+async function uploadCommit(commit, treeSha, ownerId, repoName, branchName) {
+    const spinner = ora('Creating commit...').start();
+
+    try {
+        const commitData = {
+            message: commit.message,
+            tree_sha: treeSha,
+            parent_shas: commit.parent || [],
+            author_name: commit.author.name,
+            author_email: commit.author.email,
+            branch: branchName
+        };
+
+        const cloudCommit = await repoService.createCommit(ownerId, repoName, commitData);
+
+        spinner.succeed(`Created commit ${cloudCommit.sha.substring(0, 7)}`);
+        return cloudCommit;
+    } catch (error) {
+        spinner.fail('Failed to create commit');
+        throw error;
+    }
+}
+
+/**
+ * Sync local commits to cloud
+ * @param {Array} commits - Array of local commits to upload
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} branchName - Branch name
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<Array>} Array of created cloud commits
+ */
+async function syncCommitsToCloud(commits, ownerId, repoName, branchName, cwd) {
+    console.log(chalk.cyan(`\nPushing ${commits.length} commit(s) to ${ownerId}/${repoName}...`));
+
+    const cloudCommits = [];
+
+    for (let i = 0; i < commits.length; i++) {
+        const commit = commits[i];
+        console.log(chalk.gray(`\nProcessing commit ${commit.sha.substring(0, 7)}: ${commit.message}`));
+
+        // Read files from commit
+        const files = [];
+        for (const [filePath, fileSha] of Object.entries(commit.files || {})) {
+            const objectPath = path.join(cwd, GENT_DIR, OBJECTS_DIR, fileSha);
+            if (await pathExists(objectPath)) {
+                const content = await fs.readFile(objectPath, 'utf-8');
+                files.push({ path: filePath, content });
+            }
+        }
+
+        // Upload blobs
+        const blobMap = await uploadBlobs(files, ownerId, repoName);
+
+        // Build file list with SHAs
+        const fileList = Object.keys(blobMap).map(path => ({
+            path,
+            sha: blobMap[path]
+        }));
+
+        // Upload tree
+        const tree = await uploadTree(fileList, ownerId, repoName);
+
+        // Upload commit
+        const cloudCommit = await uploadCommit(commit, tree.sha, ownerId, repoName, branchName);
+
+        cloudCommits.push(cloudCommit);
+    }
+
+    console.log(chalk.green(`\n✓ Successfully pushed ${commits.length} commit(s)`));
+    return cloudCommits;
+}
+
+/**
+ * Download commits from cloud to local
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<Array>} Array of downloaded commits
+ */
+async function syncCommitsFromCloud(ownerId, repoName, cwd) {
+    const spinner = ora('Fetching commits from cloud...').start();
+
+    try {
+        const cloudCommits = await repoService.listCommits(ownerId, repoName);
+        spinner.succeed(`Fetched ${cloudCommits.length} commit(s)`);
+
+        // Download trees and blobs for each commit
+        for (const commit of cloudCommits) {
+            console.log(chalk.gray(`Processing commit ${commit.sha.substring(0, 7)}: ${commit.message}`));
+
+            // Download tree
+            const tree = await repoService.getTree(ownerId, repoName, commit.tree_sha);
+
+            // Store entries for local metadata
+            commit.files = tree.entries.map(entry => ({
+                path: entry.path,
+                hash: entry.sha
+            }));
+
+            // Download blobs from tree entries
+            const blobShas = tree.entries.map(entry => entry.sha);
+            const blobMap = await downloadBlobs(blobShas, ownerId, repoName);
+
+            // Save blobs to local objects directory
+            const objectsDir = path.join(cwd, GENT_DIR, OBJECTS_DIR);
+            for (const [sha, content] of Object.entries(blobMap)) {
+                const objectPath = path.join(objectsDir, sha);
+                await fs.writeFile(objectPath, content, 'utf-8');
+            }
+        }
+
+        console.log(chalk.green(`\n✓ Successfully pulled ${cloudCommits.length} commit(s)`));
+        return cloudCommits;
+    } catch (error) {
+        spinner.fail('Failed to fetch commits');
+        throw error;
+    }
+}
+
+/**
+ * Get or create remote configuration
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<Object>} Remote configuration
+ */
+async function getRemoteConfig(cwd) {
+    const remotePath = path.join(cwd, GENT_DIR, 'remote.json');
+
+    if (await pathExists(remotePath)) {
+        return await readJSON(remotePath);
+    }
+
+    return { remotes: {} };
+}
+
+/**
+ * Save remote configuration
+ * @param {Object} config - Remote configuration
+ * @param {string} cwd - Current working directory
+ */
+async function saveRemoteConfig(config, cwd) {
+    const remotePath = path.join(cwd, GENT_DIR, 'remote.json');
+    await writeJSON(remotePath, config);
+}
+
+/**
+ * Add a remote to configuration
+ * @param {string} name - Remote name
+ * @param {number} ownerId - Owner user ID
+ * @param {string} repoName - Repository name
+ * @param {string} cwd - Current working directory
+ */
+async function addRemote(name, ownerId, repoName, cwd) {
+    const config = await getRemoteConfig(cwd);
+
+    config.remotes[name] = {
+        owner_id: ownerId,
+        repo_name: repoName
+    };
+
+    await saveRemoteConfig(config, cwd);
+}
+
+/**
+ * Remove a remote from configuration
+ * @param {string} name - Remote name
+ * @param {string} cwd - Current working directory
+ */
+async function removeRemote(name, cwd) {
+    const config = await getRemoteConfig(cwd);
+
+    if (config.remotes[name]) {
+        delete config.remotes[name];
+        await saveRemoteConfig(config, cwd);
+    }
+}
+
+/**
+ * Get remote by name
+ * @param {string} name - Remote name
+ * @param {string} cwd - Current working directory
+ * @returns {Promise<Object|null>} Remote configuration or null
+ */
+async function getRemote(name, cwd) {
+    const config = await getRemoteConfig(cwd);
+    return config.remotes[name] || null;
+}
+
+module.exports = {
+    uploadBlobs,
+    downloadBlobs,
+    buildTreeEntries,
+    uploadTree,
+    uploadCommit,
+    syncCommitsToCloud,
+    syncCommitsFromCloud,
+    getRemoteConfig,
+    saveRemoteConfig,
+    addRemote,
+    removeRemote,
+    getRemote
+};

package/src/utils/constants.js

@@ -11,15 +11,42 @@ module.exports = {
     COMMITS_FILE: 'commits.json',
     HEAD_FILE: 'HEAD',
     AUTH_FILE: 'auth.json',
+    OBJECTS_DIR: 'objects',
+    REMOTE_CONFIG_FILE: 'remote.json',
 
     // API Configuration
     API_BASE_URL: 'https://gent-api.onrender.com',
     API_ENDPOINTS: {
+        // Auth endpoints
         LOGIN: '/api/auth/login/',
         REGISTER: '/api/auth/register/',
         LOGOUT: '/api/auth/logout/',
         REFRESH: '/api/auth/token/refresh/',
-        PROFILE: '/api/auth/profile/'
+        PROFILE: '/api/auth/profile/',
+
+        // Repository endpoints
+        REPOS_LIST: '/api/repos/',
+        REPOS_CREATE: '/api/repos/create/',
+        REPOS_GET: '/api/repos/{owner_id}/{repo_name}/',
+        REPOS_DELETE: '/api/repos/{owner_id}/{repo_name}/delete/',
+
+        // Blob endpoints
+        BLOB_GET: '/api/repos/{owner_id}/{repo_name}/blob/{sha}/',
+        BLOB_CREATE: '/api/repos/{owner_id}/{repo_name}/blob/create/',
+
+        // Tree endpoints
+        TREE_GET: '/api/repos/{owner_id}/{repo_name}/tree/{sha}/',
+        TREE_CREATE: '/api/repos/{owner_id}/{repo_name}/tree/create/',
+
+        // Commit endpoints
+        COMMITS_LIST: '/api/repos/{owner_id}/{repo_name}/commits/',
+        COMMITS_GET: '/api/repos/{owner_id}/{repo_name}/commits/{sha}/',
+        COMMITS_CREATE: '/api/repos/{owner_id}/{repo_name}/commits/create/',
+
+        // Branch endpoints
+        BRANCHES_LIST: '/api/repos/{owner_id}/{repo_name}/branches/',
+        BRANCHES_GET: '/api/repos/{owner_id}/{repo_name}/branches/{branch_name}/',
+        BRANCHES_CREATE: '/api/repos/{owner_id}/{repo_name}/branches/create/'
     },
 
     // Default ignore patterns