rewindex 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zenonix Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,101 @@
-# Temporary Holding Version
+# rewindex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+File-level rewind for OpenAI Codex CLI, including projects that do not use Git.
+
+Codex can rewind a conversation, but that does not restore files already written to disk. `rewindex` takes automatic snapshots in an isolated shadow Git repository and lets you return the working tree to the state before an earlier prompt.
+
+It never reads or modifies your project's own Git repository.
+
+## Install
+
+```sh
+npm install --global rewindex
+rewindex install
+```
+
+Open Codex in an unimportant folder, run `/hooks`, and trust the two `rewindex` hooks. Codex requires this explicit review before third-party hooks can run.
+
+## Use inside Codex
+
+```text
+$rewindex list
+$rewindex diff 3
+$rewindex restore 3
+$rewindex undo
+```
+
+`list` shows the newest 50 prompt checkpoints:
+
+```text
+1. dcdf6bb9f1                                          3 dk önce
+                                1 değişen · 0 eklenen · 0 silinen
+   Prompt: README dosyasını yeni kurulum adımlarıyla güncelle.
+   Özet: README.md önceki haline döner.
+```
+
+The visible number is a convenient selector for the current list. The hash is a stable selector that remains valid if newer prompts change the numbering.
+
+Restore always shows a diff first and asks for confirmation. Before changing files, it takes a safety snapshot; `$rewindex undo` restores that pre-restore state.
+
+## Direct CLI
+
+The same operations are available outside Codex:
+
+```sh
+rewindex list
+rewindex diff 3
+rewindex restore 3
+rewindex restore --undo
+rewindex gc
+```
+
+Add `-C <directory>` to target another project and `-y` to skip restore confirmation in scripts.
+
+## How it works
+
+1. `UserPromptSubmit` records the state before each prompt.
+2. `PreToolUse` provides extra safety checkpoints before shell and file tools.
+3. Snapshots are stored in `~/.rewindex/<project-hash>/`, with `GIT_DIR` isolated from the project.
+4. Prompt history is presented as cumulative rewind points: restoring item 4 undoes that prompt and every newer file change.
+
+Tracked, untracked, and Git-ignored files are captured by default. Common build directories and files larger than 16 MiB are excluded.
+
+## Configuration
+
+Optional `~/.rewindex/config.json`:
+
+```json
+{
+  "exclude": [".git", "node_modules", "dist", "build"],
+  "maxFileBytes": 16777216,
+  "retentionDays": 7,
+  "retentionBytes": 524288000,
+  "captureIgnored": true
+}
+```
+
+## Security
+
+Because Git-ignored files are captured by default, local snapshots may contain `.env` files, credentials, or other secrets. They remain unencrypted on the same machine under `~/.rewindex/` and are never added to the project repository.
+
+Set `"captureIgnored": false` or add sensitive paths to `exclude` when local secret snapshots are not acceptable.
+
+## Limits
+
+- Rewinds files, not the Codex conversation. Use Codex's conversation controls separately.
+- Cannot undo external effects such as database writes, network calls, or files changed outside the project.
+- Does not currently support Windows.
+- Cannot observe tools that bypass Codex hooks.
+
+## Uninstall
+
+```sh
+rewindex uninstall
+npm uninstall --global rewindex
+```
+
+`rewindex uninstall` removes only hook entries owned by rewindex.
+
+## License
+
+[MIT](LICENSE) © 2026 Zenonix Studio

