cloving 0.3.20 → 1.1.0

package/dist/src/cli/watch-pr-observer.js

@@ -0,0 +1,108 @@
+import { prArguments, prCommandResult, } from "./watch-pr-command.js";
+import { prIdentity, } from "./watch-pr-identity.js";
+const systemClock = {
+    now: Date.now,
+    after: (expired, milliseconds) => {
+        const timer = setTimeout(expired, milliseconds);
+        return () => {
+            clearTimeout(timer);
+        };
+    },
+};
+async function readPr(state, attempt) {
+    const { entry, controller } = attempt;
+    const deadline = { expired: false };
+    const timeout = { status: "unavailable", failure: "timeout" };
+    const cancel = state.clock.after(() => {
+        deadline.expired = true;
+        entry.result = timeout;
+        controller.abort();
+    }, 5000);
+    controller.signal.addEventListener("abort", cancel, { once: true });
+    try {
+        const output = await Promise.resolve().then(() => state.settings.execute({
+            command: [
+                ...(state.settings.command ?? []),
+                ...prArguments(entry.identity),
+            ],
+            directory: state.settings.directory,
+            signal: controller.signal,
+        }));
+        return deadline.expired ? timeout : prCommandResult(entry.identity, output);
+    }
+    catch {
+        return deadline.expired
+            ? timeout
+            : { status: "unavailable", failure: "command" };
+    }
+    finally {
+        cancel();
+        controller.signal.removeEventListener("abort", cancel);
+    }
+}
+function pump(state) {
+    if (state.closed || state.active !== null)
+        return;
+    const entry = state.queue.shift();
+    if (entry === undefined)
+        return;
+    const controller = new AbortController();
+    state.active = controller;
+    entry.started = state.clock.now();
+    const completed = (result) => {
+        entry.result = result;
+        entry.pending = false;
+        state.active = null;
+        pump(state);
+    };
+    readPr(state, { entry, controller }).then(completed, () => {
+        completed({ status: "unavailable", failure: "command" });
+    });
+}
+function needsRead(entry, now) {
+    if (entry === undefined)
+        return true;
+    if (entry.pending || entry.result?.status === "merged")
+        return false;
+    return now - entry.started >= 60000;
+}
+export function prObserver(settings) {
+    const state = {
+        settings,
+        clock: settings.clock ?? systemClock,
+        cache: new Map(),
+        queue: [],
+        active: null,
+        closed: false,
+    };
+    const configured = settings.repository !== null && Boolean(settings.command?.[0]?.trim());
+    const observe = (pullRequest) => {
+        if (!configured)
+            return { status: "unavailable", failure: "configuration" };
+        const identity = prIdentity(settings.repository, pullRequest);
+        if (identity === null)
+            return { status: "unavailable", failure: "identity" };
+        const key = JSON.stringify(identity);
+        const known = state.cache.get(key);
+        if (state.closed || !needsRead(known, state.clock.now()))
+            return known?.result ?? null;
+        const entry = {
+            identity,
+            result: known?.result ?? null,
+            started: Infinity,
+            pending: true,
+        };
+        state.cache.set(key, entry);
+        state.queue.push(entry);
+        pump(state);
+        return entry.result;
+    };
+    return {
+        observe,
+        close: () => {
+            state.closed = true;
+            state.queue.length = 0;
+            state.active?.abort();
+        },
+    };
+}

package/dist/src/cli/watch-pr-settings.d.ts

@@ -0,0 +1,8 @@
+import type { WatchCommandRunner } from "./watch-pr-command.ts";
+import { type PrObserver } from "./watch-pr-observer.ts";
+export interface WatchPrSettings {
+    readonly repository: string | undefined;
+    readonly githubCommand: string | undefined;
+    readonly execute: WatchCommandRunner;
+}
+export declare function watchPrObserver(settings: WatchPrSettings): Promise<PrObserver>;

package/dist/src/cli/watch-pr-settings.js

