rewindex 0.0.0-stage → 0.1.0

package/dist/git.js

@@ -0,0 +1,275 @@
+"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.ShadowGit = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Thin wrapper over the system `git`, run against an ISOLATED shadow repo:
+ *  - GIT_DIR points at our per-project store, GIT_WORK_TREE at the project root,
+ *    so the project's own .git is never read or written.
+ *  - GIT_CONFIG_GLOBAL/SYSTEM are forced to /dev/null so the user's git config,
+ *    hooks, and signing settings can't leak in or fire.
+ *  - identity is fixed, LANG=C for stable parsing, and mutating commands pass
+ *    --no-verify so no hooks run.
+ *
+ * ponytail: ~130-line hand wrapper instead of simple-git. Ceiling: covers the
+ * handful of plumbing commands we need. Upgrade path: if the command surface
+ * grows past ~a dozen calls, swap in a real git library.
+ */
+class ShadowGit {
+    store;
+    config;
+    constructor(store, config) {
+        this.store = store;
+        this.config = config;
+    }
+    get gitDir() {
+        return this.store.gitDir;
+    }
+    env(extra = {}) {
+        return {
+            ...process.env,
+            GIT_DIR: this.store.gitDir,
+            GIT_WORK_TREE: this.store.projectRoot,
+            GIT_CONFIG_GLOBAL: "/dev/null",
+            GIT_CONFIG_SYSTEM: "/dev/null",
+            GIT_AUTHOR_NAME: "rewindex",
+            GIT_AUTHOR_EMAIL: "rewindex@localhost",
+            GIT_COMMITTER_NAME: "rewindex",
+            GIT_COMMITTER_EMAIL: "rewindex@localhost",
+            GIT_OPTIONAL_LOCKS: "0",
+            LANG: "C",
+            LC_ALL: "C",
+            ...extra,
+        };
+    }
+    /**
+     * Env for `git init`: identical to {@link env} but WITHOUT GIT_WORK_TREE.
+     * git refuses `init` when a worktree is set without an explicit --git-dir arg,
+     * so we create the repo first, then every later command uses the worktree env.
+     */
+    initEnv() {
+        const e = this.env();
+        delete e.GIT_WORK_TREE;
+        return e;
+    }
+    run(args, extraEnv = {}) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)("git", args, { env: this.env(extraEnv), maxBuffer: 256 * 1024 * 1024 }, (err, stdout, stderr) => {
+                const code = err && typeof err.code === "number" ? err.code : err ? 1 : 0;
+                if (err && code === 0) {
+                    reject(err);
+                    return;
+                }
+                resolve({ stdout: stdout ?? "", stderr: stderr ?? "", code });
+            });
+        });
+    }
+    /** Run and throw on non-zero exit. */
+    async runOk(args, extraEnv = {}) {
+        const r = await this.run(args, extraEnv);
+        if (r.code !== 0) {
+            throw new Error(`git ${args.join(" ")} failed (${r.code}): ${r.stderr.trim()}`);
+        }
+        return r.stdout;
+    }
+    async isInitialized() {
+        try {
+            await fs.promises.access(path.join(this.store.gitDir, "HEAD"));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Create the shadow repo and an empty root commit if it doesn't exist yet. */
+    async ensureInit() {
+        if (await this.isInitialized())
+            return;
+        await fs.promises.mkdir(this.store.dir, { recursive: true });
+        // Init into GIT_DIR WITHOUT a worktree set (git forbids init when a worktree
+        // is set but no --git-dir arg is given). Every later command uses the full
+        // env with GIT_WORK_TREE so snapshots read/write the project files.
+        await new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)("git", ["init", "--quiet", "--initial-branch=rewindex"], { env: this.initEnv() }, (err, _o, stderr) => (err ? reject(new Error(`git init failed: ${stderr}`)) : resolve()));
+        });
+        await this.runOk(["config", "core.bare", "false"]);
+        await this.runOk(["config", "core.logAllRefUpdates", "true"]);
+        // Root commit so the first real snapshot always has a parent to diff against.
+        await this.runOk([
+            "commit",
+            "--allow-empty",
+            "--no-verify",
+            "-m",
+            "rewindex root\n\nrewindex-event: root",
+        ]);
+    }
+    /**
+     * Build the pathspec that excludes configured dirs and (separately computed)
+     * oversized files. We force-add so gitignored project files ARE captured.
+     */
+    excludePathspecs(extraExcludes) {
+        const specs = ["."];
+        const all = [...this.config.exclude, ...extraExcludes];
+        for (const e of all) {
+            // :(exclude) pathspec magic; works for both dirs and files.
+            specs.push(`:(exclude)${e}`);
+            specs.push(`:(exclude)**/${e}`);
+        }
+        return specs;
+    }
+    /**
+     * Walk the worktree to find files over the size cap so we can exclude them.
+     * ponytail: full synchronous walk per snapshot. Ceiling: fine for normal
+     * projects once node_modules is excluded. Upgrade path: cache stat results or
+     * lean on `git ls-files -z` + stat only the candidates.
+     */
+    findOversized() {
+        const over = [];
+        const cap = this.config.maxFileBytes;
+        const skip = new Set(this.config.exclude);
+        const root = this.store.projectRoot;
+        const walk = (dir, rel) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const ent of entries) {
+                if (skip.has(ent.name))
+                    continue;
+                const abs = path.join(dir, ent.name);
+                const relPath = rel ? `${rel}/${ent.name}` : ent.name;
+                if (ent.isDirectory()) {
+                    walk(abs, relPath);
+                }
+                else if (ent.isFile()) {
+                    try {
+                        if (fs.statSync(abs).size > cap)
+                            over.push(relPath);
+                    }
+                    catch {
+                        /* ignore unreadable */
+                    }
+                }
+            }
+        };
+        walk(root, "");
+        return over;
+    }
+    /**
+     * Stage the current worktree (honoring excludes + size cap, force-adding so
+     * gitignored files are included) and commit. Returns null when nothing
+     * changed unless forceCommit is set for a metadata-only prompt boundary.
+     */
+    async snapshot(message, authorDateISO, forceCommit = false) {
+        await this.ensureInit();
+        const oversized = this.config.captureIgnored ? this.findOversized() : [];
+        // Clear the index first so deletions are captured too.
+        await this.runOk(["read-tree", "--empty"]);
+        const addArgs = ["add", "-A"];
+        if (this.config.captureIgnored)
+            addArgs.push("-f");
+        addArgs.push("--", ...this.excludePathspecs(oversized));
+        const addRes = await this.run(addArgs);
+        if (addRes.code !== 0) {
+            throw new Error(`git add failed: ${addRes.stderr.trim()}`);
+        }
+        // Did anything actually change vs HEAD?
+        const diff = await this.run(["diff", "--cached", "--quiet", "HEAD"]);
+        if (diff.code === 0 && !forceCommit) {
+            return null; // no change
+        }
+        const extraEnv = {};
+        if (authorDateISO) {
+            extraEnv.GIT_AUTHOR_DATE = authorDateISO;
+            extraEnv.GIT_COMMITTER_DATE = authorDateISO;
+        }
+        await this.runOk(["commit", "--no-verify", "--allow-empty", "-m", message], extraEnv);
+        return (await this.runOk(["rev-parse", "HEAD"])).trim();
+    }
+    async revParse(ref) {
+        return (await this.runOk(["rev-parse", ref])).trim();
+    }
+    async changesSince(ref) {
+        const out = await this.runOk([
+            "diff",
+            "--name-status",
+            "--no-renames",
+            "-z",
+            ref,
+            "--",
+        ]);
+        const fields = out.split("\0").filter(Boolean);
+        const changes = [];
+        for (let i = 0; i < fields.length; i += 2) {
+            changes.push({ status: fields[i], path: fields[i + 1] });
+        }
+        return changes;
+    }
+    async deletePaths(paths) {
+        const root = path.resolve(this.store.projectRoot) + path.sep;
+        for (const file of paths) {
+            const absolute = path.resolve(this.store.projectRoot, file);
+            if (!absolute.startsWith(root))
+                throw new Error(`unsafe snapshot path: ${file}`);
+            try {
+                await fs.promises.unlink(absolute);
+            }
+            catch (err) {
+                if (err.code !== "ENOENT")
+                    throw err;
+            }
+        }
+    }
+    /** Restore the given paths from a commit into the worktree. */
+    async checkoutPaths(ref, paths) {
+        if (paths.length === 0)
+            return;
+        await this.runOk(["checkout", ref, "--", ...paths]);
+    }
+    /** Content of a file at a commit, or null if it didn't exist then. */
+    async fileAt(ref, file) {
+        const r = await this.run(["show", `${ref}:${file}`]);
+        if (r.code !== 0)
+            return null;
+        return Buffer.from(r.stdout, "binary");
+    }
+}
+exports.ShadowGit = ShadowGit;

