jvcs 1.6.9 → 1.7.3

package/controllers/add.js

@@ -1,4 +1,4 @@
-const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility")
+const { getGlobalConfig, checkforjvcs } = require("./utility")
 const path = require("path")
 const fssync = require("fs")
 const chalk = require("chalk")
@@ -15,7 +15,7 @@ async function getFileHash(filepath) {
 // load .jvcsignore file
 async function loadIgnorePatterns() {
     const ignorePath = path.join(process.cwd(), ".jvcsignore")
-    if(!fssync.existsSync(ignorePath)) return []
+    if (!fssync.existsSync(ignorePath)) return []
 
     const content = await fs.readFile(ignorePath, "utf-8")
     return content
@@ -61,26 +61,20 @@ async function addCmd(paths) {
 
     if (!paths || paths.length === 0) {
         console.log(chalk.yellow("Please specify files or folders to add."));
-        return
+        process.exit(1);
     }
 
-    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()
+    const 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
+        process.exit(1);
     }
 
     if (!checkforjvcs()) {
         console.log(chalk.red("Repository is not initialized or is deleted. Please create it."))
-        return
+        process.exit(1);
     }
 
     const repoPath = path.join(process.cwd(), ".jvcs")
@@ -99,6 +93,43 @@ async function addCmd(paths) {
     // load ignore patterns
     const ignorePatterns = await loadIgnorePatterns()
 
+    // -------------------------------------------------------------
+    // NEW: Handle Deletions sync before adding new files
+    // -------------------------------------------------------------
+    let deletionHandledFor = new Set();
+
+    for (const key of Object.keys(hashData)) {
+        const cwdPath = path.join(process.cwd(), key);
+
+        // Check if the staged file falls under any of the target paths
+        let isUnderTarget = false;
+        if (paths.length === 1 && paths[0] === ".") {
+            isUnderTarget = true;
+        } else {
+            for (const p of paths) {
+                const targetPath = path.resolve(process.cwd(), p);
+                const relToTarget = path.relative(targetPath, cwdPath);
+                // If it's the exact file or inside the target directory
+                if (relToTarget === "" || (!relToTarget.startsWith("..") && !path.isAbsolute(relToTarget))) {
+                    isUnderTarget = true;
+                    break;
+                }
+            }
+        }
+
+        if (isUnderTarget && !fssync.existsSync(cwdPath)) {
+            // File was deleted from working directory, remove it from staging
+            delete hashData[key];
+            const stagedTarget = path.join(staging, key);
+            if (fssync.existsSync(stagedTarget)) {
+                await fs.rm(stagedTarget);
+            }
+            console.log(chalk.red(`Removed deleted file: ${key}`));
+            deletionHandledFor.add(cwdPath);
+        }
+    }
+
+
     let targets = []
     if (paths.length === 1 && paths[0] === ".") {
         let rootEntries = await fs.readdir(process.cwd(), { withFileTypes: true })
@@ -114,7 +145,10 @@ async function addCmd(paths) {
         try {
 
             if (!fssync.existsSync(target)) {
-                console.log(chalk.red(`Path not found: ${target}`))
+                // Only warn if we didn't just handle its deletion
+                if (!deletionHandledFor.has(target)) {
+                    console.log(chalk.yellow(`Path not found: ${path.relative(process.cwd(), target)}`));
+                }
                 continue
             }
 
@@ -155,7 +189,7 @@ async function addCmd(paths) {
             }
         }
         catch (error) {
-            console.log(chalk.red(`Unexpected error: ${error.message}`));
+            console.log(chalk.red(`Unexpected error processing ${target}: ${error.message}`));
         }
     }
 

package/controllers/begin.js

@@ -10,14 +10,24 @@ const fs = require("fs")
 
 async function beginCmd() {
 
-    const config = path.join(require("os").homedir(),".jvcs","config.json")
+    const config = path.join(require("os").homedir(), ".jvcs", "config.json")
     let isInitialized = false
     let configData = null
-    if(fs.existsSync(config)) {
-        isInitialized = true
-        configData = JSON.parse(fs.readFileSync(config,"utf-8"))
+    if (fs.existsSync(config)) {
+        try {
+            configData = JSON.parse(fs.readFileSync(config, "utf-8"))
+            isInitialized = true
+        }
+        catch (error) {
+            // corrupted file, delete it and force re-login
+            try {
+                fs.unlinkSync(config)
+            }
+            catch (e) { }
+            isInitialized = false
+        }
     }
-    
+
     if (isInitialized) {
         console.log(chalk.green(`You are already logged in as ${configData.username} (${configData.email})`))
         console.log(chalk.yellow(`[1] Continue \n[2] Logout \nChoose an option (1/2) : `))
@@ -38,14 +48,20 @@ async function beginCmd() {
             }
         ])
 
-        console.log(`Your choice was ${answer.choice}`)
         if (answer.choice === "1") {
             console.log(chalk.green("Continuing as current user..."))
             console.log(chalk.green("jvcs --help for help"))
         }
         else {
             console.log(chalk.green("logging out..."))
-            fs.unlinkSync(config)
+            try {
+                if (fs.existsSync(config)) {
+                    fs.unlinkSync(config)
+                }
+            }
+            catch (error) {
+                console.log(chalk.yellow("Warning: Could not remove config file properly."));
+            }
             console.log(chalk.green("Logged out Successfully"))
             console.log(chalk.green("Please login or signup again (jvcs begin) to use version control system"))
             console.log(chalk.green("jvcs --help for help"))
@@ -80,6 +96,14 @@ async function beginCmd() {
             {
                 type: 'input',
                 name: 'username',
+                validate: function (input) {
+                    // Ensure no spaces or weird special characters in username
+                    if (!/^[a-zA-Z0-9_]+$/.test(input)) {
+                        return "Username can only contain alphanumeric characters and underscores";
+                    }
+                    if (input.length < 3) return "Username must be at least 3 characters long";
+                    return true;
+                },
                 filter: function (input) {
                     return input.trim()
                 }
@@ -139,6 +163,7 @@ async function beginCmd() {
         }
         catch (error) {
             console.log(chalk.red(error))
+            process.exit(1);
         }
     }
     else {
@@ -194,6 +219,7 @@ async function beginCmd() {
         }
         catch (error) {
             console.log(chalk.red(error))
+            process.exit(1);
         }
     }
 }

package/controllers/init.js

@@ -6,16 +6,16 @@ const { getGlobalConfig, checkGlobalConfig } = require("./utility")
 
 async function initCmd() {
 
-    if(!checkGlobalConfig()) {
+    if (!checkGlobalConfig()) {
         console.log(chalk.red("No existing session found. Please login or signup."))
         console.log(chalk.green("jvcs --help for help"))
         return
     }
-    
+
     let configData = null
     configData = getGlobalConfig()
-    
-    if(!configData) {
+
+    if (!configData) {
         console.log(chalk.red("No existing session found. Please login or signup."))
         console.log(chalk.green("jvcs --help for help"))
         return
@@ -25,36 +25,45 @@ async function initCmd() {
     const cwd = process.cwd()
     const home = require("os").homedir()
 
-    if(cwd ===  home) {
+    if (cwd === home) {
         console.log(chalk.red("Cannot initialize a repository in your home directory."));
         console.log(chalk.yellow("Hint: navigate to a project folder and run 'jvcs init' there."));
         process.exit(1);
     }
 
-    const repoPath = path.join(cwd,".jvcs")
-    if(fssync.existsSync(repoPath)) {
+    const repoPath = path.join(cwd, ".jvcs")
+    if (fssync.existsSync(repoPath)) {
         console.log(chalk.yellow("Repository already is initialized."));
-        process.exit(1);    
+        process.exit(0);
     }
 
-    fssync.mkdirSync(repoPath)
-    fssync.mkdirSync(path.join(repoPath,"commits"))
-    fssync.mkdirSync(path.join(repoPath,"staging"))
-    
-    const config = {
-        repoName: path.basename(cwd),
-        createdAt: new Date().toISOString(),
-        remote: null,
-        owner : {
-            username: configData.username,
-            email: configData.email
+    try {
+        fssync.mkdirSync(repoPath)
+        fssync.mkdirSync(path.join(repoPath, "commits"))
+        fssync.mkdirSync(path.join(repoPath, "staging"))
+
+        const config = {
+            repoName: path.basename(cwd),
+            createdAt: new Date().toISOString(),
+            remote: null,
+            owner: {
+                username: configData.username,
+                email: configData.email
+            }
         }
-    }
 
-    fssync.writeFileSync(path.join(repoPath, "config.json"), JSON.stringify(config, null, 2))
-    fssync.writeFileSync(path.join(repoPath, "HEAD"), "");
+        fssync.writeFileSync(path.join(repoPath, "config.json"), JSON.stringify(config, null, 2))
+        fssync.writeFileSync(path.join(repoPath, "HEAD"), "");
 
-    console.log(chalk.green(`Initialized empty JVCS repository`));
+        console.log(chalk.green(`Initialized empty JVCS repository in ${repoPath}`));
+    }
+    catch (error) {
+        if (fssync.existsSync(repoPath)) {
+            fssync.rmSync(repoPath, { recursive: true, force: true });
+        }
+        console.log(chalk.red(`Failed to initialize repository: ${error.message}`));
+        process.exit(1);
+    }
 }
 
 module.exports = initCmd

package/controllers/status.js

@@ -1,17 +1,9 @@
-// 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");
+const { getGlobalConfig, checkforjvcs } = require("./utility");
+const { minimatch } = require("minimatch");
 
 // normalize relative path to use forward slashes for consistent comparisons
 function normalizeRel(p) {
@@ -24,10 +16,26 @@ function hashfile(filepath) {
         return crypto.createHash("sha256").update(data).digest("hex")
     }
     catch(error) {
-        // return null
+        return null;
     }
 }
 
+function loadIgnorePatterns() {
+    const ignorePath = path.join(process.cwd(), ".jvcsignore");
+    if(!fs.existsSync(ignorePath)) return [];
+
+    const content = fs.readFileSync(ignorePath, "utf-8");
+    return content
+        .split(/[\n,]+/)
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !line.startsWith("#"));
+}
+
+function isIgnored(relativePath, ignorePatterns = []) {
+    return ignorePatterns.some(pattern =>
+        minimatch(relativePath, pattern, { dot: true })
+    );
+}
 
 function getAllFiles(dir, rootDir=dir, collected=[]) {
 
@@ -39,11 +47,12 @@ function getAllFiles(dir, rootDir=dir, collected=[]) {
         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.isDirectory() && (entry.name === ".jvcs" || entry.name === ".git")) 
+            continue;
         
-        if(entry.isFile() && (entry.name === "meta.json" || entry.name === "jvcs_hashcode.json")) 
-        continue;
+        // Skip internal files from being hashed/tracked in cwd maps
+        if(entry.isFile() && (entry.name === "meta.json" || entry.name === "jvcs_hashcode.json" || entry.name === ".jvcsignore")) 
+            continue;
         
         if(entry.isFile()) {
             collected.push(rel);
@@ -51,7 +60,6 @@ function getAllFiles(dir, rootDir=dir, collected=[]) {
         else if(entry.isDirectory()) {
             getAllFiles(fullPath, rootDir, collected);
         }
-
     }
 
     return collected
@@ -59,21 +67,16 @@ function getAllFiles(dir, rootDir=dir, 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;
+        console.log(chalk.green("jvcs --help for help"));
+        process.exit(1);
     }
 
     if(!checkforjvcs()) {
-        console.log(chalk.red("Repository is not initialized or is deleted."));
-        return;
+        console.log(chalk.red("Repository is not initialized or is deleted. Please create it."));
+        process.exit(1);
     }
 
     const cwd = process.cwd()
@@ -84,77 +87,130 @@ async function statusCmd() {
 
     if(!fs.existsSync(jvcsDir)) {
         console.log(chalk.red("No repository exists. Please create one using 'jvcs init'"))
-        return
+        process.exit(1);
     }
 
-    // collect files (all relative to cwd, normalized)
+    const ignorePatterns = loadIgnorePatterns();
+
+    // 1. Collect hashes for CWD
     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))
+    const cwdMap = new Map();
+    for(const f of cwdFiles) {
+        if (!isIgnored(f, ignorePatterns)) {
+            const h = hashfile(path.join(cwd, f));
+            if (h) cwdMap.set(f, h);
+        }
+    }
+
+    // 2. Collect hashes for HEAD
+    const headMap = new Map();
+    if (fs.existsSync(commitDir) && fs.existsSync(headFile)) {
+        const headFileContent = fs.readFileSync(headFile, "utf-8").trim();
+        if (headFileContent) {
+            const commitPath = path.join(commitDir, headFileContent);
+            if (fs.existsSync(commitPath)) {
+                const commitFiles = getAllFiles(commitPath, commitPath, []);
+                for (const f of commitFiles) {
+                    const h = hashfile(path.join(commitPath, f));
+                    if (h) headMap.set(f, h);
+                }
+            }
         }
     }
 
-    // use Sets for fast looku
-    const committedSet = new Set(commitedFiles);
-    const stagedSet = new Set(stagedFiles);
+    // 3. Collect hashes for Staging (Index)
+    const stagingMap = new Map();
+    const hashPath = path.join(stagingDir, "jvcs_hashcode.json");
+    if (fs.existsSync(hashPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(hashPath, "utf-8"));
+            for (const [key, val] of Object.entries(data)) {
+                stagingMap.set(normalizeRel(key), val.hash);
+            }
+        } catch(e) {}
+    } else {
+        // Fallback
+        if (fs.existsSync(stagingDir)) {
+            const stFiles = getAllFiles(stagingDir, stagingDir, []);
+            for(const f of stFiles) {
+                const h = hashfile(path.join(stagingDir, f));
+                if (h) stagingMap.set(f, h);
+            }
+        }
+    }
 
-    // Untracked: present in cwd but not in staging or commits
-    const untracked = cwdFiles.filter(f => !stagedSet.has(f) && !committedSet.has(f));
+    // --- CALCULATE DIFFS ---
 
-    // Changes to be committed: present in staging but not in (any) commits
-    const toBeCommitted = stagedFiles.filter(f => !committedSet.has(f));
+    // Untracked files
+    const untracked = [];
+    for (const f of cwdMap.keys()) {
+        if (!stagingMap.has(f)) {
+            untracked.push(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
+    // Staged changes (Diff between Staging and HEAD)
+    const stagedAdded = [];
+    const stagedModified = [];
+    const stagedDeleted = [];
 
-        const cwdHash = hashfile(cwdFilePath)
-        const stagingHash = hashfile(stagedFilePath)
+    for (const [f, sHash] of stagingMap.entries()) {
+        if (!headMap.has(f)) {
+            stagedAdded.push(f);
+        } else if (headMap.get(f) !== sHash) {
+            stagedModified.push(f);
+        }
+    }
+    for (const f of headMap.keys()) {
+        if (!stagingMap.has(f)) {
+            stagedDeleted.push(f);
+        }
+    }
 
-        return cwdHash !== stagingHash
-    })
+    // Unstaged changes (Diff between CWD and Staging)
+    const unstagedModified = [];
+    const unstagedDeleted = [];
 
+    for (const [f, sHash] of stagingMap.entries()) {
+        if (!cwdMap.has(f)) {
+            unstagedDeleted.push(f);
+        } else if (cwdMap.get(f) !== sHash) {
+            unstagedModified.push(f);
+        }
+    }
 
-    // output
+    // --- 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 {
+    const hasStaged = stagedAdded.length > 0 || stagedModified.length > 0 || stagedDeleted.length > 0;
+    console.log(chalk.bold.green("\nChanges to be committed:"));
+    if (hasStaged) {
+        stagedAdded.forEach(f => console.log(chalk.green(`\tnew file:   ${f}`)));
+        stagedModified.forEach(f => console.log(chalk.green(`\tmodified:   ${f}`)));
+        stagedDeleted.forEach(f => console.log(chalk.green(`\tdeleted:    ${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 {
+    const hasUnstaged = unstagedModified.length > 0 || unstagedDeleted.length > 0;
+    console.log(chalk.bold.yellow("\nChanges not staged for commit:"));
+    if (hasUnstaged) {
+        unstagedModified.forEach(f => console.log(chalk.yellow(`\tmodified:   ${f}`)));
+        unstagedDeleted.forEach(f => console.log(chalk.yellow(`\tdeleted:    ${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) {
+    console.log(chalk.bold.red("\nUntracked files:"));
+    if (untracked.length > 0) {
         untracked.forEach(f => console.log(chalk.red(`\t${f}`)));
-    }
-    else {
+    } 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')"))
+    console.log(chalk.gray("(use 'jvcs unstage <file>/<folder>' to unstage a file/folder)"));
 }
 
-module.exports = statusCmd
+module.exports = statusCmd;

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const yargs = require("yargs");
 const { hideBin } = require("yargs/helpers");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jvcs",
-  "version": "1.6.9",
+  "version": "1.7.3",
   "bin": {
     "jvcs": "index.js"
   },
@@ -23,4 +23,4 @@
     "validator": "^13.15.20",
     "yargs": "^18.0.0"
   }
-}
+}