jvcs 1.1.8 → 1.2.0

package/.jvcs/HEAD

@@ -0,0 +1 @@
+cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/add.js

@@ -0,0 +1,122 @@
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility")
+const path = require("path")
+const fssync = require("fs")
+const chalk = require("chalk")
+const fs = require("fs").promises
+const crypto = require("crypto")
+
+async function getFileHash(filepath) {
+    const buffer = await fs.readFile(filepath)
+    return crypto.createHash("sha256").update(buffer).digest("hex")
+}
+
+async function hashDirectoryRecursive(dir,hashData) {
+
+    const entries = await fs.readdir(dir, {withFileTypes: true})
+    console.log(entries)
+
+    for(const entry of entries) {
+
+        const fullPath = path.join(dir,entry.name)
+        const relativePath = path.relative(process.cwd(),fullPath)
+
+        if(entry.isFile()) {
+            const hash = await getFileHash(fullPath)
+            hashData[relativePath] = {
+                hash,
+                time: new Date().toISOString(),
+            }
+        }
+        else if(entry.isDirectory()) {
+            await hashDirectoryRecursive(fullPath,hashData)
+        }
+    }
+}
+
+async function addCmd(paths) {
+    
+    if(!paths || paths.length === 0) {
+        console.log(chalk.yellow("Please specify files or folders to add."));
+        return
+    }  
+
+    if(!checkGlobalConfig()) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+        
+    let configData = getGlobalConfig()
+        
+    if(!configData) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+
+    if(!checkforjvcs()) {
+        console.log(chalk.red("Repository is not initialized or is deleted. Please create it."))
+        return
+    }
+
+    const repoPath = path.join(process.cwd(),".jvcs")
+    const staging = path.join(repoPath,"staging")
+
+    if(!fssync.existsSync(staging)) 
+    fssync.mkdirSync(staging, {recursive: true})
+
+    const hashPath = path.join(staging,"jvcs_hashcode.json")
+    let hashData = {}
+
+    if(fssync.existsSync(hashPath)) {
+        hashData = JSON.parse(await fs.readFile(hashPath,"utf-8"))
+    }
+
+    let targets = []
+    if(paths.length === 1 && paths[0] === ".") {
+        targets = await fs.readdir(process.cwd(),{withFileTypes: true})
+        targets = targets.filter((target)=> target.name !== ".jvcs" && target.name !== "node_modules").map((item)=> path.resolve(process.cwd(),item.name))
+    }
+    else {
+        targets = paths.map((p)=> path.resolve(process.cwd(),p))
+    }
+
+    // copying the files and folders to staging area
+    for(const target of targets) {
+
+        try {
+
+            if(!fssync.existsSync(target)) {
+                console.log(chalk.red(`Path not found: ${target}`))
+                continue
+            }
+    
+            const destination = path.join(staging,path.relative(process.cwd(),target))
+            await fs.mkdir(path.dirname(destination), {recursive: true})
+    
+            const stats = await fs.stat(target)
+    
+            if(stats.isFile()) {
+                await fs.copyFile(target,destination)
+                const hash = await getFileHash(target)
+                hashData[path.relative(process.cwd(),target)] = {
+                    hash,
+                    time: new Date().toISOString(),
+                }
+                console.log(chalk.green(`Added file: ${path.relative(process.cwd(), target)}`));
+            }
+            else if(stats.isDirectory()) {
+                await fs.cp(target,destination,{recursive: true})
+                await hashDirectoryRecursive(target,hashData)
+                console.log(chalk.cyan(`Added folder: ${path.relative(process.cwd(), target)}`));
+            }
+        }
+        catch(error) {
+            console.log(chalk.red(`Unexpected error: ${error.message}`));
+        }
+    }
+
+    await fs.writeFile(hashPath, JSON.stringify(hashData, null, 2));
+}
+
+module.exports = addCmd

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/begin.js

