cloving 0.3.20 → 1.1.0

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

@@ -0,0 +1,118 @@
+export const watchClient = `
+const state = { model: null, stale: false, copied: "", label: "", run: "", loading: false, again: false, columns: {}, cards: {}, start: null, hovered: null, focused: null };
+function readPreference(key) {
+  try { return JSON.parse(localStorage.getItem(key)); }
+  catch { return null; }
+}
+function readColumnChoices(key) {
+  const value = readPreference(key);
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return Object.fromEntries(Object.entries(value).filter(([, choice]) => typeof choice === "boolean"));
+}
+function savePreference(key, value) {
+  try { localStorage.setItem(key, JSON.stringify(value)); }
+  catch {}
+}
+function startControls() {
+  if (state.start === null) state.start = readPreference("cloving.watch.start") === true;
+  return { shown: state.start, onToggle() {
+    state.start = !state.start;
+    savePreference("cloving.watch.start", state.start);
+    draw();
+  } };
+}
+function columnControls(model, selected) {
+  const workflowId = model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId);
+  if (workflowId === null) return undefined;
+  const key = "cloving.watch.columns:" + workflowId;
+  if (!Object.hasOwn(state.columns, workflowId))
+    state.columns = { ...state.columns, [workflowId]: readColumnChoices(key) };
+  const choices = state.columns[workflowId];
+  return { choices, onHover(name) { state.hovered = name; }, onFocus(name) { state.focused = name; }, onToggle(name) {
+    const changed = { ...choices, [name]: !columnCollapsed(choices, name) };
+    state.columns = { ...state.columns, [workflowId]: changed };
+    savePreference(key, changed);
+    draw();
+  } };
+}
+function moved(next, followed) {
+  const arrived = next === "waiting_gate" && next !== state.run;
+  state.run = next;
+  if (arrived) scrollTo(0, 0);
+  else if (followed && next === "running") scrollTo(0, document.body.scrollHeight);
+}
+function copy(command) {
+  const shown = (label) => {
+    state.copied = command;
+    state.label = label;
+    draw();
+  };
+  navigator.clipboard.writeText(command).then(
+    () => { shown("Copied"); },
+    () => { shown("Copy failed"); },
+  );
+}
+function draw() {
+  const { model, stale } = state;
+  const selected = location.hash.slice(1);
+  const followed = innerHeight + scrollY >= document.body.scrollHeight - 80;
+  const copying = { command: state.copied, label: state.label, onCopy: copy };
+  const now = new Date().toISOString();
+  const columns = columnControls(model, selected);
+  const start = model === null ? undefined : startControls();
+  const cards = cardControls(model, model === null ? null : boardWorkflow(model, watchLocation(selected).workflowId));
+  const page = component(Page, { model, selected, now, stale, copying, columns, start, cards });
+  render(page, document.getElementById("app"));
+  if (model === null) return;
+  document.title = watchTitle(model, selected);
+  const { runId } = watchLocation(selected);
+  moved(model.runs.find((run) => run.runId === runId)?.state ?? "", followed);
+}
+async function withSelectedRun(model) {
+  const { runId } = watchLocation(location.hash);
+  if (runId === null || model.runs.some((run) => run.runId === runId)) return model;
+  const detail = await fetch("data.json?runId=" + encodeURIComponent(runId), { cache: "no-store" });
+  if (detail.status === 404) return model;
+  if (!detail.ok) throw new Error("watch-run-not-available");
+  const { run } = await detail.json();
+  if (run?.runId !== runId) throw new Error("watch-run-mismatch");
+  return { ...model, runs: [...model.runs, run] };
+}
+async function load() {
+  state.again = state.loading;
+  if (state.loading) return;
+  state.loading = true;
+  try {
+    const reply = await fetch("data.json", { cache: "no-store" });
+    if (!reply.ok) throw new Error("watch-not-available");
+    state.model = await withSelectedRun(await reply.json());
+    state.stale = false;
+  } catch {
+    state.stale = true;
+  }
+  state.loading = false;
+  draw();
+  if (state.again) load();
+}
+function listen() {
+  const source = new EventSource("events");
+  source.onmessage = () => { load(); };
+  source.onerror = () => { state.stale = true; draw(); };
+}
+addEventListener("keydown", (event) => {
+  if (event.key !== String.fromCharCode(92) || event.defaultPrevented || event.repeat || event.isComposing) return;
+  if (event.ctrlKey || event.altKey || event.metaKey || event.shiftKey) return;
+  if (event.target?.closest?.("input, textarea, select, [contenteditable]")) return;
+  const target = state.hovered ?? state.focused;
+  if (target === null || watchLocation(location.hash).runId !== null) return;
+  const controls = columnControls(state.model, location.hash);
+  if (controls === undefined) return;
+  event.preventDefault();
+  controls.onToggle(target);
+});
+addEventListener("hashchange", () => { state.run = ""; state.hovered = null; state.focused = null; draw(); load(); });
+draw();
+listen();
+setInterval(draw, 1000);
+setInterval(load, 15000);
+`;

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

