jvcs 1.1.8 → 1.2.0

package/.jvcs/staging/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/staging/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/staging/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/staging/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

package/.jvcs/staging/controllers/log.js

@@ -0,0 +1,99 @@
+const fssync = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
+
+async function logCmd() {
+
+    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;
+    }
+
+    if(!checkforjvcs()) {
+        console.log(chalk.red("Repository is not initialized or is deleted."));
+        return;
+    }
+
+    const repoPath = path.join(process.cwd(),".jvcs")
+    const commitPath = path.join(repoPath,"commits")
+    const headPath = path.join(repoPath,"HEAD")
+
+    if(!fssync.existsSync(headPath)) {
+        console.log(chalk.yellow("No commits yet."));
+        return;
+    }
+
+    if(!fssync.existsSync(commitPath)) {
+        console.log(chalk.yellow("No commits found. Try commiting first"))
+        return
+    }
+    
+    const commitDir = fssync.readdirSync(commitPath)
+    if(commitDir.length === 0) {
+        console.log(chalk.yellow("No commits found. Try commiting first"))
+        return
+    }
+
+    const currentHead = fssync.readFileSync(headPath,"utf-8").trim()
+    if(!currentHead) {
+        console.log(chalk.yellow("HEAD is empty. No commits to display."));
+        return;
+    }
+
+    console.log(chalk.bold.cyan("\n=========================== Commit History ====================\n"));
+
+    let commitId = currentHead
+    const chains = []
+
+    while(commitId) {
+        const commitFolder = path.join(commitPath,commitId)
+        const metaPath = path.join(commitFolder,"meta.json")
+
+        if (!fssync.existsSync(metaPath)) {
+            console.log(chalk.red(`Missing metadata for commit: ${commitId}`));
+            break;
+        }
+
+        const metaData = JSON.parse(fssync.readFileSync(metaPath,"utf-8"))
+        console.log('\t',chalk.yellow(`commit ${metaData.id}`));
+        console.log('\t',chalk.green(`Author:`), metaData.author || "Unknown");
+        console.log('\t',chalk.cyan(`Date:`), new Date(metaData.timeStamp).toLocaleString());
+        console.log('\t',chalk.white(`\n\t\t${metaData.message}\n`));
+
+        chains.push(metaData.id)
+        commitId = metaData.parentId
+    }
+
+    console.log(chalk.magenta("\n=================Visual Representation for commits==============\n"))
+
+    console.log(chalk.cyan.bold("\n   HEAD"));
+    console.log(chalk.cyan("    ↓\n"));
+
+    let chainLine = "";
+
+    for (let i = 0; i < chains.length; i++) {
+        const id = chains[i].substring(0, 8); // short commit ID
+        chainLine += chalk.green(id);
+
+        if (i !== chains.length - 1) {
+            chainLine += chalk.cyan("  →  ");
+        } else {
+            chainLine += chalk.gray("  →  NULL");
+        }
+    }
+
+    console.log(chainLine);
+    console.log();
+
+    console.log(chalk.bold.cyan("=================================================================\n"));
+}
+
+module.exports = logCmd

package/.jvcs/staging/controllers/login.js

@@ -0,0 +1,33 @@
+const path = require("path")
+const chalk = require("chalk")
+const fs = require("fs")
+async function login(loginData) {
+
+    const response = await fetch("http://localhost:3000/login", {
+        method: "POST",
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        credentials: "include",
+        body: JSON.stringify({email:loginData.email,username:loginData.username,password:loginData.password,cli:true})
+    })
+    
+    const data = await response.json()
+    
+    if(data.status === true) {
+        console.log(chalk.green(data.message))
+
+        const dirPath = path.join(require("os").homedir(), ".jvcs");
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        
+        const configPath = path.join(dirPath, "config.json");
+        fs.writeFileSync(configPath,JSON.stringify({email: loginData.email,username: loginData.username,token: data.token, CLIENT_ID:"835069827989-3spob55ioa2ocudi3mo8u2ni2ecqohh7.apps.googleusercontent.com",CLIENT_SECRET:"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",REDIRECT_URI:"https://developers.google.com/oauthplayground",REFRESH_TOKEN:"1//04dWkzGCpoIgACgYIARAAGAQSNwF-L9IrRV-B67zRcIkhs7USx3vLewtE764bZPv7d5d7hAlH7QThZxj2CQUr5flQIG12Ad64dQI"},null,2));        
+    }
+    else {
+        throw new Error(data.message)
+    }
+}
+
+module.exports = login

package/.jvcs/staging/controllers/push.js

