@omgbase/git-adapter 0.0.0-stage → 0.1.0

package/dist/src/git.js

@@ -0,0 +1,356 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+export class GitError extends Error {
+    args;
+    status;
+    stderr;
+    constructor(args, status, stderr) {
+        super(`git ${args.join(" ")} exited ${status}: ${stderr.trim()}`);
+        this.args = args;
+        this.status = status;
+        this.stderr = stderr;
+        this.name = "GitError";
+    }
+}
+/** The git executable: `git` on PATH, or what `OMGBASE_GIT_BIN` names (a host pinning one git; the tests pointing at a missing one). The Rust twin honours the same variable. */
+export const GIT_BIN_ENV = "OMGBASE_GIT_BIN";
+export function gitBin() {
+    const v = process.env[GIT_BIN_ENV];
+    return v !== undefined && v.trim() !== "" ? v.trim() : "git";
+}
+export const ZERO_SHA = "0".repeat(40);
+/** The empty tree's sha (git's well-known constant for the SHA-1 object format). */
+export const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+export const SHA_RE = /^[0-9a-f]{40}$/;
+/** `ts` (RFC 3339) as git's raw date `@<seconds> +0000`. */
+export function gitDate(ts) {
+    const ms = Date.parse(ts);
+    if (Number.isNaN(ms))
+        throw new Error(`not an RFC 3339 instant: ${ts}`);
+    return `@${Math.floor(ms / 1000)} +0000`;
+}
+/** Is `git` on PATH? The version line, or the reason it is not. Probed once per process. */
+let probed = null;
+export function gitAvailable() {
+    if (probed)
+        return probed;
+    const r = spawnSync(gitBin(), ["--version"], { encoding: "utf8", env: baseEnv(null) });
+    if (r.error)
+        probed = { ok: false, reason: `${gitBin()} is not on PATH (${r.error.code ?? r.error.message})` };
+    else if (r.status !== 0)
+        probed = { ok: false, reason: `git --version exited ${r.status}: ${(r.stderr ?? "").trim()}` };
+    else
+        probed = { ok: true, detail: (r.stdout ?? "").trim() };
+    return probed;
+}
+/** Tests: forget the probe's answer. */
+export function resetGitProbe() {
+    probed = null;
+}
+function baseEnv(gitDir) {
+    const env = {
+        PATH: process.env.PATH,
+        GIT_CONFIG_NOSYSTEM: "1",
+        GIT_CONFIG_GLOBAL: "/dev/null",
+        GIT_ATTR_NOSYSTEM: "1",
+        GIT_TERMINAL_PROMPT: "0",
+        LC_ALL: "C",
+        TZ: "UTC",
+    };
+    if (gitDir !== null)
+        env.GIT_DIR = gitDir;
+    return env;
+}
+/** A bare repository at `gitDir`, driven through the plumbing. */
+export class GitRepo {
+    gitDir;
+    constructor(gitDir) {
+        this.gitDir = gitDir;
+    }
+    /** Does the bare repository exist (its `HEAD` file)? */
+    exists() {
+        return existsSync(join(this.gitDir, "HEAD"));
+    }
+    /** `git init --bare -b <branch>` (idempotent: an existing repository is left as it is). */
+    init(branch) {
+        if (this.exists())
+            return;
+        mkdirSync(this.gitDir, { recursive: true });
+        // `--initial-branch` so no `init.defaultBranch` setting (which we never read) decides the name.
+        this.run(["init", "--quiet", "--bare", "--initial-branch", branch, this.gitDir], { noGitDir: true });
+    }
+    /** Delete the bare repository. */
+    remove() {
+        if (!existsSync(this.gitDir))
+            return false;
+        rmSync(this.gitDir, { recursive: true, force: true });
+        return true;
+    }
+    run(args, opts = {}) {
+        const env = { ...baseEnv(opts.noGitDir ? null : this.gitDir), ...(opts.env ?? {}) };
+        const r = spawnSync(gitBin(), args, { env, input: opts.input, maxBuffer: 256 << 20 });
+        if (r.error)
+            throw r.error;
+        const status = r.status ?? -1;
+        const stderr = r.stderr ? r.stderr.toString("utf8") : "";
+        if (status !== 0 && !opts.allowFailure)
+            throw new GitError(args, status, stderr);
+        return { status, stdout: r.stdout ?? Buffer.alloc(0), stderr };
+    }
+    text(args, opts = {}) {
+        return this.run(args, opts).stdout.toString("utf8");
+    }
+    /** The branch tip, or null when the ref does not exist. */
+    tip(branch) {
+        const r = this.run(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], { allowFailure: true });
+        if (r.status !== 0)
+            return null;
+        const sha = r.stdout.toString("utf8").trim();
+        return SHA_RE.test(sha) ? sha : null;
+    }
+    /** `git hash-object -w --stdin`: the blob's sha. */
+    writeBlob(bytes) {
+        return this.text(["hash-object", "-w", "--stdin"], { input: bytes }).trim();
+    }
+    /**
+     * Build a tree: the parent commit's tree (or empty) read into a temporary
+     * index, `update-index --index-info` with the adds (`100644 blob <sha>\t<path>`)
+     * and removes (`0 <zeros>\t<path>`), `write-tree`. Returns the tree sha. The
+     * index file lives inside the bare repository and is removed afterwards.
+     */
+    buildTree(baseTree, adds, removes) {
+        const index = join(this.gitDir, `omgbase-index-${process.pid}.tmp`);
+        const env = { GIT_INDEX_FILE: index };
+        try {
+            if (baseTree === null)
+                this.run(["read-tree", "--empty"], { env });
+            else
+                this.run(["read-tree", baseTree], { env });
+            const lines = [];
+            for (const p of removes)
+                lines.push(`0 ${ZERO_SHA}\t${p}`);
+            for (const a of adds)
+                lines.push(`100644 blob ${a.blob}\t${a.path}`);
+            if (lines.length > 0)
+                this.run(["update-index", "--index-info"], { env, input: lines.join("\n") + "\n" });
+            return this.text(["write-tree"], { env }).trim();
+        }
+        finally {
+            rmSync(index, { force: true });
+        }
+    }
+    /** The tree a commit points at. */
+    treeOf(commit) {
+        return this.text(["rev-parse", `${commit}^{tree}`]).trim();
+    }
+    /** `git commit-tree` with the message on stdin and the identities/dates in the environment; the commit sha. `parent` may be several (a merge commit, 17.6). */
+    commitTree(tree, parent, message, id) {
+        const date = gitDate(id.ts);
+        const env = {
+            GIT_AUTHOR_NAME: id.author.name, GIT_AUTHOR_EMAIL: id.author.email, GIT_AUTHOR_DATE: date,
+            GIT_COMMITTER_NAME: id.committer.name, GIT_COMMITTER_EMAIL: id.committer.email, GIT_COMMITTER_DATE: date,
+        };
+        const parents = parent === null ? [] : Array.isArray(parent) ? parent : [parent];
+        const args = ["commit-tree", tree, ...parents.flatMap((p) => ["-p", p]), "-F", "-"];
+        return this.text(args, { env, input: message }).trim();
+    }
+    /** `git update-ref` with the old value as the compare-and-swap (`ZERO_SHA` = the ref must not exist). */
+    updateRef(branch, newSha, oldSha) {
+        this.updateRefRaw(`refs/heads/${branch}`, newSha, oldSha);
+    }
+    // ---- refs, ancestry and trees (17.6, the remote half) ----
+    /** `git update-ref <ref> <new> <old>` on any full ref name (the ids ref, the remote-tracking and bookkeeping refs). */
+    updateRefRaw(ref, newSha, oldSha) {
+        this.run(["update-ref", ref, newSha, oldSha ?? ZERO_SHA]);
+    }
+    /** `git update-ref <ref> <new>` without a compare-and-swap (a tracking or bookkeeping ref that mirrors something else). */
+    setRef(ref, sha) {
+        this.run(["update-ref", ref, sha]);
+    }
+    /** The author of a commit: `%an` and `%ae`. */
+    authorOf(commit) {
+        const [name, email] = this.text(["log", "-1", "--format=%an%x1f%ae", commit]).trim().split("\x1f");
+        return { name: name ?? "", email: email ?? "" };
+    }
+    /** `git update-ref -d <ref>`; a missing ref is fine. */
+    deleteRef(ref) {
+        this.run(["update-ref", "-d", ref], { allowFailure: true });
+    }
+    /** The sha a full ref name points at, or null when it does not exist. */
+    ref(ref) {
+        const r = this.run(["rev-parse", "--verify", "--quiet", ref], { allowFailure: true });
+        if (r.status !== 0)
+            return null;
+        const sha = r.stdout.toString("utf8").trim();
+        return SHA_RE.test(sha) ? sha : null;
+    }
+    /** Is `ancestor` an ancestor of (or equal to) `descendant`? (`git merge-base --is-ancestor`.) */
+    isAncestor(ancestor, descendant) {
+        return this.run(["merge-base", "--is-ancestor", ancestor, descendant], { allowFailure: true }).status === 0;
+    }
+    /** `git merge-base a b`, or null when the histories are unrelated. */
+    mergeBase(a, b) {
+        const r = this.run(["merge-base", a, b], { allowFailure: true });
+        if (r.status !== 0)
+            return null;
+        const sha = r.stdout.toString("utf8").trim();
+        return SHA_RE.test(sha) ? sha : null;
+    }
+    /** The commits reachable from `to` and not from `from`, oldest first (`git rev-list --reverse from..to`; `from` null = all of `to`). */
+    revList(from, to) {
+        const range = from === null ? to : `${from}..${to}`;
+        return this.text(["rev-list", "--reverse", range]).split("\n").map((l) => l.trim()).filter((l) => SHA_RE.test(l));
+    }
+    /** The parents of a commit. */
+    parentsOf(commit) {
+        return this.text(["rev-list", "--parents", "-n", "1", commit]).trim().split(/\s+/).slice(1).filter((p) => SHA_RE.test(p));
+    }
+    /** A tree-ish's blobs: `path → blob sha` (`git ls-tree -r`; only blobs — the content branch holds nothing else). */
+    treeEntries(treeish) {
+        const out = new Map();
+        if (treeish === EMPTY_TREE)
+            return out;
+        for (const line of this.text(["ls-tree", "-r", "-z", treeish]).split("\0")) {
+            if (line === "")
+                continue;
+            const m = /^(\d{6}) (\w+) ([0-9a-f]{40})\t(.*)$/s.exec(line);
+            if (m && m[2] === "blob")
+                out.set(m[4], m[3]);
+        }
+        return out;
+    }
+    /** The paths whose blob differs between two tree-ishes: `path → the blob in b` (null = gone in b). `git diff-tree -r`. */
+    diffTrees(a, b) {
+        const out = new Map();
+        // The -z form interleaves `:<mode a> <mode b> <sha a> <sha b> <status>` and `<path>` records; parse pairwise.
+        const records = this.text(["diff-tree", "-r", "-z", "--no-renames", a, b]).split("\0");
+        for (let i = 0; i + 1 < records.length; i += 2) {
+            const meta = records[i];
+            const path = records[i + 1];
+            const m = /^:(\d{6}) (\d{6}) ([0-9a-f]{40}) ([0-9a-f]{40}) ([ADMT])/.exec(meta);
+            if (!m)
+                continue;
+            out.set(path, m[5] === "D" ? null : m[4]);
+        }
+        return out;
+    }
+    /** A blob's bytes. */
+    blob(sha) {
+        return this.run(["cat-file", "blob", sha]).stdout;
+    }
+    /** The configured remotes (`git remote`). */
+    remotes() {
+        return this.text(["remote"]).split("\n").map((l) => l.trim()).filter((l) => l !== "");
+    }
+    /** `git remote add` or `set-url` so that `name` points at `url`; `remote.<name>.fetch` left as git sets it (the tracking refs under `refs/remotes/<name>/`). */
+    setRemote(name, url) {
+        if (this.remotes().includes(name))
+            this.run(["remote", "set-url", name, url]);
+        else
+            this.run(["remote", "add", name, url]);
+    }
+    /** `git remote remove`; a missing remote is fine. */
+    removeRemote(name) {
+        this.run(["remote", "remove", name], { allowFailure: true });
+    }
+    /**
+     * `git push <remote> <refspec>…` — NEVER `--force`. Returns `ok`, or `rejected`
+     * when the remote refused a non-fast-forward (git's `[rejected]` /
+     * `non-fast-forward` / `fetch first` / `stale info` lines), or `failed` with
+     * git's stderr for anything else (no network, no such remote).
+     */
+    push(remote, refspecs) {
+        const r = this.run(["push", "--porcelain", "--quiet", remote, ...refspecs], { allowFailure: true });
+        if (r.status === 0)
+            return { status: "ok" };
+        const text = `${r.stdout.toString("utf8")}\n${r.stderr}`;
+        if (/\[rejected\]|non-fast-forward|fetch first|stale info|\n!\t/.test(text))
+            return { status: "rejected", stderr: r.stderr.trim() };
+        return { status: "failed", stderr: r.stderr.trim() };
+    }
+    /** `git fetch <remote> <refspec>…` (the refspecs may carry `+`: a tracking ref follows the remote wherever it went). Returns null on success, git's stderr on failure. */
+    fetch(remote, refspecs) {
+        const r = this.run(["fetch", "--quiet", "--no-tags", remote, ...refspecs], { allowFailure: true });
+        return r.status === 0 ? null : r.stderr.trim();
+    }
+    /** `git ls-remote <remote> <ref>`: the sha the remote holds for `ref`, null when it has none; throws when the remote cannot be reached. */
+    lsRemote(remote, ref) {
+        const out = this.text(["ls-remote", remote, ref]);
+        const m = /^([0-9a-f]{40})\t/.exec(out);
+        return m ? m[1] : null;
+    }
+    /** The type of an object (`commit`, `blob`, `tree`, `tag`), or null when the object is missing. */
+    objectType(sha) {
+        const r = this.run(["cat-file", "-t", sha], { allowFailure: true });
+        return r.status === 0 ? r.stdout.toString("utf8").trim() : null;
+    }
+    /** A commit's raw message (`%B`). */
+    message(commit) {
+        return this.text(["log", "-1", "--format=%B", commit]);
+    }
+    /**
+     * The commits of `branch`, oldest first, each as `{ sha, committerUnix, message }`;
+     * `grep` (fixed string) narrows to the commits whose message contains it.
+     */
+    log(branch, opts = {}) {
+        if (this.tip(branch) === null)
+            return [];
+        const filter = opts.grep !== undefined ? ["--fixed-strings", `--grep=${opts.grep}`] : opts.regex !== undefined ? ["--extended-regexp", `--grep=${opts.regex}`] : [];
+        const args = ["log", "--reverse", "--format=%H%x1f%ct%x1f%B%x1e", ...filter, `refs/heads/${branch}`];
+        const out = this.text(args);
+        const records = out.split("\x1e").map((r) => r.replace(/^\n/, "")).filter((r) => r.trim() !== "");
+        return records.map((r) => {
+            const [sha, unix, message] = r.split("\x1f");
+            return { sha: sha.trim(), committerUnix: Number(unix), message: message ?? "" };
+        });
+    }
+    /**
+     * `git cat-file --batch` over `<commit>:<path>` specs: the bytes of each, or
+     * null when the object is missing (a path not in that tree). One spawn.
+     */
+    blobsAt(specs) {
+        if (specs.length === 0)
+            return [];
+        const out = this.run(["cat-file", "--batch"], { input: specs.join("\n") + "\n" }).stdout;
+        const result = [];
+        let pos = 0;
+        for (let i = 0; i < specs.length; i++) {
+            const nl = out.indexOf(0x0a, pos);
+            if (nl < 0) {
+                result.push(null);
+                continue;
+            }
+            const header = out.subarray(pos, nl).toString("utf8");
+            pos = nl + 1;
+            const m = /^([0-9a-f]{40}) (\w+) (\d+)$/.exec(header);
+            if (!m) {
+                result.push(null);
+                continue;
+            } // `<spec> missing` / `ambiguous`
+            const size = Number(m[3]);
+            result.push(Buffer.from(out.subarray(pos, pos + size)));
+            pos += size + 1; // the trailing newline after the content
+        }
+        return result;
+    }
+    /** `git ls-tree -r <ref>` as text (the fixtures' projection). */
+    lsTree(ref) {
+        return this.text(["ls-tree", "-r", ref]);
+    }
+    /** `git count-objects -v` as a map (the measurement script's `size`/`size-pack`, in KiB). */
+    countObjects() {
+        const out = {};
+        for (const line of this.text(["count-objects", "-v"]).split("\n")) {
+            const m = /^([a-z-]+): (\d+)$/.exec(line.trim());
+            if (m)
+                out[m[1]] = Number(m[2]);
+        }
+        return out;
+    }
+    /** `git gc --quiet` (the measurement script packs before counting). */
+    gc() {
+        this.run(["gc", "--quiet"]);
+    }
+}
+//# sourceMappingURL=git.js.map