@@ -0,0 +1,47 @@
+import { prRepository } from "./watch-pr-identity.js";
+import { prObserver } from "./watch-pr-observer.js";
+function githubCommand(given) {
+    if (given === undefined)
+        return ["gh"];
+    try {
+        const parsed = JSON.parse(given);
+        if (!Array.isArray(parsed) ||
+            !parsed.every((part) => typeof part === "string"))
+            return null;
+        return parsed.map(String);
+    }
+    catch {
+        return null;
+    }
+}
+export async function watchPrObserver(settings) {
+    const directory = settings.repository;
+    const command = githubCommand(settings.githubCommand);
+    const output = directory === undefined
+        ? null
+        : await settings
+            .execute({
+            command: [
+                "git",
+                "config",
+                "--local",
+                "--get-all",
+                "remote.origin.url",
+            ],
+            directory,
+            signal: AbortSignal.timeout(5000),
+        })
+            .catch(() => null);
+    if (output?.errorCode === "ENOENT" || output?.errorCode === "EACCES")
+        return {
+            observe: () => ({ status: "unavailable", failure: "command" }),
+            close: () => undefined,
+        };
+    const repository = output?.status === 0 ? prRepository(output.stdout) : null;
+    return prObserver({
+        repository,
+        directory: directory ?? "",
+        command,
+        execute: settings.execute,
+    });
+}

package/dist/src/cli/watch-reads.d.ts

@@ -0,0 +1,28 @@
+import { type Fields } from "../protocol.ts";
+interface ReadStatus extends Fields {
+    readonly runId: string;
+    readonly latestSequence: number;
+    readonly state: string;
+    readonly latestAt: string | null;
+}
+interface ReadEvent extends Fields {
+    readonly sequence: number;
+}
+interface ReadRun {
+    readonly status: ReadStatus;
+    readonly events: readonly ReadEvent[];
+}
+export interface WatchRead {
+    readonly service: string;
+    readonly workflows: readonly string[];
+    readonly summaries: readonly ReadStatus[];
+    readonly runs: readonly ReadRun[];
+    readonly completionCandidates: readonly ReadRun[];
+    readonly decisions: readonly unknown[];
+}
+export interface WatchReader {
+    readonly read: (now: string) => Promise<WatchRead>;
+    readonly run: (runId: string) => Promise<WatchRead>;
+}
+export declare function watchReader(runtimeDirectory: string): WatchReader;
+export {};

package/dist/src/cli/watch-reads.js

