codehub-ghx-cli 1.0.2 → 1.0.3

package/commands/add.js

@@ -1,19 +1,83 @@
+
+
 const fs = require("fs").promises;
+const fssync = require("fs");
 const path = require("path");
 
+async function copyRecursive(src, dest) {
+    const stats = fssync.statSync(src);
+
+    if (stats.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+        const items = await fs.readdir(src);
+
+        for (const item of items) {
+            const srcItem = path.join(src, item);
+            const destItem = path.join(dest, item);
+            await copyRecursive(srcItem, destItem);
+        }
+    } else {
+        await fs.copyFile(src, dest);  
+    }
+}
 
 async function addRepo(filepath) {
-    const repoPath = path.resolve(process.cwd(),".codehub");
+    const repoPath = path.resolve(process.cwd(), ".codehub");
     const stagingPath = path.join(repoPath, "staging");
+    const ROOT_IGNORE = [".env", "node_modules", ".codehub", ".git"];
+
 
     try {
-        await fs.mkdir(stagingPath, {recursive: true});
+        await fs.access(repoPath);
+        await fs.mkdir(stagingPath, { recursive: true });
+
+        if(filepath === "." || filepath === "./"){
+            const currentDir = process.cwd();
+            const items = await fs.readdir(currentDir);
+            for (const item of items) {
+                // if ([".codehub", "node_modules", ".git"].includes(item)) continue;
+                if (ROOT_IGNORE.includes(item)) {
+                        console.log(`Skipped ignored item: ${item}`);
+                        continue;
+                    }
+                const src = path.join(currentDir, item);
+                const dest = path.join(stagingPath, item);
+
+                const stats = fssync.statSync(src);
+
+                if (stats.isDirectory()) {
+                    await copyRecursive(src, dest);
+                } else {
+                    await fs.copyFile(src, dest);
+                }
+
+                console.log(`Added: ${item}`);
+            }
+
+            return;
+        }
+
         const fileName = path.basename(filepath);
-        await fs.copyFile(filepath, path.join(stagingPath, fileName));
-        console.log(`File ${fileName} added to staging area`);
+        if (ROOT_IGNORE.includes(fileName)) {
+                console.log(`Cannot add "${fileName}" — It is ignored for security reasons.`);
+                return;
+            }
+
+        const destination = path.join(stagingPath, fileName);
+
+        
+        const stats = fssync.statSync(filepath);
+
+        if (stats.isDirectory()) {
+            await copyRecursive(filepath, destination);
+        } else {
+            await fs.copyFile(filepath, destination);
+        }
+
+        console.log(`✅ Added: ${fileName}`);
     } catch (err) {
-        console.log("error adding file:", err);
+        console.log("❌ error adding file:", err);
     }
 }
 
-module.exports = {addRepo};
+module.exports = { addRepo };

package/commands/commit.js

@@ -1,25 +1,56 @@
 const fs = require("fs").promises;
 const path = require('path');
+const axios = require('axios');
 const {v4: uuidv4} = require("uuid");
