pagan-artifact 0.2.9 → 0.3.1

package/bin/art.js

@@ -2,10 +2,11 @@
 
 /**
  * art - Modern version control.
- * CLI (v0.2.9)
+ * CLI (v0.3.1)
  */
 
 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.9)
+ * Module: Branching (v0.3.1)
  */
 
 const fs = require('fs');
@@ -26,6 +26,7 @@ function branch ({ name, isDelete = false } = {}) {
     });
   }
 
+  const normalizedName = name.toLowerCase();
   const illegalRegExp = /[\/\\]/g;
   const controlRegExp = /[\x00-\x1f\x80-\x9f]/g;
   const reservedRegExp = /^\.+$/;
@@ -89,20 +90,25 @@ function branch ({ name, isDelete = false } = {}) {
 
   if (initialCommits.length > 0) {
     const sourceBranchPath = path.join(localHistoryPath, sourceBranchName);
+    const sourceRemotePath = path.join(remoteHistoryPath, sourceBranchName);
 
     for (const hash of initialCommits) {
-      const masterFile = path.join(sourceBranchPath, `${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)) {
-        // 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 srcPart = path.join(currentSrcDir, partName);
             const destPart = path.join(branchLocalPath, partName);
 
             if (fs.existsSync(srcPart)) {
@@ -287,11 +293,11 @@ function checkout (branchName, { force = false } = {}) {
      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.`;
+   return `Merged ${targetBranch}.`;
  }
 
 module.exports = {
-  __libraryVersion: '0.2.9',
+  __libraryVersion: '0.3.1',
   __libraryAPIName: 'Branching',
   branch,
   checkout,

package/caches/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Caches (v0.2.9)
+ * Module: Caches (v0.3.1)
  */
 
 const fs = require('fs');
@@ -9,15 +9,16 @@ const path = require('path');
 const { checkout } = require('../branching/index.js');
 const getStateByHash = require('../utils/getStateByHash');
 
+const MAX_PART_SIZE = 32000000;
+
 /**
- * Helper to load all changes from a paginated stage directory.
+ * Helper to load all changes from a paginated directory (Stage or Stash).
  */
 
-function getStagedChanges(artPath) {
-  const stageDir = path.join(artPath, 'stage');
-  const manifestPath = path.join(stageDir, 'manifest.json');
+function getPaginatedChanges (dirPath) {
+  const manifestPath = path.join(dirPath, 'manifest.json');
 
-  if (!fs.existsSync(stageDir) || !fs.existsSync(manifestPath)) {
+  if (!fs.existsSync(dirPath) || !fs.existsSync(manifestPath)) {
     return {};
   }
 
@@ -26,7 +27,7 @@ function getStagedChanges(artPath) {
   let allChanges = {};
 
   for (const partName of manifest.parts) {
-    const partPath = path.join(stageDir, partName);
+    const partPath = path.join(dirPath, partName);
 
     if (fs.existsSync(partPath)) {
       const partData = JSON.parse(fs.readFileSync(partPath, 'utf8'));
@@ -39,30 +40,28 @@ function getStagedChanges(artPath) {
 }
 
 /**
- * Helper to write changes to a paginated stage directory.
+ * Helper to write changes to a paginated 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 });
+function savePaginatedChanges (dirPath, changes) {
+  if (fs.existsSync(dirPath)) {
+    fs.rmSync(dirPath, { recursive: true, force: true });
   }
 
-  fs.mkdirSync(stageDir, { recursive: true });
+  fs.mkdirSync(dirPath, { recursive: true });
 
-  const stageParts = [];
+  const parts = [];
 
   let currentPartChanges = {};
   let currentSize = 0;
 
   const savePart = () => {
-    const partName = `part.${stageParts.length}.json`;
+    if (Object.keys(currentPartChanges).length === 0) return;
 
-    fs.writeFileSync(path.join(stageDir, partName), JSON.stringify({ changes: currentPartChanges }, null, 2));
-    stageParts.push(partName);
+    const partName = `part.${parts.length}.json`;
 
+    fs.writeFileSync(path.join(dirPath, partName), JSON.stringify({ changes: currentPartChanges }, null, 2));
+    parts.push(partName);
     currentPartChanges = {};
     currentSize = 0;
   };
@@ -79,14 +78,9 @@ function saveStagedChanges(artPath, changes) {
   }
 
   savePart();
-
-  fs.writeFileSync(path.join(stageDir, 'manifest.json'), JSON.stringify({ parts: stageParts }, null, 2));
+  fs.writeFileSync(path.join(dirPath, 'manifest.json'), JSON.stringify({ parts }, null, 2));
 }
 
-/**
- * Moves changes to a cache folder, or restores the most recent stash.
- */
-
 function stash ({ pop = false, list = false } = {}) {
   const root = process.cwd();
   const artPath = path.join(root, '.art');
@@ -97,14 +91,14 @@ function stash ({ pop = false, list = false } = {}) {
   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
     }));
   }
 
@@ -112,18 +106,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)) {
@@ -146,9 +138,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'));
@@ -160,12 +151,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]) {
@@ -189,7 +184,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;
+      }
     }
   }
 
@@ -199,15 +196,12 @@ 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(stageDir)) {
     fs.rmSync(stageDir, { recursive: true, force: true });
@@ -215,13 +209,9 @@ function stash ({ pop = false, list = false } = {}) {
 
   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 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 stageDir = path.join(artPath, 'stage');
@@ -231,18 +221,14 @@ function reset (hash) {
     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));
@@ -258,34 +244,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 fullPath = path.join(process.cwd(), filePath);
+  const stage = getPaginatedChanges(path.join(artPath, 'stage'));
 
-  const stage = getStagedChanges(artPath);
+  stage[filePath] = { type: 'deleteFile' };
+  savePaginatedChanges(path.join(artPath, 'stage'), stage);
 
-  stage[filePath] = {
-    type: 'deleteFile'
-  };
-
-  saveStagedChanges(artPath, stage);
-
-  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.9',
+  __libraryVersion: '0.3.1',
   __libraryAPIName: 'Caches',
   stash,
   reset,

package/changes/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Changes (v0.2.9)
+ * Module: Changes (v0.3.1)
  */
 
 const fs = require('fs');
@@ -34,8 +34,6 @@ function log () {
 
   let output = `Branch: ${branch}\n\n`;
 
-  // Display commits in reverse chronological order
-
   for (let i = manifest.commits.length - 1; i >= 0; i--) {
     const hash = manifest.commits[i];
     const commitMasterPath = path.join(branchPath, `${hash}.json`);
@@ -57,7 +55,7 @@ function log () {
  * @returns {object} Formatted diff output and staged file list.
  */
 
- function diff () {
+function diff () {
   const root = process.cwd();
   const artPath = path.join(root, '.art');
   const artJsonPath = path.join(artPath, 'art.json');
@@ -78,10 +76,13 @@ function log () {
 
   for (const filePath of currentFiles) {
     const fullPath = path.join(root, filePath);
-    const currentContent = fs.readFileSync(fullPath, 'utf8');
+    const currentBuffer = fs.readFileSync(fullPath);
+    const isBinary = currentBuffer.includes(0);
+
+    const currentContent = isBinary ? null : currentBuffer.toString('utf8');
     const previousContent = lastCommitState[filePath] || '';
 
-    if (currentContent !== previousContent) {
+    if (!isBinary && currentContent !== previousContent) {
       let start = 0;
 
       while (start < previousContent.length && start < currentContent.length && previousContent[start] === currentContent[start]) {
@@ -101,6 +102,12 @@ function log () {
         deleted: previousContent.slice(start, oldEnd + 1),
         added: currentContent.slice(start, newEnd + 1)
       });
+    } else if (isBinary) {
+      const prevHash = lastCommitState[filePath] ? 'exists' : 'null';
+
+      if (prevHash === 'null') {
+        fileDiffs.push({ file: filePath, added: '<Binary Data>', deleted: '' });
+      }
     }
   }
 
@@ -115,8 +122,10 @@ function log () {
 
     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));
       }
     }
@@ -127,7 +136,7 @@ function log () {
 }
 
 module.exports = {
-  __libraryVersion: '0.2.9',
+  __libraryVersion: '0.3.1',
   __libraryAPIName: 'Changes',
   log,
   diff

package/contributions/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Contributions (v0.2.9)
+ * Module: Contributions (v0.3.1)
  */
 
 const fs = require('fs');
@@ -60,7 +60,10 @@ async function fetchRemote () {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
-      type: 'history', handle, repo, branch,
+      type: 'history',
+      handle,
+      repo,
+      branch,
       ...(token && { personalAccessToken: token })
     })
   });
@@ -171,20 +174,22 @@ async function push () {
   const handle = remoteParts.pop();
 
   const localBranchPath = path.join(artPath, 'history/local', branch);
+  const remoteBranchPath = path.join(artPath, 'history/remote', branch);
   const localManifest = JSON.parse(fs.readFileSync(path.join(localBranchPath, 'manifest.json'), 'utf8'));
 
   const response = await fetch(`${ARTIFACT_HOST}/manifest`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
-      type: 'history', handle, repo, branch,
-
+      type: 'history',
+      handle,
+      repo,
+      branch,
       ...(token && { personalAccessToken: token })
     })
   });
 
   const remoteManifest = await response.json();
-
   const missingCommits = localManifest.commits.filter(hash => !remoteManifest.commits.includes(hash));
 
   if (missingCommits.length === 0) {
@@ -208,13 +213,17 @@ async function push () {
     }
   }
 
+  const currentRemoteManifestPath = path.join(remoteBranchPath, 'manifest.json');
+  const currentRemoteManifest = fs.existsSync(currentRemoteManifestPath)
+    ? JSON.parse(fs.readFileSync(currentRemoteManifestPath, 'utf8'))
+    : { commits: [] };
+
   for (const commitHash of missingCommits) {
     const commitMaster = JSON.parse(fs.readFileSync(path.join(localBranchPath, `${commitHash}.json`), 'utf8'));
 
-    await fetch(`${ARTIFACT_HOST}/push`, {
+    const pushRes = await fetch(`${ARTIFACT_HOST}/push`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-
       body: JSON.stringify({
         handle, repo, branch, commit: commitMaster,
 
@@ -224,12 +233,14 @@ async function push () {
       })
     });
 
+    if (!pushRes.ok) throw new Error(`Server rejected push for commit ${commitHash}`);
+
     rootData = null;
 
     for (const partName of commitMaster.parts) {
       const partData = JSON.parse(fs.readFileSync(path.join(localBranchPath, partName), 'utf8'));
 
-      await fetch(`${ARTIFACT_HOST}/commit/part`, {
+      const partRes = await fetch(`${ARTIFACT_HOST}/commit/part`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
@@ -237,10 +248,13 @@ async function push () {
           ...(token && { personalAccessToken: token })
         })
       });
+
+      if (!partRes.ok) throw new Error(`Server failed to receive part ${partName}`);
     }
-  }
 
-  fs.writeFileSync(path.join(artPath, 'history/remote', branch, 'manifest.json'), JSON.stringify(localManifest, null, 2));
+    currentRemoteManifest.commits.push(commitHash);
+    fs.writeFileSync(currentRemoteManifestPath, JSON.stringify(currentRemoteManifest, null, 2));
+  }
 
   return `Pushed ${missingCommits.length} commits to remote.`;
 }

package/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Core Library Entry Point (v0.2.9)
+ * Core Library Entry Point (v0.3.1)
  */
 
 const Setup = require('./setup');
@@ -50,7 +50,7 @@ const art = {
 
   // Metadata
 
-  version: '0.2.9',
+  version: '0.3.1',
   modules: [
     Setup.__libraryAPIName,
     Workflow.__libraryAPIName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagan-artifact",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Modern version control.",
   "main": "index.js",
   "bin": {

package/setup/index.js

@@ -1,137 +1,135 @@
 /**
  * art - Modern version control.
- * Module: Setup (v0.2.9)
+ * Module: Setup (v0.3.1)
  */
 
 const fs = require('fs');
 const path = require('path');
 
 const pkg = require('../package.json');
-const { remote } = require('../contributions');
 const shouldIgnore = require('../utils/shouldIgnore');
 
 const ARTIFACT_HOST = pkg.artConfig.host || 'http://localhost:1337';
+const MAX_PART_CHARS = 32000000;
 
 /**
- * Initializes the local .art directory structure.
+ * Internal helper to create the .art directory tree.
  */
 
- function init (directoryPath = process.cwd()) {
-   const artDirectory = path.join(directoryPath, '.art');
-
-   const folders = [
-     '',
-     'root',
-     'history',
-     'history/local',
-     'history/local/main',
-     'history/remote',
-     'history/remote/main'
-   ];
-
-   if (fs.existsSync(artDirectory)) {
-     return `Reinitialized existing art repository in ${artDirectory}`;
-   }
+function ensureDirStructure(artDirectory) {
+  const folders = [
+    '',
+    'root',
+    'history',
+    'history/local',
+    'history/local/main',
+    'history/remote',
+    'history/remote/main'
+  ];
+
+  for (const folder of folders) {
+    const fullPath = path.join(artDirectory, folder);
+
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  }
+}
 
-   for (const folder of folders) {
-     const fullPath = path.join(artDirectory, folder);
+/**
+ * Initializes the local .art directory structure and indexes current files.
+ */
 
-     if (!fs.existsSync(fullPath)) {
-       fs.mkdirSync(fullPath, { recursive: true });
-     }
-   }
+function init (directoryPath = process.cwd()) {
+  const artDirectory = path.join(directoryPath, '.art');
 
-   const files = fs.readdirSync(directoryPath, { recursive: true })
-     .filter(f => {
-       const isInternal = f === '.art' || f.startsWith('.art' + path.sep);
+  if (fs.existsSync(artDirectory)) {
+    return `Reinitialized existing art repository in ${artDirectory}.`;
+  }
 
-       return !isInternal && !shouldIgnore(f);
-     });
+  ensureDirStructure(artDirectory);
 
-   const rootMasterManifest = { parts: [] };
+  const files = fs.readdirSync(directoryPath, { recursive: true })
+    .filter(f => {
+      const isInternal = f === '.art' || f.startsWith('.art' + path.sep);
 
-   let currentPartFiles = [];
-   let currentPartChars = 0;
+      return !isInternal && !shouldIgnore(f);
+    });
 
-   const MAX_PART_CHARS = 32000000;
+  const rootMasterManifest = { parts: [] };
 
-   const saveManifestPart = () => {
-     if (currentPartFiles.length === 0) return;
+  let currentPartFiles = [];
+  let currentPartChars = 0;
 
-     const partIndex = rootMasterManifest.parts.length;
-     const partName = `manifest.part.${Date.now()}.${partIndex}.json`;
-     const partPath = path.join(artDirectory, 'root', partName);
+  const saveManifestPart = () => {
+    if (currentPartFiles.length === 0) return;
 
-     fs.writeFileSync(
-       partPath,
-       JSON.stringify({ files: currentPartFiles }, null, 2)
-     );
+    const partIndex = rootMasterManifest.parts.length;
+    const partName = `manifest.part.${partIndex}.json`;
+    const partPath = path.join(artDirectory, 'root', partName);
 
-     rootMasterManifest.parts.push(partName);
+    fs.writeFileSync(
+      partPath,
+      JSON.stringify({ files: currentPartFiles }, null, 2)
+    );
 
-     currentPartFiles = [];
-     currentPartChars = 0;
-   };
+    rootMasterManifest.parts.push(partName);
+    currentPartFiles = [];
+    currentPartChars = 0;
+  };
 
-   for (const file of files) {
-     const fullPath = path.join(directoryPath, file);
+  for (const file of files) {
+    const fullPath = path.join(directoryPath, file);
 
-     if (fs.lstatSync(fullPath).isFile()) {
-       const content = fs.readFileSync(fullPath, 'utf8');
+    if (fs.lstatSync(fullPath).isFile()) {
+      const content = fs.readFileSync(fullPath, 'utf8');
 
-       if (currentPartChars + content.length > MAX_PART_CHARS && currentPartFiles.length > 0) {
-         saveManifestPart();
-       }
+      if (currentPartChars + content.length > MAX_PART_CHARS && currentPartFiles.length > 0) {
+        saveManifestPart();
+      }
 
-       currentPartFiles.push({
-         path: file,
-         content: content
-       });
+      currentPartFiles.push({
+        path: file,
+        content: content
+      });
 
-       currentPartChars += content.length;
-     }
-   }
+      currentPartChars += content.length;
+    }
+  }
 
-   saveManifestPart();
+  saveManifestPart();
 
-   fs.writeFileSync(
-     path.join(artDirectory, 'root/manifest.json'),
-     JSON.stringify(rootMasterManifest, null, 2)
-   );
+  fs.writeFileSync(
+    path.join(artDirectory, 'root/manifest.json'),
+    JSON.stringify(rootMasterManifest, null, 2)
+  );
 
-   fs.writeFileSync(
-     path.join(artDirectory, 'history/local/main/manifest.json'),
-     JSON.stringify({ commits: [] }, null, 2)
-   );
+  fs.writeFileSync(
+    path.join(artDirectory, 'history/local/main/manifest.json'),
+    JSON.stringify({ commits: [] }, null, 2)
+  );
 
-   fs.writeFileSync(
-     path.join(artDirectory, 'history/remote/main/manifest.json'),
-     JSON.stringify({ commits: [] }, null, 2)
-   );
+  fs.writeFileSync(
+    path.join(artDirectory, 'history/remote/main/manifest.json'),
+    JSON.stringify({ commits: [] }, null, 2)
+  );
 
-   const artFile = {
-     active: { branch: 'main', parent: null },
-     remote: '',
-     configuration: { handle: '', personalAccessToken: '' }
-   };
+  const artFile = {
+    active: { branch: 'main', parent: null },
+    remote: '',
+    configuration: { handle: '', personalAccessToken: '' }
+  };
 
-   fs.writeFileSync(
-     path.join(artDirectory, 'art.json'),
-     JSON.stringify(artFile, null, 2)
-   );
+  fs.writeFileSync(
+    path.join(artDirectory, 'art.json'),
+    JSON.stringify(artFile, null, 2)
+  );
 
-   return `Initialized empty art repository in ${artDirectory} with ${rootMasterManifest.parts.length} manifest part(s).`;
- }
+  return `Initialized empty art repository in ${artDirectory}.`;
+}
 
 /**
- * Clone a repository
- * @param {string} repoSlug - The handle/repo identifier.
- * @param {string} providedToken - Optional token for authentication.
- */
-
- /**
- * art - Modern version control.
- * Module: Setup (v0.2.9) - Clone logic
+ * Clone a repository and replay history.
  */
 
 async function clone (repoSlug, providedToken = null) {
@@ -148,19 +146,20 @@ async function clone (repoSlug, providedToken = null) {
   }
 
   fs.mkdirSync(targetPath, { recursive: true });
-  init(targetPath);
+
+  const artPath = path.join(targetPath, '.art');
+
+  ensureDirStructure(artPath);
   process.chdir(targetPath);
 
   try {
-    const artPath = path.join(targetPath, '.art');
     const artJsonPath = path.join(artPath, 'art.json');
-    const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
 
-    if (providedToken) {
-      artJson.configuration.personalAccessToken = providedToken;
-    }
-
-    artJson.remote = `${ARTIFACT_HOST}/${handle}/${repo}`;
+    const artJson = {
+      active: { branch: 'main', parent: null },
+      remote: `${ARTIFACT_HOST}/${handle}/${repo}`,
+      configuration: { handle: '', personalAccessToken: providedToken || '' }
+    };
 
     fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
 
@@ -174,7 +173,6 @@ async function clone (repoSlug, providedToken = null) {
         handle,
         repo,
         branch: 'main',
-
         ...(token && { personalAccessToken: token })
       })
     });
@@ -209,7 +207,6 @@ async function clone (repoSlug, providedToken = null) {
     });
 
     const historyManifest = await historyRes.json();
-
     const localHistoryDir = path.join(artPath, 'history/local/main');
     const remoteHistoryDir = path.join(artPath, 'history/remote/main');
 
@@ -217,10 +214,19 @@ async function clone (repoSlug, providedToken = null) {
       const commitRes = await fetch(`${ARTIFACT_HOST}/commit`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ handle, repo, branch: 'main', hash: commitHash, ...(token && { personalAccessToken: token }) })
+        body: JSON.stringify({
+          handle,
+          repo,
+          branch: 'main',
+          hash: commitHash,
+
+          ...(token && { personalAccessToken: token
+          })
+        })
       });
 
       const commitMaster = await commitRes.json();
+
       let fullChanges = {};
 
       if (commitMaster.parts && commitMaster.parts.length > 0) {
@@ -232,7 +238,6 @@ async function clone (repoSlug, providedToken = null) {
           });
 
           const partData = await partRes.json();
-
           fs.writeFileSync(path.join(localHistoryDir, partName), JSON.stringify(partData, null, 2));
           fs.writeFileSync(path.join(remoteHistoryDir, partName), JSON.stringify(partData, null, 2));
 
@@ -252,7 +257,6 @@ async function clone (repoSlug, providedToken = null) {
 
         if (Array.isArray(changeSet)) {
           let content = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
-
           for (const op of changeSet) {
             if (op.type === 'insert') {
               content = content.slice(0, op.position) + op.content + content.slice(op.position);
@@ -260,7 +264,6 @@ async function clone (repoSlug, providedToken = null) {
               content = content.slice(0, op.position) + content.slice(op.position + op.length);
             }
           }
-
           fs.writeFileSync(fullPath, content);
         } else if (changeSet.type === 'createFile') {
           fs.mkdirSync(path.dirname(fullPath), { recursive: true });
@@ -292,8 +295,7 @@ async function clone (repoSlug, providedToken = null) {
 /**
  * Updates the configuration in art.json.
  */
-
-function config (key, value) {
+function config(key, value) {
   const manifestPath = path.join(process.cwd(), '.art', 'art.json');
 
   if (!fs.existsSync(manifestPath)) {
@@ -304,7 +306,6 @@ function config (key, value) {
 
   if (key && value !== undefined) {
     manifest.configuration[key] = value;
-
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   }
 
@@ -316,5 +317,6 @@ module.exports = {
   __libraryAPIName: 'Setup',
   init,
   clone,
-  config
+  config,
+  ensureDirStructure
 };

package/utils/getStateByHash/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Utils (v0.2.9)
+ * Module: Utils (v0.3.1)
  */
 
 const fs = require('fs');

package/workflow/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Workflow (v0.2.9)
+ * Module: Workflow (v0.3.1)
  */
 
 const fs = require('fs');
@@ -10,6 +10,8 @@ const crypto = require('crypto');
 const getStateByHash = require('../utils/getStateByHash');
 const shouldIgnore = require('../utils/shouldIgnore');
 
+const MAX_PART_SIZE = 32000000;
+
 /**
  * Helper to load all changes from a paginated stage directory.
  */
@@ -27,8 +29,10 @@ function getStagedChanges(artPath) {
 
   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);
     }
   }
@@ -72,6 +76,7 @@ function status () {
 
     if (isIgnored && !isActive && !isStaged) {
       ignored.push(file);
+
       continue;
     }
 
@@ -79,6 +84,7 @@ function status () {
       untracked.push(file);
     } else if (!isStaged && isActive) {
       const currentContent = fs.readFileSync(path.join(root, file), 'utf8');
+
       if (currentContent !== activeState[file]) {
         modified.push(file);
       }
@@ -99,118 +105,124 @@ function status () {
  * Updates or creates a JSON diff in the stage directory.
  */
 
-function add (targetPath) {
-  const MAX_PART_SIZE = 32000000;
-  const root = process.cwd();
-  const artPath = path.join(root, '.art');
-  const stageDir = path.join(artPath, 'stage');
-  const artJsonPath = path.join(artPath, 'art.json');
-  const fullPath = path.resolve(root, targetPath);
+ function add (targetPath) {
+   const root = process.cwd();
+   const artPath = path.join(root, '.art');
+   const stageDir = path.join(artPath, 'stage');
+   const artJsonPath = path.join(artPath, 'art.json');
+   const fullPath = path.resolve(root, targetPath);
 
-  if (!fs.existsSync(fullPath)) throw new Error(`Path does not exist: ${targetPath}`);
+   if (!fs.existsSync(fullPath)) {
+     throw new Error(`Path does not exist: ${targetPath}`);
+   }
 
-  const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
-  const activeState = getStateByHash(artJson.active.branch, artJson.active.parent) || {};
-  const currentStaged = getStagedChanges(artPath);
+   const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+   const activeState = getStateByHash(artJson.active.branch, artJson.active.parent) || {};
+   const currentStaged = getStagedChanges(artPath);
 
-  const stats = fs.statSync(fullPath);
-  const relativeTarget = path.relative(root, fullPath);
+   const stats = fs.statSync(fullPath);
+   const relativeTarget = path.relative(root, fullPath);
 
-  if (!stats.isDirectory() && shouldIgnore(relativeTarget) && !activeState[relativeTarget]) {
-    return `${relativeTarget} is being ignored.`;
-  }
+   if (!stats.isDirectory() && shouldIgnore(relativeTarget) && !activeState[relativeTarget]) {
+     return `${relativeTarget} is being ignored.`;
+   }
 
-  let filesToProcess = [];
+   let filesToProcess = [];
 
-  if (stats.isDirectory()) {
-    filesToProcess = fs.readdirSync(fullPath, { recursive: true })
-      .filter(f => {
-        const absF = path.join(fullPath, f);
-        const relF = path.relative(root, absF);
+   if (stats.isDirectory()) {
+     filesToProcess = fs.readdirSync(fullPath, { recursive: true })
+       .filter(f => {
+         const absF = path.join(fullPath, f);
+         const relF = path.relative(root, absF);
 
-        return !fs.statSync(absF).isDirectory() && !relF.startsWith('.art') && (!shouldIgnore(relF) || !!activeState[relF]);
-      })
-      .map(f => path.relative(root, path.join(fullPath, f)));
-  } else {
-    filesToProcess = [relativeTarget];
-  }
+         return !fs.statSync(absF).isDirectory() && !relF.startsWith('.art') && (!shouldIgnore(relF) || !!activeState[relF]);
+       })
+       .map(f => path.relative(root, path.join(fullPath, f)));
+   } else {
+     filesToProcess = [relativeTarget];
+   }
 
-  if (filesToProcess.length === 0) return "No changes to add.";
+   if (filesToProcess.length === 0) return "No changes to add.";
 
-  for (const relPath of filesToProcess) {
-    const currentContent = fs.readFileSync(path.join(root, relPath), 'utf8');
-    const previousContent = activeState[relPath];
+   for (const relPath of filesToProcess) {
+     const currentContent = fs.readFileSync(path.join(root, relPath), 'utf8');
+     const previousContent = activeState[relPath];
 
-    if (previousContent === undefined) {
-      currentStaged[relPath] = { type: 'createFile', content: currentContent };
-    } else if (currentContent !== previousContent) {
-      let start = 0;
+     if (previousContent === undefined) {
+       currentStaged[relPath] = { type: 'createFile', content: currentContent };
+     } else if (currentContent !== previousContent) {
+       let start = 0;
 
-      while (start < previousContent.length && start < currentContent.length && previousContent[start] === currentContent[start]) {
-        start++;
-      }
+       while (start < previousContent.length && start < currentContent.length && previousContent[start] === currentContent[start]) {
+         start++;
+       }
 
-      let oldEnd = previousContent.length - 1;
-      let newEnd = currentContent.length - 1;
+       let oldEnd = previousContent.length - 1;
+       let newEnd = currentContent.length - 1;
 
-      while (oldEnd >= start && newEnd >= start && previousContent[oldEnd] === currentContent[newEnd]) {
-        oldEnd--; newEnd--;
-      }
+       while (oldEnd >= start && newEnd >= start && previousContent[oldEnd] === currentContent[newEnd]) {
+         oldEnd--; newEnd--;
+       }
 
-      const operations = [];
-      const deletionLength = oldEnd - start + 1;
+       const operations = [];
+       const deletionLength = oldEnd - start + 1;
 
-      if (deletionLength > 0) {
-        operations.push({ type: 'delete', position: start, length: deletionLength });
-      }
+       if (deletionLength > 0) {
+         operations.push({
+           type: 'delete',
+           position: start,
+           length: deletionLength,
+           content: previousContent.slice(start, oldEnd + 1)
+         });
+       }
 
-      const insertionContent = currentContent.slice(start, newEnd + 1);
+       const insertionContent = currentContent.slice(start, newEnd + 1);
 
-      if (insertionContent.length > 0) {
-        operations.push({ type: 'insert', position: start, content: insertionContent });
-      }
+       if (insertionContent.length > 0) {
+         operations.push({ type: 'insert', position: start, content: insertionContent });
+       }
 
-      if (operations.length > 0) {
-        currentStaged[relPath] = operations;
-      }
-    }
-  }
+       if (operations.length > 0) {
+         currentStaged[relPath] = operations;
+       }
+     }
+   }
 
-  if (fs.existsSync(stageDir)) fs.rmSync(stageDir, { recursive: true, force: true });
+   if (fs.existsSync(stageDir)) fs.rmSync(stageDir, { recursive: true, force: true });
 
-  fs.mkdirSync(stageDir, { recursive: true });
+   fs.mkdirSync(stageDir, { recursive: true });
 
-  const stageParts = [];
+   const stageParts = [];
 
-  let currentPartChanges = {};
-  let currentSize = 0;
+   let currentPartChanges = {};
+   let currentSize = 0;
 
-  const savePart = () => {
-    const partName = `part.${stageParts.length}.json`;
+   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;
-  };
+     fs.writeFileSync(path.join(stageDir, partName), JSON.stringify({ changes: currentPartChanges }, null, 2));
+     stageParts.push(partName);
+     currentPartChanges = {};
+     currentSize = 0;
+   };
 
-  for (const [file, changes] of Object.entries(currentStaged)) {
-    const size = JSON.stringify(changes).length;
+   for (const [file, changes] of Object.entries(currentStaged)) {
+     const size = JSON.stringify(changes).length;
 
-    if (currentSize + size > MAX_PART_SIZE && Object.keys(currentPartChanges).length > 0) {
-      savePart();
-    }
+     if (currentSize + size > MAX_PART_SIZE && Object.keys(currentPartChanges).length > 0) {
+       savePart();
+     }
 
-    currentPartChanges[file] = changes;
-    currentSize += size;
-  }
+     currentPartChanges[file] = changes;
+     currentSize += size;
+   }
 
-  savePart();
+   savePart();
 
-  fs.writeFileSync(path.join(stageDir, 'manifest.json'), JSON.stringify({ parts: stageParts }, null, 2));
+   fs.writeFileSync(path.join(stageDir, 'manifest.json'), JSON.stringify({ parts: stageParts }, null, 2));
 
-  return `Added ${filesToProcess.length} file(s) to paginated stage.`;
-}
+   return `Added ${filesToProcess.length} file(s) to stage.`;
+ }
 
 /**
  * Finalizes the paginated stage into a paginated commit structure.
@@ -290,7 +302,7 @@ function commit (message) {
 }
 
 module.exports = {
-  __libraryVersion: '0.2.9',
+  __libraryVersion: '0.3.1',
   __libraryAPIName: 'Workflow',
   status,
   add,