cloving 1.0.1 → 1.2.0

package/dist/src/daemon/github-ci.js

@@ -0,0 +1,170 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { githubText } from "./github-calls.js";
+import { githubRead } from "./github-retry.js";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+function isCheckRun(value) {
+    const conclusion = field(value, "conclusion");
+    const details = field(value, "details_url");
+    const app = field(value, "app");
+    return (typeof field(value, "id") === "number" &&
+        typeof field(value, "name") === "string" &&
+        typeof field(value, "status") === "string" &&
+        (conclusion === null || typeof conclusion === "string") &&
+        (details === null || typeof details === "string") &&
+        (app === null || typeof field(app, "slug") === "string"));
+}
+const passing = new Set(["success", "neutral", "skipped"]);
+function latestRuns(checks, required) {
+    const latest = new Map();
+    for (const check of checks) {
+        const name = check.name;
+        if (required === undefined
+            ? check.app?.slug !== "github-actions"
+            : !required.has(name))
+            continue;
+        const previous = latest.get(name);
+        if (previous === undefined || check.id > previous.id)
+            latest.set(name, check);
+    }
+    return [...latest.values()];
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+async function checkRuns(operation, commit) {
+    const pages = JSON.parse(await githubRead(operation, [
+        "api",
+        "--paginate",
+        "--slurp",
+        `${repositoryPath}/commits/${commit}/check-runs?filter=all&per_page=100`,
+    ]));
+    if (!Array.isArray(pages) || pages.length === 0)
+        throw new Error("github-call-failed");
+    return list(pages).flatMap((page) => {
+        const checks = field(page, "check_runs");
+        if (!Array.isArray(checks) || !checks.every(isCheckRun))
+            throw new Error("github-call-failed");
+        return checks;
+    });
+}
+function unavailable(operation, error) {
+    operation.signal.throwIfAborted();
+    const detail = field(error, "detail");
+    return `CI diagnostics unavailable: ${githubText(typeof detail === "string" ? detail : "GitHub logs could not be read", operation.settings)}`;
+}
+async function failedSteps(operation, place) {
+    try {
+        const view = JSON.parse(await operation.calls.gh(["run", "view", place.run, "--json", "jobs"]));
+        return list(field(view, "jobs"))
+            .filter((job) => String(field(job, "databaseId")) === place.job)
+            .flatMap((job) => list(field(job, "steps")))
+            .filter((step) => typeof field(step, "conclusion") === "string" &&
+            !passing.has(String(field(step, "conclusion"))))
+            .map((step) => `Failed step: ${String(field(step, "name"))}`)
+            .join("\n");
+    }
+    catch (error) {
+        return unavailable(operation, error);
+    }
+}
+async function failedCheck(operation, check) {
+    const summary = [
+        `Failed check: ${check.name} (${check.conclusion ?? "null"})`,
+    ];
+    const details = check.details_url ?? "";
+    const run = /\/actions\/runs\/(\d+)/.exec(details)?.[1];
+    let log = "Failed log unavailable.";
+    if (run !== undefined) {
+        const job = /\/job\/(\d+)/.exec(details)?.[1];
+        summary.push(await failedSteps(operation, { run, job }));
+        log = await failedLog(operation, { run, job });
+    }
+    return {
+        summary: githubText(summary.join("\n"), operation.settings),
+        log: githubText(log, operation.settings),
+    };
+}
+async function failedLog(operation, place) {
+    try {
+        return await operation.calls.gh([
+            "run",
+            "view",
+            place.run,
+            "--log-failed",
+            ...(place.job === undefined ? [] : ["--job", place.job]),
+        ]);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        if (place.job === undefined)
+            return unavailable(operation, error);
+        return operation.calls
+            .gh(["api", `${repositoryPath}/actions/jobs/${place.job}/logs`])
+            .catch((failure) => unavailable(operation, failure));
+    }
+}
+async function failedOutput(operation, checks) {
+    const reports = [];
+    for (const check of checks)
+        reports.push(await failedCheck(operation, check));
+    const summary = reports.map((report) => report.summary).join("\n");
+    const available = Math.max(0, 6_000 - summary.length - reports.length);
+    const allowance = Math.floor(available / reports.length);
+    return [
+        summary,
+        ...reports.map((report) => allowance === 0 ? "" : report.log.slice(-allowance)),
+    ]
+        .join("\n")
+        .slice(0, 6_000);
+}
+function requiredChecks(operation) {
+    const setting = operation.settings.environment?.["CLOVING_REQUIRED_CHECKS"] ??
+        process.env["CLOVING_REQUIRED_CHECKS"];
+    if (setting === undefined)
+        return undefined;
+    const names = JSON.parse(setting);
+    if (!Array.isArray(names) ||
+        !names.every((name) => typeof name === "string" && name.trim() !== ""))
+        throw new Error("invalid-payload");
+    return new Set(names);
+}
+function pendingChecks(checks, names) {
+    return [...names].filter((name) => !checks.some((check) => check.name === name && check.status === "completed"));
+}
+export async function waitForCi(operation, commit) {
+    const { pollMilliseconds: poll, ciGraceMilliseconds: grace, ciLimitMilliseconds: limit, } = {
+        ...githubTiming,
+        ciGraceMilliseconds: 60_000,
+        ciLimitMilliseconds: 5_400_000,
+        ...operation.settings.timing,
+    };
+    const started = Date.now();
+    const required = requiredChecks(operation);
+    const names = new Set(required);
+    for (;;) {
+        const checks = latestRuns(await checkRuns(operation, commit), required);
+        for (const check of checks)
+            names.add(check.name);
+        const failed = checks.filter((check) => check.status === "completed" && !passing.has(check.conclusion ?? ""));
+        if (failed.length > 0)
+            return {
+                reason: "ci-failed",
+                output: await failedOutput(operation, failed),
+            };
+        const pending = pendingChecks(checks, names);
+        if (pending.length === 0 &&
+            (required !== undefined ||
+                names.size > 0 ||
+                Date.now() - started >= grace))
+            return undefined;
+        const remaining = limit - (Date.now() - started);
+        if (remaining <= 0)
+            return {
+                reason: "ci-pending",
+                output: `CI wait limit reached for ${commit}. Pending checks: ${pending.join(", ") || "waiting for GitHub Actions checks"}`,
+            };
+        await delay(Math.min(poll, remaining), undefined, {
+            signal: operation.signal,
+        });
+    }
+}

package/dist/src/daemon/github-merge-call.d.ts

@@ -0,0 +1,14 @@
+import { type Operation } from "./github-operation.ts";
+export interface ReviewedPull {
+    readonly number: number;
+    readonly commit: string;
+}
+export declare function knownMerge(operation: Operation, expected: ReviewedPull & {
+    readonly updated: string;
+}): Promise<{
+    readonly head: string;
+    readonly merged: string | undefined;
+}>;
+export declare function mergePull(operation: Operation, pull: ReviewedPull & {
+    readonly updated: string;
+}): Promise<string>;

package/dist/src/daemon/github-merge-call.js

@@ -0,0 +1,73 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { field, githubTiming, repositoryPath, } from "./github-operation.js";
+import { githubRead, retryGithub } from "./github-retry.js";
+function commitOf(value, name) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("github-call-failed");
+    const commit = Reflect.get(value, name);
+    if (typeof commit !== "string")
+        throw new Error("github-call-failed");
+    return commit;
+}
+export async function knownMerge(operation, expected) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(expected.number)}`,
+    ]));
+    const head = commitOf(field(pull, "head"), "sha");
+    if (field(pull, "merged") !== true)
+        return { head, merged: undefined };
+    if (head !== expected.commit && head !== expected.updated)
+        throw new Error("merged-other-commit");
+    return { head, merged: commitOf(pull, "merge_commit_sha") };
+}
+async function mergedNow(operation, pull) {
+    const reply = JSON.parse(await operation.calls.gh([
+        "api",
+        "-X",
+        "PUT",
+        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
+        "-f",
+        "merge_method=merge",
+        "-f",
+        `sha=${pull.commit}`,
+    ]));
+    return commitOf(reply, "sha");
+}
+async function waitForHead(operation, pull) {
+    const timing = operation.settings.timing ?? githubTiming;
+    for (let attempt = 0; attempt < 30; attempt += 1) {
+        if (attempt > 0)
+            await delay(timing.pollMilliseconds, undefined, {
+                signal: operation.signal,
+            });
+        const current = JSON.parse(await githubRead(operation, [
+            "api",
+            `${repositoryPath}/pulls/${String(pull.number)}`,
+        ]));
+        if (commitOf(field(current, "head"), "sha") === pull.commit)
+            return;
+    }
+    throw new Error("head-not-updated");
+}
+export function mergePull(operation, pull) {
+    return retryGithub(operation, {
+        action: async (attempt) => {
+            const known = attempt > 0 ? await knownMerge(operation, pull) : undefined;
+            if (known?.merged !== undefined)
+                return known.merged;
+            const updated = { number: pull.number, commit: pull.updated };
+            if (pull.updated !== pull.commit)
+                await waitForHead(operation, updated);
+            return mergedNow(operation, updated);
+        },
+        statuses: pull.updated === pull.commit ? [] : [405, 409],
+    }).catch(async (error) => {
+        if (!(error instanceof Error) || error.message !== "github-network-failed")
+            throw error;
+        const known = await knownMerge(operation, pull);
+        if (known.merged !== undefined)
+            return known.merged;
+        throw error;
+    });
+}

package/dist/src/daemon/github-merge.d.ts

@@ -1,8 +1,6 @@
 import { type Operation } from "./github-operation.ts";
-interface ReviewedPull {
-    readonly number: number;
-    readonly commit: string;
-}
+import { type CiResult } from "./github-ci.ts";
+import { type ReviewedPull } from "./github-merge-call.ts";
 interface SuccessfulMerge {
     readonly number: number;
     readonly commit: string;
@@ -13,6 +11,6 @@ interface MergeRepair {
     readonly reason: "check-failed" | "merge-conflict";
     readonly output: string;
 }
-export type MergeResult = SuccessfulMerge | MergeRepair;
+export type MergeResult = SuccessfulMerge | MergeRepair | CiResult;
 export declare function merge(operation: Operation, pull: ReviewedPull): Promise<MergeResult>;
 export {};

package/dist/src/daemon/github-merge.js

@@ -1,28 +1,10 @@
 import { existsSync } from "node:fs";
-import { setTimeout as delay } from "node:timers/promises";
 import { readRecord, writeRecord } from "./operation-journal.js";
-import { changeChecked, defaultBranch, existingTree, field, githubTiming, removeWorktree, repositoryPath, } from "./github-operation.js";
+import { changeChecked, defaultBranch, existingTree, field, removeWorktree, repositoryPath, } from "./github-operation.js";
 import { treePlace } from "./work-tree.js";
-function commitOf(value, name) {
-    if (typeof value !== "object" || value === null)
-        throw new Error("github-call-failed");
-    const commit = Reflect.get(value, name);
-    if (typeof commit !== "string")
-        throw new Error("github-call-failed");
-    return commit;
-}
-async function knownMerge(operation, expected) {
-    const pull = JSON.parse(await operation.calls.gh([
-        "api",
-        `${repositoryPath}/pulls/${String(expected.number)}`,
-    ]));
-    const head = commitOf(field(pull, "head"), "sha");
-    if (field(pull, "merged") !== true)
-        return { head, merged: undefined };
-    if (head !== expected.commit && head !== expected.updated)
-        throw new Error("merged-other-commit");
-    return { head, merged: commitOf(pull, "merge_commit_sha") };
-}
+import { waitForCi } from "./github-ci.js";
+import { githubText } from "./github-calls.js";
+import { knownMerge, mergePull, } from "./github-merge-call.js";
 async function abortMerge(operation, tree) {
     const path = (await operation.calls.git(tree.path, [
         "rev-parse",
@@ -69,14 +51,19 @@ async function updatedTree(operation, place) {
             place.base,
         ]);
     }
-    catch {
+    catch (error) {
         const conflicts = await calls.git(place.tree.path, [
             "diff",
             "--name-only",
             "--diff-filter=U",
         ]);
         await calls.git(place.tree.path, ["merge", "--abort"]);
-        throw new Error("merge-conflict", { cause: conflicts.trim() });
+        const output = commandOutput(error instanceof Error ? error.cause : error);
+        throw Object.assign(new Error("merge-conflict", { cause: error }), {
+            output: githubText(output + conflicts, operation.settings)
+                .slice(-6_000)
+                .trim(),
+        });
     }
 }
 async function checked(operation, place) {
@@ -115,52 +102,6 @@ async function refreshed(operation, place) {
     }
     throw new Error("base-moved");
 }
-async function mergedNow(operation, pull) {
-    const reply = JSON.parse(await operation.calls.gh([
-        "api",
-        "-X",
-        "PUT",
-        `${repositoryPath}/pulls/${String(pull.number)}/merge`,
-        "-f",
-        "merge_method=merge",
-        "-f",
-        `sha=${pull.commit}`,
-    ]));
-    return commitOf(reply, "sha");
-}
-async function waitForHead(operation, pull) {
-    const timing = operation.settings.timing ?? githubTiming;
-    for (let attempt = 0; attempt < 30; attempt += 1) {
-        if (attempt > 0)
-            await delay(timing.pollMilliseconds, undefined, {
-                signal: operation.signal,
-            });
-        const current = JSON.parse(await operation.calls.gh([
-            "api",
-            `${repositoryPath}/pulls/${String(pull.number)}`,
-        ]));
-        if (commitOf(field(current, "head"), "sha") === pull.commit)
-            return;
-    }
-    throw new Error("head-not-updated");
-}
-async function mergeUpdated(operation, pull) {
-    const timing = operation.settings.timing ?? githubTiming;
-    for (let attempt = 0;; attempt += 1) {
-        await waitForHead(operation, pull);
-        try {
-            return await mergedNow(operation, pull);
-        }
-        catch (error) {
-            const status = field(error, "status");
-            if (attempt === 2 || (status !== 405 && status !== 409))
-                throw error;
-            await delay(timing.pollMilliseconds, undefined, {
-                signal: operation.signal,
-            });
-        }
-    }
-}
 async function removed(operation, place) {
     const { settings, calls } = operation;
     await calls
@@ -191,35 +132,47 @@ async function recordedHead(operation, commit) {
 }
 async function readyHead(operation, pull) {
     const tree = existingTree(operation);
-    const updated = await refreshed(operation, {
-        tree,
-        commit: pull.commit,
-        recorded: pull.recorded,
-    });
-    if (updated === pull.commit)
-        return updated;
-    if (pull.recorded !== updated)
-        await writeRecord(operation.folder, {
-            name: "updated-head.json",
-            value: { commit: pull.commit, updated },
+    let recorded = pull.recorded;
+    let remote = pull.remote;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const updated = await refreshed(operation, {
+            tree,
+            commit: pull.commit,
+            recorded,
         });
-    if (pull.remote !== updated)
-        await operation.calls.git(tree.path, [
-            "push",
-            "--quiet",
-            "origin",
-            `${updated}:refs/heads/${tree.branch}`,
-        ]);
-    return updated;
+        if (updated !== pull.commit && recorded !== updated)
+            await writeRecord(operation.folder, {
+                name: "updated-head.json",
+                value: { commit: pull.commit, updated },
+            });
+        if (updated !== pull.commit && remote !== updated)
+            await operation.calls.git(tree.path, [
+                "push",
+                "--quiet",
+                "origin",
+                `${updated}:refs/heads/${tree.branch}`,
+            ]);
+        const ci = await waitForCi(operation, updated);
+        if (ci !== undefined)
+            return ci;
+        const newest = await fetched(operation, await defaultBranch(operation));
+        if ((await operation.calls.git(tree.path, ["merge-base", updated, newest])).trim() === newest)
+            return updated;
+        recorded = updated;
+        remote = updated;
+    }
+    throw new Error("base-moved");
 }
 function checkOutput(cause) {
+    return commandOutput(cause).slice(-6_000);
+}
+function commandOutput(cause) {
     return ["stdout", "stderr"]
         .map((name) => {
         const value = field(cause, name);
         return typeof value === "string" ? value : "";
     })
-        .join("")
-        .slice(-6_000);
+        .join("");
 }
 export async function merge(operation, pull) {
     try {
@@ -232,10 +185,13 @@ export async function merge(operation, pull) {
         const reason = error.message;
         if (reason !== "check-failed" && reason !== "merge-conflict")
             throw error;
-        const conflicts = typeof error.cause === "string" ? error.cause : "";
+        const detail = field(error, "output");
+        const conflicts = typeof detail === "string" ? detail : "";
         return {
             reason,
-            output: reason === "check-failed" ? checkOutput(error.cause) : conflicts,
+            output: reason === "check-failed"
+                ? checkOutput(error.cause)
+                : githubText(conflicts, operation.settings),
         };
     }
 }
@@ -252,8 +208,9 @@ async function completedMerge(operation, pull) {
     const updated = known.merged === undefined
         ? await readyHead(operation, { ...pull, recorded, remote: known.head })
         : (recorded ?? pull.commit);
-    const mergeCall = updated === pull.commit ? mergedNow : mergeUpdated;
-    const merged = known.merged ?? (await mergeCall(operation, { ...pull, commit: updated }));
+    if (typeof updated !== "string")
+        return updated;
+    const merged = known.merged ?? (await mergePull(operation, { ...pull, updated }));
     await removed(operation, place);
     return { number: pull.number, commit: pull.commit, updated, merged };
 }

package/dist/src/daemon/github-methods.d.ts

@@ -1,5 +1,33 @@
+import { type Finding, type Scored } from "./github-calls.ts";
 import { type Operation } from "./github-operation.ts";
 export type { GithubTiming, MethodSettings } from "./github-operation.ts";
 export declare const methodReasons: ReadonlySet<string>;
+export interface ReviewResult extends Scored {
+    readonly number: number;
+    readonly commit: string;
+    readonly findings: readonly Finding[];
+}
+interface ReviewFailure {
+    readonly call: "read-review" | "request-review";
+    readonly reason: "github-call-failed" | "invalid-review-response";
+    readonly status?: number;
+}
+interface ReviewClock {
+    readonly now: () => number;
+    readonly sleep: (milliseconds: number, signal: AbortSignal) => Promise<void>;
+}
+interface ReviewWait {
+    readonly clock: ReviewClock;
+    failedReads: number;
+    requests: number;
+    acceptedRequests: number;
+    requestedAt: number;
+    lastFailure: ReviewFailure | null;
+}
+export declare class ReviewTimeout extends Error {
+    readonly detail: string;
+    constructor(wait: ReviewWait);
+}
+export declare function waitReview(operation: Operation, clock?: ReviewClock): Promise<ReviewResult>;
 export type Method = (operation: Operation) => Promise<unknown>;
 export declare const methods: ReadonlyMap<string, Method>;

package/dist/src/daemon/github-methods.js

@@ -1,16 +1,22 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { findingsOf, scoreOf } from "./github-calls.js";
+import { appendFile } from "node:fs/promises";
+import { join } from "node:path";
+import { findingsOf, scoreOf, } from "./github-calls.js";
+import { closeIssue, partialIssue } from "./github-ticket-status.js";
 import { merge } from "./github-merge.js";
 import { createIssue, discard } from "./github-issue-methods.js";
 import { existingTree, defaultBranch, changeChecked, field, githubTiming, repositoryPath, text, } from "./github-operation.js";
 import { workTree } from "./work-tree.js";
 const triggerText = "@greptileai";
+const maximumReviewRequests = 3;
 export const methodReasons = new Set([
     "draft-not-available",
     "invalid-draft",
     "post-uncertain",
     "private-texts-not-set",
     "github-call-failed",
+    "github-network-failed",
+    "github-issue-conflict",
     "git-call-failed",
     "check-failed",
     "merge-conflict",
@@ -155,34 +161,96 @@ async function reviewed(operation, pull) {
     const lines = await read(`pulls/${String(number)}/comments?per_page=100`);
     return { number, commit, ...scored, findings: findingsOf(lines, commit) };
 }
-async function waitReview(operation) {
+const reviewClock = {
+    now: () => Date.now(),
+    sleep: async (milliseconds, signal) => {
+        await delay(milliseconds, undefined, { signal });
+    },
+};
+export class ReviewTimeout extends Error {
+    detail;
+    constructor(wait) {
+        super("review-not-received");
+        this.detail = JSON.stringify({
+            failedReads: wait.failedReads,
+            requests: wait.requests,
+            acceptedRequests: wait.acceptedRequests,
+            lastFailure: wait.lastFailure,
+        });
+    }
+}
+async function reviewFailure(operation, failed) {
+    const { wait, call, error } = failed;
+    const status = field(error, "status");
+    const failure = {
+        call,
+        reason: error instanceof SyntaxError
+            ? "invalid-review-response"
+            : "github-call-failed",
+        ...(typeof status === "number" &&
+            Number.isInteger(status) &&
+            status >= 400 &&
+            status <= 599
+            ? { status }
+            : {}),
+    };
+    wait.lastFailure = failure;
+    await appendFile(join(operation.folder, "review-failures.jsonl"), JSON.stringify(failure) + "\n", { mode: 0o600 }).catch(() => undefined);
+}
+async function requestReview(operation, request) {
+    const { wait, number } = request;
+    wait.requests++;
+    try {
+        await operation.calls.gh([
+            "pr",
+            "comment",
+            String(number),
+            "--body",
+            triggerText,
+        ]);
+        wait.acceptedRequests++;
+        wait.requestedAt = wait.clock.now();
+    }
+    catch (error) {
+        await reviewFailure(operation, { wait, call: "request-review", error });
+    }
+}
+export async function waitReview(operation, clock = reviewClock) {
     const pull = {
         number: integer(operation, "number"),
         commit: text(operation, "commit"),
     };
     const timing = operation.settings.timing ?? githubTiming;
-    const startedAt = Date.now();
-    let triggered = false;
+    const startedAt = clock.now();
+    const wait = {
+        clock,
+        failedReads: 0,
+        requests: 0,
+        acceptedRequests: 0,
+        requestedAt: startedAt,
+        lastFailure: null,
+    };
     for (;;) {
-        const review = await reviewed(operation, pull).catch(() => undefined);
+        const review = await reviewed(operation, pull).catch(async (error) => {
+            wait.failedReads++;
+            await reviewFailure(operation, { wait, call: "read-review", error });
+            return undefined;
+        });
         if (review !== undefined)
             return review;
-        const waited = Date.now() - startedAt;
+        const waited = clock.now() - startedAt;
         if (waited >= timing.limitMilliseconds)
-            throw new Error("review-not-received");
-        if (!triggered && waited >= timing.triggerMilliseconds) {
-            triggered = true;
-            await operation.calls
-                .gh(["pr", "comment", String(pull.number), "--body", triggerText])
-                .catch(() => undefined);
-        }
-        await delay(timing.pollMilliseconds, undefined, {
-            signal: operation.signal,
-        });
+            throw new ReviewTimeout(wait);
+        if (wait.acceptedRequests < maximumReviewRequests &&
+            clock.now() - wait.requestedAt >= timing.triggerMilliseconds)
+            await requestReview(operation, { wait, number: pull.number });
+        await clock.sleep(timing.pollMilliseconds, operation.signal);
     }
 }
 export const methods = new Map([
     ["prepare", prepare],
+    ["close-issue", closeIssue],
+    ["partial-issue", partialIssue],
     ["label", label],
     ["create-issue", createIssue],
     ["discard", discard],

package/dist/src/daemon/github-operation.d.ts

@@ -3,6 +3,8 @@ export interface GithubTiming {
     readonly pollMilliseconds: number;
     readonly triggerMilliseconds: number;
     readonly limitMilliseconds: number;
+    readonly ciLimitMilliseconds?: number;
+    readonly ciGraceMilliseconds?: number;
 }
 export declare const githubTiming: GithubTiming;
 export interface MethodSettings extends CallSettings {

package/dist/src/daemon/github-retry.d.ts

@@ -0,0 +1,6 @@
+import { type Operation } from "./github-operation.ts";
+export declare function retryGithub<Result>(operation: Operation, retry: {
+    readonly action: (attempt: number) => Promise<Result>;
+    readonly statuses?: readonly number[];
+}): Promise<Result>;
+export declare function githubRead(operation: Operation, parts: readonly string[]): Promise<string>;