jvcs 1.0.2 → 1.0.4

package/.env

@@ -1,4 +1,4 @@
-CLIENT_ID='835069827989-3spob55ioa2ocudi3mo8u2ni2ecqohh7.apps.googleusercontent.com';
-CLIENT_SECRET='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';
-REDIRECT_URI='https://developers.google.com/oauthplayground';
-REFRESH_TOKEN='1//046r33XEFgQbICgYIARAAGAQSNwF-L9Ir_HV79cxAU_xla01zIvHyko6dBz0xoJ9Xhb0UQTbEqdf2czDvhkFFZUszyUQWzYw-5WQ';
+CLIENT_ID=835069827989-3spob55ioa2ocudi3mo8u2ni2ecqohh7.apps.googleusercontent.com
+CLIENT_SECRET=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
+REDIRECT_URI=https://developers.google.com/oauthplayground
+REFRESH_TOKEN=1//04wJgrjHWoDOZCgYIARAAGAQSNwF-L9Iryvz_RHMDkqyYlK2wv9TiVMsvq1eghHFnbS868U-zraLb44f8dEPvpNjJEmex_IcMxUE

package/.jvcs/HEAD

@@ -0,0 +1 @@
+f91ef83b-df7f-4137-9316-35928d9c46a3

package/.jvcs/commits/f91ef83b-df7f-4137-9316-35928d9c46a3/jvcs_hashcode.json

@@ -0,0 +1,6 @@
+{
+  "package.json": {
+    "hash": "2f5eb0e283834ec948f58da8a51c95ee26505ba837ffe753b65de239e8504524",
+    "time": "2025-10-28T18:48:37.576Z"
+  }
+}

package/.jvcs/commits/f91ef83b-df7f-4137-9316-35928d9c46a3/meta.json

@@ -0,0 +1,7 @@
+{
+  "author": "jagdish",
+  "id": "f91ef83b-df7f-4137-9316-35928d9c46a3",
+  "message": "m1",
+  "timeStamp": "2025-10-28T18:48:45.420Z",
+  "parentId": null
+}

package/.jvcs/commits/f91ef83b-df7f-4137-9316-35928d9c46a3/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "jvcs",
+  "version": "1.0.4",
+  "bin": {
+    "jvcs": "./index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "crypto": "^1.0.1",
+    "dotenv": "^17.2.3",
+    "googleapis": "^164.1.0",
+    "inquirer": "^8.2.7",
+    "uuid": "^13.0.0",
+    "validator": "^13.15.20",
+    "yargs": "^18.0.0"
+  }
+}

package/.jvcs/config.json

@@ -0,0 +1,9 @@
+{
+  "repoName": "backend2",
+  "createdAt": "2025-10-28T18:48:26.816Z",
+  "remote": null,
+  "owner": {
+    "username": "jagdish",
+    "email": "pathakjijagdish1@gmail.com"
+  }
+}

package/.jvcs/staging/jvcs_hashcode.json

@@ -0,0 +1,6 @@
+{
+  "package.json": {
+    "hash": "2f5eb0e283834ec948f58da8a51c95ee26505ba837ffe753b65de239e8504524",
+    "time": "2025-10-28T18:48:37.576Z"
+  }
+}

package/.jvcs/staging/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "jvcs",
+  "version": "1.0.4",
+  "bin": {
+    "jvcs": "./index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "crypto": "^1.0.1",
+    "dotenv": "^17.2.3",
+    "googleapis": "^164.1.0",
+    "inquirer": "^8.2.7",
+    "uuid": "^13.0.0",
+    "validator": "^13.15.20",
+    "yargs": "^18.0.0"
+  }
+}

package/apicall/handleDbForRepo.js

@@ -0,0 +1,31 @@
+const chalk = require("chalk")
+
+async function handleDbForRepo(reponame,driveId,parentId,Content,token) {
+
+    try {
+
+        const response = await fetch("http://localhost:3000/createCLIRepo", {
+            method: "POST",
+            headers: {
+                'Content-Type': "application/json"
+            },
+            body: JSON.stringify({reponame,driveId,parentId,content:Content,token})
+        })
+
+        const result = await response.json()
+        if(!result.status) {
+            console.log(chalk.red(`Server Error: ${result.message || "Unknown error"}`));
+            return;
+        }
+
+        console.log(chalk.bold.green(`${result.message}`));
+
+    }
+    catch(error) {
+        console.log(chalk.red("Failed to contact backend server."));
+        console.log(chalk.red(error.message))
+    }
+
+}
+
+module.exports = handleDbForRepo

