@amoghvj/txr 0.1.0 → 0.1.2

package/README.md

@@ -13,21 +13,13 @@ It works independently of any user Git repository, maintaining its own internal
 
 ## Installation
 
-Currently, `txr` is available as a local package.
+`txr` is available as a global npm package.
 
 ```bash
-# Clone or navigate to the repository
-cd agent-cli
-
-# Install dependencies and build
-npm install
-npm run build
-
-# Link globally (optional, so you can run 'txr' anywhere)
-npm link
+npm install -g @amoghvj/txr
 ```
 
-If you don't link it, you can run it via `node dist/index.js` or `npx .`.
+Once installed, the `txr` command will be available anywhere on your system.
 
 ## Usage Instructions
 
@@ -110,6 +102,7 @@ txr history
 
 ## Advanced Options
 
+* `txr clear`: Permanently reset the internal state and delete all transaction history in the active `.txr` folder. Useful if the system enters an unrecoverable state or you want to start fresh. Use `-y` to skip confirmation.
 * `txr run --transactional "cmd"`: Force a command to be tracked as transactional, even if the classifier flags it as unsafe.
 * `txr run --no-transaction "cmd"`: Force a command to run directly without tracking or generating a transaction.
 

package/dist/chunk-XKFFIQXW.js

@@ -0,0 +1,186 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/git/git-store.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import git from "isomorphic-git";
+var GitStore = class {
+  repoDir;
+  constructor(repoDir) {
+    this.repoDir = repoDir;
+  }
+  /** Initialize a new Git repository with an empty initial commit. */
+  async init() {
+    await fs.mkdir(this.repoDir, { recursive: true });
+    await git.init({ fs, dir: this.repoDir });
+    const commitHash = await git.commit({
+      fs,
+      dir: this.repoDir,
+      message: "txr: init",
+      author: { name: "txr", email: "txr@internal" }
+    });
+    return commitHash;
+  }
+  /** Write a file (by file ID) into the repo working tree and stage it. */
+  async writeFile(fileId, content) {
+    const filePath = path.join(this.repoDir, fileId);
+    await fs.writeFile(filePath, content);
+    await git.add({ fs, dir: this.repoDir, filepath: fileId });
+  }
+  /** Remove a file (by file ID) from the repo working tree and stage the removal. */
+  async removeFile(fileId) {
+    const filePath = path.join(this.repoDir, fileId);
+    try {
+      await fs.unlink(filePath);
+    } catch {
+    }
+    await git.remove({ fs, dir: this.repoDir, filepath: fileId });
+  }
+  /** Create a commit with all currently staged changes. */
+  async commit(message) {
+    const commitHash = await git.commit({
+      fs,
+      dir: this.repoDir,
+      message,
+      author: { name: "txr", email: "txr@internal" }
+    });
+    return commitHash;
+  }
+  /** Read file content at a specific commit. Returns the raw Buffer. */
+  async readBlob(commitHash, fileId) {
+    const { blob } = await git.readBlob({
+      fs,
+      dir: this.repoDir,
+      oid: commitHash,
+      filepath: fileId
+    });
+    return Buffer.from(blob);
+  }
+  /**
+   * Check if a file exists in a specific commit's tree.
+   */
+  async fileExistsAtCommit(commitHash, fileId) {
+    try {
+      await git.readBlob({
+        fs,
+        dir: this.repoDir,
+        oid: commitHash,
+        filepath: fileId
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Hard reset the repo to a specific commit.
+   *
+   * isomorphic-git doesn't have a native `reset --hard`, so we:
+   * 1. Update the branch ref to point to the target commit.
+   * 2. Check out the working tree from that commit.
+   */
+  async resetHard(commitHash) {
+    await git.writeRef({
+      fs,
+      dir: this.repoDir,
+      ref: "refs/heads/main",
+      value: commitHash,
+      force: true
+    });
+    await git.checkout({
+      fs,
+      dir: this.repoDir,
+      ref: "main",
+      force: true
+    });
+  }
+  /**
+   * Reset to the initial empty state.
+   * Removes all tracked files and creates a fresh empty commit.
+   */
+  async resetToEmpty() {
+    const entries = await fs.readdir(this.repoDir);
+    for (const entry of entries) {
+      if (entry === ".git") continue;
+      const fullPath = path.join(this.repoDir, entry);
+      const stat2 = await fs.stat(fullPath);
+      if (stat2.isFile()) {
+        await git.remove({ fs, dir: this.repoDir, filepath: entry });
+        await fs.unlink(fullPath);
+      }
+    }
+    const commitHash = await git.commit({
+      fs,
+      dir: this.repoDir,
+      message: "txr: reset to empty",
+      author: { name: "txr", email: "txr@internal" }
+    });
+    return commitHash;
+  }
+  /** Get the current HEAD commit hash. */
+  async getHead() {
+    return await git.resolveRef({ fs, dir: this.repoDir, ref: "HEAD" });
+  }
+  /**
+   * List files that differ between two commits.
+   * Returns arrays of added, modified, and deleted file IDs.
+   */
+  async diffCommits(commitA, commitB) {
+    const treeA = await this.listTree(commitA);
+    const treeB = await this.listTree(commitB);
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const [filepath, oidB] of treeB) {
+      const oidA = treeA.get(filepath);
+      if (!oidA) {
+        added.push(filepath);
+      } else if (oidA !== oidB) {
+        modified.push(filepath);
+      }
+    }
+    for (const [filepath] of treeA) {
+      if (!treeB.has(filepath)) {
+        deleted.push(filepath);
+      }
+    }
+    return { added, modified, deleted };
+  }
+  /** List all files in a commit's tree as Map<filepath, blobOid>. */
+  async listTree(commitHash) {
+    const result = /* @__PURE__ */ new Map();
+    try {
+      const entries = await git.walk({
+        fs,
+        dir: this.repoDir,
+        trees: [git.TREE({ ref: commitHash })],
+        map: async (filepath, [entry]) => {
+          if (!entry || filepath === ".") return void 0;
+          const type = await entry.type();
+          if (type === "blob") {
+            const oid = await entry.oid();
+            return { filepath, oid };
+          }
+          return void 0;
+        }
+      });
+      for (const entry of entries) {
+        if (entry) {
+          result.set(entry.filepath, entry.oid);
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+};
+
+export {
+  __require,
+  GitStore
+};

package/dist/git-store-XSOIM4KZ.js

@@ -0,0 +1,6 @@
+import {
+  GitStore
+} from "./chunk-XKFFIQXW.js";
+export {
+  GitStore
+};

package/dist/index.js

@@ -1,194 +1,16 @@
 #!/usr/bin/env node
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  GitStore,
+  __require
+} from "./chunk-XKFFIQXW.js";
 
 // src/index.ts
 import { Command } from "commander";
 
 // src/cli/commands/init.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-
-// src/git/git-store.ts
 import * as fs from "fs/promises";
 import * as path from "path";
-import git from "isomorphic-git";
-var GitStore = class {
-  repoDir;
-  constructor(repoDir) {
-    this.repoDir = repoDir;
-  }
-  /** Initialize a new Git repository with an empty initial commit. */
-  async init() {
-    await fs.mkdir(this.repoDir, { recursive: true });
-    await git.init({ fs, dir: this.repoDir });
-    const commitHash = await git.commit({
-      fs,
-      dir: this.repoDir,
-      message: "txr: init",
-      author: { name: "txr", email: "txr@internal" }
-    });
-    return commitHash;
-  }
-  /** Write a file (by file ID) into the repo working tree and stage it. */
-  async writeFile(fileId, content) {
-    const filePath = path.join(this.repoDir, fileId);
-    await fs.writeFile(filePath, content);
-    await git.add({ fs, dir: this.repoDir, filepath: fileId });
-  }
-  /** Remove a file (by file ID) from the repo working tree and stage the removal. */
-  async removeFile(fileId) {
-    const filePath = path.join(this.repoDir, fileId);
-    try {
-      await fs.unlink(filePath);
-    } catch {
-    }
-    await git.remove({ fs, dir: this.repoDir, filepath: fileId });
-  }
-  /** Create a commit with all currently staged changes. */
-  async commit(message) {
-    const commitHash = await git.commit({
-      fs,
-      dir: this.repoDir,
-      message,
-      author: { name: "txr", email: "txr@internal" }
-    });
-    return commitHash;
-  }
-  /** Read file content at a specific commit. Returns the raw Buffer. */
-  async readBlob(commitHash, fileId) {
-    const { blob } = await git.readBlob({
-      fs,
-      dir: this.repoDir,
-      oid: commitHash,
-      filepath: fileId
-    });
-    return Buffer.from(blob);
-  }
-  /**
-   * Check if a file exists in a specific commit's tree.
-   */
-  async fileExistsAtCommit(commitHash, fileId) {
-    try {
-      await git.readBlob({
-        fs,
-        dir: this.repoDir,
-        oid: commitHash,
-        filepath: fileId
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Hard reset the repo to a specific commit.
-   *
-   * isomorphic-git doesn't have a native `reset --hard`, so we:
-   * 1. Update the branch ref to point to the target commit.
-   * 2. Check out the working tree from that commit.
-   */
-  async resetHard(commitHash) {
-    await git.writeRef({
-      fs,
-      dir: this.repoDir,
-      ref: "refs/heads/main",
-      value: commitHash,
-      force: true
-    });
-    await git.checkout({
-      fs,
-      dir: this.repoDir,
-      ref: "main",
-      force: true
-    });
-  }
-  /**
-   * Reset to the initial empty state.
-   * Removes all tracked files and creates a fresh empty commit.
-   */
-  async resetToEmpty() {
-    const entries = await fs.readdir(this.repoDir);
-    for (const entry of entries) {
-      if (entry === ".git") continue;
-      const fullPath = path.join(this.repoDir, entry);
-      const stat4 = await fs.stat(fullPath);
-      if (stat4.isFile()) {
-        await git.remove({ fs, dir: this.repoDir, filepath: entry });
-        await fs.unlink(fullPath);
-      }
-    }
-    const commitHash = await git.commit({
-      fs,
-      dir: this.repoDir,
-      message: "txr: reset to empty",
-      author: { name: "txr", email: "txr@internal" }
-    });
-    return commitHash;
-  }
-  /** Get the current HEAD commit hash. */
-  async getHead() {
-    return await git.resolveRef({ fs, dir: this.repoDir, ref: "HEAD" });
-  }
-  /**
-   * List files that differ between two commits.
-   * Returns arrays of added, modified, and deleted file IDs.
-   */
-  async diffCommits(commitA, commitB) {
-    const treeA = await this.listTree(commitA);
-    const treeB = await this.listTree(commitB);
-    const added = [];
-    const modified = [];
-    const deleted = [];
-    for (const [filepath, oidB] of treeB) {
-      const oidA = treeA.get(filepath);
-      if (!oidA) {
-        added.push(filepath);
-      } else if (oidA !== oidB) {
-        modified.push(filepath);
-      }
-    }
-    for (const [filepath] of treeA) {
-      if (!treeB.has(filepath)) {
-        deleted.push(filepath);
-      }
-    }
-    return { added, modified, deleted };
-  }
-  /** List all files in a commit's tree as Map<filepath, blobOid>. */
-  async listTree(commitHash) {
-    const result = /* @__PURE__ */ new Map();
-    try {
-      const entries = await git.walk({
-        fs,
-        dir: this.repoDir,
-        trees: [git.TREE({ ref: commitHash })],
-        map: async (filepath, [entry]) => {
-          if (!entry || filepath === ".") return void 0;
-          const type = await entry.type();
-          if (type === "blob") {
-            const oid = await entry.oid();
-            return { filepath, oid };
-          }
-          return void 0;
-        }
-      });
-      for (const entry of entries) {
-        if (entry) {
-          result.set(entry.filepath, entry.oid);
-        }
-      }
-    } catch {
-    }
-    return result;
-  }
-};
-
-// src/cli/commands/init.ts
+import * as os from "os";
 var TXR_DIR = ".txr";
 var REPO_DIR = "repo";
 var METADATA_DIR = "metadata";
@@ -216,70 +38,78 @@ var GLOBAL_CONFIG = {
   // Base watch path; additional paths can be added
 };
 async function initTxr(projectRoot, options = {}) {
-  const txrDir = path2.join(projectRoot, TXR_DIR);
-  const repoDir = path2.join(txrDir, REPO_DIR);
-  const metadataDir = path2.join(txrDir, METADATA_DIR);
+  const txrDir = path.join(projectRoot, TXR_DIR);
+  const repoDir = path.join(txrDir, REPO_DIR);
+  const metadataDir = path.join(txrDir, METADATA_DIR);
   try {
-    await fs2.access(txrDir);
+    await fs.access(txrDir);
     throw new Error(`Already initialized: ${txrDir} exists.`);
   } catch (err) {
     if (err.message?.startsWith("Already initialized")) throw err;
   }
-  await fs2.mkdir(metadataDir, { recursive: true });
+  await fs.mkdir(metadataDir, { recursive: true });
   const gitStore = new GitStore(repoDir);
   await gitStore.init();
-  await fs2.writeFile(
-    path2.join(metadataDir, "mapping.json"),
+  await fs.writeFile(
+    path.join(metadataDir, "mapping.json"),
     JSON.stringify({ version: 1, files: {} }, null, 2),
     "utf-8"
   );
-  await fs2.writeFile(
-    path2.join(metadataDir, "transactions.json"),
+  await fs.writeFile(
+    path.join(metadataDir, "transactions.json"),
     JSON.stringify({ version: 1, head: null, undoStack: [], counter: 0, transactions: {} }, null, 2),
     "utf-8"
   );
-  await fs2.writeFile(
-    path2.join(metadataDir, "history.json"),
+  await fs.writeFile(
+    path.join(metadataDir, "history.json"),
     JSON.stringify({ version: 1, entries: [] }, null, 2),
     "utf-8"
   );
   const config = options.scope === "global" ? GLOBAL_CONFIG : DEFAULT_CONFIG;
-  await fs2.writeFile(
-    path2.join(metadataDir, "config.json"),
+  await fs.writeFile(
+    path.join(metadataDir, "config.json"),
     JSON.stringify(config, null, 2),
     "utf-8"
   );
 }
 async function findTxrRoot(startDir) {
-  let dir = path2.resolve(startDir);
+  let dir = path.resolve(startDir);
   while (true) {
-    const candidate = path2.join(dir, TXR_DIR);
+    const candidate = path.join(dir, TXR_DIR);
     try {
-      const stat4 = await fs2.stat(candidate);
-      if (stat4.isDirectory()) return dir;
+      const stat3 = await fs.stat(candidate);
+      if (stat3.isDirectory()) return dir;
     } catch {
     }
-    const parent = path2.dirname(dir);
+    const parent = path.dirname(dir);
     if (parent === dir) {
-      throw new Error(
-        "Not a txr project (or any parent). Run `txr init` first."
-      );
+      const homeDir = os.homedir();
+      const homeTxr = path.join(homeDir, TXR_DIR);
+      try {
+        const homeStat = await fs.stat(homeTxr);
+        if (homeStat.isDirectory()) return homeDir;
+      } catch {
+        console.log(`\x1B[90mNo local workspace found. Auto-initializing global txr in ${homeDir}...\x1B[0m`);
+        await initTxr(homeDir, { scope: "global" });
+        return homeDir;
+      }
+      return homeDir;
     }
     dir = parent;
   }
 }
 function getTxrPaths(projectRoot) {
-  const txrDir = path2.join(projectRoot, TXR_DIR);
+  const txrDir = path.join(projectRoot, TXR_DIR);
   return {
     txrDir,
-    repoDir: path2.join(txrDir, REPO_DIR),
-    metadataDir: path2.join(txrDir, METADATA_DIR),
-    lockFile: path2.join(txrDir, "lock")
+    repoDir: path.join(txrDir, REPO_DIR),
+    metadataDir: path.join(txrDir, METADATA_DIR),
+    lockFile: path.join(txrDir, "lock")
   };
 }
 async function loadConfig(metadataDir) {
   try {
-    const raw = await fs2.readFile(path2.join(metadataDir, "config.json"), "utf-8");
+    const raw = await fs.readFile(path.join(metadataDir, "config.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return DEFAULT_CONFIG;
@@ -287,8 +117,8 @@ async function loadConfig(metadataDir) {
 }
 
 // src/core/transaction-store.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
 var TransactionStore = class _TransactionStore {
   data;
   filePath;
@@ -298,9 +128,9 @@ var TransactionStore = class _TransactionStore {
   }
   /** Load from disk, or create empty store. */
   static async load(metadataDir) {
-    const filePath = path3.join(metadataDir, "transactions.json");
+    const filePath = path2.join(metadataDir, "transactions.json");
     try {
-      const raw = await fs3.readFile(filePath, "utf-8");
+      const raw = await fs2.readFile(filePath, "utf-8");
       const data = JSON.parse(raw);
       return new _TransactionStore(filePath, data);
     } catch {
@@ -316,8 +146,8 @@ var TransactionStore = class _TransactionStore {
   }
   async save() {
     const tmp = this.filePath + ".tmp";
-    await fs3.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
-    await fs3.rename(tmp, this.filePath);
+    await fs2.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+    await fs2.rename(tmp, this.filePath);
   }
   /** Generate the next transaction ID (monotonically increasing). */
   nextId() {
@@ -396,8 +226,8 @@ var TransactionStore = class _TransactionStore {
 };
 
 // src/core/history-store.ts
-import * as fs4 from "fs/promises";
-import * as path4 from "path";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
 var HistoryStore = class _HistoryStore {
   data;
   filePath;
@@ -406,9 +236,9 @@ var HistoryStore = class _HistoryStore {
     this.data = data;
   }
   static async load(metadataDir) {
-    const filePath = path4.join(metadataDir, "history.json");
+    const filePath = path3.join(metadataDir, "history.json");
     try {
-      const raw = await fs4.readFile(filePath, "utf-8");
+      const raw = await fs3.readFile(filePath, "utf-8");
       const data = JSON.parse(raw);
       return new _HistoryStore(filePath, data);
     } catch {
@@ -418,8 +248,8 @@ var HistoryStore = class _HistoryStore {
   }
   async save() {
     const tmp = this.filePath + ".tmp";
-    await fs4.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
-    await fs4.rename(tmp, this.filePath);
+    await fs3.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+    await fs3.rename(tmp, this.filePath);
   }
   /** Append a new history entry. */
   append(entry) {
@@ -440,8 +270,8 @@ var HistoryStore = class _HistoryStore {
 };
 
 // src/core/file-map.ts
-import * as fs5 from "fs/promises";
-import * as path5 from "path";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
 import { nanoid } from "nanoid";
 var FileMap = class _FileMap {
   data;
@@ -456,9 +286,9 @@ var FileMap = class _FileMap {
   }
   /** Load mapping from disk, or create empty mapping if file doesn't exist. */
   static async load(metadataDir) {
-    const filePath = path5.join(metadataDir, "mapping.json");
+    const filePath = path4.join(metadataDir, "mapping.json");
     try {
-      const raw = await fs5.readFile(filePath, "utf-8");
+      const raw = await fs4.readFile(filePath, "utf-8");
       const data = JSON.parse(raw);
       return new _FileMap(filePath, data);
     } catch {
@@ -469,12 +299,12 @@ var FileMap = class _FileMap {
   /** Persist current state to disk atomically. */
   async save() {
     const tmp = this.filePath + ".tmp";
-    await fs5.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
-    await fs5.rename(tmp, this.filePath);
+    await fs4.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+    await fs4.rename(tmp, this.filePath);
   }
   /** Normalize a path for consistent lookup (forward slashes, resolved). */
   static normalizePath(p) {
-    return path5.resolve(p).replace(/\\/g, "/");
+    return path4.resolve(p).replace(/\\/g, "/");
   }
   /** Get file ID for a path, or undefined if not mapped. Only returns active (non-deleted) entries. */
   getIdByPath(absolutePath) {
@@ -552,12 +382,12 @@ var FileMap = class _FileMap {
 };
 
 // src/core/transaction-engine.ts
-import * as fs7 from "fs/promises";
-import * as path8 from "path";
+import * as fs6 from "fs/promises";
+import * as path7 from "path";
 
 // src/attribution/tier3-hybrid.ts
-import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
 import * as crypto from "crypto";
 import { spawn } from "child_process";
 import { minimatch } from "minimatch";
@@ -572,7 +402,7 @@ var Tier3HybridProvider = class {
       "Using scoped filesystem diff (Tier 3). Changes by concurrent processes within watch paths may be mis-attributed."
     ];
     const resolvedWatchPaths = options.watchPaths.map(
-      (p) => path6.isAbsolute(p) ? p : path6.resolve(cwd, p)
+      (p) => path5.isAbsolute(p) ? p : path5.resolve(cwd, p)
     );
     const preSnapshot = await this.snapshotPaths(resolvedWatchPaths, options.ignorePaths);
     const exitCode = await this.executeCommand(command, cwd, options);
@@ -598,36 +428,36 @@ var Tier3HybridProvider = class {
     return snapshots;
   }
   async walkAndHash(currentPath, rootPath, ignorePaths, snapshots) {
-    let stat4;
+    let stat3;
     try {
-      stat4 = await fs6.stat(currentPath);
+      stat3 = await fs5.stat(currentPath);
     } catch {
       return;
     }
     const normalized = currentPath.replace(/\\/g, "/");
-    const relativePath = path6.relative(rootPath, currentPath).replace(/\\/g, "/");
+    const relativePath = path5.relative(rootPath, currentPath).replace(/\\/g, "/");
     for (const pattern of ignorePaths) {
-      if (minimatch(relativePath, pattern, { dot: true }) || minimatch(path6.basename(currentPath), pattern, { dot: true })) {
+      if (minimatch(relativePath, pattern, { dot: true }) || minimatch(path5.basename(currentPath), pattern, { dot: true })) {
         return;
       }
     }
-    if (stat4.isFile()) {
+    if (stat3.isFile()) {
       const hash = await this.hashFile(currentPath);
       snapshots.set(normalized, {
         path: normalized,
         hash,
-        size: stat4.size
+        size: stat3.size
       });
-    } else if (stat4.isDirectory()) {
+    } else if (stat3.isDirectory()) {
       let entries;
       try {
-        entries = await fs6.readdir(currentPath);
+        entries = await fs5.readdir(currentPath);
       } catch {
         return;
       }
       for (const entry of entries) {
         await this.walkAndHash(
-          path6.join(currentPath, entry),
+          path5.join(currentPath, entry),
           rootPath,
           ignorePaths,
           snapshots
@@ -636,7 +466,7 @@ var Tier3HybridProvider = class {
     }
   }
   async hashFile(filePath) {
-    const content = await fs6.readFile(filePath);
+    const content = await fs5.readFile(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
   }
   /**
@@ -719,7 +549,7 @@ function getOrderedProviders() {
 }
 
 // src/classifier/classifier.ts
-import * as path7 from "path";
+import * as path6 from "path";
 var DEFAULT_RULES = [
   // ── Containers & Orchestration ──
   { pattern: /^docker\b/, type: "non-transactional", category: "container", reason: "Container orchestration \u2014 may modify container/image state" },
@@ -805,18 +635,18 @@ function classifyCommand(command, scope = "workspace", projectRoot, extraRules =
   return { type: "transactional" };
 }
 function detectPathEscape(command, projectRoot) {
-  const normalizedRoot = path7.resolve(projectRoot).replace(/\\/g, "/").toLowerCase();
+  const normalizedRoot = path6.resolve(projectRoot).replace(/\\/g, "/").toLowerCase();
   const tokens = command.split(/\s+/);
   for (const token of tokens) {
     const cleaned = token.replace(/["']/g, "");
     if (cleaned.startsWith("/") && !cleaned.startsWith("/dev/null")) {
-      const normalizedToken = path7.resolve(cleaned).replace(/\\/g, "/").toLowerCase();
+      const normalizedToken = path6.resolve(cleaned).replace(/\\/g, "/").toLowerCase();
       if (!normalizedToken.startsWith(normalizedRoot)) {
         return `Path "${cleaned}" is outside the workspace root (${projectRoot})`;
       }
     }
     if (/^[A-Za-z]:[\\/]/.test(cleaned)) {
-      const normalizedToken = path7.resolve(cleaned).replace(/\\/g, "/").toLowerCase();
+      const normalizedToken = path6.resolve(cleaned).replace(/\\/g, "/").toLowerCase();
       if (!normalizedToken.startsWith(normalizedRoot)) {
         return `Path "${cleaned}" is outside the workspace root (${projectRoot})`;
       }
@@ -868,7 +698,7 @@ var TransactionEngine = class {
     }
     const provider = await selectProvider(this.config.preferredTier);
     const resolvedWatchPaths = this.config.watchPaths.map(
-      (p) => path8.isAbsolute(p) ? p : path8.resolve(cwd, p)
+      (p) => path7.isAbsolute(p) ? p : path7.resolve(cwd, p)
     );
     const result = await provider.executeAndTrack(command, cwd, {
       watchPaths: resolvedWatchPaths,
@@ -880,7 +710,7 @@ var TransactionEngine = class {
     const scopeWarnings = [];
     let trackedChanges;
     if (this.config.scope === "workspace") {
-      const normalizedRoot = path8.resolve(this.projectRoot).replace(/\\/g, "/").toLowerCase();
+      const normalizedRoot = path7.resolve(this.projectRoot).replace(/\\/g, "/").toLowerCase();
       trackedChanges = [];
       for (const change of result.changes) {
         const normalizedChange = change.absolutePath.replace(/\\/g, "/").toLowerCase();
@@ -929,7 +759,7 @@ var TransactionEngine = class {
       if (change.type === "deleted" /* Deleted */) {
         await this.gitStore.removeFile(fileId);
       } else {
-        const content = await fs7.readFile(change.absolutePath);
+        const content = await fs6.readFile(change.absolutePath);
         await this.gitStore.writeFile(fileId, content);
       }
     }
@@ -1083,8 +913,8 @@ async function runCommand(command, options) {
 }
 
 // src/core/undo-engine.ts
-import * as fs8 from "fs/promises";
-import * as path9 from "path";
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
 import * as crypto2 from "crypto";
 var UndoConflictError = class extends Error {
   conflicts;
@@ -1127,11 +957,17 @@ var UndoEngine = class {
           ops.push({ type: "delete", path: filePath });
           break;
         case "modified": {
+          if (!parentTx) {
+            throw new Error(`Cannot undo ${headTx.id}: File was modified in the very first transaction and its original state is untracked.`);
+          }
           const prevContent = await this.gitStore.readBlob(parentTx.commit, fileId);
           ops.push({ type: "write", path: filePath, content: prevContent });
           break;
         }
         case "deleted": {
+          if (!parentTx) {
+            throw new Error(`Cannot undo ${headTx.id}: File was deleted in the very first transaction and its original state is untracked.`);
+          }
           const restoredContent = await this.gitStore.readBlob(parentTx.commit, fileId);
           ops.push({ type: "write", path: filePath, content: restoredContent });
           break;
@@ -1142,14 +978,14 @@ var UndoEngine = class {
     const deletes = ops.filter((o) => o.type === "delete");
     for (const op of writes) {
       if (op.type === "write") {
-        await fs8.mkdir(path9.dirname(op.path), { recursive: true });
-        await fs8.writeFile(op.path, op.content);
+        await fs7.mkdir(path8.dirname(op.path), { recursive: true });
+        await fs7.writeFile(op.path, op.content);
       }
     }
     for (const op of deletes) {
       if (op.type === "delete") {
         try {
-          await fs8.unlink(op.path);
+          await fs7.unlink(op.path);
         } catch {
         }
         await this.removeEmptyParents(op.path);
@@ -1204,14 +1040,14 @@ var UndoEngine = class {
         case "created":
         case "modified": {
           const content = await this.gitStore.readBlob(redoTx.commit, fileId);
-          await fs8.mkdir(path9.dirname(filePath), { recursive: true });
-          await fs8.writeFile(filePath, content);
+          await fs7.mkdir(path8.dirname(filePath), { recursive: true });
+          await fs7.writeFile(filePath, content);
           filesChanged++;
           break;
         }
         case "deleted": {
           try {
-            await fs8.unlink(filePath);
+            await fs7.unlink(filePath);
           } catch {
           }
           await this.removeEmptyParents(filePath);
@@ -1270,7 +1106,7 @@ var UndoEngine = class {
         continue;
       }
       const expectedContent = await this.gitStore.readBlob(tx.commit, fileId);
-      const actualContent = await fs8.readFile(filePath);
+      const actualContent = await fs7.readFile(filePath);
       if (!this.hashEquals(expectedContent, actualContent)) {
         const expectedHash = this.hash(expectedContent).substring(0, 12);
         const actualHash = this.hash(actualContent).substring(0, 12);
@@ -1312,7 +1148,7 @@ var UndoEngine = class {
       if (parentTx) {
         try {
           const expectedContent = await this.gitStore.readBlob(parentTx.commit, fileId);
-          const actualContent = await fs8.readFile(filePath);
+          const actualContent = await fs7.readFile(filePath);
           if (!this.hashEquals(expectedContent, actualContent)) {
             conflicts.push(
               `  \u2717 ${filePath}
@@ -1327,7 +1163,7 @@ var UndoEngine = class {
   }
   async fileExists(filePath) {
     try {
-      await fs8.access(filePath);
+      await fs7.access(filePath);
       return true;
     } catch {
       return false;
@@ -1341,13 +1177,13 @@ var UndoEngine = class {
   }
   /** Remove empty parent directories up to a reasonable depth. */
   async removeEmptyParents(filePath) {
-    let dir = path9.dirname(filePath);
+    let dir = path8.dirname(filePath);
     for (let i = 0; i < 10; i++) {
       try {
-        const entries = await fs8.readdir(dir);
+        const entries = await fs7.readdir(dir);
         if (entries.length === 0) {
-          await fs8.rmdir(dir);
-          dir = path9.dirname(dir);
+          await fs7.rmdir(dir);
+          dir = path8.dirname(dir);
         } else {
           break;
         }
@@ -1451,6 +1287,88 @@ async function historyCommand(count = 20) {
   }
 }
 
+// src/cli/commands/clear.ts
+import * as fs8 from "fs/promises";
+import * as path9 from "path";
+async function clearCommand(options) {
+  const cwd = process.cwd();
+  let projectRoot;
+  try {
+    projectRoot = await findTxrRoot(cwd);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+  if (!options.yes) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve6) => {
+      console.log();
+      console.log(`\x1B[33mWARNING:\x1B[0m`);
+      console.log(`This will permanently delete all transaction history, undo history,`);
+      console.log(`redo history, mappings, and internal Git state.`);
+      console.log();
+      console.log(`This operation cannot be undone.`);
+      console.log();
+      rl.question("Continue? [y/N] ", resolve6);
+    });
+    rl.close();
+    if (answer.trim().toLowerCase() !== "y") {
+      console.log("\x1B[90mOperation cancelled.\x1B[0m");
+      return;
+    }
+  }
+  const txrDir = path9.join(projectRoot, ".txr");
+  const repoDir = path9.join(txrDir, "repo");
+  const metadataDir = path9.join(txrDir, "metadata");
+  try {
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        await fs8.rm(repoDir, { recursive: true, force: true });
+        break;
+      } catch (err) {
+        if (err.code === "EBUSY" || err.code === "EPERM") {
+          retries--;
+          if (retries === 0) {
+            throw new Error(`Files are locked by another process. Please close any IDEs or tools accessing the workspace and try again.
+Details: ${err.message}`);
+          }
+          await new Promise((resolve6) => setTimeout(resolve6, 500));
+        } else {
+          throw err;
+        }
+      }
+    }
+    const { GitStore: GitStore2 } = await import("./git-store-XSOIM4KZ.js");
+    const gitStore = new GitStore2(repoDir);
+    await gitStore.init();
+    await fs8.writeFile(
+      path9.join(metadataDir, "transactions.json"),
+      JSON.stringify({ version: 1, head: null, undoStack: [], counter: 0, transactions: {} }, null, 2),
+      "utf-8"
+    );
+    await fs8.writeFile(
+      path9.join(metadataDir, "mapping.json"),
+      JSON.stringify({ version: 1, files: {} }, null, 2),
+      "utf-8"
+    );
+    await fs8.writeFile(
+      path9.join(metadataDir, "history.json"),
+      JSON.stringify({ version: 1, entries: [] }, null, 2),
+      "utf-8"
+    );
+    console.log();
+    console.log(`\x1B[32m\u2713\x1B[0m Internal state cleared. txr is now ready for a fresh transaction.`);
+  } catch (err) {
+    console.error();
+    console.error(`\x1B[31mReset failed.\x1B[0m`);
+    console.error(`To manually recover, delete the \x1B[1m.txr/repo\x1B[0m folder and run 'txr clear' again.`);
+    console.error(`Error details: ${err.message}`);
+    process.exit(1);
+  }
+}
+
 // src/index.ts
 var program = new Command();
 program.name("txr").description("Transactional command runner \u2014 undo any shell command").version("0.1.0");
@@ -1479,7 +1397,7 @@ program.command("run").description("Execute a command with transactional trackin
       noTransaction: opts.noTransaction
     });
   } catch (err) {
-    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    console.error(`\x1B[31mError:\x1B[0m ${err.stack || err.message}`);
     process.exit(1);
   }
 });
@@ -1515,4 +1433,12 @@ program.command("history").description("Show command history").option("-n, --cou
     process.exit(1);
   }
 });
+program.command("clear").description("Reset the internal state and delete all transaction history").option("-y, --yes", "Skip confirmation prompt").action(async (opts) => {
+  try {
+    await clearCommand({ yes: opts.yes });
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amoghvj/txr",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Transactional command runner — undo any shell command",
   "type": "module",
   "main": "dist/index.js",