easegit-cli 1.0.0

package/README.md

@@ -0,0 +1,110 @@
+# EaseGit
+
+**Automatic checkpoints before Git can hurt you.**
+
+## What is EaseGit?
+
+EaseGit creates automatic safety checkpoints before dangerous Git operations and lets you undo them with one command.
+
+- Automatic protection during rebase, merge, push, checkout
+- Restore everything in one command
+- Zero configuration
+- Invisible until needed
+
+## Installation
+
+```bash
+npm install -g easegit
+cd my-repo
+easegit init
+```
+
+## Usage
+
+### Setup (one time)
+
+```bash
+easegit init
+```
+
+This installs Git hooks that automatically create checkpoints before dangerous operations.
+
+### Normal work (unchanged)
+
+```bash
+git commit
+git merge
+git rebase
+git push --force
+```
+
+EaseGit runs silently in the background. You won't notice it.
+
+### When something breaks
+
+```bash
+easegit undo
+```
+
+This restores your working directory, staged files, and untracked files to the last safe checkpoint.
+
+### Check status
+
+```bash
+easegit status
+```
+
+Shows when the last checkpoint was created and what operation triggered it.
+
+## How it works
+
+EaseGit installs Git hooks that automatically create checkpoints before:
+
+- `git rebase`
+- `git merge`
+- `git push`
+- `git checkout`
+- `git pull`
+- `git reset`
+
+Each checkpoint captures:
+
+- All working files
+- Staged changes
+- Untracked files
+
+Checkpoints are stored as Git objects under hidden refs. Your commit history is never modified.
+
+## Recovery
+
+If a Git operation damages your working state, run:
+
+```bash
+easegit undo
+```
+
+This restores everything exactly as it was before the operation.
+
+## Commands
+
+- `easegit init` - Set up EaseGit in this repository
+- `easegit status` - Show last checkpoint information
+- `easegit undo` - Restore last checkpoint
+
+## What EaseGit is NOT
+
+- Not a Git replacement
+- Not a backup tool
+- Not a tutorial
+- No configuration needed
+- No GUI
+
+## Philosophy
+
+Git is powerful but dangerous. EaseGit makes it safe by creating automatic undo points before operations that can lose work.
+
+You never have to remember to create a checkpoint. EaseGit does it automatically.
+
+## License
+
+MIT

package/bin/easegit

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index.js');

package/dist/git/plumbing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Execute a Git command and return output
+ */
+export declare function gitExec(args: string[], cwd?: string): string;
+/**
+ * Check if current directory is a Git repository
+ */
+export declare function isGitRepo(): boolean;
+/**
+ * Get the Git directory path
+ */
+export declare function getGitDir(): string;
+/**
+ * Get the root directory of the Git repository
+ */
+export declare function getRepoRoot(): string;
+/**
+ * Create a tree object from the current working directory and index
+ * Returns the tree SHA
+ */
+export declare function createTreeFromWorkingDir(): string;
+/**
+ * Create a ref under refs/easegit/checkpoints/
+ */
+export declare function createCheckpointRef(treeSha: string, operation: string): string;
+/**
+ * Get the most recent checkpoint ref
+ */
+export declare function getLatestCheckpointRef(): string | null;
+/**
+ * Get checkpoint info
+ */
+export declare function getCheckpointInfo(refName: string): {
+    timestamp: number;
+    operation: string;
+    commitSha: string;
+} | null;
+/**
+ * Restore working directory from a tree SHA
+ */
+export declare function restoreFromTree(commitSha: string): void;
+/**
+ * Check if there are merge conflicts
+ */
+export declare function hasMergeConflicts(): boolean;
+/**
+ * Check if HEAD is detached
+ */
+export declare function isDetachedHead(): boolean;
+/**
+ * Check if working directory is dirty
+ */
+export declare function isDirty(): boolean;

package/dist/git/plumbing.js

