git-remote-ops 0.1.0

package/esm/protocol/refs.js

@@ -0,0 +1,100 @@
+/**
+ * @module refs
+ *
+ * Decoders for the two flavours of `info/refs` response Git can return for the
+ * `git-upload-pack` service:
+ *
+ *  - **Protocol v0/v1** — a flat stream of `<sha> <ref>` pkt-lines where the
+ *    first ref also carries a NUL-separated capability list.
+ *  - **Protocol v2** — a capability advertisement (`version 2`, then one
+ *    `key[=args]` pkt-line per capability).
+ */
+import { Result } from "better-result";
+import { parsePktLines } from "./pkt_line.js";
+const decoder = new TextDecoder();
+/** ASCII `'#'` — leading byte of the optional `# service=...` banner line. */
+const COMMENT_LINE = 0x23;
+/** ASCII space separating sha from ref name. */
+const SPACE = 0x20;
+/** ASCII line-feed — trailing terminator on most advertisement lines. */
+const LF = 0x0a;
+/** Hex-encoded SHA-1 is always 40 chars. */
+const SHA_LENGTH = 40;
+function stripTrailingLf(payload) {
+    return payload.at(-1) === LF ? payload.subarray(0, payload.length - 1) : payload;
+}
+/**
+ * Parse a v0/v1 ref advertisement (response body of
+ * `GET /info/refs?service=git-upload-pack`).
+ *
+ * The first non-comment data line is special: its payload contains the ref
+ * pair, a NUL byte, then a space-separated list of capabilities. Subsequent
+ * lines are plain `<sha> <ref>\n` pairs.
+ *
+ * @param body Raw response bytes (including any `# service=...` banner).
+ * @returns The advertised refs (name → sha) and capabilities, or
+ *   {@link PktLineError} if the pkt-line framing is malformed.
+ */
+export function parseRefAdvertisement(body) {
+    const refs = new Map();
+    const capabilities = new Set();
+    let firstRef = true;
+    const lines = parsePktLines(body);
+    if (lines.isErr())
+        return Result.err(lines.error);
+    for (const { payload } of lines.value) {
+        if (payload === null || payload.length === 0 || payload[0] === COMMENT_LINE) {
+            continue;
+        }
+        let line = stripTrailingLf(payload);
+        if (firstRef) {
+            const nul = line.indexOf(0);
+            if (nul >= 0) {
+                const capText = decoder.decode(line.subarray(nul + 1));
+                for (const cap of capText.split(/\s+/).filter(Boolean)) {
+                    capabilities.add(cap);
+                }
+                line = line.subarray(0, nul);
+            }
+        }
+        if (line.length >= SHA_LENGTH + 1 && line[SHA_LENGTH] === SPACE) {
+            refs.set(decoder.decode(line.subarray(SHA_LENGTH + 1)), decoder.decode(line.subarray(0, SHA_LENGTH)));
+            firstRef = false;
+        }
+    }
+    return Result.ok({ refs, capabilities });
+}
+/**
+ * Parse a v2 capability advertisement.
+ *
+ * The first data line is always `version 2`; we encode that as the synthetic
+ * capability `"version=2"` so callers can detect protocol v2 with a single
+ * lookup. For the `fetch` capability, any space-separated arguments (e.g.
+ * `shallow`, `filter`, `wait-for-done`) are added as separate set entries.
+ *
+ * @param body Raw response bytes from the `git-upload-pack` advertisement.
+ * @returns Set of capability tokens, or {@link PktLineError} on bad framing.
+ */
+export function parseV2CapabilityAdvertisement(body) {
+    const capabilities = new Set();
+    const lines = parsePktLines(body);
+    if (lines.isErr())
+        return Result.err(lines.error);
+    for (const { payload } of lines.value) {
+        if (payload === null || payload.length === 0 || payload[0] === COMMENT_LINE) {
+            continue;
+        }
+        const line = decoder.decode(stripTrailingLf(payload));
+        if (line === "version 2") {
+            capabilities.add("version=2");
+            continue;
+        }
+        const [name, args] = line.split("=", 2);
+        capabilities.add(name);
+        if (name === "fetch" && args) {
+            for (const arg of args.split(/\s+/).filter(Boolean))
+                capabilities.add(arg);
+        }
+    }
+    return Result.ok(capabilities);
+}

