pagan-artifact 0.2.8 → 0.3.0

package/changes/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Changes (v0.2.8)
+ * Module: Changes (v0.3.0)
  */
 
 const fs = require('fs');
@@ -34,15 +34,17 @@ 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 commitData = JSON.parse(fs.readFileSync(path.join(branchPath, `${hash}.json`), 'utf8'));
+    const commitMasterPath = path.join(branchPath, `${hash}.json`);
+
+    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`;
+      output += `commit ${commitData.hash}\n`;
+      output += `Date: ${new Date(commitData.timestamp).toLocaleString()}\n`;
+      output += `\n    ${commitData.message}\n\n`;
+    }
   }
 
   return output;
@@ -50,14 +52,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 () {
+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) : {};
@@ -69,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]) {
@@ -92,17 +102,41 @@ 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: '' });
+      }
     }
   }
 
-  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.8',
+  __libraryVersion: '0.3.0',
   __libraryAPIName: 'Changes',
   log,
   diff

package/contributions/index.js

@@ -1,6 +1,6 @@
 /**
  * art - Modern version control.
- * Module: Contributions (v0.2.8)
+ * Module: Contributions (v0.3.0)
  */
 
 const fs = require('fs');
@@ -13,25 +13,19 @@ const ARTIFACT_HOST = pkg.artConfig.host || 'http://localhost:1337';
 
 /**
  * Configures the single URL endpoint in art.json for synchronization.
- * Supports full URLs or "handle/repo" slugs.
  */
 
 function remote (input) {
   const artPath = path.join(process.cwd(), '.art', 'art.json');
-
-  if (!fs.existsSync(artPath)) {
-    throw new Error('No art repository found.');
-  }
+  if (!fs.existsSync(artPath)) throw new Error('No art repository found.');
 
   const artJson = JSON.parse(fs.readFileSync(artPath, 'utf8'));
 
   if (input) {
     let finalUrl = input;
-
     if (input.includes('/') && !input.startsWith('http')) {
       finalUrl = `${ARTIFACT_HOST}/${input}`;
     }
-
     artJson.remote = finalUrl;
     fs.writeFileSync(artPath, JSON.stringify(artJson, null, 2));
   }
@@ -40,16 +34,14 @@ function remote (input) {
 }
 
 /**
- * Downloads JSON diff files from the remote server via POST.
+ * Downloads paginated JSON diff files from the remote server.
  */
 
 async function fetchRemote () {
   const artPath = path.join(process.cwd(), '.art');
   const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
 
-  if (!artJson.remote) {
-    throw new Error('Remote URL not configured. Use "art remote <handle>/<repo>".');
-  }
+  if (!artJson.remote) throw new Error('Remote URL not configured.');
 
   const branch = artJson.active.branch;
   const token = artJson.configuration.personalAccessToken;
@@ -72,7 +64,6 @@ async function fetchRemote () {
       handle,
       repo,
       branch,
-
       ...(token && { personalAccessToken: token })
     })
   });
@@ -80,38 +71,50 @@ async function fetchRemote () {
   const remoteManifest = await response.json();
 
   for (const commitHash of remoteManifest.commits) {
-    const commitFilePath = path.join(remoteBranchPath, `${commitHash}.json`);
+    const commitMasterPath = path.join(remoteBranchPath, `${commitHash}.json`);
 
-    if (!fs.existsSync(commitFilePath)) {
-      const commitResponse = await fetch(`${ARTIFACT_HOST}/commit`, {
+    if (!fs.existsSync(commitMasterPath)) {
+      const commitRes = await fetch(`${ARTIFACT_HOST}/commit`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          handle,
-          repo,
-          branch,
-          hash: commitHash,
-
+          handle, repo, branch, hash: commitHash,
           ...(token && { personalAccessToken: token })
         })
       });
 
-      const commitDiff = await commitResponse.json();
+      const commitMaster = await commitRes.json();
 
-      fs.writeFileSync(commitFilePath, JSON.stringify(commitDiff, null, 2));
+      fs.writeFileSync(commitMasterPath, JSON.stringify(commitMaster, null, 2));
+
+      for (const partName of commitMaster.parts) {
+        const partPath = path.join(remoteBranchPath, partName);
+
+        if (!fs.existsSync(partPath)) {
+          const partRes = await fetch(`${ARTIFACT_HOST}/commit/part`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              handle, repo, branch, partName,
+              ...(token && { personalAccessToken: token })
+            })
+          });
+
+          const partData = await partRes.json();
+
+          fs.writeFileSync(partPath, JSON.stringify(partData, null, 2));
+        }
+      }
     }
   }
 
-  fs.writeFileSync(
-    path.join(remoteBranchPath, 'manifest.json'),
-    JSON.stringify(remoteManifest, null, 2)
-  );
+  fs.writeFileSync(path.join(remoteBranchPath, 'manifest.json'), JSON.stringify(remoteManifest, null, 2));
 
   return `Fetched remote history for branch: ${branch}`;
 }
 
 /**
- * Performs a fetch and applies remote JSON diffs to local branch and files.
+ * Applies remote paginated commits to local branch.
  */
 
 async function pull () {
@@ -121,11 +124,11 @@ async function pull () {
 
   await fetchRemote();
 
-  const remoteManifestPath = path.join(artPath, 'history/remote', branch, 'manifest.json');
-  const remoteManifest = JSON.parse(fs.readFileSync(remoteManifestPath, 'utf8'));
+  const remoteBranchPath = path.join(artPath, 'history/remote', branch);
+  const localBranchPath = path.join(artPath, 'history/local', branch);
 
-  const localManifestPath = path.join(artPath, 'history/local', branch, 'manifest.json');
-  const localManifest = JSON.parse(fs.readFileSync(localManifestPath, 'utf8'));
+  const remoteManifest = JSON.parse(fs.readFileSync(path.join(remoteBranchPath, 'manifest.json'), 'utf8'));
+  const localManifest = JSON.parse(fs.readFileSync(path.join(localBranchPath, 'manifest.json'), 'utf8'));
 
   const newCommits = remoteManifest.commits.filter(hash => !localManifest.commits.includes(hash));
 
@@ -134,100 +137,127 @@ async function pull () {
   }
 
   for (const commitHash of newCommits) {
-    const remoteCommitFile = path.join(artPath, 'history/remote', branch, `${commitHash}.json`);
-    const remoteData = fs.readFileSync(remoteCommitFile, 'utf8');
+    const masterData = fs.readFileSync(path.join(remoteBranchPath, `${commitHash}.json`), 'utf8');
+    const masterJson = JSON.parse(masterData);
+
+    fs.writeFileSync(path.join(localBranchPath, `${commitHash}.json`), masterData);
 
-    fs.writeFileSync(
-      path.join(artPath, 'history/local', branch, `${commitHash}.json`),
-      remoteData
-    );
+    for (const partName of masterJson.parts) {
+      const partContent = fs.readFileSync(path.join(remoteBranchPath, partName), 'utf8');
+
+      fs.writeFileSync(path.join(localBranchPath, partName), partContent);
+    }
 
     localManifest.commits.push(commitHash);
   }
 
-  fs.writeFileSync(localManifestPath, JSON.stringify(localManifest, null, 2));
+  fs.writeFileSync(path.join(localBranchPath, 'manifest.json'), JSON.stringify(localManifest, null, 2));
   checkout(branch);
 
   return `Applied ${newCommits.length} commits.`;
 }
 
 /**
- * Uploads local JSON diffs that do not exist in the remote history.
+ * Uploads local commits via the two-step /push and /commit/part flow.
  */
 
- async function push () {
-   const artPath = path.join(process.cwd(), '.art');
-   const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+async function push () {
+  const artPath = path.join(process.cwd(), '.art');
+  const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+
+  if (!artJson.remote) throw new Error('Remote URL not configured.');
+
+  const branch = artJson.active.branch;
+  const token = artJson.configuration.personalAccessToken;
+  const remoteParts = artJson.remote.split('/');
+  const repo = remoteParts.pop();
+  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,
+      ...(token && { personalAccessToken: token })
+    })
+  });
+
+  const remoteManifest = await response.json();
+  const missingCommits = localManifest.commits.filter(hash => !remoteManifest.commits.includes(hash));
 
-   if (!artJson.remote) {
-     throw new Error('Remote URL not configured.');
-   }
+  if (missingCommits.length === 0) {
+    return 'Everything up to date.';
+  }
 
-   const branch = artJson.active.branch;
-   const token = artJson.configuration.personalAccessToken;
-   const remoteParts = artJson.remote.split('/');
-   const repo = remoteParts.pop();
-   const handle = remoteParts.pop();
+  let rootData = null;
 
-   const localManifest = JSON.parse(fs.readFileSync(path.join(artPath, 'history/local', branch, 'manifest.json'), 'utf8'));
+  if (remoteManifest.commits.length === 0) {
+    const rootMasterPath = path.join(artPath, 'root/manifest.json');
 
-   const response = await fetch(`${ARTIFACT_HOST}/manifest`, {
-     method: 'POST',
-     headers: { 'Content-Type': 'application/json' },
-     body: JSON.stringify({
-       type: 'history',
-       handle,
-       repo,
-       branch,
+    if (fs.existsSync(rootMasterPath)) {
+      const master = JSON.parse(fs.readFileSync(rootMasterPath, 'utf8'));
+      const parts = {};
 
-       ...(token && { personalAccessToken: token })
-     })
-   });
+      for (const partName of master.parts) {
+        parts[partName] = JSON.parse(fs.readFileSync(path.join(artPath, 'root', partName), 'utf8'));
+      }
 
-   const remoteManifest = await response.json();
-   const missingCommits = localManifest.commits.filter(hash => !remoteManifest.commits.includes(hash));
+      rootData = { master, parts };
+    }
+  }
 
-   if (missingCommits.length === 0) {
-     return 'Everything up to date.';
-   }
+  const currentRemoteManifestPath = path.join(remoteBranchPath, 'manifest.json');
+  const currentRemoteManifest = fs.existsSync(currentRemoteManifestPath)
+    ? JSON.parse(fs.readFileSync(currentRemoteManifestPath, 'utf8'))
+    : { commits: [] };
 
-   let rootData = null;
+  for (const commitHash of missingCommits) {
+    const commitMaster = JSON.parse(fs.readFileSync(path.join(localBranchPath, `${commitHash}.json`), 'utf8'));
 
-   if (remoteManifest.commits.length === 0) {
-     const rootManifestPath = path.join(artPath, 'root/manifest.json');
+    const pushRes = await fetch(`${ARTIFACT_HOST}/push`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        handle, repo, branch, commit: commitMaster,
 
-     if (fs.existsSync(rootManifestPath)) {
-       rootData = JSON.parse(fs.readFileSync(rootManifestPath, 'utf8'));
-     }
-   }
+        ...(rootData && { root: rootData }),
 
-   for (const commitHash of missingCommits) {
-     const commitData = JSON.parse(fs.readFileSync(path.join(artPath, 'history/local', branch, `${commitHash}.json`), 'utf8'));
+        ...(token && { personalAccessToken: token })
+      })
+    });
 
-     await fetch(`${ARTIFACT_HOST}/push`, {
-       method: 'POST',
-       headers: { 'Content-Type': 'application/json' },
-       body: JSON.stringify({
-         handle,
-         repo,
-         branch,
-         commit: commitData,
+    if (!pushRes.ok) throw new Error(`Server rejected push for commit ${commitHash}`);
 
-         ...(rootData && { root: rootData }),
+    rootData = null;
 
-         ...(token && { personalAccessToken: token })
-       })
-     });
+    for (const partName of commitMaster.parts) {
+      const partData = JSON.parse(fs.readFileSync(path.join(localBranchPath, partName), 'utf8'));
 
-     rootData = null;
-   }
+      const partRes = await fetch(`${ARTIFACT_HOST}/commit/part`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle, repo, branch, partName, partData,
+          ...(token && { personalAccessToken: token })
+        })
+      });
 
-   const remoteManifestPath = path.join(artPath, 'history/remote', branch, 'manifest.json');
+      if (!partRes.ok) throw new Error(`Server failed to receive part ${partName}`);
+    }
 
-   fs.writeFileSync(remoteManifestPath, JSON.stringify(localManifest, null, 2));
+    currentRemoteManifest.commits.push(commitHash);
+    fs.writeFileSync(currentRemoteManifestPath, JSON.stringify(currentRemoteManifest, null, 2));
+  }
 
-   return `Pushed ${missingCommits.length} commits to remote.`;
- }
+  return `Pushed ${missingCommits.length} commits to remote.`;
+}
 
 module.exports = {
   __libraryVersion: pkg.version,

package/index.js

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

package/package.json

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