pagan-artifact 0.2.8 → 0.3.0

package/setup/index.js

@@ -1,99 +1,133 @@
 /**
  * art - Modern version control.
- * Module: Setup (v0.2.8)
+ * Module: Setup (v0.3.0)
  */
 
 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';
 
 /**
- * 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}`;
-   }
-
-   for (const folder of folders) {
-     const fullPath = path.join(artDirectory, folder);
-
-     if (!fs.existsSync(fullPath)) {
-       fs.mkdirSync(fullPath, { recursive: true });
-     }
-   }
-
-   const files = fs.readdirSync(directoryPath, { recursive: true })
-     .filter(f => {
-       const isInternal = f === '.art' || f.startsWith('.art' + path.sep);
-
-       return !isInternal && !shouldIgnore(f);
-     });
-
-   const rootManifest = { files: [] };
-
-   for (const file of files) {
-     const fullPath = path.join(directoryPath, file);
-
-     if (fs.lstatSync(fullPath).isFile()) {
-       rootManifest.files.push({
-         path: file,
-         content: fs.readFileSync(fullPath, 'utf8')
-       });
-     }
-   }
-
-   fs.writeFileSync(
-     path.join(artDirectory, 'root/manifest.json'),
-     JSON.stringify(rootManifest, 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)
-   );
-
-   const artFile = {
-     active: { branch: 'main', parent: null },
-     remote: '',
-     configuration: { handle: '', personalAccessToken: '' }
-   };
-
-   fs.writeFileSync(
-     path.join(artDirectory, 'art.json'),
-     JSON.stringify(artFile, null, 2)
-   );
-
-   return `Initialized empty 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 });
+    }
+  }
+}
 
 /**
- * Clones a repository by fetching manifests and commits via POST.
- * @param {string} repoSlug - The handle/repo identifier.
- * @param {string} providedToken - Optional token for authentication.
+ * Initializes the local .art directory structure and indexes current files.
+ */
+
+function init (directoryPath = process.cwd()) {
+  const artDirectory = path.join(directoryPath, '.art');
+
+  if (fs.existsSync(artDirectory)) {
+    return `Reinitialized existing art repository in ${artDirectory}`;
+  }
+
+  ensureDirStructure(artDirectory);
+
+  const files = fs.readdirSync(directoryPath, { recursive: true })
+    .filter(f => {
+      const isInternal = f === '.art' || f.startsWith('.art' + path.sep);
+      return !isInternal && !shouldIgnore(f);
+    });
+
+  const rootMasterManifest = { parts: [] };
+  let currentPartFiles = [];
+  let currentPartChars = 0;
+  const MAX_PART_CHARS = 32000000;
+
+  const saveManifestPart = () => {
+    if (currentPartFiles.length === 0) return;
+
+    const partIndex = rootMasterManifest.parts.length;
+    const partName = `manifest.part.${Date.now()}.${partIndex}.json`;
+    const partPath = path.join(artDirectory, 'root', partName);
+
+    fs.writeFileSync(
+      partPath,
+      JSON.stringify({ files: currentPartFiles }, null, 2)
+    );
+
+    rootMasterManifest.parts.push(partName);
+    currentPartFiles = [];
+    currentPartChars = 0;
+  };
+
+  for (const file of files) {
+    const fullPath = path.join(directoryPath, file);
+
+    if (fs.lstatSync(fullPath).isFile()) {
+      const content = fs.readFileSync(fullPath, 'utf8');
+
+      if (currentPartChars + content.length > MAX_PART_CHARS && currentPartFiles.length > 0) {
+        saveManifestPart();
+      }
+
+      currentPartFiles.push({
+        path: file,
+        content: content
+      });
+
+      currentPartChars += content.length;
+    }
+  }
+
+  saveManifestPart();
+
+  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/remote/main/manifest.json'),
+    JSON.stringify({ commits: [] }, null, 2)
+  );
+
+  const artFile = {
+    active: { branch: 'main', parent: null },
+    remote: '',
+    configuration: { handle: '', personalAccessToken: '' }
+  };
+
+  fs.writeFileSync(
+    path.join(artDirectory, 'art.json'),
+    JSON.stringify(artFile, null, 2)
+  );
+
+  return `Initialized empty art repository in ${artDirectory}.`;
+}
+
+/**
+ * Clone a repository and replay history.
  */
 
 async function clone (repoSlug, providedToken = null) {
@@ -110,19 +144,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));
 
@@ -136,26 +171,26 @@ async function clone (repoSlug, providedToken = null) {
         handle,
         repo,
         branch: 'main',
-
         ...(token && { personalAccessToken: token })
       })
     });
 
-    if (!rootRes.ok) {
-      throw new Error(`Failed to fetch root: ${rootRes.statusText}`);
-    }
+    const masterManifest = await rootRes.json();
 
-    const rootManifest = await rootRes.json();
+    fs.writeFileSync(path.join(artPath, 'root/manifest.json'), JSON.stringify(masterManifest, null, 2));
 