package/dist/src/ids.d.ts

@@ -0,0 +1,48 @@
+import type { Store } from "@omgbase/core";
+import type { GitRepo, GitIdentity } from "./git.js";
+import type { GitHistoryConfig } from "./config.js";
+export declare const IDS_PREFIX = ".omgbase/ids/";
+export interface IdsBlock {
+    id: string;
+    parent: string | null;
+    ordinal: number;
+    hash: string;
+}
+export interface IdsRecord {
+    doc: string;
+    head: string;
+    blocks: IdsBlock[];
+}
+/** The id map of a live document from the rows, or null for a deleted/unknown one. */
+export declare function idsRecord(store: Store, docId: string): IdsRecord | null;
+/** The blob's bytes: canonical JSON (keys sorted bytewise at every level, as the manifest's `config`) and a final newline. */
+export declare function idsBlobText(record: IdsRecord): string;
+export declare const idsPath: (docId: string) => string;
+/** The ids tip's `omgbase-seq` position, or null without a tip or with a foreign one. */
+export declare function idsPosition(git: GitRepo, config: GitHistoryConfig): {
+    tip: string;
+    epoch: string;
+    seq: number;
+} | null;
+export interface IdsSyncInput {
+    store: Store;
+    repoId: string;
+    git: GitRepo;
+    config: GitHistoryConfig;
+    identity: GitIdentity;
+    /** the documents a checkpoint touched (deleted ones included — their blob leaves the tree); null = every live document (a catch-up or a snapshot) */
+    docs: string[] | null;
+    epoch: string;
+    from: number;
+    to: number;
+    ts: string;
+    /** the content commit this ids commit belongs to */
+    content: string;
+    actor: string | null;
+}
+/**
+ * Write one ids commit for a checkpoint when the ids tree changed; returns the
+ * ids tip (unchanged when nothing moved). Never fails the checkpoint that
+ * called it beyond a thrown git error: the content ref already moved.
+ */
+export declare function syncIds(input: IdsSyncInput): string | null;

