cloving 0.3.20 → 1.1.0

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

@@ -0,0 +1,259 @@
+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 { 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") };
+}
+async function abortMerge(operation, tree) {
+    const path = (await operation.calls.git(tree.path, [
+        "rev-parse",
+        "--git-path",
+        "MERGE_HEAD",
+    ])).trim();
+    if (existsSync(path))
+        await operation.calls.git(tree.path, ["merge", "--abort"]);
+}
+async function restored(operation, place) {
+    await abortMerge(operation, place.tree);
+    await clean(operation, place.tree);
+    if ((await headOf(operation, place.tree)) === place.commit)
+        return;
+    await operation.calls.git(place.tree.path, ["reset", "--hard", place.commit]);
+}
+async function clean(operation, tree) {
+    const status = await operation.calls.git(tree.path, [
+        "status",
+        "--porcelain",
+        "--untracked-files=no",
+    ]);
+    if (status.trim() !== "")
+        throw new Error("uncommitted-change");
+}
+async function headOf(operation, tree) {
+    return (await operation.calls.git(tree.path, ["rev-parse", "HEAD"])).trim();
+}
+async function fetched(operation, base) {
+    const { calls, settings } = operation;
+    await calls.git(settings.repository, ["fetch", "--quiet", "origin"]);
+    return (await calls.git(settings.repository, ["rev-parse", `origin/${base}`])).trim();
+}
+async function updatedTree(operation, place) {
+    const { calls } = operation;
+    const ancestor = (await calls.git(place.tree.path, ["merge-base", "HEAD", place.base])).trim();
+    if (ancestor === place.base)
+        return;
+    try {
+        await calls.git(place.tree.path, [
+            "merge",
+            "--no-ff",
+            "--no-edit",
+            place.base,
+        ]);
+    }
+    catch {
+        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() });
+    }
+}
+async function checked(operation, place) {
+    await changeChecked(operation, place);
+    const head = await headOf(operation, place.tree);
+    if (operation.settings.check !== undefined)
+        await operation.calls.run(operation.settings.check, place.tree.path);
+    await clean(operation, place.tree);
+    if ((await headOf(operation, place.tree)) !== head)
+        throw new Error("uncommitted-change");
+    if (head !== place.commit && operation.settings.check === undefined)
+        throw new Error("check-required");
+    return head;
+}
+async function refreshed(operation, place) {
+    await restored(operation, {
+        tree: place.tree,
+        commit: place.recorded ?? place.commit,
+    });
+    const base = await defaultBranch(operation);
+    let newest = await fetched(operation, base);
+    if (place.recorded !== undefined &&
+        (await operation.calls.git(place.tree.path, [
+            "merge-base",
+            place.recorded,
+            newest,
+        ])).trim() === newest)
+        return place.recorded;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        await updatedTree(operation, { tree: place.tree, base: newest });
+        const head = await checked(operation, { ...place, base });
+        const latest = await fetched(operation, base);
+        if (latest === newest)
+            return head;
+        newest = latest;
+    }
+    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
+        .gh([
+        "api",
+        "-X",
+        "DELETE",
+        `${repositoryPath}/git/refs/heads/${place.branch}`,
+    ])
+        .catch(() => undefined);
+    await removeWorktree(operation, place);
+    await calls.git(settings.repository, [
+        "update-ref",
+        "-d",
+        `refs/remotes/origin/${place.branch}`,
+    ]);
+}
+async function recordedHead(operation, commit) {
+    const record = await readRecord(operation.folder, "updated-head.json");
+    if (record === undefined)
+        return undefined;
+    const updated = field(record, "updated");
+    if (field(record, "commit") !== commit ||
+        typeof updated !== "string" ||
+        !/^[0-9a-f]{40,64}$/.test(updated))
+        throw new Error("git-call-failed");
+    return updated;
+}
+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 },
+        });
+    if (pull.remote !== updated)
+        await operation.calls.git(tree.path, [
+            "push",
+            "--quiet",
+            "origin",
+            `${updated}:refs/heads/${tree.branch}`,
+        ]);
+    return updated;
+}
+function checkOutput(cause) {
+    return ["stdout", "stderr"]
+        .map((name) => {
+        const value = field(cause, name);
+        return typeof value === "string" ? value : "";
+    })
+        .join("")
+        .slice(-6_000);
+}
+export async function merge(operation, pull) {
+    try {
+        return await completedMerge(operation, pull);
+    }
+    catch (error) {
+        operation.signal.throwIfAborted();
+        if (!(error instanceof Error))
+            throw error;
+        const reason = error.message;
+        if (reason !== "check-failed" && reason !== "merge-conflict")
+            throw error;
+        const conflicts = typeof error.cause === "string" ? error.cause : "";
+        return {
+            reason,
+            output: reason === "check-failed" ? checkOutput(error.cause) : conflicts,
+        };
+    }
+}
+async function completedMerge(operation, pull) {
+    const place = treePlace({
+        worktrees: operation.settings.worktrees,
+        target: operation.target,
+    });
+    const recorded = await recordedHead(operation, pull.commit);
+    const known = await knownMerge(operation, {
+        ...pull,
+        updated: recorded ?? pull.commit,
+    });
+    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 }));
+    await removed(operation, place);
+    return { number: pull.number, commit: pull.commit, updated, merged };
+}

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