package/dist/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hook_1 = require("./hook");
+const commands_1 = require("./commands");
+const install_1 = require("./install");
+const VERSION = "0.1.0";
+function usage() {
+    console.log(`rewindex ${VERSION} — git-free /undo for OpenAI Codex CLI
+
+Usage:
+  rewindex install            Add snapshot hooks and the $rewindex Codex skill
+  rewindex uninstall          Remove rewindex hooks and skill (leaves yours alone)
+  rewindex list               List snapshots (grouped by turn, with prompt + files changed)
+  rewindex diff <number|id>   Show what restoring that prompt would change
+  rewindex restore <number|id> Restore that prompt baseline (preview + confirm)
+  rewindex restore --undo     Undo the last restore (via its safety snapshot)
+  rewindex gc                 Prune old snapshots (default: 7 days / 500 MB)
+  rewindex hook               (internal) read a hook payload on stdin and snapshot
+
+Inside Codex after install:
+  $rewindex list
+  $rewindex diff <number|id>
+  $rewindex restore <number|id>
+  $rewindex undo
+
+Options:
+  -y, --yes                   Skip the restore confirmation prompt
+  -C, --cwd <dir>             Operate on <dir> instead of the current directory
+  -h, --help                  Show this help
+  -v, --version               Show version
+`);
+}
+function parse(argv) {
+    const out = {
+        positionals: [],
+        yes: false,
+        undo: false,
+        cwd: process.cwd(),
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-y" || a === "--yes")
+            out.yes = true;
+        else if (a === "--undo")
+            out.undo = true;
+        else if (a === "-C" || a === "--cwd")
+            out.cwd = argv[++i] ?? out.cwd;
+        else if (!out.cmd && !a.startsWith("-"))
+            out.cmd = a;
+        else if (!a.startsWith("-"))
+            out.positionals.push(a);
+        else
+            out.positionals.push(a); // keep unknown flags as positionals for help
+    }
+    return out;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("-h") || argv.includes("--help") || argv.length === 0) {
+        usage();
+        return 0;
+    }
+    if (argv.includes("-v") || argv.includes("--version")) {
+        console.log(VERSION);
+        return 0;
+    }
+    const args = parse(argv);
+    switch (args.cmd) {
+        case "hook":
+            return (0, hook_1.hookCommand)();
+        case "install":
+            return (0, install_1.installCommand)();
+        case "uninstall":
+            return (0, install_1.uninstallCommand)();
+        case "list":
+        case "ls":
+            return (0, commands_1.listCommand)(args.cwd);
+        case "diff":
+            return (0, commands_1.diffCommand)(args.cwd, args.positionals[0]);
+        case "restore":
+            return (0, commands_1.restoreCommand)(args.cwd, args.positionals[0], {
+                yes: args.yes,
+                undo: args.undo,
+            });
+        case "gc":
+            return (0, commands_1.gcCommand)(args.cwd);
+        default:
+            console.error(`Unknown command: ${args.cmd}\n`);
+            usage();
+            return 1;
+    }
+}
+main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    console.error(`rewindex: ${err?.message ?? err}`);
+    process.exit(1);
+});

