urmama 1.0.0

package/README.MD

@@ -0,0 +1,119 @@
+# urmama
+
+urmama is a Node.js CLI tool for rewriting the full commit history of a Git branch so that every commit falls within a chosen date window while preserving the original order of commits.
+
+It is especially useful for re-timing a branch for a hackathon, project sprint, or other date-based workflow without changing the commit contents themselves.
+
+## Features
+
+- Rewrites an entire branch history from the root commit to HEAD
+- Preserves commit order and message content
+- Supports three distribution strategies:
+  - randomise (default)
+  - equalize
+  - greedyMum
+- Writes to a new branch by default, or rewrites the target branch in place when requested
+- Optionally force-pushes the rewritten branch to a remote
+- Enforces safety checks such as valid date range, existing target branch, and clean working tree
+
+## Installation
+
+Install globally with npm:
+
+```bash
+npm install -g urmama
+```
+
+## Usage
+
+```bash
+urmama \
+  --starts "YYYY-MM-DD HH:mm" \
+  --ends "YYYY-MM-DD HH:mm" \
+  [options]
+```
+
+### Required arguments
+
+- --starts: start datetime (inclusive)
+- --ends: end datetime (inclusive)
+
+### Optional arguments
+
+- --targetBranch <name>: branch to rewrite; defaults to the current active branch
+- --destBranch <name>: branch that will receive the rewritten history
+- --useTargetAsDest [true|false]: rewrite the target branch in place instead of creating a copy
+- --mode <mode>: distribution strategy; one of randomise, equalize, greedyMum
+- --forcePushTo <remote>: force-push the rewritten branch after completion
+- --help, -h: show usage information
+
+## Distribution modes
+
+### randomise (default)
+
+Distributes commits randomly across the available days while keeping their original relative order.
+
+### equalize
+
+Spreads commits as evenly as possible across the date range.
+
+### greedyMum
+
+Preserves commits already inside the requested range and only adjusts commits that fall outside it. This mode is deterministic and is designed to avoid moving commits unnecessarily.
+
+## Examples
+
+### 1. Create a rewritten copy of the current branch
+
+```bash
+urmama \
+  --starts "2026-06-01 09:00" \
+  --ends "2026-06-04 18:00"
+```
+
+This creates a new branch named like currentBranch-Copy.
+
+### 2. Rewrite the main branch in place
+
+```bash
+urmama \
+  --starts "2026-06-01 09:00" \
+  --ends "2026-06-04 18:00" \
+  --targetBranch "main" \
+  --useTargetAsDest true
+```
+
+### 3. Backup, rewrite, and force-push
+
+```bash
+urmama \
+  --starts "2026-06-01 09:00" \
+  --ends "2026-06-04 18:00" \
+  --targetBranch "main" \
+  --destBranch "main-backup" \
+  --useTargetAsDest true \
+  --forcePushTo "origin"
+```
+
+## Safety and requirements
+
+Before rewriting history, urmama checks that:
+
+- you are inside a Git repository
+- the target branch exists
+- the working tree has no uncommitted changes
+- --starts occurs before --ends
+
+Because this tool rewrites history, it is safest to use it on a backup branch or a disposable branch first. When --useTargetAsDest is enabled, the tool will warn you before rewriting the target branch in place.
+
+## Development
+
+Run the test suite:
+
+```bash
+npm test
+```
+
+## Notes
+
+This project uses Git’s native CLI to rebuild commit history and updates both the author and committer dates for rewritten commits.

