pagan-artifact 0.2.7 → 0.2.9

package/bin/art.js

@@ -2,7 +2,7 @@
 
 /**
  * art - Modern version control.
- * CLI (v0.2.7)
+ * CLI (v0.2.9)
  */
 
 const art = require('../index.js');
@@ -12,6 +12,7 @@ const [,, command, ...args] = process.argv;
 const RED = '\x1b[31m';
 const GREEN = '\x1b[32m';
 const RESET = '\x1b[0m';
+const GRAY = '\x1b[90m';
 
 async function run() {
   try {

package/branching/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Branching (v0.2.7)
+ * Module: Branching (v0.2.9)
  */
 
 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,8 +22,8 @@ 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 illegalRegExp = /[\/\\]/g;
@@ -60,7 +62,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 +88,28 @@ function branch ({ name, isDelete = false } = {}) {
   }
 
   if (initialCommits.length > 0) {
-    const sourceBranchPath = path.join(localHistoryPath, artJson.active.branch);
+    const sourceBranchPath = path.join(localHistoryPath, sourceBranchName);
 
     for (const hash of initialCommits) {
-      const srcFile = path.join(sourceBranchPath, `${hash}.json`);
-      const destFile = path.join(branchLocalPath, `${hash}.json`);
+      const masterFile = path.join(sourceBranchPath, `${hash}.json`);
+
+      if (fs.existsSync(masterFile)) {
+        // Copy the Master File
+        fs.copyFileSync(masterFile, path.join(branchLocalPath, `${hash}.json`));
+
+        // Detect and copy all Parts
+        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(sourceBranchPath, partName);
+            const destPart = path.join(branchLocalPath, partName);
 
-      if (fs.existsSync(srcFile)) {
-        fs.copyFileSync(srcFile, destFile);
+            if (fs.existsSync(srcPart)) {
+              fs.copyFileSync(srcPart, destPart);
+            }
+          }
+        }
       }
     }
   }
@@ -122,10 +139,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 +154,7 @@ function checkout (branchName, { force = false } = {}) {
       for (const file in currentState) {
         if (!fs.existsSync(path.join(root, file))) {
           isDirty = true;
+
           break;
         }
       }
@@ -155,12 +176,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 +201,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}. ${partCount} stage parts created. Resolve conflicts and art commit.`;
+ }
 
 module.exports = {
-  __libraryVersion: '0.2.7',
+  __libraryVersion: '0.2.9',
   __libraryAPIName: 'Branching',
   branch,
   checkout,

package/caches/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Caches (v0.2.7)
+ * Module: Caches (v0.2.9)
  */
 
 const fs = require('fs');
@@ -9,6 +9,80 @@ const path = require('path');
 const { checkout } = require('../branching/index.js');
 const getStateByHash = require('../utils/getStateByHash');
 
+/**
+ * Helper to load all changes from a paginated stage directory.
+ */
+
+function getStagedChanges(artPath) {
+  const stageDir = path.join(artPath, 'stage');
+  const manifestPath = path.join(stageDir, 'manifest.json');
+
+  if (!fs.existsSync(stageDir) || !fs.existsSync(manifestPath)) {
+    return {};
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  let allChanges = {};
+
+  for (const partName of manifest.parts) {
+    const partPath = path.join(stageDir, 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 stage directory.
+ */
+
+function saveStagedChanges(artPath, changes) {
+  const MAX_PART_SIZE = 32000000;
+  const stageDir = path.join(artPath, 'stage');
+
+  if (fs.existsSync(stageDir)) {
+    fs.rmSync(stageDir, { recursive: true, force: true });
+  }
+
+  fs.mkdirSync(stageDir, { recursive: true });
+
+  const stageParts = [];
+
+  let currentPartChanges = {};
+  let currentSize = 0;
+
+  const savePart = () => {
+    const partName = `part.${stageParts.length}.json`;
+
+    fs.writeFileSync(path.join(stageDir, partName), JSON.stringify({ changes: currentPartChanges }, null, 2));
+    stageParts.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(stageDir, 'manifest.json'), JSON.stringify({ parts: stageParts }, null, 2));
+}
+
 /**
  * Moves changes to a cache folder, or restores the most recent stash.
  */
@@ -16,12 +90,13 @@ const getStateByHash = require('../utils/getStateByHash');
 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'))
       .sort();
@@ -134,8 +209,8 @@ function stash ({ pop = false, list = false } = {}) {
 
   fs.writeFileSync(path.join(cachePath, `stash_${timestamp}.json`), JSON.stringify({ changes: stashChanges }, null, 2));
 
-  if (fs.existsSync(stagePath)) {
-    fs.unlinkSync(stagePath);
+  if (fs.existsSync(stageDir)) {
+    fs.rmSync(stageDir, { recursive: true, force: true });
   }
 
   checkout(artJson.active.branch, { force: true });
@@ -149,11 +224,11 @@ function stash ({ pop = false, list = false } = {}) {
 
 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) {
@@ -192,20 +267,15 @@ function reset (hash) {
 
 function rm (filePath) {
   const artPath = path.join(process.cwd(), '.art');
-  const stagePath = path.join(artPath, 'stage.json');
   const fullPath = path.join(process.cwd(), filePath);
 
-  let stage = { changes: {} };
-
-  if (fs.existsSync(stagePath)) {
-    stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
-  }
+  const stage = getStagedChanges(artPath);
 
-  stage.changes[filePath] = {
+  stage[filePath] = {
     type: 'deleteFile'
   };
 
-  fs.writeFileSync(stagePath, JSON.stringify(stage, null, 2));
+  saveStagedChanges(artPath, stage);
 
   if (fs.existsSync(fullPath)) {
     fs.unlinkSync(fullPath);
@@ -215,7 +285,7 @@ function rm (filePath) {
 }
 
 module.exports = {
-  __libraryVersion: '0.2.7',
+  __libraryVersion: '0.2.9',
   __libraryAPIName: 'Caches',
   stash,
   reset,

package/changes/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Changes (v0.2.7)
+ * Module: Changes (v0.2.9)
  */
 
 const fs = require('fs');
@@ -38,11 +38,15 @@ function log () {
 
   for (let i = manifest.commits.length - 1; i >= 0; i--) {
     const hash = manifest.commits[i];
-    const commitData = JSON.parse(fs.readFileSync(path.join(branchPath, `${hash}.json`), 'utf8'));
+    const commitMasterPath = path.join(branchPath, `${hash}.json`);
 
-    output += `commit ${commitData.hash}\n`;
-    output += `Date: ${new Date(commitData.timestamp).toLocaleString()}\n`;
-    output += `\n    ${commitData.message}\n\n`;
+    if (fs.existsSync(commitMasterPath)) {
+      const commitData = JSON.parse(fs.readFileSync(commitMasterPath, 'utf8'));
+
+      output += `commit ${commitData.hash}\n`;
+      output += `Date: ${new Date(commitData.timestamp).toLocaleString()}\n`;
+      output += `\n    ${commitData.message}\n\n`;
+    }
   }
 
   return output;
@@ -50,14 +54,19 @@ function log () {
 
 /**
  * Displays line-by-line differences between working directory and the last commit/stage.
- * @returns {string} Formatted diff output.
+ * @returns {object} Formatted diff output and staged file list.
  */
 
  function diff () {
   const root = process.cwd();
   const artPath = path.join(root, '.art');
-  const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+  const artJsonPath = path.join(artPath, 'art.json');
+
+  if (!fs.existsSync(artJsonPath)) {
+    throw new Error('No art repository found.');
+  }
 
+  const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
   const activeBranch = artJson.active.branch;
   const lastCommitHash = artJson.active.parent;
   const lastCommitState = lastCommitHash ? getStateByHash(activeBranch, lastCommitHash) : {};
@@ -95,14 +104,30 @@ function log () {
     }
   }
 
-  const stagePath = path.join(artPath, 'stage.json');
-  const staged = fs.existsSync(stagePath) ? Object.keys(JSON.parse(fs.readFileSync(stagePath, 'utf8')).changes) : [];
+  const stageDir = path.join(artPath, 'stage');
+  const stageManifestPath = path.join(stageDir, 'manifest.json');
+
+  let staged = [];
+
+  if (fs.existsSync(stageManifestPath)) {
+    const manifest = JSON.parse(fs.readFileSync(stageManifestPath, 'utf8'));
+    const stagedFilesSet = new Set();
+
+    for (const partName of manifest.parts) {
+      const partPath = path.join(stageDir, partName);
+      if (fs.existsSync(partPath)) {
+        const partData = JSON.parse(fs.readFileSync(partPath, 'utf8'));
+        Object.keys(partData.changes).forEach(file => stagedFilesSet.add(file));
+      }
+    }
+    staged = Array.from(stagedFilesSet);
+  }
 
   return { fileDiffs, staged };
 }
 
 module.exports = {
-  __libraryVersion: '0.2.7',
+  __libraryVersion: '0.2.9',
   __libraryAPIName: 'Changes',
   log,
   diff