cloving 1.0.1 → 1.1.0

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.js

@@ -84,6 +84,8 @@ function matchingCompletion(status, ticketIds) {
     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));
 }
@@ -171,6 +173,8 @@ function stoppedTicketIds(runs, now) {
     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]

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

@@ -1,9 +1,15 @@
+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;
@@ -56,9 +62,11 @@ export interface WatchStep {
     readonly startedAt: string | null;
 }
 export interface WatchCard {
+    readonly estimatedCostUsd: number | null;
     readonly runId: string;
     readonly title: string | null;
-    readonly claudeCostUsd: number;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
     readonly currentStep: WatchStep | null;
     readonly endedAt: string | null;
     readonly decisionWaiting: boolean;
@@ -66,6 +74,7 @@ export interface WatchCard {
     readonly greptileScore: number | null;
     readonly pullRequestNumber: number | null;
     readonly completionMark: WatchCompletionMark | null;
+    readonly pullRequestObservation: PrObservation | null;
 }
 export interface WatchCompletionMark {
     readonly text: string;
@@ -83,11 +92,15 @@ export interface WatchWorkflow {
     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;
+    readonly claudeCostUsd: number | null;
+    readonly usage: WorkerUsage;
     readonly currentStep: WatchStep;
     readonly round: number;
     readonly runId: string;
@@ -108,6 +121,7 @@ export interface WatchRun {
     readonly mergeCommit: string | null;
 }
 export interface WatchModel {
+    readonly cardForms?: readonly CardForm[];
     readonly workflows: readonly WatchWorkflow[];
     readonly startWorkflowId: string | null;
     readonly updatedAt: string;

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

@@ -1,3 +1,4 @@
+import { priceText } from "./usage-render.js";
 export function counted(count, noun) {
     return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -49,7 +50,7 @@ export function runTone(run) {
     return toneOf(run.state);
 }
 export function runName(run) {
-    return run.turns[0]?.target ?? run.runId.slice(0, 12);
+    return run.turns[0]?.target || run.runId.slice(0, 12);
 }
 export function waitingDetail(run, now) {
     const opened = run.phases.find((phase) => phase.state === "active");
@@ -60,7 +61,7 @@ export function waitingDetail(run, now) {
 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 cost = priceText(run.claudeCostUsd, run.estimatedCostUsd);
     const time = first === undefined || last === undefined
         ? ""
         : ` in ${elapsed(first.recordedAt, last.recordedAt)}`;
@@ -68,7 +69,13 @@ export function completedDetail(run) {
         approved: "You approved the work. ",
         denied: "You denied the work. ",
     };
-    return `${verdicts[run.decision] ?? ""}The run completed${time} · cost ${cost.toFixed(2)} USD.`;
+    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)

package/dist/src/cli/watch-run-input.d.ts

@@ -0,0 +1,14 @@
+import { type ServiceRequest } from "../protocol.ts";
+export interface CardField {
+    readonly name: string;
+    readonly label: string;
+    readonly multiline: boolean;
+    readonly optional: boolean;
+}
+export interface CardForm {
+    readonly workflowId: string;
+    readonly source: "ticket" | "prompt" | "input";
+    readonly fields: readonly CardField[];
+}
+export declare function builtinCardForms(): readonly CardForm[];
+export declare function cardRunRequest(forms: readonly CardForm[], value: unknown): ServiceRequest | null;

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,6 +11,7 @@ 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 libraryFile = fileURLToPath(import.meta.resolve("preact"));
 function parsed(text) {
@@ -75,7 +79,7 @@ async function snapshot(watch, runId) {
         turns(watch),
         githubRecords(watch),
     ]);
-    return watchModel({
+    const model = watchModel({
         ...read,
         home: homedir(),
         client: watch.settings.client,
@@ -83,17 +87,34 @@ async function snapshot(watch, runId) {
         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 answered(watch, request) {
+    if (!watchHost(request))
+        return forbidden;
     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 {
@@ -132,9 +153,14 @@ 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,
+        observer,
         reader: watchReader(settings.runtimeDirectory),
         streams: new Map(),
         github: new Map(),
@@ -145,7 +171,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 +185,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 +195,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 +204,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,7 +31,7 @@ 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 cost = priceText(turn.costUsd, turn.estimatedCostUsd);
     const heading = ["Claude 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 }));
@@ -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,7 @@
+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";
 interface Timed {
     readonly run: WatchRun;
     readonly now: string;
@@ -24,16 +26,29 @@ 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 selected: string;
     readonly now: string;
     readonly stale: boolean;
     readonly copying: Copying;
+    readonly columns?: ColumnControls;
+    readonly start?: StartControls;
 }
 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 {};