@relbns/github-cloner/src/utils.js

Github Cloner is a CLI tool for cloning Github repositories with interactive lists in the terminal. the tool lists your repositories and sorts them by owners (users and organizations) and by name. choosing the repo will clone it to the current directory i

import fs from 'fs/promises';
import os from 'os';
import simpleGit from 'simple-git';
import chalk from 'chalk';
import { OwnerTypes, sortingDirections, sortingFields } from "./constants.js";
import { createRequire } from "module";


export const getPackageVersion = () => {
    const require = createRequire(import.meta.url);
    const packageJson = require('../package.json');
    return packageJson.version;
}

export const sortReposByType = (data, sortingField, direction) => {
    switch (sortingField) {
        case sortingFields.pushedAt: {
            if (direction === sortingDirections.descending) {
                return data.sort((a, b) => new Date(b[sortingField]) - new Date(a[sortingField]));
            } else {
                return data.sort((a, b) => new Date(a[sortingField]) - new Date(b[sortingField]));
            }
        }
        case sortingFields.name: {
            if (direction === sortingDirections.descending) {
                return data.sort((a, b) => b[sortingField].localeCompare(a[sortingField]));
            } else {
                return data.sort((a, b) => a[sortingField].localeCompare(b[sortingField]));
            }
        }
        default: {
            return data;
        }
    }
};

export const sortRepositories = (data) => sortReposByType(data, sortingFields.pushedAt, sortingDirections.descending);

export const organizeRepositories = (data, owner) => {
    // Create an object to store the organized data.
    const organizedData = {
        All: [],
        Users: {},
        Organizations: {},
    };

    // Categorize the repositories.
    data.forEach((repo) => {
        organizedData.All.push(repo);
        if (repo.ownerType === OwnerTypes.User) {
            if (repo.owner === owner) {
                if (!organizedData.Users.MyProjects) {
                    organizedData.Users.MyProjects = [];
                }
                organizedData.Users.MyProjects.push(repo);
            } else {
                if (!organizedData.Users.OtherUsersProjects) {
                    organizedData.Users.OtherUsersProjects = [];
                }
                organizedData.Users.OtherUsersProjects.push(repo);
            }
        } else if (repo.ownerType === OwnerTypes.Organization) {
            if (!organizedData.Organizations[repo.owner]) {
                organizedData.Organizations[repo.owner] = [];
            }
            organizedData.Organizations[repo.owner].push(repo);
        }
    });

    // Sort repositories within categories.
    Object.keys(organizedData.Users).forEach((key) => sortRepositories(organizedData.Users[key]));

    Object.keys(organizedData.Organizations).forEach((org) => sortRepositories(organizedData.Organizations[org]));

    // Sort the All category by name.
    organizedData.All.sort((a, b) => a.name.localeCompare(b.name));

    return organizedData;
}

export const isRepositoryCloned = async (repoName) => {
    try {
        // Check if the repository directory exists in the current working directory.
        await fs.access(repoName);
        return true;
    } catch (error) {
        return false;
    }
}

export const cloneRepo = async (cliSpinner, cloneUrl, repoName) => {
    const git = simpleGit();

    try {
        // Use token in clone URL for authentication
        const tokenUrl = cloneUrl.replace(
            'https://',
            `https://${process.env.GITHUB_TOKEN}@`
        );
        await git.clone(tokenUrl, repoName);
        cliSpinner.text = `${repoName} cloned successfully.`;
        cliSpinner.succeed();
        process.exit(0);
    } catch (error) {
        cliSpinner.fail('Clone failed');
        console.log(chalk.red('Error:'), error.message);
        process.exit(1);
    }
}

const importTokenToEnv = async () => {
    const homeDirectory = os.homedir();
    const bashProfilePath = `${homeDirectory}/.bash_profile`;
    const zshrcPath = `${homeDirectory}/.zshrc`;
    const userShell = process.env.SHELL;
    const shellProfilePath = userShell.includes('zsh') ? zshrcPath : bashProfilePath;
    console.log('shellProfilePath', shellProfilePath);
}