package/bin/urmama.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const {
+  isInsideGitWorktree,
+  hasUncommittedChanges,
+  getCurrentBranch,
+  branchExists,
+  getCommitsReverse,
+  getCommitDetails,
+  createCommitTree,
+  updateBranchRef,
+  resetHard,
+  copyBranch,
+  forcePush
+} = require('../lib/git');
+
+const {
+  parseDateTime,
+  toLocalISOString,
+  getCalendarDaysCount,
+  getDayWindow,
+  distributeCommitsInWindow
+} = require('../lib/date');
+
+const {
+  equalize,
+  randomise,
+  greedyMum
+} = require('../lib/modes');
+
+function askConfirmation(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+function generateRandomId() {
+  return Math.random().toString(36).substring(2, 10);
+}
+
+function printUsage() {
+  console.log(`
+Usage: urmama --starts "YYYY-MM-DD HH:mm" --ends "YYYY-MM-DD HH:mm" [options]
+
+Required Options:
+  --starts "YYYY-MM-DD HH:mm"   Start datetime (inclusive)
+  --ends "YYYY-MM-DD HH:mm"     End datetime (inclusive)
+
+Optional Options:
+  --targetBranch <name>         Branch to rewrite (defaults to current active branch)
+  --destBranch <name>           Branch to contain rewritten commits
+  --useTargetAsDest [true|false] Rewrite history directly on target branch (default: false)
+  --mode <mode>                 Distribution mode: "randomise", "equalize", "greedyMum" (default: "randomise")
+  --forcePushTo <remote>        Remote name to force push to (e.g. "origin")
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  
+  let startsStr = null;
+  let endsStr = null;
+  let targetBranch = null;
+  let destBranch = null;
+  let useTargetAsDest = false;
+  let mode = 'randomise';
+  let forcePushTo = null;
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--starts') {
+      startsStr = args[++i];
+    } else if (arg === '--ends') {
+      endsStr = args[++i];
+    } else if (arg === '--targetBranch') {
+      targetBranch = args[++i];
+    } else if (arg === '--destBranch') {
+      destBranch = args[++i];
+    } else if (arg === '--useTargetAsDest') {
+      const next = args[i + 1];
+      if (next === 'true') {
+        useTargetAsDest = true;
+        i++;
+      } else if (next === 'false') {
+        useTargetAsDest = false;
+        i++;
+      } else {
+        useTargetAsDest = true;
+      }
+    } else if (arg === '--mode') {
+      mode = args[++i];
+    } else if (arg === '--forcePushTo') {
+      forcePushTo = args[++i];
+    } else if (arg === '--help' || arg === '-h') {
+      printUsage();
+      process.exit(0);
+    }
+  }
+  
+  if (!startsStr || !endsStr) {
+    console.error('Error: Both --starts and --ends must be provided.');
+    printUsage();
+    process.exit(1);
+  }
+  
+  let S, E;
+  try {
+    S = parseDateTime(startsStr);
+    E = parseDateTime(endsStr);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+  
+  if (S.getTime() >= E.getTime()) {
+    console.error('Error: --starts must be before --ends');
+    process.exit(1);
+  }
+  
+  const allowedModes = ['randomise', 'equalize', 'greedyMum'];
+  if (!allowedModes.includes(mode)) {
+    console.error(`Error: Invalid mode "${mode}". Must be one of: ${allowedModes.join(', ')}`);
+    process.exit(1);
+  }
+  
+  if (!isInsideGitWorktree()) {
+    console.error('Error: Not inside a Git repository.');
+    process.exit(1);
+  }
+  
+  if (hasUncommittedChanges()) {
+    console.error('Error: Working directory has uncommitted changes. Please commit or stash them first.');
+    process.exit(1);
+  }
+  
+  const activeBranch = getCurrentBranch();
+  if (!targetBranch) {
+    targetBranch = activeBranch;
+  }
+  
+  if (!branchExists(targetBranch)) {
+    console.error(`Error: Target branch "${targetBranch}" does not exist.`);
+    process.exit(1);
+  }
+  
+  console.log(`Collecting commits on branch "${targetBranch}"...`);
+  const commitHashes = getCommitsReverse(targetBranch);
+  const N = commitHashes.length;
+  if (N === 0) {
+    console.error(`Error: No commits found on branch "${targetBranch}".`);
+    process.exit(1);
+  }
+  
+  console.log(`Found ${N} commit(s) to rewrite.`);
+  const commits = commitHashes.map(hash => getCommitDetails(hash));
+  
+  let commitMappings;
+  if (mode === 'greedyMum') {
+    commitMappings = greedyMum(commits, S, E);
+  } else {
+    const D = getCalendarDaysCount(S, E);
+    const bucketSizes = mode === 'equalize' ? equalize(N, D) : randomise(N, D);
+    
+    const newCommitDates = [];
+    let commitIdx = 0;
+    for (let dayIdx = 0; dayIdx < D; dayIdx++) {
+      const count = bucketSizes[dayIdx];
+      if (count > 0) {
+        const { start, end } = getDayWindow(dayIdx, D, S, E);
+        const dates = distributeCommitsInWindow(start, end, count);
+        for (let j = 0; j < count; j++) {
+          newCommitDates[commitIdx++] = dates[j];
+        }
+      }
+    }
+    
+    commitMappings = commits.map((c, i) => ({
+      hash: c.hash,
+      newAuthorDate: newCommitDates[i],
+      newCommitterDate: newCommitDates[i],
+      unchanged: false
+    }));
+  }
+  
+  let destBranchName = destBranch;
+  let isBackupNeeded = false;
+  
+  if (!useTargetAsDest) {
+    if (!destBranchName) {
+      const defaultName = `${targetBranch}-Copy`;
+      if (branchExists(defaultName)) {
+        const randomId = generateRandomId();
+        destBranchName = `${defaultName}_${randomId}`;
+      } else {
+        destBranchName = defaultName;
+      }
+    }
+  } else {
+    if (destBranchName) {
+      isBackupNeeded = true;
+    }
+    destBranchName = targetBranch;
+  }
+  
+  console.log('\n--- URMAMA Rewrite Configuration ---');
+  console.log(`Target Branch:       ${targetBranch}`);
+  console.log(`Destination Branch:  ${destBranchName}`);
+  if (isBackupNeeded) {
+    console.log(`Backup Branch:       ${destBranch}`);
+  }
+  console.log(`Distribution Mode:   ${mode}`);
+  console.log(`Time Range (Local):  ${toLocalISOString(S)} -> ${toLocalISOString(E)}`);
+  if (forcePushTo) {
+    console.log(`Force Push To:       ${forcePushTo}`);
+  }
+  console.log('------------------------------------');
+  
+  const willModifyTarget = useTargetAsDest;
+  if (willModifyTarget) {
+    console.log('\n[WARNING] You have enabled --useTargetAsDest.');
+    console.log(`This will rewrite the history of "${targetBranch}" IN-PLACE.`);
+    console.log('Ensure you have a backup of this branch if it is remote or shared.');
+    
+    const confirm = await askConfirmation(`Are you sure you want to rewrite "${targetBranch}"? (y/N): `);
+    if (confirm !== 'y' && confirm !== 'yes') {
+      console.log('Operation cancelled by user. Exiting.');
+      process.exit(0);
+    }
+  }
+  
+  console.log('\nRewriting commit history...');
+  
+  if (isBackupNeeded) {
+    console.log(`Creating backup branch "${destBranch}" from "${targetBranch}"...`);
+    copyBranch(targetBranch, destBranch);
+  }
+  
+  const rewrittenMap = {};
+  
+  for (let i = 0; i < N; i++) {
+    const c = commits[i];
+    const mapping = commitMappings[i];
+    
+    const newParents = c.parents.map(p => rewrittenMap[p] || p);
+    
+    const authorDateStr = toLocalISOString(mapping.newAuthorDate);
+    const committerDateStr = toLocalISOString(mapping.newCommitterDate);
+    
+    const newHash = createCommitTree(
+      c.tree,
+      newParents,
+      c.authorName,
+      c.authorEmail,
+      authorDateStr,
+      c.committerName,
+      c.committerEmail,
+      committerDateStr,
+      c.message
+    );
+    
+    rewrittenMap[c.hash] = newHash;
+    console.log(`  [${i + 1}/${N}] Rewrote ${c.hash.slice(0, 7)} -> ${newHash.slice(0, 7)}`);
+  }
+  
+  const lastOldHash = commitHashes[N - 1];
+  const newHeadHash = rewrittenMap[lastOldHash];
+  
+  const isUpdatingActiveBranch = (destBranchName === activeBranch);
+  
+  if (isUpdatingActiveBranch) {
+    console.log(`Updating current active branch "${destBranchName}" to new HEAD...`);
+    resetHard(newHeadHash);
+  } else {
+    console.log(`Updating branch "${destBranchName}" reference to new HEAD...`);
+    updateBranchRef(destBranchName, newHeadHash);
+  }
+  
+  console.log(`Successfully rewrote history! Branch "${destBranchName}" is now at ${newHeadHash.slice(0, 7)}.`);
+  
+  if (forcePushTo) {
+    console.log(`Force pushing "${destBranchName}" to remote "${forcePushTo}"...`);
+    try {
+      forcePush(forcePushTo, destBranchName);
+      console.log('Force push completed successfully.');
+    } catch (err) {
+      console.error(`Error performing force push: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/lib/date.js

@@ -0,0 +1,101 @@
+function parseDateTime(str) {
+  if (!str) {
+    throw new Error('Date string is required');
+  }
+  const match = str.match(/^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})$/);
+  if (!match) {
+    throw new Error(`Invalid date format: "${str}". Expected "YYYY-MM-DD HH:mm"`);
+  }
+  const [_, year, month, day, hour, minute] = match;
+  const y = parseInt(year, 10);
+  const m = parseInt(month, 10);
+  const d = parseInt(day, 10);
+  const h = parseInt(hour, 10);
+  const min = parseInt(minute, 10);
+
+  if (m < 1 || m > 12) {
+    throw new Error(`Invalid date: "${str}"`);
+  }
+  const maxDays = new Date(y, m, 0).getDate();
+  if (d < 1 || d > maxDays) {
+    throw new Error(`Invalid date: "${str}"`);
+  }
+  if (h < 0 || h > 23) {
+    throw new Error(`Invalid date: "${str}"`);
+  }
+  if (min < 0 || min > 59) {
+    throw new Error(`Invalid date: "${str}"`);
+  }
+
+  return new Date(y, m - 1, d, h, min, 0, 0);
+}
+
+function toLocalISOString(date) {
+  const tzOffset = -date.getTimezoneOffset();
+  const diff = tzOffset >= 0 ? '+' : '-';
+  const pad = num => String(num).padStart(2, '0');
+  
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  
+  const absOffsetHour = pad(Math.floor(Math.abs(tzOffset) / 60));
+  const absOffsetMin = pad(Math.abs(tzOffset) % 60);
+  
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${diff}${absOffsetHour}:${absOffsetMin}`;
+}
+
+function getCalendarDaysCount(S, E) {
+  const sDay = new Date(S.getFullYear(), S.getMonth(), S.getDate());
+  const eDay = new Date(E.getFullYear(), E.getMonth(), E.getDate());
+  const diffTime = eDay.getTime() - sDay.getTime();
+  return Math.round(diffTime / (1000 * 60 * 60 * 24)) + 1;
+}
+
+function getDayWindow(dayIndex, totalDays, S, E) {
+  const sDay = new Date(S.getFullYear(), S.getMonth(), S.getDate());
+  const dayStart = new Date(sDay.getTime() + dayIndex * 24 * 60 * 60 * 1000);
+  const dayEnd = new Date(dayStart.getFullYear(), dayStart.getMonth(), dayStart.getDate(), 23, 59, 59, 999);
+  
+  let windowStart = new Date(dayStart.getFullYear(), dayStart.getMonth(), dayStart.getDate(), 0, 0, 0, 0);
+  let windowEnd = dayEnd;
+  
+  if (dayIndex === 0) {
+    windowStart = S;
+  }
+  if (dayIndex === totalDays - 1) {
+    windowEnd = E;
+  }
+  
+  return { start: windowStart, end: windowEnd };
+}
+
+function distributeCommitsInWindow(startTime, endTime, count) {
+  if (count <= 0) return [];
+  const windowDuration = endTime.getTime() - startTime.getTime();
+  
+  let spacing = windowDuration / (count + 1);
+  if (spacing < 60000) {
+    if (spacing < 1000) {
+      spacing = Math.max(1, windowDuration / (count + 1));
+    }
+  }
+  
+  const dates = [];
+  for (let i = 0; i < count; i++) {
+    const time = startTime.getTime() + (i + 1) * spacing;
+    dates.push(new Date(time));
+  }
+  return dates;
+}
+
+module.exports = {
+  parseDateTime,
+  toLocalISOString,
+  getCalendarDaysCount,
+  getDayWindow,
+  distributeCommitsInWindow
+};

package/lib/git.js

@@ -0,0 +1,159 @@
+const { execSync } = require('child_process');
+
+function runGit(cmd, options = {}) {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...options
+    }).trim();
+  } catch (error) {
+    const stderr = error.stderr ? error.stderr.toString().trim() : '';
+    const message = error.message || '';
+    throw new Error(`Git command failed: ${cmd}\nError: ${message}\nStderr: ${stderr}`);
+  }
+}
+
+function isInsideGitWorktree() {
+  try {
+    const res = runGit('git rev-parse --is-inside-work-tree');
+    return res === 'true';
+  } catch (e) {
+    return false;
+  }
+}
+
+function hasUncommittedChanges() {
+  const status = runGit('git status --porcelain');
+  return status.length > 0;
+}
+
+function getCurrentBranch() {
+  return runGit('git rev-parse --abbrev-ref HEAD');
+}
+
+function branchExists(branchName) {
+  try {
+    runGit(`git show-ref --verify refs/heads/${branchName}`);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function getCommitsReverse(branchName) {
+  const output = runGit(`git rev-list --reverse ${branchName}`);
+  return output ? output.split('\n') : [];
+}
+
+function getCommitDetails(hash) {
+  const raw = runGit(`git cat-file -p ${hash}`);
+  const lines = raw.split('\n');
+  
+  let tree = '';
+  const parents = [];
+  let authorName = '';
+  let authorEmail = '';
+  let committerName = '';
+  let committerEmail = '';
+  let originalAuthorTimestamp = 0;
+  let originalAuthorOffset = '+0000';
+  let originalCommitterTimestamp = 0;
+  let originalCommitterOffset = '+0000';
+  let messageIndex = -1;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === '') {
+      messageIndex = i + 1;
+      break;
+    }
+    if (line.startsWith('tree ')) {
+      tree = line.slice(5).trim();
+    } else if (line.startsWith('parent ')) {
+      parents.push(line.slice(7).trim());
+    } else if (line.startsWith('author ')) {
+      const emailStart = line.indexOf('<');
+      const emailEnd = line.indexOf('>');
+      authorName = line.slice(7, emailStart).trim();
+      authorEmail = line.slice(emailStart + 1, emailEnd).trim();
+      
+      const rest = line.slice(emailEnd + 1).trim().split(/\s+/);
+      originalAuthorTimestamp = parseInt(rest[0]);
+      originalAuthorOffset = rest[1] || '+0000';
+    } else if (line.startsWith('committer ')) {
+      const emailStart = line.indexOf('<');
+      const emailEnd = line.indexOf('>');
+      committerName = line.slice(10, emailStart).trim();
+      committerEmail = line.slice(emailStart + 1, emailEnd).trim();
+      
+      const rest = line.slice(emailEnd + 1).trim().split(/\s+/);
+      originalCommitterTimestamp = parseInt(rest[0]);
+      originalCommitterOffset = rest[1] || '+0000';
+    }
+  }
+  
+  const message = lines.slice(messageIndex).join('\n');
+  return {
+    hash,
+    tree,
+    parents,
+    authorName,
+    authorEmail,
+    committerName,
+    committerEmail,
+    originalAuthorDate: new Date(originalAuthorTimestamp * 1000),
+    originalAuthorOffset,
+    originalCommitterDate: new Date(originalCommitterTimestamp * 1000),
+    originalCommitterOffset,
+    message
+  };
+}
+
+function createCommitTree(treeHash, parents, authorName, authorEmail, authorDateStr, committerName, committerEmail, committerDateStr, message) {
+  const parentArgs = parents.map(p => `-p ${p}`).join(' ');
+  const cmd = `git commit-tree ${treeHash} ${parentArgs}`;
+  
+  const env = {
+    ...process.env,
+    GIT_AUTHOR_NAME: authorName,
+    GIT_AUTHOR_EMAIL: authorEmail,
+    GIT_AUTHOR_DATE: authorDateStr,
+    GIT_COMMITTER_NAME: committerName,
+    GIT_COMMITTER_EMAIL: committerEmail,
+    GIT_COMMITTER_DATE: committerDateStr
+  };
+  
+  return runGit(cmd, { input: message, env });
+}
+
+function updateBranchRef(branchName, commitHash) {
+  runGit(`git update-ref refs/heads/${branchName} ${commitHash}`);
+}
+
+function resetHard(commitHash) {
+  runGit(`git reset --hard ${commitHash}`);
+}
+
+function copyBranch(src, dest) {
+  runGit(`git branch -f ${dest} ${src}`);
+}
+
+function forcePush(remote, branchName) {
+  runGit(`git push --force ${remote} ${branchName}`);
+}
+
+module.exports = {
+  runGit,
+  isInsideGitWorktree,
+  hasUncommittedChanges,
+  getCurrentBranch,
+  branchExists,
+  getCommitsReverse,
+  getCommitDetails,
+  createCommitTree,
+  updateBranchRef,
+  resetHard,
+  copyBranch,
+  forcePush
+};

package/lib/modes.js

@@ -0,0 +1,182 @@
+const { distributeCommitsInWindow } = require('./date');
+
+function equalize(N, D) {
+  const base = Math.floor(N / D);
+  const remainder = N % D;
+  const buckets = new Array(D).fill(base);
+  for (let i = 0; i < remainder; i++) {
+    buckets[i]++;
+  }
+  return buckets;
+}
+
+function randomise(N, D) {
+  const points = [];
+  for (let i = 0; i < D - 1; i++) {
+    points.push(Math.floor(Math.random() * (N + 1)));
+  }
+  points.sort((a, b) => a - b);
+  const buckets = [];
+  let prev = 0;
+  for (let i = 0; i < D - 1; i++) {
+    buckets.push(points[i] - prev);
+    prev = points[i];
+  }
+  buckets.push(N - prev);
+  return buckets;
+}
+
+function greedyMum(commits, S, E) {
+  const result = commits.map(c => ({
+    hash: c.hash,
+    newAuthorDate: c.originalAuthorDate,
+    newCommitterDate: c.originalCommitterDate,
+    unchanged: true
+  }));
+  
+  let bufferMs = 60 * 60 * 1000; // 1 hour
+  const rangeDuration = E.getTime() - S.getTime();
+  if (rangeDuration < 2 * bufferMs) {
+    bufferMs = rangeDuration / 2;
+  }
+  
+  const firstHourEnd = new Date(S.getTime() + bufferMs);
+  const lastHourStart = new Date(E.getTime() - bufferMs);
+  
+  const firstDayStartOfDay = new Date(S.getFullYear(), S.getMonth(), S.getDate(), 0, 0, 0, 0);
+  const firstDayEndOfDay = new Date(S.getFullYear(), S.getMonth(), S.getDate(), 23, 59, 59, 999);
+  
+  const lastDayStartOfDay = new Date(E.getFullYear(), E.getMonth(), E.getDate(), 0, 0, 0, 0);
+  const lastDayEndOfDay = new Date(E.getFullYear(), E.getMonth(), E.getDate(), 23, 59, 59, 999);
+  
+  const beforeSIndices = [];
+  const afterEIndices = [];
+  const insideIndices = [];
+  
+  for (let i = 0; i < commits.length; i++) {
+    const d = commits[i].originalAuthorDate;
+    if (d < S) {
+      beforeSIndices.push(i);
+    } else if (d > E) {
+      afterEIndices.push(i);
+    } else {
+      insideIndices.push(i);
+    }
+  }
+  
+  if (beforeSIndices.length === 0 && afterEIndices.length === 0) {
+    return result;
+  }
+  
+  // Case A: Commits before S
+  if (beforeSIndices.length > 0) {
+    const dates = distributeCommitsInWindow(S, firstHourEnd, beforeSIndices.length);
+    for (let j = 0; j < beforeSIndices.length; j++) {
+      const idx = beforeSIndices[j];
+      result[idx].newAuthorDate = dates[j];
+      result[idx].newCommitterDate = dates[j];
+      result[idx].unchanged = false;
+    }
+  }
+  
+  // First-day nudges
+  const firstDayNudgeIndices = [];
+  for (const idx of insideIndices) {
+    const d = commits[idx].originalAuthorDate;
+    const isOnFirstDay = d >= firstDayStartOfDay && d <= firstDayEndOfDay;
+    if (isOnFirstDay && d <= firstHourEnd) {
+      firstDayNudgeIndices.push(idx);
+    }
+  }
+  
+  if (firstDayNudgeIndices.length > 0) {
+    let nudgeWindowEnd = firstDayEndOfDay;
+    const lastNudgeIdx = firstDayNudgeIndices[firstDayNudgeIndices.length - 1];
+    
+    let nextIdx = -1;
+    for (let i = 0; i < insideIndices.length; i++) {
+      if (insideIndices[i] === lastNudgeIdx) {
+        if (i + 1 < insideIndices.length) {
+          nextIdx = insideIndices[i + 1];
+        }
+        break;
+      }
+    }
+    
+    if (nextIdx !== -1) {
+      const nextDate = commits[nextIdx].originalAuthorDate;
+      const nextIsOnFirstDay = nextDate >= firstDayStartOfDay && nextDate <= firstDayEndOfDay;
+      if (nextIsOnFirstDay) {
+        nudgeWindowEnd = nextDate;
+      }
+    }
+    
+    const nudgeDates = distributeCommitsInWindow(firstHourEnd, nudgeWindowEnd, firstDayNudgeIndices.length);
+    for (let j = 0; j < firstDayNudgeIndices.length; j++) {
+      const idx = firstDayNudgeIndices[j];
+      result[idx].newAuthorDate = nudgeDates[j];
+      result[idx].newCommitterDate = nudgeDates[j];
+      result[idx].unchanged = false;
+    }
+  }
+  
+  // Case B: Commits after E
+  if (afterEIndices.length > 0) {
+    const dates = distributeCommitsInWindow(lastHourStart, E, afterEIndices.length);
+    for (let j = 0; j < afterEIndices.length; j++) {
+      const idx = afterEIndices[j];
+      result[idx].newAuthorDate = dates[j];
+      result[idx].newCommitterDate = dates[j];
+      result[idx].unchanged = false;
+    }
+  }
+  
+  // Last-day nudges
+  const lastDayNudgeIndices = [];
+  for (const idx of insideIndices) {
+    const d = commits[idx].originalAuthorDate;
+    const isOnLastDay = d >= lastDayStartOfDay && d <= lastDayEndOfDay;
+    if (isOnLastDay && d >= lastHourStart) {
+      lastDayNudgeIndices.push(idx);
+    }
+  }
+  
+  if (lastDayNudgeIndices.length > 0) {
+    let nudgeWindowStart = lastDayStartOfDay;
+    const firstNudgeIdx = lastDayNudgeIndices[0];
+    
+    let prevIdx = -1;
+    for (let i = 0; i < insideIndices.length; i++) {
+      if (insideIndices[i] === firstNudgeIdx) {
+        if (i - 1 >= 0) {
+          prevIdx = insideIndices[i - 1];
+        }
+        break;
+      }
+    }
+    
+    if (prevIdx !== -1) {
+      const prevDate = commits[prevIdx].originalAuthorDate;
+      const prevIsOnLastDay = prevDate >= lastDayStartOfDay && prevDate <= lastDayEndOfDay;
+      if (prevIsOnLastDay) {
+        nudgeWindowStart = prevDate;
+      }
+    }
+    
+    const nudgeDates = distributeCommitsInWindow(nudgeWindowStart, lastHourStart, lastDayNudgeIndices.length);
+    for (let j = 0; j < lastDayNudgeIndices.length; j++) {
+      const idx = lastDayNudgeIndices[j];
+      result[idx].newAuthorDate = nudgeDates[j];
+      result[idx].newCommitterDate = nudgeDates[j];
+      result[idx].unchanged = false;
+    }
+  }
+  
+  return result;
+}
+
+module.exports = {
+  equalize,
+  randomise,
+  greedyMum
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "urmama",
+  "version": "1.0.0",
+  "description": "Rewrite the full commit history of a Git branch so that all commits fall within a specified date range.",
+  "main": "bin/urmama.js",
+  "bin": {
+    "urmama": "./bin/urmama.js"
+  },
+  "scripts": {
+    "test": "node tests/urmama.test.js"
+  },
+  "keywords": ["git", "history", "rewrite", "dates", "commit"],
+  "author": "",
+  "license": "ISC"
+}