@amoghvj/txr 0.1.1 → 0.2.0

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-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+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');
+});
+
+export {
+  __require
+};

package/dist/chunk-6SSBMHMQ.js

@@ -0,0 +1,185 @@
+// src/core/external-detector.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as crypto from "crypto";
+import { nanoid } from "nanoid";
+var ExternalChangeDetector = class {
+  constructor(txStore, fileMap, gitStore, config, projectRoot) {
+    this.txStore = txStore;
+    this.fileMap = fileMap;
+    this.gitStore = gitStore;
+    this.config = config;
+    this.projectRoot = projectRoot;
+  }
+  txStore;
+  fileMap;
+  gitStore;
+  config;
+  projectRoot;
+  async detectAndRecord() {
+    return this.detectAndRecordWithSource("external");
+  }
+  async detectAndRecordWithSource(source) {
+    const headTx = this.txStore.getHead();
+    if (!headTx) return null;
+    const divergences = await this.findDivergences(headTx);
+    if (divergences.length === 0) return null;
+    for (const div of divergences) {
+      if (div.type === "created" || div.type === "modified") {
+        try {
+          const content = await fs.readFile(div.absolutePath);
+          await this.gitStore.writeFile(div.fileId, content);
+        } catch {
+          await this.gitStore.removeFile(div.fileId).catch(() => {
+          });
+        }
+      } else if (div.type === "deleted") {
+        await this.gitStore.removeFile(div.fileId).catch(() => {
+        });
+      }
+    }
+    const isExternal = source === "external";
+    const txId = isExternal ? this.txStore.nextExtId() : this.txStore.nextId();
+    const actionType = isExternal ? "E" : "U";
+    const commitMsg = isExternal ? `txr: ${txId} | [external change \u2014 ${divergences.length} file(s)]` : `txr: ${txId} | passive: ${source}`;
+    const commitHash = await this.gitStore.commit(commitMsg);
+    const changeManifest = {};
+    for (const div of divergences) {
+      changeManifest[div.fileId] = div.type;
+    }
+    const tx = {
+      id: txId,
+      type: actionType,
+      parent: headTx.id,
+      commit: commitHash,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      command: isExternal ? null : source,
+      source,
+      touchedFiles: divergences.map((d) => d.fileId),
+      changeManifest,
+      workingDirectory: this.projectRoot,
+      exitCode: isExternal ? null : 0,
+      attributionTier: null,
+      scope: this.config.scope,
+      scopeWarnings: []
+    };
+    for (const div of divergences) {
+      if (div.type === "deleted") {
+        const entry = this.fileMap.getEntry(div.fileId);
+        if (entry && !entry.deletedAt) {
+          this.fileMap.markDeleted(div.fileId, txId);
+        }
+      } else if (div.type === "created") {
+        this.fileMap.registerNewFile(div.absolutePath, div.fileId, txId);
+      }
+    }
+    if (isExternal) {
+      this.txStore.addExternalTransaction(tx);
+    } else {
+      const discarded = this.txStore.addTransaction(tx);
+      if (discarded.length > 0) {
+        this.fileMap.untrackByTransactions(discarded);
+      }
+    }
+    await this.txStore.save();
+    await this.fileMap.save();
+    const { HistoryStore } = await import("./history-store-2H73O75H.js");
+    const historyStore = await HistoryStore.load(path.join(this.projectRoot, ".txr", "metadata"));
+    historyStore.append({
+      timestamp: tx.timestamp,
+      command: isExternal ? null : source,
+      transactionId: txId,
+      workingDirectory: this.projectRoot,
+      exitCode: isExternal ? null : 0,
+      classification: isExternal ? "external" : "transactional",
+      attributionTier: null,
+      durationMs: 0,
+      actionType
+    });
+    await historyStore.save();
+    if (isExternal) {
+      process.stderr.write(
+        `\x1B[33m\u26A0 External changes detected.\x1B[0m ${divergences.length} file(s) modified outside TXR since ${headTx.id}.
+  Recorded as \x1B[1m${txId}\x1B[0m. Run \x1B[1mtxr history\x1B[0m to review.
+`
+      );
+    }
+    return tx;
+  }
+  /**
+   * Find all filesystem divergences since the HEAD transaction's commit.
+   *
+   * Strategy:
+   * 1. For each file tracked in HEAD's commit tree → compare blob hash to disk hash.
+   * 2. Scan watch paths for new files not yet in FileMap.
+   */
+  async findDivergences(headTx) {
+    const divergences = [];
+    const activeFiles = this.fileMap.getActiveFiles();
+    for (const { id: fileId, entry } of activeFiles) {
+      const absolutePath = entry.path;
+      const existsInCommit = await this.gitStore.fileExistsAtCommit(headTx.commit, fileId);
+      if (!existsInCommit) continue;
+      let existsOnDisk = false;
+      let diskHash = null;
+      try {
+        const content = await fs.readFile(absolutePath);
+        existsOnDisk = true;
+        diskHash = this.hash(content);
+      } catch {
+        existsOnDisk = false;
+      }
+      if (!existsOnDisk) {
+        divergences.push({ fileId, absolutePath, type: "deleted" });
+        continue;
+      }
+      try {
+        const blobContent = await this.gitStore.readBlob(headTx.commit, fileId);
+        const blobHash = this.hash(blobContent);
+        if (diskHash !== blobHash) {
+          divergences.push({ fileId, absolutePath, type: "modified" });
+        }
+      } catch {
+        divergences.push({ fileId, absolutePath, type: "modified" });
+      }
+    }
+    try {
+      const { glob } = await import("glob");
+      const allFiles = await glob("**/*", {
+        cwd: this.projectRoot,
+        nodir: true,
+        absolute: true,
+        ignore: [
+          ".git/**",
+          ".txr/**",
+          "node_modules/**",
+          "__pycache__/**",
+          ".venv/**",
+          "venv/**",
+          "dist/**",
+          "build/**"
+        ]
+      });
+      for (const absolutePath of allFiles) {
+        if (!this.fileMap.getIdByPath(absolutePath)) {
+          const tempFileId = nanoid();
+          divergences.push({
+            fileId: tempFileId,
+            absolutePath,
+            type: "created"
+          });
+        }
+      }
+    } catch (err) {
+      console.error("Error scanning for new files:", err);
+    }
+    return divergences;
+  }
+  hash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+};
+
+export {
+  ExternalChangeDetector
+};