@@ -0,0 +1,11 @@
+export type WatchElement = {
+    readonly tag: string;
+    readonly props: Readonly<Record<string, unknown>>;
+} | {
+    readonly content: () => Shown;
+};
+export type Shown = WatchElement | string | number | null | undefined | readonly Shown[];
+export declare function element(tag: string, props: Readonly<Record<string, unknown>>): WatchElement;
+export declare function component<Props>(type: (props: Props) => Shown, props: Props & {
+    readonly key?: string;
+}): WatchElement;

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

@@ -0,0 +1,6 @@
+export function element(tag, props) {
+    return { tag, props };
+}
+export function component(type, props) {
+    return { content: () => type(props) };
+}

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

@@ -0,0 +1,29 @@
+import type { WatchDecision, WatchItem, WatchModel, WatchTurn } from "./watch-render.ts";
+export declare function activityOf(line: string): WatchItem[];
+export interface TurnRecords {
+    readonly key: string;
+    readonly started: unknown;
+    readonly result: unknown;
+    readonly lines: readonly string[];
+    readonly activeAt?: string | null;
+}
+export declare function turnOf(records: TurnRecords): WatchTurn;
+export declare function decisionCommands(decision: unknown, client: string): WatchDecision;
+export interface WatchInputs {
+    readonly workflows: readonly string[];
+    readonly summaries?: readonly unknown[];
+    readonly home: string;
+    readonly client: string;
+    readonly updatedAt: string;
+    readonly service: string;
+    readonly runs: readonly unknown[];
+    readonly completionCandidates?: readonly unknown[];
+    readonly decisions: readonly unknown[];
+    readonly turns: readonly WatchTurn[];
+    readonly githubRecords: readonly GithubRecords[];
+}
+export interface GithubRecords {
+    readonly started: unknown;
+    readonly result: unknown;
+}
+export declare function watchModel(inputs: WatchInputs): WatchModel;

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