package/config/drive-config.js

@@ -15,11 +15,13 @@ const oauth2client = new google.auth.OAuth2(
     REDIRECT_URI
 );
 
+
+// hello
 oauth2client.setCredentials({ refresh_token: REFRESH_TOKEN });
 
 const drive = google.drive({
     version: 'v3',
     auth: oauth2client
 });
-
+//hello
 module.exports = { drive };

package/controllers/add.js

@@ -75,7 +75,7 @@ async function addCmd(paths) {
     let targets = []
     if(paths.length === 1 && paths[0] === ".") {
         targets = await fs.readdir(process.cwd(),{withFileTypes: true})
-        targets = targets.filter((target)=> target.name !== ".jvcs").map((item)=> path.resolve(process.cwd(),item.name))
+        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))

package/controllers/driveUtility.js

@@ -0,0 +1,55 @@
+const { drive } = require("../config/drive-config");
+
+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/controllers/push.js

@@ -1,135 +1,164 @@
-const fs = require("fs");
-const fsPromises = require("fs").promises;
-const path = require("path");
-const chalk = require("chalk");
-const { drive } = require("../config/drive-config");
-const saveData = require("../controllers/saveData");
-const { checkInitialization, checkRepoExists, getCLIConfig } = require("./utils");
-
-async function pushCmd(reponame) {
-    try {
-        if (!checkInitialization()) return;
-        if (!checkRepoExists(reponame)) return;
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+const { drive } = require("../config/drive-config")
+const { getGlobalConfig, checkGlobalConfig, checkforjvcs } = require("./utility")
+const getDirectoryStructure = require("./driveUtility")
+const handleDbForRepo = require("../apicall/handleDbForRepo")
+
+
 
-        const repoPath = path.join(process.cwd(), `.${reponame}`);
-        const commitFolder = path.join(repoPath, "commits");
 
-        const config = await getCLIConfig();
-        if (!config) return console.log(chalk.red("Could not read CLI configuration."));
+async function uploadFile(localFile, parentId,data) {
+
+    try {
 
-        console.log(chalk.blue("Pushing commits for user:"), chalk.green(config.username));
+        const fileName = path.basename(localFile)
+        const fileMetaData = {
+            name: fileName,
+            parents: [parentId]
+        }
 
-        // Check commits locally
-        const commitDirs = await fsPromises.readdir(commitFolder);
-        if (!commitDirs.length) {
-            console.log(chalk.yellow("⚠ No commits to push."));
-            return;
+        const media = {
+            mimeType: "application/octet-stream",
+            body: fs.createReadStream(localFile),
         }
 
-        // Ensure user folder exists in Google Drive
-        let userFolderId;
-        const userFolderRes = await drive.files.list({
-            q: `name='${config.username}' and '1ahuoMCN_Ls5kGF2KPUGLbRZb9kGVMe0V' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
+        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],
+            }
 
-        if (userFolderRes.data.files.length) {
-            userFolderId = userFolderRes.data.files[0].id;
-        } else {
             const folder = await drive.files.create({
-                requestBody: {
-                    name: config.username,
-                    mimeType: "application/vnd.google-apps.folder",
-                    parents: ["1ahuoMCN_Ls5kGF2KPUGLbRZb9kGVMe0V"]
-                },
-                fields: "id, name"
-            });
-            userFolderId = folder.data.id;
-            console.log(chalk.green(`Created user folder in Drive.`));
+                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
         }
 
-        // Ensure repo folder exists
-        let repoFolderId;
-        const repoFolderRes = await drive.files.list({
-            q: `name='${reponame}' and '${userFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
+        let configData = getGlobalConfig()
 
-        if (repoFolderRes.data.files.length) {
-            repoFolderId = repoFolderRes.data.files[0].id;
-        } else {
-            const folder = await drive.files.create({
-                requestBody: {
-                    name: reponame,
-                    mimeType: "application/vnd.google-apps.folder",
-                    parents: [userFolderId]
-                },
-                fields: "id, name"
-            });
-            repoFolderId = folder.data.id;
-            console.log(chalk.green(`Created repo folder '${reponame}' in Drive.`));
+        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
         }
 
-        // List existing commits in Drive
-        const driveCommitsRes = await drive.files.list({
-            q: `'${repoFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(name, id)"
-        });
-        const driveCommitNames = driveCommitsRes.data.files.map(f => f.name);
-
-        // Upload commits
-        for (const commitDir of commitDirs) {
-            if (driveCommitNames.includes(commitDir)) {
-                console.log(chalk.yellow(`Commit '${commitDir}' already exists on Drive, skipping.`));
+        // 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 folderPath = path.join(commitFolder, commitDir);
+            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 commitFolderRes = await drive.files.create({
-                requestBody: {
-                    name: commitDir,
-                    mimeType: "application/vnd.google-apps.folder",
-                    parents: [repoFolderId]
-                },
-                fields: "id, name"
-            });
-            const commitFolderId = commitFolderRes.data.id;
+            const folderStructure = await getDirectoryStructure(configData.username,reponame,commitId)
+            const driveCommitId = folderStructure.commitFolderId;
+            repoFolderId = folderStructure.repoFolderId;
+            userFolderId = folderStructure.userFolderId;
+            const commitAlreadyExists = folderStructure.commitAlreadyExists;
 
-            await uploadFolder(folderPath, commitFolderId);
+            if (commitAlreadyExists) {
+                console.log(chalk.yellow(`Skipping ${commitId} (already uploaded)`));
+                continue;
+            }
 
-            console.log(chalk.green(`Commit '${commitDir}' pushed successfully.`));
+            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!"));
 
-    } catch(error) {
-        console.log(chalk.red("Error in pushCmd:"), error.message);
+        // database call for creating/updating an repository
+        await handleDbForRepo(reponame,repoFolderId,userFolderId,Content,configData.token)
     }
-}
-
-// Helper to recursively upload folder to Drive
-async function uploadFolder(folderPath, parentId) {
-    const items = await fsPromises.readdir(folderPath);
-    for (const item of items) {
-        const fullPath = path.join(folderPath, item);
-        const stats = await fsPromises.stat(fullPath);
-        if (stats.isDirectory()) {
-            const folder = await drive.files.create({
-                requestBody: {
-                    name: item,
-                    mimeType: "application/vnd.google-apps.folder",
-                    parents: [parentId]
-                },
-                fields: "id, name"
-            });
-            await uploadFolder(fullPath, folder.data.id);
-        } else {
-            await drive.files.create({
-                requestBody: { name: item, parents: [parentId] },
-                media: { body: fs.createReadStream(fullPath) },
-                fields: "id, name"
-            });
-        }
+    catch(error) {
+        console.log(chalk.red.bold("\nPush Failed"));
+        console.error(chalk.red(error.stack || error.message || error));
     }
 }
 
-module.exports = pushCmd;
+module.exports = pushCmd

package/controllers/revert.js

@@ -1,110 +1,193 @@
 const fs = require("fs");
-const fsPromises = require("fs").promises;
 const path = require("path");
-const { v4: uuidv4 } = require("uuid");
 const chalk = require("chalk");
-const { drive } = require("../config/drive-config");
-const { checkInitialization, checkRepoExists, getCLIConfig } = require("./utils");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
+const drive = require("../config/drive-config")
 
-async function revertCmd(commitId, reponame) {
-    try {
-        if (!checkInitialization()) return;
-        if (!checkRepoExists(reponame)) return;
-
-        const repoPath = path.join(process.cwd(), `.${reponame}`);
-        const commitFolder = path.join(repoPath, "commits");
-        if (!fs.existsSync(commitFolder)) fs.mkdirSync(commitFolder, { recursive: true });
-
-        const config = await getCLIConfig();
-        if (!config) return console.log(chalk.red("Could not read CLI configuration."));
-
-        // 1️⃣ Get user folder
-        const userFolderRes = await drive.files.list({
-            q: `name='${config.username}' and '1ahuoMCN_Ls5kGF2KPUGLbRZb9kGVMe0V' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
-        if (!userFolderRes.data.files.length) return console.log(chalk.red("User folder not found on Drive."));
-        const userFolderId = userFolderRes.data.files[0].id;
-
-        // 2️⃣ Get repo folder
-        const repoFolderRes = await drive.files.list({
-            q: `name='${reponame}' and '${userFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
-        if (!repoFolderRes.data.files.length) return console.log(chalk.red("Repo folder not found on Drive."));
-        const repoFolderId = repoFolderRes.data.files[0].id;
-
-        // 3️⃣ Get commit folder
-        const commitRes = await drive.files.list({
-            q: `name='${commitId}' and '${repoFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
-        if (!commitRes.data.files.length) return console.log(chalk.red(`Commit '${commitId}' not found on Drive.`));
-        const driveCommitId = commitRes.data.files[0].id;
-
-        // 4️⃣ Create new revert commit folder locally
-        const newCommitId = `revert_${commitId}_${uuidv4()}`;
-        const newCommitPath = path.join(commitFolder, newCommitId);
-        await fsPromises.mkdir(newCommitPath, { recursive: true });
-
-        // 5️⃣ Recursively download commit files from Drive
-        await downloadFolderFromDrive(driveCommitId, newCommitPath);
-
-        // 6️⃣ Clean working directory (except hidden files)
-        const cwd = process.cwd();
-        const entries = await fsPromises.readdir(cwd);
-        for (const entry of entries) {
-            if (entry.startsWith(".")) continue;
-            await fsPromises.rm(path.join(cwd, entry), { recursive: true, force: true });
+function copyDir(targetCommitFolder) {
+
+    const cwd = process.cwd()
+    const entries = fs.readdirSync(targetCommitFolder, {recursive: true})
+
+    for(const entry of entries) {
+
+        const srcpath = path.join(targetCommitFolder,entry.name)
+        const destpath = path.join(cwd,entry.name)
+
+        if(entry.isDirectory()) {
+            fs.mkdirSync(destpath, { recursive: true });
+            copyDir(srcpath, destpath);
+        }
+        else {
+            fs.copyFileSync(srcpath, destpath);
+        }
+    }
+}
+
+function cleanCWD() {
+
+    const cwd = process.cwd()
+    const entries = fs.readdirSync(cwd, {withFileTypes: true})
+
+    for(const entry of entries) {
+        if(entry.name === ".jvcs") continue
+        const deleteEntry = path.join(cwd,entry.name)
+        fs.rmSync(deleteEntry, {recursive: true, force: true})
+    }
+}
+
+function getCommitsToDelete(commitFolder,currentCommit,targetCommit) {
+
+    let toDelete = []
+
+    while(currentCommit && currentCommit !== targetCommit) {
+
+        const commitPath = path.join(commitFolder,currentCommit)
+        const metaPath = path.join(commitPath,"meta.json")
+
+        if(!fs.existsSync(commitPath)) break
+        toDelete.push(currentCommit)
+
+        let parent = null
+        if(fs.existsSync(metaPath)) {
+            const data = JSON.parse(fs.readFileSync(metaPath,"utf-8"))
+            parent = data.parent || null
         }
 
-        // 7️⃣ Copy new revert commit into working directory
-        await copyFolderRecursive(newCommitPath, cwd);
+        currentCommit = parent
+    }
+
+    return toDelete
+}
 
-        console.log(chalk.green(`Reverted to commit '${commitId}'. New revert commit: '${newCommitId}'`));
+function deleteLocalCommits(commitDir,Ids) {
 
-    } catch (err) {
-        console.log(chalk.red("Error in revertCmd:"), err.message);
+    for(const id of Ids) {
+        const p = path.join(commitDir,id)
+        fs.rmSync(p, {recursive: true, force: true})
+        console.log(chalk.red(`Deleted local commit ${id}`))
     }
 }
 
-// Recursive download helper
-async function downloadFolderFromDrive(folderId, localPath) {
-    const res = await drive.files.list({
-        q: `'${folderId}' in parents and trashed=false`,
-        fields: "files(id, name, mimeType)"
-    });
-
-    for (const file of res.data.files) {
-        const filePath = path.join(localPath, file.name);
-        if (file.mimeType === "application/vnd.google-apps.folder") {
-            await fsPromises.mkdir(filePath, { recursive: true });
-            await downloadFolderFromDrive(file.id, filePath);
-        } else {
-            const destStream = fs.createWriteStream(filePath);
-            await new Promise((resolve, reject) => {
-                drive.files.get({ fileId: file.id, alt: "media" }, { responseType: "stream" }, (err, response) => {
-                    if (err) return reject(err);
-                    response.data.pipe(destStream).on("finish", resolve).on("error", reject);
-                });
-            });
+async function deleteCommitsFromDrive(ids) {
+
+    let folderName = null
+    try {
+        for(const id of ids) {
+            folderName = `commit_${id}`
+            
+            const res = await drive.files.list({
+                q: `name=${folderName} and trashed=false`,
+                fields: "files(id,name)"
+            })
+            
+            if(res.data.files.length > 0) {
+                const fileId = res.data.files[0].id;
+                await drive.files.delete({fileId})
+                console.log(chalk.red(`Deleted folder ${folderName} from remote`));
+            }
+            else {
+                console.log(chalk.gray(`Drive folder ${folderName} not found.`));
+            }
         }
     }
+    catch(error) {
+        console.log(chalk.red(`Failed to delete ${folderName} from remote: ${err.message}`));
+    }
 }
 
-// Recursive copy helper
-async function copyFolderRecursive(src, dest) {
-    const entries = await fsPromises.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await fsPromises.mkdir(destPath, { recursive: true });
-            await copyFolderRecursive(srcPath, destPath);
-        } else {
-            await fsPromises.copyFile(srcPath, destPath);
+async function deleteCommitsFromDatabase(configData,toDelete,reponame) {
+
+    try {
+
+        const response = await fetch("http://localhost:3000/deleteCommit", {
+            method: "POST",
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({token:configData.token,email:configData.email,username:configData.username,toDelete,reponame})
+        })
+
+        const data = await response.json()
+
+        if(data.status === true) {
+            console.log(chalk.green("Removed previous commits from DB"))
+        }
+        else {
+            console.log(chalk.red(data.message))
         }
     }
+    catch(error) {
+        console.log(chalk.red(error || error.message))
+    }
+}
+
+async function revertCmd(commitId) {
+
+    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;
+    }
+    
+    // actual implementation
+    const cwd = process.cwd()
+    const jvcsDir = path.join(cwd,".jvcs")
+    const commitFolder = path.join(jvcsDir,"commits")
+    const targetCommitFolder = path.join(commitFolder,commitId)
+    const headFile = path.join(jvcsDir,"HEAD")
+
+    if(!fs.existsSync(jvcsDir)) {
+        console.log(chalk.red("Repository is not initialized or is deleted."));
+        return;
+    }
+
+    if(!fs.existsSync(commitFolder)) {
+        console.log(chalk.red("You have made no commits yet. Revert not possible"))
+        return
+    }
+
+    if(!fs.existsSync(targetCommitFolder)) {
+        console.log(chalk.red("No commit exists with commit Id : ",commitId))
+        return
+    }   
+
+    
+    const currentHead = fs.readFileSync(headFile,"utf-8").trim()
+
+    if(currentHead === commitId) {
+        console.log(chalk.green("HEAD is already at the given commit"))
+        return
+    }
+
+    // get commits to delete
+    const toDelete = getCommitsToDelete(commitFolder,currentHead,commitId)
+
+    // clear the current working directory except .jvcs
+    cleanCWD()
+
+    // copy the content of commit to cwd
+    copyDir(targetCommitFolder)
+
+    fs.writeFileSync(headFile,commitId,"utf-8")
+    console.log(chalk.green(`HEAD moved to ${commitId}`));
+
+    deleteLocalCommits(commitFolder,toDelete)
+    await deleteCommitsFromDrive(toDelete)
+    await deleteCommitsFromDatabase(configData,toDelete,path.basename(process.cwd()))
+
+    console.log(chalk.green(`Successfully reverted to commit ${commitId}`));
 }
 
-module.exports = revertCmd;
+module.exports = revertCmd

package/controllers/status.js

@@ -0,0 +1,160 @@
+// Untracked files
+// Files that exist in your working directory (project folder) but have never been added to staging or committed.
+
+// Changes to be committed
+// Files that are in the staging area (.jvcs/staging) — meaning, you’ve already added them using jvcs add, but haven’t committed yet.
+
+// Changes not staged for commit
+// Files that were already added to staging earlier, but you modified them again in your working directory after staging — i.e., the staged copy and working copy are different.
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const chalk = require("chalk");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
+
+// normalize relative path to use forward slashes for consistent comparisons
+function normalizeRel(p) {
+    return p.split(path.sep).join("/")
+}
+
+function hashfile(filepath) {
+    try {
+        const data = fs.readFileSync(filepath)
+        return crypto.createHash("sha256").update(data).digest("hex")
+    }
+    catch(error) {
+        // return null
+    }
+}
+
+
+function getAllFiles(dir, rootDir=dir, collected=[]) {
+
+    if (!fs.existsSync(dir)) return collected;
+
+    const entries = fs.readdirSync(dir,{withFileTypes:true})
+
+    for(const entry of entries) {
+        const fullPath = path.join(dir,entry.name)
+        const rel = normalizeRel(path.relative(rootDir,fullPath))
+
+        if(entry.isDirectory() && (entry.name === ".jvcs" || entry.name === "node_modules")) 
+        continue;
+        
+        if(entry.isFile() && (entry.name === "meta.json" || entry.name === "jvcs_hashcode.json")) 
+        continue;
+        
+        if(entry.isFile()) {
+            collected.push(rel);
+        }
+        else if(entry.isDirectory()) {
+            getAllFiles(fullPath, rootDir, collected);
+        }
+
+    }
+
+    return collected
+}
+
+async function statusCmd() {
+
+    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 cwd = process.cwd()
+    const jvcsDir = path.join(cwd,".jvcs")
+    const commitDir = path.join(jvcsDir,"commits")
+    const stagingDir = path.join(jvcsDir,"staging")
+    const headFile = path.join(jvcsDir, "HEAD");
+
+    if(!fs.existsSync(jvcsDir)) {
+        console.log(chalk.red("No repository exists. Please create one using 'jvcs init'"))
+        return
+    }
+
+    // collect files (all relative to cwd, normalized)
+    const cwdFiles = getAllFiles(cwd, cwd, []);
+    const stagedFiles = fs.existsSync(stagingDir) ? getAllFiles(stagingDir, stagingDir, []).map(f => normalizeRel(f)) : [];
+    let commitedFiles = []
+    if(fs.existsSync(commitDir)) {
+        const commits = fs.readdirSync(commitDir)
+        if(commits.length > 0) {
+            const lastCommit = `${fs.readFileSync(headFile, "utf-8").trim()}`;
+            const commitPath = path.join(commitDir, lastCommit);
+            commitedFiles = getAllFiles(commitPath, commitPath, []).map(f => normalizeRel(f))
+        }
+    }
+
+    // use Sets for fast looku
+    const committedSet = new Set(commitedFiles);
+    const stagedSet = new Set(stagedFiles);
+
+    // Untracked: present in cwd but not in staging or commits
+    const untracked = cwdFiles.filter(f => !stagedSet.has(f) && !committedSet.has(f));
+
+    // Changes to be committed: present in staging but not in (any) commits
+    const toBeCommitted = stagedFiles.filter(f => !committedSet.has(f));
+
+    // Changes not staged for commit: present in staging and in cwd, but changed in cwd compared to staged copy
+    const modified = stagedFiles.filter((file)=> {
+        const cwdFilePath = path.join(process.cwd(),file)
+        const stagedFilePath = path.join(stagingDir,file)
+        
+        if(!fs.existsSync(cwdFilePath) || !fs.existsSync(stagedFilePath))
+        return false
+
+        const cwdHash = hashfile(cwdFilePath)
+        const stagingHash = hashfile(stagedFilePath)
+
+        return cwdHash !== stagingHash
+    })
+
+
+    // output
+    console.log(chalk.bold.blue(`\nOn branch: main (default)`));
+
+    console.log(chalk.bold.green("\nChanges to be committed (files that are staged but not commited):"));
+    if(toBeCommitted.length > 0) {
+        toBeCommitted.forEach(f => console.log(chalk.green(`\t${f}`)));
+    }
+    else {
+        console.log(chalk.gray("\tNo changes added to commit"));
+    }
+
+    console.log(chalk.bold.yellow("\nChanges not staged for commit (files that are modified after adding to staging area):"));
+    if(modified.length > 0) {
+        modified.forEach(f => console.log(chalk.yellow(`\t${f}`)));
+    } 
+    else {
+        console.log(chalk.gray("\tNo modified files detected"));
+    }
+
+    console.log(chalk.bold.red("\nUntracked files (files that are not staged or commited):"));
+    if(untracked.length > 0) {
+        untracked.forEach(f => console.log(chalk.red(`\t${f}`)));
+    }
+    else {
+        console.log(chalk.gray("\tNo untracked files"));
+    }
+
+    console.log(chalk.gray("\n(use 'jvcs add <file>' to stage changes)"));
+    console.log(chalk.gray("(use 'jvcs commit -m \"message\"' to commit changes)"));
+    console.log(chalk.gray("(use 'jvcs unstage <file>/<folder> to unstage a file/folder')"))
+}
+
+module.exports = statusCmd

package/controllers/utility.js

@@ -10,6 +10,7 @@ function checkGlobalConfig() {
 function getGlobalConfig() {
     if(checkGlobalConfig()) {
         const configData = JSON.parse(fs.readFileSync(config,"utf-8"))
+        if(configData.username && configData.email && configData.token)
         return configData
     }
 

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const yargs = require("yargs");
 const { hideBin } = require("yargs/helpers");
@@ -11,8 +11,11 @@ const initCmd = require("./controllers/init")
 const addCmd = require("./controllers/add")
 const commitCmd = require("./controllers/commit")
 const unstageCmd = require("./controllers/unstage")
-const logCmd = require("./controllers/log")
-
+const logCmd = require("./controllers/log");
+const pushCmd = require("./controllers/push");
+const statusCmd = require("./controllers/status")
+const revertCmd = require("./controllers/revert")
+// 
 yargs(hideBin(process.argv))
 .scriptName("jvcs")
 .command(
@@ -115,7 +118,7 @@ yargs(hideBin(process.argv))
 )
 .command(
     "log",
-    "show details of all commits",
+    chalk.blue("show details of all commits"),
     {},
     async ()=> {
         try {
@@ -126,6 +129,50 @@ yargs(hideBin(process.argv))
         }
     }
 )
+.command(
+    "push",
+    chalk.blue("Push all the commits to remote"),
+    {},
+    async ()=> {
+        try {
+            await pushCmd()
+        }
+        catch(error) {
+            console.log(chalk.red(error))
+        }
+    }
+)
+.command(
+    "status",
+    chalk.blue("Check status of each file/folder"),
+    {},
+    async ()=> {
+        try {
+            await statusCmd()
+        }
+        catch(error) {
+            console.log(chalk.red(error))
+        }
+    }
+)
+.command(
+    "revert <commitId>",
+    chalk.blue("Replace your working directory with specific commit you made previously"),
+    (yargs)=> {
+        return yargs.positional("commitId", {
+            type: 'string',
+            describe: 'commitId to move your head'
+        })
+    },
+    async (argv)=> {
+        try {
+            await revertCmd(argv.commitId)
+        }
+        catch(error) {
+            console.log(chalk.red(error))
+        }
+    }
+)
 .demandCommand(1, chalk.yellow("You need at least one command"))
 .help()
 .parse();

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "jvcs",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "bin": {
     "jvcs": "./index.js"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "description": "",
   "dependencies": {
     "chalk": "^4.1.2",
     "crypto": "^1.0.1",
@@ -18,4 +17,4 @@
     "validator": "^13.15.20",
     "yargs": "^18.0.0"
   }
-}
+}

package/controllers/pull.js

@@ -1,98 +0,0 @@
-const fs = require("fs");
-const fsPromises = require("fs").promises;
-const path = require("path");
-const chalk = require("chalk");
-const { drive } = require("../config/drive-config");
-const { checkInitialization, checkRepoExists, getCLIConfig } = require("./utils");
-
-async function pullCmd(reponame) {
-    try {
-        if (!checkInitialization()) return;
-        if (!checkRepoExists(reponame)) return;
-
-        const repoPath = path.join(process.cwd(), `.${reponame}`);
-        const commitFolder = path.join(repoPath, "commits");
-        if (!fs.existsSync(commitFolder)) fs.mkdirSync(commitFolder, { recursive: true });
-
-        const config = await getCLIConfig();
-        if (!config) return console.log(chalk.red("Could not read CLI configuration."));
-
-        console.log(chalk.blue("Pulling commits for user:"), chalk.green(config.username));
-
-        // 1️⃣ Find user folder in Drive
-        const userFolderRes = await drive.files.list({
-            q: `name='${config.username}' and '1ahuoMCN_Ls5kGF2KPUGLbRZb9kGVMe0V' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
-        if (!userFolderRes.data.files.length) {
-            console.log(chalk.yellow("⚠ No user folder found on Drive."));
-            return;
-        }
-        const userFolderId = userFolderRes.data.files[0].id;
-
-        // 2️⃣ Find repo folder in Drive
-        const repoFolderRes = await drive.files.list({
-            q: `name='${reponame}' and '${userFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(id, name)"
-        });
-        if (!repoFolderRes.data.files.length) {
-            console.log(chalk.yellow(`⚠ Repository '${reponame}' not found on Drive.`));
-            return;
-        }
-        const repoFolderId = repoFolderRes.data.files[0].id;
-
-        // 3️⃣ Get commit folders in Drive
-        const driveCommitsRes = await drive.files.list({
-            q: `'${repoFolderId}' in parents and mimeType='application/vnd.google-apps.folder' and trashed=false`,
-            fields: "files(name, id)"
-        });
-        const driveCommits = driveCommitsRes.data.files;
-        if (!driveCommits.length) {
-            console.log(chalk.yellow("⚠ No commits found on Drive."));
-            return;
-        }
-
-        // 4️⃣ Get local commit folders
-        const localCommits = await fsPromises.readdir(commitFolder);
-
-        // 5️⃣ Download only missing commits
-        for (const commit of driveCommits) {
-            if (localCommits.includes(commit.name)) {
-                console.log(chalk.gray(`✔ Commit '${commit.name}' already exists locally.`));
-                continue;
-            }
-            const localCommitPath = path.join(commitFolder, commit.name);
-            await fsPromises.mkdir(localCommitPath, { recursive: true });
-            await downloadFolder(commit.id, localCommitPath);
-            console.log(chalk.green(`⬇ Pulled new commit '${commit.name}' successfully.`));
-        }
-
-        console.log(chalk.blue("Pull complete! Local repo is now up to date."));
-
-    } catch (error) {
-        console.log(chalk.red("Error in pullCmd:"), error.message);
-    }
-}
-
-// Recursive folder download helper
-async function downloadFolder(folderId, destPath) {
-    const res = await drive.files.list({
-        q: `'${folderId}' in parents and trashed=false`,
-        fields: "files(id, name, mimeType)"
-    });
-    for (const file of res.data.files) {
-        const localPath = path.join(destPath, file.name);
-        if (file.mimeType === "application/vnd.google-apps.folder") {
-            await fsPromises.mkdir(localPath, { recursive: true });
-            await downloadFolder(file.id, localPath);
-        } else {
-            const dest = fs.createWriteStream(localPath);
-            await drive.files.get({ fileId: file.id, alt: "media" }, { responseType: "stream" })
-                .then(res => new Promise((resolve, reject) => {
-                    res.data.on("end", resolve).on("error", reject).pipe(dest);
-                }));
-        }
-    }
-}
-
-module.exports = pullCmd;