git-remote-ops 0.1.0

package/esm/cli.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+import * as dntShim from "./_dnt.shims.js";
+!/usr/bin / env - S;
+deno;
+run--;
+allow - net;
+/**
+ * @module cli
+ *
+ * Cliffy-driven command-line front-end. Each subcommand wires the global
+ * verbosity / stats flags into a freshly built {@link RemoteGit}, executes
+ * one operation, and prints a plain-text result to stdout. Errors come back
+ * through {@link unwrap} as `[Tag] message` lines on stderr with exit 1.
+ *
+ * Subcommands:
+ *  - `probe`       — capability + filter probe
+ *  - `ls-refs`     — list advertised refs
+ *  - `cat-commit`  — fetch one commit
+ *  - `cat-tree`    — fetch a commit's root tree (or a tree by sha)
+ *  - `list-files`  — walk a snapshot and emit every file path
+ *  - `cat-blob`    — pipe one blob's raw bytes to stdout
+ */
+import { Command, ValidationError } from "./deps/jsr.io/@cliffy/command/1.1.0/mod.js";
+import { Logger, RemoteGit } from "./index.js";
+import { parseTree } from "./objects/index.js";
+/** Bumped in lockstep with `deno.json`. Surfaced by `git-remote-ops --version`. */
+const VERSION = "0.1.0";
+/** Octal mode of a subtree entry — used to recurse during `list-files`. */
+const TREE_MODE = "40000";
+function resolveLevel(flags) {
+    if (flags.quiet)
+        return "silent";
+    if (flags.debug)
+        return "trace";
+    if (flags.verbose)
+        return "debug";
+    return "info";
+}
+function makeClient(url, flags) {
+    const logger = new Logger({
+        level: resolveLevel(flags),
+        sink: (line) => console.error(line),
+    }, "client");
+    const client = new RemoteGit(url, { logger });
+    return { client, logger };
+}
+function unwrap(result) {
+    if (result.isErr()) {
+        console.error(`[${result.error._tag}] ${result.error.message}`);
+        dntShim.Deno.exit(1);
+    }
+    return result.value;
+}
+function maybeStats(logger, flags) {
+    if (flags.stats)
+        console.error(logger.summary());
+}
+function cachedTreeEntries(client, treeSha) {
+    const object = client.getObject(treeSha);
+    if (!object) {
+        console.error(`[ObjectNotFoundError] tree not present in fetched pack: ${treeSha}`);
+        dntShim.Deno.exit(1);
+    }
+    if (object.type !== "tree") {
+        console.error(`[ObjectDecodeError] object is not a tree: ${treeSha}`);
+        dntShim.Deno.exit(1);
+    }
+    const entries = parseTree(object.content);
+    if (entries.isErr()) {
+        console.error(`[${entries.error._tag}] ${entries.error.message}`);
+        dntShim.Deno.exit(1);
+    }
+    return entries.value;
+}
+function printCachedFiles(client, entries, prefix, details) {
+    for (const entry of entries) {
+        const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.mode === TREE_MODE) {
+            printCachedFiles(client, cachedTreeEntries(client, entry.sha), path, details);
+        }
+        else {
+            console.log(details ? `${entry.mode} ${entry.sha} ${path}` : path);
+        }
+    }
+}
+await new Command()
+    .name("git-remote-ops")
+    .version(VERSION)
+    .description("Read-only Git remote operations over smart HTTP.")
+    .globalOption("-q, --quiet", "Suppress all log output (silent level).")
+    .globalOption("-v, --verbose", "Enable debug-level logs to stderr.", {
+    conflicts: ["quiet"],
+})
+    .globalOption("--debug", "Enable trace-level logs to stderr (very chatty).", {
+    conflicts: ["quiet"],
+})
+    .globalOption("--stats", "Print performance/analytics summary on stderr after completion.")
+    .action(function () {
+    this.showHelp();
+})
+    .command("probe", "Probe server capabilities (protocol, filter, shallow).")
+    .arguments("<url:string>")
+    .action(async (flags, url) => {
+    const { client, logger } = makeClient(url, flags);
+    const profile = unwrap(await client.probe(true));
+    console.log(`refs=${profile.refs.size}`);
+    console.log(`protocol=${profile.protocolVersion}`);
+    console.log(`filter_blob_none=${profile.supportsFilterBlobNone}`);
+    console.log(`filter_tree_0=${profile.supportsFilterTree0}`);
+    console.log(`shallow=${profile.supportsShallow}`);
+    maybeStats(logger, flags);
+})
+    .command("ls-refs", "List remote refs as '<sha> <name>' per line.")
+    .arguments("<url:string>")
+    .action(async (flags, url) => {
+    const { client, logger } = makeClient(url, flags);
+    for (const [name, sha] of unwrap(await client.lsRefs())) {
+        console.log(`${sha} ${name}`);
+    }
+    maybeStats(logger, flags);
+})
+    .command("cat-commit", "Fetch & print a commit object.")
+    .arguments("<url:string>")
+    .option("--ref <ref:string>", "Ref or sha to resolve.", { default: "HEAD" })
+    .option("--depth <n:integer>", "Shallow depth (ignored if server lacks shallow).", {
+    default: 1,
+    value: (n) => {
+        if (n < 1)
+            throw new ValidationError("--depth must be >= 1");
+        return n;
+    },
+})
+    .option("--filter <spec:string>", "Object filter spec (e.g. blob:none, tree:0).", {
+    default: "blob:none",
+})
+    .option("--no-filter", "Fetch without object filter; may download a full snapshot pack.")
+    .action(async (flags, url) => {
+    const { client, logger } = makeClient(url, flags);
+    const filter = flags.filter === false ? undefined : flags.filter;
+    const { sha, commit } = unwrap(await client.fetchCommit(flags.ref, { depth: flags.depth, filter }));
+    console.log(`commit ${sha}`);
+    console.log(`tree ${commit.tree}`);
+    if (commit.parent)
+        console.log(`parent ${commit.parent}`);
+    if (commit.author)
+        console.log(`author ${commit.author}`);
+    if (commit.committer)
+        console.log(`committer ${commit.committer}`);
+    maybeStats(logger, flags);
+})
+    .command("cat-tree", "Fetch a commit snapshot and print its root tree as '<mode> <sha> <name>' per entry.")
+    .arguments("<url:string>")
+    .option("--ref <ref:string>", "Ref or commit sha to resolve.", { default: "HEAD" })
+    .option("--depth <n:integer>", "Shallow depth (ignored if server lacks shallow).", {
+    default: 1,
+    value: (n) => {
+        if (n < 1)
+            throw new ValidationError("--depth must be >= 1");
+        return n;
+    },
+})
+    .option("--filter <spec:string>", "Object filter spec (e.g. blob:none, tree:0).", {
+    default: "blob:none",
+})
+    .option("--no-filter", "Fetch without object filter; downloads a full snapshot pack.")
+    .option("--tree-sha <sha:string>", "Fetch the tree by SHA directly (no commit snapshot).")
+    .action(async (flags, url) => {
+    const { client, logger } = makeClient(url, flags);
+    if (flags.treeSha) {
+        for (const entry of unwrap(await client.fetchTree(flags.treeSha))) {
+            console.log(`${entry.mode} ${entry.sha} ${entry.name}`);
+        }
+    }
+    else {
+        const filter = flags.filter === false ? undefined : flags.filter;
+        const result = unwrap(await client.fetchTreeForCommit(flags.ref, { depth: flags.depth, filter }));
+        for (const entry of result.entries) {
+            console.log(`${entry.mode} ${entry.sha} ${entry.name}`);
+        }
+    }
+    maybeStats(logger, flags);
+})
+    .command("list-files", "List all files in a commit snapshot without cloning.")
+    .arguments("<url:string>")
+    .option("--ref <ref:string>", "Ref or commit sha to resolve.", { default: "HEAD" })
+    .option("--depth <n:integer>", "Shallow depth (ignored if server lacks shallow).", {
+    default: 1,
+    value: (n) => {
+        if (n < 1)
+            throw new ValidationError("--depth must be >= 1");
+        return n;
+    },
+})
+    .option("--filter <spec:string>", "Object filter spec (e.g. blob:none, tree:0).", {
+    default: "blob:none",
+})
+    .option("--no-filter", "Fetch without object filter; downloads a full snapshot pack.")
+    .option("--details", "Print '<mode> <sha> <path>' instead of path only.")
+    .action(async (flags, url) => {
+    const { client, logger } = makeClient(url, flags);
+    const filter = flags.filter === false ? undefined : flags.filter;
+    const result = unwrap(await client.fetchTreeForCommit(flags.ref, {
+        depth: flags.depth,
+        filter,
+        parseFull: true,
+    }));
+    printCachedFiles(client, result.entries, "", !!flags.details);
+    maybeStats(logger, flags);
+})
+    .command("cat-blob", "Fetch a blob and write raw bytes to stdout.")
+    .arguments("<url:string> <blob-sha:string>")
+    .action(async (flags, url, sha) => {
+    const { client, logger } = makeClient(url, flags);
+    await dntShim.Deno.stdout.write(unwrap(await client.fetchBlob(sha)));
+    maybeStats(logger, flags);
+})
+    .parse(dntShim.Deno.args);

