pagan-artifact 0.2.8 → 0.3.0

package/bin/art.js

@@ -2,10 +2,11 @@
 
 /**
  * art - Modern version control.
- * CLI (v0.2.8)
+ * CLI (v0.3.0)
  */
 
 const art = require('../index.js');
+const path = require('path');
 
 const [,, command, ...args] = process.argv;
 
@@ -69,7 +70,19 @@ async function run() {
 
         if (ignored && ignored.length > 0) {
           console.log('\nIgnored files:');
-          ignored.forEach(f => console.log(`${GRAY}\t${f}${RESET}`));
+
+          const compressedIgnored = new Set();
+
+          ignored.forEach(f => {
+            const parts = f.split(path.sep);
+            if (parts.length > 1) {
+              compressedIgnored.add(`${parts[0]}${path.sep}`);
+            } else {
+              compressedIgnored.add(f);
+            }
+          });
+
+          compressedIgnored.forEach(f => console.log(`${GRAY}\t${f}${RESET}`));
         }
 
         if (untracked.length === 0 && modified.length === 0 && staged.length === 0) {

package/branching/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Branching (v0.2.8)
+ * Module: Branching (v0.3.0)
  */
 
 const fs = require('fs');
@@ -8,6 +8,8 @@ const path = require('path');
 
 const getStateByHash = require('../utils/getStateByHash');
 
+const MAX_PART_SIZE = 32000000;
+
 /**
  * Lists, creates, or deletes branches.
  */
@@ -20,10 +22,11 @@ function branch ({ name, isDelete = false } = {}) {
 
   if (!name) {
    return fs.readdirSync(localHistoryPath).filter(f => {
-     return f !== '.DS_Store' && f !== 'desktop.ini' && f !== 'thumbs.db';
-   });
+      return f !== '.DS_Store' && f !== 'desktop.ini' && f !== 'thumbs.db';
+    });
   }
 
+  const normalizedName = name.toLowerCase();
   const illegalRegExp = /[\/\\]/g;
   const controlRegExp = /[\x00-\x1f\x80-\x9f]/g;
   const reservedRegExp = /^\.+$/;
@@ -60,7 +63,8 @@ function branch ({ name, isDelete = false } = {}) {
   }
 
   const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
-  const currentBranchManifest = path.join(localHistoryPath, artJson.active.branch, 'manifest.json');
+  const sourceBranchName = artJson.active.branch;
+  const currentBranchManifest = path.join(localHistoryPath, sourceBranchName, 'manifest.json');
 
   let initialCommits = [];
 
@@ -85,14 +89,33 @@ function branch ({ name, isDelete = false } = {}) {
   }
 
   if (initialCommits.length > 0) {
-    const sourceBranchPath = path.join(localHistoryPath, artJson.active.branch);
+    const sourceBranchPath = path.join(localHistoryPath, sourceBranchName);
+    const sourceRemotePath = path.join(remoteHistoryPath, sourceBranchName);
 
     for (const hash of initialCommits) {
-      const srcFile = path.join(sourceBranchPath, `${hash}.json`);
-      const destFile = path.join(branchLocalPath, `${hash}.json`);
+      let masterFile = path.join(sourceBranchPath, `${hash}.json`);
+      let currentSrcDir = sourceBranchPath;
+
+      if (!fs.existsSync(masterFile)) {
+        masterFile = path.join(sourceRemotePath, `${hash}.json`);
+        currentSrcDir = sourceRemotePath;
+      }
+
+      if (fs.existsSync(masterFile)) {
+        fs.copyFileSync(masterFile, path.join(branchLocalPath, `${hash}.json`));
 
-      if (fs.existsSync(srcFile)) {
-        fs.copyFileSync(srcFile, destFile);
+        const commitMaster = JSON.parse(fs.readFileSync(masterFile, 'utf8'));
+
+        if (commitMaster.parts && Array.isArray(commitMaster.parts)) {
+          for (const partName of commitMaster.parts) {
+            const srcPart = path.join(currentSrcDir, partName);
+            const destPart = path.join(branchLocalPath, partName);
+
+            if (fs.existsSync(srcPart)) {
+              fs.copyFileSync(srcPart, destPart);
+            }
+          }
+        }
       }
     }
   }
@@ -122,10 +145,13 @@ function checkout (branchName, { force = false } = {}) {
       .filter(f => !f.startsWith('.art') && !fs.statSync(path.join(root, f)).isDirectory());
 
     let isDirty = false;
+
     for (const file of allWorkDirFiles) {
       const currentContent = fs.readFileSync(path.join(root, file), 'utf8');
+
       if (currentContent !== currentState[file]) {
         isDirty = true;
+
         break;
       }
     }
@@ -134,6 +160,7 @@ function checkout (branchName, { force = false } = {}) {
       for (const file in currentState) {
         if (!fs.existsSync(path.join(root, file))) {
           isDirty = true;
+
           break;
         }
       }
@@ -155,12 +182,16 @@ function checkout (branchName, { force = false } = {}) {
   for (const filePath of Object.keys(currentState)) {
     if (!targetState[filePath]) {
       const fullPath = path.join(root, filePath);
-      if (fs.existsSync(fullPath)) fs.rmSync(fullPath, { recursive: true, force: true });
+
+      if (fs.existsSync(fullPath)) {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      }
     }
   }
 
   for (const [filePath, content] of Object.entries(targetState)) {
     const fullPath = path.join(root, filePath);
+
     fs.mkdirSync(path.dirname(fullPath), { recursive: true });
     fs.writeFileSync(fullPath, content);
   }
@@ -176,57 +207,97 @@ function checkout (branchName, { force = false } = {}) {
  * Performs a three-way merge. Overwrites working directory with conflicts.
  */
 
-function merge (targetBranch) {
-  const root = process.cwd();
-  const artPath = path.join(root, '.art');
-  const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
-  const activeBranch = artJson.active.branch;
+ function merge (targetBranch) {
+   const root = process.cwd();
+   const artPath = path.join(root, '.art');
+   const stageDir = path.join(artPath, 'stage');
+   const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+   const activeBranch = artJson.active.branch;
 
-  const activeManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${activeBranch}/manifest.json`), 'utf8'));
-  const targetManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${targetBranch}/manifest.json`), 'utf8'));
+   if (fs.existsSync(stageDir)) {
+     fs.rmSync(stageDir, { recursive: true, force: true });
+   }
 
-  const commonAncestorHash = [...activeManifest.commits].reverse().find(h => targetManifest.commits.includes(h)) || null;
+   fs.mkdirSync(stageDir, { recursive: true });
 
-  const baseState = commonAncestorHash ? getStateByHash(activeBranch, commonAncestorHash) : {};
-  const activeState = getStateByHash(activeBranch, artJson.active.parent);
-  const lastTargetHash = targetManifest.commits[targetManifest.commits.length - 1];
-  const targetState = getStateByHash(targetBranch, lastTargetHash);
+   const activeManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${activeBranch}/manifest.json`), 'utf8'));
+   const targetManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${targetBranch}/manifest.json`), 'utf8'));
 
-  const mergedChanges = {};
-  const allFiles = new Set([...Object.keys(activeState), ...Object.keys(targetState)]);
+   const commonAncestorHash = [...activeManifest.commits].reverse().find(h => targetManifest.commits.includes(h)) || null;
 
-  for (const filePath of allFiles) {
-    const base = baseState[filePath];
-    const active = activeState[filePath];
-    const target = targetState[filePath];
-    const fullPath = path.join(root, filePath);
+   const baseState = commonAncestorHash ? getStateByHash(activeBranch, commonAncestorHash) : {};
+   const activeState = getStateByHash(activeBranch, artJson.active.parent);
+   const lastTargetHash = targetManifest.commits[targetManifest.commits.length - 1];
+   const targetState = getStateByHash(targetBranch, lastTargetHash);
 
-    if (active === target) continue;
+   const allFiles = new Set([...Object.keys(activeState), ...Object.keys(targetState)]);
 
-    if (base === active && base !== target) {
-      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-      fs.writeFileSync(fullPath, target || '');
+   let currentPartChanges = {};
+   let currentPartSize = 0;
+   let partCount = 0;
 
-      mergedChanges[filePath] = { type: 'createFile', content: target };
-    } else if (base !== active && base !== target && active !== target) {
-      const conflictContent = `<<<<<<< active\n${active || ''}\n=======\n${target || ''}\n>>>>>>> ${targetBranch}`;
+   const saveStagePart = () => {
+     if (Object.keys(currentPartChanges).length === 0) return;
 
-      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-      fs.writeFileSync(fullPath, conflictContent);
+     const partPath = path.join(stageDir, `part.${partCount}.json`);
 
-      mergedChanges[filePath] = { type: 'createFile', content: conflictContent };
-    }
-  }
+     fs.writeFileSync(partPath, JSON.stringify({ changes: currentPartChanges }, null, 2));
+     currentPartChanges = {};
+     currentPartSize = 0;
+     partCount++;
+   };
 
-  const stage = { changes: mergedChanges };
+   for (const filePath of allFiles) {
+     const base = baseState[filePath];
+     const active = activeState[filePath];
+     const target = targetState[filePath];
+     const fullPath = path.join(root, filePath);
 
-  fs.writeFileSync(path.join(artPath, 'stage.json'), JSON.stringify(stage, null, 2));
+     if (active === target) continue;
 
-  return `Merged ${targetBranch}. Conflicts written to the stage and working directory to be resolved.`;
-}
+     let change = null;
+
+     if (base === active && base !== target) {
+       if (target === undefined) {
+          if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+          change = { type: 'deleteFile' };
+       } else {
+          fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+          fs.writeFileSync(fullPath, target);
+          change = { type: 'createFile', content: target };
+       }
+     } else if (base !== active && base !== target && active !== target) {
+       const conflictContent = `<<<<<<< active\n${active || ''}\n=======\n${target || ''}\n>>>>>>> ${targetBranch}`;
+
+       fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+       fs.writeFileSync(fullPath, conflictContent);
+       change = { type: 'createFile', content: conflictContent };
+     }
+
+     if (change) {
+       const changeSize = JSON.stringify(change).length;
+
+       if (currentPartSize + changeSize > MAX_PART_SIZE) {
+         saveStagePart();
+       }
+
+       currentPartChanges[filePath] = change;
+       currentPartSize += changeSize;
+     }
+   }
+
+   saveStagePart();
+
+   fs.writeFileSync(
+     path.join(stageDir, 'manifest.json'),
+     JSON.stringify({ parts: Array.from({ length: partCount }, (_, i) => `part.${i}.json`) }, null, 2)
+   );
+
+   return `Merged ${targetBranch}.`;
+ }
 
 module.exports = {
-  __libraryVersion: '0.2.8',
+  __libraryVersion: '0.3.0',
   __libraryAPIName: 'Branching',
   branch,
   checkout,

package/caches/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Caches (v0.2.8)
+ * Module: Caches (v0.3.0)
  */
 
 const fs = require('fs');
@@ -9,27 +9,95 @@ const path = require('path');
 const { checkout } = require('../branching/index.js');
 const getStateByHash = require('../utils/getStateByHash');
 
+const MAX_PART_SIZE = 32000000;
+
 /**
- * Moves changes to a cache folder, or restores the most recent stash.
+ * Helper to load all changes from a paginated directory (Stage or Stash).
  */
 
+function getPaginatedChanges(dirPath) {
+  const manifestPath = path.join(dirPath, 'manifest.json');
+
+  if (!fs.existsSync(dirPath) || !fs.existsSync(manifestPath)) {
+    return {};
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  let allChanges = {};
+
+  for (const partName of manifest.parts) {
+    const partPath = path.join(dirPath, partName);
+    if (fs.existsSync(partPath)) {
+      const partData = JSON.parse(fs.readFileSync(partPath, 'utf8'));
+
+      Object.assign(allChanges, partData.changes);
+    }
+  }
+
+  return allChanges;
+}
+
+/**
+ * Helper to write changes to a paginated directory.
+ */
+
+function savePaginatedChanges (dirPath, changes) {
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(dirPath, { recursive: true });
+
+  const parts = [];
+
+  let currentPartChanges = {};
+  let currentSize = 0;
+
+  const savePart = () => {
+    if (Object.keys(currentPartChanges).length === 0) return;
+
+    const partName = `part.${parts.length}.json`;
+
+    fs.writeFileSync(path.join(dirPath, partName), JSON.stringify({ changes: currentPartChanges }, null, 2));
+    parts.push(partName);
+    currentPartChanges = {};
+    currentSize = 0;
+  };
+
+  for (const [file, changeSet] of Object.entries(changes)) {
+    const size = JSON.stringify(changeSet).length;
+
+    if (currentSize + size > MAX_PART_SIZE && Object.keys(currentPartChanges).length > 0) {
+      savePart();
+    }
+
+    currentPartChanges[file] = changeSet;
+    currentSize += size;
+  }
+
+  savePart();
+  fs.writeFileSync(path.join(dirPath, 'manifest.json'), JSON.stringify({ parts }, null, 2));
+}
+
 function stash ({ pop = false, list = false } = {}) {
   const root = process.cwd();
   const artPath = path.join(root, '.art');
-  const stagePath = path.join(artPath, 'stage.json');
+  const stageDir = path.join(artPath, 'stage');
   const cachePath = path.join(artPath, 'cache');
   const artJsonPath = path.join(artPath, 'art.json');
 
   if (list) {
     if (!fs.existsSync(cachePath)) return [];
-    const stashFiles = fs.readdirSync(cachePath)
-      .filter(f => f.startsWith('stash_') && f.endsWith('.json'))
+
+    const stashDirs = fs.readdirSync(cachePath)
+      .filter(d => d.startsWith('stash_') && fs.statSync(path.join(cachePath, d)).isDirectory())
       .sort();
 
-    return stashFiles.map((file, index) => ({
-      id: `stash@{${stashFiles.length - 1 - index}}`,
-      date: new Date(parseInt(file.replace('stash_', '').replace('.json', ''))).toLocaleString(),
-      file
+    return stashDirs.map((dirName, index) => ({
+      id: `stash@{${stashDirs.length - 1 - index}}`,
+      date: new Date(parseInt(dirName.replace('stash_', ''))).toLocaleString(),
+      dirName
     }));
   }
 
@@ -37,18 +105,16 @@ function stash ({ pop = false, list = false } = {}) {
     if (!fs.existsSync(cachePath)) throw new Error('No stashes found.');
 
     const stashes = fs.readdirSync(cachePath)
-      .filter(f => f.startsWith('stash_') && f.endsWith('.json'))
+      .filter(d => d.startsWith('stash_') && fs.statSync(path.join(cachePath, d)).isDirectory())
       .sort();
 
-    if (stashes.length === 0) {
-      throw new Error('No stashes found.');
-    }
+    if (stashes.length === 0) throw new Error('No stashes found.');
 
-    const latestStashName = stashes[stashes.length - 1];
-    const latestStashPath = path.join(cachePath, latestStashName);
-    const stashData = JSON.parse(fs.readFileSync(latestStashPath, 'utf8'));
+    const latestStashDirName = stashes[stashes.length - 1];
+    const latestStashPath = path.join(cachePath, latestStashDirName);
+    const stashChanges = getPaginatedChanges(latestStashPath);
 
-    for (const [filePath, changeSet] of Object.entries(stashData.changes)) {
+    for (const [filePath, changeSet] of Object.entries(stashChanges)) {
       const fullPath = path.join(root, filePath);
 
       if (Array.isArray(changeSet)) {
@@ -71,9 +137,8 @@ function stash ({ pop = false, list = false } = {}) {
       }
     }
 
-    fs.unlinkSync(latestStashPath);
-
-    return `Restored changes from ${latestStashName}.`;
+    fs.rmSync(latestStashPath, { recursive: true, force: true });
+    return `Restored changes from ${latestStashDirName}.`;
   }
 
   const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
@@ -85,12 +150,16 @@ function stash ({ pop = false, list = false } = {}) {
   const stashChanges = {};
 
   for (const file of allWorkDirFiles) {
-    const currentContent = fs.readFileSync(path.join(root, file), 'utf8');
+    const fullPath = path.join(root, file);
+    const currentBuffer = fs.readFileSync(fullPath);
+    const isBinary = currentBuffer.includes(0);
+
+    const currentContent = isBinary ? null : currentBuffer.toString('utf8');
     const previousContent = activeState[file];
 
     if (previousContent === undefined) {
-      stashChanges[file] = { type: 'createFile', content: currentContent };
-    } else if (currentContent !== previousContent) {
+      stashChanges[file] = { type: 'createFile', content: isBinary ? currentBuffer.toString('base64') : currentContent };
+    } else if (currentContent !== previousContent && !isBinary) {
       let start = 0;
 
       while (start < previousContent.length && start < currentContent.length && previousContent[start] === currentContent[start]) {
@@ -114,7 +183,9 @@ function stash ({ pop = false, list = false } = {}) {
 
       if (insCont.length > 0) ops.push({ type: 'insert', position: start, content: insCont });
 
-      if (ops.length > 0) stashChanges[file] = ops;
+      if (ops.length > 0) {
+        stashChanges[file] = ops;
+      }
     }
   }
 
@@ -124,50 +195,38 @@ function stash ({ pop = false, list = false } = {}) {
     }
   }
 
-  if (Object.keys(stashChanges).length === 0) {
-    return 'No local changes to stash.';
-  }
-
-  if (!fs.existsSync(cachePath)) fs.mkdirSync(cachePath, { recursive: true });
+  if (Object.keys(stashChanges).length === 0) return 'No local changes to stash.';
 
   const timestamp = Date.now();
+  const newStashPath = path.join(cachePath, `stash_${timestamp}`);
 
-  fs.writeFileSync(path.join(cachePath, `stash_${timestamp}.json`), JSON.stringify({ changes: stashChanges }, null, 2));
+  savePaginatedChanges(newStashPath, stashChanges);
 
-  if (fs.existsSync(stagePath)) {
-    fs.unlinkSync(stagePath);
+  if (fs.existsSync(stageDir)) {
+    fs.rmSync(stageDir, { recursive: true, force: true });
   }
-
   checkout(artJson.active.branch, { force: true });
 
-  return `Saved working directory changes to stash_${timestamp}.json and reverted to clean state.`;
+  return `Saved working directory changes to paginated stash_${timestamp} and reverted to clean state.`;
 }
 
-/**
- * Wipes the stage and moves the active parent pointer if a hash is provided.
- */
-
 function reset (hash) {
   const artPath = path.join(process.cwd(), '.art');
-  const stagePath = path.join(artPath, 'stage.json');
+  const stageDir = path.join(artPath, 'stage');
   const artJsonPath = path.join(artPath, 'art.json');
 
-  if (fs.existsSync(stagePath)) {
-    fs.unlinkSync(stagePath);
+  if (fs.existsSync(stageDir)) {
+    fs.rmSync(stageDir, { recursive: true, force: true });
   }
 
-  if (!hash) {
-    return 'Staging area cleared.';
-  }
+  if (!hash) return 'Staging area cleared.';
 
   const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
   const branch = artJson.active.branch;
   const branchPath = path.join(artPath, 'history/local', branch);
   const commitPath = path.join(branchPath, `${hash}.json`);
 
-  if (!fs.existsSync(commitPath)) {
-    throw new Error(`Commit ${hash} not found in branch ${branch}.`);
-  }
+  if (!fs.existsSync(commitPath)) throw new Error(`Commit ${hash} not found in branch ${branch}.`);
 
   artJson.active.parent = hash;
   fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
@@ -183,39 +242,24 @@ function reset (hash) {
 
   checkout(branch);
 
-  return `Head is now at ${hash.slice(0, 7)}. Working directory updated.`;
+  return `Branch is now at ${hash.slice(0, 7)}. Working directory updated.`;
 }
 
-/**
- * Marks a file for deletion by adding a "deleteFile" entry to the stage.
- */
-
 function rm (filePath) {
   const artPath = path.join(process.cwd(), '.art');
-  const stagePath = path.join(artPath, 'stage.json');
   const fullPath = path.join(process.cwd(), filePath);
+  const stage = getPaginatedChanges(path.join(artPath, 'stage'));
 
-  let stage = { changes: {} };
+  stage[filePath] = { type: 'deleteFile' };
+  savePaginatedChanges(path.join(artPath, 'stage'), stage);
 
-  if (fs.existsSync(stagePath)) {
-    stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
-  }
-
-  stage.changes[filePath] = {
-    type: 'deleteFile'
-  };
-
-  fs.writeFileSync(stagePath, JSON.stringify(stage, null, 2));
-
-  if (fs.existsSync(fullPath)) {
-    fs.unlinkSync(fullPath);
-  }
+  if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
 
   return `File ${filePath} marked for removal.`;
 }
 
 module.exports = {
-  __libraryVersion: '0.2.8',
+  __libraryVersion: '0.3.0',
   __libraryAPIName: 'Caches',
   stash,
   reset,