@@ -0,0 +1,248 @@
+import { record } from "../protocol.js";
+import { send } from "./client.js";
+import { activeRun, recentRun } from "./watch-board.js";
+const unavailable = {
+    service: "down",
+    workflows: [],
+    summaries: [],
+    runs: [],
+    completionCandidates: [],
+    decisions: [],
+};
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+function statusOf(value) {
+    const fields = record(value);
+    const runId = fields?.["runId"];
+    const latestSequence = fields?.["latestSequence"];
+    const state = fields?.["state"];
+    const latestAt = fields?.["latestAt"];
+    if (typeof runId !== "string" ||
+        typeof latestSequence !== "number" ||
+        typeof state !== "string")
+        throw new Error("invalid-run-status");
+    return {
+        ...fields,
+        runId,
+        latestSequence,
+        state,
+        latestAt: typeof latestAt === "string" ? latestAt : null,
+    };
+}
+function eventOf(value) {
+    const fields = record(value);
+    const sequence = fields?.["sequence"];
+    if (typeof sequence !== "number")
+        throw new Error("invalid-event-page");
+    return { ...fields, sequence };
+}
+async function asked(reader, request) {
+    const reply = await send(reader.runtimeDirectory, request);
+    if (reply.kind === "error")
+        throw new Error(reply.error.code);
+    return reply.result;
+}
+async function* eventPages(reader, cursor) {
+    let after = 0;
+    for (;;) {
+        const limit = after === 0 ? (cursor.firstLimit ?? 1000) : 1000;
+        const page = await asked(reader, {
+            operation: "events",
+            parameters: { runId: cursor.runId, after, limit },
+        });
+        const batch = list(page["events"]).map(eventOf);
+        yield batch;
+        if (batch.length < limit)
+            return;
+        const next = batch.at(-1)?.sequence;
+        if (next === undefined || next <= after)
+            throw new Error("invalid-event-page");
+        after = next;
+    }
+}
+async function eventsOf(reader, runId) {
+    const events = [];
+    for await (const batch of eventPages(reader, { runId }))
+        events.push(...batch);
+    return events;
+}
+async function creationOf(reader, runId) {
+    for await (const batch of eventPages(reader, { runId, firstLimit: 1 })) {
+        const event = batch.find((value) => value["type"] === "run.created");
+        if (event !== undefined)
+            return {
+                sequence: event.sequence,
+                type: event["type"],
+                recordedAt: event["recordedAt"],
+            };
+    }
+    return null;
+}
+function matchingCompletion(status, ticketIds) {
+    const ticketId = status["ticketId"];
+    return (status.state === "completed" &&
+        status["workflowId"] === "develop-issue" &&
+        record(status["outcome"])?.["kind"] === "handoff_requested" &&
+        record(status["outcome"])?.["ticketStatus"] !== "partial" &&
+        record(status["outcome"])?.["issueUpdate"] !== "failed" &&
+        typeof ticketId === "string" &&
+        ticketIds.has(ticketId));
+}
+async function completionOf(reader, search) {
+    const { runId, latestSequence } = search.summary;
+    let known = reader.completions.get(runId);
+    if (known?.status.latestSequence !== latestSequence) {
+        const shown = await asked(reader, {
+            operation: "status",
+            parameters: { runId },
+        });
+        const status = statusOf(shown["run"]);
+        known = {
+            status: {
+                runId,
+                latestSequence: status.latestSequence,
+                latestAt: status.latestAt,
+                state: status.state,
+                workflowId: status["workflowId"],
+                ticketId: status["ticketId"],
+                outcome: status["outcome"],
+            },
+        };
+        reader.completions.set(runId, known);
+    }
+    if (!matchingCompletion(known.status, search.ticketIds))
+        return null;
+    const creation = known.creation === undefined
+        ? await creationOf(reader, runId)
+        : known.creation;
+    reader.completions.set(runId, { ...known, creation });
+    return { status: known.status, events: creation === null ? [] : [creation] };
+}
+async function detailed(reader, summary) {
+    const { runId, latestSequence: sequence } = summary;
+    const known = reader.details.get(runId);
+    if (known !== undefined && known.sequence === sequence)
+        return known.value;
+    const shown = await asked(reader, {
+        operation: "status",
+        parameters: { runId },
+    });
+    return remember(reader, statusOf(shown["run"]));
+}
+async function remember(reader, status) {
+    const { runId, latestSequence: sequence } = status;
+    const value = { status, events: await eventsOf(reader, runId) };
+    reader.details.set(runId, { sequence, value });
+    return value;
+}
+async function allRuns(reader, first) {
+    const runs = list(first["runs"]).map(statusOf);
+    let next = first["next"];
+    const visited = new Set();
+    while (typeof next === "string") {
+        if (visited.has(next))
+            throw new Error("invalid-run-page");
+        visited.add(next);
+        const page = await asked(reader, {
+            operation: "status",
+            parameters: { after: next },
+        });
+        runs.push(...list(page["runs"]).map(statusOf));
+        next = page["next"];
+    }
+    return runs;
+}
+async function decisionsOf(reader) {
+    const questions = await asked(reader, {
+        operation: "questions",
+        parameters: {},
+    });
+    return list(questions["decisions"]);
+}
+function stoppedTicketIds(runs, now) {
+    const stopped = runs
+        .map((run) => run.status)
+        .filter((status) => recentRun(status.latestAt, now) &&
+        status["workflowId"] === "develop-issue" &&
+        (["failed", "cancelled"].includes(status.state) ||
+            (status.state === "completed" &&
+                record(status["outcome"])?.["kind"] === "blocked")))
+        .toSorted((first, second) => Date.parse(second.latestAt ?? "") - Date.parse(first.latestAt ?? ""))
+        .slice(0, 20);
+    return new Set(stopped.flatMap((status) => {
+        const ticketId = status["ticketId"];
+        return status.state === "completed" &&
+            record(status["outcome"])?.["ticketStatus"] !== "partial" &&
+            record(status["outcome"])?.["issueUpdate"] !== "failed" &&
+            typeof ticketId === "string" &&
+            ticketId !== ""
+            ? [ticketId]
+            : [];
+    }));
+}
+async function service(reader, now) {
+    const status = await asked(reader, {
+        operation: "status",
+        parameters: {},
+    }).catch(() => null);
+    if (status === null || !Array.isArray(status["runs"]))
+        return unavailable;
+    const summaries = await allRuns(reader, status);
+    const runs = [];
+    const completionCandidates = [];
+    const current = summaries.filter((summary) => activeRun(summary.state) || recentRun(summary.latestAt, now));
+    for (const summary of current)
+        runs.push(await detailed(reader, summary));
+    const ticketIds = stoppedTicketIds(runs, now);
+    const older = ticketIds.size === 0
+        ? []
+        : summaries.filter((summary) => !recentRun(summary.latestAt, now) &&
+            summary["workflowId"] === "develop-issue" &&
+            summary.state === "completed");
+    for (const summary of older) {
+        const candidate = await completionOf(reader, { summary, ticketIds });
+        if (candidate !== null)
+            completionCandidates.push(candidate);
+    }
+    return {
+        service: "up",
+        workflows: list(status["workflows"]).filter((value) => typeof value === "string"),
+        summaries,
+        runs,
+        completionCandidates,
+        decisions: await decisionsOf(reader),
+    };
+}
+async function singleRun(reader, runId) {
+    const reply = await send(reader.runtimeDirectory, {
+        operation: "status",
+        parameters: { runId },
+    });
+    if (reply.kind === "error" && reply.error.code === "unknown-run")
+        return unavailable;
+    if (reply.kind === "error")
+        throw new Error(reply.error.code);
+    const status = statusOf(reply.result["run"]);
+    const known = reader.details.get(runId);
+    const value = known !== undefined && known.sequence === status.latestSequence
+        ? known.value
+        : await remember(reader, status);
+    return {
+        ...unavailable,
+        service: "up",
+        runs: [value],
+        decisions: await decisionsOf(reader),
+    };
+}
+export function watchReader(runtimeDirectory) {
+    const reader = {
+        runtimeDirectory,
+        details: new Map(),
+        completions: new Map(),
+    };
+    return {
+        read: (now) => service(reader, now),
+        run: (runId) => singleRun(reader, runId),
+    };
+}