package/dist/hook.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookCommand = hookCommand;
+const paths_1 = require("./paths");
+const config_1 = require("./config");
+const git_1 = require("./git");
+const snapshot_1 = require("./snapshot");
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.on("data", (d) => (data += d));
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", () => resolve(data));
+        // If nothing is piped, don't hang forever.
+        setTimeout(() => resolve(data), 2000).unref();
+    });
+}
+function labelFor(p) {
+    const event = p.hook_event_name || "unknown";
+    const meta = {
+        turnId: p.turn_id,
+        sessionId: p.session_id,
+        event,
+        tool: p.tool_name,
+        prompt: p.prompt,
+    };
+    let label;
+    if (event === "UserPromptSubmit" && p.prompt) {
+        label = p.prompt;
+    }
+    else if (event === "PreToolUse") {
+        label = `before ${p.tool_name || "tool"}`;
+    }
+    else {
+        label = `${event} snapshot`;
+    }
+    return { label, meta };
+}
+/**
+ * The `rewindex hook` entrypoint. Reads one JSON payload, takes a SYNCHRONOUS
+ * snapshot, then exits 0. It must NEVER block the tool call: any failure is
+ * logged to stderr and we still exit 0 (stdout stays empty, which Codex ignores
+ * for PreToolUse so the tool proceeds unchanged).
+ */
+async function hookCommand() {
+    const raw = await readStdin();
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch {
+        // Can't parse — nothing to snapshot against, but never block the tool.
+        process.stderr.write("rewindex: unparseable hook payload, skipping snapshot\n");
+        return 0;
+    }
+    const projectRoot = payload.cwd || process.cwd();
+    try {
+        const store = (0, paths_1.storeFor)(projectRoot);
+        const config = (0, config_1.loadConfig)();
+        const git = new git_1.ShadowGit(store, config);
+        const { label, meta } = labelFor(payload);
+        const sha = await git.snapshot((0, snapshot_1.buildMessage)(label, meta), undefined, meta.event === "UserPromptSubmit");
+        if (sha) {
+            process.stderr.write(`rewindex: snapshot ${sha.slice(0, 10)} (${meta.event})\n`);
+        }
+    }
+    catch (err) {
+        // Log and warn only — the snapshot failing must not stop Codex.
+        process.stderr.write(`rewindex: snapshot failed (non-blocking): ${err.message}\n`);
+    }
+    return 0;
+}