+const fssync = require("fs");
+
+async function copyRecursive(src, dest) {
+    const stats = fssync.statSync(src);
+
+    if (stats.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+        const items = await fs.readdir(src);
+
+        for (const item of items) {
+            const srcItem = path.join(src, item);
+            const destItem = path.join(dest, item);
+            await copyRecursive(srcItem, destItem);
+        }
+    } else {
+        await fs.copyFile(src, dest);
+    }
+}
 
 
 async function commitRepo(message) {
     const repopath = path.resolve(process.cwd(), ".codehub");
     const stagedPath = path.join(repopath, "staging");
     const commitPath = path.join(repopath, "commits");
+    const configPath = path.join(repopath, "config.json");
 
     try {
+        const config = JSON.parse(await fs.readFile(configPath, "utf8"));
+        const repoId = config.repoId;
         const commitID = uuidv4();
         const commitDir = path.join(commitPath, commitID);
         await fs.mkdir(commitDir, {recursive: true});
 
         const files = await fs.readdir(stagedPath);
+        if (files.length === 0) {
+        console.log(" Nothing to commit. Run: ghx add <file>");
+        return;
+    }
         for(const file of files){
-            await fs.copyFile(
+            await copyRecursive(
                 path.join(stagedPath, file),
                 path.join(commitDir, file)
             );
         }
+
+        await axios.put(`http://localhost:3000/repo/update/${repoId}`, {
+                    message:message,
+                });
+
         await fs.writeFile(path.join(commitDir, "commit.json"),JSON.stringify({message, date:new Date().toISOString()}));
         console.log(`Commit ${commitID} created with message: ${message}`);
     } catch (err) {

package/commands/init.js

@@ -1,22 +1,46 @@
+
 const fs = require("fs").promises;
 const path = require("path");
 
 
-async function initRepo(){
+async function initRepo(repoLink) {
+
+    function extractRepoId(repoLink) {
+  const url = new URL(repoLink);
+  return url.searchParams.get("repoId");
+}
+
     const repoPath = path.resolve(process.cwd(), ".codehub");
     const commitsPath = path.join(repoPath, "commits");
 
     try {
-        await fs.mkdir(repoPath, {recursive: true});
-        await fs.mkdir(commitsPath, {recursive: true});
+        await fs.mkdir(repoPath, { recursive: true });
+        await fs.mkdir(commitsPath, { recursive: true });
+
+        const repoId = extractRepoId(repoLink);
+    
+    if (!repoId) {
+        console.error("repoId missing in clone URL!");
+        return;
+    }
+
         await fs.writeFile(
             path.join(repoPath, "config.json"),
-            JSON.stringify({ bucket: process.env.S3_BUCKET})
+            JSON.stringify({
+                bucket: process.env.S3_BUCKET,
+                repoLink,
+                repoId
+            })
         );
+
         console.log("Repository initialized!");
+        console.log("Repo ID saved:", repoId);
+
+        if (repoLink) console.log("Linked to:", repoLink);
+
     } catch (error) {
-        console.error("Error initialising repository", error);
+        console.error("Error initializing repository", error);
     }
 }
- 
-module.exports = { initRepo};
+
+module.exports = { initRepo };

package/commands/push.js

@@ -1,34 +1,202 @@
+
+
+// ghx-cli/commands/push.js
 const fs = require("fs").promises;
-const path = require('path');
-// const {s3, s3_BUCKET} = require('../config/aws-config');
-const {s3, s3_BUCKET} = require('../config/aws-config');
+const fssync = require("fs");
+const path = require("path");
+const axios = require("axios");
+const mongoose = require('mongoose');
+const { s3, s3_BUCKET } = require("../config/aws-config");
+const PushLog = require('../../models/pushModel');
+require('dotenv').config;
+
+
+async function connectDB(){
+    const mongoURI = process.env.MONGODB_URI;
+        mongoose.connect(mongoURI)
+        .then(()=>console.log("push date saved"))
+        .catch((err)=>console.error("Unable to connect",err));
+}
+
+
+
+// uploadRecursive:
+
+async function uploadRecursive(localPath, baseDir, commitId, collectedFiles) {
+
+    const relative = path.relative(baseDir, localPath).replace(/\\/g, "/");
+
+    if (relative !== "") {
+        collectedFiles.push({
+            filename: path.basename(localPath),
+            commit: commitId,
+            path: `repo/${commitId}/${relative}`,
+            folder: path.dirname(relative).replace(/\\/g, "/"),
+            fullS3Path: `repo/${commitId}/${relative}`,
+            fullPath: `repo/${commitId}/${relative}`,
+            isFolder: true
+        });
+    }
+
+
+    const stats = fssync.statSync(localPath);
 
+    if (stats.isDirectory()) {
+        const items = await fs.readdir(localPath);
+        for (const item of items) {
+            const itemLocal = path.join(localPath, item);
+            await uploadRecursive(itemLocal, baseDir, commitId, collectedFiles);
+        }
+    } else {
+        
+        const relative = path.relative(baseDir, localPath).replace(/\\/g, "/");
+
+        const cleanPath = relative.replace(/\\/g, "/");
+        // const s3Key = `commits/${commitId}/${relative}`; // canonical S3 key and DB path
+        const s3Key = `repo/${commitId}/${cleanPath}`;
+        const fileIdPath = cleanPath;
+        const fileContent = await fs.readFile(localPath);
+
+        // upload to S3 under canonical key
+        await s3.upload({
+            Bucket: s3_BUCKET,
+            Key: s3Key,
+            Body: fileContent
+        }).promise();
+
+        const filename = path.basename(localPath);
+        const folder = path.dirname(relative).replace(/\\/g, "/"); // relative folder inside commit
+
+        collectedFiles.push({
+            // filename,
+            // commit: commitId,
+            // // path: s3Key,      // canonical path saved to DB
+            // // folder: folder === "." ? "" : folder,
+            // // isFolder: false
+            // path: cleanPath,   // <-- canonical
+            // folder: folder === "." ? "" : folder,
+            // fullS3Path: s3Key,  // <-- actual file stored in S3
+            // fullPath: cleanPath,
+            // isFolder: false
+             filename,
+    commit: commitId,
+    path: s3Key,        // <--- ALWAYS THIS
+    folder: folder === "." ? "" : folder,
+    fullS3Path: s3Key,  // <--- ALWAYS THIS
+    fullPath: s3Key,    // <--- ALWAYS THIS
+    isFolder: false
+        });
+    }
+}
 
 async function pushRepo() {
-    const repopath = path.resolve(process.cwd(), ".codehub");
-    const commitsPath = path.join(repopath, "commits");
+    const repoPath = path.resolve(process.cwd(), ".codehub");
+    const commitsPath = path.join(repoPath, "commits");
+    const configPath = path.join(repoPath, "config.json");
 
     try {
+        const config = JSON.parse(await fs.readFile(configPath, "utf8"));
+        const repoId = config.repoId;
+
+        if (!repoId) {
+            console.log("❌ repoId missing in .codehub/config.json");
+            return;
+        }
+
+
         const commitDirs = await fs.readdir(commitsPath);
-        for(const commitDir of commitDirs){
-            const commitPath = path.join(commitsPath, commitDir);
-            const files = await fs.readdir(commitPath);
-
-            for(const file of files){
-                const filePath = path.join(commitPath, file);
-                const fileContent = await fs.readFile(filePath);
-                const params = {
-                    Bucket: s3_BUCKET,
-                    Key: `commits/${commitDir}/${file}`,
-                    Body: fileContent,
-                };
-                await s3.upload(params).promise();
-            }
+
+        if (commitDirs.length === 0) {
+            console.log("❌ No commits to push");
+            return;
+        }
+
+        const lastCommit = commitDirs[commitDirs.length - 1];
+        const metaFile = path.join(commitsPath, lastCommit, "commit.json");
+
+        let commitMessage = "No commit message";
+        if (fssync.existsSync(metaFile)) {
+            const metaData = JSON.parse(await fs.readFile(metaFile, "utf8"));
+            commitMessage = metaData.message;
+        }
+
+
+
+
+        // Fetch existing repo content so we can merge (and dedupe)
+        const dbRes = await axios.get(`http://localhost:3000/repo/id/${repoId}`);
+        // backend returns array; first element is repo object
+        const existing = (dbRes.data && dbRes.data[0] && dbRes.data[0].content) || [];
+
+        // map existing by path for fast overwrite
+        const contentMap = {};
+        existing.forEach(f => {
+            if (!f || !f.path) return;
+            contentMap[f.path] = f;
+        });
+
+        // const commitDirs = await fs.readdir(commitsPath);
+        let newFiles = [];
+
+        for (const commitId of commitDirs) {
+            const commitFolder = path.join(commitsPath, commitId);
+
+            // commitFolder may contain files/folders
+            await uploadRecursive(
+                commitFolder,
+                commitFolder, // baseDir
+                commitId,
+                newFiles
+            );
+        }
+
+        // merge/overwrite: newFiles wins
+        for (const f of newFiles) {
+
+            for (const existingPath in contentMap) {
+        const old = contentMap[existingPath];
+
+        // compare logical location (folder + filename)
+        if (old.filename === f.filename && old.folder === f.folder) {
+            delete contentMap[existingPath];
         }
-        console.log("All commits pushed to S3.")
-    } catch (error) {
-        console.error("Error pushing to s3:", error);
+    }
+
+
+            contentMap[f.path] = f;
+        }
+
+
+
+        
+        const finalFiles = Object.values(contentMap);
+
+        // push finalFiles to backend (replace content)
+        await axios.put(`http://localhost:3000/repo/update/${repoId}`, {
+            content: finalFiles,
+            message: commitMessage,
+            description: ""
+        });
+
+
+        await fs.rm(commitsPath, { recursive: true, force: true });
+        await fs.mkdir(commitsPath);
+        await connectDB();
+
+
+        console.log("✅ Push complete!");
+        // console.log("Using repoId:", repoId);
+
+        await PushLog.create({
+    repoId: repoId,
+    pushedAt: new Date()
+});
+
+        process.exit(0);
+    } catch (err) {
+        console.error("❌ Push error:", err);
+        process.exit(1);
     }
 }
 
-module.exports = {pushRepo};
+module.exports = { pushRepo };

package/commands/revert.js

@@ -1,30 +1,78 @@
-const fs = require("fs");
-const path = require('path');
-const { promisify } = require("util");
+// const fs = require("fs");
+// const path = require('path');
+// const { promisify } = require("util");
+// // const {s3, s3_BUCKET} = require('../config/aws-config');
 // const {s3, s3_BUCKET} = require('../config/aws-config');
-const {s3, s3_BUCKET} = require('../config/aws-config');
 
-const readdir = promisify(fs.readdir);
-const copyFile = promisify(fs.copyFile);
+// const readdir = promisify(fs.readdir);
+// const copyFile = promisify(fs.copyFile);
 
 
+// async function revertRepo(commitID) {
+//   const repopath = path.resolve(process.cwd(), ".codehub");
+//  const commitsPath = path.join(repopath, "commits");
+
+
+//  try {
+//     const commitDir = path.join(commitsPath, commitID);
+//     const files = await readdir(commitDir);
+//     const parentDir = path.resolve(repopath, "..");
+
+//     for(const file of files){
+//         await copyFile(path.join(commitDir, file), path.join(parentDir, file));
+//     }
+//     console.log(`Commit ${commitID} reverted successfully!`);
+//  } catch (err) {
+//     console.error("Unable to revert:", err);
+//  }
+// }
+
+// module.exports = {revertRepo};
+
+const fs = require("fs").promises;
+const fssync = require("fs");
+const path = require("path");
+
+async function copyRecursive(src, dest) {
+    const stats = fssync.statSync(src);
+
+    if (stats.isDirectory()) {
+        await fs.mkdir(dest, { recursive: true });
+
+        const items = await fs.readdir(src);
+        for (const item of items) {
+            const srcItem = path.join(src, item);
+            const destItem = path.join(dest, item);
+            await copyRecursive(srcItem, destItem);
+        }
+    } else {
+        await fs.copyFile(src, dest);
+    }
+}
+
 async function revertRepo(commitID) {
-  const repopath = path.resolve(process.cwd(), ".codehub");
- const commitsPath = path.join(repopath, "commits");
+    const repoPath = path.join(process.cwd(), ".codehub");
+    const commitsPath = path.join(repoPath, "commits");
+    const commitFolder = path.join(commitsPath, commitID);
 
+    // Ensure that commit exists
+    if (!fssync.existsSync(commitFolder)) {
+        console.log(`❌ Commit "${commitID}" not found.`);
+        return;
+    }
 
- try {
-    const commitDir = path.join(commitsPath, commitID);
-    const files = await readdir(commitDir);
-    const parentDir = path.resolve(repopath, "..");
+    console.log(`🔄 Reverting to commit: ${commitID}`);
 
-    for(const file of files){
-        await copyFile(path.join(commitDir, file), path.join(parentDir, file));
+    const items = await fs.readdir(commitFolder);
+
+    for (const item of items) {
+        const src = path.join(commitFolder, item);
+        const dest = path.join(process.cwd(), item);
+
+        await copyRecursive(src, dest);
     }
-    console.log(`Commit ${commitID} reverted successfully!`);
- } catch (err) {
-    console.error("Unable to revert:", err);
- }
+
+    console.log("✅ Revert complete! Project reset to the selected commit.");
 }
 
-module.exports = {revertRepo};
+module.exports = { revertRepo };

package/config/aws-config.js

@@ -0,0 +1,21 @@
+// const AWS = require("aws-sdk");
+
+// AWS.config.update({ region: "ap-south-1"});
+
+// const s3 = new AWS.S3();
+// const s3_BUCKET = "gitbuck";
+
+// module.exports = {s3, s3_BUCKET};
+const AWS = require("aws-sdk");
+require("dotenv").config();
+
+AWS.config.update({
+  accessKeyId: process.env.AWS_ACCESS_KEY,
+  secretAccessKey: process.env.AWS_SECRET_KEY,
+  region: "ap-south-1",
+});
+
+const s3 = new AWS.S3();
+const s3_BUCKET = process.env.S3_BUCKET;
+
+module.exports = { s3, s3_BUCKET };

package/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
+process.env.DOTENV_SILENT = "true";
+process.env.DOTENVX_SILENT = "true";
 
-// require("dotenv").config();
 const path = require("path");
 require("dotenv").config({
   path: path.join(__dirname, ".env")  
@@ -12,6 +13,7 @@ const { hideBin } = require("yargs/helpers");
 const { initRepo } = require("./commands/init");
 const { addRepo } = require("./commands/add");
 const { commitRepo } = require("./commands/commit");
+const mongoose = require('mongoose');
 const { pushRepo } = require("./commands/push");
 const { pullRepo } = require("./commands/pull");
 const { revertRepo } = require("./commands/revert");
@@ -20,11 +22,21 @@ yargs(hideBin(process.argv))
 
   // init
   .command(
-    "init",
+    "init <repoLink>",
     "Initialize a repository in the current folder",
-    () => {},
-    () => {
-      initRepo();
+    (yargs) => {
+      yargs
+      .positional("repoLink", {
+        type: "string",
+        describe: "Repository link from CodeHub"
+    })
+    // .positional("repoId",{
+    //       type: "string",
+    //       describe: "Repository ID from CodeHub backend"
+    //     });
+    },
+    (argv) => {
+      initRepo(argv.repoLink);
     }
   )
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehub-ghx-cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "",
   "main": "index.js",
   "bin": {