package/dist/src/ids.js

@@ -0,0 +1,84 @@
+import { canonicalConfigJson } from "@omgbase/core";
+import { parseMessage, renderMessage } from "./trailers.js";
+// The identity record (spec/store §5.12 "The identity record", 17.6 — the
+// design's option 3, second half): beside the content branch — a plain notes
+// repository a customer can clone — the worker keeps a PARALLEL commit chain on
+// `refs/omgbase/ids` (`config.ids_ref`) whose tree holds one blob per live
+// document at `.omgbase/ids/<doc_id>`: canonical JSON
+// `{ doc, head, blocks: [{ id, parent, ordinal, hash }] }` — the document's id
+// and head token, its blocks in pre-order with their ids, parent ids (null at
+// the top level), sibling ordinals and `raw_hash` (hex). Each ids commit
+// carries the same `omgbase-seq` trailer as the checkpoint it belongs to and
+// `omgbase-content: <content commit sha>` naming the content tip at that
+// moment; its tree is the previous ids tree plus the touched documents' blobs
+// (a deleted document's blob removed). Push and fetch carry the ref, so a
+// clone of BOTH refs recovers content and identities; restoration from it is
+// 6c. The chain is written AFTER the content ref moved (its own CAS), and
+// catches up on resume: an ids tip whose `omgbase-seq` is behind the content
+// tip's re-stages every live document once.
+export const IDS_PREFIX = ".omgbase/ids/";
+/** The id map of a live document from the rows, or null for a deleted/unknown one. */
+export function idsRecord(store, docId) {
+    const doc = store.db.prepare("SELECT head, deleted_at FROM docs WHERE doc_id = ?").get(docId);
+    if (!doc || doc.deleted_at !== null || doc.head === null)
+        return null;
+    const rows = store.db
+        .prepare("SELECT block_id, parent_block, ordinal, raw_hash FROM blocks WHERE doc_id = ? AND deleted_at IS NULL ORDER BY order_key")
+        .all(docId);
+    return { doc: docId, head: doc.head, blocks: rows.map((r) => ({ id: r.block_id, parent: r.parent_block, ordinal: r.ordinal, hash: r.raw_hash.toString("hex") })) };
+}
+/** The blob's bytes: canonical JSON (keys sorted bytewise at every level, as the manifest's `config`) and a final newline. */
+export function idsBlobText(record) {
+    return `${canonicalConfigJson(record)}\n`;
+}
+export const idsPath = (docId) => `${IDS_PREFIX}${docId}`;
+/** The ids tip's `omgbase-seq` position, or null without a tip or with a foreign one. */
+export function idsPosition(git, config) {
+    const tip = git.ref(config.ids_ref);
+    if (tip === null)
+        return null;
+    const t = parseMessage(git.message(tip));
+    return t ? { tip, epoch: t.epoch, seq: t.to } : null;
+}
+/**
+ * Write one ids commit for a checkpoint when the ids tree changed; returns the
+ * ids tip (unchanged when nothing moved). Never fails the checkpoint that
+ * called it beyond a thrown git error: the content ref already moved.
+ */
+export function syncIds(input) {
+    const { store, git, config } = input;
+    const parent = git.ref(config.ids_ref);
+    const baseTree = parent === null ? null : git.treeOf(parent);
+    const live = new Set(store.db.prepare("SELECT doc_id FROM docs WHERE repo_id = ? AND deleted_at IS NULL AND head IS NOT NULL").all(input.repoId).map((r) => r.doc_id));
+    const existing = baseTree === null ? new Map() : git.treeEntries(baseTree);
+    const docs = input.docs ?? [...live];
+    const adds = [];
+    const removes = [];
+    for (const docId of [...new Set(docs)].sort()) {
+        const path = idsPath(docId);
+        const record = live.has(docId) ? idsRecord(store, docId) : null;
+        if (record === null) {
+            if (existing.has(path))
+                removes.push(path);
+            continue;
+        }
+        const blob = git.writeBlob(idsBlobText(record));
+        if (existing.get(path) !== blob)
+            adds.push({ path, blob });
+    }
+    if (input.docs === null)
+        for (const path of existing.keys())
+            if (path.startsWith(IDS_PREFIX) && !live.has(path.slice(IDS_PREFIX.length)))
+                removes.push(path);
+    if (adds.length === 0 && removes.length === 0)
+        return parent;
+    const tree = git.buildTree(baseTree, adds, removes);
+    if (baseTree !== null && tree === baseTree)
+        return parent;
+    const trailers = { epoch: input.epoch, from: input.from, to: input.to, ts: input.ts, commits: [], origin: null, actor: input.actor, plan: null, docs: [], rescan: null, merge: null, content: input.content };
+    const subject = `ids: ${adds.length + removes.length} document(s)`;
+    const sha = git.commitTree(tree, parent, renderMessage(subject, trailers), { author: { name: input.actor ?? input.identity.name, email: input.identity.email }, committer: input.identity, ts: input.ts });
+    git.updateRefRaw(config.ids_ref, sha, parent);
+    return sha;
+}
+//# sourceMappingURL=ids.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export { GitHistoryProvider, gitHistoryProvider, DEFAULT_IDENTITY, FIXTURE_IDENTITY, type GitProviderOptions } from "./provider.js";
+export { GitHistoryReader } from "./reader.js";
+export { runCheckpoint, commitSnapshot, tipPosition, resumePosition, type WorkerContext } from "./worker.js";
+export { idsRecord, idsBlobText, idsPath, idsPosition, syncIds, IDS_PREFIX, type IdsRecord, type IdsBlock } from "./ids.js";
+export { remoteSet, remoteUnset, remoteStatus, remoteSummary, pushBranch, fetchRemote, resolveConflict, reconcileRemote, remoteSync, pushAfterCheckpoint, pausedBy, sidecarPath, tsSegment, rejectedMessage, rewrittenMessage, conflictMessage, forkedMessage, GIT_REMOTE_DIVERGED_ALERT, GIT_MERGE_CONFLICT_ALERT, GIT_REMOTE_FORKED_ALERT, type RemoteStatus, type FetchResult, type FetchState, type ResolveResult, type ResolveChoice, type ReconcileResult, type ReconcileMode, } from "./remote.js";
+export { createCheckpointScheduler, type CheckpointScheduler, type SchedulerOptions } from "./scheduler.js";
+export { GitRepo, GitError, gitAvailable, resetGitProbe, gitDate, gitBin, GIT_BIN_ENV, ZERO_SHA, EMPTY_TREE, SHA_RE, type GitIdentity, type CommitIdentity } from "./git.js";
+export { renderMessage, parseMessage, subjectOf, seqValue, TRAILER_PREFIX, type CommitTrailers, type DocTrailer } from "./trailers.js";
+export { GIT_PROVIDER, DEFAULT_GIT_DIR, DEFAULT_BRANCH, IDS_REF, DEFAULT_REMOTE_NAME, PUSH_POLICIES, FETCH_POLICIES, gitConfigFor, readGitConfig, readRemoteConfig, remoteConfigFor, validRemoteName, parseCadence, refuseCredentials, type GitHistoryConfig, type GitCadence, type GitRemoteConfig, type GitRemoteOptions, type GitPushPolicy, type GitFetchPolicy, type GitEnableOptions, } from "./config.js";
+export { GIT_CURSOR_SOURCE, readGitCursor, writeGitCursor, writeGitPushed, clearGitCursor, type GitCursor, type GitPushed } from "./cursor.js";
+export { ensureExcluded, excludeFileFor, EXCLUDE_LINE } from "./exclude.js";

