dep-vcs 0.0.1

package/.nvmrc

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

package/README.md

@@ -0,0 +1,12 @@
+# dep-vcs
+
+**dep** is an 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 `dep` command anywhere in your terminal:
+
+```bash
+npm install -g dep-vcs

package/bin/dep.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * dep - Simple version control
+ * CLI Binary (v0.0.1)
+ */
+
+const dep = require('../index.js');
+
+const [,, command, ...args] = process.argv;
+
+async function run() {
+  try {
+    switch (command) {
+      case 'init':
+        console.log(dep.init(args[0]));
+
+        break;
+
+      case 'clone':
+        console.log(await dep.clone(args[0]));
+
+        break;
+
+      case 'config':
+        console.log(dep.config(args[0], args[1]));
+
+        break;
+
+      case 'status':
+        const s = dep.status();
+
+        console.log(`On branch ${s.activeBranch}`);
+        console.log(`Last commit: ${s.lastCommit || 'None'}`);
+
+        if (s.staged.length > 0) {
+          console.log('\nChanges to be committed:');
+
+          for (const file of s.staged) console.log(`  (staged): ${file}`);
+        } else {
+          console.log('\nNothing staged.');
+        }
+
+        break;
+
+      case 'add':
+        if (!args[0]) throw new Error('Specify a file path to add.');
+
+        console.log(dep.add(args[0]));
+
+        break;
+
+      case 'commit':
+        if (!args[0]) throw new Error('Specify a commit message.');
+        console.log(dep.commit(args[0]));
+
+        break;
+
+      case 'branch':
+        const branches = dep.branch(args[0]);
+
+        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(dep.checkout(args[0]));
+
+        break;
+
+      case 'merge':
+        if (!args[0]) throw new Error('Specify a target branch to merge.');
+
+        console.log(dep.merge(args[0]));
+
+        break;
+
+      case 'remote':
+        console.log(dep.remote(args[0]));
+
+        break;
+
+      case 'fetch':
+        console.log(await dep.fetch());
+
+        break;
+
+      case 'pull':
+        console.log(await dep.pull());
+
+        break;
+
+      case 'push':
+        console.log(await dep.push());
+
+        break;
+
+      case 'log':
+        console.log(dep.log());
+
+        break;
+
+      case 'diff':
+        console.log(dep.diff());
+        break;
+
+      case 'stash':
+        const isPop = args[0] === 'pop';
+
+        console.log(dep.stash({ pop: isPop }));
+
+        break;
+
+      case 'reset':
+        console.log(dep.reset(args[0]));
+
+        break;
+
+      case 'rm':
+        if (!args[0]) throw new Error('Specify a file path to remove.');
+
+        console.log(dep.rm(args[0]));
+
+        break;
+
+      case '--version':
+      case '-v':
+        console.log(`dep version ${dep.version}`);
+
+        break;
+
+      default:
+        console.log('Usage: dep <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,141 @@
+/**
+ * dep - Simple version control
+ * Module: Branching (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const getStateByHash = require('../utils/getStateByHash');
+
+/**
+ * Lists, creates, or deletes branches.
+ */
+
+function branch (name) {
+  const depPath = path.join(process.cwd(), '.dep');
+  const localHistoryPath = path.join(depPath, 'history/local');
+
+  if (!name) {
+    return fs.readdirSync(localHistoryPath);
+  }
+
+  const branchPath = path.join(localHistoryPath, name);
+
+  if (fs.existsSync(branchPath)) {
+    throw new Error(`Branch "${name}" already exists.`);
+  }
+
+  fs.mkdirSync(branchPath, { recursive: true });
+
+  const historyManifest = {
+    commits: []
+  };
+
+  fs.writeFileSync(
+    path.join(branchPath, 'manifest.json'),
+    JSON.stringify(historyManifest, null, 2)
+  );
+
+  return `Created branch "${name}".`;
+}
+
+/**
+ * Updates the active pointer and reconstructs the working directory.
+ */
+
+function checkout (branchName) {
+  const depPath = path.join(process.cwd(), '.dep');
+  const depJsonPath = path.join(depPath, 'dep.json');
+  const branchPath = path.join(depPath, 'history/local', branchName);
+
+  if (!fs.existsSync(branchPath)) {
+    branch(branchName);
+  }
+
+  const depJson = JSON.parse(fs.readFileSync(depJsonPath, 'utf8'));
+  const targetState = getStateByHash(branchName, null);
+
+  const currentFiles = fs.readdirSync(process.cwd()).filter(f => f !== '.dep');
+
+  for (const f of currentFiles) {
+    fs.rmSync(path.join(process.cwd(), f), { recursive: true, force: true });
+  }
+
+  for (const [filePath, content] of Object.entries(targetState)) {
+    const fullPath = path.join(process.cwd(), filePath);
+
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(path.join(branchPath, 'manifest.json'), 'utf8'));
+
+  depJson.active.branch = branchName;
+  depJson.active.parent = manifest.commits.length > 0 ? manifest.commits[manifest.commits.length - 1] : null;
+
+  fs.writeFileSync(depJsonPath, JSON.stringify(depJson, 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 depPath = path.join(root, '.dep');
+  const depJson = JSON.parse(fs.readFileSync(path.join(depPath, 'dep.json'), 'utf8'));
+  const activeBranch = depJson.active.branch;
+
+  const activeManifest = JSON.parse(fs.readFileSync(path.join(depPath, `history/local/${activeBranch}/manifest.json`), 'utf8'));
+  const targetManifest = JSON.parse(fs.readFileSync(path.join(depPath, `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, depJson.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(depPath, '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.0.1',
+  __libraryAPIName: 'Branching',
+  branch,
+  checkout,
+  merge
+};