-    if (rootManifest.files) {
-      fs.writeFileSync(
-        path.join(artPath, 'root/manifest.json'),
-        JSON.stringify(rootManifest, null, 2)
-      );
+    for (const partName of masterManifest.parts) {
+      const partRes = await fetch(`${ARTIFACT_HOST}/part`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ handle, repo, partName, ...(token && { personalAccessToken: token }) })
+      });
 
-      for (const file of rootManifest.files) {
-        const workingPath = path.join(targetPath, file.path);
+      const partData = await partRes.json();
+      fs.writeFileSync(path.join(artPath, 'root', partName), JSON.stringify(partData, null, 2));
 
+      for (const file of partData.files) {
+        const workingPath = path.join(targetPath, file.path);
         fs.mkdirSync(path.dirname(workingPath), { recursive: true });
         fs.writeFileSync(workingPath, file.content);
       }
@@ -164,79 +199,85 @@ async function clone (repoSlug, providedToken = null) {
     const historyRes = await fetch(`${ARTIFACT_HOST}/manifest`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        type: 'history',
-        handle,
-        repo,
-        branch: 'main',
-
-        ...(token && { personalAccessToken: token })
-      })
+      body: JSON.stringify({ type: 'history', handle, repo, branch: 'main', ...(token && { personalAccessToken: token }) })
     });
 
     const historyManifest = await historyRes.json();
-    const localManifest = { commits: [] };
     const localHistoryDir = path.join(artPath, 'history/local/main');
     const remoteHistoryDir = path.join(artPath, 'history/remote/main');
 
-    if (historyManifest.commits) {
-      for (const commitHash of historyManifest.commits) {
-        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 })
+    for (const commitHash of historyManifest.commits) {
+      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
           })
-        });
+        })
+      });
 
-        const commitDiff = await commitRes.json();
+      const commitMaster = await commitRes.json();
 
-        for (const filePath of Object.keys(commitDiff.changes)) {
-          const fullPath = path.join(targetPath, filePath);
-          const changeSet = commitDiff.changes[filePath];
+      let fullChanges = {};
 
-          if (Array.isArray(changeSet)) {
-            let content = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
+      if (commitMaster.parts && commitMaster.parts.length > 0) {
+        for (const partName of commitMaster.parts) {
+          const partRes = await fetch(`${ARTIFACT_HOST}/commit/part`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ handle, repo, branch: 'main', partName, ...(token && { personalAccessToken: token }) })
+          });
 
-            for (const operation of changeSet) {
-              if (operation.type === 'insert') {
-                content = `${content.slice(0, operation.position)}${operation.content}${content.slice(operation.position)}`;
-              } else if (operation.type === 'delete') {
-                content = `${content.slice(0, operation.position)}${content.slice(operation.position + operation.length)}`;
-              }
-            }
+          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));
 
-           fs.writeFileSync(fullPath, content);
-         } else if (changeSet.type === 'createFile') {
-           fs.mkdirSync(path.dirname(fullPath), { recursive: true });
-           fs.writeFileSync(fullPath, changeSet.content || '');
-         } else if (changeSet.type === 'deleteFile' && fs.existsSync(fullPath)) {
-           fs.unlinkSync(fullPath);
-         }
-       }
+          Object.assign(fullChanges, partData.changes);
+        }
+      } else if (commitMaster.changes) {
+        fullChanges = commitMaster.changes;
+      }
+
+      const masterContent = JSON.stringify(commitMaster, null, 2);
 
-       const commitContent = JSON.stringify(commitDiff, null, 2);
+      fs.writeFileSync(path.join(localHistoryDir, `${commitHash}.json`), masterContent);
+      fs.writeFileSync(path.join(remoteHistoryDir, `${commitHash}.json`), masterContent);
 
-       fs.writeFileSync(path.join(localHistoryDir, `${commitHash}.json`), commitContent);
-       fs.writeFileSync(path.join(remoteHistoryDir, `${commitHash}.json`), commitContent);
+      for (const [filePath, changeSet] of Object.entries(fullChanges)) {
+        const fullPath = path.join(targetPath, filePath);
 
-       localManifest.commits.push(commitHash);
-     }
+        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);
+            } else if (op.type === 'delete') {
+              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 });
+          fs.writeFileSync(fullPath, changeSet.content || '');
+        } else if (changeSet.type === 'deleteFile' && fs.existsSync(fullPath)) {
+          fs.unlinkSync(fullPath);
+        }
+      }
     }
 
-    fs.writeFileSync(path.join(localHistoryDir, 'manifest.json'), JSON.stringify(localManifest, null, 2));
-    fs.writeFileSync(path.join(remoteHistoryDir, 'manifest.json'), JSON.stringify(localManifest, null, 2));
+    const manifestJson = JSON.stringify({ commits: historyManifest.commits }, null, 2);
 
-    const updatedDepJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+    fs.writeFileSync(path.join(localHistoryDir, 'manifest.json'), manifestJson);
+    fs.writeFileSync(path.join(remoteHistoryDir, 'manifest.json'), manifestJson);
 