package/dist/install.js

@@ -0,0 +1,207 @@
+"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.installCommand = installCommand;
+exports.uninstallCommand = uninstallCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Install/uninstall the rewindex hooks into Codex's USER-level hook config.
+ *
+ * ponytail / DELIBERATE DEVIATION: the task said "merge into ~/.codex/config.toml
+ * ... parse TOML properly". We instead write ~/.codex/hooks.json, which Codex
+ * loads as a first-class user-level hook source and MERGES with config.toml
+ * (verified: learn.chatgpt.com/docs/hooks lists `~/.codex/hooks.json` alongside
+ * `~/.codex/config.toml`). Rationale: hooks.json is pure JSON, so a round-trip
+ * can't clobber the user's hand-written config.toml comments/formatting/other
+ * hooks — the single biggest footgun here. Net effect is identical. Ceiling:
+ * if a user keeps hooks ONLY in config.toml and nowhere else, ours live in a
+ * separate file (still both load). Upgrade path: add a `--into config.toml`
+ * mode backed by a real TOML round-tripper if anyone needs it.
+ */
+const EVENTS = ["PreToolUse", "UserPromptSubmit"];
+const MARKER = "rewindex"; // how we recognize our own entries for idempotency
+const SKILL_MARKER = "<!-- generated by rewindex -->";
+const STATUS_MESSAGE = "rewindex snapshot";
+function codexHome() {
+    const env = process.env.CODEX_HOME;
+    return env && env.trim() ? path.resolve(env) : path.join(os.homedir(), ".codex");
+}
+function hooksJsonPath() {
+    return path.join(codexHome(), "hooks.json");
+}
+function skillDirPath() {
+    return path.join(codexHome(), "skills", "rewindex");
+}
+function skillFilePath() {
+    return path.join(skillDirPath(), "SKILL.md");
+}
+function cliScript() {
+    // Resolve the installed binary. When run via `npx rewindex` / a global
+    // install, process.argv[1] points at dist/cli.js; prefer the `rewindex` bin
+    // on PATH for portability, falling back to the absolute script path.
+    const abs = process.argv[1] ? path.resolve(process.argv[1]) : "";
+    return abs ? `node ${JSON.stringify(abs)}` : "rewindex";
+}
+function rewindexCommand() {
+    return `${cliScript()} hook`;
+}
+function ourHandler() {
+    return {
+        type: "command",
+        command: rewindexCommand(),
+        timeout: 30,
+        statusMessage: STATUS_MESSAGE,
+    };
+}
+function isOurGroup(g) {
+    return (g.hooks || []).some((h) => h.statusMessage === STATUS_MESSAGE ||
+        (typeof h.command === "string" && h.command.includes(MARKER)));
+}
+function readHooksFile() {
+    try {
+        return JSON.parse(fs.readFileSync(hooksJsonPath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeHooksFile(data) {
+    fs.mkdirSync(codexHome(), { recursive: true });
+    fs.writeFileSync(hooksJsonPath(), JSON.stringify(data, null, 2) + "\n");
+}
+function skillBody() {
+    const cli = cliScript();
+    return `---
+name: rewindex
+description: Use when the user asks to list, inspect, restore, undo, or rewind rewindex file snapshots in the current Codex workspace.
+---
+
+${SKILL_MARKER}
+
+# Rewindex
+
+Interpret the text after \`$rewindex\` as exactly one command:
+
+- \`$rewindex list\`: run \`${cli} list -C "$PWD"\`.
+- \`$rewindex diff <number|id>\`: validate the selector, then run \`${cli} diff "<number|id>" -C "$PWD"\`.
+- \`$rewindex restore <number|id>\`: validate the selector, run the diff command first, show its output, and ask for explicit confirmation. Only after the user confirms, run \`${cli} restore "<number|id>" -y -C "$PWD"\`.
+- \`$rewindex undo\`: ask for explicit confirmation. Only after the user confirms, run \`${cli} restore --undo -y -C "$PWD"\`.
+
+A selector is valid only when it is a decimal number from \`1\` through \`50\`, hexadecimal, or exactly \`latest\` or \`last\`. Never pass other user input to the shell, infer a selector, or add user-supplied flags. For missing or unsupported arguments, show the four forms above and make no changes.
+`;
+}
+function installSkill() {
+    const file = skillFilePath();
+    if (fs.existsSync(file) && !fs.readFileSync(file, "utf8").includes(SKILL_MARKER)) {
+        throw new Error(`Refusing to overwrite existing unowned skill: ${file}`);
+    }
+    fs.mkdirSync(skillDirPath(), { recursive: true });
+    fs.writeFileSync(file, skillBody());
+}
+function uninstallSkill() {
+    const file = skillFilePath();
+    if (!fs.existsSync(file))
+        return false;
+    if (!fs.readFileSync(file, "utf8").includes(SKILL_MARKER))
+        return false;
+    fs.unlinkSync(file);
+    try {
+        fs.rmdirSync(skillDirPath());
+    }
+    catch (err) {
+        if (err.code !== "ENOTEMPTY")
+            throw err;
+    }
+    return true;
+}
+function installCommand() {
+    installSkill();
+    const data = readHooksFile();
+    data.hooks = data.hooks || {};
+    let added = 0;
+    for (const event of EVENTS) {
+        const groups = (data.hooks[event] = data.hooks[event] || []);
+        // Idempotent: replace any existing rewindex group, leave others untouched.
+        const kept = groups.filter((g) => !isOurGroup(g));
+        kept.push({ hooks: [ourHandler()] });
+        data.hooks[event] = kept;
+        added++;
+    }
+    writeHooksFile(data);
+    console.log(`Installed rewindex hooks into ${hooksJsonPath()} (${added} events).`);
+    console.log(`Installed Codex skill: ${skillFilePath()}`);
+    console.log("Use it in a new Codex session: $rewindex list");
+    console.log("");
+    printTrustNote();
+    return 0;
+}
+function uninstallCommand() {
+    const removedSkill = uninstallSkill();
+    const data = readHooksFile();
+    if (!data.hooks) {
+        console.log("No rewindex hooks found.");
+        return 0;
+    }
+    let removed = 0;
+    for (const event of Object.keys(data.hooks)) {
+        const groups = data.hooks[event] || [];
+        const before = groups.length;
+        const kept = groups.filter((g) => !isOurGroup(g));
+        removed += before - kept.length;
+        if (kept.length > 0)
+            data.hooks[event] = kept;
+        else
+            delete data.hooks[event];
+    }
+    if (Object.keys(data.hooks).length === 0)
+        delete data.hooks;
+    writeHooksFile(data);
+    console.log(`Removed ${removed} rewindex hook group(s) from ${hooksJsonPath()}.`);
+    console.log(removedSkill ? "Removed the rewindex Codex skill." : "No owned rewindex skill found.");
+    console.log("Your other hooks were left untouched.");
+    return 0;
+}
+function printTrustNote() {
+    console.log("IMPORTANT — Codex requires you to TRUST new hooks before they run:");
+    console.log("  1. Start (or restart) Codex.");
+    console.log("  2. Run  /hooks  in the Codex CLI.");
+    console.log("  3. Review the two `rewindex hook` entries and mark them trusted.");
+    console.log("");
+    console.log("Until trusted, Codex SKIPS them (it warns at startup), so no snapshots");
+    console.log("are taken. Trust is tied to the hook's hash — if you reinstall/upgrade");
+    console.log("rewindex, re-run /hooks to re-trust the changed command.");
+}

package/dist/paths.js

@@ -0,0 +1,81 @@
+"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.rewindexHome = rewindexHome;
+exports.projectHash = projectHash;
+exports.storeFor = storeFor;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+/**
+ * Where rewindex keeps its shadow repos and state. Overridable via REWINDEX_HOME
+ * (used by the self-check to stay out of the real ~/.rewindex).
+ */
+function rewindexHome() {
+    const override = process.env.REWINDEX_HOME;
+    if (override && override.trim())
+        return path.resolve(override);
+    return path.join(os.homedir(), ".rewindex");
+}
+/**
+ * A stable per-project id. We hash the real (symlink-resolved) absolute path so
+ * two checkouts at different paths get separate stores and the same path always
+ * maps to the same store.
+ */
+function projectHash(projectRoot) {
+    const real = safeRealpath(projectRoot);
+    return crypto.createHash("sha256").update(real).digest("hex").slice(0, 16);
+}
+function safeRealpath(p) {
+    try {
+        return fs.realpathSync(path.resolve(p));
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+function storeFor(projectRoot) {
+    const root = safeRealpath(projectRoot);
+    const hash = projectHash(root);
+    const dir = path.join(rewindexHome(), hash);
+    return {
+        projectRoot: root,
+        hash,
+        dir,
+        gitDir: path.join(dir, "git"),
+        stateFile: path.join(dir, "state.json"),
+    };
+}