package/caches/index.js

@@ -0,0 +1,162 @@
+/**
+ * dep - Simple version control
+ * Module: Caches (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { checkout } = require('../Branching/index.js');
+
+/**
+ * Moves stage.json to a cache folder, or restores the most recent stash.
+ * @param {object} options - Configuration for the stash operation.
+ * @param {boolean} options.pop - Whether to restore and remove the latest stash.
+ * @returns {string} Result message.
+ */
+
+function stash ({ pop = false } = {}) {
+  const depPath = path.join(process.cwd(), '.dep');
+  const stagePath = path.join(depPath, 'stage.json');
+  const cachePath = path.join(depPath, 'cache');
+
+  if (pop) {
+    if (!fs.existsSync(cachePath)) {
+      return 'No stashes found.';
+    }
+
+    const stashes = fs.readdirSync(cachePath)
+      .filter(f => f.startsWith('stash_') && f.endsWith('.json'))
+      .sort();
+
+    if (stashes.length === 0) {
+      return 'No stashes found.';
+    }
+
+    const latestStashName = stashes[stashes.length - 1];
+    const latestStashPath = path.join(cachePath, latestStashName);
+    const stashData = JSON.parse(fs.readFileSync(latestStashPath, 'utf8'));
+
+    let currentStage = { changes: {} };
+
+    if (fs.existsSync(stagePath)) {
+      currentStage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+    }
+
+    // Merge stashed changes into current stage and apply to working directory
+
+    for (const [filePath, change] of Object.entries(stashData.changes)) {
+      currentStage.changes[filePath] = change;
+
+      const fullPath = path.join(process.cwd(), filePath);
+
+      if (change.type === 'createFile' || change.type === 'update') {
+        fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+        fs.writeFileSync(fullPath, change.content);
+      } else if (change.type === 'deleteFile') {
+        if (fs.existsSync(fullPath)) fs.unlinkSync(fullPath);
+      }
+    }
+
+    fs.writeFileSync(stagePath, JSON.stringify(currentStage, null, 2));
+    fs.unlinkSync(latestStashPath);
+
+    return `Dropped ${latestStashName} and updated working directory.`;
+  }
+
+  // Standard Stash (Push) logic
+
+  if (!fs.existsSync(stagePath)) {
+    return 'No changes to stash.';
+  }
+
+  if (!fs.existsSync(cachePath)) {
+    fs.mkdirSync(cachePath, { recursive: true });
+  }
+
+  const timestamp = Date.now();
+  const stashFilePath = path.join(cachePath, `stash_${timestamp}.json`);
+
+  fs.renameSync(stagePath, stashFilePath);
+
+  return `Saved working directory and index state in stash_${timestamp}`;
+}
+
+/**
+ * Wipes the stage and moves the active parent pointer if a hash is provided.
+ */
+
+function reset (hash) {
+  const depPath = path.join(process.cwd(), '.dep');
+  const stagePath = path.join(depPath, 'stage.json');
+  const depJsonPath = path.join(depPath, 'dep.json');
+
+  if (fs.existsSync(stagePath)) {
+    fs.unlinkSync(stagePath);
+  }
+
+  if (!hash) {
+    return 'Staging area cleared.';
+  }
+
+  const depJson = JSON.parse(fs.readFileSync(depJsonPath, 'utf8'));
+  const branch = depJson.active.branch;
+  const branchPath = path.join(depPath, 'history/local', branch);
+  const commitPath = path.join(branchPath, `${hash}.json`);
+
+  if (!fs.existsSync(commitPath)) {
+    throw new Error(`Commit ${hash} not found in branch ${branch}.`);
+  }
+
+  depJson.active.parent = hash;
+  fs.writeFileSync(depJsonPath, JSON.stringify(depJson, 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 depPath = path.join(process.cwd(), '.dep');
+  const stagePath = path.join(depPath, '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.0.1',
+  __libraryAPIName: 'Caches',
+  stash,
+  reset,
+  rm
+};

package/changes/index.js

@@ -0,0 +1,120 @@
+/**
+ * dep - Simple version control
+ * Module: Changes (v0.0.1)
+ */
+
+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 depPath = path.join(process.cwd(), '.dep');
+  const depJsonPath = path.join(depPath, 'dep.json');
+
+  if (!fs.existsSync(depJsonPath)) {
+    throw new Error('No dep repository found.');
+  }
+
+  const depJson = JSON.parse(fs.readFileSync(depJsonPath, 'utf8'));
+  const branch = depJson.active.branch;
+  const branchPath = path.join(depPath, '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 depPath = path.join(root, '.dep');
+  const depJson = JSON.parse(fs.readFileSync(path.join(depPath, 'dep.json'), 'utf8'));
+
+  const activeBranch = depJson.active.branch;
+  const lastCommitHash = depJson.active.parent;
+
+  // Get the state as of the last commit
+
+  const lastCommitState = lastCommitHash ? getStateByHash(activeBranch, lastCommitHash) : {};
+
+  // Get current working directory files (excluding .dep)
+
+  const currentFiles = fs.readdirSync(root).filter(f => f !== '.dep' && fs.lstatSync(path.join(root, f)).isFile());
+
+  let output = '';
+
+  for (const filePath of currentFiles) {
+    const fullPath = path.join(root, filePath);
+    const currentContent = fs.readFileSync(fullPath, 'utf8');
+    const previousContent = lastCommitState[filePath] || '';
+
+    if (currentContent !== previousContent) {
+      output += `diff --dep a/${filePath} b/${filePath}\n`;
+
+      const prevLines = previousContent.split('\n');
+      const currLines = currentContent.split('\n');
+
+      // Simple line-by-line comparison
+
+      for (const line of prevLines) {
+        if (!currLines.includes(line)) {
+          output += `- ${line}\n`;
+        }
+      }
+
+      for (const line of currLines) {
+        if (!prevLines.includes(line)) {
+          output += `+ ${line}\n`;
+        }
+      }
+      output += '\n';
+    }
+  }
+
+  const stagePath = path.join(depPath, 'stage.json');
+
+  if (fs.existsSync(stagePath)) {
+    output += `--- Staged Changes ---\n`;
+    const stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+    for (const stagedFile of Object.keys(stage.changes)) {
+      output += `staged: ${stagedFile}\n`;
+    }
+  }
+
+  return output || 'No changes detected.';
+}
+
+module.exports = {
+  __libraryVersion: '0.0.1',
+  __libraryAPIName: 'Changes',
+  log,
+  diff
+};

package/contributions/index.js

@@ -0,0 +1,174 @@
+/**
+ * dep - Simple version control
+ * Module: Contributions (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const pkg = require('../../package.json');
+
+const { checkout } = require('../Branching/index.js');
+
+const DEP_HOST = pkg.depConfig.host || 'http://localhost:1337';
+
+/**
+ * Configures the single URL endpoint in dep.json for synchronization.
+ * Supports full URLs or "userName/repoName" slugs.
+ * @param {string} input - The remote endpoint or slug.
+ * @returns {string} The current remote URL.
+ */
+
+function remote (input) {
+  const depPath = path.join(process.cwd(), '.dep', 'dep.json');
+
+  if (!fs.existsSync(depPath)) {
+    throw new Error('No dep repository found.');
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(depPath, 'utf8'));
+
+  if (input) {
+    let finalUrl = input;
+
+    if (input.includes('/') && !input.startsWith('http')) {
+      finalUrl = `${DEP_HOST}/code/${input}`;
+    }
+
+    manifest.remote = finalUrl;
+    fs.writeFileSync(depPath, JSON.stringify(manifest, null, 2));
+  }
+
+  return manifest.remote;
+}
+
+/**
+ * Downloads JSON diff files from the remote server into history/remote.
+ * @returns {Promise<string>} Result message.
+ */
+
+async function fetchRemote () {
+  const depPath = path.join(process.cwd(), '.dep');
+  const depJson = JSON.parse(fs.readFileSync(path.join(depPath, 'dep.json'), 'utf8'));
+
+  if (!depJson.remote) {
+    throw new Error('Remote URL not configured. Use "dep remote <url|slug>".');
+  }
+
+  const branch = depJson.active.branch;
+  const remoteBranchPath = path.join(depPath, 'history/remote', branch);
+
+  if (!fs.existsSync(remoteBranchPath)) {
+    fs.mkdirSync(remoteBranchPath, { recursive: true });
+  }
+
+  const response = await fetch(`${depJson.remote}/history/remote/${branch}/manifest.json`);
+  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(`${depJson.remote}/history/remote/${branch}/${commitHash}.json`);
+      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 depPath = path.join(process.cwd(), '.dep');
+  const depJson = JSON.parse(fs.readFileSync(path.join(depPath, 'dep.json'), 'utf8'));
+  const branch = depJson.active.branch;
+
+  await fetchRemote();
+
+  const remoteManifestPath = path.join(depPath, 'history/remote', branch, 'manifest.json');
+  const remoteManifest = JSON.parse(fs.readFileSync(remoteManifestPath, 'utf8'));
+
+  const localManifestPath = path.join(depPath, '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(depPath, 'history/remote', branch, `${commitHash}.json`);
+    const remoteData = fs.readFileSync(remoteCommitFile, 'utf8');
+
+    fs.writeFileSync(
+      path.join(depPath, '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 depPath = path.join(process.cwd(), '.dep');
+  const depJson = JSON.parse(fs.readFileSync(path.join(depPath, 'dep.json'), 'utf8'));
+
+  if (!depJson.remote) {
+    throw new Error('Remote URL not configured.');
+  }
+
+  const branch = depJson.active.branch;
+  const localManifest = JSON.parse(fs.readFileSync(path.join(depPath, 'history/local', branch, 'manifest.json'), 'utf8'));
+
+  const response = await fetch(`${depJson.remote}/history/remote/${branch}/manifest.json`);
+  const remoteManifest = await response.json();
+
+  const missingCommits = localManifest.commits.filter(hash => !remoteManifest.commits.includes(hash));
+
+  if (missingCommits.length === 0) {
+    return 'Everything up to date.';
+  }
+
+  for (const commitHash of missingCommits) {
+    const commitData = JSON.parse(fs.readFileSync(path.join(depPath, 'history/local', branch, `${commitHash}.json`), 'utf8'));
+
+    await fetch(`${depJson.remote}/source/push`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        branch: branch,
+        commit: commitData
+      })
+    });
+  }
+
+  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 @@
+/**
+ * dep - Simple version control
+ * Core Library Entry Point (v0.0.1)
+ */
+
+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 dep = {
+
+  // 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.0.1',
+  modules: [
+    Setup.__libraryAPIName,
+    Workflow.__libraryAPIName,
+    Branching.__libraryAPIName,
+    Contributions.__libraryAPIName,
+    Changes.__libraryAPIName,
+    Caches.__libraryAPIName
+  ]
+};
+
+module.exports = dep;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "dep-vcs",
+  "version": "0.0.1",
+  "description": "Efficient version control.",
+  "main": "index.js",
+  "bin": {
+    "dep": "./bin/dep.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"
+  },
+  "depConfig": {
+    "host": "https://www.gametorq.com/source"
+  }
+}

package/setup/index.js

@@ -0,0 +1,201 @@
+/**
+ * dep - Simple version control
+ * Module: Setup (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const pkg = require('../../package.json');
+const DEP_HOST = pkg.depConfig.host || 'http://localhost:1337';
+
+/**
+ * Initializes the local .dep directory structure.
+ * @param {string} directoryPath - The path where the repository should be initialized.
+ * @returns {string} A message indicating the result of the operation.
+ */
+
+function init (directoryPath = process.cwd()) {
+  const depDirectory = path.join(directoryPath, '.dep');
+
+  const folders = [
+    '',
+    'data',
+    'history',
+    'history/local',
+    'history/local/main',
+    'history/remote',
+    'history/remote/main'
+  ];
+
+  if (fs.existsSync(depDirectory)) {
+    return `Reinitialized existing dep repository in ${depDirectory}`;
+  }
+
+  for (const folder of folders) {
+    const fullPath = path.join(depDirectory, folder);
+
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  }
+
+  const files = fs.readdirSync(directoryPath).filter(f => f !== '.dep');
+
+  const dataManifest = {
+    files: []
+  };
+
+  for (const file of files) {
+    const fullPath = path.join(directoryPath, file);
+    if (fs.lstatSync(fullPath).isFile()) {
+      dataManifest.files.push({
+        path: file,
+        content: fs.readFileSync(fullPath, 'utf8')
+      });
+    }
+  }
+
+  fs.writeFileSync(
+    path.join(depDirectory, 'data/manifest.json'),
+    JSON.stringify(dataManifest, null, 2)
+  );
+
+  const historyManifest = {
+    commits: []
+  };
+
+  fs.writeFileSync(
+    path.join(depDirectory, 'history/local/main/manifest.json'),
+    JSON.stringify(historyManifest, null, 2)
+  );
+
+  const depFile = {
+    active: {
+      branch: 'main',
+      parent: null
+    },
+    remote: '',
+    configuration: {
+      userName: ''
+    }
+  };
+
+  fs.writeFileSync(
+    path.join(depDirectory, 'dep.json'),
+    JSON.stringify(depFile, null, 2)
+  );
+
+  return `Initialized empty dep repository in ${depDirectory}`;
+}
+
+/**
+ * Clones a repository, populates "data", and replays "history".
+ * @param {string} repoSlug - The "userName/repoName" slug.
+ * @returns {Promise<string>}
+ */
+
+async function clone (repoSlug) {
+  if (!repoSlug || !repoSlug.includes('/')) {
+    throw new Error('A valid slug is required.');
+  }
+
+  const [userName, repoName] = repoSlug.split('/');
+  const targetPath = path.join(process.cwd(), repoName);
+  const depPath = path.join(targetPath, '.dep');
+
+  if (fs.existsSync(targetPath)) {
+    throw new Error(`Destination path "${targetPath}" already exists.`);
+  }
+
+  fs.mkdirSync(targetPath);
+  init(targetPath);
+
+  const dataRes = await fetch(`${DEP_HOST}/${userName}/${repoName}/data/manifest.json`);
+  const dataManifest = await dataRes.json();
+
+  if (dataManifest.files) {
+    for (const file of dataManifest.files) {
+      const internalDataPath = path.join(depPath, 'data', file.path);
+      const workingPath = path.join(targetPath, file.path);
+
+      fs.mkdirSync(path.dirname(internalDataPath), { recursive: true });
+      fs.writeFileSync(internalDataPath, file.content);
+      fs.writeFileSync(workingPath, file.content);
+    }
+  }
+
+  const historyUrl = `${DEP_HOST}/${userName}/${repoName}/history/remote/main/manifest.json`;
+  const historyRes = await fetch(historyUrl);
+  const historyManifest = await historyRes.json();
+
+  if (historyManifest.commits) {
+    for (const commitHash of historyManifest.commits) {
+      const commitRes = await fetch(`${DEP_HOST}/${userName}/${repoName}/history/remote/main/${commitHash}.json`);
+      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 currentContent = fs.existsSync(fullPath)
+            ? fs.readFileSync(fullPath, 'utf8')
+            : '';
+
+          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)}`;
+            }
+          }
+
+          fs.writeFileSync(fullPath, currentContent);
+        } else if (changeSet.type === 'deleteFile') {
+          if (fs.existsSync(fullPath)) {
+            fs.unlinkSync(fullPath);
+          }
+        } else if (changeSet.type === 'createFile') {
+          fs.writeFileSync(fullPath, changeSet.content || '');
+        }
+      }
+
+      fs.writeFileSync(
+        path.join(depPath, 'history/remote/main', `${commitHash}.json`),
+        JSON.stringify(commitDiff, null, 2)
+      );
+    }
+  }
+
+  return `Successfully cloned and replayed ${repoSlug}.`;
+}
+
+/**
+ * Updates the configuration in dep.json.
+ */
+
+function config (key, value) {
+  const manifestPath = path.join(process.cwd(), '.dep', 'dep.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error('No dep 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
+};

package/utils/getStateByHash/index.js

@@ -0,0 +1,48 @@
+/**
+ * dep - Simple version control
+ * Module: Utils (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Helper to reconstruct file states at a specific commit hash.
+ */
+
+module.exports = (branchName, targetHash) => {
+  const depPath = path.join(process.cwd(), '.dep');
+  const dataPath = path.join(depPath, 'data/manifest.json');
+
+  if (!fs.existsSync(dataPath)) return {};
+
+  const dataManifest = JSON.parse(fs.readFileSync(dataPath, 'utf8'));
+  const branchPath = path.join(depPath, 'history/local', branchName);
+  const manifestPath = path.join(branchPath, 'manifest.json');
+
+  if (!fs.existsSync(manifestPath)) return {};
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  let state = {};
+
+  for (const file of dataManifest.files) {
+   state[file.path] = file.content;
+  }
+
+  for (const hash of manifest.commits) {
+   const commitPath = path.join(branchPath, `${hash}.json`);
+   const commit = JSON.parse(fs.readFileSync(commitPath, 'utf8'));
+
+   for (const [filePath, change] of Object.entries(commit.changes)) {
+     if (change.type === 'createFile' || change.type === 'update') {
+       state[filePath] = change.content;
+     } else if (change.type === 'deleteFile') {
+       delete state[filePath];
+     }
+   }
+
+   if (hash === targetHash) break;
+  }
+
+  return state;
+};

package/workflow/index.js

@@ -0,0 +1,148 @@
+/**
+ * dep - Simple version control
+ * Module: Workflow (v0.0.1)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Compares the working directory against the last commit and pending stage.
+ * @returns {object} Status object containing branch info and change summaries.
+ */
+
+function status () {
+  const depPath = path.join(process.cwd(), '.dep');
+  const depJsonPath = path.join(depPath, 'dep.json');
+
+  if (!fs.existsSync(depJsonPath)) {
+    throw new Error('No dep repository found.');
+  }
+
+  const depJson = JSON.parse(fs.readFileSync(depJsonPath, 'utf8'));
+  const stagePath = path.join(depPath, 'stage.json');
+
+  let stagedFiles = [];
+
+  if (fs.existsSync(stagePath)) {
+    const stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+
+    stagedFiles = Object.keys(stage.changes);
+  }
+
+  return {
+    activeBranch: depJson.active.branch,
+    lastCommit: depJson.active.parent,
+    staged: stagedFiles
+  };
+}
+
+/**
+ * Updates or creates a JSON diff in the stage.json file.
+ * @param {string} filePath - Path of the file to add.
+ * @returns {string} Confirmation message.
+ */
+
+function add (filePath) {
+  const depPath = path.join(process.cwd(), '.dep');
+  const stagePath = path.join(depPath, 'stage.json');
+  const fullPath = path.join(process.cwd(), filePath);
+
+  if (!fs.existsSync(fullPath)) {
+    throw new Error(`Path does not exist: ${filePath}`);
+  }
+
+  let stage = { changes: {} };
+
+  if (fs.existsSync(stagePath)) {
+    stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+  }
+
+  const content = fs.readFileSync(fullPath, 'utf8');
+
+  // Currently records full content for the commit diff logic.
+  // In our replay design, this is treated as a 'createFile' or 'update' operation.
+
+  stage.changes[filePath] = {
+    type: 'createFile',
+    content: content
+  };
+
+  fs.writeFileSync(stagePath, JSON.stringify(stage, null, 2));
+
+  return `Added ${filePath} to stage.`;
+}
+
+/**
+ * Finalizes the stage into a commit file within the history directory.
+ * @param {string} message - The commit message.
+ * @returns {string} Confirmation message with the new hash.
+ */
+
+function commit (message) {
+  if (!message) {
+    throw new Error('A commit message is required.');
+  }
+
+  const depPath = path.join(process.cwd(), '.dep');
+  const stagePath = path.join(depPath, 'stage.json');
+  const depJsonPath = path.join(depPath, 'dep.json');
+
+  if (!fs.existsSync(stagePath)) {
+    throw new Error('Nothing to commit (stage is empty).');
+  }
+
+  const stage = JSON.parse(fs.readFileSync(stagePath, 'utf8'));
+  const depJson = JSON.parse(fs.readFileSync(depJsonPath, 'utf8'));
+  const branch = depJson.active.branch;
+
+  const timestamp = Date.now();
+
+  const hash = crypto
+    .createHash('sha1')
+    .update(JSON.stringify(stage.changes) + timestamp + message)
+    .digest('hex');
+
+  const commitObject = {
+    hash: hash,
+    message: message,
+    timestamp: timestamp,
+    parent: depJson.active.parent,
+    changes: stage.changes
+  };
+
+  const branchHistoryDir = path.join(depPath, 'history', 'local', branch);
+  const commitFilePath = path.join(branchHistoryDir, `${hash}.json`);
+  const manifestPath = path.join(branchHistoryDir, 'manifest.json');
+
+  // Write the commit file
+
+  fs.writeFileSync(commitFilePath, JSON.stringify(commitObject, null, 2));
+
+  // Update the branch manifest
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+  manifest.commits.push(hash);
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+  // Update dep.json active pointer
+
+  depJson.active.parent = hash;
+  fs.writeFileSync(depJsonPath, JSON.stringify(depJson, null, 2));
+
+  // Clear stage by deleting the file
+
+  fs.unlinkSync(stagePath);
+
+  return `[${branch} ${hash.slice(0, 7)}] ${message}`;
+}
+
+module.exports = {
+  __libraryVersion: '0.0.1',
+  __libraryAPIName: 'Workflow',
+  status,
+  add,
+  commit
+};