pagan-artifact 0.2.5

package/changes/index.js

@@ -0,0 +1,109 @@
+/**
+ * art - Modern version control.
+ * Module: Changes (v0.2.5)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const getStateByHash = require('../utils/getStateByHash');
+
+/**
+ * Iterates through the JSON commit files in the active branch folder.
+ * @returns {string} A formatted string of commit history.
+ */
+
+function log () {
+  const artPath = path.join(process.cwd(), '.art');
+  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 branch = artJson.active.branch;
+  const branchPath = path.join(artPath, 'history/local', branch);
+  const manifestPath = path.join(branchPath, 'manifest.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    return 'No commits found.';
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  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'));
+
+    output += `commit ${commitData.hash}\n`;
+    output += `Date: ${new Date(commitData.timestamp).toLocaleString()}\n`;
+    output += `\n    ${commitData.message}\n\n`;
+  }
+
+  return output;
+}
+
+/**
+ * Displays line-by-line differences between working directory and the last commit/stage.
+ * @returns {string} Formatted diff output.
+ */
+
+ 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 activeBranch = artJson.active.branch;
+  const lastCommitHash = artJson.active.parent;
+  const lastCommitState = lastCommitHash ? getStateByHash(activeBranch, lastCommitHash) : {};
+
+  const currentFiles = fs.readdirSync(root, { recursive: true })
+    .filter(f => !f.startsWith('.art') && !fs.statSync(path.join(root, f)).isDirectory());
+
+  const fileDiffs = [];
+
+  for (const filePath of currentFiles) {
+    const fullPath = path.join(root, filePath);
+    const currentContent = fs.readFileSync(fullPath, 'utf8');
+    const previousContent = lastCommitState[filePath] || '';
+
+    if (currentContent !== previousContent) {
+      let start = 0;
+
+      while (start < previousContent.length && start < currentContent.length && previousContent[start] === currentContent[start]) {
+        start++;
+      }
+
+      let oldEnd = previousContent.length - 1;
+      let newEnd = currentContent.length - 1;
+
+      while (oldEnd >= start && newEnd >= start && previousContent[oldEnd] === currentContent[newEnd]) {
+        oldEnd--;
+        newEnd--;
+      }
+
+      fileDiffs.push({
+        file: filePath,
+        deleted: previousContent.slice(start, oldEnd + 1),
+        added: currentContent.slice(start, newEnd + 1)
+      });
+    }
+  }
+
+  const stagePath = path.join(artPath, 'stage.json');
+  const staged = fs.existsSync(stagePath) ? Object.keys(JSON.parse(fs.readFileSync(stagePath, 'utf8')).changes) : [];
+
+  return { fileDiffs, staged };
+}
+
+module.exports = {
+  __libraryVersion: '0.2.5',
+  __libraryAPIName: 'Changes',
+  log,
+  diff
+};

package/contributions/index.js

