jvcs 1.0.0

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/push.js

@@ -0,0 +1,135 @@
+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 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."));
+
+        console.log(chalk.blue("Pushing commits for user:"), chalk.green(config.username));
+
+        // Check commits locally
+        const commitDirs = await fsPromises.readdir(commitFolder);
+        if (!commitDirs.length) {
+            console.log(chalk.yellow("⚠ No commits to push."));
+            return;
+        }
+
+        // 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)"
+        });
+
+        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.`));
+        }
+
+        // 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)"
+        });
+
+        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.`));
+        }
+
+        // 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.`));
+                continue;
+            }
+
+            const folderPath = path.join(commitFolder, commitDir);
+
+            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;
+
+            await uploadFolder(folderPath, commitFolderId);
+
+            console.log(chalk.green(`Commit '${commitDir}' pushed successfully.`));
+        }
+
+    } catch(error) {
+        console.log(chalk.red("Error in pushCmd:"), error.message);
+    }
+}
+
+// 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"
+            });
+        }
+    }
+}
+
+module.exports = pushCmd;

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/revert.js

@@ -0,0 +1,110 @@
+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");
+
+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 });
+        }
+
+        // 7️⃣ Copy new revert commit into working directory
+        await copyFolderRecursive(newCommitPath, cwd);
+
+        console.log(chalk.green(`Reverted to commit '${commitId}'. New revert commit: '${newCommitId}'`));
+
+    } catch (err) {
+        console.log(chalk.red("Error in revertCmd:"), err.message);
+    }
+}
+
+// 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);
+                });
+            });
+        }
+    }
+}
+
+// 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);
+        }
+    }
+}
+
+module.exports = revertCmd;

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/signup.js

@@ -0,0 +1,28 @@
+const chalk = require("chalk")
+const verifyOtp = require("./verifyOtp")
+async function signup(signupData) {
+
+    const response = await fetch("http://localhost:3000/signup", {
+        method: "POST",
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        credentials: "include",
+        body: JSON.stringify(signupData)
+    })
+
+    const data = await response.json()
+
+    if(data.status === true) {
+        console.log(chalk.green(data.message))
+        await verifyOtp(signupData)
+    }
+    else if(data.status == "user") {
+        console.log(chalk.yellow(data.message))
+    }
+    else {
+        throw new Error(data.message)
+    }
+}
+
+module.exports = signup

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/unstage.js

@@ -0,0 +1,96 @@
+const fs = require("fs").promises;
+const fssync = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
+
+function removeHashesForFolder(hashData,folderPath) {
+
+    for(const key of Object.keys(hashData)) {
+        if(key.startsWith(folderPath+path.sep)) {
+            delete hashData[key]
+        }
+    }
+}
+
+async function unstageCmd(paths) {
+
+    if(!paths || paths.length === 0) {
+        console.log(chalk.yellow("Please specify files or folders to unstage."));
+        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;
+    }
+
+    if(!checkforjvcs()) {
+        console.log(chalk.red("Repository is not initialized or is deleted."));
+        return;
+    }
+
+    const repoPath = path.join(process.cwd(), ".jvcs");
+    const stagingPath = path.join(repoPath, "staging");
+    const hashPath = path.join(stagingPath, "jvcs_hashcode.json");
+
+    if(!fssync.existsSync(stagingPath)) {
+        console.log(chalk.yellow("Nothing is staged yet."));
+        return;
+    }
+
+    const stagedItems = fssync.readdirSync(stagingPath).filter((item)=> item !== "jvcs_hashcode.json")
+    if(stagedItems.length === 0) {
+        console.log(chalk.yellow("Staging area is empty. Nothing to unstage."));
+        return;
+    }
+
+    let hashData = {};
+    if(fssync.existsSync(hashPath)) {
+        hashData = JSON.parse(await fs.readFile(hashPath, "utf-8"));
+    }
+
+    if(paths.length === 1 && paths[0] === ".") {
+        await fs.rm(stagingPath, {recursive: true, force: true})
+        await fs.mkdir(stagingPath, {recursive: true})
+        console.log(chalk.cyan("Unstaged all files and folders."));
+        return
+    }
+
+    const targets = paths.map((p) => path.resolve(process.cwd(), p));
+
+    for(const target of targets) {
+
+        const stagedTarget = path.join(stagingPath, path.relative(process.cwd(),target))
+
+        if(!fssync.existsSync(stagedTarget)) {
+            console.log(chalk.yellow(`Not found in staging: ${path.relative(process.cwd(), target)}`));
+            continue;
+        }
+
+        const stats = await fs.stat(stagedTarget);
+
+        if(stats.isDirectory()) {
+            await fs.rm(stagedTarget, {recursive: true, force: true})
+            removeHashesForFolder(hashData,path.relative(process.cwd(),target))
+            console.log(chalk.cyan(`Unstaged folder: ${path.relative(process.cwd(), target)}`));
+        }
+        else if(stats.isFile()) {
+            await fs.rm(stagedTarget)
+            delete hashData[path.relative(process.cwd(),target)]
+            console.log(chalk.green(`Unstaged file: ${path.relative(process.cwd(), target)}`));
+        }
+
+    }
+
+    await fs.writeFile(hashPath, JSON.stringify(hashData, null, 2));
+}
+
+module.exports = unstageCmd

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/utility.js

