cloving 1.0.1 → 1.2.0

package/dist/src/cli/watch-run-input.js

@@ -0,0 +1,49 @@
+import { record } from "../protocol.js";
+export function builtinCardForms() {
+    const entries = [
+        ["develop-issue", "ticket", "Issue number"],
+        ["develop-ticket", "ticket", "Ticket ID"],
+        ["develop-prd", "prompt", "Idea"],
+        ["develop-prompt", "prompt", "Task"],
+    ];
+    return entries.map(([workflowId, name, label]) => ({
+        workflowId,
+        source: name === "ticket" ? "ticket" : "prompt",
+        fields: [{ name, label, multiline: name === "prompt", optional: false }],
+    }));
+}
+function validFields(form, fields) {
+    if (Object.keys(fields).some((name) => !form.fields.some((field) => field.name === name)))
+        return false;
+    return form.fields.every((field) => {
+        if (field.optional && !Object.hasOwn(fields, field.name))
+            return true;
+        const text = fields[field.name];
+        return typeof text === "string" && text.trim() !== "";
+    });
+}
+export function cardRunRequest(forms, value) {
+    const body = record(value);
+    if (body === undefined ||
+        Object.keys(body).some((key) => !["workflowId", "fields", "commandId"].includes(key)))
+        return null;
+    const { workflowId, commandId } = body;
+    const form = forms.find((item) => item.workflowId === workflowId);
+    const fields = record(body["fields"]);
+    if (form === undefined ||
+        fields === undefined ||
+        typeof commandId !== "string" ||
+        !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(commandId))
+        return null;
+    if (!validFields(form, fields))
+        return null;
+    return {
+        operation: "run",
+        parameters: {
+            workflowId,
+            source: form.source,
+            submission: fields,
+            commandId,
+        },
+    };
+}

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