@@ -0,0 +1,239 @@
+/**
+ * art - Modern version control.
+ * Module: Contributions (v0.2.5)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const pkg = require('../package.json');
+const { checkout } = require('../branching/index.js');
+
+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.');
+  }
+
+  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));
+  }
+
+  return artJson.remote;
+}
+
+/**
+ * Downloads JSON diff files from the remote server via POST.
+ */
+
+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>".');
+  }
+
+  const branch = artJson.active.branch;
+  const token = artJson.configuration.personalAccessToken;
+
+  const remoteParts = artJson.remote.split('/');
+  const repo = remoteParts.pop();
+  const handle = remoteParts.pop();
+
+  const remoteBranchPath = path.join(artPath, 'history/remote', branch);
+
+  if (!fs.existsSync(remoteBranchPath)) {
+    fs.mkdirSync(remoteBranchPath, { recursive: true });
+  }
+
+  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();
+
+  for (const commitHash of remoteManifest.commits) {
+    const commitFilePath = path.join(remoteBranchPath, `${commitHash}.json`);
+
+    if (!fs.existsSync(commitFilePath)) {
+      const commitResponse = await fetch(`${ARTIFACT_HOST}/commit`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          handle,
+          repo,
+          branch,
+          hash: commitHash,
+
+          ...(token && { personalAccessToken: token })
+        })
+      });
+
+      const commitDiff = await commitResponse.json();
+
+      fs.writeFileSync(commitFilePath, JSON.stringify(commitDiff, 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.
+ */
+
+async function pull () {
+  const artPath = path.join(process.cwd(), '.art');
+  const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+  const branch = artJson.active.branch;
+
+  await fetchRemote();
+
+  const remoteManifestPath = path.join(artPath, 'history/remote', branch, 'manifest.json');
+  const remoteManifest = JSON.parse(fs.readFileSync(remoteManifestPath, 'utf8'));
+
+  const localManifestPath = path.join(artPath, 'history/local', branch, 'manifest.json');
+  const localManifest = JSON.parse(fs.readFileSync(localManifestPath, 'utf8'));
+
+  const newCommits = remoteManifest.commits.filter(hash => !localManifest.commits.includes(hash));
+
+  if (newCommits.length === 0) {
+    return 'Already up to date.';
+  }
+
+  for (const commitHash of newCommits) {
+    const remoteCommitFile = path.join(artPath, 'history/remote', branch, `${commitHash}.json`);
+    const remoteData = fs.readFileSync(remoteCommitFile, 'utf8');
+
+    fs.writeFileSync(
+      path.join(artPath, 'history/local', branch, `${commitHash}.json`),
+      remoteData
+    );
+
+    localManifest.commits.push(commitHash);
+  }
+
+  fs.writeFileSync(localManifestPath, JSON.stringify(localManifest, null, 2));
+  checkout(branch);
+
+  return `Applied ${newCommits.length} commits.`;
+}
+
+/**
+ * Uploads local JSON diffs that do not exist in the remote history.
+ */
+
+ 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 localManifest = JSON.parse(fs.readFileSync(path.join(artPath, 'history/local', branch, '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 (missingCommits.length === 0) {
+     return 'Everything up to date.';
+   }
+
+   let rootData = null;
+
+   if (remoteManifest.commits.length === 0) {
+     const rootManifestPath = path.join(artPath, 'root/manifest.json');
+
+     if (fs.existsSync(rootManifestPath)) {
+       rootData = JSON.parse(fs.readFileSync(rootManifestPath, 'utf8'));
+     }
+   }
+
+   for (const commitHash of missingCommits) {
+     const commitData = JSON.parse(fs.readFileSync(path.join(artPath, 'history/local', branch, `${commitHash}.json`), 'utf8'));
+
+     await fetch(`${ARTIFACT_HOST}/push`, {
+       method: 'POST',
+       headers: { 'Content-Type': 'application/json' },
+       body: JSON.stringify({
+         handle,
+         repo,
+         branch,
+         commit: commitData,
+
+         ...(rootData && { root: rootData }),
+
+         ...(token && { personalAccessToken: token })
+       })
+     });
+
+     rootData = null;
+   }
+
+   const remoteManifestPath = path.join(artPath, 'history/remote', branch, 'manifest.json');
+
+   fs.writeFileSync(remoteManifestPath, JSON.stringify(localManifest, null, 2));
+
+   return `Pushed ${missingCommits.length} commits to remote.`;
+ }
+
+module.exports = {
+  __libraryVersion: pkg.version,
+  __libraryAPIName: 'Contributions',
+  remote,
+  fetch: fetchRemote,
+  pull,
+  push
+};

package/index.js

@@ -0,0 +1,64 @@
+/**
+ * art - Modern version control.
+ * Core Library Entry Point (v0.2.5)
+ */
+
+const Setup = require('./setup');
+const Workflow = require('./workflow');
+const Branching = require('./branching');
+const Contributions = require('./contributions');
+const Changes = require('./changes');
+const Caches = require('./caches');
+
+const art = {
+
+  // Setup
+
+  init: Setup.init,
+  clone: Setup.clone,
+  config: Setup.config,
+
+  // Workflow
+
+  status: Workflow.status,
+  add: Workflow.add,
+  commit: Workflow.commit,
+
+  // Branching
+
+  branch: Branching.branch,
+  checkout: Branching.checkout,
+  merge: Branching.merge,
+
+  // Contributions
+
+  remote: Contributions.remote,
+  fetch: Contributions.fetch,
+  pull: Contributions.pull,
+  push: Contributions.push,
+
+  // Changes
+
+  log: Changes.log,
+  diff: Changes.diff,
+
+  // Caches
+
+  stash: Caches.stash,
+  reset: Caches.reset,
+  rm: Caches.rm,
+
+  // Metadata
+
+  version: '0.2.5',
+  modules: [
+    Setup.__libraryAPIName,
+    Workflow.__libraryAPIName,
+    Branching.__libraryAPIName,
+    Contributions.__libraryAPIName,
+    Changes.__libraryAPIName,
+    Caches.__libraryAPIName
+  ]
+};
+
+module.exports = art;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "pagan-artifact",
+  "version": "0.2.5",
+  "description": "Modern version control.",
+  "main": "index.js",
+  "bin": {
+    "art": "./bin/art.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "vcs",
+    "version-control",
+    "git-alternative",
+    "json-diff"
+  ],
+  "author": "bennyschmidt",
+  "license": "ISC",
+  "engines": {
+    "node": ">=24.11.0"
+  },
+  "artConfig": {
+    "host": "https://www.paganartifact.com/artifact"
+  }
+}

package/setup/index.js

@@ -0,0 +1,271 @@
+/**
+ * art - Modern version control.
+ * Module: Setup (v0.2.5)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const pkg = require('../package.json');
+const { remote } = require('../contributions');
+
+const ARTIFACT_HOST = pkg.artConfig.host || 'http://localhost:1337';
+
+/**
+ * Initializes the local .art directory structure.
+ */
+
+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).filter(f => f !== '.art');
+  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}`;
+}
+
+/**
+ * Clones a repository by fetching manifests and commits via POST.
+ * @param {string} repoSlug - The handle/repo identifier.
+ * @param {string} providedToken - Optional token for authentication.
+ */
+
+async function clone (repoSlug, providedToken = null) {
+  if (!repoSlug || !repoSlug.includes('/')) {
+    throw new Error('A valid slug is required (e.g., handle/repo).');
+  }
+
+  const [handle, repo] = repoSlug.split('/');
+  const targetPath = path.join(process.cwd(), repo);
+  const originalCwd = process.cwd();
+
+  if (fs.existsSync(targetPath)) {
+    throw new Error(`Destination path "${targetPath}" already exists.`);
+  }
+
+  fs.mkdirSync(targetPath, { recursive: true });
+  init(targetPath);
+  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}`;
+
+    fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
+
+    const token = artJson.configuration.personalAccessToken;
+
+    const rootRes = await fetch(`${ARTIFACT_HOST}/manifest`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'root',
+        handle,
+        repo,
+        branch: 'main',
+
+        ...(token && { personalAccessToken: token })
+      })
+    });
+
+    if (!rootRes.ok) {
+      throw new Error(`Failed to fetch root: ${rootRes.statusText}`);
+    }
+
+    const rootManifest = await rootRes.json();
+
+    if (rootManifest.files) {
+      fs.writeFileSync(
+        path.join(artPath, 'root/manifest.json'),
+        JSON.stringify(rootManifest, null, 2)
+      );
+
+      for (const file of rootManifest.files) {
+        const workingPath = path.join(targetPath, file.path);
+
+        fs.mkdirSync(path.dirname(workingPath), { recursive: true });
+        fs.writeFileSync(workingPath, file.content);
+      }
+    }
+
+    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 })
+      })
+    });
+
+    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 })
+          })
+        });
+
+        const commitDiff = await commitRes.json();
+
+        for (const filePath of Object.keys(commitDiff.changes)) {
+          const fullPath = path.join(targetPath, filePath);
+          const changeSet = commitDiff.changes[filePath];
+
+          if (Array.isArray(changeSet)) {
+            let content = fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
+
+            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)}`;
+              }
+            }
+
+           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);
+         }
+       }
+
+       const commitContent = JSON.stringify(commitDiff, null, 2);
+
+       fs.writeFileSync(path.join(localHistoryDir, `${commitHash}.json`), commitContent);
+       fs.writeFileSync(path.join(remoteHistoryDir, `${commitHash}.json`), commitContent);
+
+       localManifest.commits.push(commitHash);
+     }
+    }
+
+    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 updatedDepJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+
+    if (localManifest.commits.length > 0) {
+      updatedDepJson.active.parent = localManifest.commits[localManifest.commits.length - 1];
+      fs.writeFileSync(artJsonPath, JSON.stringify(updatedDepJson, null, 2));
+    }
+
+    return `Successfully cloned and replayed ${repoSlug}.`;
+  } catch (error) {
+    throw error;
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+/**
+ * Updates the configuration in art.json.
+ */
+
+function config (key, value) {
+  const manifestPath = path.join(process.cwd(), '.art', 'art.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No art repository found.');
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  if (key && value !== undefined) {
+    manifest.configuration[key] = value;
+
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  return manifest.configuration;
+}
+
+module.exports = {
+  __libraryVersion: pkg.version,
+  __libraryAPIName: 'Setup',
+  init,
+  clone,
+  config
+};