package/dist/commands.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = listCommand;
+exports.diffCommand = diffCommand;
+exports.restoreCommand = restoreCommand;
+exports.gcCommand = gcCommand;
+const readline = __importStar(require("readline"));
+const paths_1 = require("./paths");
+const config_1 = require("./config");
+const git_1 = require("./git");
+const snapshot_1 = require("./snapshot");
+const state_1 = require("./state");
+const gc_1 = require("./gc");
+function git(projectRoot) {
+    return new git_1.ShadowGit((0, paths_1.storeFor)(projectRoot), (0, config_1.loadConfig)());
+}
+function relativeTime(ms) {
+    const diff = Date.now() - ms;
+    const s = Math.round(diff / 1000);
+    if (s < 60)
+        return `${s} sn önce`;
+    const m = Math.round(s / 60);
+    if (m < 60)
+        return `${m} dk önce`;
+    const h = Math.round(m / 60);
+    if (h < 48)
+        return `${h} sa önce`;
+    return `${Math.round(h / 24)} gün önce`;
+}
+const OUTPUT_WIDTH = 88;
+async function listCommand(projectRoot) {
+    const g = git(projectRoot);
+    const checkpoints = await (0, snapshot_1.listPromptCheckpoints)(g);
+    if (checkpoints.length === 0) {
+        console.log("Henüz geri alınabilecek bir prompt değişikliği yok.");
+        return 0;
+    }
+    console.log("Son 50 değişiklik\n");
+    for (const [index, checkpoint] of checkpoints.entries()) {
+        const groups = changeGroups(checkpoint);
+        console.log(alignRight(`${index + 1}. ${checkpoint.id}`, relativeTime(checkpoint.unixTime)));
+        console.log(alignRight("", `${groups.changed.length} değişen · ${groups.added.length} eklenen · ${groups.deleted.length} silinen`));
+        printWrapped("   Prompt: ", checkpoint.meta.prompt || checkpoint.label, 2);
+        printWrapped("   Özet: ", summary(groups));
+        if (index + 1 < checkpoints.length)
+            console.log("");
+    }
+    return 0;
+}
+function changeGroups(checkpoint) {
+    return {
+        added: checkpoint.changes.filter((change) => change.status === "A").map((change) => change.path),
+        deleted: checkpoint.changes.filter((change) => change.status === "D").map((change) => change.path),
+        changed: checkpoint.changes.filter((change) => !["A", "D"].includes(change.status)).map((change) => change.path),
+    };
+}
+function summary(groups) {
+    const parts = [];
+    if (groups.changed.length)
+        parts.push(`${pathList(groups.changed)} önceki haline döner`);
+    if (groups.added.length)
+        parts.push(`${pathList(groups.added)} kaldırılır`);
+    if (groups.deleted.length)
+        parts.push(`${pathList(groups.deleted)} yeniden oluşturulur`);
+    return `${parts.join("; ")}.`;
+}
+function pathList(paths) {
+    const shown = paths.slice(0, 3);
+    const names = shown.length === 1
+        ? shown[0]
+        : `${shown.slice(0, -1).join(", ")} ve ${shown.at(-1)}`;
+    return paths.length > shown.length ? `${names} ve ${paths.length - shown.length} dosya daha` : names;
+}
+function alignRight(left, right) {
+    return `${left}${" ".repeat(Math.max(1, OUTPUT_WIDTH - left.length - right.length))}${right}`;
+}
+function printWrapped(prefix, text, maxLines = Number.POSITIVE_INFINITY) {
+    const lines = wrap(text, OUTPUT_WIDTH - prefix.length, maxLines);
+    for (const [index, line] of lines.entries()) {
+        console.log(`${index === 0 ? prefix : " ".repeat(prefix.length)}${line}`);
+    }
+}
+function wrap(text, width, maxLines) {
+    let remaining = text.replace(/\s+/g, " ").trim();
+    const lines = [];
+    while (remaining && lines.length < maxLines) {
+        if (remaining.length <= width) {
+            lines.push(remaining);
+            remaining = "";
+            break;
+        }
+        const space = remaining.lastIndexOf(" ", width);
+        const cut = space > 0 ? space : width;
+        lines.push(remaining.slice(0, cut));
+        remaining = remaining.slice(cut).trim();
+    }
+    if (remaining)
+        lines[lines.length - 1] = `${lines.at(-1).slice(0, width - 1)}…`;
+    return lines;
+}
+async function diffCommand(projectRoot, id) {
+    const g = git(projectRoot);
+    const c = await (0, snapshot_1.resolveCheckpoint)(g, id);
+    if (!c) {
+        console.error(`No snapshot matching "${id}". Try \`rewindex list\`.`);
+        return 1;
+    }
+    const r = await g.run(["diff", c.fullId, "--"]);
+    if (!r.stdout.trim()) {
+        console.log(`Snapshot ${c.id} matches the working tree for its files (nothing to restore).`);
+        return 0;
+    }
+    process.stdout.write(r.stdout);
+    return 0;
+}
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => rl.question(question, resolve));
+    rl.close();
+    return /^y(es)?$/i.test(answer.trim());
+}
+async function restoreCommand(projectRoot, id, opts) {
+    const store = (0, paths_1.storeFor)(projectRoot);
+    const g = new git_1.ShadowGit(store, (0, config_1.loadConfig)());
+    await g.snapshot((0, snapshot_1.buildMessage)("before rewindex restore", { event: "manual" }));
+    let target;
+    if (opts.undo) {
+        const st = (0, state_1.readState)(store);
+        if (!st.lastSafetySnapshot) {
+            console.error("Nothing to undo: no restore has run yet in this project.");
+            return 1;
+        }
+        target = st.lastSafetySnapshot;
+    }
+    else {
+        if (!id) {
+            console.error("Usage: rewindex restore <id>   (or --undo)");
+            return 1;
+        }
+        target = await (0, snapshot_1.resolveCheckpoint)(g, id);
+        if (!target) {
+            console.error(`No snapshot matching "${id}". Try \`rewindex list\`.`);
+            return 1;
+        }
+    }
+    const targetRef = typeof target === "string" ? target : target.fullId;
+    const changes = await g.changesSince(targetRef);
+    const changed = changes.map((change) => change.path);
+    if (changed.length === 0) {
+        console.log("Working tree already matches that snapshot. Nothing to do.");
+        return 0;
+    }
+    const label = typeof target === "string" ? "safety snapshot" : target.label;
+    console.log(`Restore ${typeof target === "string" ? target.slice(0, 10) : target.id}  "${label}"`);
+    console.log(`This will change ${changed.length} file(s) in ${projectRoot}:`);
+    for (const f of changed)
+        console.log(`  ~ ${f}`);
+    if (changed.length > 0) {
+        console.log(`\n  note: ${changed.length} file(s) differ from the snapshot; ` +
+            `those edits will be replaced. A safety snapshot is taken first — ` +
+            `run \`rewindex restore --undo\` to get them back.`);
+    }
+    if (!opts.yes) {
+        const ok = await confirm("\nProceed? [y/N] ");
+        if (!ok) {
+            console.log("Aborted.");
+            return 1;
+        }
+    }
+    // Safety snapshot of the CURRENT state so the restore is reversible.
+    const safety = (await g.snapshot((0, snapshot_1.buildMessage)("pre-restore safety snapshot", { event: "pre-restore" }))) ?? await g.revParse("HEAD");
+    (0, state_1.writeState)(store, {
+        lastSafetySnapshot: safety,
+        lastRestoredTo: targetRef,
+    });
+    await g.deletePaths(changes.filter((change) => change.status === "A").map((change) => change.path));
+    await g.checkoutPaths(targetRef, changes.filter((change) => change.status !== "A").map((change) => change.path));
+    console.log(`\nRestored ${changed.length} file(s).`);
+    if (!opts.undo) {
+        console.log(`Undo with: rewindex restore --undo`);
+    }
+    console.log(`Tip: to also rewind the conversation, press Esc-Esc in Codex — rewindex only touches files.`);
+    return 0;
+}
+async function gcCommand(projectRoot) {
+    const store = (0, paths_1.storeFor)(projectRoot);
+    const config = (0, config_1.loadConfig)();
+    const result = await (0, gc_1.gcStore)(store, config);
+    console.log(`GC: dropped ${result.dropped} snapshot(s), kept ${result.kept}. ` +
+        `Store now ~${(result.bytesAfter / (1024 * 1024)).toFixed(1)} MB.`);
+    return 0;
+}