package/esm/protocol/upload_pack.js

@@ -0,0 +1,259 @@
+/**
+ * @module upload-pack
+ *
+ * Build `git-upload-pack` request bodies (protocol v0 and v2) and demux the
+ * sideband-multiplexed response back into a raw packfile.
+ *
+ * Sideband framing: each data pkt-line is prefixed by a single byte channel
+ * marker — `1` packfile bytes, `2` human-readable progress, `3` fatal error
+ * text. The packfile itself is the concatenation of all channel-1 payloads.
+ */
+import { Result } from "better-result";
+import { UploadPackError } from "../errors.js";
+import { PACK_SIGNATURE } from "../pack/objects.js";
+import { DELIM_PKT, FLUSH_PKT, parsePktLines, pktLine } from "./pkt_line.js";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Sideband channel for packfile bytes. */
+const BAND_PACK = 1;
+/** Sideband channel for human-readable progress messages. */
+const BAND_PROGRESS = 2;
+/** Sideband channel for fatal error text. */
+const BAND_ERROR = 3;
+/**
+ * Pkt-line payload prefixes that mark control / framing lines, not packfile
+ * data. Used to skip past the v2 section headers (`packfile\n` etc.) when
+ * hunting for the first real data line.
+ */
+const CONTROL_PREFIXES = [
+    "version 2",
+    "shallow-info",
+    "wanted-refs",
+    "packfile",
+    "shallow ",
+    "unshallow ",
+    "NAK",
+    "ACK",
+];
+/** Bytes of payload to peek at when matching against {@link CONTROL_PREFIXES}. */
+const CONTROL_PREFIX_PEEK = 16;
+function concat(parts) {
+    const length = parts.reduce((sum, part) => sum + part.length, 0);
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+/**
+ * Build the POST body for `/git-upload-pack`. Dispatches to a v0 or v2 encoder
+ * based on `options.protocolVersion` (defaults to v0).
+ *
+ * @returns Encoded request bytes, or {@link PktLineError} if any inner frame
+ *   exceeds the pkt-line size cap.
+ */
+export function buildFetchRequest(options) {
+    return options.protocolVersion === 2
+        ? buildV2FetchRequest(options)
+        : buildV0FetchRequest(options);
+}
+/**
+ * Encode a v0 fetch request: one `want <sha>` per oid (capabilities ride on
+ * the first `want` line, space-separated after the sha), optional `deepen`
+ * and `filter` lines, a flush, then `done`.
+ */
+function buildV0FetchRequest(options) {
+    const lines = [];
+    for (let index = 0; index < options.wants.length; index++) {
+        const sha = options.wants[index];
+        const caps = index === 0 && options.caps.length > 0 ? ` ${options.caps.join(" ")}` : "";
+        const line = pktLine(encoder.encode(`want ${sha}${caps}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    if (options.depth !== undefined) {
+        const line = pktLine(encoder.encode(`deepen ${options.depth}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    if (options.filterSpec !== undefined) {
+        const line = pktLine(encoder.encode(`filter ${options.filterSpec}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    lines.push(FLUSH_PKT);
+    const done = pktLine(encoder.encode("done\n"));
+    if (done.isErr())
+        return Result.err(done.error);
+    lines.push(done.value);
+    return Result.ok(concat(lines));
+}
+/**
+ * Encode a v2 fetch command. Header section carries `command=fetch` and an
+ * `agent=` string, separated from the argument section by a delim packet.
+ * The argument section lists transport hints (`thin-pack`, `ofs-delta`),
+ * `want` lines, optional `deepen`/`filter`, then `done` and a flush.
+ */
+function buildV2FetchRequest(options) {
+    const lines = [];
+    for (const text of ["command=fetch\n", "agent=git-remote-ops-deno/0.1\n"]) {
+        const line = pktLine(encoder.encode(text));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    lines.push(DELIM_PKT);
+    for (const text of ["thin-pack\n", "ofs-delta\n"]) {
+        const line = pktLine(encoder.encode(text));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    for (const sha of options.wants) {
+        const line = pktLine(encoder.encode(`want ${sha}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    if (options.depth !== undefined) {
+        const line = pktLine(encoder.encode(`deepen ${options.depth}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    if (options.filterSpec !== undefined) {
+        const line = pktLine(encoder.encode(`filter ${options.filterSpec}\n`));
+        if (line.isErr())
+            return Result.err(line.error);
+        lines.push(line.value);
+    }
+    const done = pktLine(encoder.encode("done\n"));
+    if (done.isErr())
+        return Result.err(done.error);
+    lines.push(done.value, FLUSH_PKT);
+    return Result.ok(concat(lines));
+}
+/**
+ * Demultiplex sideband-framed `git-upload-pack` response bytes into three
+ * channel-segregated streams (pack / progress / errors). All payloads from a
+ * given channel are concatenated in order.
+ *
+ * Inputs that lack a sideband framing byte are dropped — callers needing the
+ * non-sideband path should use {@link extractPack}.
+ */
+export function demuxSideband(body) {
+    const packChunks = [];
+    const progressChunks = [];
+    const errorChunks = [];
+    const lines = parsePktLines(body);
+    if (lines.isErr())
+        return Result.err(lines.error);
+    for (const { payload } of lines.value) {
+        if (payload === null || payload.length === 0)
+            continue;
+        const data = payload.subarray(1);
+        switch (payload[0]) {
+            case BAND_PACK:
+                packChunks.push(data);
+                break;
+            case BAND_PROGRESS:
+                progressChunks.push(data);
+                break;
+            case BAND_ERROR:
+                errorChunks.push(data);
+                break;
+        }
+    }
+    return Result.ok({
+        pack: concat(packChunks),
+        progress: concat(progressChunks),
+        errors: concat(errorChunks),
+    });
+}
+function findFirstDataPktLine(response) {
+    let previousOffset = 0;
+    const lines = parsePktLines(response);
+    if (lines.isErr())
+        return Result.err(lines.error);
+    for (const { offset, payload } of lines.value) {
+        if (payload === null) {
+            previousOffset = offset;
+            continue;
+        }
+        const head = decoder.decode(payload.subarray(0, Math.min(payload.length, CONTROL_PREFIX_PEEK)));
+        if (CONTROL_PREFIXES.some((prefix) => head.startsWith(prefix))) {
+            previousOffset = offset;
+            continue;
+        }
+        return Result.ok({ payload, bodyOffset: previousOffset });
+    }
+    return Result.err(new UploadPackError({
+        reason: "missing-data-pkt-line",
+        message: "no data in upload-pack response",
+    }));
+}
+/**
+ * Pull the packfile bytes out of a `git-upload-pack` response.
+ *
+ * Walks pkt-lines until it finds the first non-control data line and then
+ * picks the right strategy:
+ *
+ *  1. raw `PACK` signature inline — slice from there to end-of-buffer;
+ *  2. sideband byte (1/2/3) prefix — demux and return channel 1;
+ *  3. no framed data at all — fall back to a byte-level `PACK` search.
+ *
+ * @param response Raw HTTP response body.
+ * @param diagnostic Optional sink for non-fatal server stderr (channel 3).
+ */
+export function extractPack(response, diagnostic) {
+    const first = findFirstDataPktLine(response);
+    if (first.isErr()) {
+        if (first.error._tag === "UploadPackError" && first.error.reason === "missing-data-pkt-line") {
+            const idx = indexOfBytes(response, PACK_SIGNATURE);
+            if (idx >= 0)
+                return Result.ok(response.subarray(idx));
+        }
+        return Result.err(first.error);
+    }
+    const { payload, bodyOffset } = first.value;
+    if (startsWith(payload, PACK_SIGNATURE)) {
+        return Result.ok(response.subarray(bodyOffset + PACK_SIGNATURE.length));
+    }
+    if (payload[0] === BAND_PACK || payload[0] === BAND_PROGRESS || payload[0] === BAND_ERROR) {
+        const data = demuxSideband(response.subarray(bodyOffset));
+        if (data.isErr())
+            return Result.err(data.error);
+        if (data.value.errors.length > 0) {
+            diagnostic?.(`server stderr: ${decoder.decode(data.value.errors)}`);
+        }
+        return Result.ok(data.value.pack);
+    }
+    return Result.err(new UploadPackError({
+        reason: "unrecognized-data-pkt-line",
+        message: `unrecognized data pkt-line (starts with ${Array.from(payload.subarray(0, 8)).join(",")})`,
+    }));
+}
+function startsWith(bytes, prefix) {
+    if (bytes.length < prefix.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++) {
+        if (bytes[i] !== prefix[i])
+            return false;
+    }
+    return true;
+}
+function indexOfBytes(haystack, needle) {
+    outer: for (let i = 0; i <= haystack.length - needle.length; i++) {
+        for (let j = 0; j < needle.length; j++) {
+            if (haystack[i + j] !== needle[j])
+                continue outer;
+        }
+        return i;
+    }
+    return -1;
+}

package/esm/transport.js

@@ -0,0 +1,128 @@
+/**
+ * @module transport
+ *
+ * Thin `fetch` wrappers for the two HTTP endpoints the smart-HTTP Git
+ * protocol uses:
+ *
+ *  - `GET <repo>/info/refs?service=git-upload-pack` — capability/ref ad.
+ *  - `POST <repo>/git-upload-pack` — the actual fetch request, body framed
+ *    by the protocol layer.
+ *
+ * Both helpers turn errors into {@link TransportError} (never throw) and
+ * record timing / byte counts onto the supplied {@link Logger}.
+ */
+import * as dntShim from "./_dnt.shims.js";
+import { Result } from "better-result";
+import { TransportError } from "./errors.js";
+import { NULL_LOGGER } from "./logger.js";
+/** Sent verbatim as `User-Agent`. Git servers sometimes log this. */
+const USER_AGENT = "git/2.0 (git-remote-ops-deno)";
+function trimUrl(url) {
+    return url.replace(/\/+$/, "");
+}
+function protocolHeaders(options) {
+    return options?.protocolVersion === 2 ? { "Git-Protocol": "version=2" } : {};
+}
+async function readResponse(response, method, url) {
+    if (!response.ok) {
+        return Result.err(new TransportError({
+            method,
+            url,
+            status: response.status,
+            statusText: response.statusText,
+            message: `${method} failed: ${response.status} ${response.statusText}`,
+        }));
+    }
+    const body = await Result.tryPromise({
+        try: () => response.arrayBuffer(),
+        catch: (cause) => new TransportError({
+            method,
+            url,
+            message: `${method} failed reading response body`,
+            cause,
+        }),
+    });
+    if (body.isErr())
+        return Result.err(body.error);
+    return Result.ok({
+        body: new Uint8Array(body.value),
+        status: response.status,
+    });
+}
+/**
+ * Issue a smart-HTTP GET to `${url}${path}`. Used to fetch the ref/capability
+ * advertisement. When `protocolVersion === 2`, sends `Git-Protocol: version=2`
+ * so the server responds with a v2 capability ad instead of the legacy format.
+ */
+export async function getSmartHttp(url, path, options) {
+    const logger = options?.logger ?? NULL_LOGGER;
+    const requestUrl = `${trimUrl(url)}${path}`;
+    logger.debug(`GET ${path} (protocol=${options?.protocolVersion ?? 0})`);
+    const start = performance.now();
+    const response = await Result.tryPromise({
+        try: () => dntShim.fetch(requestUrl, {
+            headers: { "User-Agent": USER_AGENT, ...protocolHeaders(options) },
+        }),
+        catch: (cause) => new TransportError({
+            method: "GET",
+            url: requestUrl,
+            message: `GET ${path} failed`,
+            cause,
+        }),
+    });
+    if (response.isErr())
+        return Result.err(response.error);
+    const read = await readResponse(response.value, `GET ${path}`, requestUrl);
+    const durationMs = performance.now() - start;
+    if (read.isOk()) {
+        logger.recordHttp({ bytesIn: read.value.body.length, bytesOut: 0, durationMs });
+        logger.debug(`GET ${path} -> ${response.value.status}, ${read.value.body.length}B in ${durationMs.toFixed(1)}ms`);
+    }
+    return read;
+}
+/**
+ * POST a `git-upload-pack` request body. Sets the magic content/accept types
+ * the upload-pack service expects and forwards the response bytes as-is for
+ * the protocol layer to demux.
+ *
+ * `Connection: close` is set explicitly because some servers (notably
+ * `dumb-http-bridge` setups) hang on keep-alive.
+ */
+export async function postUploadPack(url, body, options) {
+    const logger = options?.logger ?? NULL_LOGGER;
+    const requestUrl = `${trimUrl(url)}/git-upload-pack`;
+    logger.debug(`POST git-upload-pack (${body.length}B, protocol=${options?.protocolVersion ?? 0})`);
+    const start = performance.now();
+    const response = await Result.tryPromise({
+        try: () => dntShim.fetch(requestUrl, {
+            method: "POST",
+            body: body,
+            headers: {
+                "Content-Type": "application/x-git-upload-pack-request",
+                "Accept": "application/x-git-upload-pack-result",
+                "User-Agent": USER_AGENT,
+                "Connection": "close",
+                ...protocolHeaders(options),
+            },
+        }),
+        catch: (cause) => new TransportError({
+            method: "POST",
+            url: requestUrl,
+            message: "POST git-upload-pack failed",
+            cause,
+        }),
+    });
+    if (response.isErr())
+        return Result.err(response.error);
+    const read = await readResponse(response.value, "POST git-upload-pack", requestUrl);
+    const durationMs = performance.now() - start;
+    if (read.isOk()) {
+        logger.recordHttp({
+            bytesIn: read.value.body.length,
+            bytesOut: body.length,
+            durationMs,
+        });
+        logger.debug(`POST git-upload-pack -> ${response.value.status}, ${read.value.body.length}B in ${durationMs.toFixed(1)}ms`);
+    }
+    return read;
+}

package/esm/types.js

@@ -0,0 +1,8 @@
+/**
+ * @module types
+ *
+ * Public and internal type vocabulary. Anything that crosses a module
+ * boundary lives here so dependents don't end up importing each other's
+ * implementation files just to name a shape.
+ */
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "git-remote-ops",
+  "version": "0.1.0",
+  "description": "Read-only Git over smart HTTP. No clone, no subprocess.",
+  "keywords": [
+    "git",
+    "smart-http",
+    "upload-pack",
+    "packfile",
+    "partial-clone",
+    "shallow-clone"
+  ],
+  "author": "Goulin Khoge",
+  "homepage": "https://github.com/goulinkh/git-remote-ops#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/goulinkh/git-remote-ops.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/goulinkh/git-remote-ops/issues"
+  },
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    }
+  },
+  "scripts": {},
+  "bin": {
+    "git-remote-ops": "./esm/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "better-result": "^2",
+    "@deno/shim-deno": "~0.18.0",
+    "@deno/shim-crypto": "~0.3.1",
+    "undici": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/types/_dnt.shims.d.ts

@@ -0,0 +1,16 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
+import { fetch, File, FormData, Headers, Request, Response } from "undici";
+export { fetch, File, FormData, Headers, Request, Response, type BodyInit, type HeadersInit, type ReferrerPolicy, type RequestInit, type RequestCache, type RequestMode, type RequestRedirect, type ResponseInit } from "undici";
+export declare const dntGlobalThis: Omit<typeof globalThis, "fetch" | "File" | "FormData" | "Headers" | "Request" | "Response" | "crypto" | "Deno"> & {
+    Deno: typeof Deno;
+    crypto: import("@deno/shim-crypto").Crypto;
+    fetch: typeof fetch;
+    File: typeof File;
+    FormData: typeof FormData;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/types/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,UAAU,EAAE,KAAK,uBAAuB,EAAE,KAAK,YAAY,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrvB,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC3E,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAC;AAYjO,eAAO,MAAM,aAAa;;;;;;;;;CAA2C,CAAC"}

package/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/types/client.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @module client
+ *
+ * High-level read-only Git remote client. {@link RemoteGit} composes the
+ * transport, protocol, and pack layers behind a small surface: discover a
+ * server, ask for commits/trees/blobs, get them back as decoded objects.
+ *
+ * The client caches:
+ *  - a single {@link ServerProfile} (capabilities + ref advertisement);
+ *  - every object materialized by any prior fetch, in a process-lifetime
+ *    map. Subsequent fetches dedupe wants against this map so multi-step
+ *    workflows (commit → tree → blob) only pay for what's new.
+ */
+import { Result } from "better-result";
+import type { GitRemoteOpsError } from "./errors.js";
+import { Logger } from "./logger.js";
+import type { CommitInfo, FetchCommitOptions, GitObject, RemoteGitOptions, ServerProfile, TreeEntry } from "./types.js";
+/**
+ * Read-only Git remote client over smart HTTP.
+ *
+ * One instance corresponds to one upstream `url`. Reuse it across operations
+ * so the cached profile and object store can do their job; throw it away
+ * when you're done with that remote.
+ */
+export declare class RemoteGit {
+    readonly url: string;
+    readonly logger: Logger;
+    private profile;
+    private objects;
+    private snapshotCommits;
+    private diagnostic?;
+    private transportLogger;
+    private packLogger;
+    /**
+     * @param url Base repository URL (e.g. `https://github.com/owner/repo.git`).
+     *   Trailing slashes are stripped.
+     * @param options Optional logger / diagnostic sink. When neither is given, a
+     *   silent logger is used. Passing `diagnostic` alone gets you a `debug`
+     *   logger routed to the diagnostic function.
+     */
+    constructor(url: string, options?: RemoteGitOptions);
+    /**
+     * Fetch and cache the server's ref/capability advertisement.
+     *
+     * Issues both a v0/v1 GET and a v2 GET. The v0 response is the source of
+     * truth for refs and base capabilities; if the v2 response advertises
+     * `version=2`, those caps are merged in and `protocolVersion` flips to 2.
+     * Subsequent client calls hit the cached profile until `discover()` runs again.
+     */
+    discover(): Promise<Result<ServerProfile, GitRemoteOpsError>>;
+    /**
+     * Confirm what the server *actually* honours, not just what it advertises.
+     *
+     * Some servers advertise `filter` but ignore it; others advertise `shallow`
+     * but reject deepen requests. We send minimal-cost shallow fetches with
+     * `blob:none` and `tree:0` filters and look at the returned pack to decide.
+     * Sets `supportsFilterBlobNone` / `supportsFilterTree0` on the cached profile.
+     *
+     * @param verbose Emit raw probe outcomes through {@link RemoteGitOptions.diagnostic}.
+     */
+    probe(verbose?: boolean): Promise<Result<ServerProfile, GitRemoteOpsError>>;
+    /** Return a snapshot of the advertised refs (name → sha). Triggers `discover()` if needed. */
+    lsRefs(): Promise<Result<Map<string, string>, GitRemoteOpsError>>;
+    /**
+     * Resolve `ref` to a 40-char hex sha against the cached advertisement.
+     *
+     * Tries the literal name, then `refs/heads/<ref>`, then `refs/tags/<ref>`.
+     * A 40-char hex input is accepted as-is even when it isn't in the ad — the
+     * server may still serve it as a `want`.
+     */
+    resolveRef(ref: string): Promise<Result<string, GitRemoteOpsError>>;
+    /**
+     * Fetch and decode a single commit reachable from `ref`.
+     *
+     * `options.depth` defaults to deep fetch; pass `1` for a snapshot. Filters
+     * are silently dropped if the server doesn't support them — we log an
+     * info-level message in that case.
+     */
+    fetchCommit(ref: string, options?: FetchCommitOptions): Promise<Result<{
+        commit: CommitInfo;
+        sha: string;
+    }, GitRemoteOpsError>>;
+    /** Fetch a blob by sha and return its raw contents. */
+    fetchBlob(sha: string): Promise<Result<Uint8Array, GitRemoteOpsError>>;
+    /**
+     * Fetch the commit at `ref` *and* its root tree from a single snapshot pack.
+     *
+     * Forces `parseFull: true` so the tree object — which the commit references
+     * but doesn't `want` directly — ends up in the local object store. Useful
+     * for "list files at HEAD" without a clone.
+     */
+    fetchTreeForCommit(ref: string, options?: FetchCommitOptions): Promise<Result<{
+        commit: CommitInfo;
+        commitSha: string;
+        entries: TreeEntry[];
+    }, GitRemoteOpsError>>;
+    /** Fetch and decode a single tree by sha. */
+    fetchTree(sha: string): Promise<Result<TreeEntry[], GitRemoteOpsError>>;
+    /** Look up an already-materialized object by sha. Does not fetch on miss. */
+    getObject(sha: string): GitObject | undefined;
+    private fetchObjects;
+    private probeFilter;
+    private fetchPack;
+    private normalizeWants;
+    private pickProbeSha;
+    private log;
+}
+//# sourceMappingURL=client.d.ts.map