just-git 1.0.2 → 1.1.0

package/README.md

@@ -46,7 +46,8 @@ await bash.exec("git log --oneline");
 | `credentials`   | `(url) => HttpAuth \| null` callback for Smart HTTP transport auth.                                                                                                                                                                                |
 | `disabled`      | `GitCommandName[]` of subcommands to block (e.g. `["push", "rebase"]`).                                                                                                                                                                            |
 | `network`       | `{ allowed?: string[], fetch?: FetchFunction }` to restrict HTTP access and/or provide a custom `fetch`. `allowed` accepts hostnames (`"github.com"`) or URL prefixes (`"https://github.com/myorg/"`). Set to `false` to block all network access. |
-| `resolveRemote` | `(url) => GitContext \| null` callback for cross-VFS remote resolution. See [Multi-agent collaboration](#multi-agent-collaboration).                                                                                                               |
+| `hooks`         | `GitHooks` config object with named callback properties. See [Hooks](#hooks).                                                                                                                                                                      |
+| `resolveRemote` | `(url) => GitRepo \| null` callback for cross-VFS remote resolution. See [Multi-agent collaboration](#multi-agent-collaboration).                                                                                                                  |
 
 ```ts
 const git = createGit({
@@ -57,80 +58,73 @@ const git = createGit({
 });
 ```
 
-## Middleware
+## Hooks
+
+Hooks fire at specific points inside command execution. Specified as a `GitHooks` config object at construction time. All hook event payloads include `repo: GitRepo`, providing access to the [repo module helpers](src/repo/) inside hooks.
 
-Middleware wraps every `git <subcommand>` invocation. Each middleware receives a `CommandEvent` and a `next()` function. Call `next()` to proceed, or return an `ExecResult` to short-circuit. Middlewares compose in registration order (first registered = outermost). `git.use()` returns an unsubscribe function.
+Pre-hooks can reject the operation by returning `{ reject: true, message? }`. Post-hooks are observational — return value is ignored.
 
 ```ts
-// Audit log — record every command the agent runs
-git.use(async (event, next) => {
-  const result = await next();
-  auditLog.push({ command: `git ${event.command}`, exitCode: result.exitCode });
-  return result;
-});
+import { createGit, type GitHooks } from "just-git";
+import { getChangedFiles } from "just-git/repo";
 
-// Gate pushes on human approval
-git.use(async (event, next) => {
-  if (event.command === "push" && !(await getHumanApproval(event.rawArgs))) {
-    return { stdout: "", stderr: "Push blocked — awaiting approval.\n", exitCode: 1 };
-  }
-  return next();
-});
+const git = createGit({
+  hooks: {
+    // Block secrets from being committed
+    preCommit: ({ index }) => {
+      const forbidden = index.entries.filter((e) => /\.(env|pem|key)$/.test(e.path));
+      if (forbidden.length) {
+        return { reject: true, message: `Blocked: ${forbidden.map((e) => e.path).join(", ")}` };
+      }
+    },
 
-// Block commits that add large files (uses event.fs to read the worktree)
-git.use(async (event, next) => {
-  if (event.command === "add") {
-    for (const path of event.rawArgs.filter((a) => !a.startsWith("-"))) {
-      const resolved = path.startsWith("/") ? path : `${event.cwd}/${path}`;
-      const stat = await event.fs.stat(resolved).catch(() => null);
-      if (stat && stat.size > 5_000_000) {
-        return { stdout: "", stderr: `Blocked: ${path} exceeds 5 MB\n`, exitCode: 1 };
+    // Enforce conventional commit messages
+    commitMsg: (event) => {
+      if (!/^(feat|fix|docs|refactor|test|chore)(\(.+\))?:/.test(event.message)) {
+        return { reject: true, message: "Commit message must follow conventional commits format" };
       }
-    }
-  }
-  return next();
+    },
+
+    // Feed agent activity to your UI — with changed file list
+    postCommit: async ({ repo, hash, branch, parents }) => {
+      const files = await getChangedFiles(repo, parents[0] ?? null, hash);
+      onAgentCommit({ hash, branch, changedFiles: files });
+    },
+
+    // Audit log — record every command
+    afterCommand: ({ command, args, result }) => {
+      auditLog.push({ command: `git ${command}`, exitCode: result.exitCode });
+    },
+
+    // Gate pushes on human approval
+    beforeCommand: async ({ command }) => {
+      if (command === "push" && !(await getHumanApproval())) {
+        return { reject: true, message: "Push blocked — awaiting approval." };
+      }
+    },
+  },
 });
 ```
 
-## Hooks
-
-Hooks fire at specific points inside command execution (after middleware, inside operation logic). Register with `git.on(event, handler)`, which returns an unsubscribe function.
-
-Pre-hooks can abort the operation by returning `{ abort: true, message? }`. Post-hooks are observational — return value is ignored.
+Use `composeGitHooks()` to combine multiple hook sets:
 
 ```ts
-// Block secrets from being committed
-git.on("pre-commit", (event) => {
-  const forbidden = event.index.entries.filter((e) => /\.(env|pem|key)$/.test(e.path));
-  if (forbidden.length) {
-    return { abort: true, message: `Blocked: ${forbidden.map((e) => e.path).join(", ")}` };
-  }
-});
-
-// Enforce conventional commit messages
-git.on("commit-msg", (event) => {
-  if (!/^(feat|fix|docs|refactor|test|chore)(\(.+\))?:/.test(event.message)) {
-    return { abort: true, message: "Commit message must follow conventional commits format" };
-  }
-});
+import { createGit, composeGitHooks } from "just-git";
 
-// Feed agent activity to your UI or orchestration layer
-git.on("post-commit", (event) => {
-  onAgentCommit({ hash: event.hash, branch: event.branch, message: event.message });
+const git = createGit({
+  hooks: composeGitHooks(auditHooks, policyHooks, loggingHooks),
 });
 ```
 
-Available pre-hooks: `pre-commit`, `commit-msg`, `merge-msg`, `pre-merge-commit`, `pre-checkout`, `pre-push`, `pre-fetch`, `pre-clone`, `pre-pull`, `pre-rebase`, `pre-reset`, `pre-clean`, `pre-rm`, `pre-cherry-pick`, `pre-revert`, `pre-stash`. Available post-hooks: `post-commit`, `post-merge`, `post-checkout`, `post-push`, `post-fetch`, `post-clone`, `post-pull`, `post-reset`, `post-clean`, `post-rm`, `post-cherry-pick`, `post-revert`, `post-stash`. Low-level events: `ref:update`, `ref:delete`, `object:write`.
-
-See [HOOKS.md](HOOKS.md) for full payload types and the `CommandEvent` shape.
+Available pre-hooks: `preCommit`, `commitMsg`, `mergeMsg`, `preMergeCommit`, `preCheckout`, `prePush`, `preFetch`, `preClone`, `prePull`, `preRebase`, `preReset`, `preClean`, `preRm`, `preCherryPick`, `preRevert`, `preStash`. Available post-hooks: `postCommit`, `postMerge`, `postCheckout`, `postPush`, `postFetch`, `postClone`, `postPull`, `postReset`, `postClean`, `postRm`, `postCherryPick`, `postRevert`, `postStash`. Low-level events: `onRefUpdate`, `onRefDelete`, `onObjectWrite`. Command-level: `beforeCommand`, `afterCommand`.
 
 ## Multi-agent collaboration
 
-Multiple agents can work on clones of the same repository in the same process, each with full VFS isolation. The `resolveRemote` option maps remote URLs to `GitContext` instances on other virtual filesystems, so clone/fetch/push/pull cross VFS boundaries without any network or shared filesystem.
+Multiple agents can work on clones of the same repository in the same process, each with full VFS isolation. The `resolveRemote` option maps remote URLs to `GitRepo` instances (any object/ref store — VFS-backed, SQLite, etc.), so clone/fetch/push/pull cross VFS boundaries without any network or shared filesystem.
 
 ```ts
 import { Bash, InMemoryFs } from "just-bash";
-import { createGit, findGitDir } from "just-git";
+import { createGit, findRepo } from "just-git";
 
 // Origin repo on its own filesystem
 const originFs = new InMemoryFs();
@@ -145,17 +139,13 @@ await setupBash.exec("git init");
 await setupBash.exec("echo 'hello' > README.md");
 await setupBash.exec("git add . && git commit -m 'initial'");
 
-const originCtx = await findGitDir(originFs, "/repo");
-const resolve = (url: string) => (url === "/origin" ? originCtx : null);
-
-// Each agent gets its own filesystem + resolveRemote pointing to origin
 const alice = new Bash({
   fs: new InMemoryFs(),
   cwd: "/repo",
   customCommands: [
     createGit({
       identity: { name: "Alice", email: "alice@example.com", locked: true },
-      resolveRemote: resolve,
+      resolveRemote: () => findRepo(originFs, "/repo"),
     }),
   ],
 });
@@ -166,7 +156,7 @@ const bob = new Bash({
   customCommands: [
     createGit({
       identity: { name: "Bob", email: "bob@example.com", locked: true },
-      resolveRemote: resolve,
+      resolveRemote: () => findRepo(originFs, "/repo"),
     }),
   ],
 });

package/dist/hooks-jTfqkfs1.d.ts

@@ -0,0 +1,480 @@
+interface FileStat {
+    isFile: boolean;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    mode: number;
+    size: number;
+    mtime: Date;
+}
+interface FileSystem {
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    /** Stat without following symlinks. Falls back to stat() semantics when not implemented. */
+    lstat?(path: string): Promise<FileStat>;
+    /** Read the target of a symbolic link. */
+    readlink?(path: string): Promise<string>;
+    /** Create a symbolic link pointing to target at the given path. */
+    symlink?(target: string, path: string): Promise<void>;
+}
+
+/** 40-character lowercase hex SHA-1 hash. */
+type ObjectId = string;
+/** The four Git object types. */
+type ObjectType = "blob" | "tree" | "commit" | "tag";
+/** An object as stored in .git/objects — type + raw content bytes. */
+interface RawObject {
+    type: ObjectType;
+    content: Uint8Array;
+}
+/** Author or committer identity with timestamp. */
+interface Identity {
+    name: string;
+    email: string;
+    /** Unix epoch seconds. */
+    timestamp: number;
+    /** Timezone offset string, e.g. "+0000", "-0500". */
+    timezone: string;
+}
+interface Commit {
+    type: "commit";
+    tree: ObjectId;
+    parents: ObjectId[];
+    author: Identity;
+    committer: Identity;
+    message: string;
+}
+interface SymbolicRef {
+    type: "symbolic";
+    /** The ref path this points to, e.g. "refs/heads/main". */
+    target: string;
+}
+interface DirectRef {
+    type: "direct";
+    hash: ObjectId;
+}
+type Ref = SymbolicRef | DirectRef;
+/** Stat-like metadata stored per index entry. */
+interface IndexStat {
+    ctimeSeconds: number;
+    ctimeNanoseconds: number;
+    mtimeSeconds: number;
+    mtimeNanoseconds: number;
+    dev: number;
+    ino: number;
+    uid: number;
+    gid: number;
+    size: number;
+}
+interface IndexEntry {
+    /** File path relative to the work tree root. */
+    path: string;
+    /** File mode as a numeric value (e.g. 0o100644). */
+    mode: number;
+    /** SHA-1 of the blob content. */
+    hash: ObjectId;
+    /** Merge stage: 0 = normal, 1 = base, 2 = ours, 3 = theirs. */
+    stage: number;
+    stat: IndexStat;
+}
+interface Index {
+    version: number;
+    entries: IndexEntry[];
+}
+interface RefEntry {
+    name: string;
+    hash: ObjectId;
+}
+/**
+ * Abstract ref storage backend.
+ * Implementations handle reading, writing, deleting, and listing git refs.
+ * The default filesystem-backed implementation is `FileSystemRefStore`.
+ */
+interface RefStore {
+    /** Read a single ref without following symbolic refs. */
+    readRef(name: string): Promise<Ref | null>;
+    /** Write a ref (direct or symbolic). */
+    writeRef(name: string, ref: Ref): Promise<void>;
+    /** Delete a ref from storage. */
+    deleteRef(name: string): Promise<void>;
+    /** List all refs under a prefix, returning resolved hashes. */
+    listRefs(prefix?: string): Promise<RefEntry[]>;
+    /**
+     * Atomically update a ref only if its current resolved hash matches
+     * `expectedOldHash`. Returns true on success, false if the ref has
+     * been modified concurrently.
+     *
+     * - `expectedOldHash === null` — create-only: fails if the ref exists.
+     * - `expectedOldHash === "<hash>"` — fails if current hash !== expected.
+     * - `newRef === null` — conditional delete.
+     * - `newRef === Ref` — conditional create/update.
+     */
+    compareAndSwapRef(name: string, expectedOldHash: string | null, newRef: Ref | null): Promise<boolean>;
+}
+/**
+ * Abstract object storage backend.
+ * Implementations handle reading, writing, and querying git objects.
+ * The default filesystem-backed implementation is `PackedObjectStore`.
+ */
+interface ObjectStore {
+    read(hash: ObjectId): Promise<RawObject>;
+    write(type: ObjectType, content: Uint8Array): Promise<ObjectId>;
+    exists(hash: ObjectId): Promise<boolean>;
+    ingestPack(packData: Uint8Array): Promise<number>;
+    /** Return all object hashes matching a hex prefix (for short hash resolution). */
+    findByPrefix(prefix: string): Promise<ObjectId[]>;
+    /**
+     * Signal that pack files on disk have changed externally (e.g. after
+     * repack or gc). Implementations should discard cached pack state
+     * and re-scan on the next read.
+     */
+    invalidatePacks?(): void;
+}
+/**
+ * Minimal repository handle: object store + ref store + hooks.
+ * Sufficient for all pure object/ref operations (read, write, walk,
+ * diff trees, merge-base, blame, etc.) without filesystem access.
+ *
+ * Used directly by the server module and accepted by ~35 lib functions.
+ */
+interface GitRepo {
+    objectStore: ObjectStore;
+    refStore: RefStore;
+    /** Hook callbacks for operation hooks and low-level events. */
+    hooks?: GitHooks;
+}
+/**
+ * Resolves a remote URL to a GitRepo, enabling cross-VFS transport.
+ * Called before local filesystem lookup for non-HTTP URLs.
+ * Return null to fall back to local filesystem resolution.
+ */
+type RemoteResolver = (url: string) => GitRepo | null | Promise<GitRepo | null>;
+/**
+ * Full repository context including filesystem access.
+ * Extends `GitRepo` with the filesystem handle, resolved paths,
+ * and operator-level extensions (credentials, identity, network).
+ *
+ * Threaded through command handlers and lib functions that need
+ * worktree/index/config/reflog access.
+ */
+interface GitContext extends GitRepo {
+    fs: FileSystem;
+    /** Absolute path to the .git directory. */
+    gitDir: string;
+    /** Absolute path to the working tree root, or null for bare repos. */
+    workTree: string | null;
+    /** Operator-provided credential resolver (bypasses env vars). */
+    credentialProvider?: CredentialProvider;
+    /** Operator-provided identity override for author/committer. */
+    identityOverride?: IdentityOverride;
+    /** Custom fetch function for HTTP transport. Falls back to globalThis.fetch. */
+    fetchFn?: FetchFunction;
+    /** Network access policy. `false` blocks all HTTP access. */
+    networkPolicy?: NetworkPolicy | false;
+    /** Resolves remote URLs to GitRepos on potentially different VFS instances. */
+    resolveRemote?: RemoteResolver;
+}
+type DiffStatus = "added" | "deleted" | "modified";
+interface TreeDiffEntry {
+    path: string;
+    status: DiffStatus;
+    /** Hash in tree A (undefined if added). */
+    oldHash?: ObjectId;
+    /** Hash in tree B (undefined if deleted). */
+    newHash?: ObjectId;
+    oldMode?: string;
+    newMode?: string;
+}
+
+type HttpAuth = {
+    type: "basic";
+    username: string;
+    password: string;
+} | {
+    type: "bearer";
+    token: string;
+};
+
+interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+
+type CredentialProvider = (url: string) => HttpAuth | null | Promise<HttpAuth | null>;
+interface IdentityOverride {
+    name: string;
+    email: string;
+    locked?: boolean;
+}
+type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface NetworkPolicy {
+    /**
+     * Allowed URL patterns. Can be:
+     * - A hostname: "github.com" (matches any URL whose host equals this)
+     * - A URL prefix: "https://github.com/myorg/" (matches URLs starting with this)
+     */
+    allowed?: string[];
+    /** Custom fetch function for HTTP transport. Falls back to globalThis.fetch. */
+    fetch?: FetchFunction;
+}
+interface Rejection {
+    reject: true;
+    message?: string;
+}
+declare function isRejection(value: unknown): value is Rejection;
+interface PreCommitEvent {
+    readonly repo: GitRepo;
+    readonly index: Index;
+    readonly treeHash: ObjectId;
+}
+interface CommitMsgEvent {
+    readonly repo: GitRepo;
+    message: string;
+}
+interface MergeMsgEvent {
+    readonly repo: GitRepo;
+    message: string;
+    readonly treeHash: ObjectId;
+    readonly headHash: ObjectId;
+    readonly theirsHash: ObjectId;
+}
+interface PostCommitEvent {
+    readonly repo: GitRepo;
+    readonly hash: ObjectId;
+    readonly message: string;
+    readonly branch: string | null;
+    readonly parents: readonly ObjectId[];
+    readonly author: Identity;
+}
+interface PreMergeCommitEvent {
+    readonly repo: GitRepo;
+    readonly mergeMessage: string;
+    readonly treeHash: ObjectId;
+    readonly headHash: ObjectId;
+    readonly theirsHash: ObjectId;
+}
+interface PostMergeEvent {
+    readonly repo: GitRepo;
+    readonly headHash: ObjectId;
+    readonly theirsHash: ObjectId;
+    readonly strategy: "fast-forward" | "three-way";
+    readonly commitHash: ObjectId | null;
+}
+interface PostCheckoutEvent {
+    readonly repo: GitRepo;
+    readonly prevHead: ObjectId | null;
+    readonly newHead: ObjectId;
+    readonly isBranchCheckout: boolean;
+}
+interface PrePushEvent {
+    readonly repo: GitRepo;
+    readonly remote: string;
+    readonly url: string;
+    readonly refs: ReadonlyArray<{
+        srcRef: string | null;
+        srcHash: ObjectId | null;
+        dstRef: string;
+        dstHash: ObjectId | null;
+        force: boolean;
+        delete: boolean;
+    }>;
+}
+type PostPushEvent = PrePushEvent;
+interface PreRebaseEvent {
+    readonly repo: GitRepo;
+    readonly upstream: string;
+    readonly branch: string | null;
+}
+interface PreCheckoutEvent {
+    readonly repo: GitRepo;
+    readonly target: string;
+    readonly mode: "switch" | "detach" | "create-branch" | "paths";
+}
+interface PreFetchEvent {
+    readonly repo: GitRepo;
+    readonly remote: string;
+    readonly url: string;
+    readonly refspecs: readonly string[];
+    readonly prune: boolean;
+    readonly tags: boolean;
+}
+interface PostFetchEvent {
+    readonly repo: GitRepo;
+    readonly remote: string;
+    readonly url: string;
+    readonly refsUpdated: number;
+}
+interface PreCloneEvent {
+    readonly repo?: GitRepo;
+    readonly repository: string;
+    readonly targetPath: string;
+    readonly bare: boolean;
+    readonly branch: string | null;
+}
+interface PostCloneEvent {
+    readonly repo: GitRepo;
+    readonly repository: string;
+    readonly targetPath: string;
+    readonly bare: boolean;
+    readonly branch: string | null;
+}
+interface PrePullEvent {
+    readonly repo: GitRepo;
+    readonly remote: string;
+    readonly branch: string | null;
+}
+interface PostPullEvent {
+    readonly repo: GitRepo;
+    readonly remote: string;
+    readonly branch: string | null;
+    readonly strategy: "up-to-date" | "fast-forward" | "three-way";
+    readonly commitHash: ObjectId | null;
+}
+interface PreResetEvent {
+    readonly repo: GitRepo;
+    readonly mode: "soft" | "mixed" | "hard" | "paths";
+    readonly target: string | null;
+}
+interface PostResetEvent {
+    readonly repo: GitRepo;
+    readonly mode: "soft" | "mixed" | "hard" | "paths";
+    readonly targetHash: ObjectId | null;
+}
+interface PreCleanEvent {
+    readonly repo: GitRepo;
+    readonly dryRun: boolean;
+    readonly force: boolean;
+    readonly removeDirs: boolean;
+    readonly removeIgnored: boolean;
+    readonly onlyIgnored: boolean;
+}
+interface PostCleanEvent {
+    readonly repo: GitRepo;
+    readonly removed: readonly string[];
+    readonly dryRun: boolean;
+}
+interface PreRmEvent {
+    readonly repo: GitRepo;
+    readonly paths: readonly string[];
+    readonly cached: boolean;
+    readonly recursive: boolean;
+    readonly force: boolean;
+}
+interface PostRmEvent {
+    readonly repo: GitRepo;
+    readonly removedPaths: readonly string[];
+    readonly cached: boolean;
+}
+interface PreCherryPickEvent {
+    readonly repo: GitRepo;
+    readonly mode: "pick" | "continue" | "abort";
+    readonly commit: string | null;
+}
+interface PostCherryPickEvent {
+    readonly repo: GitRepo;
+    readonly mode: "pick" | "continue" | "abort";
+    readonly commitHash: ObjectId | null;
+    readonly hadConflicts: boolean;
+}
+interface PreRevertEvent {
+    readonly repo: GitRepo;
+    readonly mode: "revert" | "continue" | "abort";
+    readonly commit: string | null;
+}
+interface PostRevertEvent {
+    readonly repo: GitRepo;
+    readonly mode: "revert" | "continue" | "abort";
+    readonly commitHash: ObjectId | null;
+    readonly hadConflicts: boolean;
+}
+interface PreStashEvent {
+    readonly repo: GitRepo;
+    readonly action: "push" | "pop" | "apply" | "list" | "drop" | "show" | "clear";
+    readonly ref: string | null;
+}
+interface PostStashEvent {
+    readonly repo: GitRepo;
+    readonly action: "push" | "pop" | "apply" | "list" | "drop" | "show" | "clear";
+    readonly ok: boolean;
+}
+interface RefUpdateEvent {
+    readonly repo: GitRepo;
+    readonly ref: string;
+    readonly oldHash: ObjectId | null;
+    readonly newHash: ObjectId;
+}
+interface RefDeleteEvent {
+    readonly repo: GitRepo;
+    readonly ref: string;
+    readonly oldHash: ObjectId | null;
+}
+interface ObjectWriteEvent {
+    readonly repo: GitRepo;
+    readonly type: ObjectType;
+    readonly hash: ObjectId;
+}
+
+interface BeforeCommandEvent {
+    readonly command: string;
+    readonly args: string[];
+    readonly fs: FileSystem;
+    readonly cwd: string;
+    readonly env: Map<string, string>;
+}
+interface AfterCommandEvent {
+    readonly command: string;
+    readonly args: string[];
+    readonly result: ExecResult;
+}
+type PreHookReturn = void | Rejection | Promise<void | Rejection>;
+type PostHookReturn = void | Promise<void>;
+interface GitHooks {
+    preCommit?: (event: PreCommitEvent) => PreHookReturn;
+    commitMsg?: (event: CommitMsgEvent) => PreHookReturn;
+    mergeMsg?: (event: MergeMsgEvent) => PreHookReturn;
+    preMergeCommit?: (event: PreMergeCommitEvent) => PreHookReturn;
+    preCheckout?: (event: PreCheckoutEvent) => PreHookReturn;
+    prePush?: (event: PrePushEvent) => PreHookReturn;
+    preFetch?: (event: PreFetchEvent) => PreHookReturn;
+    preClone?: (event: PreCloneEvent) => PreHookReturn;
+    prePull?: (event: PrePullEvent) => PreHookReturn;
+    preRebase?: (event: PreRebaseEvent) => PreHookReturn;
+    preReset?: (event: PreResetEvent) => PreHookReturn;
+    preClean?: (event: PreCleanEvent) => PreHookReturn;
+    preRm?: (event: PreRmEvent) => PreHookReturn;
+    preCherryPick?: (event: PreCherryPickEvent) => PreHookReturn;
+    preRevert?: (event: PreRevertEvent) => PreHookReturn;
+    preStash?: (event: PreStashEvent) => PreHookReturn;
+    postCommit?: (event: PostCommitEvent) => PostHookReturn;
+    postMerge?: (event: PostMergeEvent) => PostHookReturn;
+    postCheckout?: (event: PostCheckoutEvent) => PostHookReturn;
+    postPush?: (event: PostPushEvent) => PostHookReturn;
+    postFetch?: (event: PostFetchEvent) => PostHookReturn;
+    postClone?: (event: PostCloneEvent) => PostHookReturn;
+    postPull?: (event: PostPullEvent) => PostHookReturn;
+    postReset?: (event: PostResetEvent) => PostHookReturn;
+    postClean?: (event: PostCleanEvent) => PostHookReturn;
+    postRm?: (event: PostRmEvent) => PostHookReturn;
+    postCherryPick?: (event: PostCherryPickEvent) => PostHookReturn;
+    postRevert?: (event: PostRevertEvent) => PostHookReturn;
+    postStash?: (event: PostStashEvent) => PostHookReturn;
+    onRefUpdate?: (event: RefUpdateEvent) => void;
+    onRefDelete?: (event: RefDeleteEvent) => void;
+    onObjectWrite?: (event: ObjectWriteEvent) => void;
+    beforeCommand?: (event: BeforeCommandEvent) => PreHookReturn;
+    afterCommand?: (event: AfterCommandEvent) => PostHookReturn;
+}
+declare function composeGitHooks(...hookSets: (GitHooks | undefined)[]): GitHooks;
+
+export { type Commit as $, type AfterCommandEvent as A, type BeforeCommandEvent as B, type CredentialProvider as C, type PrePullEvent as D, type ExecResult as E, type FileSystem as F, type GitHooks as G, type HttpAuth as H, type IdentityOverride as I, type PrePushEvent as J, type PreRebaseEvent as K, type PreResetEvent as L, type MergeMsgEvent as M, type NetworkPolicy as N, type ObjectStore as O, type PostCheckoutEvent as P, type PreRevertEvent as Q, type RemoteResolver as R, type PreRmEvent as S, type PreStashEvent as T, type RefDeleteEvent as U, type RefEntry as V, type RefUpdateEvent as W, type Rejection as X, composeGitHooks as Y, isRejection as Z, type ObjectId as _, type RefStore as a, type Identity as a0, type TreeDiffEntry as a1, type ObjectType as a2, type RawObject as a3, type Ref as a4, type FetchFunction as b, type GitContext as c, type CommitMsgEvent as d, type FileStat as e, type GitRepo as f, type ObjectWriteEvent as g, type PostCherryPickEvent as h, type PostCleanEvent as i, type PostCloneEvent as j, type PostCommitEvent as k, type PostFetchEvent as l, type PostMergeEvent as m, type PostPullEvent as n, type PostPushEvent as o, type PostResetEvent as p, type PostRevertEvent as q, type PostRmEvent as r, type PostStashEvent as s, type PreCheckoutEvent as t, type PreCherryPickEvent as u, type PreCleanEvent as v, type PreCloneEvent as w, type PreCommitEvent as x, type PreFetchEvent as y, type PreMergeCommitEvent as z };