gent-cli 2.1.0 → 5.0.0

package/src/services/repo-service.js

@@ -1,291 +0,0 @@
-/**
- * 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
- */
-/**
- * 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} name - Repository name
- * @returns {Promise<Object>} Repository data
- */
-async function getRepository(ownerId, name) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.REPOS_GET, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @returns {Promise<Object>} Delete response
- */
-async function deleteRepository(ownerId, name) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.REPOS_DELETE, { owner_id: ownerId, name: name });
-        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} name - 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, name, content, encoding = 'utf-8') {
-    try {
-        const url = buildUrl(API_ENDPOINTS.BLOB_CREATE, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @param {string} sha - Blob SHA
- * @returns {Promise<Object>} Blob data
- */
-async function getBlob(ownerId, name, sha) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.BLOB_GET, { owner_id: ownerId, name: name, 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} name - Repository name
- * @param {Array} entries - Tree entries
- * @returns {Promise<Object>} Created tree data
- */
-async function createTree(ownerId, name, entries) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.TREE_CREATE, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @param {string} sha - Tree SHA
- * @returns {Promise<Object>} Tree data
- */
-async function getTree(ownerId, name, sha) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.TREE_GET, { owner_id: ownerId, name: name, 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} name - 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, name, commitData) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.COMMITS_CREATE, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @returns {Promise<Array>} List of commits
- */
-async function listCommits(ownerId, name) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.COMMITS_LIST, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @param {string} sha - Commit SHA
- * @returns {Promise<Object>} Commit data
- */
-async function getCommit(ownerId, name, sha) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.COMMITS_GET, { owner_id: ownerId, name: name, 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} name - 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, name, branchName, commitSha) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.BRANCHES_CREATE, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @returns {Promise<Array>} List of branches
- */
-async function listBranches(ownerId, name) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.BRANCHES_LIST, { owner_id: ownerId, name: name });
-        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} name - Repository name
- * @param {string} branchName - Branch name
- * @returns {Promise<Object>} Branch data
- */
-async function getBranch(ownerId, name, branchName) {
-    try {
-        const url = buildUrl(API_ENDPOINTS.BRANCHES_GET, { owner_id: ownerId, name: name, 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

@@ -1,323 +0,0 @@
-/**
- * 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: Array.isArray(commit.parent) ? commit.parent : (commit.parent ? [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 = [];
-        const commitFiles = Array.isArray(commit.files) ? commit.files : [];
-        for (const file of commitFiles) {
-            const objectPath = path.join(cwd, GENT_DIR, OBJECTS_DIR, file.hash);
-            if (await pathExists(objectPath)) {
-                const content = await fs.readFile(objectPath, 'utf-8');
-                files.push({ path: file.path, 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
-};