@amoghvj/txr 0.1.0

package/dist/index.js

@@ -0,0 +1,1518 @@
+#!/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');
+});
+
+// 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
+var TXR_DIR = ".txr";
+var REPO_DIR = "repo";
+var METADATA_DIR = "metadata";
+var DEFAULT_CONFIG = {
+  version: 1,
+  scope: "workspace",
+  watchPaths: ["."],
+  ignorePaths: [
+    ".git",
+    ".txr",
+    "node_modules/.cache",
+    "*.log",
+    "*.tmp",
+    ".DS_Store",
+    "Thumbs.db"
+  ],
+  preferredTier: "auto",
+  confirmUnsafe: true,
+  maxTransactions: 100
+};
+var GLOBAL_CONFIG = {
+  ...DEFAULT_CONFIG,
+  scope: "global",
+  watchPaths: ["."]
+  // 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);
+  try {
+    await fs2.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 });
+  const gitStore = new GitStore(repoDir);
+  await gitStore.init();
+  await fs2.writeFile(
+    path2.join(metadataDir, "mapping.json"),
+    JSON.stringify({ version: 1, files: {} }, null, 2),
+    "utf-8"
+  );
+  await fs2.writeFile(
+    path2.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"),
+    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"),
+    JSON.stringify(config, null, 2),
+    "utf-8"
+  );
+}
+async function findTxrRoot(startDir) {
+  let dir = path2.resolve(startDir);
+  while (true) {
+    const candidate = path2.join(dir, TXR_DIR);
+    try {
+      const stat4 = await fs2.stat(candidate);
+      if (stat4.isDirectory()) return dir;
+    } catch {
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) {
+      throw new Error(
+        "Not a txr project (or any parent). Run `txr init` first."
+      );
+    }
+    dir = parent;
+  }
+}
+function getTxrPaths(projectRoot) {
+  const txrDir = path2.join(projectRoot, TXR_DIR);
+  return {
+    txrDir,
+    repoDir: path2.join(txrDir, REPO_DIR),
+    metadataDir: path2.join(txrDir, METADATA_DIR),
+    lockFile: path2.join(txrDir, "lock")
+  };
+}
+async function loadConfig(metadataDir) {
+  try {
+    const raw = await fs2.readFile(path2.join(metadataDir, "config.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+// src/core/transaction-store.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var TransactionStore = class _TransactionStore {
+  data;
+  filePath;
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  /** Load from disk, or create empty store. */
+  static async load(metadataDir) {
+    const filePath = path3.join(metadataDir, "transactions.json");
+    try {
+      const raw = await fs3.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      return new _TransactionStore(filePath, data);
+    } catch {
+      const data = {
+        version: 1,
+        head: null,
+        undoStack: [],
+        counter: 0,
+        transactions: {}
+      };
+      return new _TransactionStore(filePath, data);
+    }
+  }
+  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);
+  }
+  /** Generate the next transaction ID (monotonically increasing). */
+  nextId() {
+    this.data.counter += 1;
+    return `tx_${String(this.data.counter).padStart(3, "0")}`;
+  }
+  /** Get the current HEAD transaction ID, or null if no transactions exist. */
+  get head() {
+    return this.data.head;
+  }
+  /** Get a transaction by ID. */
+  get(id) {
+    return this.data.transactions[id];
+  }
+  /** Get the HEAD transaction object, or undefined. */
+  getHead() {
+    return this.data.head ? this.data.transactions[this.data.head] : void 0;
+  }
+  /** Get the undo stack (most recently undone first). */
+  get undoStack() {
+    return this.data.undoStack;
+  }
+  /** Add a new transaction and set it as HEAD. Clears the undo stack. */
+  addTransaction(tx) {
+    this.data.transactions[tx.id] = tx;
+    this.data.head = tx.id;
+    this.data.undoStack = [];
+  }
+  /**
+   * Undo: move HEAD to the parent of the current HEAD.
+   * Pushes the undone transaction ID onto the undo stack.
+   */
+  undoHead() {
+    const head = this.data.head;
+    if (!head) throw new Error("Nothing to undo.");
+    const tx = this.data.transactions[head];
+    if (!tx) throw new Error(`Transaction "${head}" not found.`);
+    this.data.undoStack.unshift(head);
+    this.data.head = tx.parent;
+    return tx;
+  }
+  /**
+   * Redo: pop the most recently undone transaction from the undo stack
+   * and set it as HEAD.
+   */
+  redoNext() {
+    if (this.data.undoStack.length === 0) {
+      throw new Error("Nothing to redo.");
+    }
+    const redoId = this.data.undoStack.shift();
+    const tx = this.data.transactions[redoId];
+    if (!tx) throw new Error(`Transaction "${redoId}" not found.`);
+    this.data.head = redoId;
+    return tx;
+  }
+  /** Get all transactions in chain order (oldest first), up to and including HEAD. */
+  getChain() {
+    const chain = [];
+    let current = this.data.head;
+    while (current) {
+      const tx = this.data.transactions[current];
+      if (!tx) break;
+      chain.unshift(tx);
+      current = tx.parent;
+    }
+    return chain;
+  }
+  /** Get total number of transactions (including orphaned/undone). */
+  get totalCount() {
+    return Object.keys(this.data.transactions).length;
+  }
+  /** Get count of transactions in the active chain. */
+  get chainLength() {
+    return this.getChain().length;
+  }
+};
+
+// src/core/history-store.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+var HistoryStore = class _HistoryStore {
+  data;
+  filePath;
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  static async load(metadataDir) {
+    const filePath = path4.join(metadataDir, "history.json");
+    try {
+      const raw = await fs4.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      return new _HistoryStore(filePath, data);
+    } catch {
+      const data = { version: 1, entries: [] };
+      return new _HistoryStore(filePath, data);
+    }
+  }
+  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);
+  }
+  /** Append a new history entry. */
+  append(entry) {
+    this.data.entries.push(entry);
+  }
+  /** Get all entries (oldest first). */
+  getAll() {
+    return this.data.entries;
+  }
+  /** Get the N most recent entries. */
+  getRecent(n) {
+    return this.data.entries.slice(-n);
+  }
+  /** Get total entry count. */
+  get count() {
+    return this.data.entries.length;
+  }
+};
+
+// src/core/file-map.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import { nanoid } from "nanoid";
+var FileMap = class _FileMap {
+  data;
+  pathIndex;
+  // normalized path → fileId
+  filePath;
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+    this.pathIndex = /* @__PURE__ */ new Map();
+    this.rebuildPathIndex();
+  }
+  /** Load mapping from disk, or create empty mapping if file doesn't exist. */
+  static async load(metadataDir) {
+    const filePath = path5.join(metadataDir, "mapping.json");
+    try {
+      const raw = await fs5.readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      return new _FileMap(filePath, data);
+    } catch {
+      const data = { version: 1, files: {} };
+      return new _FileMap(filePath, data);
+    }
+  }
+  /** 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);
+  }
+  /** Normalize a path for consistent lookup (forward slashes, resolved). */
+  static normalizePath(p) {
+    return path5.resolve(p).replace(/\\/g, "/");
+  }
+  /** Get file ID for a path, or undefined if not mapped. Only returns active (non-deleted) entries. */
+  getIdByPath(absolutePath) {
+    const norm = _FileMap.normalizePath(absolutePath);
+    return this.pathIndex.get(norm);
+  }
+  /** Get file entry by ID. */
+  getEntry(fileId) {
+    return this.data.files[fileId];
+  }
+  /** Get file path by ID (returns undefined if entry doesn't exist). */
+  getPath(fileId) {
+    return this.data.files[fileId]?.path;
+  }
+  /** Get or create a file ID for the given path. Returns existing ID if path is already mapped. */
+  getOrCreateId(absolutePath, transactionId) {
+    const existing = this.getIdByPath(absolutePath);
+    if (existing) return existing;
+    const fileId = nanoid();
+    const norm = _FileMap.normalizePath(absolutePath);
+    this.data.files[fileId] = {
+      path: norm,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdByTx: transactionId
+    };
+    this.pathIndex.set(norm, fileId);
+    return fileId;
+  }
+  /** Mark a file as deleted. Preserves the mapping entry for undo. */
+  markDeleted(fileId, transactionId) {
+    const entry = this.data.files[fileId];
+    if (!entry) throw new Error(`FileMap: unknown file ID "${fileId}"`);
+    entry.deletedAt = (/* @__PURE__ */ new Date()).toISOString();
+    entry.deletedByTx = transactionId;
+    const norm = _FileMap.normalizePath(entry.path);
+    this.pathIndex.delete(norm);
+  }
+  /** Restore a previously deleted file (used during undo). */
+  markRestored(fileId) {
+    const entry = this.data.files[fileId];
+    if (!entry) throw new Error(`FileMap: unknown file ID "${fileId}"`);
+    delete entry.deletedAt;
+    delete entry.deletedByTx;
+    const norm = _FileMap.normalizePath(entry.path);
+    this.pathIndex.set(norm, fileId);
+  }
+  /** Update the path for a file ID (rename). */
+  updatePath(fileId, newAbsolutePath) {
+    const entry = this.data.files[fileId];
+    if (!entry) throw new Error(`FileMap: unknown file ID "${fileId}"`);
+    const oldNorm = _FileMap.normalizePath(entry.path);
+    this.pathIndex.delete(oldNorm);
+    const newNorm = _FileMap.normalizePath(newAbsolutePath);
+    entry.path = newNorm;
+    this.pathIndex.set(newNorm, fileId);
+  }
+  /** Get all active (non-deleted) file entries. */
+  getActiveFiles() {
+    return Object.entries(this.data.files).filter(([, entry]) => !entry.deletedAt).map(([id, entry]) => ({ id, entry }));
+  }
+  /** Get count of active files. */
+  get activeCount() {
+    return this.pathIndex.size;
+  }
+  /** Rebuild the in-memory path→ID index from persisted data. */
+  rebuildPathIndex() {
+    this.pathIndex.clear();
+    for (const [id, entry] of Object.entries(this.data.files)) {
+      if (!entry.deletedAt) {
+        const norm = _FileMap.normalizePath(entry.path);
+        this.pathIndex.set(norm, id);
+      }
+    }
+  }
+};
+
+// src/core/transaction-engine.ts
+import * as fs7 from "fs/promises";
+import * as path8 from "path";
+
+// src/attribution/tier3-hybrid.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+import * as crypto from "crypto";
+import { spawn } from "child_process";
+import { minimatch } from "minimatch";
+var Tier3HybridProvider = class {
+  name = "Tier 3: Scoped Filesystem Diff";
+  tier = 3;
+  async isAvailable() {
+    return true;
+  }
+  async executeAndTrack(command, cwd, options) {
+    const warnings = [
+      "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)
+    );
+    const preSnapshot = await this.snapshotPaths(resolvedWatchPaths, options.ignorePaths);
+    const exitCode = await this.executeCommand(command, cwd, options);
+    const postSnapshot = await this.snapshotPaths(resolvedWatchPaths, options.ignorePaths);
+    const changes = this.diffSnapshots(preSnapshot, postSnapshot);
+    this.detectRenames(changes);
+    return {
+      changes,
+      tier: 3,
+      processExitCode: exitCode,
+      warnings
+    };
+  }
+  /**
+   * Recursively hash all files in the given paths.
+   * Returns a Map of normalized-path → FileSnapshot.
+   */
+  async snapshotPaths(watchPaths, ignorePaths) {
+    const snapshots = /* @__PURE__ */ new Map();
+    for (const watchPath of watchPaths) {
+      await this.walkAndHash(watchPath, watchPath, ignorePaths, snapshots);
+    }
+    return snapshots;
+  }
+  async walkAndHash(currentPath, rootPath, ignorePaths, snapshots) {
+    let stat4;
+    try {
+      stat4 = await fs6.stat(currentPath);
+    } catch {
+      return;
+    }
+    const normalized = currentPath.replace(/\\/g, "/");
+    const relativePath = path6.relative(rootPath, currentPath).replace(/\\/g, "/");
+    for (const pattern of ignorePaths) {
+      if (minimatch(relativePath, pattern, { dot: true }) || minimatch(path6.basename(currentPath), pattern, { dot: true })) {
+        return;
+      }
+    }
+    if (stat4.isFile()) {
+      const hash = await this.hashFile(currentPath);
+      snapshots.set(normalized, {
+        path: normalized,
+        hash,
+        size: stat4.size
+      });
+    } else if (stat4.isDirectory()) {
+      let entries;
+      try {
+        entries = await fs6.readdir(currentPath);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        await this.walkAndHash(
+          path6.join(currentPath, entry),
+          rootPath,
+          ignorePaths,
+          snapshots
+        );
+      }
+    }
+  }
+  async hashFile(filePath) {
+    const content = await fs6.readFile(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Compare pre and post snapshots to detect changes.
+   */
+  diffSnapshots(pre, post) {
+    const changes = [];
+    for (const [filePath, postSnap] of post) {
+      const preSnap = pre.get(filePath);
+      if (!preSnap) {
+        changes.push({ absolutePath: filePath, type: "created" /* Created */ });
+      } else if (preSnap.hash !== postSnap.hash) {
+        changes.push({ absolutePath: filePath, type: "modified" /* Modified */ });
+      }
+    }
+    for (const [filePath] of pre) {
+      if (!post.has(filePath)) {
+        changes.push({ absolutePath: filePath, type: "deleted" /* Deleted */ });
+      }
+    }
+    return changes;
+  }
+  /**
+   * Best-effort rename detection: if a file was deleted and a new file
+   * with identical content hash was created, treat as rename.
+   */
+  detectRenames(changes) {
+  }
+  /**
+   * Spawn the command and wait for exit.
+   * Uses shell execution to support piping, env expansion, etc.
+   */
+  executeCommand(command, cwd, options) {
+    return new Promise((resolve6, reject) => {
+      const isWindows = process.platform === "win32";
+      const shell = isWindows ? "cmd.exe" : "/bin/sh";
+      const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+      const child = spawn(shell, shellArgs, {
+        cwd,
+        env: { ...process.env, ...options.env },
+        stdio: [
+          options.stdin ?? "inherit",
+          options.stdout ?? "inherit",
+          options.stderr ?? "inherit"
+        ]
+      });
+      child.on("error", reject);
+      child.on("close", (code) => {
+        resolve6(code ?? 1);
+      });
+    });
+  }
+};
+
+// src/attribution/tier-selector.ts
+async function selectProvider(preferred = "auto") {
+  const providers = getOrderedProviders();
+  if (preferred !== "auto") {
+    const tierNum = parseInt(preferred.replace("tier", ""), 10);
+    const match = providers.find((p) => p.tier === tierNum);
+    if (match && await match.isAvailable()) return match;
+    throw new Error(
+      `Preferred attribution tier "${preferred}" is not available on this platform.`
+    );
+  }
+  for (const provider of providers) {
+    if (await provider.isAvailable()) {
+      return provider;
+    }
+  }
+  throw new Error("No attribution provider available.");
+}
+function getOrderedProviders() {
+  return [
+    // new Tier1WindowsProvider(),  // Phase 5+
+    // new Tier1LinuxProvider(),    // Phase 5+
+    // new Tier2LinuxProvider(),    // Phase 3
+    new Tier3HybridProvider()
+  ];
+}
+
+// src/classifier/classifier.ts
+import * as path7 from "path";
+var DEFAULT_RULES = [
+  // ── Containers & Orchestration ──
+  { pattern: /^docker\b/, type: "non-transactional", category: "container", reason: "Container orchestration \u2014 may modify container/image state" },
+  { pattern: /^docker-compose\b/, type: "non-transactional", category: "container", reason: "Container orchestration" },
+  { pattern: /^docker compose\b/, type: "non-transactional", category: "container", reason: "Container orchestration" },
+  { pattern: /^podman\b/, type: "non-transactional", category: "container", reason: "Container orchestration" },
+  { pattern: /^kubectl\b/, type: "non-transactional", category: "container", reason: "Kubernetes cluster management" },
+  { pattern: /^helm\b/, type: "non-transactional", category: "container", reason: "Helm chart management" },
+  // ── Databases ──
+  { pattern: /^(mysql|psql|mongosh?|redis-cli|sqlite3)\b/, type: "non-transactional", category: "database", reason: "Database client \u2014 may modify database state" },
+  { pattern: /^prisma\s+(migrate|db\s+push|db\s+seed)/, type: "non-transactional", category: "database", reason: "Database migration/seeding" },
+  { pattern: /^(knex|sequelize|typeorm)\s+migrate/, type: "non-transactional", category: "database", reason: "Database migration" },
+  // ── Services & Daemons ──
+  { pattern: /^(systemctl|service)\b/, type: "non-transactional", category: "service", reason: "System service management" },
+  { pattern: /^sc\s+(start|stop|config|create|delete)\b/, type: "non-transactional", category: "service", reason: "Windows service management" },
+  { pattern: /^(pm2|forever)\b/, type: "non-transactional", category: "service", reason: "Node.js process manager" },
+  // ── System Administration ──
+  { pattern: /^sudo\b/, type: "non-transactional", category: "system", reason: "Elevated system command" },
+  { pattern: /^(chmod|chown|chgrp)\b/, type: "non-transactional", category: "system", reason: "Permission/ownership change \u2014 not tracked by content hashing" },
+  { pattern: /^(mount|umount)\b/, type: "non-transactional", category: "system", reason: "Filesystem mount operation" },
+  { pattern: /^(apt|apt-get|yum|dnf|pacman|brew|choco|winget|scoop)\b/, type: "non-transactional", category: "system", reason: "System package manager \u2014 modifies system-level state" },
+  // ── Network ──
+  { pattern: /^(ssh|scp|rsync)\b/, type: "non-transactional", category: "network", reason: "Remote operation \u2014 effects not local" },
+  // ── Version Control (user's repo) ──
+  { pattern: /^git\b/, type: "non-transactional", category: "vcs", reason: "Git operation \u2014 may conflict with internal repository" },
+  { pattern: /^(svn|hg|bzr)\b/, type: "non-transactional", category: "vcs", reason: "Version control operation" }
+];
+var SCOPE_ESCAPE_PATTERNS = [
+  // Global npm/pnpm/yarn installs
+  { pattern: /\bnpm\s+install\s+.*-g\b/, reason: "Global npm install writes to system-level node_modules" },
+  { pattern: /\bnpm\s+install\s+.*--global\b/, reason: "Global npm install writes to system-level node_modules" },
+  { pattern: /\bpnpm\s+add\s+.*-g\b/, reason: "Global pnpm install writes outside workspace" },
+  { pattern: /\byarn\s+global\s+add\b/, reason: "Global yarn install writes outside workspace" },
+  // Commands that reference absolute paths outside cwd
+  { pattern: /\b(mkdir|touch|cp|mv|rm|rmdir)\s+\//, reason: "Command targets an absolute path (may be outside workspace)" },
+  { pattern: /\b(mkdir|touch|cp|mv|rm|rmdir)\s+[A-Z]:\\/, reason: "Command targets an absolute Windows path (may be outside workspace)" },
+  // pip / pipx global installs
+  { pattern: /\bpip\s+install\b(?!.*(-e|--editable)\s+\.)/, reason: "pip install may write to system site-packages" },
+  { pattern: /\bpipx\s+install\b/, reason: "pipx installs globally" },
+  // cargo global installs
+  { pattern: /\bcargo\s+install\b/, reason: "cargo install writes to ~/.cargo/bin" },
+  // go install
+  { pattern: /\bgo\s+install\b/, reason: "go install writes to $GOPATH/bin" }
+];
+function classifyCommand(command, scope = "workspace", projectRoot, extraRules = []) {
+  const trimmed = command.trim();
+  const allRules = [...extraRules, ...DEFAULT_RULES];
+  for (const rule of allRules) {
+    if (rule.pattern.test(trimmed)) {
+      return {
+        type: rule.type,
+        category: rule.category,
+        reason: rule.reason,
+        matchedRule: rule
+      };
+    }
+  }
+  if (scope === "workspace") {
+    for (const escape of SCOPE_ESCAPE_PATTERNS) {
+      if (escape.pattern.test(trimmed)) {
+        return {
+          type: "scope-external",
+          category: "scope",
+          reason: escape.reason,
+          scopeViolation: true,
+          scopeReason: escape.reason
+        };
+      }
+    }
+    if (projectRoot) {
+      const scopeViolation = detectPathEscape(trimmed, projectRoot);
+      if (scopeViolation) {
+        return {
+          type: "scope-external",
+          category: "scope",
+          reason: scopeViolation,
+          scopeViolation: true,
+          scopeReason: scopeViolation
+        };
+      }
+    }
+  }
+  return { type: "transactional" };
+}
+function detectPathEscape(command, projectRoot) {
+  const normalizedRoot = path7.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();
+      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();
+      if (!normalizedToken.startsWith(normalizedRoot)) {
+        return `Path "${cleaned}" is outside the workspace root (${projectRoot})`;
+      }
+    }
+  }
+  return null;
+}
+
+// src/core/transaction-engine.ts
+var TransactionEngine = class {
+  constructor(txStore, historyStore, fileMap, gitStore, config, projectRoot) {
+    this.txStore = txStore;
+    this.historyStore = historyStore;
+    this.fileMap = fileMap;
+    this.gitStore = gitStore;
+    this.config = config;
+    this.projectRoot = projectRoot;
+  }
+  txStore;
+  historyStore;
+  fileMap;
+  gitStore;
+  config;
+  projectRoot;
+  /**
+   * Execute a command with full transaction lifecycle.
+   *
+   * Returns null if the command produced zero tracked changes
+   * (a history entry is still recorded).
+   */
+  async execute(command, cwd, options) {
+    const startTime = Date.now();
+    const classification = options?.forceTransactional ? { type: "transactional" } : options?.forceNonTransactional ? { type: "non-transactional", reason: "User override" } : classifyCommand(command, this.config.scope, this.projectRoot);
+    if (classification.type === "non-transactional" || classification.type === "scope-external") {
+      const exitCode = await this.executeDirectly(command, cwd);
+      const durationMs2 = Date.now() - startTime;
+      this.historyStore.append({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        command,
+        transactionId: null,
+        workingDirectory: cwd,
+        exitCode,
+        classification: classification.type,
+        attributionTier: null,
+        durationMs: durationMs2
+      });
+      await this.historyStore.save();
+      return null;
+    }
+    const provider = await selectProvider(this.config.preferredTier);
+    const resolvedWatchPaths = this.config.watchPaths.map(
+      (p) => path8.isAbsolute(p) ? p : path8.resolve(cwd, p)
+    );
+    const result = await provider.executeAndTrack(command, cwd, {
+      watchPaths: resolvedWatchPaths,
+      ignorePaths: this.config.ignorePaths,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const scopeWarnings = [];
+    let trackedChanges;
+    if (this.config.scope === "workspace") {
+      const normalizedRoot = path8.resolve(this.projectRoot).replace(/\\/g, "/").toLowerCase();
+      trackedChanges = [];
+      for (const change of result.changes) {
+        const normalizedChange = change.absolutePath.replace(/\\/g, "/").toLowerCase();
+        if (normalizedChange.startsWith(normalizedRoot)) {
+          trackedChanges.push(change);
+        } else {
+          scopeWarnings.push(
+            `Out-of-scope change ignored: ${change.type} ${change.absolutePath}`
+          );
+        }
+      }
+      if (scopeWarnings.length > 0) {
+        scopeWarnings.unshift(
+          `${scopeWarnings.length} file change(s) outside workspace were NOT tracked. These changes cannot be undone. Run with 'txr init --global' for full tracking.`
+        );
+      }
+    } else {
+      trackedChanges = result.changes;
+    }
+    if (trackedChanges.length === 0) {
+      const durationMs2 = Date.now() - startTime;
+      this.historyStore.append({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        command,
+        transactionId: null,
+        workingDirectory: cwd,
+        exitCode: result.processExitCode,
+        classification: "transactional",
+        attributionTier: result.tier,
+        durationMs: durationMs2
+      });
+      await this.historyStore.save();
+      for (const w of scopeWarnings) {
+        process.stderr.write(`\x1B[33m\u26A0\x1B[0m ${w}
+`);
+      }
+      return null;
+    }
+    const txId = this.txStore.nextId();
+    const touchedFiles = [];
+    const changeManifest = {};
+    for (const change of trackedChanges) {
+      const fileId = this.resolveFileId(change, txId);
+      touchedFiles.push(fileId);
+      changeManifest[fileId] = this.mapChangeType(change.type);
+      if (change.type === "deleted" /* Deleted */) {
+        await this.gitStore.removeFile(fileId);
+      } else {
+        const content = await fs7.readFile(change.absolutePath);
+        await this.gitStore.writeFile(fileId, content);
+      }
+    }
+    const commitMessage = `txr: ${txId} | ${this.summarizeCommand(command)}`;
+    const commitHash = await this.gitStore.commit(commitMessage);
+    const tx = {
+      id: txId,
+      parent: this.txStore.head,
+      commit: commitHash,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      command,
+      touchedFiles,
+      changeManifest,
+      workingDirectory: cwd,
+      exitCode: result.processExitCode,
+      attributionTier: result.tier,
+      scope: this.config.scope,
+      scopeWarnings
+    };
+    this.txStore.addTransaction(tx);
+    await this.txStore.save();
+    await this.fileMap.save();
+    const durationMs = Date.now() - startTime;
+    this.historyStore.append({
+      timestamp: tx.timestamp,
+      command,
+      transactionId: txId,
+      workingDirectory: cwd,
+      exitCode: result.processExitCode,
+      classification: "transactional",
+      attributionTier: result.tier,
+      durationMs
+    });
+    await this.historyStore.save();
+    return {
+      transactionId: txId,
+      commit: commitHash,
+      changesCount: trackedChanges.length,
+      tier: result.tier,
+      durationMs,
+      scopeWarnings
+    };
+  }
+  /** Resolve a FileChange to a file ID (creating new IDs as needed). */
+  resolveFileId(change, txId) {
+    if (change.type === "renamed" /* Renamed */ && change.oldPath) {
+      const existingId = this.fileMap.getIdByPath(change.oldPath);
+      if (existingId) {
+        this.fileMap.updatePath(existingId, change.absolutePath);
+        return existingId;
+      }
+    }
+    if (change.type === "deleted" /* Deleted */) {
+      const existingId = this.fileMap.getIdByPath(change.absolutePath);
+      if (existingId) {
+        this.fileMap.markDeleted(existingId, txId);
+        return existingId;
+      }
+    }
+    return this.fileMap.getOrCreateId(change.absolutePath, txId);
+  }
+  /** Map FileChangeType to ChangeType for storage. */
+  mapChangeType(type) {
+    switch (type) {
+      case "created" /* Created */:
+        return "created";
+      case "modified" /* Modified */:
+        return "modified";
+      case "deleted" /* Deleted */:
+        return "deleted";
+      case "renamed" /* Renamed */:
+        return "modified";
+    }
+  }
+  /** Truncate command for commit message. */
+  summarizeCommand(command) {
+    return command.length > 72 ? command.substring(0, 69) + "..." : command;
+  }
+  /** Execute a command directly without tracking. */
+  executeDirectly(command, cwd) {
+    const { spawn: spawn2 } = __require("child_process");
+    return new Promise((resolve6, reject) => {
+      const isWindows = process.platform === "win32";
+      const shell = isWindows ? "cmd.exe" : "/bin/sh";
+      const shellArgs = isWindows ? ["/c", command] : ["-c", command];
+      const child = spawn2(shell, shellArgs, {
+        cwd,
+        stdio: "inherit"
+      });
+      child.on("error", reject);
+      child.on("close", (code) => resolve6(code ?? 1));
+    });
+  }
+};
+
+// src/cli/commands/run.ts
+async function runCommand(command, options) {
+  const cwd = process.cwd();
+  const projectRoot = await findTxrRoot(cwd);
+  const paths = getTxrPaths(projectRoot);
+  const config = await loadConfig(paths.metadataDir);
+  if (!options.transactional && !options.noTransaction) {
+    const classification = classifyCommand(command, config.scope, projectRoot);
+    if ((classification.type === "non-transactional" || classification.type === "scope-external") && config.confirmUnsafe && !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();
+        if (classification.type === "scope-external") {
+          console.log(`\x1B[33m\u26A0 SCOPE WARNING:\x1B[0m This command may modify files outside your workspace.`);
+        } else {
+          console.log(`\x1B[33m\u26A0 WARNING:\x1B[0m This command may modify state outside the transaction engine.`);
+        }
+        console.log(`  Category: ${classification.category}`);
+        console.log(`  Reason:   ${classification.reason}`);
+        console.log();
+        console.log("  Rollback guarantees cannot be provided.");
+        console.log();
+        rl.question("  Continue without tracking? [y/N] ", resolve6);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Aborted.");
+        process.exit(0);
+      }
+    }
+  }
+  const txStore = await TransactionStore.load(paths.metadataDir);
+  const historyStore = await HistoryStore.load(paths.metadataDir);
+  const fileMap = await FileMap.load(paths.metadataDir);
+  const gitStore = new GitStore(paths.repoDir);
+  const engine = new TransactionEngine(txStore, historyStore, fileMap, gitStore, config, projectRoot);
+  const result = await engine.execute(command, cwd, {
+    forceTransactional: options.transactional,
+    forceNonTransactional: options.noTransaction
+  });
+  if (result) {
+    console.log();
+    console.log(`\x1B[32m\u2713\x1B[0m Transaction \x1B[1m${result.transactionId}\x1B[0m committed`);
+    console.log(`  ${result.changesCount} file(s) changed | Tier ${result.tier} | ${result.durationMs}ms`);
+    if (result.scopeWarnings && result.scopeWarnings.length > 0) {
+      console.log();
+      for (const warning of result.scopeWarnings) {
+        console.log(`  \x1B[33m\u26A0\x1B[0m ${warning}`);
+      }
+    }
+  } else {
+    console.log();
+    console.log(`\x1B[90mCommand completed. No transaction created.\x1B[0m`);
+  }
+}
+
+// src/core/undo-engine.ts
+import * as fs8 from "fs/promises";
+import * as path9 from "path";
+import * as crypto2 from "crypto";
+var UndoConflictError = class extends Error {
+  conflicts;
+  constructor(message, conflicts = []) {
+    super(message);
+    this.name = "UndoConflictError";
+    this.conflicts = conflicts;
+  }
+};
+var UndoEngine = class {
+  constructor(txStore, fileMap, gitStore) {
+    this.txStore = txStore;
+    this.fileMap = fileMap;
+    this.gitStore = gitStore;
+  }
+  txStore;
+  fileMap;
+  gitStore;
+  /** Undo the current HEAD transaction. */
+  async undo() {
+    const headTx = this.txStore.getHead();
+    if (!headTx) throw new Error("Nothing to undo.");
+    const parentTx = headTx.parent ? this.txStore.get(headTx.parent) : void 0;
+    const conflicts = await this.validateForUndo(headTx);
+    if (conflicts.length > 0) {
+      throw new UndoConflictError(
+        `Cannot undo ${headTx.id}: ${conflicts.length} file(s) have been externally modified.
+
+` + conflicts.join("\n"),
+        conflicts
+      );
+    }
+    const ops = [];
+    for (const fileId of headTx.touchedFiles) {
+      const filePath = this.fileMap.getPath(fileId);
+      if (!filePath) continue;
+      const changeType = headTx.changeManifest[fileId];
+      switch (changeType) {
+        case "created":
+          ops.push({ type: "delete", path: filePath });
+          break;
+        case "modified": {
+          const prevContent = await this.gitStore.readBlob(parentTx.commit, fileId);
+          ops.push({ type: "write", path: filePath, content: prevContent });
+          break;
+        }
+        case "deleted": {
+          const restoredContent = await this.gitStore.readBlob(parentTx.commit, fileId);
+          ops.push({ type: "write", path: filePath, content: restoredContent });
+          break;
+        }
+      }
+    }
+    const writes = ops.filter((o) => o.type === "write");
+    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);
+      }
+    }
+    for (const op of deletes) {
+      if (op.type === "delete") {
+        try {
+          await fs8.unlink(op.path);
+        } catch {
+        }
+        await this.removeEmptyParents(op.path);
+      }
+    }
+    for (const fileId of headTx.touchedFiles) {
+      const changeType = headTx.changeManifest[fileId];
+      if (changeType === "created") {
+        this.fileMap.markDeleted(fileId, `undo:${headTx.id}`);
+      } else if (changeType === "deleted") {
+        this.fileMap.markRestored(fileId);
+      }
+    }
+    if (parentTx) {
+      await this.gitStore.resetHard(parentTx.commit);
+    } else {
+      await this.gitStore.resetToEmpty();
+    }
+    this.txStore.undoHead();
+    await this.txStore.save();
+    await this.fileMap.save();
+    return {
+      undone: headTx.id,
+      newHead: headTx.parent,
+      filesRestored: ops.length
+    };
+  }
+  /** Redo the most recently undone transaction. */
+  async redo() {
+    if (this.txStore.undoStack.length === 0) {
+      throw new Error("Nothing to redo.");
+    }
+    const redoTxId = this.txStore.undoStack[0];
+    const redoTx = this.txStore.get(redoTxId);
+    if (!redoTx) throw new Error(`Transaction "${redoTxId}" not found.`);
+    const parentTx = redoTx.parent ? this.txStore.get(redoTx.parent) : void 0;
+    const conflicts = await this.validateForRedo(redoTx, parentTx);
+    if (conflicts.length > 0) {
+      throw new UndoConflictError(
+        `Cannot redo ${redoTx.id}: filesystem state does not match expected pre-redo state.
+
+` + conflicts.join("\n"),
+        conflicts
+      );
+    }
+    let filesChanged = 0;
+    for (const fileId of redoTx.touchedFiles) {
+      const filePath = this.fileMap.getPath(fileId) ?? this.fileMap.getEntry(fileId)?.path;
+      if (!filePath) continue;
+      const changeType = redoTx.changeManifest[fileId];
+      switch (changeType) {
+        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);
+          filesChanged++;
+          break;
+        }
+        case "deleted": {
+          try {
+            await fs8.unlink(filePath);
+          } catch {
+          }
+          await this.removeEmptyParents(filePath);
+          filesChanged++;
+          break;
+        }
+      }
+    }
+    for (const fileId of redoTx.touchedFiles) {
+      const changeType = redoTx.changeManifest[fileId];
+      if (changeType === "created") {
+        this.fileMap.markRestored(fileId);
+      } else if (changeType === "deleted") {
+        this.fileMap.markDeleted(fileId, `redo:${redoTx.id}`);
+      }
+    }
+    await this.gitStore.resetHard(redoTx.commit);
+    this.txStore.redoNext();
+    await this.txStore.save();
+    await this.fileMap.save();
+    return {
+      redone: redoTx.id,
+      newHead: redoTx.id,
+      filesChanged
+    };
+  }
+  /**
+   * Validate all touched files for undo.
+   * Returns an array of human-readable conflict descriptions.
+   * Empty array = safe to proceed.
+   */
+  async validateForUndo(tx) {
+    const conflicts = [];
+    for (const fileId of tx.touchedFiles) {
+      const filePath = this.fileMap.getPath(fileId) ?? this.fileMap.getEntry(fileId)?.path;
+      if (!filePath) {
+        conflicts.push(`  \u2717 [${fileId}]: File ID has no path mapping.`);
+        continue;
+      }
+      const changeType = tx.changeManifest[fileId];
+      const existsOnDisk = await this.fileExists(filePath);
+      if (changeType === "deleted") {
+        if (existsOnDisk) {
+          conflicts.push(
+            `  \u2717 ${filePath}
+    Was deleted by ${tx.id} but now exists on disk.`
+          );
+        }
+        continue;
+      }
+      if (!existsOnDisk) {
+        conflicts.push(
+          `  \u2717 ${filePath}
+    Expected on disk but missing.`
+        );
+        continue;
+      }
+      const expectedContent = await this.gitStore.readBlob(tx.commit, fileId);
+      const actualContent = await fs8.readFile(filePath);
+      if (!this.hashEquals(expectedContent, actualContent)) {
+        const expectedHash = this.hash(expectedContent).substring(0, 12);
+        const actualHash = this.hash(actualContent).substring(0, 12);
+        conflicts.push(
+          `  \u2717 ${filePath}
+    Expected hash: ${expectedHash}...
+    Actual hash:   ${actualHash}...`
+        );
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Validate current state matches the parent of the redo transaction.
+   */
+  async validateForRedo(redoTx, parentTx) {
+    const conflicts = [];
+    for (const fileId of redoTx.touchedFiles) {
+      const filePath = this.fileMap.getPath(fileId) ?? this.fileMap.getEntry(fileId)?.path;
+      if (!filePath) continue;
+      const changeType = redoTx.changeManifest[fileId];
+      const existsOnDisk = await this.fileExists(filePath);
+      if (changeType === "created") {
+        if (existsOnDisk) {
+          conflicts.push(
+            `  \u2717 ${filePath}
+    Should not exist (it was created by ${redoTx.id}).`
+          );
+        }
+        continue;
+      }
+      if (!existsOnDisk) {
+        conflicts.push(
+          `  \u2717 ${filePath}
+    Expected on disk but missing.`
+        );
+        continue;
+      }
+      if (parentTx) {
+        try {
+          const expectedContent = await this.gitStore.readBlob(parentTx.commit, fileId);
+          const actualContent = await fs8.readFile(filePath);
+          if (!this.hashEquals(expectedContent, actualContent)) {
+            conflicts.push(
+              `  \u2717 ${filePath}
+    Current content does not match expected parent state.`
+            );
+          }
+        } catch {
+        }
+      }
+    }
+    return conflicts;
+  }
+  async fileExists(filePath) {
+    try {
+      await fs8.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  hash(content) {
+    return crypto2.createHash("sha256").update(content).digest("hex");
+  }
+  hashEquals(a, b) {
+    return this.hash(a) === this.hash(b);
+  }
+  /** Remove empty parent directories up to a reasonable depth. */
+  async removeEmptyParents(filePath) {
+    let dir = path9.dirname(filePath);
+    for (let i = 0; i < 10; i++) {
+      try {
+        const entries = await fs8.readdir(dir);
+        if (entries.length === 0) {
+          await fs8.rmdir(dir);
+          dir = path9.dirname(dir);
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+    }
+  }
+};
+
+// src/cli/commands/undo.ts
+async function undoCommand() {
+  const cwd = process.cwd();
+  const projectRoot = await findTxrRoot(cwd);
+  const paths = getTxrPaths(projectRoot);
+  const txStore = await TransactionStore.load(paths.metadataDir);
+  const fileMap = await FileMap.load(paths.metadataDir);
+  const gitStore = new GitStore(paths.repoDir);
+  const engine = new UndoEngine(txStore, fileMap, gitStore);
+  try {
+    const result = await engine.undo();
+    console.log();
+    console.log(`\x1B[32m\u2713\x1B[0m Undone: \x1B[1m${result.undone}\x1B[0m`);
+    console.log(`  ${result.filesRestored} file operation(s) applied`);
+    console.log(`  HEAD: ${result.newHead ?? "(empty)"}`);
+  } catch (err) {
+    if (err instanceof UndoConflictError) {
+      console.error();
+      console.error(`\x1B[31mERROR:\x1B[0m ${err.message}`);
+      console.error();
+      console.error("Undo aborted. No files were changed.");
+      console.error();
+      console.error("To resolve: manually revert the conflicting files, then retry `txr undo`.");
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+async function redoCommand() {
+  const cwd = process.cwd();
+  const projectRoot = await findTxrRoot(cwd);
+  const paths = getTxrPaths(projectRoot);
+  const txStore = await TransactionStore.load(paths.metadataDir);
+  const fileMap = await FileMap.load(paths.metadataDir);
+  const gitStore = new GitStore(paths.repoDir);
+  const engine = new UndoEngine(txStore, fileMap, gitStore);
+  try {
+    const result = await engine.redo();
+    console.log();
+    console.log(`\x1B[32m\u2713\x1B[0m Redone: \x1B[1m${result.redone}\x1B[0m`);
+    console.log(`  ${result.filesChanged} file(s) changed`);
+    console.log(`  HEAD: ${result.newHead}`);
+  } catch (err) {
+    if (err instanceof UndoConflictError) {
+      console.error();
+      console.error(`\x1B[31mERROR:\x1B[0m ${err.message}`);
+      console.error();
+      console.error("Redo aborted. No files were changed.");
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+// src/cli/commands/status.ts
+async function statusCommand() {
+  const cwd = process.cwd();
+  const projectRoot = await findTxrRoot(cwd);
+  const paths = getTxrPaths(projectRoot);
+  const config = await loadConfig(paths.metadataDir);
+  const txStore = await TransactionStore.load(paths.metadataDir);
+  const provider = await selectProvider(config.preferredTier);
+  const head = txStore.getHead();
+  console.log();
+  console.log(`\x1B[1mtxr status\x1B[0m`);
+  console.log(`  Root:          ${projectRoot}`);
+  console.log(`  Attribution:   ${provider.name}`);
+  console.log(`  HEAD:          ${head ? `${head.id} (${head.command})` : "(empty)"}`);
+  console.log(`  Chain length:  ${txStore.chainLength}`);
+  console.log(`  Redo stack:    ${txStore.undoStack.length} transaction(s)`);
+  console.log(`  Watch paths:   ${config.watchPaths.join(", ")}`);
+}
+async function historyCommand(count = 20) {
+  const cwd = process.cwd();
+  const projectRoot = await findTxrRoot(cwd);
+  const paths = getTxrPaths(projectRoot);
+  const historyStore = await HistoryStore.load(paths.metadataDir);
+  const entries = historyStore.getRecent(count);
+  if (entries.length === 0) {
+    console.log("\nNo command history yet.");
+    return;
+  }
+  console.log();
+  console.log(`\x1B[1mCommand History\x1B[0m (${entries.length} most recent)
+`);
+  for (const entry of entries) {
+    const txLabel = entry.transactionId ? `\x1B[32m${entry.transactionId}\x1B[0m` : "\x1B[90mno-tx\x1B[0m";
+    const tierLabel = entry.attributionTier ? `T${entry.attributionTier}` : "  ";
+    const timeStr = new Date(entry.timestamp).toLocaleTimeString();
+    console.log(`  ${timeStr}  ${tierLabel}  ${txLabel}  ${entry.command}`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("txr").description("Transactional command runner \u2014 undo any shell command").version("0.1.0");
+program.command("init").description("Initialize txr in the current directory").option("-g, --global", "Enable global tracking mode (track files outside workspace)").action(async (opts) => {
+  try {
+    const scope = opts.global ? "global" : "workspace";
+    await initTxr(process.cwd(), { scope });
+    const provider = await selectProvider("auto");
+    console.log();
+    console.log("\x1B[32m\u2713\x1B[0m Initialized txr");
+    console.log(`  Directory: .txr/`);
+    console.log(`  Scope: ${scope}`);
+    console.log(`  Attribution: ${provider.name}`);
+    console.log();
+    console.log('Run commands with: \x1B[1mtxr run "<command>"\x1B[0m');
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("run").description("Execute a command with transactional tracking").argument("<command>", "The shell command to execute").option("-y, --yes", "Skip confirmation for non-transactional commands").option("--transactional", "Force transactional execution").option("--no-transaction", "Force non-transactional execution").action(async (command, opts) => {
+  try {
+    await runCommand(command, {
+      yes: opts.yes,
+      transactional: opts.transactional,
+      noTransaction: opts.noTransaction
+    });
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("undo").description("Undo the most recent transaction").action(async () => {
+  try {
+    await undoCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("redo").description("Redo the most recently undone transaction").action(async () => {
+  try {
+    await redoCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("status").description("Show current transaction state").action(async () => {
+  try {
+    await statusCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("history").description("Show command history").option("-n, --count <number>", "Number of entries to show", "20").action(async (opts) => {
+  try {
+    await historyCommand(parseInt(opts.count, 10));
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err.message}`);
+    process.exit(1);
+  }
+});
+program.parse();