cloving 0.3.20 → 1.0.1

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

@@ -0,0 +1,198 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { findingsOf, scoreOf } from "./github-calls.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",
+    "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],
+    ["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-worker.d.ts

@@ -0,0 +1,17 @@
+import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import { type MethodSettings } from "./github-methods.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+export type { GithubTiming } from "./github-methods.ts";
+export interface GithubWorkerSettings extends MethodSettings {
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly operationStatus: (operationId: string) => Promise<string | undefined>;
+    readonly runStatus: (runId: string) => Promise<string | undefined>;
+}
+export interface GithubWorker extends Delivery {
+    readonly stop: NonNullable<Delivery["stop"]>;
+    readonly scan: () => Promise<void>;
+    readonly close: () => Promise<void>;
+}
+export declare function githubWorker(settings: GithubWorkerSettings): GithubWorker;

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

@@ -0,0 +1,281 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { calls } from "./github-calls.js";
+import { methodReasons, methods, } from "./github-methods.js";
+import { interrupted, located, readRecord, replied, reportOf, writeRecord, } from "./operation-journal.js";
+const worker = "github";
+const closing = "github-worker-closed";
+const endedRuns = new Set([
+    "cancelled",
+    "failed",
+    "completed",
+]);
+const unsettledOperations = new Set([
+    "dispatch-pending",
+    "running",
+    "recovering",
+    "blocked",
+]);
+const outcomes = ["completed", "failed", "stopped"];
+function placed(parts, intent) {
+    return located(parts.settings.journal, intent.operationId);
+}
+async function reconciled(parts, intent) {
+    const { key, folder } = placed(parts, intent);
+    const identity = { receipt: key, worker };
+    const result = await readRecord(folder, "result.json");
+    if (result !== undefined)
+        return replied(identity, result);
+    if (parts.active.has(key))
+        return { kind: "accepted", ...identity };
+    if ((await readRecord(folder, "started.json")) === undefined)
+        return { kind: "absent" };
+    const ending = interrupted("github-call-interrupted");
+    await writeRecord(folder, { name: "result.json", value: ending });
+    return replied(identity, ending);
+}
+async function outcome(parts, run) {
+    const { intent, method, payload, signal } = run;
+    const { settings } = parts;
+    if (intent.target.startsWith("branch:"))
+        return interrupted("branch-target-not-supported");
+    try {
+        const result = await method({
+            settings,
+            folder: run.folder,
+            calls: calls(settings, signal),
+            target: intent.target,
+            payload,
+            signal,
+        });
+        return {
+            outcome: "completed",
+            result: JSON.stringify(result),
+            endedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        if (signal.aborted)
+            return { outcome: "stopped", endedAt: new Date().toISOString() };
+        const reason = String(Reflect.get(Object(error), "message"));
+        const detail = Reflect.get(Object(error), "detail");
+        return {
+            ...interrupted(methodReasons.has(reason) ? reason : "github-call-failed"),
+            ...(typeof detail === "string" ? { detail } : {}),
+        };
+    }
+}
+async function reported(parts, ending) {
+    const { start, recorded } = ending;
+    const { key, intent } = start;
+    await parts.settings.report(reportOf({ intent, commandId: `github:${key}`, worker }, recorded));
+}
+async function ended(parts, ending) {
+    const { start, recorded } = ending;
+    await writeRecord(start.folder, { name: "result.json", value: recorded });
+    await reported(parts, ending);
+}
+function begun(parts, start) {
+    const { key } = start;
+    const stopping = new AbortController();
+    const concluded = (async () => {
+        const recorded = await outcome(parts, {
+            ...start,
+            signal: stopping.signal,
+        });
+        if (stopping.signal.reason === closing)
+            return;
+        await ended(parts, { start, recorded });
+    })()
+        .catch(() => undefined)
+        .finally(() => parts.active.delete(key));
+    parts.active.set(key, { stopping, concluded });
+}
+function ownIntent(intent) {
+    return (intent.capability === worker &&
+        intent.method !== undefined &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function payloadOf(text) {
+    try {
+        const value = JSON.parse(text);
+        return typeof value === "object" && value !== null && !Array.isArray(value)
+            ? { ...value }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function failure(reason) {
+    return { kind: "failed", reason };
+}
+async function delivered(parts, intent) {
+    if (!ownIntent(intent))
+        return failure("unsupported-effect");
+    if (intent.target.startsWith("branch:"))
+        return failure("branch-target-not-supported");
+    const method = methods.get(intent.method);
+    if (method === undefined)
+        return failure("unsupported-effect");
+    const known = await reconciled(parts, intent);
+    if (known.kind !== "absent")
+        return known;
+    const text = await parts.settings.document(intent.payload);
+    if (text === undefined)
+        return failure("payload-not-available");
+    const payload = payloadOf(text);
+    if (payload === undefined)
+        return failure("invalid-payload");
+    const place = placed(parts, intent);
+    await writeRecord(place.folder, {
+        name: "started.json",
+        value: {
+            operationId: intent.operationId,
+            method: intent.method,
+            target: intent.target,
+            startedAt: new Date().toISOString(),
+            runId: intent.runId,
+            inputDigest: intent.inputDigest,
+            leaseGeneration: intent.leaseGeneration,
+            payloadText: text,
+        },
+    });
+    begun(parts, { ...place, intent, method, payload });
+    return { receipt: place.key, worker };
+}
+async function halted(active, reason) {
+    active.stopping.abort(reason);
+    await active.concluded;
+}
+async function stopped(parts, intent) {
+    const active = parts.active.get(placed(parts, intent).key);
+    if (active !== undefined)
+        await halted(active, "github-operation-stopped");
+    return reconciled(parts, intent);
+}
+function textOf(value, name) {
+    const item = Reflect.get(Object(value), name);
+    return typeof item === "string" ? item : "";
+}
+function keptOf(value) {
+    const leaseGeneration = Reflect.get(Object(value), "leaseGeneration");
+    const kept = {
+        operationId: textOf(value, "operationId"),
+        runId: textOf(value, "runId"),
+        inputDigest: textOf(value, "inputDigest"),
+        method: textOf(value, "method"),
+        target: textOf(value, "target"),
+        payloadText: textOf(value, "payloadText"),
+    };
+    if (typeof leaseGeneration !== "number" || Object.values(kept).includes(""))
+        return undefined;
+    return { ...kept, leaseGeneration };
+}
+function startOf(parts, value) {
+    const kept = keptOf(value);
+    if (kept === undefined)
+        return undefined;
+    const method = methods.get(kept.method);
+    const payload = payloadOf(kept.payloadText);
+    if (method === undefined || payload === undefined)
+        return undefined;
+    const place = located(parts.settings.journal, kept.operationId);
+    return { ...place, intent: kept, method, payload };
+}
+function recordOf(value) {
+    const outcome = outcomes.find((item) => item === textOf(value, "outcome"));
+    if (outcome === undefined)
+        return undefined;
+    const result = Reflect.get(Object(value), "result");
+    const reason = Reflect.get(Object(value), "reason");
+    return {
+        outcome,
+        endedAt: textOf(value, "endedAt"),
+        ...(typeof result === "string" ? { result } : {}),
+        ...(typeof reason === "string" ? { reason } : {}),
+    };
+}
+async function unsettled(parts, kept) {
+    const status = await parts.settings.operationStatus(kept.operationId);
+    return unsettledOperations.has(status ?? "");
+}
+async function live(parts, kept) {
+    if (!(await unsettled(parts, kept)))
+        return false;
+    const run = await parts.settings.runStatus(kept.runId);
+    return run !== undefined && !endedRuns.has(run);
+}
+async function resent(parts, saved) {
+    const recorded = recordOf(saved.result);
+    if (recorded === undefined)
+        return;
+    if (!(await unsettled(parts, saved.start.intent)))
+        return;
+    await reported(parts, { start: saved.start, recorded });
+}
+async function continued(parts, start) {
+    if (await live(parts, start.intent)) {
+        begun(parts, start);
+        return;
+    }
+    const recorded = {
+        outcome: "stopped",
+        endedAt: new Date().toISOString(),
+    };
+    await ended(parts, { start, recorded });
+}
+async function resumed(parts, folder) {
+    const started = await readRecord(folder, "started.json");
+    if (started === undefined)
+        return;
+    const result = await readRecord(folder, "result.json");
+    const start = startOf(parts, started);
+    if (start !== undefined && result !== undefined) {
+        await resent(parts, { start, result });
+        return;
+    }
+    if (start !== undefined) {
+        await continued(parts, start);
+        return;
+    }
+    if (result !== undefined)
+        return;
+    const ending = interrupted("github-call-interrupted");
+    await writeRecord(folder, { name: "result.json", value: ending });
+}
+async function scanned(parts) {
+    const { journal } = parts.settings;
+    const entries = await readdir(journal).catch(() => []);
+    await Promise.all(entries.map((entry) => resumed(parts, join(journal, entry)).catch(() => undefined)));
+}
+function scanning(parts) {
+    const scan = scanned(parts).finally(() => {
+        parts.scanned.resolve();
+    });
+    parts.scans.push(scan);
+    return scan;
+}
+export function githubWorker(settings) {
+    if (settings.gh.length === 0)
+        throw new Error("invalid-github-command");
+    const parts = {
+        settings,
+        active: new Map(),
+        scanned: Promise.withResolvers(),
+        scans: [],
+    };
+    const after = (call) => parts.scanned.promise.then(call);
+    return {
+        deliver: (intent) => after(() => delivered(parts, intent)),
+        reconcile: (intent) => after(() => reconciled(parts, intent)),
+        stop: (intent) => after(() => stopped(parts, intent)),
+        scan: () => scanning(parts),
+        close: async () => {
+            await Promise.all(parts.scans);
+            await Promise.all([...parts.active.values()].map((active) => halted(active, closing)));
+        },
+    };
+}

package/dist/src/daemon/host-environment.d.ts

@@ -0,0 +1,8 @@
+export interface HostPlace {
+    readonly directory: string;
+    readonly concurrency: number;
+    readonly leaseSeconds?: number;
+}
+export declare const ownershipLeaseSeconds = 15;
+export declare function worldDirectory(directory: string): string;
+export declare function hostEnvironment(place: HostPlace): Readonly<Record<string, string>>;

package/dist/src/daemon/host-environment.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+export const ownershipLeaseSeconds = 15;
+export function worldDirectory(directory) {
+    return join(directory, "world");
+}
+export function hostEnvironment(place) {
+    return {
+        WORKFLOW_TARGET_WORLD: "local",
+        WORKFLOW_LOCAL_DATA_DIR: worldDirectory(place.directory),
+        WORKFLOW_LOCAL_BASE_URL: "http://127.0.0.1:1",
+        WORKFLOW_LOCAL_QUEUE_CONCURRENCY: String(place.concurrency),
+        WORKFLOW_INLINE_OWNERSHIP_LEASE_SECONDS: String(place.leaseSeconds ?? ownershipLeaseSeconds),
+    };
+}

package/dist/src/daemon/issue-queue.d.ts

@@ -0,0 +1,9 @@
+interface QueueSettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly intervalMilliseconds: number;
+}
+export declare function issueQueue(settings: QueueSettings): {
+    readonly stop: () => Promise<void>;
+};
+export {};