package/esm/client.js

@@ -0,0 +1,439 @@
+/**
+ * @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 { ObjectDecodeError, ObjectNotFoundError, RefNotFoundError } from "./errors.js";
+import { Logger } from "./logger.js";
+import { parseCommit, parseTree } from "./objects/index.js";
+import { parsePackfile } from "./pack/index.js";
+import { buildFetchRequest, extractPack, parseRefAdvertisement, parseV2CapabilityAdvertisement, } from "./protocol/index.js";
+import { getSmartHttp, postUploadPack } from "./transport.js";
+/**
+ * Capabilities offered on every v0 fetch unless overridden. `shallow` and
+ * `filter` are appended dynamically when the corresponding feature is in use.
+ *
+ * - `multi_ack`: lets the server send `ACK` continuations while we're
+ *   negotiating wants. Required by some servers even on a `done` short-circuit.
+ * - `side-band-64k`: turns on the channel-multiplexed response framing
+ *   ({@link demuxSideband} expects this).
+ * - `ofs-delta`: allows the more compact offset-based delta encoding.
+ * - `agent=…`: identification string, mirrored into v2's `agent=` header.
+ */
+const DEFAULT_CAPS = [
+    "multi_ack",
+    "side-band-64k",
+    "ofs-delta",
+    "agent=git-remote-ops-deno/0.1",
+];
+function fail(error) {
+    return Result.err(error);
+}
+function buildCaps(opts = {}) {
+    return [
+        ...DEFAULT_CAPS,
+        ...(opts.shallow ? ["shallow"] : []),
+        ...(opts.filter ? ["filter"] : []),
+    ];
+}
+/**
+ * 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 class RemoteGit {
+    url;
+    logger;
+    profile = null;
+    objects = new Map();
+    snapshotCommits = new Set();
+    diagnostic;
+    transportLogger;
+    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, options) {
+        this.url = url.replace(/\/+$/, "");
+        this.diagnostic = options?.diagnostic;
+        this.logger = options?.logger ??
+            new Logger({
+                level: options?.diagnostic ? "debug" : "silent",
+                sink: options?.diagnostic,
+            }, "client");
+        this.transportLogger = this.logger.child("transport");
+        this.packLogger = this.logger.child("pack");
+    }
+    /**
+     * 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.
+     */
+    async discover() {
+        this.logger.info(`discover ${this.url}`);
+        const response = await getSmartHttp(this.url, "/info/refs?service=git-upload-pack", {
+            logger: this.transportLogger,
+        });
+        if (response.isErr())
+            return fail(response.error);
+        const parsed = parseRefAdvertisement(response.value.body);
+        if (parsed.isErr())
+            return fail(parsed.error);
+        let protocolVersion = 0;
+        const capabilities = new Set(parsed.value.capabilities);
+        const v2Response = await getSmartHttp(this.url, "/info/refs?service=git-upload-pack", {
+            protocolVersion: 2,
+            logger: this.transportLogger,
+        });
+        if (v2Response.isOk()) {
+            const parsedV2 = parseV2CapabilityAdvertisement(v2Response.value.body);
+            if (parsedV2.isOk() && parsedV2.value.has("version=2")) {
+                protocolVersion = 2;
+                for (const cap of parsedV2.value)
+                    capabilities.add(cap);
+            }
+        }
+        this.profile = {
+            url: this.url,
+            refs: parsed.value.refs,
+            advertisedCaps: capabilities,
+            protocolVersion,
+            supportsFilterBlobNone: false,
+            supportsFilterTree0: false,
+            supportsShallow: capabilities.has("shallow"),
+            probed: false,
+        };
+        return Result.ok(this.profile);
+    }
+    /**
+     * 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}.
+     */
+    async probe(verbose = false) {
+        const profileResult = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profileResult.isErr())
+            return fail(profileResult.error);
+        const profile = profileResult.value;
+        if (profile.probed) {
+            return Result.ok(profile);
+        }
+        profile.supportsShallow = profile.advertisedCaps.has("shallow");
+        const advertisesFilter = profile.advertisedCaps.has("filter");
+        const targetSha = this.pickProbeSha(profile);
+        if (targetSha.isErr())
+            return fail(targetSha.error);
+        if (advertisesFilter) {
+            await this.probeFilter(profile, targetSha.value, verbose);
+        }
+        profile.probed = true;
+        return Result.ok(profile);
+    }
+    /** Return a snapshot of the advertised refs (name → sha). Triggers `discover()` if needed. */
+    async lsRefs() {
+        const profile = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profile.isErr())
+            return fail(profile.error);
+        return Result.ok(new Map(profile.value.refs));
+    }
+    /**
+     * 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`.
+     */
+    async resolveRef(ref) {
+        const profile = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profile.isErr())
+            return fail(profile.error);
+        for (const candidate of [ref, `refs/heads/${ref}`, `refs/tags/${ref}`]) {
+            const sha = profile.value.refs.get(candidate);
+            if (sha) {
+                return Result.ok(sha);
+            }
+        }
+        if (/^[0-9a-f]{40}$/.test(ref)) {
+            return Result.ok(ref);
+        }
+        return fail(new RefNotFoundError({ ref, message: `ref not found: ${ref}` }));
+    }
+    /**
+     * 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.
+     */
+    async fetchCommit(ref, options = {}) {
+        const profile = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profile.isErr())
+            return fail(profile.error);
+        const commitSha = await this.resolveRef(ref);
+        if (commitSha.isErr())
+            return fail(commitSha.error);
+        const depth = options.depth !== undefined && profile.value.supportsShallow
+            ? options.depth
+            : undefined;
+        const filter = options.filter !== undefined && profile.value.advertisedCaps.has("filter")
+            ? options.filter
+            : undefined;
+        if (options.filter !== undefined && filter === undefined) {
+            this.logger.info(`server does not advertise object filters; fetching without ${options.filter}`);
+        }
+        const objects = await this.fetchObjects([commitSha.value], depth, filter, options.parseFull === true);
+        if (objects.isErr())
+            return fail(objects.error);
+        const object = requiredObject(objects.value, commitSha.value);
+        if (object.isErr())
+            return fail(object.error);
+        if (object.value.type !== "commit") {
+            return fail(new ObjectDecodeError({
+                reason: "unexpected-object-type",
+                message: `object is not a commit: ${commitSha.value}`,
+                objectType: object.value.type,
+                sha: commitSha.value,
+            }));
+        }
+        const commit = parseCommit(object.value.content);
+        if (commit.isErr())
+            return fail(commit.error);
+        return Result.ok({ commit: commit.value, sha: commitSha.value });
+    }
+    /** Fetch a blob by sha and return its raw contents. */
+    async fetchBlob(sha) {
+        const profile = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profile.isErr())
+            return fail(profile.error);
+        const objects = await this.fetchObjects([sha]);
+        if (objects.isErr())
+            return fail(objects.error);
+        const object = requiredObject(objects.value, sha);
+        if (object.isErr())
+            return fail(object.error);
+        if (object.value.type !== "blob") {
+            return fail(new ObjectDecodeError({
+                reason: "unexpected-object-type",
+                message: `object is not a blob: ${sha}`,
+                objectType: object.value.type,
+                sha,
+            }));
+        }
+        return Result.ok(object.value.content);
+    }
+    /**
+     * 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.
+     */
+    async fetchTreeForCommit(ref, options = {}) {
+        const commit = await this.fetchCommit(ref, { ...options, parseFull: true });
+        if (commit.isErr())
+            return fail(commit.error);
+        const treeObject = this.objects.get(commit.value.commit.tree);
+        if (!treeObject) {
+            return fail(new ObjectNotFoundError({
+                sha: commit.value.commit.tree,
+                message: `tree ${commit.value.commit.tree} not present in snapshot pack`,
+            }));
+        }
+        if (treeObject.type !== "tree") {
+            return fail(new ObjectDecodeError({
+                reason: "unexpected-object-type",
+                message: `object is not a tree: ${commit.value.commit.tree}`,
+                objectType: treeObject.type,
+                sha: commit.value.commit.tree,
+            }));
+        }
+        const entries = parseTree(treeObject.content);
+        if (entries.isErr())
+            return fail(entries.error);
+        return Result.ok({
+            commit: commit.value.commit,
+            commitSha: commit.value.sha,
+            entries: entries.value,
+        });
+    }
+    /** Fetch and decode a single tree by sha. */
+    async fetchTree(sha) {
+        const profile = this.profile ? Result.ok(this.profile) : await this.discover();
+        if (profile.isErr())
+            return fail(profile.error);
+        const objects = await this.fetchObjects([sha]);
+        if (objects.isErr())
+            return fail(objects.error);
+        const object = requiredObject(objects.value, sha);
+        if (object.isErr())
+            return fail(object.error);
+        if (object.value.type !== "tree") {
+            return fail(new ObjectDecodeError({
+                reason: "unexpected-object-type",
+                message: `object is not a tree: ${sha}`,
+                objectType: object.value.type,
+                sha,
+            }));
+        }
+        const tree = parseTree(object.value.content);
+        if (tree.isErr())
+            return fail(tree.error);
+        return Result.ok(tree.value);
+    }
+    /** Look up an already-materialized object by sha. Does not fetch on miss. */
+    getObject(sha) {
+        return this.objects.get(sha);
+    }
+    async fetchObjects(wants, depth, filterSpec, parseFull = false) {
+        const normalized = this.normalizeWants(wants, depth, filterSpec);
+        if (normalized.length === 0) {
+            return Result.ok(this.objects);
+        }
+        this.logger.debug(`fetchObjects wants=${normalized.length} depth=${depth ?? "-"} filter=${filterSpec ?? "-"}`);
+        const pack = await this.fetchPack(normalized, depth, filterSpec);
+        if (pack.isErr())
+            return fail(pack.error);
+        const parseStart = performance.now();
+        const targets = !parseFull && normalized.length === 1 ? new Set(normalized) : undefined;
+        const parsed = parsePackfile(pack.value, targets);
+        const parseMs = performance.now() - parseStart;
+        if (parsed.isErr())
+            return fail(parsed.error);
+        const counts = countByType(parsed.value);
+        this.packLogger.recordPack({
+            bytes: pack.value.length,
+            durationMs: parseMs,
+            byType: counts,
+        });
+        this.packLogger.debug(`parsed ${parsed.value.size} objects (${counts.commit}c/${counts.tree}t/${counts.blob}b/${counts.tag}T) in ${parseMs.toFixed(1)}ms`);
+        for (const [sha, object] of parsed.value) {
+            this.objects.set(sha, object);
+        }
+        if (depth === 1 && filterSpec === undefined) {
+            for (const sha of normalized)
+                this.snapshotCommits.add(sha);
+        }
+        return Result.ok(this.objects);
+    }
+    async probeFilter(profile, sha, verbose) {
+        const caps = buildCaps({ shallow: true, filter: true });
+        const blobNonePack = await this.fetchPack([sha], 1, "blob:none", caps);
+        if (blobNonePack.isErr()) {
+            if (verbose)
+                this.log(`filter blob:none probe failed: ${blobNonePack.error}`);
+        }
+        else {
+            const parsed = parsePackfile(blobNonePack.value);
+            if (parsed.isErr()) {
+                if (verbose)
+                    this.log(`filter blob:none probe failed: ${parsed.error}`);
+            }
+            else {
+                const counts = countByType(parsed.value);
+                if (verbose)
+                    this.log(`filter blob:none probe: ${counts.tree} trees, ${counts.blob} blobs`);
+                profile.supportsFilterBlobNone = counts.blob === 0 ||
+                    counts.blob < Math.floor(counts.tree / 4);
+            }
+        }
+        const tree0Pack = await this.fetchPack([sha], 1, "tree:0", caps);
+        if (tree0Pack.isErr()) {
+            if (verbose)
+                this.log(`filter tree:0 probe failed: ${tree0Pack.error}`);
+        }
+        else {
+            const parsed = parsePackfile(tree0Pack.value);
+            if (parsed.isErr()) {
+                if (verbose)
+                    this.log(`filter tree:0 probe failed: ${parsed.error}`);
+            }
+            else {
+                const counts = countByType(parsed.value);
+                profile.supportsFilterTree0 = counts.tree === 0;
+            }
+        }
+    }
+    async fetchPack(wants, depth, filterSpec, caps) {
+        const protocolVersion = this.profile?.protocolVersion ?? 0;
+        const requestCaps = caps ?? buildCaps({
+            shallow: depth !== undefined,
+            filter: filterSpec !== undefined,
+        });
+        const body = buildFetchRequest({
+            wants,
+            caps: requestCaps,
+            depth,
+            filterSpec,
+            protocolVersion,
+        });
+        if (body.isErr())
+            return fail(body.error);
+        const response = await postUploadPack(this.url, body.value, {
+            protocolVersion,
+            logger: this.transportLogger,
+        });
+        if (response.isErr())
+            return fail(response.error);
+        const pack = extractPack(response.value.body, this.diagnostic);
+        if (pack.isErr())
+            return fail(pack.error);
+        this.packLogger.debug(`extracted pack: ${pack.value.length}B`);
+        return Result.ok(pack.value);
+    }
+    normalizeWants(wants, depth, filterSpec) {
+        if (depth === 1 && filterSpec === undefined) {
+            return wants.every((want) => this.snapshotCommits.has(want)) ? [] : wants;
+        }
+        return wants.filter((want) => !this.objects.has(want));
+    }
+    pickProbeSha(profile) {
+        for (const ref of ["HEAD", "refs/heads/main", "refs/heads/master"]) {
+            const sha = profile.refs.get(ref);
+            if (sha)
+                return Result.ok(sha);
+        }
+        const next = profile.refs.values().next();
+        if (!next.done)
+            return Result.ok(next.value);
+        return fail(new ObjectNotFoundError({ sha: "", message: "no refs available for probe" }));
+    }
+    log(message) {
+        this.diagnostic?.(message);
+    }
+}
+function requiredObject(objects, sha) {
+    const object = objects.get(sha);
+    if (!object) {
+        return fail(new ObjectNotFoundError({ sha, message: `object not found: ${sha}` }));
+    }
+    return Result.ok(object);
+}
+function countByType(objects) {
+    const counts = { commit: 0, tree: 0, blob: 0, tag: 0 };
+    for (const obj of objects.values())
+        counts[obj.type]++;
+    return counts;
+}

package/esm/deps/jsr.io/@cliffy/command/1.1.0/_argument_types.js

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