@usecontextlayer/pggit 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,132 @@
+<div align="center">
+
+# pggit
+
+A battle-tested git server that runs on Postgres.
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+</div>
+
+```sh
+# Point it at a Postgres database and start it. No bare repo on disk, no git binary.
+PGGIT_DATABASE_URL=postgres://localhost/pggit pnpm run dev
+# [pggit] listening on http://localhost:8080
+
+# Push with stock git. The repo is created on first push, HEAD -> refs/heads/main.
+git push http://localhost:8080/myrepo main
+
+# Clone it back. Every object came out of Postgres. (git >= 2.26)
+git clone http://localhost:8080/myrepo
+```
+
+```sql
+-- A branch's working tree is plain SQL — no clone, no checkout, no git.
+select f.path, f.mode, o.content
+from repo_file f
+join repos r      on r.id = f.repo_id
+join git_object o on o.repo_id = f.repo_id and o.oid = f.blob_oid
+where r.name = 'myrepo' and f.ref_name = 'refs/heads/main'
+order by f.path;
+```
+
+- **It's just Postgres** — every git object and ref is a row in your database, sitting next to the rest of your data. No bare repos on disk, no git host to run.
+- **Compatible with any modern git client, nothing special needed** — `clone`, `fetch`, and `push` work over standard smart-HTTP with the git you already have (>= 2.26, the default since 2020).
+- **Queryable** — an optional per-branch index maps each branch tip's files to their blobs, so a `SELECT` returns a repo's working tree with no clone and no checkout.
+- **Thoroughly tested** — every operation round-trips against the canonical `git` binary (clone or push, then `fsck --full`), plus property-based differential tests over thousands of random commit graphs.
+- **Pure TypeScript** — a git smart-HTTP server built from scratch; no native addons and no `git` binary on the request path.
+- **Embed into your app** — it's a Hono sub-app: `host.route("/git", createGitApp(deps))` runs the git server in-process, inside your own service.
+
+## Why?
+
+A git server normally needs a filesystem: bare repos on disk, backed up and replicated out of band, reached through a `git` process. pggit drops that. Objects and refs live in Postgres, so the database you already run, back up, and replicate holds your git data too — right next to everything else. Point any `git remote` at it; it doesn't care what you store: generated files, per-user workspaces, agent output, application content.
+
+## Installation
+
+```sh
+npm install @usecontextlayer/pggit
+```
+
+Or build from source to hack on it (Node >= 20, pnpm, and a Postgres you can reach):
+
+```sh
+git clone https://github.com/usecontextlayer/pggit
+cd pggit
+pnpm install
+pnpm run build
+```
+
+Create the schema. Migrations use `DATABASE_URL` (note: the server uses `PGGIT_DATABASE_URL`):
+
+```sh
+DATABASE_URL=postgres://localhost/pggit pnpm run db.manage latest
+```
+
+## Usage
+
+### As a standalone server
+
+```sh
+PGGIT_DATABASE_URL=postgres://localhost/pggit pnpm run dev
+# [pggit] listening on http://localhost:8080
+```
+
+Then treat it as an ordinary remote:
+
+```sh
+git push  http://localhost:8080/myrepo main                  # first push creates the repo
+git clone http://localhost:8080/myrepo                       # git >= 2.26 (negotiates v2)
+git clone --filter=blob:none http://localhost:8080/myrepo    # blobless / partial clone
+```
+
+The standalone server wires the queryable view on by default, so the `repo_file` SQL above works against any repo you push.
+
+### As a Hono sub-app
+
+`createGitApp(deps)` returns a Hono app you mount into your own server, keeping one Postgres connection for the whole host:
+
+```ts
+import { createGitApp } from "@usecontextlayer/pggit"
+
+// `deps` supplies the Postgres-backed object and ref stores, plus an optional
+// snapshot store that maintains the queryable repo_file index. Omit `snapshots`
+// and pggit is a plain git remote.
+host.route("/git", createGitApp({ objects, refs, snapshots }))
+```
+
+The app exposes the smart-HTTP endpoints under the mount point: `GET /:repo/info/refs`, `POST /:repo/git-upload-pack` (fetch), `POST /:repo/git-receive-pack` (push), and `GET /health`.
+
+## How It Works
+
+git's core data is immutable, content-addressed objects, so pggit stores them that way rather than as packfiles:
+
+- **`git_object`** holds one row per object — the raw inflated body (no loose `<type> <size>\0` header, no zlib), LZ4-compressed Postgres-side, keyed `(repo_id, oid)` and hash-partitioned by repo. Append-only on the push path; unreachable rows are later reclaimed by the background GC drain (below).
+- **`git_ref`** is git's only mutable surface. Each row is either a direct ref or a symref; ref updates are compare-and-swap against the advertised old OID.
+- **`git_edge`** materializes the commit/tree/tag DAG so reachability — fetch negotiation and the push connectivity check — is a recursive SQL walk instead of re-parsing objects.
+- **`repo_file`** is the optional projection: on each push it rebuilds a branch tip's `path -> (mode, blob_oid)` index. It stores no duplicate bytes; content is read by joining `git_object`.
+
+Pushes ingest via binary `COPY` (no per-row bind-parameter ceiling, so a single push can carry huge blobs and tens of thousands of files). Thin-pack delta bases are resolved against objects already in the store. Fetches serve undeltified packs built straight from the closure. OIDs are SHA-1 throughout; correctness is pinned by a suite that round-trips every operation against the real `git` binary and diffs generated commit graphs with `fast-check`.
+
+Because objects are append-only, cleanup is deletion, not rewriting. A background **GC drain** keeps storage bounded: for any repo pushed since its last sweep, it reclaims objects unreachable from every ref and older than a grace window, using the same reachability engine the serve path uses — so a reachable object is never deleted — on a connection pool separate from the request path. The standalone server runs it on by default; a mounted host opts in with the exported `createGcScheduler`.
+
+## Configuration
+
+| Variable | Used by | Default | Notes |
+|---|---|---|---|
+| `PGGIT_DATABASE_URL` | the server (`pnpm run dev`, `startServer`) | — | Required to serve; throws on boot if unset. |
+| `PGGIT_PORT` | the server | `8080` | Listen port. |
+| `PGGIT_GC_ENABLED` | the server | `true` | Runs the background GC drain that reclaims unreachable objects. |
+| `PGGIT_GC_GRACE_SECONDS` | the server | `60` | Reclaim only objects unreachable for longer than this. |
+| `PGGIT_GC_INTERVAL_MS` | the server | `30000` | How often the drain polls for repos to sweep. |
+| `PGGIT_GC_CONCURRENCY` | the server | `4` | Max repos swept per drain pass. |
+| `DATABASE_URL` | the migration CLI (`pnpm run db.manage`) | — | Required for `latest`/`up`/`down`/`reset`/`drop`. |
+
+## Scope
+
+pggit is deliberately narrow:
+
+- **No authentication.** It serves every request; put it behind your own auth/network boundary.
+- **SHA-1 only.** A SHA-256 client is rejected at the wire boundary.
+- **Fetch is protocol v2 only**, push is v0. A v0/v1 fetch client fails loudly rather than silently cloning nothing. Shallow clones are rejected; `blob:none` is the only partial-clone filter that's honored — other filters are accepted but ignored, so you get a full clone.
+
+MIT License