@@ -0,0 +1,5 @@
+import { type Operation } from "./github-operation.ts";
+export type { GithubTiming, MethodSettings } from "./github-operation.ts";
+export declare const methodReasons: ReadonlySet<string>;
+export type Method = (operation: Operation) => Promise<unknown>;
+export declare const methods: ReadonlyMap<string, Method>;

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

@@ -0,0 +1,202 @@
+import { setTimeout as delay } from "node:timers/promises";
+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";
+export const methodReasons = new Set([
+    "draft-not-available",
+    "invalid-draft",
+    "post-uncertain",
+    "private-texts-not-set",
+    "github-call-failed",
+    "github-issue-conflict",
+    "git-call-failed",
+    "check-failed",
+    "merge-conflict",
+    "check-required",
+    "base-moved",
+    "head-not-updated",
+    "uncommitted-change",
+    "invalid-payload",
+    "merged-other-commit",
+    "no-change",
+    "private-path-in-change",
+    "review-not-received",
+    "work-tree-not-available",
+]);
+function integer(operation, name) {
+    const value = operation.payload[name];
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1)
+        throw new Error("invalid-payload");
+    return value;
+}
+async function prepare(operation) {
+    const { settings, calls, target, signal } = operation;
+    await calls.git(settings.repository, ["fetch", "--quiet", "origin"]);
+    const base = await defaultBranch(operation);
+    const tree = await workTree({
+        repository: settings.repository,
+        worktrees: settings.worktrees,
+        target,
+        signal,
+        base: `origin/${base}`,
+    }).catch(() => {
+        throw new Error("work-tree-not-available");
+    });
+    return {
+        branch: tree.branch,
+        worktree: tree.path,
+        base,
+        startCommit: tree.startCommit,
+    };
+}
+function labels(operation, name) {
+    const value = operation.payload[name];
+    if (!Array.isArray(value))
+        throw new Error("invalid-payload");
+    return value.map((label) => {
+        if (typeof label !== "string" || label.trim() === "")
+            throw new Error("invalid-payload");
+        return label;
+    });
+}
+async function label(operation) {
+    const repository = `${text(operation, "owner")}/${text(operation, "repository")}`;
+    const number = integer(operation, "number");
+    if (!/^[\w.-]+\/[\w.-]+$/.test(repository) || !Number.isSafeInteger(number))
+        throw new Error("invalid-payload");
+    const added = labels(operation, "add");
+    const removed = labels(operation, "remove");
+    for (const name of new Set([...added, ...removed]))
+        await operation.calls.gh([
+            "label",
+            "create",
+            name,
+            "--repo",
+            repository,
+            "--color",
+            "ededed",
+            "--force",
+        ]);
+    await operation.calls.gh([
+        "issue",
+        "edit",
+        String(number),
+        "--repo",
+        repository,
+        ...added.flatMap((name) => ["--add-label", name]),
+        ...removed.flatMap((name) => ["--remove-label", name]),
+    ]);
+    return { number };
+}
+async function pullOf(operation, branch) {
+    const listed = JSON.parse(await operation.calls.gh([
+        "pr",
+        "list",
+        "--head",
+        branch,
+        "--state",
+        "open",
+        "--json",
+        "number,url",
+    ]));
+    const first = Array.isArray(listed) ? listed[0] : undefined;
+    if (first === undefined)
+        return undefined;
+    return {
+        number: Number(field(first, "number")),
+        url: String(field(first, "url")),
+    };
+}
+async function created(operation, place) {
+    const printed = await operation.calls.gh([
+        "pr",
+        "create",
+        "--head",
+        place.tree.branch,
+        "--base",
+        place.base,
+        "--title",
+        text(operation, "title"),
+        "--body",
+        text(operation, "body"),
+    ]);
+    const url = printed.trim().split("\n").at(-1) ?? "";
+    const number = Number(/\/pull\/(\d+)$/.exec(url)?.[1]);
+    if (!Number.isInteger(number))
+        throw new Error("github-call-failed");
+    return { number, url };
+}
+async function openPull(operation) {
+    const tree = existingTree(operation);
+    const base = await defaultBranch(operation);
+    await changeChecked(operation, { tree, base });
+    await operation.calls.git(tree.path, [
+        "push",
+        "--quiet",
+        "origin",
+        `HEAD:refs/heads/${tree.branch}`,
+    ]);
+    const commit = (await operation.calls.git(tree.path, ["rev-parse", "HEAD"])).trim();
+    const pull = (await pullOf(operation, tree.branch)) ??
+        (await created(operation, { tree, base }));
+    return { number: pull.number, url: pull.url, commit };
+}
+async function reviewed(operation, pull) {
+    const { number, commit } = pull;
+    const read = async (path) => {
+        const value = JSON.parse(await operation.calls.gh(["api", `${repositoryPath}/${path}`]));
+        return value;
+    };
+    const scored = scoreOf(await read(`issues/${String(number)}/comments?per_page=100`), commit);
+    if (scored === undefined)
+        return undefined;
+    const lines = await read(`pulls/${String(number)}/comments?per_page=100`);
+    return { number, commit, ...scored, findings: findingsOf(lines, commit) };
+}
+async function waitReview(operation) {
+    const pull = {
+        number: integer(operation, "number"),
+        commit: text(operation, "commit"),
+    };
+    const timing = operation.settings.timing ?? githubTiming;
+    const startedAt = Date.now();
+    let triggered = false;
+    for (;;) {
+        const review = await reviewed(operation, pull).catch(() => undefined);
+        if (review !== undefined)
+            return review;
+        const waited = Date.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,
+        });
+    }
+}
+export const methods = new Map([
+    ["prepare", prepare],
+    ["close-issue", closeIssue],
+    ["partial-issue", partialIssue],
+    ["label", label],
+    ["create-issue", createIssue],
+    ["discard", discard],
+    ["open-pr", openPull],
+    ["wait-review", waitReview],
+    [
+        "merge",
+        (operation) => merge(operation, {
+            number: integer(operation, "number"),
+            commit: text(operation, "commit"),
+        }),
+    ],
+]);

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

