@susu-eng/trunk-sync 2.3.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,26 @@
+{
+  "name": "trunk-sync",
+  "owner": {
+    "name": "Eli Mydlarz"
+  },
+  "metadata": {
+    "description": "trunk-sync plugin marketplace",
+    "version": "1.0.0"
+  },
+  "plugins": [
+    {
+      "name": "trunk-sync",
+      "source": {
+        "source": "github",
+        "repo": "elimydlarz/trunk-sync"
+      },
+      "description": "Auto-commit and push every file edit, keeping multiple agents in sync on trunk",
+      "author": {
+        "name": "Eli Mydlarz"
+      },
+      "repository": "https://github.com/elimydlarz/trunk-sync",
+      "license": "MIT",
+      "keywords": ["hooks", "git", "multi-agent", "sync", "trunk-based-development"]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "trunk-sync",
+  "version": "1.0.0",
+  "description": "Maximum continuous integration for multi-agent coding — every edit is committed and pushed to trunk immediately",
+  "author": {
+    "name": "Eli Mydlarz"
+  },
+  "repository": "https://github.com/elimydlarz/trunk-sync",
+  "license": "MIT",
+  "keywords": ["hooks", "git", "multi-agent", "sync", "trunk-based-development"]
+}

package/README.md

@@ -0,0 +1,86 @@
+# trunk-sync
+
+Run multiple Claude Code agents on the same repo without breaking each other's work, and understand any line of generated code on demand.
+
+## Trunk-Sync — maximum continuous integration for coding agents
+
+Every file edit is committed and pushed to `origin/main` automatically. Agents work in parallel — on local worktrees, across remote machines, any mix — with agentic conflict resolution. No more wasted time resolving conflicts by hand, remembering to commit, or discovering that an agent never pushed its work.
+
+## Seance — talk to dead coding agents
+
+Point at any line of code, and seance rewinds the codebase and the Claude session back to the exact moment that line was written. Ask the agent what it was thinking. Understand generated code easily, on demand — stop worrying about keeping up with every change your agents make.
+
+## Quick start
+
+```bash
+npm install -g trunk-sync
+trunk-sync install
+```
+
+This installs the plugin at **project scope** (active in the current repo only). To install at **user scope** (active in all repos):
+
+```bash
+trunk-sync install --scope user
+```
+
+### Prerequisites
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) CLI
+- `jq` on the machine running Claude Code
+- A git repo with a remote (`origin`)
+
+### Scopes
+
+| Scope | Config location | Effect |
+|-------|----------------|--------|
+| `project` (default) | `.claude/plugins.json` | Active in this repo only — committed to git so collaborators get it too |
+| `user` | `~/.claude/plugins.json` | Active in all repos for this user |
+
+## Using Trunk-Sync
+
+```bash
+claude -w    # each invocation gets its own worktree
+```
+
+Launch as many agents as you need. They all push to the same trunk. After every `Edit` or `Write`, trunk-sync commits, pulls, and pushes — automatically. If two agents edit the same file, trunk-sync tells the agent to resolve the conflict by editing the file normally. No git commands, no manual merging.
+
+## Using Seance
+
+```bash
+# Rewind and resume the session that wrote line 42
+trunk-sync seance src/main.ts:42
+
+# Just show which session wrote it, without launching Claude
+trunk-sync seance src/main.ts:42 --inspect
+
+# List all trunk-sync sessions in the repo
+trunk-sync seance --list
+```
+
+Seance traces `git blame` back to the commit, rewinds the session transcript to that point, checks out the code at that commit, and resumes Claude with the same context it had when it wrote the line. The resumed agent is read-only — it explains and explores but cannot edit.
+
+## Transcript commits
+
+By default, seance finds session transcripts on the local filesystem (`~/.claude/projects/<slug>/<sessionId>.jsonl`). This works when you're tracing code written on the same machine, but the transcript won't exist if the code was written by an agent on a different machine, in CI, or if the local transcript has been cleaned up.
+
+**Enable transcript commits** to solve this — each auto-commit will include a snapshot of the session transcript in `.transcripts/`, so the conversation travels with the code in git history:
+
+```bash
+trunk-sync config commit-transcripts true
+```
+
+With this enabled, seance can find the transcript directly in the commit via `git diff-tree`, regardless of which machine wrote the code. This is the recommended setup for teams and multi-machine workflows.
+
+To disable:
+
+```bash
+trunk-sync config commit-transcripts false
+```
+
+### Security note
+
+Transcripts contain your full conversation with Claude, which may include sensitive context, proprietary code discussions, or credentials you pasted into the chat. With `commit-transcripts=true`, these are committed to git — meaning anyone with repo access can read them. Encryption of snapshots before commit is a likely future addition, which would let transcripts hitch a ride on git without being readable in the clear. For now, only enable this on repos where you're comfortable with transcript visibility, or where access is already restricted.
+
+## For humans
+
+Developer docs, architecture, and testing: [.humans/README.md](.humans/README.md)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { configCommand } from "./commands/config.js";
+import { installCommand } from "./commands/install.js";
+import { seanceCommand } from "./commands/seance.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const USAGE = `trunk-sync v${pkg.version}
+
+Usage: trunk-sync <command> [options]
+
+Commands:
+  install   Install the trunk-sync Claude Code plugin
+  seance    Find which Claude session wrote a line of code
+  config    Read or write trunk-sync configuration
+
+Options:
+  --version  Show version
+  -h, --help Show this help message`;
+const command = process.argv[2];
+if (!command || command === "--help" || command === "-h") {
+    console.log(USAGE);
+    process.exit(0);
+}
+if (command === "--version") {
+    console.log(pkg.version);
+    process.exit(0);
+}
+const subArgs = process.argv.slice(3);
+switch (command) {
+    case "install":
+        installCommand(subArgs);
+        break;
+    case "seance":
+        seanceCommand(subArgs);
+        break;
+    case "config":
+        configCommand(subArgs);
+        break;
+    default:
+        console.error(`Unknown command: ${command}\n`);
+        console.log(USAGE);
+        process.exit(1);
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,4 @@
+export declare function configPath(): string;
+export declare function readConfig(): Map<string, string>;
+export declare function writeConfig(map: Map<string, string>): void;
+export declare function configCommand(args: string[]): void;

package/dist/commands/config.js

@@ -0,0 +1,85 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const USAGE = `Usage: trunk-sync config                   Show all config
+       trunk-sync config <key>=<value>       Set a value
+       trunk-sync config --unset <key>       Remove a key
+
+Config file: ~/.trunk-sync (key=value format)`;
+export function configPath() {
+    return join(homedir(), ".trunk-sync");
+}
+export function readConfig() {
+    const map = new Map();
+    let content;
+    try {
+        content = readFileSync(configPath(), "utf-8");
+    }
+    catch {
+        return map;
+    }
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        map.set(trimmed.slice(0, eq), trimmed.slice(eq + 1));
+    }
+    return map;
+}
+export function writeConfig(map) {
+    const lines = [];
+    for (const [key, value] of map) {
+        lines.push(`${key}=${value}`);
+    }
+    writeFileSync(configPath(), lines.join("\n") + "\n");
+}
+export function configCommand(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(USAGE);
+        return;
+    }
+    const unsetIndex = args.indexOf("--unset");
+    if (unsetIndex !== -1) {
+        const key = args[unsetIndex + 1];
+        if (!key) {
+            console.error("Usage: trunk-sync config --unset <key>");
+            process.exit(1);
+        }
+        const map = readConfig();
+        if (!map.has(key)) {
+            console.error(`Key not found: ${key}`);
+            process.exit(1);
+        }
+        map.delete(key);
+        writeConfig(map);
+        console.log(`Unset ${key}`);
+        return;
+    }
+    const positional = args.filter((a) => !a.startsWith("--"));
+    if (positional.length === 0) {
+        const map = readConfig();
+        if (map.size === 0) {
+            console.log("No config set. Config file: ~/.trunk-sync");
+            return;
+        }
+        for (const [key, value] of map) {
+            console.log(`${key}=${value}`);
+        }
+        return;
+    }
+    const arg = positional[0];
+    const eq = arg.indexOf("=");
+    if (eq === -1) {
+        console.error(`Expected key=value, got: ${arg}`);
+        process.exit(1);
+    }
+    const key = arg.slice(0, eq);
+    const value = arg.slice(eq + 1);
+    const map = readConfig();
+    map.set(key, value);
+    writeConfig(map);
+    console.log(`Set ${key}=${value}`);
+}

package/dist/commands/install.d.ts

@@ -0,0 +1 @@
+export declare function installCommand(args: string[]): void;

package/dist/commands/install.js

@@ -0,0 +1,66 @@
+import { execSync } from "node:child_process";
+import { getGitRoot, commandExists } from "../lib/git.js";
+export function installCommand(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`Usage: trunk-sync install [--scope user|project]
+
+Installs the trunk-sync Claude Code plugin.
+
+Options:
+  --scope <scope>  Installation scope: "project" (default) or "user"
+                   project — active in this repo only (.claude/plugins.json)
+                   user    — active in all repos (~/.claude/plugins.json)
+  -h, --help       Show this help message`);
+        return;
+    }
+    const scopeIdx = args.indexOf("--scope");
+    const scope = scopeIdx !== -1 ? args[scopeIdx + 1] : "project";
+    if (scope !== "project" && scope !== "user") {
+        console.error(`Invalid scope: ${scope}. Must be "project" or "user".`);
+        process.exit(1);
+    }
+    // Precondition checks (git repo and remote are soft warnings — trunk-sync
+    // works without them, just with reduced functionality)
+    if (!getGitRoot()) {
+        console.warn("Warning: not inside a git repository. trunk-sync needs git to auto-commit and sync.");
+    }
+    else {
+        try {
+            execSync("git remote get-url origin", { stdio: "ignore" });
+        }
+        catch {
+            // No remote is fine — hook will commit locally and skip pushing
+        }
+    }
+    if (!commandExists("jq")) {
+        console.error("jq is required. Install: brew install jq / apt install jq");
+        process.exit(1);
+    }
+    if (!commandExists("claude")) {
+        console.error("Claude Code CLI not found. Install: https://docs.anthropic.com/en/docs/claude-code");
+        process.exit(1);
+    }
+    // Add GitHub repo as a marketplace source
+    console.log("Adding trunk-sync marketplace...");
+    try {
+        execSync(`claude plugin marketplace add elimydlarz/trunk-sync --scope ${scope}`, { stdio: "inherit" });
+    }
+    catch {
+        // May already be added — continue to install
+    }
+    // Install the plugin from the marketplace
+    console.log(`Installing trunk-sync plugin (scope: ${scope})...`);
+    try {
+        execSync(`claude plugin install trunk-sync@trunk-sync --scope ${scope}`, {
+            stdio: "inherit",
+        });
+    }
+    catch {
+        console.error("Plugin installation failed.");
+        process.exit(1);
+    }
+    console.log(`\ntrunk-sync installed successfully (scope: ${scope}).
+
+Every file edit will now auto-commit and sync to the remote.
+Works on main, on branches, or in worktrees (claude -w).`);
+}

package/dist/commands/seance.d.ts

@@ -0,0 +1 @@
+export declare function seanceCommand(args: string[]): void;

package/dist/commands/seance.js

@@ -0,0 +1,228 @@
+import { execSync, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { join, relative, resolve } from "node:path";
+import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from "node:fs";
+import { parseFileRef, blame, getCommitBody, getCommitSubject, getCommitDate, getCommitTimestamp, extractSessionId, findSnapshotInCommit, commandExists, shortSha, getGitRoot, } from "../lib/git.js";
+const USAGE = `Usage: trunk-sync seance <file:line> [--inspect]
+       trunk-sync seance --list
+
+Find which Claude session wrote a line of code and fork that session.
+
+Arguments:
+  <file:line>   File path and line number, e.g. src/main.ts:42
+
+Options:
+  --inspect     Show commit and session info without launching Claude
+  --list        List all trunk-sync sessions found in git history
+  -h, --help    Show this help message`;
+function listSessions() {
+    let output;
+    try {
+        output = execSync('git log --format="%H" --grep="^auto("', {
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        output = "";
+    }
+    if (!output) {
+        console.log("No trunk-sync sessions found in git history.");
+        return;
+    }
+    const shas = output.split("\n");
+    const seen = new Map();
+    for (const sha of shas) {
+        const body = getCommitBody(sha);
+        const sessionId = extractSessionId(body);
+        if (sessionId && !seen.has(sessionId)) {
+            seen.set(sessionId, {
+                sha,
+                subject: getCommitSubject(sha),
+                date: getCommitDate(sha),
+            });
+        }
+    }
+    if (seen.size === 0) {
+        console.log("No trunk-sync sessions found in git history.");
+        return;
+    }
+    console.log("SESSION_ID                            SUBJECT                                          DATE");
+    console.log("─".repeat(100));
+    for (const [sessionId, { subject, date }] of seen) {
+        const truncSubject = subject.length > 48 ? subject.slice(0, 45) + "..." : subject;
+        const shortDate = date.slice(0, 19);
+        console.log(`${sessionId.padEnd(38)}${truncSubject.padEnd(50)}${shortDate}`);
+    }
+}
+/**
+ * Derive the Claude project slug for a given directory path.
+ * Claude replaces "/" and "." with "-" in the absolute path.
+ */
+function projectSlug(dirPath) {
+    return dirPath.replace(/[/.]/g, "-");
+}
+/**
+ * Create a truncated copy of a session transcript, containing only messages
+ * up to the given timestamp. The copy is written into the worktree's project
+ * directory so Claude can find it via --resume.
+ */
+function rewindTranscript(transcriptPath, commitTimestamp, worktreePath) {
+    const expandedPath = transcriptPath.replace(/^~/, process.env.HOME || "~");
+    if (!existsSync(expandedPath))
+        return null;
+    const cutoff = new Date(commitTimestamp).getTime();
+    const lines = readFileSync(expandedPath, "utf-8").split("\n").filter(Boolean);
+    // Find the last line whose timestamp is <= the commit timestamp.
+    let cutIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        try {
+            const obj = JSON.parse(lines[i]);
+            const ts = obj.timestamp;
+            if (ts && new Date(ts).getTime() <= cutoff) {
+                cutIndex = i;
+            }
+        }
+        catch {
+            // Non-JSON lines (shouldn't happen) — include them if before cutoff
+        }
+    }
+    if (cutIndex < 0)
+        return null;
+    const newId = randomUUID();
+    // Write into the project directory Claude will use for the worktree.
+    const home = process.env.HOME || "~";
+    const projectDir = join(home, ".claude", "projects", projectSlug(worktreePath));
+    mkdirSync(projectDir, { recursive: true });
+    const newPath = join(projectDir, `${newId}.jsonl`);
+    // Rewrite sessionId and cwd so Claude recognises this as a valid session.
+    const rewritten = lines.slice(0, cutIndex + 1).map((line) => {
+        try {
+            const obj = JSON.parse(line);
+            if (obj.sessionId)
+                obj.sessionId = newId;
+            if (obj.cwd)
+                obj.cwd = worktreePath;
+            return JSON.stringify(obj);
+        }
+        catch {
+            return line;
+        }
+    });
+    writeFileSync(newPath, rewritten.join("\n") + "\n");
+    return { path: newPath, id: newId };
+}
+function inspectOrLaunch(fileRef, inspect) {
+    const { file, line } = parseFileRef(fileRef);
+    const sha = blame(file, line);
+    if (/^0+$/.test(sha)) {
+        console.error(`Line ${line} has uncommitted changes.`);
+        process.exit(1);
+    }
+    const body = getCommitBody(sha);
+    const sessionId = extractSessionId(body);
+    const subject = getCommitSubject(sha);
+    if (!sessionId) {
+        console.error(`Commit ${shortSha(sha)} was not created by trunk-sync.`);
+        process.exit(1);
+    }
+    if (inspect) {
+        console.log(`Commit:   ${sha}`);
+        console.log(`Subject:  ${subject}`);
+        console.log(`Session:  ${sessionId}`);
+        return;
+    }
+    if (!commandExists("claude")) {
+        console.error("Claude Code CLI not found.");
+        process.exit(1);
+    }
+    const root = getGitRoot();
+    if (!root) {
+        console.error("Not in a git repository.");
+        process.exit(1);
+    }
+    const worktreePath = join(root, ".claude", "worktrees", `seance-${shortSha(sha)}`);
+    try {
+        execSync(`git worktree add --detach "${worktreePath}" "${sha}"`, { stdio: "pipe" });
+    }
+    catch {
+        console.error(`Failed to create worktree at ${sha}.`);
+        process.exit(1);
+    }
+    const relFile = relative(root, resolve(file));
+    const prompt = `*STOP*. *HALT ALL PREVIOUS OPERATIONS AND STOP IMMEDIATELY*. *DO NOT CONTINUE YOUR CURRENT CHAIN OF THOUGHT*. This session already ended. It has been resumed and rewound — including the code — so you can answer questions about why it was written this way. *DO NOT* change any code. Start by explaining ${relFile}:${line} (commit ${shortSha(sha)}) — what does it do, how does it work, and why is it written this way?`;
+    // Rewind the session transcript to the commit point.
+    // Try snapshot from .transcripts/ in the commit first, fall back to Transcript: field.
+    const snapshotRelPath = findSnapshotInCommit(sha);
+    let transcriptSource = null;
+    if (snapshotRelPath) {
+        const snapshotAbsPath = join(root, snapshotRelPath);
+        if (existsSync(snapshotAbsPath)) {
+            transcriptSource = snapshotAbsPath;
+        }
+    }
+    if (!transcriptSource) {
+        const home = process.env.HOME || "~";
+        const derived = join(home, ".claude", "projects", projectSlug(root), `${sessionId}.jsonl`);
+        if (existsSync(derived)) {
+            transcriptSource = derived;
+        }
+    }
+    if (!transcriptSource) {
+        console.error(`Commit ${shortSha(sha)} has no transcript (no .transcripts/ snapshot and no transcript at derived path).`);
+        process.exit(1);
+    }
+    const commitTimestamp = getCommitTimestamp(sha);
+    const rewound = rewindTranscript(transcriptSource, commitTimestamp, worktreePath);
+    if (!rewound) {
+        console.error(`Could not rewind transcript for commit ${shortSha(sha)}.`);
+        process.exit(1);
+    }
+    console.log(`Rewound session to commit ${shortSha(sha)} (${commitTimestamp})`);
+    console.log(`Forking session ${sessionId} (from commit ${shortSha(sha)}: ${subject})`);
+    console.log(`Worktree at ${worktreePath}`);
+    const readOnlyTools = "Read,Grep,Glob,Bash(git:*),Agent,WebSearch,WebFetch";
+    const systemPrompt = "You are in SEANCE MODE — a read-only forensic session. You MUST NOT edit, write, or create any files. " +
+        "Your only job is to explain the code: what it does, how it works, and why it was written this way. " +
+        "You do not have access to Edit, Write, or NotebookEdit tools.";
+    const args = [
+        "--resume", rewound.id,
+        "--allowedTools", readOnlyTools,
+        "--append-system-prompt", systemPrompt,
+        prompt,
+    ];
+    const result = spawnSync("claude", args, {
+        stdio: "inherit",
+        cwd: worktreePath,
+    });
+    // Clean up the rewound transcript file
+    if (rewound) {
+        try {
+            unlinkSync(rewound.path);
+        }
+        catch { /* best-effort */ }
+    }
+    try {
+        execSync(`git worktree remove "${worktreePath}"`, { stdio: "pipe" });
+    }
+    catch {
+        console.error(`Note: worktree left at ${worktreePath} — remove with: git worktree remove "${worktreePath}"`);
+    }
+    process.exit(result.status ?? 1);
+}
+export function seanceCommand(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(USAGE);
+        return;
+    }
+    if (args.includes("--list")) {
+        listSessions();
+        return;
+    }
+    const positional = args.filter((a) => !a.startsWith("--"));
+    if (positional.length === 0) {
+        console.log(USAGE);
+        return;
+    }
+    const inspect = args.includes("--inspect");
+    inspectOrLaunch(positional[0], inspect);
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,14 @@
+export declare function getGitRoot(): string | null;
+export declare function parseFileRef(ref: string): {
+    file: string;
+    line: number;
+};
+export declare function blame(file: string, line: number, cwd?: string): string;
+export declare function getCommitBody(sha: string, cwd?: string): string;
+export declare function getCommitSubject(sha: string, cwd?: string): string;
+export declare function getCommitDate(sha: string, cwd?: string): string;
+export declare function extractSessionId(body: string): string | null;
+export declare function getCommitTimestamp(sha: string, cwd?: string): string;
+export declare function commandExists(cmd: string): boolean;
+export declare function shortSha(sha: string): string;
+export declare function findSnapshotInCommit(sha: string, cwd?: string): string | null;

package/dist/lib/git.js

@@ -0,0 +1,71 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+export function getGitRoot() {
+    try {
+        return execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function parseFileRef(ref) {
+    const lastColon = ref.lastIndexOf(":");
+    if (lastColon === -1) {
+        throw new Error(`Expected file:line, e.g. src/main.ts:42`);
+    }
+    const file = ref.slice(0, lastColon);
+    const lineStr = ref.slice(lastColon + 1);
+    const line = Number(lineStr);
+    if (!Number.isInteger(line) || line < 1) {
+        throw new Error(`Expected file:line with a positive integer line number, got: ${ref}`);
+    }
+    if (!existsSync(file)) {
+        throw new Error(`File not found: ${file}`);
+    }
+    return { file, line };
+}
+export function blame(file, line, cwd) {
+    const output = execSync(`git blame "${file}" -L ${line},${line} --porcelain`, {
+        encoding: "utf-8",
+        cwd,
+    });
+    const sha = output.split("\n")[0].split(" ")[0];
+    return sha;
+}
+export function getCommitBody(sha, cwd) {
+    return execSync(`git log -1 --format=%b "${sha}"`, { encoding: "utf-8", cwd }).trim();
+}
+export function getCommitSubject(sha, cwd) {
+    return execSync(`git log -1 --format=%s "${sha}"`, { encoding: "utf-8", cwd }).trim();
+}
+export function getCommitDate(sha, cwd) {
+    return execSync(`git log -1 --format=%ci "${sha}"`, { encoding: "utf-8", cwd }).trim();
+}
+export function extractSessionId(body) {
+    const match = body.match(/^Session:\s*(.+)/m);
+    return match ? match[1].trim() : null;
+}
+export function getCommitTimestamp(sha, cwd) {
+    return execSync(`git log -1 --format=%cI "${sha}"`, { encoding: "utf-8", cwd }).trim();
+}
+export function commandExists(cmd) {
+    try {
+        execSync(`command -v "${cmd}"`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function shortSha(sha) {
+    return sha.slice(0, 8);
+}
+export function findSnapshotInCommit(sha, cwd) {
+    try {
+        const output = execSync(`git diff-tree --root --no-commit-id --name-only -r "${sha}" -- .transcripts/`, { encoding: "utf-8", cwd }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/hook-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/hook-entry.js

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { parseHookInput, planHook } from "./hook-plan.js";
+import { gatherRepoState, executePlan } from "./hook-execute.js";
+function main() {
+    let rawInput = "";
+    try {
+        rawInput = readFileSync(0, "utf-8");
+    }
+    catch {
+        // no stdin
+    }
+    const input = parseHookInput(rawInput || "{}");
+    const state = gatherRepoState(input);
+    // Not in a git repo — no-op
+    if (!state)
+        process.exit(0);
+    const plan = planHook(input, state);
+    const result = executePlan(plan, input, state);
+    if (result.stderr) {
+        process.stderr.write(result.stderr + "\n");
+    }
+    process.exit(result.exitCode);
+}
+main();