package/dist/src/cli/watch-render.d.ts

@@ -0,0 +1,153 @@
+import type { CardForm } from "./watch-run-input.ts";
+import type { WorkerUsage } from "../worker-usage.ts";
+import type { PrObservation } from "./watch-pr-identity.ts";
+export interface WatchItem {
+    readonly kind: string;
+    readonly text: string;
+    readonly costUsd?: number;
+}
+export interface WatchTurn {
+    readonly estimatedCostUsd: number | null;
+    readonly operationId: string;
+    readonly usage: WorkerUsage;
+    readonly key: string;
+    readonly runId: string;
+    readonly target: string;
+    readonly branch: string;
+    readonly worktree: string;
+    readonly startedAt: string;
+    readonly endedAt: string | null;
+    readonly activeAt: string | null;
+    readonly outcome: string;
+    readonly costUsd: number | null;
+    readonly activity: readonly WatchItem[];
+    readonly commits: readonly string[];
+    readonly files: readonly string[];
+    readonly uncommitted: readonly string[];
+    readonly summary: string;
+}
+export interface WatchDecision {
+    readonly decisionId: string;
+    readonly type: string;
+    readonly prompt: string;
+    readonly approve: string;
+    readonly deny: string;
+}
+export interface WatchEvent {
+    readonly sequence: number;
+    readonly recordedAt: string;
+    readonly type: string;
+}
+export interface WatchPhase {
+    readonly name: string;
+    readonly state: string;
+    readonly startedAt: string | null;
+    readonly endedAt: string | null;
+}
+export interface WatchFeedback {
+    readonly decisionId: string;
+    readonly text: string;
+}
+export interface WatchPullRequest {
+    readonly number: number;
+    readonly url: string;
+}
+export interface WatchReview {
+    readonly round: number;
+    readonly commit: string;
+    readonly score: number;
+}
+export interface WatchStep {
+    readonly name: string;
+    readonly startedAt: string | null;
+}
+export interface WatchCard {
+    readonly estimatedCostUsd: number | null;
+    readonly runId: string;
+    readonly title: string | null;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
+    readonly currentStep: WatchStep | null;
+    readonly endedAt: string | null;
+    readonly decisionWaiting: boolean;
+    readonly round: number | null;
+    readonly greptileScore: number | null;
+    readonly pullRequestNumber: number | null;
+    readonly completionMark: WatchCompletionMark | null;
+    readonly pullRequestObservation: PrObservation | null;
+}
+export interface WatchCompletionMark {
+    readonly text: string;
+    readonly laterRunId: string | null;
+}
+export interface WatchColumn {
+    readonly name: string;
+    readonly cards: readonly WatchCard[];
+}
+export interface WatchWorkflow {
+    readonly workflowId: string;
+    readonly activeCount: number;
+    readonly waitingCount: number;
+    readonly latestAt: string | null;
+    readonly columns: readonly WatchColumn[];
+}
+export interface WatchRun {
+    readonly issueUpdate?: "failed";
+    readonly ticketStatus?: "complete" | "partial";
+    readonly estimatedCostUsd: number | null;
+    readonly ticketId: string | null;
+    readonly title: string | null;
+    readonly outcome: string | null;
+    readonly latestAt: string | null;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
+    readonly currentStep: WatchStep;
+    readonly round: number;
+    readonly runId: string;
+    readonly workflowId: string;
+    readonly state: string;
+    readonly code: string;
+    readonly detail: string;
+    readonly spent: number | null;
+    readonly limit: number | null;
+    readonly decisions: readonly WatchDecision[];
+    readonly events: readonly WatchEvent[];
+    readonly turns: readonly WatchTurn[];
+    readonly phases: readonly WatchPhase[];
+    readonly decision: string;
+    readonly feedback: readonly WatchFeedback[];
+    readonly pullRequest: WatchPullRequest | null;
+    readonly reviews: readonly WatchReview[];
+    readonly mergeCommit: string | null;
+}
+export interface WatchModel {
+    readonly cardForms?: readonly CardForm[];
+    readonly workflows: readonly WatchWorkflow[];
+    readonly startWorkflowId: string | null;
+    readonly updatedAt: string;
+    readonly service: string;
+    readonly runs: readonly WatchRun[];
+}
+export interface WatchTone {
+    readonly tone: string;
+    readonly icon: string;
+    readonly label: string;
+}
+export interface Copying {
+    readonly command: string;
+    readonly label: string;
+    readonly onCopy: (command: string) => void;
+}
+export declare function counted(count: number, noun: string): string;
+export declare function elapsed(from: string, to: string): string;
+export declare function clockTime(time: string): string;
+export declare function groupActivity(activity: readonly WatchItem[]): WatchItem[][];
+export declare function turnTime(turn: WatchTurn, now: string): string;
+export declare function toneOf(state: string): WatchTone;
+export declare function runTone(run: WatchRun): WatchTone;
+export declare function runName(run: WatchRun): string;
+export declare function waitingDetail(run: WatchRun, now: string): string;
+export declare function completedDetail(run: WatchRun): string;
+export declare function phaseTime(phase: WatchPhase, now: string): string;
+export declare function selectedRun(model: WatchModel, selected: string): WatchRun | undefined;
+export declare function pageTitle(model: WatchModel, selected: string): string;