package/dist/index.d.mts

@@ -0,0 +1,274 @@
+import { Hono } from "hono";
+import { Sql } from "postgres";
+
+//#region src/object/object.d.ts
+/** The four addressable git object types (deltas resolve into one of these). */
+type GitObjectType = "blob" | "commit" | "tree" | "tag";
+//#endregion
+//#region src/repo-view/build-file-list.d.ts
+type FileEntry = {
+  path: string;
+  mode: string;
+  blobOid: string;
+};
+type FileList = {
+  files: FileEntry[];
+};
+//#endregion
+//#region src/repo-view/repo-file-projection.d.ts
+type RepoFileProjection = ReturnType<typeof createRepoFileProjection>;
+/**
+ * Write-only maintainer of `repo_file`: the slim per-branch-tip `path → (mode,
+ * blob_oid)` index that IS pggit's public read surface. Reads never go through this
+ * module — a consumer queries `repo_file ⋈ git_object` (on `oid = blob_oid`) with
+ * direct SQL, the one read mechanism (docs/2026-06-26-read-surface-sharpening-design.md).
+ * So this only ever rebuilds or drops the projection on push; there is no read method
+ * here by design. It is a derived projection of the canonical objects — no duplicate
+ * blob bytes, no orphan reaper (the redesign's collapse, §4.5) — droppable and
+ * rebuildable at will. The wire repo name resolves to its bigint surrogate (memoized)
+ * here, like the other stores.
+ */
+declare function createRepoFileProjection(pg: Sql): {
+  /** Drop a repo's entire projection (all branches) — the clean slate for a full
+   * rebuild. No blob bytes to reap; the index is the only state. */
+  clearRepo(repoId: string): Promise<void>; /** Drop `refName`'s snapshot (branch deleted). */
+  dropRefSnapshot(repoId: string, refName: string): Promise<void>;
+  /** Replace `refName`'s snapshot with `fileList` (one atomic transaction). The
+   * blobs already live in git_object — we store only the path→blob_oid index. */
+  rebuildRefSnapshot(repoId: string, refName: string, fileList: FileList): Promise<void>;
+};
+//#endregion
+//#region src/pack/write-pack.d.ts
+type PackInputObject = {
+  type: GitObjectType;
+  content: Buffer;
+};
+//#endregion
+//#region src/store/object-store.d.ts
+type StoredObject = {
+  type: GitObjectType;
+  content: Buffer;
+};
+type ObjectStore = ReturnType<typeof createObjectStore>;
+/**
+ * Postgres-backed git object store. Each immutable object is one row in the
+ * per-repo, HASH-partitioned `git_object` (raw 20-byte `bytea` OID, pack type
+ * code, raw inflated body lz4-TOASTed Postgres-side) — packs are a transport
+ * encoding produced on serve and consumed on ingest, never stored. So a fetch is
+ * a primary-key point-read, not a whole-pack re-inflate.
+ *
+ * The store is the wire→DB boundary: callers speak hex OIDs and the wire repo
+ * name; OIDs are coerced hex↔raw here, and the repo name is resolved to its
+ * bigint surrogate (memoized) here.
+ */
+declare function createObjectStore(pg: Sql): {
+  /**
+   * Build the served pack for a fetch: the want-closure minus the have-closure,
+   * re-adding the explicit wants (promisor lazy-fetch roots — a partial clone may
+   * want a blob reachable from a tree it already has, so it must not be
+   * subtracted). The object count is known from the closure before any content is
+   * read; content then streams in keyset batches into the pack encoder, so only
+   * one batch of inflated content is ever held (never the whole repo).
+   */
+  buildPack(repoId: string, wants: string[], haves: string[], omitBlobs: boolean, includeTag?: boolean): Promise<Buffer>;
+  /** The subset of `haves` this repo actually has — the negotiation common set,
+   * in one indexed lookup rather than a per-have probe. */
+  commonHaves(repoId: string, haves: string[]): Promise<string[]>;
+  getObject(repoId: string, oid: string): Promise<StoredObject | null>;
+  hasObject(repoId: string, oid: string): Promise<boolean>;
+  /**
+   * Ingest a received pack: parse it — resolving in-pack deltas, and thin-pack
+   * REF_DELTA bases against objects already in this repo — then insert every
+   * resolved object as a row.
+   */
+  ingestPack(repoId: string, packBytes: Buffer): Promise<{
+    oids: string[];
+  }>;
+  /**
+   * Connectivity check (spec §5.2): is every object reachable from `oid` present?
+   * A push whose new tip fails this references an object the pack neither carried
+   * nor delta-resolved, and must be rejected. Delegates to the one reachability
+   * engine (`reachableClosure`) shared with clone/fetch, so connectivity and
+   * serving can never disagree on what is reachable. Full-closure (matching the
+   * old walk's scope); the bounded "new objects only" form is a deferred
+   * optimization (OQ-14).
+   */
+  isConnected(repoId: string, oid: string): Promise<boolean>;
+  /** Seed objects directly (the differential harness + perf bench path): insert
+   * each as a row, idempotently. Equivalent to `ingestPack` minus the pack codec. */
+  putPack(repoId: string, objects: PackInputObject[]): Promise<{
+    oids: string[];
+  }>;
+  /**
+   * git's `ok_to_give_up`: ready once every want reaches a common have by commit/
+   * tag ancestry (the haves form a cut below all wants, so the delta is well-
+   * defined). One ancestry CTE (edge kinds 2,5) per want replaces `reachesCommon`'s
+   * per-object BFS. Generation-number pruning is a deferred §6.4 lever.
+   */
+  readyToGiveUp(repoId: string, wants: string[], common: string[]): Promise<boolean>;
+};
+//#endregion
+//#region src/store/refs-store.d.ts
+type RefRow = {
+  name: string;
+  oid: string;
+  peeled?: string;
+};
+/** A ref change: create (oldOid=zero), update (old→new), or delete (newOid=zero). */
+type RefUpdate = {
+  oldOid: string;
+  newOid: string;
+  ref: string;
+};
+type RefStore = ReturnType<typeof createRefStore>;
+/**
+ * Postgres-backed git refs: direct refs (name → oid) and symbolic refs
+ * (HEAD → refs/heads/...). Push applies ref changes through `applyRefUpdates`;
+ * `setRef`/`setSymref` are the seeding helpers.
+ *
+ * Like the object store, this is the wire→DB boundary: the repo name resolves to
+ * its bigint surrogate (memoized) here, ref names cast to their branded column
+ * type, and oids coerce hex↔raw `bytea`.
+ */
+declare function createRefStore(pg: Sql): {
+  /**
+   * Apply a batch of ref CAS updates. Non-atomic (the default push mode): each
+   * ref is independent and the returned flags are per-command. Atomic
+   * (`--atomic`): all-or-nothing in one transaction — if any CAS fails, every
+   * command is rolled back and the result is all-false (spec §3.6).
+   */
+  applyRefUpdates(repoId: string, commands: RefUpdate[], atomic: boolean): Promise<boolean[]>;
+  getSymref(repoId: string, name: string): Promise<string | null>;
+  /** Direct refs (name → oid + peeled tag target), sorted by name. Excludes
+   * symbolic refs. */
+  listRefs(repoId: string): Promise<RefRow[]>;
+  setRef(repoId: string, name: string, oid: string): Promise<void>;
+  setSymref(repoId: string, name: string, target: string): Promise<void>;
+};
+//#endregion
+//#region src/gc-scheduler.d.ts
+/**
+ * Self-scheduling GC — the background drain that decides WHEN the per-repo
+ * reachability GC (`store/gc.ts`) runs, off the push/fetch hot path. See
+ * `docs/2026-06-24-gc-scheduler-design.md`; the observable contract is §6 of that
+ * doc (SCH-1 … SCH-11 / PBT-S1).
+ *
+ * Mechanism (data-structures-first): every storage-mutating push stamps
+ * `repos.last_pushed_at` in its own transaction (the store), so the scheduler is a
+ * pure poll loop over Postgres with NO coupling to the request path. One pass
+ * (`drainOnce`) selects the eligible repos — `last_pushed_at > last_gc_at`
+ * (or `last_gc_at is null`) — and runs `gc()` on each (per-repo serialized,
+ * bounded concurrency), then advances `last_gc_at` to the pass's start time so a
+ * push landing mid-pass re-qualifies the repo next loop (no lost garbage). `start`
+ * is just `drainOnce` on a `setInterval`; all correctness lives in `drainOnce`,
+ * which the tests drive directly (the timer is never in a test's critical path).
+ */
+/** One repo's outcome in a drain pass: the repo and what its GC reclaimed.
+ * Emitted for EVERY repo the pass judged eligible (including zero-reclaim), so the
+ * eligible set itself is observable (SCH-3). */
+type DrainEntry = {
+  repo: string;
+  deletedObjects: number;
+  deletedEdges: number;
+};
+/** What one `drainOnce()` reclaimed, one entry per eligible repo. */
+type DrainSummary = DrainEntry[];
+/** Scheduler tunables (resolved from `env` / `startServer` opts). `graceSeconds`
+ * is passed straight to `gc()`; `intervalMs` is the drain cadence (the debounce
+ * window); `concurrency` caps repos GC'd at once per pass so one large-orphan repo
+ * cannot head-of-line-block the rest. */
+type GcSchedulerOptions = {
+  graceSeconds: number;
+  intervalMs: number;
+  concurrency: number;
+};
+type GcScheduler = ReturnType<typeof createGcScheduler>;
+/**
+ * Build the GC scheduler over a porsager client (the same wire→DB boundary the
+ * stores take). `drainOnce()` runs one poll+sweep pass; `start()`/`stop()` drive
+ * it on `intervalMs`. Reachable objects are never touched — it only invokes the
+ * per-repo GC primitive, which is reachability-safe.
+ */
+declare function createGcScheduler(pg: Sql, opts: GcSchedulerOptions): {
+  drainOnce: () => Promise<DrainSummary>;
+  start: () => void;
+  stop: () => Promise<void>;
+};
+//#endregion
+//#region src/store/gc.d.ts
+/**
+ * Per-repo reachability GC — the one piece of the Postgres-native redesign (§7)
+ * that the rest of the spine deferred. See `docs/2026-06-24-force-commit-gc-design.md`
+ * for the design; the observable contract is §4 of that doc, and the authoritative
+ * algorithm is §7 of `internal/archived/2026-06-22-pggit-postgres-native-storage-
+ * redesign.md`.
+ *
+ * The mechanism (data-structures-first): materialize the LIVE set — the reachable
+ * closure from every ref tip — into an UNLOGGED table, then sweep `git_object` in
+ * batched short transactions with a server-side anti-join (`NOT EXISTS`) against
+ * that table plus a `created_at` grace cutoff. Reachability itself is NOT re-derived
+ * here: it is exactly `reachableClosure(omitBlobs=false)`, the one engine clone /
+ * fetch / connectivity already share, so GC can never disagree with them about what
+ * is reachable.
+ */
+/** Tunables for one GC pass. `graceSeconds` is REQUIRED — no silent default: an
+ * object is reclaimed iff it is unreachable from every ref AND its `created_at`
+ * is older than `graceSeconds` (0 ⇒ reclaim all unreachable; a huge value ⇒
+ * retain). `batchLimit` caps the per-batch DELETE size (sweep tuning only — it
+ * never changes the final observable state). `maintain` (default true) runs the
+ * post-sweep VACUUM/REINDEX; the self-scheduling drain passes `false` so a
+ * frequent per-repo pass never triggers a full-table VACUUM on the hot cadence
+ * (autovacuum reclaims the GC churn instead). Maintenance is observable-neutral —
+ * it changes dead-tuple bloat, never the row/clone state. */
+type GcOptions = {
+  graceSeconds: number;
+  batchLimit?: number;
+  maintain?: boolean;
+};
+/**
+ * Internal-only test seam (NOT part of the public `GcOptions` contract): hooks the
+ * GC pass at the one point §5 in-flight safety depends on. `afterLiveSet` is awaited
+ * AFTER the live set is materialized and BEFORE the object sweep begins, so a test
+ * can deterministically interpose a concurrent push there and assert the just-pushed
+ * tip is never partially reclaimed. Test-only; do not document or use in production.
+ */
+type GcHooks = {
+  afterLiveSet?: () => Promise<void>;
+};
+type InternalGcOptions = GcOptions & {
+  _hooks?: GcHooks;
+};
+/** What one GC pass reclaimed: the deleted `git_object` / `git_edge` row counts. */
+type GcResult = {
+  deletedObjects: number;
+  deletedEdges: number;
+};
+type Gc = ReturnType<typeof createGc>;
+/**
+ * Build the GC over a porsager client (the same wire→DB boundary the object and ref
+ * stores take). `gc(repo, opts)` reclaims a single repo's unreachable-and-old-enough
+ * objects offline; reachable objects are always retained.
+ */
+declare function createGc(pg: Sql): {
+  gc(repo: string, opts: InternalGcOptions): Promise<GcResult>;
+};
+//#endregion
+//#region src/index.d.ts
+type GitAppDeps = {
+  objects: ObjectStore;
+  refs: RefStore;
+  /** Optional queryable-view layer. When provided, push maintains a `repo_file`
+   * path→blob index per branch; when omitted, this is a plain git remote. */
+  snapshots?: RepoFileProjection;
+};
+/**
+ * Build the git-remote Hono app (smart-HTTP, protocol v2 fetch). Mountable into
+ * a host app via `host.route("/git", createGitApp(deps))`; the host owns the
+ * Postgres lifecycle behind `deps`.
+ */
+declare function createGitApp(deps: GitAppDeps, opts?: {
+  instrument?: boolean;
+}): Hono;
+//#endregion
+export { type DrainEntry, type DrainSummary, type Gc, type GcOptions, type GcResult, type GcScheduler, type GcSchedulerOptions, GitAppDeps, createGc, createGcScheduler, createGitApp };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/object/object.ts","../src/repo-view/build-file-list.ts","../src/repo-view/repo-file-projection.ts","../src/pack/write-pack.ts","../src/store/object-store.ts","../src/store/refs-store.ts","../src/gc-scheduler.ts","../src/store/gc.ts","../src/index.ts"],"mappings":"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"}