package/dist/src/index.js

@@ -0,0 +1,17 @@
+// @omgbase/git-adapter — the Git-backed history provider (modular-core Phase
+// 6a; spec/store §5.12, spec/surface §3/§4, spec/cli `history`, spec/sync §6).
+// The core knows a `HistoryProvider` by name; this package is the one named
+// `git`. Nothing here is imported by `@omgbase/core`: the CLI/MCP host registers
+// `gitHistoryProvider()` before it opens a store.
+export { GitHistoryProvider, gitHistoryProvider, DEFAULT_IDENTITY, FIXTURE_IDENTITY } from "./provider.js";
+export { GitHistoryReader } from "./reader.js";
+export { runCheckpoint, commitSnapshot, tipPosition, resumePosition } from "./worker.js";
+export { idsRecord, idsBlobText, idsPath, idsPosition, syncIds, IDS_PREFIX } from "./ids.js";
+export { remoteSet, remoteUnset, remoteStatus, remoteSummary, pushBranch, fetchRemote, resolveConflict, reconcileRemote, remoteSync, pushAfterCheckpoint, pausedBy, sidecarPath, tsSegment, rejectedMessage, rewrittenMessage, conflictMessage, forkedMessage, GIT_REMOTE_DIVERGED_ALERT, GIT_MERGE_CONFLICT_ALERT, GIT_REMOTE_FORKED_ALERT, } from "./remote.js";
+export { createCheckpointScheduler } from "./scheduler.js";
+export { GitRepo, GitError, gitAvailable, resetGitProbe, gitDate, gitBin, GIT_BIN_ENV, ZERO_SHA, EMPTY_TREE, SHA_RE } from "./git.js";
+export { renderMessage, parseMessage, subjectOf, seqValue, TRAILER_PREFIX } from "./trailers.js";
+export { GIT_PROVIDER, DEFAULT_GIT_DIR, DEFAULT_BRANCH, IDS_REF, DEFAULT_REMOTE_NAME, PUSH_POLICIES, FETCH_POLICIES, gitConfigFor, readGitConfig, readRemoteConfig, remoteConfigFor, validRemoteName, parseCadence, refuseCredentials, } from "./config.js";
+export { GIT_CURSOR_SOURCE, readGitCursor, writeGitCursor, writeGitPushed, clearGitCursor } from "./cursor.js";
+export { ensureExcluded, excludeFileFor, EXCLUDE_LINE } from "./exclude.js";
+//# sourceMappingURL=index.js.map