@@ -0,0 +1,201 @@
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const validator = require("validator");
+const signup = require("./signup")
+const login = require("./login")
+const path = require("path")
+const fs = require("fs")
+
+
+
+async function beginCmd() {
+
+    const config = path.join(require("os").homedir(),".jvcs","config.json")
+    let isInitialized = false
+    let configData = null
+    if(fs.existsSync(config)) {
+        isInitialized = true
+        configData = JSON.parse(fs.readFileSync(config,"utf-8"))
+    }
+    
+    if (isInitialized) {
+        console.log(chalk.green(`You are already logged in as ${configData.username} (${configData.email})`))
+        console.log(chalk.yellow(`[1] Continue \n[2] Logout \nChoose an option (1/2) : `))
+
+        const answer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'choice',
+                validate: function (input) {
+                    if (input === "1" || input === "2")
+                        return true
+
+                    return "Please enter 1 or 2"
+                },
+                filter: function (input) {
+                    return input.trim()
+                }
+            }
+        ])
+
+        console.log(`Your choice was ${answer.choice}`)
+        if (answer.choice === "1") {
+            console.log(chalk.green("Continuing as current user..."))
+            console.log(chalk.green("jvcs --help for help"))
+        }
+        else {
+            console.log(chalk.green("logging out..."))
+            fs.unlinkSync(config)
+            console.log(chalk.green("Logged out Successfully"))
+            console.log(chalk.green("Please login or signup again (jvcs begin) to use version control system"))
+            console.log(chalk.green("jvcs --help for help"))
+        }
+
+        return
+    }
+
+    console.log(chalk.red("No existing session found. Please login or signup."))
+    console.log(chalk.yellow(`[1] Signup \n[2] login \nChoose an option (1/2) : `))
+
+    const answer = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'choice',
+            validate: function (input) {
+
+                if (input === "1" || input === "2")
+                    return true
+
+                return "Please enter 1 or 2"
+            },
+            filter: function (input) {
+                return input.trim(); // optional: remove whitespace
+            }
+        }
+    ])
+
+    if (answer.choice === "1") {
+
+        const signupData = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'username',
+                filter: function (input) {
+                    return input.trim()
+                }
+            },
+            {
+                type: 'input',
+                name: 'email',
+                validate: function (input) {
+                    // validate email
+                    if (validator.isEmail(input))
+                        return true
+
+                    return "Please enter an valid email"
+                },
+                filter: function (input) {
+                    return input.trim()
+                }
+            },
+            {
+                type: 'password',
+                name: 'password',
+                validate: function (input) {
+                    // validate password
+                    if (validator.isStrongPassword(input, {
+                        minLength: 8,
+                        maxLength: 20,
+                        minLowercase: 1,
+                        minUppercase: 1,
+                        minNumbers: 1,
+                        minSymbols: 1,
+                    }))
+                        return true
+
+                    return "Please enter a strong password"
+                },
+                filter: function (input) {
+                    return input.trim()
+                }
+            },
+            {
+                type: 'password',
+                name: 'confirmPassword',
+                validate: function (input, answers) {
+                    if (answers.password !== input)
+                        return "password must be same as above"
+
+                    return true
+                },
+                filter: function (input) {
+                    return input.trim()
+                }
+            }
+        ])
+
+        try {
+            await signup(signupData)
+        }
+        catch (error) {
+            console.log(chalk.red(error))
+        }
+    }
+    else {
+
+        const loginData = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'username',
+                filter: function (input) {
+                    return input.trim()
+                },
+                validate: function (input) {
+                    if (input === "")
+                        return "email cannot be empty"
+
+                    return true
+                }
+            },
+            {
+                type: 'input',
+                name: 'email',
+                filter: function (input) {
+                    return input.trim()
+                },
+                validate: function (input) {
+                    if (!validator.isEmail(input))
+                        return "email is not valid"
+
+                    if (input === "")
+                        return "email cannot be empty"
+
+                    return true
+                }
+            },
+            {
+                type: 'password',
+                name: 'password',
+                filter: function (input) {
+                    return input.trim()
+                },
+                validate: function (input) {
+
+                    if (input === "")
+                        return "password cannot be empty"
+
+                    return true
+                }
+            }
+        ])
+
+        try {
+            await login(loginData)
+        }
+        catch (error) {
+            console.log(chalk.red(error))
+        }
+    }
+}
+
+module.exports = beginCmd

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/clone.js

