cloving 1.2.0 → 1.4.0

package/dist/src/cli/report-ready.js

@@ -0,0 +1,96 @@
+import { record } from "../protocol.js";
+import { hardDependencies } from "../ticket-dependencies.js";
+import { rows, identity, timestamp, issueTimeline, } from "./report-github-reader.js";
+function intervals(events) {
+    const labels = events
+        .filter((event) => ["labeled", "unlabeled"].includes(String(event["event"])) &&
+        record(event["label"])?.["name"] === "cloving: ready")
+        .map((event) => ({
+        type: event["event"],
+        at: timestamp(event["created_at"]),
+    }))
+        .toSorted((a, b) => a.at - b.at);
+    const result = [];
+    let start = null;
+    for (const label of labels) {
+        if (label.type === "labeled")
+            start ??= label.at;
+        else if (start !== null) {
+            result.push({ start, end: label.at });
+            start = null;
+        }
+    }
+    if (start !== null)
+        result.push({ start, end: null });
+    return result;
+}
+async function detail(reader, number) {
+    const row = record(await reader.read(`issues/${String(number)}`));
+    if (row === undefined ||
+        identity(row, { repository: reader.repository, kind: "issues" }) !==
+            number ||
+        Object.hasOwn(row, "pull_request"))
+        throw new Error("identity");
+    return row;
+}
+async function dependencies(reader, row) {
+    const body = row["body"];
+    if (body !== null && typeof body !== "string")
+        throw new Error("response");
+    const result = [];
+    for (const id of hardDependencies(body ?? "")) {
+        const number = Number(id);
+        if (!Number.isSafeInteger(number))
+            throw new Error("identity");
+        const dependency = await detail(reader, number);
+        const state = dependency["state"];
+        if (state !== "closed" && state !== "open")
+            throw new Error("response");
+        result.push({
+            issue: number,
+            closedAt: state === "open" ? null : timestamp(dependency["closed_at"]),
+        });
+    }
+    return result;
+}
+export async function readyTicketsOf(reader) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues?state=all&per_page=100&page=${String(page)}`, [
+            "--jq",
+            'map({number, html_url} + (if has("pull_request") then {pull_request: {}} else {} end))',
+        ]));
+        const numbers = [];
+        for (const row of values) {
+            if (Object.hasOwn(row, "pull_request"))
+                continue;
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "issues",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            numbers.push(number);
+        }
+        for (let offset = 0; offset < numbers.length; offset += 5) {
+            const tickets = await Promise.all(numbers
+                .slice(offset, offset + 5)
+                .map((number) => readyTicket(reader, number)));
+            result.push(...tickets.filter((ticket) => ticket !== null));
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+async function readyTicket(reader, number) {
+    const ready = intervals(await issueTimeline(reader, number));
+    if (ready.length === 0)
+        return null;
+    return {
+        issue: number,
+        intervals: ready,
+        dependencies: await dependencies(reader, await detail(reader, number)),
+    };
+}

package/dist/src/cli/report-text.d.ts

@@ -0,0 +1,9 @@
+import type { loopReport } from "../report.ts";
+type TextReport = Omit<ReturnType<typeof loopReport>, "window" | "runCosts"> & {
+    readonly window: Readonly<Record<string, string | number>>;
+    readonly runCosts: readonly (Omit<ReturnType<typeof loopReport>["runCosts"][number], "completedAt"> & {
+        readonly completedAt: string;
+    })[];
+};
+export declare function textReport(report: TextReport): string;
+export {};

package/dist/src/cli/report-text.js

@@ -0,0 +1,33 @@
+function isMetric(value) {
+    return typeof value["status"] === "string";
+}
+function sectionMetrics(section, prefix) {
+    return Object.fromEntries(Object.entries(section).flatMap(([name, value]) => isMetric(value)
+        ? [[`${prefix}.${name}`, value]]
+        : Object.entries(value).map(([key, metric]) => [`${prefix}.${name}.${key}`, metric])));
+}
+export function textReport(report) {
+    const lines = [`Loop report ${JSON.stringify(report.window)}`];
+    const { jobLogs, ...quality } = report.quality;
+    const metrics = {
+        ...report.metrics,
+        ...sectionMetrics(quality, "quality"),
+        ...sectionMetrics(report.ci, "ci"),
+        ...sectionMetrics(report.operator, "operator"),
+    };
+    for (const [name, metric] of Object.entries(metrics)) {
+        lines.push(`${name}: ${metric.status === "unavailable" ? "unavailable" : String(metric.value)}`);
+        const baseline = metric.baseline;
+        lines.push(`  history: ${baseline.history}; median: ${String(baseline.median)}; band: ${JSON.stringify(baseline.band)}${metric.mark === "outside" ? "; outside" : ""}`);
+        lines.push(`  comparison value: ${String(metric.comparisonValue)}`);
+        lines.push(`  evidence: ${JSON.stringify(metric.evidence)}`);
+        lines.push(`  baseline evidence: ${JSON.stringify(baseline.evidence)}`);
+    }
+    lines.push(`Quality job logs: ${JSON.stringify(jobLogs)}`);
+    lines.push(`Run costs (USD): ${JSON.stringify(report.runCosts)}`);
+    lines.push(`Completed ticket costs (USD): ${JSON.stringify(report.completedTicketCosts)}`);
+    lines.push(`Semantics: ${JSON.stringify(report.semantics)}`);
+    lines.push(`Sources: ${JSON.stringify(report.sources)}`);
+    lines.push(`Coverage: ${JSON.stringify(report.coverage)}`);
+    return lines.join("\n") + "\n";
+}

package/dist/src/cli/report.d.ts

@@ -0,0 +1,18 @@
+import { type Fields } from "../protocol.ts";
+import { type ReportCompletion } from "../report.ts";
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+interface ReportEnvironment {
+    readonly now?: number;
+    readonly runtimeDirectory: string;
+    readonly workingDirectory: string;
+    readonly watchPr?: WatchPrSettings;
+    readonly terminal: {
+        readonly out: (text: string) => void;
+    };
+}
+export declare function reportCommand(invocation: {
+    readonly since: number;
+    readonly json: boolean;
+}, environment: ReportEnvironment): Promise<number>;
+export declare function reportCompletion(event: Fields): ReportCompletion | null;
+export {};

package/dist/src/cli/report.js

@@ -0,0 +1,269 @@
+import { textReport } from "./report-text.js";
+import { record } from "../protocol.js";
+import { loopReport, } from "../report.js";
+import { send } from "./client.js";
+import { readReportFlow } from "./report-flow.js";
+import { readReportGithub } from "./report-github.js";
+function reportRecord(value, after) {
+    const event = record(value) ?? {};
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof sequence !== "number" ||
+        !Number.isSafeInteger(sequence) ||
+        sequence <= after ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-cursor");
+    return { event, sequence, at: Date.parse(at) };
+}
+function appendEvents(snapshot, values) {
+    for (const value of values) {
+        const parsed = reportRecord(value, snapshot.after);
+        if (snapshot.latest !== null && parsed.sequence > snapshot.latest)
+            break;
+        snapshot.after = parsed.sequence;
+        if (snapshot.observedSince === null || parsed.at < snapshot.observedSince)
+            snapshot.observedSince = parsed.at;
+        if (["effect.requested", "effect.reported"].includes(String(parsed.event["type"])))
+            snapshot.effects.push({ ...parsed.event, at: parsed.at });
+        if (["run.started", "schedule.skipped"].includes(String(parsed.event["type"])))
+            snapshot.flowEvents.push(parsed.event);
+        const completion = reportCompletion(parsed.event);
+        if (completion === null)
+            continue;
+        if (snapshot.completions.has(completion.runId))
+            throw new Error("duplicate-report-completion");
+        snapshot.completions.set(completion.runId, completion);
+    }
+}
+async function daemonReport(runtime) {
+    const snapshot = {
+        after: 0,
+        latest: null,
+        observedSince: null,
+        completions: new Map(),
+        effects: [],
+        flowEvents: [],
+    };
+    for (;;) {
+        const reply = await send(runtime, {
+            operation: "events",
+            parameters: { after: snapshot.after, limit: 1000 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const latest = reply.result["latestSequence"];
+        if (typeof latest !== "number" ||
+            !Number.isSafeInteger(latest) ||
+            latest < snapshot.after)
+            throw new Error("invalid-report-snapshot");
+        snapshot.latest ??= latest;
+        const events = reply.result["events"];
+        if (!Array.isArray(events))
+            throw new Error("invalid-report-events");
+        appendEvents(snapshot, events);
+        if (snapshot.after >= snapshot.latest)
+            return {
+                completions: [...snapshot.completions.values()],
+                effects: snapshot.effects,
+                flowEvents: snapshot.flowEvents,
+                observedSince: snapshot.observedSince,
+            };
+        if (events.length < 1000)
+            throw new Error("incomplete-report-snapshot");
+    }
+}
+function settledSpending(run) {
+    const condition = run["condition"];
+    const effects = run["effects"];
+    return (["completed", "failed", "cancelled"].includes(String(condition)) &&
+        Array.isArray(effects) &&
+        effects.every((value) => ["completed", "failed", "stopped", "cancelled", "refused"].includes(String(record(value)?.["state"]))));
+}
+async function runCost(runtime, runId) {
+    const reply = await send(runtime, {
+        operation: "status",
+        parameters: { runId },
+    });
+    if (reply.kind === "error")
+        return { runId, turns: null };
+    const run = record(reply.result["run"]);
+    if (run?.["runId"] !== runId)
+        return { runId, turns: null };
+    const turns = run["workerTurns"];
+    const ticket = runTicket(run);
+    if (!Array.isArray(turns) || !settledSpending(run))
+        return { runId, ...ticket, turns: null };
+    const parsed = turns.map((value) => {
+        const turn = record(value);
+        const operationId = turn?.["operationId"];
+        const costUsd = turn?.["costUsd"];
+        return typeof operationId === "string" &&
+            (costUsd === null ||
+                (typeof costUsd === "number" &&
+                    Number.isFinite(costUsd) &&
+                    costUsd >= 0))
+            ? { operationId, costUsd }
+            : null;
+    });
+    return {
+        runId,
+        ...ticket,
+        turns: parsed.some((turn) => turn === null)
+            ? null
+            : parsed.filter((turn) => turn !== null),
+    };
+}
+export async function reportCommand(invocation, environment) {
+    const now = environment.now ?? Date.now();
+    const since = new Date(now - (invocation.since + 168) * 3_600_000).toISOString();
+    const settings = environment.watchPr === undefined ? {} : { settings: environment.watchPr };
+    const [daemonRead, githubRead] = await Promise.allSettled([
+        daemonReport(environment.runtimeDirectory),
+        readReportGithub({ since, ...settings }),
+    ]);
+    const daemon = daemonRead.status === "fulfilled"
+        ? daemonRead.value
+        : {
+            completions: null,
+            effects: null,
+            flowEvents: null,
+            observedSince: null,
+        };
+    const github = githubRead.status === "fulfilled" ? { github: githubRead.value } : {};
+    const costs = await reportCosts(environment.runtimeDirectory, {
+        completions: daemon.completions ?? [],
+        start: Date.parse(since),
+        end: now,
+        issues: githubRead.status === "fulfilled" ? githubRead.value.issues : null,
+    });
+    const calculated = loopReport({
+        flow: await readReportFlow(environment.runtimeDirectory, {
+            events: daemon.flowEvents,
+            start: Date.parse(since),
+            completions: daemon.completions,
+        }),
+        since: invocation.since,
+        now,
+        ...daemon,
+        costs,
+        ...github,
+    });
+    const report = {
+        ...calculated,
+        window: {
+            ...calculated.window,
+            start: new Date(calculated.window.start).toISOString(),
+            end: new Date(now).toISOString(),
+        },
+        runCosts: calculated.runCosts.map((cost) => ({
+            ...cost,
+            completedAt: new Date(cost.completedAt).toISOString(),
+        })),
+    };
+    environment.terminal.out(invocation.json ? `${JSON.stringify(report)}\n` : textReport(report));
+    return 0;
+}
+function outcomeOf(event) {
+    if (event["type"] === "run.failed")
+        return "failed";
+    if (event["type"] === "run.cancelled")
+        return "cancelled";
+    if (event["type"] !== "run.completed")
+        return null;
+    const payload = record(event["payload"]) ?? {};
+    if (payload["outcome"] === "handoff_requested" &&
+        payload["ticketStatus"] === "partial")
+        return "partial";
+    const outcome = payload["outcome"];
+    if (outcome === undefined || outcome === "handoff_requested")
+        return "completed";
+    return outcome === "blocked" ? "blocked" : null;
+}
+export function reportCompletion(event) {
+    const terminal = ["run.completed", "run.failed", "run.cancelled"].includes(String(event["type"]));
+    if (!terminal)
+        return null;
+    const outcome = outcomeOf(event);
+    if (outcome === null)
+        throw new Error("invalid-report-event");
+    const runId = event["runId"];
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof runId !== "string" ||
+        typeof sequence !== "number" ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-event");
+    return { runId, sequence, at: Date.parse(at), outcome };
+}
+function runTicket(run) {
+    const ticketId = run?.["ticketId"];
+    return ticketId === null || (typeof ticketId === "string" && ticketId !== "")
+        ? { ticketId }
+        : {};
+}
+async function ticketIndex(runtime) {
+    const index = new Map();
+    let after = "";
+    for (;;) {
+        const reply = await send(runtime, {
+            operation: "status",
+            parameters: { metadata: "tickets", after, limit: 500 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const runs = reply.result["runs"];
+        if (!Array.isArray(runs))
+            throw new Error("invalid-report-ticket-index");
+        const latest = appendTicketIndex(index, { runs, after });
+        const next = reply.result["next"];
+        if (next === null)
+            return index;
+        if (typeof next !== "string" || next !== latest || next <= after)
+            throw new Error("invalid-report-ticket-cursor");
+        after = next;
+    }
+}
+async function reportCosts(runtime, input) {
+    const ended = input.completions.filter((event) => event.at < input.end);
+    const costs = [];
+    for (const event of ended.filter((event) => event.at >= input.start))
+        costs.push(await runCost(runtime, event.runId));
+    const older = ended.filter((event) => event.at < input.start);
+    const tickets = new Set((input.issues ?? [])
+        .filter((issue) => issue.at >= input.start && issue.at < input.end)
+        .map((issue) => String(issue.evidence["issue"])));
+    if (older.length === 0 || tickets.size === 0)
+        return costs;
+    try {
+        const index = await ticketIndex(runtime);
+        for (const event of older) {
+            const ticketId = index.get(event.runId);
+            if (ticketId === undefined)
+                continue;
+            costs.push(ticketId !== null && tickets.has(ticketId)
+                ? await runCost(runtime, event.runId)
+                : { runId: event.runId, ticketId, turns: null });
+        }
+    }
+    catch {
+        return costs;
+    }
+    return costs;
+}
+function appendTicketIndex(index, page) {
+    let latest = page.after;
+    for (const value of page.runs) {
+        const row = record(value);
+        const runId = row?.["runId"];
+        const ticketId = row?.["ticketId"];
+        if (typeof runId !== "string" ||
+            runId <= latest ||
+            !(ticketId === null || (typeof ticketId === "string" && ticketId !== "")))
+            throw new Error("invalid-report-ticket-index");
+        index.set(runId, ticketId);
+        latest = runId;
+    }
+    return latest;
+}

package/dist/src/cli/repository-arguments.d.ts

@@ -0,0 +1,5 @@
+import { type ParseArgsConfig } from "node:util";
+export declare function repositoryArguments(argumentsList: readonly string[], options: NonNullable<ParseArgsConfig["options"]>): {
+    readonly argumentsList: readonly string[];
+    readonly repository: string | undefined;
+} | string;

package/dist/src/cli/repository-arguments.js

@@ -0,0 +1,34 @@
+import { parseArgs } from "node:util";
+export function repositoryArguments(argumentsList, options) {
+    if (!argumentsList.some((argument) => argument === "--repository" || argument.startsWith("--repository=")))
+        return { argumentsList, repository: undefined };
+    try {
+        const parsed = parseArgs({
+            args: [...argumentsList],
+            options: {
+                ...options,
+                repository: { type: "string" },
+            },
+            tokens: true,
+            allowPositionals: true,
+            strict: false,
+        });
+        const selectors = parsed.tokens.filter((token) => token.kind === "option" && token.name === "repository");
+        if (selectors.length > 1)
+            return "repeated-option";
+        const removed = new Set(selectors.flatMap((token) => token.kind === "option" && !token.inlineValue
+            ? [token.index, token.index + 1]
+            : [token.index]));
+        const repository = parsed.values["repository"];
+        if (selectors.length > 0 &&
+            (typeof repository !== "string" || repository === ""))
+            return "missing-value";
+        return {
+            argumentsList: argumentsList.filter((_, index) => !removed.has(index)),
+            repository: typeof repository === "string" ? repository : undefined,
+        };
+    }
+    catch {
+        return "missing-value";
+    }
+}

package/dist/src/cli/runtime-arguments.d.ts

@@ -1,3 +1,4 @@
+import { type ScheduleInvocation } from "./schedule-arguments.ts";
 export type RunSource = {
     readonly kind: "prompt";
     readonly text: string;
@@ -10,7 +11,11 @@ export type RunSource = {
 };
 type DecisionCommand = "answer" | "approve" | "deny";
 type RunCommand = "pause" | "resume" | "drop";
-export type RuntimeInvocation = {
+export type RuntimeInvocation = ScheduleInvocation | {
+    readonly kind: "report";
+    readonly since: number;
+    readonly json: boolean;
+} | {
     readonly kind: "command-help";
     readonly command: string;
 } | {

package/dist/src/cli/runtime-arguments.js

@@ -1,4 +1,5 @@
 import { isRecordKey } from "../authority/commands.js";
+import { scheduleInvocation, } from "./schedule-arguments.js";
 const identifier = /^[A-Za-z0-9._:/-]{1,128}$/;
 const decisionReference = /^[A-Za-z0-9._:/-]{1,256}$/;
 const sha256Digest = /^sha256:[0-9a-f]{64}$/;
@@ -51,6 +52,15 @@ const shapes = new Map([
             build: events,
         },
     ],
+    [
+        "report",
+        {
+            subject: "none",
+            required: [],
+            allowed: () => ["since", "json"],
+            build: report,
+        },
+    ],
     [
         "watch",
         {
@@ -62,17 +72,21 @@ const shapes = new Map([
     ],
 ]);
 export function isRuntimeCommand(command) {
-    return shapes.has(command);
+    return command === "schedule" || shapes.has(command);
 }
 export function runtimeInvocation(request) {
     const shape = shapes.get(request.command);
-    if (shape === undefined)
+    if (!isRuntimeCommand(request.command))
         return "unknown-command";
     const names = request.options.map((option) => option.name);
     if (new Set(names).size !== names.length)
         return "repeated-option";
     if (names.includes("help"))
         return { kind: "command-help", command: request.command };
+    if (request.command === "schedule")
+        return scheduleInvocation(request);
+    if (shape === undefined)
+        return "unknown-command";
     return shapeFailure(shape, request) ?? shape.build(request);
 }
 function shapeFailure(shape, request) {
@@ -246,3 +260,9 @@ function events(request) {
     const json = given(request, "json");
     return { kind: "events", runId, after: after ?? 0, limit, follow, json };
 }
+function report(request) {
+    const since = whole(valueOf(request, "since"), { minimum: 1, maximum: 168 });
+    if (since === invalid)
+        return "invalid-option-value";
+    return { kind: "report", since: since ?? 24, json: given(request, "json") };
+}

package/dist/src/cli/runtime-directory.d.ts

@@ -1,4 +1,8 @@
 type Environment = Readonly<Record<string, string | undefined>>;
-export declare function clientCommand(environment: Environment): string;
-export declare function runtimeDirectory(environment: Environment): string | undefined;
+export declare function shellArgument(value: string): string;
+export declare function clientCommand(environment: Environment, repository?: string): string;
+export declare function repositoryRuntimeName(repository: string): string;
+export declare function adoptionRecordPath(environment: Environment, repository: string): string | undefined;
+export declare function legacyRuntimeDirectory(environment: Environment): string | undefined;
+export declare function runtimeDirectory(environment: Environment, repository?: string): string | undefined;
 export {};

package/dist/src/cli/runtime-directory.js

@@ -1,25 +1,83 @@
-import { join } from "node:path";
+import { repositoryFileName } from "../repository-identity.js";
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync } from "node:fs";
+import { basename, isAbsolute, join } from "node:path";
+import { record } from "../protocol.js";
 function given(value) {
     return value !== undefined && value.length > 0;
 }
-export function clientCommand(environment) {
+export function shellArgument(value) {
+    return /^[A-Za-z0-9_./-]+$/.test(value)
+        ? value
+        : `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function clientCommand(environment, repository) {
     const explicit = environment["CLOVING_RUNTIME_DIR"];
     return given(explicit)
-        ? `CLOVING_RUNTIME_DIR=${explicit} cloving`
-        : "cloving";
+        ? `CLOVING_RUNTIME_DIR=${shellArgument(explicit)} cloving`
+        : `cloving${repository === undefined ? "" : ` --repository ${shellArgument(repository)}`}`;
+}
+function stateRoot(environment) {
+    const state = environment["XDG_STATE_HOME"];
+    if (given(state))
+        return state;
+    const home = environment["HOME"];
+    return given(home) ? join(home, ".local", "state") : undefined;
+}
+export function repositoryRuntimeName(repository) {
+    const canonical = realpathSync(repository);
+    return repositoryFileName({
+        name: basename(canonical),
+        sha256: createHash("sha256").update(canonical).digest("hex"),
+    });
+}
+export function adoptionRecordPath(environment, repository) {
+    const state = stateRoot(environment);
+    return state === undefined
+        ? undefined
+        : join(state, "cloving", "adopted-runtime", `${repositoryRuntimeName(repository)}.json`);
+}
+export function legacyRuntimeDirectory(environment) {
+    const runtime = environment["XDG_RUNTIME_DIR"];
+    if (given(runtime))
+        return join(runtime, "cloving");
+    const state = stateRoot(environment);
+    return state === undefined ? undefined : join(state, "cloving", "run");
+}
+function adoptedRuntime(environment, repository) {
+    const path = adoptionRecordPath(environment, repository);
+    if (path === undefined)
+        return undefined;
+    try {
+        return runtimeRecord(path, repository);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
 }
-export function runtimeDirectory(environment) {
+function runtimeRecord(path, repository) {
+    const value = record(JSON.parse(readFileSync(path, "utf8")));
+    if (value?.["schemaVersion"] === 1 &&
+        value["repository"] === realpathSync(repository) &&
+        typeof value["runtimeDirectory"] === "string" &&
+        isAbsolute(value["runtimeDirectory"]))
+        return value["runtimeDirectory"];
+    throw new Error("invalid-runtime-record");
+}
+export function runtimeDirectory(environment, repository) {
     const explicit = environment["CLOVING_RUNTIME_DIR"];
     if (given(explicit))
         return explicit;
+    if (repository === undefined)
+        return undefined;
+    const adopted = adoptedRuntime(environment, repository);
+    if (adopted !== undefined)
+        return adopted;
     const runtime = environment["XDG_RUNTIME_DIR"];
-    if (given(runtime))
-        return join(runtime, "cloving");
-    const state = environment["XDG_STATE_HOME"];
-    if (given(state))
-        return join(state, "cloving", "run");
-    const home = environment["HOME"];
-    return given(home)
-        ? join(home, ".local", "state", "cloving", "run")
-        : undefined;
+    const root = given(runtime) ? runtime : stateRoot(environment);
+    return root === undefined
+        ? undefined
+        : join(root, "cloving", repositoryRuntimeName(repository), "run");
 }

package/dist/src/cli/schedule-arguments.d.ts

@@ -0,0 +1,14 @@
+import type { ServiceRequest } from "../protocol.ts";
+export interface ScheduleInvocation {
+    readonly kind: "schedule";
+    readonly action: "list" | "pause" | "resume";
+    readonly workflowId: string | null;
+    readonly json: boolean;
+}
+export declare function scheduleInvocation(request: {
+    readonly positionals: readonly string[];
+    readonly options: readonly {
+        readonly name: string;
+    }[];
+}): ScheduleInvocation | string;
+export declare function scheduleServiceRequest(invocation: ScheduleInvocation): ServiceRequest;