package/dist/src/cli/watch-render.js

@@ -0,0 +1,102 @@
+import { priceText } from "./usage-render.js";
+export function counted(count, noun) {
+    return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+}
+export function elapsed(from, to) {
+    const span = Math.round((Date.parse(to) - Date.parse(from)) / 1000);
+    if (Number.isNaN(span))
+        return "";
+    const seconds = Math.max(0, span);
+    const minutes = Math.floor(seconds / 60);
+    if (minutes === 0)
+        return `${String(seconds)} s`;
+    if (minutes < 60)
+        return `${String(minutes)} min ${String(seconds % 60)} s`;
+    return `${String(Math.floor(minutes / 60))} h ${String(minutes % 60)} min`;
+}
+export function clockTime(time) {
+    const moment = new Date(time);
+    return Number.isNaN(moment.getTime()) ? "" : moment.toLocaleTimeString();
+}
+export function groupActivity(activity) {
+    const routine = (item) => item?.kind === "tool" || item?.kind === "error";
+    return activity.reduce((groups, item) => {
+        const last = groups.at(-1) ?? [];
+        if (routine(item) && routine(last[0]))
+            return [...groups.slice(0, -1), [...last, item]];
+        return [...groups, [item]];
+    }, []);
+}
+export function turnTime(turn, now) {
+    if (turn.outcome === "in work")
+        return elapsed(turn.startedAt, now);
+    return turn.endedAt === null ? "" : elapsed(turn.startedAt, turn.endedAt);
+}
+export function toneOf(state) {
+    const tones = {
+        waiting_gate: ["attention", "!", "Needs your decision"],
+        running: ["working", "●", "In work"],
+        paused: ["attention", "Ⅱ", "Paused"],
+        completed: ["good", "✓", "Completed"],
+        failed: ["bad", "✕", "Failed"],
+        cancelled: ["bad", "✕", "Dropped"],
+    };
+    const [tone, icon, label] = tones[state] ?? ["idle", "○", state];
+    return { tone, icon, label };
+}
+export function runTone(run) {
+    if (run.state === "completed" && run.decision === "denied")
+        return { tone: "idle", icon: "✕", label: "Denied" };
+    return toneOf(run.state);
+}
+export function runName(run) {
+    return run.turns[0]?.target || run.runId.slice(0, 12);
+}
+export function waitingDetail(run, now) {
+    const opened = run.phases.find((phase) => phase.state === "active");
+    const since = opened?.startedAt ?? null;
+    const waited = since === null ? "" : ` for ${elapsed(since, now)}`;
+    return `A decision waits for you${waited}. Examine the work, then approve or deny.`;
+}
+export function completedDetail(run) {
+    const [first] = run.events;
+    const last = run.events.at(-1);
+    const cost = priceText(run.claudeCostUsd, run.estimatedCostUsd);
+    const time = first === undefined || last === undefined
+        ? ""
+        : ` in ${elapsed(first.recordedAt, last.recordedAt)}`;
+    const verdicts = {
+        approved: "You approved the work. ",
+        denied: "You denied the work. ",
+    };
+    const ticket = run.ticketStatus === undefined
+        ? ""
+        : ` Ticket status: ${run.ticketStatus}.`;
+    const update = run.issueUpdate === "failed"
+        ? " Issue status update failed; check the GitHub operation."
+        : "";
+    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost}.${ticket}${update}`;
+}
+export function phaseTime(phase, now) {
+    if (phase.startedAt === null)
+        return "";
+    if (phase.endedAt === null)
+        return phase.state === "active" ? elapsed(phase.startedAt, now) : "";
+    return phase.startedAt === phase.endedAt
+        ? clockTime(phase.startedAt)
+        : elapsed(phase.startedAt, phase.endedAt);
+}
+export function selectedRun(model, selected) {
+    if (selected === "")
+        return model.runs[0];
+    return model.runs.find((run) => run.runId === selected);
+}
+export function pageTitle(model, selected) {
+    const run = selectedRun(model, selected);
+    if (run === undefined)
+        return "Cloving";
+    const waiting = model.runs.filter((item) => item.state === "waiting_gate");
+    const count = waiting.length === 0 ? "" : `(${String(waiting.length)}) `;
+    const { icon, label } = runTone(run);
+    return `${count}${icon} ${label} · ${runName(run)} · Cloving`;
+}