@@ -1,5 +1,8 @@
+import { type WatchPrSettings } from "./watch-pr-settings.ts";
 export declare const defaultWatchPort = 3663;
 export interface WatchSettings {
+    readonly actions?: string;
+    readonly pullRequests?: WatchPrSettings;
     readonly runtimeDirectory: string;
     readonly port: number;
     readonly client: string;

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

@@ -1,3 +1,6 @@
+import { watchAction, watchActions, watchHost, } from "./watch-actions.js";
+import { observedBoard } from "./watch-pr-board.js";
+import { watchPrObserver } from "./watch-pr-settings.js";
 import { readdir, readFile, stat } from "node:fs/promises";
 import { createServer, } from "node:http";
 import { homedir } from "node:os";
@@ -8,7 +11,22 @@ import { turnOf, watchModel } from "./watch-model.js";
 import { pageDocument } from "./watch-page.js";
 import { watchStream } from "./watch-stream.js";
 export const defaultWatchPort = 3663;
+const forbidden = { status: 403, type: "text/plain", body: "refused" };
 const notFound = { status: 404, type: "text/plain", body: "not found" };
+const fontFiles = new Map([
+    "fira-code-latin-400-normal.woff2",
+    "fira-code-latin-500-normal.woff2",
+    "heebo-latin-500-normal.woff2",
+    "heebo-latin-700-normal.woff2",
+    "heebo-latin-800-normal.woff2",
+    "space-grotesk-latin-400-normal.woff2",
+    "space-grotesk-latin-500-normal.woff2",
+    "space-grotesk-latin-600-normal.woff2",
+    "space-grotesk-latin-700-normal.woff2",
+].map((name) => [
+    `/watch-fonts-v1/${name}`,
+    new URL(`assets/watch-fonts/${name}`, import.meta.resolve("#package")),
+]));
 const libraryFile = fileURLToPath(import.meta.resolve("preact"));
 function parsed(text) {
     try {
@@ -75,25 +93,59 @@ async function snapshot(watch, runId) {
         turns(watch),
         githubRecords(watch),
     ]);
-    return watchModel({
+    const model = watchModel({
         ...read,
+        repository: watch.observer.repository ?? null,
         home: homedir(),
         client: watch.settings.client,
         updatedAt,
         turns: journal,
         githubRecords: github,
     });
+    const shown = runId === null ? observedBoard(model, watch.observer) : model;
+    return {
+        ...shown,
+        cardForms: watch.actions?.forms.filter((form) => shown.workflows.some((workflow) => workflow.workflowId === form.workflowId)) ?? [],
+    };
+}
+async function fontReply(request) {
+    const fontFile = fontFiles.get(request.url ?? "");
+    if (fontFile === undefined)
+        return request.url?.startsWith("/watch-fonts-v1/") ? notFound : null;
+    if (request.method !== "GET")
+        return notFound;
+    return {
+        status: 200,
+        type: "font/woff2",
+        body: await readFile(fontFile),
+        cache: "public, max-age=31536000, immutable",
+    };
 }
 async function answered(watch, request) {
+    if (!watchHost(request))
+        return forbidden;
+    const font = await fontReply(request);
+    if (font !== null)
+        return font;
     const url = new URL(String(request.url), "http://localhost");
-    const path = url.pathname;
-    if (request.method !== "GET")
+    if (request.method === "GET")
+        return readReply(watch, url);
+    if (request.method !== "POST" ||
+        url.pathname !== "/actions/run" ||
+        watch.actions === null)
         return notFound;
+    const body = await watchAction(watch.actions, request).catch(() => null);
+    return body === null
+        ? forbidden
+        : { status: 200, type: "application/json", body };
+}
+async function readReply(watch, url) {
+    const path = url.pathname;
     if (path === "/")
         return {
             status: 200,
             type: "text/html; charset=utf-8",
-            body: pageDocument(),
+            body: pageDocument(watch.actions?.token ?? null),
         };
     if (path === "/preact.mjs")
         return {
@@ -116,7 +168,7 @@ async function answered(watch, request) {
 function replied(response, reply) {
     response.writeHead(reply.status, {
         "content-type": reply.type,
-        "cache-control": "no-store",
+        "cache-control": reply.cache ?? "no-store",
     });
     response.end(reply.body);
 }
@@ -132,10 +184,15 @@ function subscribed(stream, exchange) {
     changed();
     request.once("close", stream.subscribe(changed));
 }
-export function watchServer(settings) {
+export async function watchServer(settings) {
+    const observer = await observerFor(settings);
     const watch = {
+        actions: settings.actions === "off"
+            ? null
+            : await watchActions(settings.runtimeDirectory),
         settings,
-        reader: watchReader(settings.runtimeDirectory),
+        observer,
+        reader: watchReader(settings.runtimeDirectory, observer.repository ?? null),
         streams: new Map(),
         github: new Map(),
     };
@@ -145,7 +202,9 @@ export function watchServer(settings) {
         retryMilliseconds: 1000,
     });
     const server = createServer((request, response) => {
-        if (request.method === "GET" && request.url === "/events") {
+        if (watchHost(request) &&
+            request.method === "GET" &&
+            request.url === "/events") {
             subscribed(stream, { request, response });
             return;
         }
@@ -157,6 +216,7 @@ export function watchServer(settings) {
     });
     return new Promise((settle) => {
         server.once("error", (error) => {
+            observer.close();
             stream.close();
             settings.complain(`watch-not-started: ${error.message}\n`);
             settle(1);
@@ -166,6 +226,7 @@ export function watchServer(settings) {
             settings.announce(`Watch page: http://127.0.0.1:${String(bound)}/\n`);
         });
         const closed = () => {
+            observer.close();
             stream.close();
             server.close();
             server.closeAllConnections();
@@ -174,3 +235,11 @@ export function watchServer(settings) {
         settings.stopped.then(closed, closed);
     });
 }
+function observerFor(settings) {
+    if (settings.pullRequests !== undefined)
+        return watchPrObserver(settings.pullRequests);
+    return Promise.resolve({
+        observe: () => ({ status: "unavailable", failure: "configuration" }),
+        close: () => undefined,
+    });
+}

package/dist/src/cli/watch-start-view.d.ts

@@ -0,0 +1,18 @@
+import { type Shown } from "./watch-element.ts";
+import type { Copying, WatchModel } from "./watch-render.ts";
+interface StartPrompt {
+    readonly workflowId: string;
+    readonly sentence: string;
+    readonly prompt: string;
+}
+export declare function startPrompts(): readonly StartPrompt[];
+export declare function StartCard(props: {
+    readonly item: StartPrompt;
+    readonly copying: Copying;
+}): Shown;
+export declare function StartRun(props: {
+    readonly workflows: WatchModel["workflows"];
+    readonly copying: Copying;
+    readonly shown?: boolean;
+}): Shown;
+export {};

package/dist/src/cli/watch-start-view.js

@@ -0,0 +1,77 @@
+import { component, element } from "./watch-element.js";
+import { Command } from "./watch-turn.js";
+export function startPrompts() {
+    return [
+        {
+            workflowId: "develop-issue",
+            sentence: "Work on a GitHub issue through a pull request.",
+            prompt: `Start a Cloving run for a GitHub issue in this repository.
+Run: cloving run develop-issue --ticket ISSUE_NUMBER
+Use the issue number that I give on the last line.
+Report the run ID. Then run cloving status RUN_ID until the run completes or stops, and tell me the result and the pull request.
+Do not push, merge or change labels yourself.
+Issue number:`,
+        },
+        {
+            workflowId: "develop-ticket",
+            sentence: "Work on a ticket with your review of the diff.",
+            prompt: `Start a Cloving run for a ticket in this repository.
+Run: cloving run develop-ticket --ticket TICKET_ID
+Use the ticket ID that I give on the last line.
+When the run waits for a decision, run cloving questions, show me the diff and the decision, and give me the approve and deny commands.
+Run only the command that I choose. Do not decide for me.
+Ticket ID:`,
+        },
+        {
+            workflowId: "develop-prd",
+            sentence: "Turn an idea into a GitHub issue.",
+            prompt: `Start a Cloving run that turns an idea into a GitHub issue.
+Run: cloving run develop-prd --prompt "IDEA"
+Use the idea that I give on the last line as IDEA.
+When the run completes, show me the new issue.
+Add the label cloving: ready only when I tell you to.
+Idea:`,
+        },
+        {
+            workflowId: "develop-prompt",
+            sentence: "Do a small task with your review of the diff.",
+            prompt: `Start a Cloving run for a small task in this repository.
+Run: cloving run develop-prompt --prompt "TASK"
+Use the task that I give on the last line as TASK.
+When the run waits for a decision, run cloving questions, show me the diff, and give me the approve and deny commands.
+Run only the command that I choose. Do not decide for me.
+Task:`,
+        },
+    ];
+}
+export function StartCard(props) {
+    const { item, copying } = props;
+    return element("article", {
+        class: "start-card",
+        children: [
+            element("h3", { children: item.workflowId }),
+            element("p", { children: item.sentence }),
+            component(Command, {
+                label: "Agent prompt",
+                command: item.prompt,
+                copyLabel: "Copy the prompt",
+                copying,
+            }),
+        ],
+    });
+}
+export function StartRun(props) {
+    const registered = startPrompts().filter((item) => props.workflows.some((workflow) => workflow.workflowId === item.workflowId));
+    const cards = registered.map((item) => component(StartCard, {
+        key: item.workflowId,
+        item,
+        copying: props.copying,
+    }));
+    return element("section", {
+        class: "start-run",
+        id: "start-run",
+        "aria-label": "Start a run",
+        hidden: props.shown !== true,
+        children: element("div", { class: "start-cards", children: cards }),
+    });
+}

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

@@ -17,6 +17,7 @@ export declare function Work(props: {
 export declare function Command(props: {
     readonly label: string;
     readonly command: string;
+    readonly copyLabel?: string;
     readonly copying: Copying;
 }): Shown;
 export declare function Decision(props: {

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

@@ -1,3 +1,4 @@
+import { priceText, usageText } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
 import { clockTime, counted, groupActivity, turnTime, } from "./watch-render.js";
 export function Item(props) {
@@ -30,8 +31,8 @@ export function Turn(props) {
     const { turn, now } = props;
     const groups = groupActivity(turn.activity);
     const working = turn.outcome === "in work";
-    const cost = turn.costUsd === null ? "" : `${turn.costUsd.toFixed(2)} USD`;
-    const heading = ["Claude turn", turn.outcome, turnTime(turn, now), cost];
+    const cost = priceText(turn.costUsd, turn.estimatedCostUsd);
+    const heading = ["Agent turn", turn.outcome, turnTime(turn, now), cost];
     const place = `Branch ${turn.branch} · work tree ${turn.worktree}`;
     const activity = groups.map((items, index) => component(Group, { items, open: working && index === groups.length - 1 }));
     return element("section", {
@@ -42,6 +43,10 @@ export function Turn(props) {
                 children: heading.filter((part) => part !== "").join(" · "),
             }),
             element("p", { class: "meta", children: place }),
+            element("p", {
+                class: "turn-usage",
+                children: usageText(turn.usage),
+            }),
             element("div", { class: "activity", children: activity }),
         ],
     });
@@ -77,7 +82,7 @@ export function Command(props) {
     const onClick = () => {
         copying.onCopy(command);
     };
-    const shown = copying.command === command ? copying.label : "Copy";
+    const shown = copying.command === command ? copying.label : (props.copyLabel ?? "Copy");
     return element("div", {
         class: "command code-window",
         children: [

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

@@ -0,0 +1,6 @@
+import { type Fields } from "../protocol.ts";
+import type { WatchTurn } from "./watch-render.ts";
+export declare function priceFields(value: unknown): {
+    readonly costUsd?: number;
+};
+export declare function statusTurns(turns: readonly WatchTurn[], status: Fields): readonly WatchTurn[];

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

@@ -0,0 +1,65 @@
+import { record } from "../protocol.js";
+import { priceOf, usageOf } from "../worker-usage.js";
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function emptyTurn(operationId, runId) {
+    return {
+        operationId,
+        runId,
+        key: operationId,
+        usage: usageOf(null),
+        costUsd: null,
+        estimatedCostUsd: null,
+        target: "",
+        branch: "",
+        worktree: "",
+        startedAt: "",
+        endedAt: null,
+        activeAt: null,
+        outcome: "ended",
+        activity: [],
+        commits: [],
+        files: [],
+        uncommitted: [],
+        summary: "",
+    };
+}
+export function priceFields(value) {
+    const cost = priceOf(value);
+    return cost === null ? {} : { costUsd: cost };
+}
+export function statusTurns(turns, status) {
+    const runId = text(status["runId"]);
+    const journal = turns.filter((turn) => turn.runId === runId);
+    if (!Array.isArray(status["workerTurns"]))
+        return journal;
+    const ended = status["workerTurns"].map((value) => {
+        const fields = record(value) ?? {};
+        const operationId = text(fields["operationId"]);
+        const known = journal.find((turn) => turn.operationId === operationId) ??
+            emptyTurn(operationId, runId);
+        return {
+            ...known,
+            runId,
+            operationId,
+            outcome: known.outcome === "in work" ? "ended" : known.outcome,
+            activeAt: null,
+            usage: usageOf(fields["usage"]),
+            costUsd: priceOf(fields["costUsd"]),
+            estimatedCostUsd: priceOf(fields["estimatedCostUsd"]),
+            activity: known.activity.map((item) => item.kind === "result"
+                ? {
+                    kind: item.kind,
+                    text: item.text,
+                    ...priceFields(fields["costUsd"]),
+                }
+                : item),
+        };
+    });
+    return [
+        ...ended,
+        ...journal.filter((turn) => turn.outcome === "in work" &&
+            !ended.some((item) => item.operationId === turn.operationId)),
+    ];
+}

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

@@ -1,5 +1,10 @@
+import type { CardControls } from "./watch-card-view.ts";
 import { type Shown } from "./watch-element.ts";
 import { type Copying, type WatchModel, type WatchPhase, type WatchRun } from "./watch-render.ts";
+import { type ColumnControls } from "./watch-board-view.ts";
+export declare function Queue(props: {
+    readonly model: WatchModel;
+}): Shown;
 interface Timed {
     readonly run: WatchRun;
     readonly now: string;
@@ -24,16 +29,33 @@ export declare function PullRequest(props: {
 export declare function Run(props: Timed & {
     readonly copying: Copying;
 }): Shown;
+export interface StartControls {
+    readonly shown: boolean;
+    readonly onToggle: () => void;
+}
 export declare function Header(props: {
     readonly model: WatchModel | null;
     readonly stale: boolean;
+    readonly start?: StartControls;
 }): Shown;
 export interface PageProps {
+    readonly cards?: CardControls;
     readonly model: WatchModel | null;
+    readonly observationNow?: string | undefined;
     readonly selected: string;
     readonly now: string;
     readonly stale: boolean;
     readonly copying: Copying;
+    readonly columns?: ColumnControls;
+    readonly start?: StartControls;
 }
+export declare function RefusedWorkflows(props: {
+    readonly model: WatchModel;
+}): Shown;
 export declare function Page(props: PageProps): Shown;
+export declare function BoardPage(props: PageProps & {
+    readonly model: WatchModel;
+    readonly workflowId: string | null;
+    readonly down: Shown;
+}): Shown;
 export {};

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

@@ -1,8 +1,36 @@
+import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
 import { clockTime, completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
-import { Board, WorkflowList } from "./watch-board-view.js";
+import { Board, HandoffLinks, WorkflowList, } from "./watch-board-view.js";
 import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
 import { Decision, Events, Turn } from "./watch-turn.js";
+import { StartRun } from "./watch-start-view.js";
+import { record } from "../protocol.js";
+export function Queue(props) {
+    const queue = props.model.queue;
+    if (queue === undefined)
+        return null;
+    const skipped = Array.isArray(queue["skipped"])
+        ? queue["skipped"]
+        : [];
+    return [
+        element("p", {
+            class: "meta",
+            children: `Queue: ${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`,
+        }),
+        ...skipped.map((value) => {
+            const ticket = record(value) ?? {};
+            const dependencies = ticket["dependencies"];
+            const needs = Array.isArray(dependencies)
+                ? `; needs ${dependencies.map(String).join(", ")}`
+                : "";
+            return element("p", {
+                class: "meta",
+                children: `Skipped ticket ${String(ticket["ticketId"])}: ${String(ticket["reason"])}${needs}`,
+            });
+        }),
+    ];
+}
 export const clove = {
     viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
     paths: [
@@ -96,7 +124,7 @@ export function PullRequest(props) {
         children: `#${String(pullRequest.number)}`,
     });
     const scores = reviews.map((review) => element("li", {
-        children: `Round ${String(review.round)} · Greptile ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
+        children: `Round ${String(review.round)} · Review ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
     }));
     const merge = mergeCommit === null
         ? null
@@ -122,7 +150,7 @@ export function Run(props) {
     const budget = run.spent === null || run.limit === null
         ? ""
         : ` · ${String(run.spent)} of ${String(run.limit)} effect units`;
-    const none = "No Claude turn for this run.";
+    const none = "No agent turn for this run.";
     const turns = run.turns.length === 0
         ? element("p", { class: "meta", children: none })
         : run.turns.map((item, index) => [
@@ -140,6 +168,17 @@ export function Run(props) {
     ];
     return [
         component(Banner, { run, now }),
+        component(HandoffLinks, { run }),
+        element("section", {
+            class: "run-usage",
+            children: [
+                element("h3", { children: `Run totals${totalsSuffix(run.state)}` }),
+                element("p", { children: usageText(run.usage) }),
+                element("p", {
+                    children: priceText(run.claudeCostUsd, run.estimatedCostUsd),
+                }),
+            ],
+        }),
         component(Phases, { phases: run.phases, now }),
         component(PullRequest, { run }),
         run.decisions.map((decision) => component(Decision, { decision, turn, copying })),
@@ -173,6 +212,32 @@ export function Header(props) {
                 ],
             }),
             stamp,
+            props.start === undefined
+                ? null
+                : element("button", {
+                    type: "button",
+                    class: "start-toggle",
+                    "aria-controls": "start-run",
+                    "aria-expanded": String(props.start.shown),
+                    onClick: props.start.onToggle,
+                    children: "Start a run",
+                }),
+        ],
+    });
+}
+export function RefusedWorkflows(props) {
+    const refusals = props.model.workflowRefusals ?? [];
+    if (refusals.length === 0)
+        return null;
+    return element("section", {
+        class: "workflow-refusals",
+        children: [
+            element("h2", { children: "Refused workflows" }),
+            element("ul", {
+                children: refusals.map((entry) => element("li", {
+                    children: `${entry.scope} ${entry.label}: ${entry.codes.join(", ")}`,
+                })),
+            }),
         ],
     });
 }
@@ -193,6 +258,8 @@ export function Page(props) {
         return [
             head,
             down,
+            component(Queue, { model }),
+            component(RefusedWorkflows, { model }),
             element("a", {
                 class: "back",
                 href: watchHash({ workflowId: back, runId: null }),
@@ -203,21 +270,46 @@ export function Page(props) {
                 : component(Run, { key: run.runId, run, now, copying }),
         ];
     }
+    return component(BoardPage, { ...props, model, workflowId, down });
+}
+export function BoardPage(props) {
+    const { model, workflowId, down, now, stale, copying } = props;
     const workflow = model.workflows.find((item) => item.workflowId === workflowId);
-    return [
-        head,
-        down,
-        element("div", {
-            class: "workspace",
-            children: [
-                component(WorkflowList, {
-                    workflows: model.workflows,
-                    selected: workflowId,
-                }),
-                workflow === undefined
-                    ? text("meta", "No workflows registered.")
-                    : component(Board, { workflow, now }),
-            ],
-        }),
-    ];
+    const start = props.start ?? { shown: false, onToggle: () => undefined };
+    return element("div", {
+        class: "board-page",
+        children: [
+            component(Header, { model, stale, start }),
+            component(Queue, { model }),
+            down,
+            component(RefusedWorkflows, { model }),
+            component(StartRun, {
+                workflows: model.workflows,
+                copying,
+                shown: start.shown,
+            }),
+            component(WorkflowList, {
+                workflows: model.workflows,
+                selected: workflowId,
+            }),
+            element("div", {
+                class: "workspace",
+                children: [
+                    workflow === undefined
+                        ? element("p", {
+                            class: "meta",
+                            children: "No workflows registered.",
+                        })
+                        : component(Board, {
+                            workflow,
+                            now,
+                            observationNow: props.observationNow,
+                            controls: props.columns,
+                            cardForm: model.cardForms?.find((form) => form.workflowId === workflowId),
+                            cards: props.cards,
+                        }),
+                ],
+            }),
+        ],
+    });
 }