cloving 0.3.20 → 1.0.1

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

@@ -0,0 +1,148 @@
+const endings = [
+    { type: "run.completed", name: "Completed", state: "done" },
+    { type: "run.failed", name: "Failed", state: "failed" },
+    { type: "run.cancelled", name: "Dropped", state: "failed" },
+];
+const review = { open: "gate.opened", close: "gate.decided" };
+const effect = { open: "effect.requested", close: "effect.reported" };
+const issueWorkflow = "develop-issue";
+export const issueSteps = [
+    { name: "Work tree", operation: "github-prepare" },
+    { name: "Claude turn", operation: "claude-turn" },
+    { name: "Pull request", operation: "github-open-pr" },
+    { name: "Greptile review", operation: "github-wait-review" },
+    { name: "Merge", operation: "github-merge" },
+];
+const verdicts = {
+    approved: "Approved",
+    denied: "Denied",
+};
+const unfinished = ["failed", "stopped"];
+const roundOperations = ["claude-turn", "github-open-pr", "github-wait-review"];
+function record(value) {
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function timeOf(event) {
+    const recordedAt = event?.["recordedAt"];
+    return typeof recordedAt === "string" ? recordedAt : null;
+}
+function firstAt(events, type) {
+    return timeOf(events.find((event) => event["type"] === type));
+}
+function closedAt(events, pair) {
+    const types = events.map((event) => event["type"]);
+    const closed = types.lastIndexOf(pair.close);
+    return closed > types.lastIndexOf(pair.open) ? timeOf(events[closed]) : null;
+}
+export function decisionOf(events) {
+    const known = events.map(record);
+    const types = known.map((event) => event["type"]);
+    const closed = types.lastIndexOf(review.close);
+    if (closed <= types.lastIndexOf(review.open))
+        return "";
+    const decision = record(known[closed]?.["payload"])["decision"];
+    return typeof decision === "string" ? decision : "";
+}
+function admission(events) {
+    const created = firstAt(events, "run.created");
+    const started = firstAt(events, "run.started");
+    return [
+        { name: "Admitted", startedAt: created, endedAt: created, ending: "done" },
+        { name: "Started", startedAt: started, endedAt: started, ending: "done" },
+    ];
+}
+function ticketSpans(events) {
+    const decision = decisionOf(events);
+    return [
+        ...admission(events),
+        {
+            name: "Claude turn",
+            startedAt: firstAt(events, effect.open),
+            endedAt: closedAt(events, effect),
+            ending: "done",
+        },
+        {
+            name: verdicts[decision] ?? "Your review",
+            startedAt: firstAt(events, review.open),
+            endedAt: closedAt(events, review),
+            ending: decision === "denied" ? "failed" : "done",
+        },
+    ];
+}
+function operationOf(event) {
+    const operationId = record(event?.["payload"])["operationId"];
+    try {
+        const scope = JSON.parse(String(operationId));
+        return Array.isArray(scope) ? scope : [];
+    }
+    catch {
+        return [];
+    }
+}
+function currentRound(events) {
+    const requested = events.findLast((event) => event["type"] === effect.open && operationOf(event)[4] === "claude-turn");
+    const round = operationOf(requested)[1];
+    return typeof round === "number" ? round : 1;
+}
+function spans(events, workflowId) {
+    if (workflowId !== issueWorkflow)
+        return ticketSpans(events);
+    const effects = events.filter((event) => [effect.open, effect.close].includes(String(event["type"])));
+    const round = currentRound(effects);
+    return [
+        ...admission(events),
+        ...issueSteps.map((step) => {
+            const repeated = roundOperations.includes(step.operation);
+            const own = effects.filter((event) => {
+                const scope = operationOf(event);
+                return scope[4] === step.operation && (!repeated || scope[1] === round);
+            });
+            const last = own.findLast((event) => event["type"] === effect.close);
+            const outcome = String(record(last?.["payload"])["outcome"]);
+            return {
+                name: repeated && round > 1
+                    ? `${step.name}, round ${String(round)}`
+                    : step.name,
+                startedAt: firstAt(own, effect.open),
+                endedAt: closedAt(own, effect),
+                ending: unfinished.includes(outcome) ? "failed" : "done",
+            };
+        }),
+    ];
+}
+function phase(span, open) {
+    const { ending, ...shown } = span;
+    if (span.endedAt !== null)
+        return { ...shown, state: ending };
+    return { ...shown, state: span.startedAt === null ? "pending" : open };
+}
+function ends(events) {
+    return endings.flatMap(({ type, name, state }) => {
+        const event = events.findLast((item) => item["type"] === type);
+        if (event === undefined)
+            return [];
+        const recordedAt = timeOf(event);
+        return [{ name, state, startedAt: recordedAt, endedAt: recordedAt }];
+    });
+}
+function advanced(phases) {
+    const next = phases.findLastIndex((item) => item.state === "done") + 1;
+    const idle = phases.every((item) => item.state !== "active");
+    return phases.map((item, index) => idle && next > 0 && index === next && item.state === "pending"
+        ? { ...item, state: "active" }
+        : item);
+}
+export function phasesOf(events, workflowId = "") {
+    const known = events.map(record);
+    const steps = spans(known, workflowId);
+    const [end] = ends(known);
+    if (end !== undefined)
+        return [...steps.map((span) => phase(span, "failed")), end];
+    const open = {
+        name: "Completed",
+        startedAt: null,
+        endedAt: null,
+        ending: "done",
+    };
+    return advanced([...steps, open].map((span) => phase(span, "active")));
+}

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,244 @@
+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" &&
+        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" &&
+            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,139 @@
+export interface WatchItem {
+    readonly kind: string;
+    readonly text: string;
+    readonly costUsd?: number;
+}
+export interface WatchTurn {
+    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 runId: string;
+    readonly title: string | null;
+    readonly claudeCostUsd: number;
+    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;
+}
+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 ticketId: string | null;
+    readonly title: string | null;
+    readonly outcome: string | null;
+    readonly latestAt: string | null;
+    readonly claudeCostUsd: number;
+    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 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,95 @@
+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 = run.turns.reduce((sum, turn) => sum + (turn.costUsd ?? 0), 0);
+    const time = first === undefined || last === undefined
+        ? ""
+        : ` in ${elapsed(first.recordedAt, last.recordedAt)}`;
+    const verdicts = {
+        approved: "You approved the work. ",
+        denied: "You denied the work. ",
+    };
+    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost.toFixed(2)} USD.`;
+}
+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`;
+}

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

@@ -0,0 +1,10 @@
+export declare const defaultWatchPort = 3663;
+export interface WatchSettings {
+    readonly runtimeDirectory: string;
+    readonly port: number;
+    readonly client: string;
+    readonly announce: (text: string) => void;
+    readonly complain: (text: string) => void;
+    readonly stopped: Promise<void>;
+}
+export declare function watchServer(settings: WatchSettings): Promise<number>;