@@ -0,0 +1,165 @@
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const { getDriveClient } = require("../config/drive-config")
+const drive = getDriveClient()
+const { getGlobalConfig, checkGlobalConfig, checkforjvcs } = require("./utility")
+const getDirectoryStructure = require("./driveUtility")
+const handleDbForRepo = require("../apicall/handleDbForRepo")
+
+
+
+
+async function uploadFile(localFile, parentId,data) {
+
+    try {
+
+        const fileName = path.basename(localFile)
+        const fileMetaData = {
+            name: fileName,
+            parents: [parentId]
+        }
+
+        const media = {
+            mimeType: "application/octet-stream",
+            body: fs.createReadStream(localFile),
+        }
+
+        const res = await drive.files.create({
+            resource: fileMetaData,
+            media,
+            fields: "id"
+        })
+
+        console.log(chalk.gray(`   ↳ Uploaded: ${fileName}`));
+        data.files.push({name:fileName,driveId:res.data.id,parentId:parentId,type:"file"})
+        return res.data.id;
+    }
+    catch(error) {
+        console.log(chalk.red(`Failed to upload ${filePath}: ${err.message}`));
+    }
+}
+
+async function uploadDirectory(localDir, parentId,data) {
+
+    const entries = fs.readdirSync(localDir, {withFileTypes: true})
+
+    for(const entry of entries) {
+
+        const entryPath = path.join(localDir,entry.name)
+
+        if(entry.isDirectory()) {
+            const folderMeta = {
+                name: entry.name,
+                mimeType: "application/vnd.google-apps.folder",
+                parents: [parentId],
+            }
+
+            const folder = await drive.files.create({
+                resource: folderMeta,
+                fields: "id"
+            })
+
+            data.files.push({name:entry.name,driveId:folder.data.id,parentId:parentId,type:"folder"})
+            await uploadDirectory(entryPath,folder.data.id,data)
+        }
+        else {
+            await uploadFile(entryPath,parentId,data)
+        }
+    }
+}
+
+async function pushCmd() {
+
+    try {
+
+        let userFolderId,repoFolderId
+
+        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 cwd = process.cwd()
+        const jvcsDir = path.join(cwd,".jvcs")
+        const commitDir = path.join(jvcsDir,"commits")
+        const reponame = path.basename(process.cwd())
+
+        if(!fs.existsSync(commitDir)) {
+            console.log(chalk.yellow("No commits to push"))
+            return
+        }
+
+        // storing the name of commit folders
+        const commitFolders = fs.readdirSync(commitDir, {withFileTypes: true}).filter((e)=> e.isDirectory()).map((e)=> e.name)
+        if(commitFolders.length === 0) {
+            console.log(chalk.yellow('No commits to push'))
+            return
+        }
+
+        console.log(chalk.blue("Pushing commits of ",reponame," to cloud storage..."))
+        
+        const Content = []
+        for(const commitId of commitFolders) {
+            let data = {}
+            data.files = []
+            data.uuid = commitId
+            const commitFolder = path.join(commitDir,commitId)
+            const metaPath = path.join(commitFolder,"meta.json")
+
+            if(!fs.existsSync(metaPath)) {
+                console.log(chalk.yellow(`Skipping ${commitId} (no meta.json found)`));
+                continue;
+            }
+
+            const metaData = JSON.parse(fs.readFileSync(metaPath,"utf-8"))
+            const { author, message, timeStamp } = metaData;
+
+            console.log(chalk.green(`\n Uploading commit:`));
+            console.log(chalk.gray(`   id: ${commitId}`));
+            console.log(chalk.gray(`   message: ${message}`));
+            console.log(chalk.gray(`   author: ${author}`));
+            console.log(chalk.gray(`   time: ${timeStamp}`));
+
+            const folderStructure = await getDirectoryStructure(configData.username,reponame,commitId)
+            const driveCommitId = folderStructure.commitFolderId;
+            repoFolderId = folderStructure.repoFolderId;
+            userFolderId = folderStructure.userFolderId;
+            const commitAlreadyExists = folderStructure.commitAlreadyExists;
+
+            if (commitAlreadyExists) {
+                console.log(chalk.yellow(`Skipping ${commitId} (already uploaded)`));
+                continue;
+            }
+
+            await uploadDirectory(commitFolder,driveCommitId,data)
+            console.log(chalk.green(`Commit ${commitId} uploaded successfully!`));
+            Content.push(data)
+        }
+        
+        console.log(chalk.bold.green("\nAll commits pushed successfully!"));
+
+        // database call for creating/updating an repository
+        await handleDbForRepo(reponame,repoFolderId,userFolderId,Content,configData.token)
+    }
+    catch(error) {
+        console.log(chalk.red.bold("\nPush Failed"));
+        console.error(chalk.red(error.stack || error.message || error));
+    }
+}
+
+module.exports = pushCmd