-    if (localManifest.commits.length > 0) {
-      updatedDepJson.active.parent = localManifest.commits[localManifest.commits.length - 1];
-      fs.writeFileSync(artJsonPath, JSON.stringify(updatedDepJson, null, 2));
+    if (historyManifest.commits.length > 0) {
+      artJson.active.parent = historyManifest.commits[historyManifest.commits.length - 1];
+      fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
     }
 
     return `Successfully cloned and replayed ${repoSlug}.`;
@@ -250,8 +291,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)) {
@@ -262,7 +302,6 @@ function config (key, value) {
 
   if (key && value !== undefined) {
     manifest.configuration[key] = value;
-
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   }
 
@@ -274,5 +313,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.8)
+ * Module: Utils (v0.3.0)
  */
 
 const fs = require('fs');
@@ -10,58 +10,78 @@ const path = require('path');
  * Helper to reconstruct file states at a specific commit hash.
  */
 
-module.exports = (branchName, targetHash) => {
-  const artPath = path.join(process.cwd(), '.art');
-  const rootPath = path.join(artPath, 'root/manifest.json');
+ module.exports = (branchName, targetHash) => {
+   const artPath = path.join(process.cwd(), '.art');
+   const rootPath = path.join(artPath, 'root/manifest.json');
 
-  if (!fs.existsSync(rootPath)) return {};
+   if (!fs.existsSync(rootPath)) return {};
 
-  const rootManifest = JSON.parse(fs.readFileSync(rootPath, 'utf8'));
-  const branchPath = path.join(artPath, 'history/local', branchName);
-  const manifestPath = path.join(branchPath, 'manifest.json');
+   const rootMaster = JSON.parse(fs.readFileSync(rootPath, 'utf8'));
+   const branchPath = path.join(artPath, 'history/local', branchName);
+   const manifestPath = path.join(branchPath, 'manifest.json');
 
-  if (!fs.existsSync(manifestPath)) return {};
+   if (!fs.existsSync(manifestPath)) return {};
 
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+   const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
 
-  let state = {};
+   let state = {};
 
-  for (const file of rootManifest.files) {
-    state[file.path] = file.content;
-  }
+   for (const partName of rootMaster.parts) {
+     const partPath = path.join(artPath, 'root', partName);
+     const partData = JSON.parse(fs.readFileSync(partPath, 'utf8'));
 
-  for (const hash of manifest.commits) {
-    const commitPath = path.join(branchPath, `${hash}.json`);
+     for (const file of partData.files) {
+       state[file.path] = file.content;
+     }
+   }
 
-    if (!fs.existsSync(commitPath)) continue;
+   if (!targetHash) return state;
 
-    const commit = JSON.parse(fs.readFileSync(commitPath, 'utf8'));
+   for (const hash of manifest.commits) {
+     const commitPath = path.join(branchPath, `${hash}.json`);
 
-    for (const [filePath, changeSet] of Object.entries(commit.changes)) {
-      if (Array.isArray(changeSet)) {
-        let currentContent = state[filePath] || '';
+     if (!fs.existsSync(commitPath)) continue;
 
-        for (const operation of changeSet) {
-          if (operation.type === 'insert') {
-            currentContent = `${currentContent.slice(0, operation.position)}${operation.content}${currentContent.slice(operation.position)}`;
-          } else if (operation.type === 'delete') {
-            currentContent = `${currentContent.slice(0, operation.position)}${currentContent.slice(operation.position + operation.length)}`;
-          }
-        }
+     const commitMaster = JSON.parse(fs.readFileSync(commitPath, 'utf8'));
 
-        state[filePath] = currentContent;
+     let fullChanges = {};
 
-      } else {
-        if (changeSet.type === 'createFile') {
-          state[filePath] = changeSet.content;
-        } else if (changeSet.type === 'deleteFile') {
-          delete state[filePath];
-        }
-      }
-    }
+     if (commitMaster.parts && Array.isArray(commitMaster.parts)) {
+       for (const partName of commitMaster.parts) {
+         const partPath = path.join(branchPath, partName);
+         if (fs.existsSync(partPath)) {
+           const partData = JSON.parse(fs.readFileSync(partPath, 'utf8'));
+           Object.assign(fullChanges, partData.changes);
+         }
+       }
+     } else if (commitMaster.changes) {
+       fullChanges = commitMaster.changes;
+     }
 
-    if (hash === targetHash) break;
-  }
+     for (const [filePath, changeSet] of Object.entries(fullChanges)) {
+       if (Array.isArray(changeSet)) {
+         let currentContent = state[filePath] || '';
 
-  return state;
-};
+         for (const operation of changeSet) {
+           if (operation.type === 'insert') {
+             currentContent = `${currentContent.slice(0, operation.position)}${operation.content}${currentContent.slice(operation.position)}`;
+           } else if (operation.type === 'delete') {
+             currentContent = `${currentContent.slice(0, operation.position)}${currentContent.slice(operation.position + operation.length)}`;
+           }
+         }
+
+         state[filePath] = currentContent;
+       } else {
+         if (changeSet.type === 'createFile') {
+           state[filePath] = changeSet.content;
+         } else if (changeSet.type === 'deleteFile') {
+           delete state[filePath];
+         }
+       }
+     }
+
+     if (hash === targetHash) break;
+   }
+
+   return state;
+ };