package/dist/config.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("./paths");
+exports.DEFAULT_CONFIG = {
+    exclude: [
+        ".git",
+        "node_modules",
+        ".rewindex",
+        ".DS_Store",
+        // common heavy build/output dirs
+        "dist",
+        "build",
+        ".next",
+        ".venv",
+        "target",
+        "__pycache__",
+    ],
+    maxFileBytes: 16 * 1024 * 1024,
+    retentionDays: 7,
+    retentionBytes: 500 * 1024 * 1024,
+    captureIgnored: true,
+};
+/**
+ * Config is read from ~/.rewindex/config.json if present, else defaults.
+ * ponytail: single global config file, no per-project override and no schema
+ * validation. Ceiling: fine for v1 (one user, one machine). Upgrade path: layer
+ * a project-local .rewindex.json and validate with a tiny schema check.
+ */
+function loadConfig() {
+    const file = path.join((0, paths_1.rewindexHome)(), "config.json");
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        return { ...exports.DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...exports.DEFAULT_CONFIG };
+    }
+}

package/dist/gc.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gcStore = gcStore;
+const child_process_1 = require("child_process");
+const git_1 = require("./git");
+/**
+ * Retention GC. Snapshots live as a commit chain on the `rewindex` branch; to
+ * drop old ones we REBUILD the chain from the survivors' trees with `commit-tree`
+ * (preserving each message + author date), then expire reflogs and `git gc` so
+ * the dropped objects are actually reclaimed.
+ *
+ * ponytail: O(n) history rewrite on every gc run. Ceiling: fine at hundreds of
+ * snapshots. Upgrade path: a generational/packfile strategy, or only rewrite
+ * when the drop count crosses a threshold.
+ */
+async function gcStore(store, config) {
+    const git = new git_1.ShadowGit(store, config);
+    if (!(await git.isInitialized())) {
+        return { dropped: 0, kept: 0, bytesAfter: 0 };
+    }
+    const commits = await readCommits(git);
+    if (commits.length === 0) {
+        return { dropped: 0, kept: 0, bytesAfter: dirBytes(store.gitDir) };
+    }
+    const cutoffSec = Date.now() / 1000 - config.retentionDays * 86400;
+    // Keep the empty root (anchor) plus any snapshot newer than the cutoff.
+    // Oldest -> newest order for rebuilding.
+    const chronological = [...commits].reverse();
+    const survivors = chronological.filter((c) => c.isRoot || c.time >= cutoffSec);
+    // Size cap: if still over budget, drop oldest snapshots (never the root) until
+    // under budget or only the root + newest remain.
+    let bytes = dirBytes(store.gitDir);
+    if (bytes > config.retentionBytes) {
+        // survivors is oldest->newest; peel from the front (after the root).
+        const root = survivors.filter((c) => c.isRoot);
+        let snaps = survivors.filter((c) => !c.isRoot);
+        while (bytes > config.retentionBytes && snaps.length > 1) {
+            snaps = snaps.slice(1);
+            // Rough proportional estimate; real bytes recomputed after rewrite.
+            bytes = bytes * (snaps.length / (snaps.length + 1));
+        }
+        survivors.length = 0;
+        survivors.push(...root, ...snaps);
+    }
+    const droppedCount = commits.length - survivors.length;
+    if (droppedCount === 0) {
+        return { dropped: 0, kept: commits.length, bytesAfter: dirBytes(store.gitDir) };
+    }
+    // Rebuild the chain from survivor trees.
+    let parent = null;
+    for (const c of survivors) {
+        const args = ["commit-tree", c.tree];
+        if (parent)
+            args.push("-p", parent);
+        args.push("-m", c.message);
+        const env = {
+            GIT_AUTHOR_DATE: `${c.time} +0000`,
+            GIT_COMMITTER_DATE: `${c.time} +0000`,
+        };
+        parent = (await git.runOk(args, env)).trim();
+    }
+    if (parent) {
+        await git.runOk(["update-ref", "refs/heads/rewindex", parent]);
+    }
+    // Reclaim space.
+    await git.run(["reflog", "expire", "--all", "--expire=now"]);
+    await git.run(["gc", "--prune=now", "--quiet"]);
+    return {
+        dropped: droppedCount,
+        kept: survivors.length,
+        bytesAfter: dirBytes(store.gitDir),
+    };
+}
+async function readCommits(git) {
+    const SEP = "\x1e";
+    const REC = "\x1f";
+    const fmt = `%H${SEP}%T${SEP}%ct${SEP}%B${REC}`;
+    const out = (await git.run(["log", `--pretty=format:${fmt}`])).stdout;
+    const records = out.split(REC).map((r) => r.trim()).filter(Boolean);
+    // newest-first (git log default)
+    return records.map((rec) => {
+        const [sha, tree, ct, message = ""] = rec.split(SEP);
+        const isRoot = /rewindex-event: root/.test(message);
+        return { sha, tree, time: Number(ct), message: message.trim(), isRoot };
+    });
+}
+/** Disk usage of the shadow git dir in bytes (best-effort). */
+function dirBytes(dir) {
+    try {
+        const out = (0, child_process_1.execSync)(`du -sk "${dir}"`, { encoding: "utf8" });
+        const kb = parseInt(out.trim().split(/\s+/)[0], 10);
+        return kb * 1024;
+    }
+    catch {
+        return 0;
+    }
+}