@@ -0,0 +1,38 @@
+import type { CallSettings, Calls } from "./github-calls.ts";
+export interface GithubTiming {
+    readonly pollMilliseconds: number;
+    readonly triggerMilliseconds: number;
+    readonly limitMilliseconds: number;
+}
+export declare const githubTiming: GithubTiming;
+export interface MethodSettings extends CallSettings {
+    readonly worktrees: string;
+    readonly timing?: GithubTiming;
+    readonly check?: readonly string[];
+}
+export interface Operation {
+    readonly settings: MethodSettings;
+    readonly calls: Calls;
+    readonly target: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly signal: AbortSignal;
+    readonly folder: string;
+}
+export interface Place {
+    readonly path: string;
+    readonly branch: string;
+}
+export interface Pull {
+    readonly number: number;
+    readonly url: string;
+}
+export declare const repositoryPath = "repos/{owner}/{repo}";
+export declare function text(operation: Operation, name: string): string;
+export declare function field(value: unknown, name: string): unknown;
+export declare function existingTree(operation: Operation): Place;
+export declare function removeWorktree(operation: Operation, place: Place): Promise<void>;
+export declare function defaultBranch(operation: Operation): Promise<string>;
+export declare function changeChecked(operation: Operation, place: {
+    readonly tree: Place;
+    readonly base: string;
+}): Promise<void>;

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

@@ -0,0 +1,57 @@
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { treePlace } from "./work-tree.js";
+export const githubTiming = {
+    pollMilliseconds: 30_000,
+    triggerMilliseconds: 300_000,
+    limitMilliseconds: 3_600_000,
+};
+export const repositoryPath = "repos/{owner}/{repo}";
+export function text(operation, name) {
+    const value = operation.payload[name];
+    if (typeof value !== "string" || value === "")
+        throw new Error("invalid-payload");
+    return value;
+}
+export function field(value, name) {
+    return Reflect.get(Object(value), name);
+}
+export function existingTree(operation) {
+    const place = treePlace({
+        worktrees: operation.settings.worktrees,
+        target: operation.target,
+    });
+    if (!existsSync(join(place.path, ".git")))
+        throw new Error("work-tree-not-available");
+    return place;
+}
+export async function removeWorktree(operation, place) {
+    const repository = (parts) => operation.calls.git(operation.settings.repository, parts);
+    if (existsSync(join(place.path, ".git")))
+        await repository(["worktree", "remove", "--force", place.path]);
+    if ((await repository(["branch", "--list", place.branch])).trim() !== "")
+        await repository(["branch", "-D", place.branch]);
+}
+export async function defaultBranch(operation) {
+    const reference = await operation.calls.git(operation.settings.repository, [
+        "symbolic-ref",
+        "--short",
+        "refs/remotes/origin/HEAD",
+    ]);
+    return reference.trim().replace(/^origin[/]/, "");
+}
+export async function changeChecked(operation, place) {
+    const call = (parts) => operation.calls.git(place.tree.path, parts);
+    const range = `origin/${place.base}..HEAD`;
+    if (Number((await call(["rev-list", "--count", range])).trim()) === 0)
+        throw new Error("no-change");
+    const change = [
+        await call(["diff", `origin/${place.base}...HEAD`]),
+        await call(["log", "--format=%B", range]),
+    ].join("\n");
+    const privateTexts = [homedir(), ...(operation.settings.privateTexts ?? [])];
+    const lowered = change.toLowerCase();
+    if (privateTexts.some((item) => item !== "" && lowered.includes(item.toLowerCase())))
+        throw new Error("private-path-in-change");
+}

package/dist/src/daemon/github-ticket-status.d.ts

@@ -0,0 +1,3 @@
+import { type Operation } from "./github-operation.ts";
+export declare function closeIssue(operation: Operation): Promise<unknown>;
+export declare function partialIssue(operation: Operation): Promise<unknown>;