@@ -0,0 +1,28 @@
+const fs = require("fs")
+const path = require("path")
+
+const config = path.join(require("os").homedir(),".jvcs","config.json")
+
+function checkGlobalConfig() {
+    return fs.existsSync(config)
+}
+
+function getGlobalConfig() {
+    if(checkGlobalConfig()) {
+        const configData = JSON.parse(fs.readFileSync(config,"utf-8"))
+        return configData
+    }
+
+    return null
+}
+
+function checkforjvcs() {
+    const jvcsPath = path.join(process.cwd(),".jvcs")
+    return fs.existsSync(jvcsPath)
+}
+
+module.exports = {
+    checkGlobalConfig,
+    getGlobalConfig,
+    checkforjvcs
+}

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/controllers/verifyOtp.js

@@ -0,0 +1,55 @@
+const inquirer = require("inquirer");
+const fs = require("fs")
+const path = require("path")
+const chalk = require("chalk")
+
+async function verifyOtp(signupData) {
+
+    const otp = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'otp',
+            validate: function(input) {
+                if(input.length !== 6)
+                return "OTP must be of 6 length"
+
+                return true
+            },
+            filter: function(input) {
+                return input.trim()
+            },
+            mask: '*',
+        }
+    ])
+
+    console.log(`otp is : ${otp.otp}`)
+    const response = await fetch("http://localhost:3000/verifyEmail", {
+        method: "POST",
+        headers: { 'Content-Type': 'application/json' },
+        credentials: "include",
+        body: JSON.stringify({email:signupData.email,otp:otp.otp,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: signupData.email,username: signupData.username,token: data.token},null,2));
+    }
+    else if(data.status === "user") {
+        console.log(chalk.yellow(data.message))
+    } 
+    else {
+        throw new Error(data.message)
+    }
+
+}
+
+module.exports = verifyOtp

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/jvcs_hashcode.json

@@ -0,0 +1,50 @@
+{
+  "controllers\\add.js": {
+    "hash": "1108e6f710b0e3bc171fe91b4bb05b06e184536b7ff481a835e0d58e8fb6dd86",
+    "time": "2025-10-27T14:28:57.120Z"
+  },
+  "controllers\\begin.js": {
+    "hash": "228ccbb0e8965765aa039b27cd4a6ffaad388b9b09c52fafe8f807b7b568f378",
+    "time": "2025-10-27T14:28:57.122Z"
+  },
+  "controllers\\commit.js": {
+    "hash": "605f17f8bd9b41031ec4b8622b16a8df23e0fc9e61eaabfa208e3c86e8393225",
+    "time": "2025-10-27T14:28:57.123Z"
+  },
+  "controllers\\init.js": {
+    "hash": "32343d60e405454a913fddb507749648f9888a9da0d600e521c2c629216d3692",
+    "time": "2025-10-27T14:28:57.124Z"
+  },
+  "controllers\\login.js": {
+    "hash": "221da70c0993adf46cefd25ed4c8fd23d0a0608da9e6cc9ab829757cd4807bd1",
+    "time": "2025-10-27T14:28:57.124Z"
+  },
+  "controllers\\pull.js": {
+    "hash": "470e368a19c7c7e8d9779410442a38c8edc935c4c4c2ddc31da5f718aa03765b",
+    "time": "2025-10-27T14:28:57.125Z"
+  },
+  "controllers\\push.js": {
+    "hash": "adc10399b4de39d76fee60f30cda01d19a173ff6e2a5efef91ee2d4687f813d4",
+    "time": "2025-10-27T14:28:57.125Z"
+  },
+  "controllers\\revert.js": {
+    "hash": "9cb908b0bfc6b5fd5d46ed95a847c9639297293c1bd9948991ba6ea797ad8cb0",
+    "time": "2025-10-27T14:28:57.126Z"
+  },
+  "controllers\\signup.js": {
+    "hash": "67c1f5ad80f8a64e92fd8cd685a06a605831011fd4246256a60e09a6b5d161b8",
+    "time": "2025-10-27T14:28:57.126Z"
+  },
+  "controllers\\unstage.js": {
+    "hash": "dad05d36b99737206255ff62655968ede6b5f941b56622df48b50ac8ed48f582",
+    "time": "2025-10-27T14:28:57.127Z"
+  },
+  "controllers\\utility.js": {
+    "hash": "7102c426a65ff9b875f43bf5ca77ddc9c6050bb057b4e8c269529dccef44b921",
+    "time": "2025-10-27T14:28:57.127Z"
+  },
+  "controllers\\verifyOtp.js": {
+    "hash": "bca1ca95df41204ade025dea0822c29422c17cd67cc24584ef17231c4382701f",
+    "time": "2025-10-27T14:28:57.127Z"
+  }
+}

package/.jvcs/commits/484ac37d-c1a9-4ddd-8796-6e3facda1e11/meta.json

@@ -0,0 +1,7 @@
+{
+  "author": "jagdish",
+  "id": "484ac37d-c1a9-4ddd-8796-6e3facda1e11",
+  "message": "commit 2",
+  "timeStamp": "2025-10-27T14:29:20.829Z",
+  "parentId": "c3f6ff7a-13bd-4697-a80e-041f7dae8a09"
+}

package/.jvcs/commits/c3f6ff7a-13bd-4697-a80e-041f7dae8a09/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").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