@@ -0,0 +1,138 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { checkGlobalConfig, getGlobalConfig } = require("./utility");
+const { getDriveClient } = require("../config/drive-config");
+const drive = getDriveClient()
+
+async function findFolderIdByName(name,parentId=null) {
+
+    const safeName = name.replace(/'/g, "\\'");
+    const parts = [`name='${safeName}'`, "trashed=false"];
+    if (parentId) parts.push(`'${parentId}' in parents`);
+
+    const q = parts.join(" and ");
+    const res = await drive.files.list({
+        q,
+        fields: "files(id, name)",
+    });
+
+    const files = (res.data && res.data.files) || [];
+    if (files.length === 0) return null;
+    return files[0].id;
+}   
+
+async function downloadFolderFromDrive(folderId, destPath) {
+    try {
+        const res = await drive.files.list({
+            q: `'${folderId}' in parents and trashed=false`,
+            fields: "files(id, name, mimeType)",
+        });
+
+        const files = res.data.files;
+        if (!files.length) return;
+
+        for (const file of files) {
+            const filePath = path.join(destPath, file.name);
+
+            if (file.mimeType === "application/vnd.google-apps.folder") {
+                // create folder locally
+                if (!fs.existsSync(filePath)) fs.mkdirSync(filePath);
+                await downloadFolderFromDrive(file.id, filePath);
+            } else {
+                const dest = fs.createWriteStream(filePath);
+                await drive.files.get(
+                    { fileId: file.id, alt: "media" },
+                    { responseType: "stream" }
+                ).then(res => {
+                    return new Promise((resolve, reject) => {
+                        res.data
+                            .on("end", resolve)
+                            .on("error", reject)
+                            .pipe(dest);
+                    });
+                });
+            }
+        }
+    } catch (err) {
+        console.log(chalk.red("Error downloading folder: " + err.message));
+    }
+}
+
+
+async function getVisibilityAndLatestCommit(username,reponame,configData) {
+
+    try {
+
+        const response = await fetch("http://localhost:3000/cloneRepo", {
+            method:"POST",
+            headers: {
+                'Content-Type':"application/json"
+            },
+            body: JSON.stringify({username,reponame,token:configData.token})
+        })
+
+        const data = await response.json()
+        return data
+    }
+    catch(error) {
+        console.log(chalk.red(error || error.message))
+    }
+}
+
+async function cloneCmd(username,reponame) {
+
+    if(!username || !reponame) {
+        console.log(chalk.red("Path is not provided properly"))
+        return
+    }   
+
+    if(!checkGlobalConfig()) {
+        console.log(chalk.red("No existing session found. Please login or signup."));
+        console.log(chalk.green("jvcs --help for help"));
+        return;
+    }
+    
+    const configData = getGlobalConfig();
+    if(!configData) {
+        console.log(chalk.red("No existing session found. Please login or signup."));
+        return;
+    }
+
+    console.log(username,reponame)
+    
+    const response = await getVisibilityAndLatestCommit(username,reponame,configData)
+    if(response.status === false) {
+        console.log(chalk.red(`${response.message}`))
+        return
+    }
+
+    const latestCommit = response.commitId
+    // find the repo from drive GithubClone/username/reponame/commit_lastestCommit
+
+    const rootFolder = await findFolderIdByName("GithubClone")
+    if(!rootFolder) throw new Error("Root folder not found on cloud.");
+
+    const userFolder = await findFolderIdByName(username, rootFolder);
+    if (!userFolder) throw new Error(`User folder '${username}' not found.`);
+
+    const repoFolder = await findFolderIdByName(reponame, userFolder);
+    if (!repoFolder) throw new Error(`Repository folder '${reponame}' not found.`);
+
+    const commitFolder = await findFolderIdByName(`commit_${latestCommit}`, repoFolder);
+    if (!commitFolder) throw new Error(`Commit folder 'commit_${latestCommit}' not found.`);
+
+    console.log(chalk.green(`Found repository, downloading...`));
+
+    const destPath = path.join(process.cwd(), reponame);
+    if(fs.existsSync(destPath)) {
+        console.log(chalk.red(`Destination '${reponame}' already exists. Remove or rename it and retry.`));
+        return;
+    }
+
+    await downloadFolderFromDrive(commitFolder, destPath);
+    
+    console.log(chalk.green(`Repository cloned successfully into ./${reponame}`));
+}
+
+module.exports = cloneCmd

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/commit.js

@@ -0,0 +1,83 @@
+const path = require("path");
+const fs = require("fs").promises;
+const fssync = require("fs");
+const chalk = require("chalk");
+const { v4: uuidv4 } = require("uuid");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
+
+async function commitCmd(message) {
+    
+    if (!message || !message.trim()) {
+        console.log(chalk.yellow("Please provide a commit message."));
+        return;
+    }
+
+    if(!checkGlobalConfig()) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+
+    let configData = getGlobalConfig()
+
+    if(!configData) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+
+    if(!checkforjvcs()) {
+        console.log(chalk.red("Repository is not initialized or is deleted. Please create it."))
+        return
+    }
+
+    const repoPath = path.join(process.cwd(),".jvcs")
+    const staging = path.join(repoPath,"staging")
+    const commits = path.join(repoPath,"commits")
+
+    if(!fssync.existsSync(staging)) {
+        console.log(chalk.yellow("Nothing to commit — staging area is empty."))
+        return
+    }
+
+    const stagedContent = await fs.readdir(staging)
+    if(stagedContent.length === 0) {
+        console.log(chalk.yellow("Nothing to commit — staging area is empty."))
+        return
+    }
+
+
+    if(!fssync.existsSync(commits)) {
+        await fs.mkdir(commits)
+    }
+
+    // main commit logic
+    const commitId = uuidv4()
+    const commitFolder = path.join(commits,commitId)
+    await fs.mkdir(commitFolder, {recursive: true})
+
+    // copying the staging area content to commit folder
+    await fs.cp(staging,commitFolder, {recursive: true})
+
+    // saving metadata of commit
+    let parentId = null;
+    const headPath = path.join(repoPath, "HEAD");
+    if (fssync.existsSync(headPath)) {
+        parentId = (await fs.readFile(headPath, "utf8")).trim() || null;
+    }
+
+    const meta = {
+        author: configData.username || "unknown",
+        id: commitId,
+        message,
+        timeStamp: new Date().toISOString(),
+        parentId
+    }
+
+    await fs.writeFile(path.join(commitFolder,"meta.json"),JSON.stringify(meta,null,2))
+
+    await fs.writeFile(path.join(repoPath, "HEAD"), commitId);
+    console.log(chalk.green(`Committed as ${commitId}: "${message}"`));
+}
+
+module.exports = commitCmd

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/driveUtility.js

@@ -0,0 +1,56 @@
+const { getDriveClient } = require("../config/drive-config");
+const drive = getDriveClient()
+
+async function getDirectoryStructure(username,reponame,commitId) {
+
+    async function findOrCreateFolder(name,parentId=null) {
+
+        const query = [
+            `name='${name}'`,
+            "mimeType='application/vnd.google-apps.folder'",
+            "trashed=false"
+        ]
+
+        if(parentId) {
+            query.push(`'${parentId}' in parents`)
+        }
+
+        const res = await drive.files.list({
+            q: query.join(" and "),
+            fields: "files(id,name)"
+        })
+
+        if (res.data.files.length > 0)
+        return { id: res.data.files[0].id, alreadyExists: true };
+
+        const folderMetaData = {
+            name,
+            mimeType: "application/vnd.google-apps.folder",
+        }
+        if(parentId) folderMetaData.parents = [parentId];
+
+        const folder = await drive.files.create({
+            resource: folderMetaData,
+            fields: "id"
+        })
+
+        return { id: folder.data.id, alreadyExists: false };
+    }
+
+    // Build folder hierarchy in drive
+    const githubClone = await findOrCreateFolder("GithubClone");
+    const userFolder = await findOrCreateFolder(username,githubClone.id)
+    const repoFolder = await findOrCreateFolder(reponame,userFolder.id)
+    const commitFolderName = `commit_${commitId}`
+    const commitFolder = await findOrCreateFolder(commitFolderName,repoFolder.id)
+
+    return {
+        githubCloneId: githubClone.id,
+        userFolderId: userFolder.id,
+        repoFolderId: repoFolder.id,
+        commitFolderId: commitFolder.id,
+        commitAlreadyExists: commitFolder.alreadyExists
+    }
+}
+
+module.exports = getDirectoryStructure

package/.jvcs/commits/cd2a0ec7-04b8-4ac9-b539-617bb5fea1f3/controllers/init.js

@@ -0,0 +1,60 @@
+const fs = require("fs").promises;
+const path = require("path");
+const chalk = require("chalk");
+const fssync = require("fs")
+const { getGlobalConfig, checkGlobalConfig } = require("./utility")
+
+async function initCmd() {
+
+    if(!checkGlobalConfig()) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+    
+    let configData = null
+    configData = getGlobalConfig()
+    
+    if(!configData) {
+        console.log(chalk.red("No existing session found. Please login or signup."))
+        console.log(chalk.green("jvcs --help for help"))
+        return
+    }
+
+    // initialize an empty folder with the name of current directory
+    const cwd = process.cwd()
+    const home = require("os").homedir()
+
+    if(cwd ===  home) {
+        console.log(chalk.red("Cannot initialize a repository in your home directory."));
+        console.log(chalk.yellow("Hint: navigate to a project folder and run 'jvcs init' there."));
+        process.exit(1);
+    }
+
+    const repoPath = path.join(cwd,".jvcs")
+    if(fssync.existsSync(repoPath)) {
+        console.log(chalk.yellow("Repository already is initialized."));
+        process.exit(1);    
+    }
+
+    fssync.mkdirSync(repoPath)
+    fssync.mkdirSync(path.join(repoPath,"commits"))
+    fssync.mkdirSync(path.join(repoPath,"staging"))
+    
+    const config = {
+        repoName: path.basename(cwd),
+        createdAt: new Date().toISOString(),
+        remote: null,
+        owner : {
+            username: configData.username,
+            email: configData.email
+        }
+    }
+
+    fssync.writeFileSync(path.join(repoPath, "config.json"), JSON.stringify(config, null, 2))
+    fssync.writeFileSync(path.join(repoPath, "HEAD"), "");
+
+    console.log(chalk.green(`Initialized empty JVCS repository`));
+}
+
+module.exports = initCmd