backupman 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# backupman
+
+Ultra-simple local snapshot tool for when your code (or your AI) goes off the rails.
+
+You run it inside your source folder (for example `src` or your project root), hit `save` when things look okay, and later you can `restore` any snapshot from an interactive list.
+
+No branches, no remotes, no staging. Just: “this state feels safe → save”.
+
+## Install
+
+```bash
+npm install -g backupman
+```
+
+Or inside a project:
+
+```bash
+npm install backupman
+npm link
+```
+
+## Usage
+
+From the folder you want to protect (for example your project root or `src`):
+
+```bash
+backupman save "before refactor"
+backupman save "after AI edit"
+
+backupman restore
+```
+
+- `backupman save "message"`
+  - Create a full snapshot of the current directory with a short message.
+
+- `backupman restore`
+  - Show an interactive list of snapshots (newest first), auto-back up the current state, then restore the chosen snapshot.
+
+## Notes
+
+- Snapshots are stored under `.backupman/snapshots` in the same folder.
+- On `save`, backupman copies all files and subfolders from the current directory.
+- It ignores:
+  - `.backupman`
+  - `node_modules`
+  - `.git`

package/index.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+class BackupMan {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.backupDir = path.join(rootDir, ".backupman");
+    this.snapshotsDir = path.join(this.backupDir, "snapshots");
+    this.indexFile = path.join(this.backupDir, "index.json");
+  }
+
+  async ensureDirs() {
+    await fs.promises.mkdir(this.backupDir, { recursive: true });
+    await fs.promises.mkdir(this.snapshotsDir, { recursive: true });
+  }
+
+  async loadIndex() {
+    try {
+      const data = await fs.promises.readFile(this.indexFile, "utf8");
+      const parsed = JSON.parse(data);
+      if (!parsed.snapshots || typeof parsed.lastId !== "number") {
+        throw new Error("Corrupted index");
+      }
+      return parsed;
+    } catch (err) {
+      return { lastId: 0, snapshots: [] };
+    }
+  }
+
+  async saveIndex(index) {
+    const json = JSON.stringify(index, null, 2);
+    await fs.promises.writeFile(this.indexFile, json, "utf8");
+  }
+
+  isIgnored(name) {
+    return name === ".backupman" || name === "node_modules" || name === ".git";
+  }
+
+  async copyDir(src, dest) {
+    await fs.promises.mkdir(dest, { recursive: true });
+    const entries = await fs.promises.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (this.isIgnored(name)) continue;
+      const srcPath = path.join(src, name);
+      const destPath = path.join(dest, name);
+      if (entry.isDirectory()) {
+        await this.copyDir(srcPath, destPath);
+      } else if (entry.isFile()) {
+        await fs.promises.copyFile(srcPath, destPath);
+      }
+    }
+  }
+
+  async deleteEverythingExceptBackupDir() {
+    const entries = await fs.promises.readdir(this.rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (name === ".backupman") continue;
+      const target = path.join(this.rootDir, name);
+      await fs.promises.rm(target, { recursive: true, force: true });
+    }
+  }
+
+  async prompt(question) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise(resolve => {
+      rl.question(question, answer => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  async createSnapshot(message) {
+    await this.ensureDirs();
+    const index = await this.loadIndex();
+    const id = index.lastId + 1;
+    const snapshotDir = path.join(this.snapshotsDir, String(id));
+    const now = new Date().toISOString();
+
+    await this.copyDir(this.rootDir, snapshotDir);
+
+    index.lastId = id;
+    index.snapshots.push({
+      id,
+      createdAt: now,
+      message
+    });
+
+    await this.saveIndex(index);
+    return id;
+  }
+
+  formatSnapshot(snapshot) {
+    const ts = snapshot.createdAt || "";
+    const msg = snapshot.message || "";
+    return `#${snapshot.id}  [${ts}]  ${msg}`;
+  }
+
+  async chooseSnapshot(index) {
+    if (!index.snapshots.length) {
+      console.log("No snapshots yet. Use `backupman save \"message\"` first.");
+      return null;
+    }
+
+    const list = [...index.snapshots].sort((a, b) => b.id - a.id);
+    console.log("");
+    console.log("Available snapshots (newest first):");
+    list.forEach((s, i) => {
+      console.log(`  [${i + 1}] ${this.formatSnapshot(s)}`);
+    });
+    console.log("");
+
+    while (true) {
+      const answer = (await this.prompt("Select snapshot number to restore (empty = cancel): ")).trim();
+      if (!answer) {
+        return null;
+      }
+      const n = Number.parseInt(answer, 10);
+      if (!Number.isNaN(n) && n >= 1 && n <= list.length) {
+        return list[n - 1];
+      }
+      console.log("Invalid choice. Please enter a valid number or press Enter to cancel.");
+    }
+  }
+
+  async restore() {
+    await this.ensureDirs();
+    const index = await this.loadIndex();
+    const snapshot = await this.chooseSnapshot(index);
+    if (!snapshot) {
+      console.log("Restore cancelled.");
+      return;
+    }
+
+    console.log("");
+    console.log(`You chose snapshot: ${this.formatSnapshot(snapshot)}`);
+    const confirm = (await this.prompt("Overwrite current files with this snapshot? (y/N): ")).trim().toLowerCase();
+    if (confirm !== "y" && confirm !== "yes") {
+      console.log("Restore aborted.");
+      return;
+    }
+
+    console.log("Clearing current directory (except .backupman)...");
+    await this.deleteEverythingExceptBackupDir();
+
+    console.log("Restoring snapshot files...");
+    const srcSnapshotDir = path.join(this.snapshotsDir, String(snapshot.id));
+    await this.copyDir(srcSnapshotDir, this.rootDir);
+
+    console.log(`Done. Restored snapshot #${snapshot.id}.`);
+  }
+}
+
+function printUsage() {
+  console.log("backupman - ultra-simple local snapshot versioning");
+  console.log("");
+  console.log("Usage:");
+  console.log("  backupman save \"message\"    Save current directory as a snapshot");
+  console.log("  backupman restore            Restore from a previous snapshot");
+  console.log("");
+  console.log("Notes:");
+  console.log("  - Snapshots are stored in .backupman/snapshots");
+  console.log("  - .backupman, node_modules, .git are ignored");
+}
+
+async function main() {
+  const cwd = process.cwd();
+  const manager = new BackupMan(cwd);
+  const [, , command, ...args] = process.argv;
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printUsage();
+    return;
+  }
+
+  if (command === "save") {
+    let message = args.join(" ").trim();
+    if (!message) {
+      message = await manager.prompt("Describe this snapshot (required): ");
+      if (!message || !message.trim()) {
+        console.error("Snapshot message is required.");
+        process.exit(1);
+      }
+    }
+    const id = await manager.createSnapshot(message.trim());
+    console.log(`Saved snapshot #${id}.`);
+    return;
+  }
+
+  if (command === "restore") {
+    await manager.restore();
+    return;
+  }
+
+  console.error(`Unknown command: ${command}`);
+  printUsage();
+  process.exit(1);
+}
+
+main().catch(err => {
+  console.error("Error:", err && err.message ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "backupman",
+  "version": "0.1.0",
+  "description": "Ultra-simple local snapshot versioning tool for chaotic devs and mischievous AIs.",
+  "bin": {
+    "backupman": "index.js"
+  },
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "backup",
+    "snapshot",
+    "versioning",
+    "cli",
+    "local"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {}
+}