@@ -0,0 +1,236 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitExec = gitExec;
+exports.isGitRepo = isGitRepo;
+exports.getGitDir = getGitDir;
+exports.getRepoRoot = getRepoRoot;
+exports.createTreeFromWorkingDir = createTreeFromWorkingDir;
+exports.createCheckpointRef = createCheckpointRef;
+exports.getLatestCheckpointRef = getLatestCheckpointRef;
+exports.getCheckpointInfo = getCheckpointInfo;
+exports.restoreFromTree = restoreFromTree;
+exports.hasMergeConflicts = hasMergeConflicts;
+exports.isDetachedHead = isDetachedHead;
+exports.isDirty = isDirty;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+/**
+ * Execute a Git command and return output
+ */
+function gitExec(args, cwd) {
+    try {
+        return (0, child_process_1.execSync)(`git ${args.join(' ')}`, {
+            cwd: cwd || process.cwd(),
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch (error) {
+        throw new Error(`Git command failed: ${error.message}`);
+    }
+}
+/**
+ * Check if current directory is a Git repository
+ */
+function isGitRepo() {
+    try {
+        gitExec(['rev-parse', '--git-dir']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the Git directory path
+ */
+function getGitDir() {
+    return gitExec(['rev-parse', '--git-dir']);
+}
+/**
+ * Get the root directory of the Git repository
+ */
+function getRepoRoot() {
+    return gitExec(['rev-parse', '--show-toplevel']);
+}
+/**
+ * Create a tree object from the current working directory and index
+ * Returns the tree SHA
+ */
+function createTreeFromWorkingDir() {
+    const fs = require('fs');
+    // Add all files including untracked to index temporarily
+    const originalIndex = path.join(getGitDir(), 'index');
+    const tempIndex = path.join(getGitDir(), 'index.easegit.tmp');
+    try {
+        // Copy current index
+        fs.copyFileSync(originalIndex, tempIndex);
+        // Set temporary index
+        process.env.GIT_INDEX_FILE = tempIndex;
+        // Add all files including untracked
+        gitExec(['add', '-A']);
+        // Write tree
+        const treeSha = gitExec(['write-tree']);
+        return treeSha;
+    }
+    finally {
+        // Restore original index
+        delete process.env.GIT_INDEX_FILE;
+        // Clean up temp index
+        try {
+            fs.unlinkSync(tempIndex);
+        }
+        catch { }
+    }
+}
+/**
+ * Create a ref under refs/easegit/checkpoints/
+ */
+function createCheckpointRef(treeSha, operation) {
+    const timestamp = Date.now();
+    const refName = `refs/easegit/checkpoints/${timestamp}`;
+    // Create a commit object for the checkpoint
+    const message = `EaseGit checkpoint before ${operation}\nTimestamp: ${timestamp}`;
+    // Use current HEAD as parent if it exists
+    const commitArgs = ['commit-tree', treeSha, '-m', message];
+    try {
+        const head = gitExec(['rev-parse', 'HEAD']);
+        commitArgs.splice(2, 0, '-p', head);
+    }
+    catch {
+        // No HEAD yet (empty repo)
+    }
+    const commitSha = gitExec(commitArgs).trim();
+    // Update ref
+    gitExec(['update-ref', refName, commitSha]);
+    return refName;
+}
+/**
+ * Get the most recent checkpoint ref
+ */
+function getLatestCheckpointRef() {
+    try {
+        const refs = gitExec(['for-each-ref', 'refs/easegit/checkpoints/', '--sort=-refname', '--format=%(refname)', '--count=1']);
+        return refs || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get checkpoint info
+ */
+function getCheckpointInfo(refName) {
+    try {
+        const commitSha = gitExec(['rev-parse', refName]);
+        const message = gitExec(['log', '-1', '--format=%B', commitSha]);
+        const timestampMatch = message.match(/Timestamp: (\d+)/);
+        const operationMatch = message.match(/checkpoint before (.+)/);
+        if (!timestampMatch)
+            return null;
+        return {
+            timestamp: parseInt(timestampMatch[1]),
+            operation: operationMatch ? operationMatch[1].split('\n')[0] : 'unknown',
+            commitSha
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Restore working directory from a tree SHA
+ */
+function restoreFromTree(commitSha) {
+    const repoRoot = getRepoRoot();
+    // Clear working directory (except .git)
+    gitExec(['clean', '-fd']);
+    // Checkout the tree without moving HEAD
+    gitExec(['checkout', commitSha, '--', '.']);
+}
+/**
+ * Check if there are merge conflicts
+ */
+function hasMergeConflicts() {
+    try {
+        const status = gitExec(['status', '--porcelain']);
+        return status.includes('UU ') || status.includes('AA ') || status.includes('DD ');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if HEAD is detached
+ */
+function isDetachedHead() {
+    try {
+        gitExec(['symbolic-ref', 'HEAD']);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Check if working directory is dirty
+ */
+function isDirty() {
+    try {
+        const status = gitExec(['status', '--porcelain']);
+        return status.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+// CommonJS exports for hook scripts
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        gitExec,
+        isGitRepo,
+        getGitDir,
+        getRepoRoot,
+        createTreeFromWorkingDir,
+        createCheckpointRef,
+        getLatestCheckpointRef,
+        getCheckpointInfo,
+        restoreFromTree,
+        hasMergeConflicts,
+        isDetachedHead,
+        isDirty
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const init_1 = require("./init");
+const status_1 = require("./status");
+const undo_1 = require("./undo");
+const command = process.argv[2];
+async function main() {
+    try {
+        switch (command) {
+            case 'init':
+                await (0, init_1.init)();
+                break;
+            case 'status':
+                await (0, status_1.status)();
+                break;
+            case 'undo':
+                await (0, undo_1.undo)();
+                break;
+            default:
+                console.log('EaseGit - Automatic Git safety checkpoints\n');
+                console.log('Commands:');
+                console.log('  easegit init     Set up EaseGit in this repository');
+                console.log('  easegit status   Show last checkpoint information');
+                console.log('  easegit undo     Restore last checkpoint');
+                process.exit(command ? 1 : 0);
+        }
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+main();

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/init.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const plumbing_1 = require("./git/plumbing");
+async function init() {
+    if (!(0, plumbing_1.isGitRepo)()) {
+        throw new Error('Not a Git repository. Run this command inside a Git repository.');
+    }
+    const gitDir = (0, plumbing_1.getGitDir)();
+    const hooksDir = path.join(gitDir, 'hooks');
+    // Ensure hooks directory exists
+    if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+    }
+    // Hook definitions
+    const hooks = [
+        'pre-rebase',
+        'pre-merge-commit',
+        'pre-push',
+        'post-checkout'
+    ];
+    // Get the hooks template directory (from installed package)
+    // This will be in node_modules/easegit/hooks or local hooks/ during development
+    const packageHooksDir = path.join(__dirname, '..', 'hooks');
+    // Install hooks
+    for (const hookName of hooks) {
+        const hookPath = path.join(hooksDir, hookName);
+        const templatePath = path.join(packageHooksDir, hookName);
+        if (fs.existsSync(templatePath)) {
+            // Copy the hook template
+            const hookContent = fs.readFileSync(templatePath, 'utf8');
+            fs.writeFileSync(hookPath, hookContent, { mode: 0o755 });
+        }
+    }
+    console.log('EaseGit initialized successfully');
+    console.log('Automatic checkpoints will be created before dangerous operations');
+}

package/dist/snapshot/create.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Create a checkpoint of the current working state
+ */
+export declare function createCheckpoint(operation: string): void;

package/dist/snapshot/create.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckpoint = createCheckpoint;
+const plumbing_1 = require("../git/plumbing");
+/**
+ * Create a checkpoint of the current working state
+ */
+function createCheckpoint(operation) {
+    try {
+        // Create tree from current working directory (includes untracked files)
+        const treeSha = (0, plumbing_1.createTreeFromWorkingDir)();
+        // Store as checkpoint ref
+        (0, plumbing_1.createCheckpointRef)(treeSha, operation);
+    }
+    catch (error) {
+        // Silently fail - checkpoints are best-effort
+        // We never want to block the user's Git operation
+    }
+}
+// CommonJS export for hook scripts
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = { createCheckpoint };
+}

package/dist/snapshot/restore.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Restore the most recent checkpoint
+ */
+export declare function restoreCheckpoint(): void;

package/dist/snapshot/restore.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreCheckpoint = restoreCheckpoint;
+const plumbing_1 = require("../git/plumbing");
+/**
+ * Restore the most recent checkpoint
+ */
+function restoreCheckpoint() {
+    const refName = (0, plumbing_1.getLatestCheckpointRef)();
+    if (!refName) {
+        throw new Error('No checkpoint found to restore');
+    }
+    const info = (0, plumbing_1.getCheckpointInfo)(refName);
+    if (!info) {
+        throw new Error('Checkpoint data is corrupted');
+    }
+    // Restore working directory from the checkpoint
+    (0, plumbing_1.restoreFromTree)(info.commitSha);
+    console.log(`Restored checkpoint from ${new Date(info.timestamp).toLocaleString()}`);
+    console.log(`Operation: ${info.operation}`);
+}

package/dist/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/status.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = status;
+const plumbing_1 = require("./git/plumbing");
+async function status() {
+    if (!(0, plumbing_1.isGitRepo)()) {
+        throw new Error('Not a Git repository');
+    }
+    const refName = (0, plumbing_1.getLatestCheckpointRef)();
+    if (!refName) {
+        console.log('No checkpoints available');
+        console.log('EaseGit will create checkpoints automatically before dangerous operations');
+        return;
+    }
+    const info = (0, plumbing_1.getCheckpointInfo)(refName);
+    if (!info) {
+        console.log('Checkpoint data corrupted');
+        return;
+    }
+    const date = new Date(info.timestamp);
+    console.log('Last checkpoint:');
+    console.log(`  Time: ${date.toLocaleString()}`);
+    console.log(`  Operation: ${info.operation}`);
+    console.log(`  Undo available: yes`);
+}

package/dist/undo.d.ts

@@ -0,0 +1 @@
+export declare function undo(): Promise<void>;

package/dist/undo.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undo = undo;
+const plumbing_1 = require("./git/plumbing");
+const restore_1 = require("./snapshot/restore");
+async function undo() {
+    if (!(0, plumbing_1.isGitRepo)()) {
+        throw new Error('Not a Git repository');
+    }
+    (0, restore_1.restoreCheckpoint)();
+}

package/hooks/post-checkout

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// Post-checkout hook - creates checkpoint after checkout
+// Also detects failures and warns user
+const path = require('path');
+const mainPath = path.join(__dirname, '..', '..');
+const { createCheckpoint } = require(path.join(mainPath, 'dist', 'snapshot', 'create'));
+const { hasMergeConflicts, isDetachedHead, isDirty } = require(path.join(mainPath, 'dist', 'git', 'plumbing'));
+
+// Create checkpoint for the new state
+createCheckpoint('checkout');
+
+// Check for problems after checkout
+try {
+  const hasConflicts = hasMergeConflicts();
+  const detached = isDetachedHead();
+  const dirty = isDirty();
+  
+  if (hasConflicts || (detached && dirty)) {
+    console.error('⚠ EaseGit: last Git operation damaged your working state.');
+    console.error('Run `easegit undo` to restore the last safe checkpoint.');
+  }
+} catch {
+  // Silent fail
+}

package/hooks/pre-merge-commit

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// Pre-merge hook - creates checkpoint before merge
+const path = require('path');
+const mainPath = path.join(__dirname, '..', '..');
+const { createCheckpoint } = require(path.join(mainPath, 'dist', 'snapshot', 'create'));
+
+createCheckpoint('merge');

package/hooks/pre-push

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// Pre-push hook - creates checkpoint before push
+const path = require('path');
+const mainPath = path.join(__dirname, '..', '..');
+const { createCheckpoint } = require(path.join(mainPath, 'dist', 'snapshot', 'create'));
+
+createCheckpoint('push');

package/hooks/pre-rebase

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// Pre-rebase hook - creates checkpoint before rebase
+const path = require('path');
+const mainPath = path.join(__dirname, '..', '..');
+const { createCheckpoint } = require(path.join(mainPath, 'dist', 'snapshot', 'create'));
+
+createCheckpoint('rebase');

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "easegit-cli",
+  "version": "1.0.0",
+  "description": "Automatic checkpoints before Git can hurt you",
+  "main": "dist/index.js",
+  "bin": {
+    "easegit": "./bin/easegit"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "hooks",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublish": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "undo",
+    "safety",
+    "checkpoint",
+    "git-safety",
+    "git-undo"
+  ],
+  "author": "hp-078",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hp-078/easegit-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hp-078/easegit-cli/issues"
+  },
+  "homepage": "https://github.com/hp-078/easegit-cli#readme",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}