myvcs 0.1.0 → 1.1.2

package/.env.example

@@ -0,0 +1,4 @@
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+S3_BUCKET=myvcs-bucket
+MY_NAMESPACE=123e4567...

package/Controllers/addRepo.js

@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 async function readIgnoreFile() {
-    const ignorePath = path.join(process.cwd(), ".myvcsignore");
+    const ignorePath = path.resolve(process.cwd(), ".myvcsignore");
     
     try {
         // Check if file exists
@@ -9,7 +9,6 @@ async function readIgnoreFile() {
         
         // Read file content
         const content = await fs.readFile(ignorePath, "utf-8");
-        
         // Split into lines and clean up
         const patterns = content
             .split("\n")                    // Split by newline
@@ -24,7 +23,7 @@ async function readIgnoreFile() {
         return null;
     }
 }
-const ignoreList = await readIgnoreFile();
+let ignoreList=[];
 async function checkExists(path) {
     try {
         await fs.access(path);
@@ -37,6 +36,7 @@ async function addRepo(filePath){
     const repoPath=path.resolve(process.cwd(),".myvcs");
     const stagingPath=path.resolve(repoPath,"staging");
     const repoExists=await checkExists(repoPath);
+    ignoreList = await readIgnoreFile();
      if (!repoExists) {
         console.log("Not a repository. Run 'myvcs init' first.");
         return;
@@ -44,7 +44,7 @@ async function addRepo(filePath){
     try{
         await fs.mkdir(stagingPath,{recursive:true});
         const fileName=path.basename(filePath);
-        if(fileName==".") addAllFiles(process.cwd(),stagingPath);
+        if(fileName==".") await addAllFiles(process.cwd(),stagingPath);
         else if(ignoreList && ignoreList.includes(fileName)){
             console.log("File not added to staging area Ignored!!")
         }
@@ -56,37 +56,53 @@ async function addRepo(filePath){
         console.error("Failed to add file to staging area!! ",err)
     }
 }
-async function shouldIgnore(filename) {
-    
-    // Ignore specific files/folders
+async function shouldIgnore(filename, fullPath) {
+    // Check against ignore patterns
     if (ignoreList && ignoreList.includes(filename)) return true;
     
-    // Ignore hidden files (starting with .)
+    // Check if path contains ignored directories
+    if (ignoreList) {
+        for (const pattern of ignoreList) {
+            if (fullPath.includes(pattern)) return true;
+        }
+    }
+    
+    // Ignore hidden files
     if (filename.startsWith(".")) return true;
     
     return false;
 }
-async function addAllFiles(directory,stagingPath,baseDir=process.cwd()){
-    const items=await fs.readdir(directory);
-    let addedCount=0;
+async function addAllFiles(directory, stagingPath, baseDir=process.cwd()){
+    // Check if this directory itself should be ignored
+    const dirName = path.basename(directory);
+    const shouldSkip = await shouldIgnore(dirName, directory);
+    
+    if(shouldSkip) {
+        console.log(` X SKIPPING ${directory}`);
+        return 0;
+    }
+    
+    const items = await fs.readdir(directory);
+    let addedCount = 0;
     for(const item of items){
-        if(await shouldIgnore(item)) continue;
-        const fullPath=path.join(directory,item);
-        const stat=await fs.stat(fullPath);
+        const fullPath = path.join(directory, item);
+        if(await shouldIgnore(item, fullPath)) continue;
+        
+        const stat = await fs.stat(fullPath);
         if(stat.isDirectory()){
-            const count=await addAllFiles(fullPath,stagingPath);
-            addedCount+=count;
+            const count = await addAllFiles(fullPath, stagingPath, baseDir); // recursive call will check it
+            addedCount += count;
         }
-        else{
-            const relativePath=path.relative(baseDir,fullPath);
-            const destPath=path.join(stagingPath,relativePath);
-            await fs.mkdir(path.dirname(destPath),{recursive:true});
-            await fs.copyFile(fullPath,destPath);
+        else {
+            const relativePath = path.relative(baseDir, fullPath);
+            const destPath = path.join(stagingPath, relativePath);
+            await fs.mkdir(path.dirname(destPath), {recursive: true});
+            await fs.copyFile(fullPath, destPath);
             addedCount++;
             console.log(`added file ${relativePath}`);
         }
     }
-    if(directory==baseDir){
+    if(directory == baseDir){
         console.log(`Added ${addedCount} files to staging area`);
     }
     return addedCount;

package/Controllers/commitRepo.js

@@ -2,30 +2,82 @@ import fs from "fs/promises"
 import path from "path"
 import { v5 as uuidv5 } from 'uuid';
 import dotenv from "dotenv"
+import { diffLines } from "./diffLines.js";
 dotenv.config();
-function generateCommitID(message) {
-    return uuidv5(message, process.env.MY_NAMESPACE);
+
+function generateCommitID(message, parent) {
+    const unique = message + (parent || "") + Date.now();
+    return uuidv5(unique, process.env.MY_NAMESPACE);
 }
-async function commitRepo(message){
-    const repoPath=path.resolve(process.cwd(),".myvcs");
-    const commitPath=path.resolve(repoPath,"commits");
-    const stagedPath=path.resolve(repoPath,"staging");
-    const commitId=generateCommitID(message);
-    const thisCommitPath=path.resolve(path.join(commitPath,commitId));
-    const commitsJsonPath = path.join(commitPath, "commits.json");
-    try{
-        await fs.mkdir(commitPath,{recursive:true});
-        await fs.mkdir(thisCommitPath,{recursive:true});
-        const files=await fs.readdir(stagedPath);
-        for(const file of files){
-            await fs.copyFile(path.join(stagedPath,file),path.join(thisCommitPath,file));
+
+async function processFiles(stagedPath, thisCommitPath, commitPath, parent, diffs, baseDir = stagedPath) {
+    const items = await fs.readdir(stagedPath);
+    
+    for (const item of items) {
+        const sourcePath = path.join(stagedPath, item);
+        const stat = await fs.stat(sourcePath);
+        
+        if (stat.isDirectory()) {
+            // Recurse into subdirectory
+            const destDir = path.join(thisCommitPath, path.relative(baseDir, sourcePath));
+            await fs.mkdir(destDir, { recursive: true });
+            await processFiles(sourcePath, thisCommitPath, commitPath, parent, diffs, baseDir);
+        } else {
+            // Process file
+            const relativePath = path.relative(baseDir, sourcePath);
+            const newContent = await fs.readFile(sourcePath, "utf-8");
+            
+            let oldContent = "";
+            if (parent) {
+                const parentSnapshotPath = path.join(commitPath, parent, relativePath);
+                try {
+                    oldContent = await fs.readFile(parentSnapshotPath, "utf-8");
+                } catch {
+                    oldContent = "";
+                }
+            }
+            
+            const diff = diffLines(oldContent, newContent);
+            diffs[relativePath] = diff;
+            
+            // Copy file to commit snapshot
+            const destPath = path.join(thisCommitPath, relativePath);
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.copyFile(sourcePath, destPath);
         }
-       let commits = [];
+    }
+}
+
+async function commitRepo(message) {
+    const repoPath = path.resolve(process.cwd(), ".myvcs");
+    const headPath = path.join(repoPath, "HEAD");
+    const commitPath = path.resolve(repoPath, "commits");
+    const stagedPath = path.resolve(repoPath, "staging");
+    const commitsJsonPath = path.join(commitPath, "commits.json");
+    
+    let parent = null;
+    try {
+        parent = (await fs.readFile(headPath, "utf-8")).trim() || null;
+    } catch {
+        parent = null;
+    }
+    
+    const diffs = {};
+    const commitId = generateCommitID(message, parent);
+    const thisCommitPath = path.resolve(path.join(commitPath, commitId));
+    
+    try {
+        await fs.mkdir(commitPath, { recursive: true });
+        await fs.mkdir(thisCommitPath, { recursive: true });
+        
+        // Process all files recursively
+        await processFiles(stagedPath, thisCommitPath, commitPath, parent, diffs);
+        
+        let commits = [];
         try {
             const data = await fs.readFile(commitsJsonPath, 'utf-8');
             commits = JSON.parse(data);
         } catch (err) {
-            // File doesn't exist yet, start with empty array
             if (err.code !== 'ENOENT') throw err;
         }
         
@@ -33,17 +85,19 @@ async function commitRepo(message){
         commits.push({
             commitId,
             message,
-            date: new Date().toISOString()
+            date: new Date().toISOString(),
+            parent
         });
         
         // Write back to file
+        const diffsPath = path.join(thisCommitPath, "diffs.json");
+        await fs.writeFile(diffsPath, JSON.stringify(diffs, null, 2));
         await fs.writeFile(commitsJsonPath, JSON.stringify(commits, null, 2));
+        await fs.writeFile(headPath, commitId);
         console.log(`commit done ${commitId} with message ${message}`);
-    }catch(err){
-        console.error("Commit failed!! ",err);
+    } catch (err) {
+        console.error("Commit failed!! ", err);
     }
-    
-
 }
 
-export {commitRepo}
+export { commitRepo }

package/Controllers/config.js

@@ -1,5 +1,4 @@
 import {readConfig,setConfigValue} from "../config/vcsConfig.js"
-
 export function showConfig(){
     try{
         const config=readConfig();
@@ -16,14 +15,14 @@ export function showConfig(){
     }
 }
 
-export function setConfig(key,value){
+export async function setConfig(key,value){
     try{
         const validKeys=["username","email"];
         if(!validKeys.includes(key)){
             console.log(`Invalid Config Key ${key}`);
             process.exit(1);
         }
-        if(key=="username"){
+        if(key==="username"){
             if(!/^[a-zA-Z0-9_-]+$/.test(value)){
                 console.log("username must only contain letters,underscores and hyphen");
                 process.exit(1);

package/Controllers/diffLines.js

@@ -0,0 +1,41 @@
+function lcs(a,b){
+    const m=a.length,n=b.length;
+    const dp=Array.from({length:m+1},()=>Array(n+1).fill(0));
+
+    for(let i=1;i<m;i++){
+        for(let j=1;j<n;j++){
+            if(a[i-1]===b[j-1]){
+                dp[i][j]=dp[i-1][j-1]+1;
+            }
+            else dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
+        }
+    }
+
+    return dp;
+}
+function backtrack(dp,a,b,i,j){
+    if(i===0 && j==0) return [];
+    if(i>0 && j>0 && a[i-1]===b[j-1]){
+        const result=backtrack(dp,a,b,i-1,j-1);
+        result.push({type:"same",line:a[i-1]});
+        return result;
+    }
+    else if(j>0 && (i==0||dp[i][j-1]>=dp[i-1][j])){
+        const result=backtrack(dp,a,b,i,j-1);
+        result.push({type:"added",line:b[j-1]});
+        return result;
+    }
+    else{
+        const result=backtrack(dp,a,b,i-1,j);
+        result.push({type:"removed",line:a[i-1]});
+        return result;
+    }
+}
+function diffLines(oldContent,newContent){
+    const a = oldContent.split("\n").filter(line => line.length > 0); 
+    const b = newContent.split("\n").filter(line => line.length > 0); 
+    const dp=lcs(a,b);
+    return backtrack(dp,a,b,a.length,b.length);
+}
+
+export {diffLines}

package/Controllers/initRepo.js

@@ -10,6 +10,7 @@ async function initRepo(){
     try{
         await fs.mkdir(repoPath,{recursive:true});
         await fs.mkdir(commitPath,{recursive:true});
+        await fs.writeFile(path.join(repoPath, "HEAD"), "");
         await fs.writeFile(
             path.join(repoPath,"config.json"),
             JSON.stringify({bucket:process.env.S3_BUCKET})

package/Controllers/pullRepo.js

@@ -1,64 +1,89 @@
 import fs from "fs/promises"
 import path from "path"
-import {S3,S3_BUCKET} from "../config/aws-config.js"
-import {getUsername,getConfigValue} from "../config/vcsConfig.js"
-async function pullRepo(){
-    const repoPath=path.resolve(process.cwd(),".myvcs");
-    const commitsPath=path.resolve(repoPath,"commits");
-    const username=getUsername();
-    const repoName=getConfigValue("repoName");
-    try{
-        const data = await S3.listObjectsV2({
-            Bucket:S3_BUCKET,
-            Prefix:`commits/${username}/${repoName}`
-        }).promise();
-        const objects=data.Contents;
-        console.log(`Found ${objects.length} files to pull`);
-        for(const object of objects){
-            const key=object.Key;
-            console.log(key);
-            // Remove 'commits/' prefix to get relative path
-            const relativePath = key.replace('commits/', ''); // e.g., 'a0f0a67b.../hello.txt'
-            const localFilePath = path.join(commitsPath, relativePath);
-            // Create parent directory if needed
-            const localDir = path.dirname(localFilePath);
-            await fs.mkdir(localDir, {recursive: true});
-            const  params={
-                Bucket: S3_BUCKET,
-                Key:key
-            }
-            const fileContent=await S3.getObject(params).promise();
-            await fs.writeFile(localFilePath,fileContent.Body);
-            console.log(`Downloaded: ${relativePath}`);
+import { S3, S3_BUCKET } from "../config/aws-config.js"
+import { getUsername, getConfigValue } from "../config/vcsConfig.js"
+
+async function pullRepo() {
+    const repoPath = path.resolve(process.cwd(), ".myvcs");
+    const commitsPath = path.resolve(repoPath, "commits");
+    const commitsJsonPath = path.join(commitsPath, "commits.json");
+    const headPath = path.join(repoPath, "HEAD");
+    const username = getUsername();
+    const repoName = getConfigValue("repoName");
+    
+    try {
+        // Download repo payload from S3
+        const params = {
+            Bucket: S3_BUCKET,
+            Key: `repos/${username}/${repoName}/repo.json`
+        };
+        
+        const data = await S3.getObject(params).promise();
+        const payload = JSON.parse(data.Body.toString());
+        
+        // Read local commits
+        let localCommits = [];
+        try {
+            const localData = await fs.readFile(commitsJsonPath, "utf-8");
+            localCommits = JSON.parse(localData);
+        } catch {
+            localCommits = [];
         }
-        console.log("Pulled all commits");
-        const commitsJsonPath=path.resolve(commitsPath,"commits.json");
-        const commitsData=await fs.readFile(commitsJsonPath,'utf-8');
-        const commits=JSON.parse(commitsData);
-        if(commits.length==0){
-            console.log("No commits to Restore");
+        
+        const localHashes = new Set(localCommits.map(c => c.commitId));
+        
+        // Find new commits
+        const newCommits = payload.commits.filter(c => !localHashes.has(c.commitId));
+        
+        if (newCommits.length === 0) {
+            console.log("✓ Already up to date");
             return;
         }
-        const latestCommit=commits[commits.length-1];
-        const latestCommitId=latestCommit.commitId;
-        const latestPathCommit=path.join(commitsPath,latestCommitId);
-
-        console.log(`Restoring files from commit: ${latestCommitId}`);
-        console.log(`Message: ${latestCommit.message}`);
-
-        const files=await fs.readdir(latestPathCommit);
-
-        for(const file of files){
-            const sourcePath=path.join(latestPathCommit,file);
-            const destPath=path.join(process.cwd(),file);
-
-            await fs.copyFile(sourcePath,destPath);
-            console.log(`Restored ${file} \n`);
+        
+        console.log(`Pulling ${newCommits.length} commit(s)...`);
+        
+        // Apply new commits
+        for (const commit of newCommits) {
+            const commitDir = path.join(commitsPath, commit.commitId);
+            await fs.mkdir(commitDir, { recursive: true });
+            
+            // Write snapshot files
+            const snapshot = payload.snapshots[commit.commitId] || {};
+            for (const [filePath, content] of Object.entries(snapshot)) {
+                const destPath = path.join(commitDir, filePath);
+                await fs.mkdir(path.dirname(destPath), { recursive: true });
+                await fs.writeFile(destPath, content, "utf-8");
+            }
+            
+            // Write diffs
+            const diff = payload.diffs[commit.commitId] || {};
+            const diffsPath = path.join(commitDir, "diffs.json");
+            await fs.writeFile(diffsPath, JSON.stringify(diff, null, 2));
+            
+            console.log(`Applied [${commit.commitId.slice(0, 7)}] ${commit.message}`);
         }
-
-    }catch(err){
-        console.log("Error pulling from S3!! ",err);
+        
+        // Update commits.json
+        const allCommits = [...localCommits, ...newCommits];
+        await fs.writeFile(commitsJsonPath, JSON.stringify(allCommits, null, 2));
+        
+        // Update HEAD
+        await fs.writeFile(headPath, payload.head);
+        
+        // Restore working files from latest commit
+        const latestSnapshot = payload.snapshots[payload.head] || {};
+        for (const [filePath, content] of Object.entries(latestSnapshot)) {
+            const destPath = path.join(process.cwd(), filePath);
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            await fs.writeFile(destPath, content, "utf-8");
+        }
+        
+        console.log(`Pulled ${newCommits.length} commit(s)`);
+        console.log(`HEAD -> ${payload.head.slice(0, 7)}`);
+        
+    } catch (err) {
+        console.error("Pull failed:", err);
     }
 }
 
-export {pullRepo}
+export { pullRepo }

package/Controllers/pushRepo.js

@@ -1,49 +1,136 @@
 import fs from "fs/promises"
 import path from "path"
-import {S3,S3_BUCKET} from "../config/aws-config.js"
-import {getUsername,getConfigValue} from "../config/vcsConfig.js"
-async function pushRepo(){
-    const repoPath=path.resolve(process.cwd(),".myvcs");
-    const commitsPath=path.resolve(repoPath,"commits");
-    const username=getUsername();
-    const repoName=getConfigValue("repoName");
-    try{
-        const commitDirs=await fs.readdir(commitsPath);
-        console.log(commitDirs);
-        for(const dir of commitDirs){
-            const dirPath=path.join(commitsPath,dir);
-            // CHECK IF IT'S A DIRECTORY FIRST
-            const stats = await fs.stat(dirPath);
-           if(!stats.isDirectory()){
-                // If it's commits.json, upload it separately
-                if(dir === 'commits.json'){
-                    const fileContent = await fs.readFile(dirPath);
-                    const params = {
-                        Bucket: S3_BUCKET,
-                        Key: `commits/${username}/${repoName}/commits.json`,
-                        Body: fileContent
-                    };
-                    await S3.upload(params).promise();
-                    console.log('commits.json uploaded to S3');
-                }
-                continue; // Skip to next item
+import { S3, S3_BUCKET } from "../config/aws-config.js"
+import { getUsername, getConfigValue } from "../config/vcsConfig.js"
+import repoModel from "../models/repoModel.js"
+import userModel from "../models/userModel.js"
+
+async function pushRepo() {
+    const repoPath = path.resolve(process.cwd(), ".myvcs");
+    const commitsPath = path.resolve(repoPath, "commits");
+    const commitsJsonPath = path.join(commitsPath, "commits.json");
+    const headPath = path.join(repoPath, "HEAD");
+    const username = getUsername();
+    const repoName = getConfigValue("repoName");
+    
+    try {
+        // Read commits metadata
+        const commitsData = await fs.readFile(commitsJsonPath, "utf-8");
+        const commits = JSON.parse(commitsData);
+        
+        if (commits.length === 0) {
+            console.log("No commits to push");
+            return;
+        }
+        
+        // Read HEAD
+        const head = (await fs.readFile(headPath, "utf-8")).trim();
+        
+        // Create S3 key
+        const s3Key = `repos/${username}/${repoName}/repo.json`;
+        
+        // Check if repo exists in MongoDB, create if not
+        const existingRepo = await repoModel.findOne({ name: repoName }); 
+        
+        if (!existingRepo) {
+            const existingUser = await userModel.findOne({ email: username }); 
+            
+            if (!existingUser) {
+                throw new Error("User not found. Please register first.");
             }
-            const files=await fs.readdir(dirPath);
-            for(const file of files){
-                const filePath=path.join(dirPath,file);
-                const fileContent=await fs.readFile(filePath);
-                const params={
-                    Bucket:S3_BUCKET,
-                    Key:`commits/${username}/${repoName}/${dir}/${file}`,
-                    Body:fileContent
-                }
-                await S3.upload(params).promise();
+            
+            const newRepo = new repoModel({
+                name: repoName,
+                visibility: false,
+                owner: existingUser._id,
+                s3Key: s3Key, 
+                lastCommitHash: head,
+                totalCommits: commits.length
+            });
+            
+            await newRepo.save();
+            console.log(`Created new repo: ${repoName}`);
+        } else {
+            // Update existing repo metadata
+            const latestCommit = commits[commits.length - 1];
+            existingRepo.s3Key = s3Key;
+            existingRepo.lastCommitHash = head;
+            existingRepo.lastCommitMessage = latestCommit.message;
+            existingRepo.lastCommitDate = new Date(latestCommit.date);
+            existingRepo.totalCommits = commits.length;
+            await existingRepo.save();
+        }
+        
+        // Bundle all commit snapshots and diffs
+        const snapshots = {};
+        const diffs = {};
+        
+        for (const commit of commits) {
+            const commitDir = path.join(commitsPath, commit.commitId);
+            
+            // Read snapshot files recursively
+            snapshots[commit.commitId] = await readCommitFiles(commitDir);
+            
+            // Read diffs
+            const diffsPath = path.join(commitDir, "diffs.json");
+            try {
+                const diffData = await fs.readFile(diffsPath, "utf-8");
+                diffs[commit.commitId] = JSON.parse(diffData);
+            } catch {
+                diffs[commit.commitId] = {};
             }
         }
-        console.log("All commits pushed to myVCS")
-    }catch(err){
-        console.error("Error in pushing code to GitHub!!",err);
+        
+        // Create payload
+        const payload = {
+            repoName,
+            username,
+            pushedAt: new Date().toISOString(),
+            head,
+            commits,
+            snapshots,
+            diffs
+        };
+        
+        // Upload as single JSON file
+        const params = {
+            Bucket: S3_BUCKET,
+            Key: s3Key,
+            Body: JSON.stringify(payload, null, 2),
+            ContentType: "application/json"
+        };
+        
+        await S3.upload(params).promise();
+        console.log(`✓ Pushed ${commits.length} commit(s) to S3`);
+        console.log(`  HEAD → ${head.slice(0, 7)}`);
+        
+    } catch (err) {
+        console.error("Push failed:", err);
+        throw err; // re-throw so withDB can handle cleanup
+    }
+}
+
+async function readCommitFiles(commitDir, baseDir = commitDir) {
+    const files = {};
+    const items = await fs.readdir(commitDir);
+    
+    for (const item of items) {
+        if (item === "diffs.json") continue;
+        
+        const fullPath = path.join(commitDir, item);
+        const stat = await fs.stat(fullPath);
+        
+        if (stat.isDirectory()) {
+            const nested = await readCommitFiles(fullPath, baseDir);
+            Object.assign(files, nested);
+        } else {
+            const relativePath = path.relative(baseDir, fullPath);
+            const content = await fs.readFile(fullPath, "utf-8");
+            files[relativePath] = content;
+        }
     }
+    
+    return files;
 }
 
-export {pushRepo}
+export { pushRepo }

package/Controllers/revertRepo.js

@@ -1,23 +1,56 @@
 import fs from "fs/promises"
 import path from "path"
-
-async function revertRepo(commitID){
-    const repoPath=path.resolve(process.cwd(),".myvcs");
-    const commitPath=path.resolve(repoPath,"commits");
-    const thisCommit=path.join(commitPath,commitID);
-    const parentDir=path.resolve(repoPath,"..");
-    try{
-        const files=await fs.readdir(thisCommit);
-
-        for(const file of files){
-            await fs.copyFile(path.join(thisCommit,file),path.join(parentDir,file));
+import {addRepo} from "./addRepo.js"
+import { commitRepo } from "./commitRepo.js"
+async function applyInverseDiff(diff, filePath) {
+    const invertedLines = [];
+    
+    for(const d of diff) {
+        if(d.type === "same") {
+            invertedLines.push(d.line);  // keep it
         }
-
-        console.log(`Reverted to commitId:${commitID} successfully!!`);
-    }
-    catch(err){
-        console.log("Unable to Revert!! ",err);
+        else if(d.type === "removed") {
+            invertedLines.push(d.line);  // it was removed, bring it back
+        }
+        // skip "added" 
     }
+    
+    const content = invertedLines.join("\n");
+    await fs.writeFile(filePath, content);
 }
 
+async function revertRepo(commitID) {
+    const repoPath = path.resolve(process.cwd(), ".myvcs");
+    const commitPath = path.resolve(repoPath, "commits");
+    const diffsPath = path.join(commitPath, commitID, "diffs.json"); 
+    const commitJSON = path.join(commitPath, "commits.json");
+    
+    try {
+        // Read diffs
+        const diffs = JSON.parse(await fs.readFile(diffsPath, "utf-8"));
+        
+        // Read original commit message
+        const commits = JSON.parse(await fs.readFile(commitJSON, "utf-8"));
+        const originalCommit = commits.find(c => c.commitId === commitID);
+        
+        if (!originalCommit) {
+            console.error(`Commit ${commitID} not found`);
+            return;
+        }
+        
+        // Apply inverse diffs and stage files
+        for (const [file, diff] of Object.entries(diffs)) {
+            const filePath = path.join(process.cwd(), file);
+            await applyInverseDiff(diff, filePath);
+            await addRepo(filePath); 
+        }
+        
+        // Create revert commit
+        await commitRepo(`Revert: ${originalCommit.message}`);
+        
+        console.log(`Reverted commit ${commitID} successfully!`);
+    } catch (err) {
+        console.error("Unable to revert:", err);
+    }
+}
 export {revertRepo}

package/Controllers/specificCommit.js

@@ -0,0 +1,16 @@
+import path from "path"
+import fs from "fs/promises"
+async function showSpecificCommit(commitId) {
+    const repoPath=path.resolve(process.cwd(),".myvcs");
+    const commitsPath=path.join(repoPath,"commits");
+    const diffsPath = path.join(commitsPath, commitId, "diffs.json");
+    const diffs = JSON.parse(await fs.readFile(diffsPath, "utf-8"));
+    for(const [file, diff] of Object.entries(diffs)) {
+        console.log(`\n${file}:`);
+        for(const line of diff) {
+            if(line.type === "added") console.log(`+ ${line.line}`);
+            if(line.type === "removed") console.log(`- ${line.line}`);
+        }
+    }
+}
+export {showSpecificCommit}

package/README.md

@@ -8,6 +8,16 @@ npm install -g myvcs
 ```
 
 ## Setup
+Create a .env file in your project:
+
+AWS_ACCESS_KEY_ID=...
+AWS_SECRET_ACCESS_KEY=...
+S3_BUCKET=...
+MY_NAMESPACE=...
+
+Then run:
+
+myvcs init
 ```
 Initialize a repository:
 ```bash

package/config/aws-config.js

@@ -7,7 +7,7 @@ aws.config.update({
 });
 
 const S3=new aws.S3();
-const S3_BUCKET="amzn-777";
+const S3_BUCKET=process.env.S3_BUCKET;
 
 export {S3,S3_BUCKET}
 

package/config/vcsConfig.js

@@ -1,6 +1,5 @@
 import fs from "fs"
 import path from "path"
-
 function getConfigPath(){
     return path.join(process.cwd(),".myvcs","config.json");
 }
@@ -8,7 +7,6 @@ function configDirExists(){
     const configDir=path.join(process.cwd(),".myvcs");
     return fs.existsSync(configDir);
 }
-
 function initConfig(){
     const defaultConfig={
         "username":null,
@@ -50,7 +48,7 @@ function writeConfig(config){
         throw new Error("Not a myvcs repository. Run 'myvcs init' first.")
     }
 }
-function setConfigValue(key,value){
+async function setConfigValue(key,value){
     const config=readConfig();
     config[key]=value;
     writeConfig(config);
@@ -61,11 +59,11 @@ function getConfigValue(key) {
     return config[key];
 }
 function getUsername(){
-    const username=getConfigValue("username");
+    const username=getConfigValue("email");
     if(!username){
         throw new Error(
-            "Username not configured. Please set your username with:\n" +
-            "  myvcs config set username <your-username>"
+            "Username not configured. Please set your email with:\n" +
+            "  myvcs config set email <your-registered-mail>"
         );
     }
     return username;

package/index.js

@@ -9,8 +9,24 @@ import { pullRepo } from "./Controllers/pullRepo.js";
 import {revertRepo} from "./Controllers/revertRepo.js"
 import {showCommits} from "./Controllers/showCommits.js"
 import {showConfig,setConfig} from "./Controllers/config.js"
+import { showSpecificCommit } from "./Controllers/specificCommit.js";
+import { connectDB, disconnectDB } from "./utils/db.js";
+
 yargs(hideBin(process.argv))
-.command("init","initialise a new repository",{},initRepo)
+.command("init","initialise a new repository",{},
+    async ()=>{
+        try{
+            await connectDB();
+            await initRepo()
+        }
+        catch(e){
+            console.log('ERROR:',e);
+        }
+        finally{
+            await disconnectDB();
+        }
+    }
+)
 .command("add <file>","Add a file to repo/staging area use 'add .' to add all files",
     (yargs)=>{
         yargs.positional("file",{
@@ -28,11 +44,26 @@ yargs(hideBin(process.argv))
             type:"string"
         })
     },
-    (argv)=>{
-        commitRepo(argv.message);
+    async (argv)=>{
+        await commitRepo(argv.message);
+    }
+)
+.command("push","push commits to cloud storage",{},
+    async ()=>{
+        try{
+            await connectDB();
+            pushRepo();
+        }
+        catch(e){
+            console.log('ERROR:',e);
+        }
+        finally{
+            await disconnectDB();
+        }
     }
+    
+    
 )
-.command("push","push commits to cloud storage",{},pushRepo)
 .command("pull","pull commits from cloud to local system",{},pullRepo)
 .command("revert <commitID>","revert back to specified commitID",
     (yargs)=>{
@@ -41,11 +72,22 @@ yargs(hideBin(process.argv))
             type:"string"
         })
     },
-    (argv)=>{
-        revertRepo(argv.commitID);
+    async (argv)=>{
+        await revertRepo(argv.commitID);
     }
 )
 .command("list commits","show all commmits",{},showCommits)
+.command("show <commitID>","show specific CommitID",
+    (yargs)=>{
+        yargs.positional("commitID",{
+            describe:"commitID to revert",
+            type:"string"
+        })
+    }
+    ,async (argv)=>{
+        await showSpecificCommit(argv.commitID);
+    }
+)
 .command("config","configure myVCS on your system",
     (yargs)=>{
         return yargs
@@ -61,8 +103,18 @@ yargs(hideBin(process.argv))
                         type:"string"
                     })
                 },
-                (argv)=>{
-                    setConfig(argv.key,argv.value);
+                async (argv)=>{
+                    try{
+                        await connectDB();
+                        await setConfig(argv.key,argv.value);
+                    }
+                    catch(e){
+                        console.log('Error while configuring:',e);
+                    }
+                    finally{
+                        await disconnectDB();
+                        process.exit(0);
+                    }
                 }
             )
             .command("list","show config details",{},showConfig)

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "myvcs",
-  "version": "0.1.0",
+  "version": "1.1.2",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": ["vcs", "version-control", "git", "s3", "cloud-storage"],
+  "keywords": [
+    "vcs",
+    "version-control",
+    "git",
+    "s3",
+    "cloud-storage"
+  ],
   "type": "module",
   "author": "Amarnath Vasanth amarnathvasanth39@gmail.com",
   "license": "ISC",
@@ -15,11 +21,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/myvcs.git"
+    "url": "https://github.com/amar1009/VCStool.git"
   },
   "dependencies": {
     "aws-sdk": "^2.1693.0",
     "dotenv": "^17.2.3",
+    "mongoose": "^9.2.2",
     "uuid": "^13.0.0",
     "yargs": "^18.0.0"
   }

package/utils/db.js

@@ -0,0 +1,11 @@
+import mongoose from 'mongoose';
+
+export async function connectDB() {
+  if (mongoose.connection.readyState === 0) {
+    await mongoose.connect(process.env.MONGO_URI);
+  }
+}
+
+export async function disconnectDB() {
+  await mongoose.disconnect();
+}