package/dist/src/provider.d.ts

@@ -0,0 +1,63 @@
+import type { Store, CommitRecord, HistoryProvider, HistoryProviderAvailability, HistoryProviderConfig, HistoryCheckpointResult, HistoryProviderFactory, HistoryPushResult, HistoryRemoteSummary, HistoryRemoteSyncResult, HistoryVaultSink } from "@omgbase/core";
+import { GitRepo, type GitIdentity } from "./git.js";
+import { GitHistoryReader } from "./reader.js";
+import { type GitHistoryConfig, type GitRemoteOptions } from "./config.js";
+import { type FetchResult, type ReconcileMode, type ReconcileResult, type RemoteStatus, type ResolveChoice, type ResolveResult } from "./remote.js";
+/** The committer identity in production. The author's name is the commit's actor when it has one. */
+export declare const DEFAULT_IDENTITY: GitIdentity;
+/** The identity the fixture runners and the CLI under the spec seams use (spec/store §9.4 "The git provider"): pinned shas follow from it. */
+export declare const FIXTURE_IDENTITY: GitIdentity;
+export interface GitProviderOptions {
+    identity?: GitIdentity;
+}
+export declare class GitHistoryProvider implements HistoryProvider {
+    private readonly store;
+    readonly name = "git";
+    private readonly identity;
+    constructor(store: Store, opts?: GitProviderOptions);
+    available(): HistoryProviderAvailability;
+    /** The workspace root: the parent of `.omgbase`. */
+    private root;
+    private repoOf;
+    private context;
+    reader(repoId: string, config: HistoryProviderConfig): GitHistoryReader;
+    enable(repoId: string, commit: CommitRecord, opts: Record<string, unknown>): {
+        config: HistoryProviderConfig;
+        baseline: {
+            revisions: number;
+            tip: string | null;
+        };
+    };
+    purge(repoId: string, config: HistoryProviderConfig): {
+        removed: boolean;
+        path: string;
+    };
+    checkpoint(repoId: string, config: HistoryProviderConfig, opts?: {
+        now?: string;
+    }): HistoryCheckpointResult;
+    remoteSummary(repoId: string, config: HistoryProviderConfig): HistoryRemoteSummary | null;
+    remoteSync(repoId: string, config: HistoryProviderConfig, opts: {
+        now: string;
+        vault: HistoryVaultSink;
+    }): HistoryRemoteSyncResult | null;
+    /** `history remote set`: returns the config as written to the row. */
+    remoteSet(repoId: string, config: HistoryProviderConfig, options: GitRemoteOptions, now?: string): GitHistoryConfig;
+    /** `history remote unset`. */
+    remoteUnset(repoId: string, config: HistoryProviderConfig, now?: string): GitHistoryConfig;
+    /** `history remote status` (local refs only). */
+    remoteStatus(repoId: string, config: HistoryProviderConfig): RemoteStatus;
+    /** `history push`. */
+    push(repoId: string, config: HistoryProviderConfig, now?: string): HistoryPushResult & {
+        ids: "pushed" | "rejected" | "none";
+    };
+    /** `history fetch`: inbound content through `vault`. */
+    fetch(repoId: string, config: HistoryProviderConfig, vault: HistoryVaultSink, now?: string): FetchResult;
+    /** `history remote resolve <path> --ours|--theirs`. */
+    resolve(repoId: string, config: HistoryProviderConfig, vault: HistoryVaultSink, path: string, choice: ResolveChoice, now?: string): ResolveResult;
+    /** `history remote reconcile --rebase|--merge|--adopt|--fork`. */
+    reconcile(repoId: string, config: HistoryProviderConfig, vault: HistoryVaultSink, mode: ReconcileMode, now?: string): ReconcileResult;
+    /** The bare repository of a repository (the measurement script, tests). */
+    gitRepo(config: HistoryProviderConfig): GitRepo;
+}
+/** The factory the composition layer registers: `registerHistoryProvider("git", gitHistoryProvider())`. */
+export declare function gitHistoryProvider(opts?: GitProviderOptions): HistoryProviderFactory;