@@ -0,0 +1,278 @@
+import { isTicketStatus } from "../ticket-status.js";
+import { priceFields, statusTurns } from "./watch-usage.js";
+import { priceOf, usageOf } from "../worker-usage.js";
+import { priceText } from "./usage-render.js";
+import { boardsOf, currentStepOf, roundOf, startWorkflowOf, } from "./watch-board.js";
+import { decisionOf, phasesOf } from "./watch-phases.js";
+import { displayRun } from "./watch-paths.js";
+const textLimit = 600;
+const activityLimit = 400;
+function record(value) {
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function list(value) {
+    return Array.isArray(value) ? value.map((item) => item) : [];
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function count(value) {
+    return typeof value === "number" ? value : null;
+}
+function stamp(value) {
+    return typeof value === "string" ? value : null;
+}
+function texts(value) {
+    return list(value).filter((item) => typeof item === "string");
+}
+function parsed(line) {
+    try {
+        const value = JSON.parse(line);
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function cut(value) {
+    return value.length > textLimit ? `${value.slice(0, textLimit)}…` : value;
+}
+function summary(input) {
+    const named = ["command", "file_path", "pattern", "description"]
+        .map((name) => text(input[name]))
+        .find((value) => value !== "");
+    return named ?? JSON.stringify(input);
+}
+function spoken(part) {
+    const words = text(part["text"]);
+    return words.trim() === "" ? [] : [{ kind: "say", text: words }];
+}
+function said(part) {
+    if (part["type"] === "text")
+        return spoken(part);
+    if (part["type"] !== "tool_use")
+        return [];
+    const tool = `${text(part["name"])}: ${summary(record(part["input"]))}`;
+    return [{ kind: "tool", text: tool }];
+}
+function failed(part) {
+    if (part["type"] !== "tool_result" || part["is_error"] !== true)
+        return [];
+    const content = part["content"];
+    const shown = typeof content === "string" ? content : JSON.stringify(content);
+    return [{ kind: "error", text: shown }];
+}
+function ended(line) {
+    const cost = priceOf(line["total_cost_usd"]);
+    return [
+        {
+            kind: "result",
+            text: text(line["result"]),
+            ...(cost === null ? {} : { costUsd: cost }),
+        },
+    ];
+}
+function parts(line) {
+    return list(record(line["message"])["content"]).map(record);
+}
+export function activityOf(line) {
+    const value = record(parsed(line));
+    if (value["type"] === "assistant")
+        return parts(value).flatMap(said);
+    if (value["type"] === "user")
+        return parts(value).flatMap(failed);
+    return value["type"] === "result" ? ended(value) : [];
+}
+function concise(items) {
+    return items.map((item, index) => {
+        const before = items[index - 1];
+        if (item.kind !== "result" || before?.kind !== "say")
+            return item;
+        if (!item.text.startsWith(before.text))
+            return item;
+        const cost = item.text.slice(before.text.length);
+        return { kind: "result", text: `Result of the worker${cost}` };
+    });
+}
+function shortened(run) {
+    return {
+        ...run,
+        turns: run.turns.map((turn) => ({
+            ...turn,
+            activity: concise(turn.activity.map((item) => {
+                const spent = item.kind === "result"
+                    ? ` (cost ${priceText(item.costUsd, turn.estimatedCostUsd)})`
+                    : "";
+                return { kind: item.kind, text: `${cut(item.text)}${spent}` };
+            })).slice(-activityLimit),
+        })),
+    };
+}
+export function turnOf(records) {
+    const started = record(records.started);
+    const operation = list(parsed(text(started["operationId"])));
+    const result = record(records.result);
+    const outcome = text(result["outcome"]);
+    const report = record(parsed(text(result["result"])));
+    return {
+        key: records.key,
+        operationId: text(started["operationId"]),
+        usage: usageOf(report["usage"]),
+        runId: text(operation[2]),
+        target: text(started["target"]),
+        branch: text(started["branch"]),
+        worktree: text(started["worktree"]),
+        startedAt: text(started["startedAt"]),
+        outcome: records.result === null ? "in work" : outcome,
+        costUsd: priceOf(report["costUsd"]),
+        estimatedCostUsd: priceOf(report["estimatedCostUsd"]),
+        activity: records.lines
+            .flatMap(activityOf)
+            .map((item) => item.kind === "result"
+            ? {
+                kind: item.kind,
+                text: item.text,
+                ...priceFields(report["costUsd"]),
+            }
+            : item)
+            .slice(-activityLimit - 1),
+        endedAt: stamp(result["endedAt"]),
+        activeAt: records.activeAt ?? null,
+        commits: texts(report["commits"]),
+        files: texts(report["files"]),
+        uncommitted: texts(report["uncommitted"]),
+        summary: text(report["summary"]),
+    };
+}
+export function decisionCommands(decision, client) {
+    const fields = record(decision);
+    const decisionId = text(fields["decisionId"]);
+    const binding = `--expected-revision ${String(fields["revision"])} --generation ${String(fields["generation"])} --subject-digest ${text(fields["subjectDigest"])}`;
+    return {
+        decisionId,
+        type: text(fields["type"]),
+        prompt: text(fields["prompt"]),
+        approve: `${client} approve ${decisionId} ${binding}`,
+        deny: `${client} deny ${decisionId} --text "<feedback>" ${binding}`,
+    };
+}
+function githubOf(records) {
+    const started = record(records.started);
+    const operation = list(parsed(text(started["operationId"])));
+    const result = record(records.result);
+    const completed = result["outcome"] === "completed";
+    return {
+        runId: text(operation[2]),
+        round: Number(operation[1]),
+        method: text(started["method"]),
+        report: completed ? record(parsed(text(result["result"]))) : {},
+    };
+}
+function pullRequestOf(results) {
+    const opened = results
+        .filter((item) => item.method === "open-pr")
+        .map((item) => item.report)
+        .findLast((report) => text(report["url"]).startsWith("https://"));
+    if (opened === undefined)
+        return null;
+    return { number: Number(opened["number"]), url: text(opened["url"]) };
+}
+function reviewsOf(results) {
+    return results
+        .filter((item) => item.method === "wait-review")
+        .flatMap(({ round, report }) => {
+        const score = count(report["score"]);
+        if (score === null)
+            return [];
+        return [{ round, commit: text(report["commit"]), score }];
+    });
+}
+function mergeCommitOf(results) {
+    const merged = results
+        .filter((item) => item.method === "merge")
+        .map((item) => stamp(item.report["merged"]));
+    return merged.find((commit) => commit !== null) ?? null;
+}
+function pullOf(inputs, runId) {
+    const results = inputs.githubRecords
+        .map(githubOf)
+        .filter((item) => item.runId === runId)
+        .toSorted((first, second) => first.round - second.round);
+    return {
+        pullRequest: pullRequestOf(results),
+        reviews: reviewsOf(results),
+        mergeCommit: mergeCommitOf(results),
+    };
+}
+function feedbackOf(value) {
+    const fields = record(value);
+    return {
+        decisionId: text(fields["decisionId"]),
+        text: text(fields["text"]),
+    };
+}
+function eventOf(value) {
+    const fields = record(value);
+    return {
+        sequence: count(fields["sequence"]) ?? 0,
+        recordedAt: text(fields["recordedAt"]),
+        type: text(fields["type"]),
+    };
+}
+function runOf(inputs, value) {
+    const status = record(record(value)["status"]);
+    const runId = text(status["runId"]);
+    const workflowId = text(status["workflowId"]);
+    const budget = record(status["budget"]);
+    const ticketId = text(status["ticketId"]);
+    const ticketStatus = record(status["outcome"])["ticketStatus"];
+    return {
+        runId,
+        workflowId,
+        ticketId: ticketId === "" ? null : ticketId,
+        title: stamp(status["title"]),
+        outcome: stamp(record(status["outcome"])["kind"]),
+        ...(isTicketStatus(ticketStatus) ? { ticketStatus } : {}),
+        ...(record(status["outcome"])["issueUpdate"] === "failed"
+            ? { issueUpdate: "failed" }
+            : {}),
+        latestAt: stamp(status["latestAt"]),
+        claudeCostUsd: priceOf(status["claudeCostUsd"]),
+        estimatedCostUsd: priceOf(status["estimatedCostUsd"]),
+        usage: usageOf(status["usage"]),
+        currentStep: currentStepOf(list(record(value)["events"]), workflowId),
+        round: roundOf(list(record(value)["events"])),
+        state: text(status["state"]),
+        code: text(record(status["reason"])["code"]),
+        detail: text(record(status["reason"])["detail"]),
+        spent: count(budget["spent"]),
+        limit: count(budget["limit"]),
+        decisions: inputs.decisions
+            .filter((decision) => record(decision)["runId"] === runId)
+            .map((decision) => decisionCommands(decision, inputs.client)),
+        events: list(record(value)["events"]).map(eventOf),
+        turns: statusTurns(inputs.turns, status),
+        phases: phasesOf(list(record(value)["events"]), workflowId),
+        decision: decisionOf(list(record(value)["events"])),
+        feedback: list(status["feedback"]).map(feedbackOf),
+        ...pullOf(inputs, runId),
+    };
+}
+function began(run) {
+    return run.events[0]?.recordedAt ?? "";
+}
+export function watchModel(inputs) {
+    const runs = inputs.runs.map((value) => shortened(displayRun(runOf(inputs, value), inputs.home)));
+    const candidates = [
+        ...runs,
+        ...list(inputs.completionCandidates).map((value) => runOf(inputs, value)),
+    ];
+    const workflows = boardsOf({ ...inputs, completionCandidates: candidates }, runs);
+    return {
+        workflows,
+        startWorkflowId: startWorkflowOf(workflows),
+        updatedAt: inputs.updatedAt,
+        service: inputs.service,
+        runs: runs.toSorted((first, second) => began(first) < began(second) ? 1 : -1),
+    };
+}

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

@@ -0,0 +1,9 @@
+import { type WatchModel } from "./watch-render.ts";
+export interface WatchLocation {
+    readonly workflowId: string | null;
+    readonly runId: string | null;
+}
+export declare function watchLocation(hash: string): WatchLocation;
+export declare function watchHash(location: WatchLocation): string;
+export declare function boardWorkflow(model: WatchModel, workflowId: string | null): string | null;
+export declare function watchTitle(model: WatchModel, selected: string): string;

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

@@ -0,0 +1,40 @@
+import { pageTitle } from "./watch-render.js";
+export function watchLocation(hash) {
+    const value = hash.replace(/^#/, "");
+    if (value === "")
+        return { workflowId: null, runId: null };
+    if (/^(workflow|run)=/.test(value)) {
+        const fields = new URLSearchParams(value);
+        return {
+            workflowId: fields.get("workflow") || null,
+            runId: fields.get("run") || null,
+        };
+    }
+    try {
+        return { workflowId: null, runId: decodeURIComponent(value) };
+    }
+    catch {
+        return { workflowId: null, runId: value };
+    }
+}
+export function watchHash(location) {
+    const workflow = location.workflowId === null
+        ? ""
+        : `workflow=${encodeURIComponent(location.workflowId)}`;
+    const run = location.runId === null ? "" : `run=${encodeURIComponent(location.runId)}`;
+    return `#${[workflow, run].filter((part) => part !== "").join("&")}`;
+}
+export function boardWorkflow(model, workflowId) {
+    return model.workflows.some((workflow) => workflow.workflowId === workflowId)
+        ? workflowId
+        : model.startWorkflowId;
+}
+export function watchTitle(model, selected) {
+    const location = watchLocation(selected);
+    if (location.runId !== null)
+        return pageTitle(model, location.runId);
+    const workflow = boardWorkflow(model, location.workflowId);
+    const waiting = model.workflows.reduce((total, item) => total + item.waitingCount, 0);
+    const prefix = waiting === 0 ? "" : `(${String(waiting)}) `;
+    return workflow === null ? "Cloving" : `${prefix}${workflow} · Cloving`;
+}

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

@@ -0,0 +1 @@
+export declare function pageDocument(actionToken?: string | null): string;