pagan-artifact 0.2.5

package/.nvmrc

@@ -0,0 +1 @@
+24.11.0

package/README.md

@@ -0,0 +1,13 @@
+# Artifact
+
+Artifact is a modern and efficient version control system designed for simplicity and transparency. It tracks changes as discrete state snapshots and synchronizes seamlessly the network.
+
+## Installation
+
+Install globally via npm to use the `art` command anywhere in your terminal:
+
+```bash
+npm i -g pagan-artifact
+```
+
+Available commands: `init`, `clone`, `status`, `add`, `commit`, `branch`, `checkout`, `merge`, `remote`, `fetch`, `pull`, `push`, `log`, `diff`, `stash`, `reset`, `rm`

package/bin/art.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+/**
+ * art - Modern version control.
+ * CLI (v0.2.5)
+ */
+
+const art = require('../index.js');
+
+const [,, command, ...args] = process.argv;
+
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const RESET = '\x1b[0m';
+
+async function run() {
+  try {
+    switch (command) {
+      case 'init':
+        console.log(art.init(args[0]));
+
+        break;
+
+      case 'clone':
+        if (!args[0]) {
+          throw new Error('Specify a repository slug (handle/repo).');
+        }
+
+        const tokenIndex = args.indexOf('--token');
+        const cliToken = (tokenIndex !== -1) && args[tokenIndex + 1];
+
+        console.log(await art.clone(args[0], cliToken));
+
+        break;
+
+      case 'config':
+        console.log(art.config(args[0], args[1]));
+
+        break;
+
+      case 'status':
+        const {
+          activeBranch,
+          lastCommit,
+          staged,
+          modified,
+          untracked
+        } = art.status();
+
+        console.log(`On branch ${activeBranch}`);
+        console.log(`Last commit: ${lastCommit || 'None'}`);
+
+        if (staged.length > 0) {
+          console.log('\nChanges to be committed:');
+          staged.forEach(f => console.log(`${GREEN}\t${f}${RESET}`));
+        }
+
+        if (modified.length > 0) {
+          console.log('\nChanges not staged for commit:');
+          modified.forEach(f => console.log(`${RED}\tmodified: ${f}${RESET}`));
+        }
+
+        if (untracked.length > 0) {
+          console.log('\nUntracked files:');
+          untracked.forEach(f => console.log(`${RED}\t${f}${RESET}`));
+        }
+
+        if (untracked.length === 0 && modified.length === 0 && staged.length === 0) {
+          console.log('Nothing to commit.');
+        }
+
+        break;
+
+      case 'add':
+        if (!args[0]) throw new Error('Specify a file path to add.');
+
+        console.log(art.add(args[0]));
+
+        break;
+
+      case 'commit':
+        if (!args[0]) throw new Error('Specify a commit message.');
+        console.log(art.commit(args[0]));
+
+        break;
+
+      case 'branch':
+        const deleteFlags = ['--delete', '-d', '-D'];
+        const isDelete = deleteFlags.includes(args[0]);
+        const branchName = isDelete ? args[1] : args[0];
+
+        const branches = art.branch({ name: branchName, isDelete });
+
+        if (Array.isArray(branches)) {
+          for (const b of branches) console.log(b);
+        } else {
+          console.log(branches);
+        }
+
+        break;
+
+      case 'checkout':
+        if (!args[0]) throw new Error('Specify a branch name.');
+
+        console.log(art.checkout(args[0]));
+
+        break;
+
+      case 'merge':
+        if (!args[0]) throw new Error('Specify a target branch to merge.');
+
+        console.log(art.merge(args[0]));
+
+        break;
+
+      case 'remote':
+        console.log(art.remote(args[0]));
+
+        break;
+
+      case 'fetch':
+        console.log(await art.fetch());
+
+        break;
+
+      case 'pull':
+        console.log(await art.pull());
+
+        break;
+
+      case 'push':
+        console.log(await art.push());
+
+        break;
+
+      case 'log':
+        console.log(art.log());
+
+        break;
+
+      case 'diff':
+        const { fileDiffs, staged: diffStaged } = art.diff();
+
+        if (fileDiffs.length === 0 && diffStaged.length === 0) {
+          console.log('No changes detected.');
+
+          break;
+        }
+
+        for (const df of fileDiffs) {
+          console.log(`diff --art a/${df.file} b/${df.file}`);
+
+          if (df.deleted) {
+            df.deleted.split('\n').forEach(line => {
+              console.log(`${RED}- ${line}${RESET}`);
+            });
+          }
+
+          if (df.added) {
+            df.added.split('\n').forEach(line => {
+              console.log(`${GREEN}+ ${line}${RESET}`);
+            });
+          }
+
+          console.log('');
+        }
+
+        if (diffStaged.length > 0) {
+          console.log('--- Staged Changes ---');
+          diffStaged.forEach(f => console.log(`staged: ${GREEN}${f}${RESET}`));
+        }
+
+        break;
+
+      case 'stash':
+        const isPop = args[0] === 'pop';
+        const isList = args[0] === 'list';
+        const result = art.stash({ pop: isPop, list: isList });
+
+        if (isList && Array.isArray(result)) {
+          if (result.length === 0) {
+            console.log('No stashes found.');
+          } else {
+            console.log('Saved stashes:');
+
+            for (const s of result) {
+              console.log(`${s.id}: WIP on branch: (${s.date})`);
+            }
+          }
+        } else {
+          console.log(result);
+        }
+
+        break;
+
+      case 'reset':
+        console.log(art.reset(args[0]));
+
+        break;
+
+      case 'rm':
+        if (!args[0]) throw new Error('Specify a file path to remove.');
+
+        console.log(art.rm(args[0]));
+
+        break;
+
+      case '--version':
+      case '-v':
+        console.log(`art version ${art.version}`);
+
+        break;
+
+      default:
+        console.log('Usage: art <command> [arguments]');
+        console.log('Available commands: init, clone, status, add, commit, branch, checkout, merge, remote, fetch, pull, push, log, diff, stash, reset, rm');
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+run();

package/branching/index.js

@@ -0,0 +1,234 @@
+/**
+ * art - Modern version control.
+ * Module: Branching (v0.2.5)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const getStateByHash = require('../utils/getStateByHash');
+
+/**
+ * Lists, creates, or deletes branches.
+ */
+
+function branch ({ name, isDelete = false } = {}) {
+  const artPath = path.join(process.cwd(), '.art');
+  const localHistoryPath = path.join(artPath, 'history/local');
+  const remoteHistoryPath = path.join(artPath, 'history/remote');
+  const artJsonPath = path.join(artPath, 'art.json');
+
+  if (!name) {
+   return fs.readdirSync(localHistoryPath).filter(f => {
+     return f !== '.DS_Store' && f !== 'desktop.ini' && f !== 'thumbs.db';
+   });
+  }
+
+  const illegalRegExp = /[\/\\]/g;
+  const controlRegExp = /[\x00-\x1f\x80-\x9f]/g;
+  const reservedRegExp = /^\.+$/;
+
+  if (illegalRegExp.test(name) || controlRegExp.test(name) || reservedRegExp.test(name)) {
+    throw new Error(`Invalid branch name: "${name}". Branch names cannot contain slashes or illegal characters.`);
+  }
+
+  const branchLocalPath = path.join(localHistoryPath, name);
+  const branchRemotePath = path.join(remoteHistoryPath, name);
+
+  if (isDelete) {
+    if (!fs.existsSync(branchLocalPath)) {
+      throw new Error(`Local branch "${name}" does not exist.`);
+    }
+
+    const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+
+    if (artJson.active.branch === name) {
+      throw new Error(`Local branch "${name}" is in use and can't be deleted right now.`);
+    }
+
+    fs.rmSync(branchLocalPath, { recursive: true, force: true });
+
+    if (fs.existsSync(branchRemotePath)) {
+      fs.rmSync(branchRemotePath, { recursive: true, force: true });
+    }
+
+    return `Deleted local branch "${name}".`;
+  }
+
+  if (fs.existsSync(branchLocalPath)) {
+    throw new Error(`Local branch "${name}" already exists.`);
+  }
+
+  const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+  const currentBranchManifest = path.join(localHistoryPath, artJson.active.branch, 'manifest.json');
+
+  let initialCommits = [];
+
+  if (fs.existsSync(currentBranchManifest)) {
+    initialCommits = JSON.parse(fs.readFileSync(currentBranchManifest, 'utf8')).commits;
+  }
+
+  fs.mkdirSync(branchLocalPath, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(branchLocalPath, 'manifest.json'),
+    JSON.stringify({ commits: initialCommits }, null, 2)
+  );
+
+  if (!fs.existsSync(branchRemotePath)) {
+    fs.mkdirSync(branchRemotePath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(branchRemotePath, 'manifest.json'),
+      JSON.stringify({ commits: initialCommits }, null, 2)
+    );
+  }
+
+  if (initialCommits.length > 0) {
+    const sourceBranchPath = path.join(localHistoryPath, artJson.active.branch);
+
+    for (const hash of initialCommits) {
+      const srcFile = path.join(sourceBranchPath, `${hash}.json`);
+      const destFile = path.join(branchLocalPath, `${hash}.json`);
+
+      if (fs.existsSync(srcFile)) {
+        fs.copyFileSync(srcFile, destFile);
+      }
+    }
+  }
+
+  return `Created branch "${name}".`;
+}
+
+/**
+ * Updates the active pointer and reconstructs the working directory.
+ */
+
+function checkout (branchName, { force = false } = {}) {
+  const root = process.cwd();
+  const artPath = path.join(root, '.art');
+  const artJsonPath = path.join(artPath, 'art.json');
+  const branchPath = path.join(artPath, 'history/local', branchName);
+
+  if (!fs.existsSync(branchPath)) {
+    branch({ name: branchName });
+  }
+
+  const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+  const currentState = getStateByHash(artJson.active.branch, artJson.active.parent) || {};
+
+  if (!force) {
+    const allWorkDirFiles = fs.readdirSync(root, { recursive: true })
+      .filter(f => !f.startsWith('.art') && !fs.statSync(path.join(root, f)).isDirectory());
+
+    let isDirty = false;
+    for (const file of allWorkDirFiles) {
+      const currentContent = fs.readFileSync(path.join(root, file), 'utf8');
+      if (currentContent !== currentState[file]) {
+        isDirty = true;
+        break;
+      }
+    }
+
+    if (!isDirty) {
+      for (const file in currentState) {
+        if (!fs.existsSync(path.join(root, file))) {
+          isDirty = true;
+          break;
+        }
+      }
+    }
+
+    if (isDirty) {
+      throw new Error('Your local changes would be overwritten by checkout. Please commit or stash them.');
+    }
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(path.join(branchPath, 'manifest.json'), 'utf8'));
+
+  const targetHash = manifest.commits.length > 0
+    ? manifest.commits[manifest.commits.length - 1]
+    : null;
+
+  const targetState = getStateByHash(branchName, targetHash);
+
+  for (const filePath of Object.keys(currentState)) {
+    if (!targetState[filePath]) {
+      const fullPath = path.join(root, filePath);
+      if (fs.existsSync(fullPath)) fs.rmSync(fullPath, { recursive: true, force: true });
+    }
+  }
+
+  for (const [filePath, content] of Object.entries(targetState)) {
+    const fullPath = path.join(root, filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+  }
+
+  artJson.active.branch = branchName;
+  artJson.active.parent = targetHash;
+  fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
+
+  return `Switched to branch "${branchName}".`;
+}
+
+/**
+ * Performs a three-way merge. Overwrites working directory with conflicts.
+ */
+
+function merge (targetBranch) {
+  const root = process.cwd();
+  const artPath = path.join(root, '.art');
+  const artJson = JSON.parse(fs.readFileSync(path.join(artPath, 'art.json'), 'utf8'));
+  const activeBranch = artJson.active.branch;
+
+  const activeManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${activeBranch}/manifest.json`), 'utf8'));
+  const targetManifest = JSON.parse(fs.readFileSync(path.join(artPath, `history/local/${targetBranch}/manifest.json`), 'utf8'));
+
+  const commonAncestorHash = [...activeManifest.commits].reverse().find(h => targetManifest.commits.includes(h)) || null;
+
+  const baseState = commonAncestorHash ? getStateByHash(activeBranch, commonAncestorHash) : {};
+  const activeState = getStateByHash(activeBranch, artJson.active.parent);
+  const lastTargetHash = targetManifest.commits[targetManifest.commits.length - 1];
+  const targetState = getStateByHash(targetBranch, lastTargetHash);
+
+  const mergedChanges = {};
+  const allFiles = new Set([...Object.keys(activeState), ...Object.keys(targetState)]);
+
+  for (const filePath of allFiles) {
+    const base = baseState[filePath];
+    const active = activeState[filePath];
+    const target = targetState[filePath];
+    const fullPath = path.join(root, filePath);
+
+    if (active === target) continue;
+
+    if (base === active && base !== target) {
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, target || '');
+
+      mergedChanges[filePath] = { type: 'createFile', content: target };
+    } else if (base !== active && base !== target && active !== target) {
+      const conflictContent = `<<<<<<< active\n${active || ''}\n=======\n${target || ''}\n>>>>>>> ${targetBranch}`;
+
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, conflictContent);
+
+      mergedChanges[filePath] = { type: 'createFile', content: conflictContent };
+    }
+  }
+
+  const stage = { changes: mergedChanges };
+
+  fs.writeFileSync(path.join(artPath, 'stage.json'), JSON.stringify(stage, null, 2));
+
+  return `Merged ${targetBranch}. Conflicts written to the stage and working directory to be resolved.`;
+}
+
+module.exports = {
+  __libraryVersion: '0.2.5',
+  __libraryAPIName: 'Branching',
+  branch,
+  checkout,
+  merge
+};

package/caches/index.js

@@ -0,0 +1,223 @@
+/**
+ * art - Modern version control.
+ * Module: Caches (v0.2.5)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { checkout } = require('../branching/index.js');
+const getStateByHash = require('../utils/getStateByHash');
+
+/**
+ * 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');
+  const stagePath = path.join(artPath, 'stage.json');
+  const cachePath = path.join(artPath, 'cache');
+  const artJsonPath = path.join(artPath, 'art.json');
+
+  if (list) {
+    if (!fs.existsSync(cachePath)) return [];
+    const stashFiles = fs.readdirSync(cachePath)
+      .filter(f => f.startsWith('stash_') && f.endsWith('.json'))
+      .sort();
+
+    return stashFiles.map((file, index) => ({
+      id: `stash@{${stashFiles.length - 1 - index}}`,
+      date: new Date(parseInt(file.replace('stash_', '').replace('.json', ''))).toLocaleString(),
+      file
+    }));
+  }
+
+  if (pop) {
+    if (!fs.existsSync(cachePath)) throw new Error('No stashes found.');
+
+    const stashes = fs.readdirSync(cachePath)
+      .filter(f => f.startsWith('stash_') && f.endsWith('.json'))
+      .sort();
+
+    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'));
+
+    for (const [filePath, changeSet] of Object.entries(stashData.changes)) {
+      const fullPath = path.join(root, 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') {
+        if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+      }
+    }
+
+    fs.unlinkSync(latestStashPath);
+
+    return `Restored changes from ${latestStashName}.`;
+  }
+
+  const artJson = JSON.parse(fs.readFileSync(artJsonPath, 'utf8'));
+  const activeState = getStateByHash(artJson.active.branch, artJson.active.parent) || {};
+
+  const allWorkDirFiles = fs.readdirSync(root, { recursive: true })
+    .filter(f => !f.startsWith('.art') && !fs.statSync(path.join(root, f)).isDirectory());
+
+  const stashChanges = {};
+
+  for (const file of allWorkDirFiles) {
+    const currentContent = fs.readFileSync(path.join(root, file), 'utf8');
+    const previousContent = activeState[file];
+
+    if (previousContent === undefined) {
+      stashChanges[file] = { type: 'createFile', content: currentContent };
+    } else 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--;
+      }
+
+      const ops = [];
+      const delLen = oldEnd - start + 1;
+
+      if (delLen > 0) ops.push({ type: 'delete', position: start, length: delLen });
+
+      const insCont = currentContent.slice(start, newEnd + 1);
+
+      if (insCont.length > 0) ops.push({ type: 'insert', position: start, content: insCont });
+
+      if (ops.length > 0) stashChanges[file] = ops;
+    }
+  }
+
+  for (const file in activeState) {
+    if (!fs.existsSync(path.join(root, file))) {
+      stashChanges[file] = { type: 'deleteFile' };
+    }
+  }
+
+  if (Object.keys(stashChanges).length === 0) {
+    return 'No local changes to stash.';
+  }
+
+  if (!fs.existsSync(cachePath)) fs.mkdirSync(cachePath, { recursive: true });
+
+  const timestamp = Date.now();
+
+  fs.writeFileSync(path.join(cachePath, `stash_${timestamp}.json`), JSON.stringify({ changes: stashChanges }, null, 2));
+
+  if (fs.existsSync(stagePath)) {
+    fs.unlinkSync(stagePath);
+  }
+
+  checkout(artJson.active.branch, { force: true });
+
+  return `Saved working directory changes to stash_${timestamp}.json 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 stagePath = path.join(artPath, 'stage.json');
+  const artJsonPath = path.join(artPath, 'art.json');
+
+  if (fs.existsSync(stagePath)) {
+    fs.unlinkSync(stagePath);
+  }
+
+  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}.`);
+  }
+
+  artJson.active.parent = hash;
+  fs.writeFileSync(artJsonPath, JSON.stringify(artJson, null, 2));
+
+  const manifestPath = path.join(branchPath, 'manifest.json');
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  const hashIndex = manifest.commits.indexOf(hash);
+
+  if (hashIndex !== -1) {
+    manifest.commits = manifest.commits.slice(0, hashIndex + 1);
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  }
+
+  checkout(branch);
+
+  return `Head 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 stagePath = path.join(artPath, 'stage.json');
+  const fullPath = path.join(process.cwd(), filePath);
+
+  let stage = { changes: {} };
+
+  if (fs.existsSync(stagePath)) {
+    stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+  }
+
+  stage.changes[filePath] = {
+    type: 'deleteFile'
+  };
+
+  fs.writeFileSync(stagePath, JSON.stringify(stage, null, 2));
+
+  if (fs.existsSync(fullPath)) {
+    fs.unlinkSync(fullPath);
+  }
+
+  return `File ${filePath} marked for removal.`;
+}
+
+module.exports = {
+  __libraryVersion: '0.2.5',
+  __libraryAPIName: 'Caches',
+  stash,
+  reset,
+  rm
+};