package/dist/chunk-KXCWVEEG.js

@@ -0,0 +1,47 @@
+// src/core/history-store.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var HistoryStore = class _HistoryStore {
+  data;
+  filePath;
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  static async load(metadataDir) {
+    const filePath = path.join(metadataDir, "history.json");
+    try {
+      const raw = await fs.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 fs.writeFile(tmp, JSON.stringify(this.data, null, 2), "utf-8");
+    await fs.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;
+  }
+};
+
+export {
+  HistoryStore
+};

package/dist/{chunk-XKFFIQXW.js → chunk-MCJNEIJH.js}

@@ -1,10 +1,3 @@
-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";
@@ -181,6 +174,5 @@ var GitStore = class {
 };
 
 export {
-  __require,
   GitStore
 };

package/dist/external-detector-5TT634UP.js

@@ -0,0 +1,7 @@
+import {
+  ExternalChangeDetector
+} from "./chunk-6SSBMHMQ.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  ExternalChangeDetector
+};

package/dist/git-store-MUETZYUT.js

@@ -0,0 +1,7 @@
+import {
+  GitStore
+} from "./chunk-MCJNEIJH.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  GitStore
+};

package/dist/history-store-2H73O75H.js

@@ -0,0 +1,7 @@
+import {
+  HistoryStore
+} from "./chunk-KXCWVEEG.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  HistoryStore
+};