jvcs 1.7.3 → 1.7.4

package/controllers/status.js

@@ -1,9 +1,17 @@
+// 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 { getGlobalConfig, checkforjvcs } = require("./utility");
-const { minimatch } = require("minimatch");
+const { checkGlobalConfig, getGlobalConfig, checkforjvcs } = require("./utility");
 
 // normalize relative path to use forward slashes for consistent comparisons
 function normalizeRel(p) {
@@ -15,51 +23,35 @@ function hashfile(filepath) {
         const data = fs.readFileSync(filepath)
         return crypto.createHash("sha256").update(data).digest("hex")
     }
-    catch(error) {
-        return null;
+    catch (error) {
+        // 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=[]) {
+function getAllFiles(dir, rootDir = dir, collected = []) {
 
     if (!fs.existsSync(dir)) return collected;
 
-    const entries = fs.readdirSync(dir,{withFileTypes:true})
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
 
-    for(const entry of entries) {
-        const fullPath = path.join(dir,entry.name)
-        const rel = normalizeRel(path.relative(rootDir,fullPath))
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name)
+        const rel = normalizeRel(path.relative(rootDir, fullPath))
 
-        if(entry.isDirectory() && (entry.name === ".jvcs" || entry.name === ".git")) 
+        if (entry.isDirectory() && (entry.name === ".jvcs" || entry.name === "node_modules"))
             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")) 
+
+        if (entry.isFile() && (entry.name === "meta.json" || entry.name === "jvcs_hashcode.json"))
             continue;
-        
-        if(entry.isFile()) {
+
+        if (entry.isFile()) {
             collected.push(rel);
         }
-        else if(entry.isDirectory()) {
+        else if (entry.isDirectory()) {
             getAllFiles(fullPath, rootDir, collected);
         }
+
     }
 
     return collected
@@ -67,150 +59,102 @@ function getAllFiles(dir, rootDir=dir, collected=[]) {
 
 async function statusCmd() {
 
-    const configData = getGlobalConfig();
-    if(!configData) {
+    if (!checkGlobalConfig()) {
         console.log(chalk.red("No existing session found. Please login or signup."));
         console.log(chalk.green("jvcs --help for help"));
-        process.exit(1);
+        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. Please create it."));
-        process.exit(1);
+    if (!checkforjvcs()) {
+        console.log(chalk.red("Repository is not initialized or is deleted."));
+        return;
     }
 
     const cwd = process.cwd()
-    const jvcsDir = path.join(cwd,".jvcs")
-    const commitDir = path.join(jvcsDir,"commits")
-    const stagingDir = path.join(jvcsDir,"staging")
+    const jvcsDir = path.join(cwd, ".jvcs")
+    const commitDir = path.join(jvcsDir, "commits")
+    const stagingDir = path.join(jvcsDir, "staging")
     const headFile = path.join(jvcsDir, "HEAD");
 
-    if(!fs.existsSync(jvcsDir)) {
+    if (!fs.existsSync(jvcsDir)) {
         console.log(chalk.red("No repository exists. Please create one using 'jvcs init'"))
-        process.exit(1);
+        return
     }
 
-    const ignorePatterns = loadIgnorePatterns();
-
-    // 1. Collect hashes for CWD
+    // collect files (all relative to cwd, normalized)
     const cwdFiles = getAllFiles(cwd, cwd, []);
-    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);
+    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))
         }
     }
 
-    // 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)
 
-    // Staged changes (Diff between Staging and HEAD)
-    const stagedAdded = [];
-    const stagedModified = [];
-    const stagedDeleted = [];
+        if (!fs.existsSync(cwdFilePath) || !fs.existsSync(stagedFilePath))
+            return false
 
-    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);
-        }
-    }
+        const cwdHash = hashfile(cwdFilePath)
+        const stagingHash = hashfile(stagedFilePath)
 
-    // Unstaged changes (Diff between CWD and Staging)
-    const unstagedModified = [];
-    const unstagedDeleted = [];
+        return cwdHash !== stagingHash
+    })
 
-    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)`));
 
-    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.bold.green("\nChanges to be committed (files that are staged but not commited):"));
+    if (toBeCommitted.length > 0) {
+        toBeCommitted.forEach(f => console.log(chalk.green(`\t${f}`)));
+    }
+    else {
         console.log(chalk.gray("\tNo changes added to commit"));
     }
 
-    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.bold.yellow("\nChanges not staged for commit (files that are modified after adding to staging area):"));
+    if (modified.length > 0) {
+        modified.forEach(f => console.log(chalk.yellow(`\t${f}`)));
+    }
+    else {
         console.log(chalk.gray("\tNo modified files detected"));
     }
 
-    console.log(chalk.bold.red("\nUntracked files:"));
+    console.log(chalk.bold.red("\nUntracked files (files that are not staged or commited):"));
     if (untracked.length > 0) {
         untracked.forEach(f => console.log(chalk.red(`\t${f}`)));
-    } else {
+    }
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jvcs",
-  "version": "1.7.3",
+  "version": "1.7.4",
   "bin": {
     "jvcs": "index.js"
   },