cloving 0.3.20 → 1.0.1

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

@@ -0,0 +1,176 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { createServer, } from "node:http";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { watchReader } from "./watch-reads.js";
+import { turnOf, watchModel } from "./watch-model.js";
+import { pageDocument } from "./watch-page.js";
+import { watchStream } from "./watch-stream.js";
+export const defaultWatchPort = 3663;
+const notFound = { status: 404, type: "text/plain", body: "not found" };
+const libraryFile = fileURLToPath(import.meta.resolve("preact"));
+function parsed(text) {
+    try {
+        const value = JSON.parse(text);
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+const noStream = { size: 0, lines: [], activeAt: null };
+async function streamed(watch, file) {
+    const found = await stat(file).catch(() => null);
+    if (found === null)
+        return noStream;
+    const known = watch.streams.get(file);
+    const activeAt = found.mtime.toISOString();
+    if (known?.size === found.size)
+        return { ...known, activeAt };
+    const lines = (await readFile(file, "utf8").catch(() => "")).split("\n");
+    watch.streams.set(file, { size: found.size, lines });
+    return { size: found.size, lines, activeAt };
+}
+async function stored(file) {
+    return parsed(await readFile(file, "utf8").catch(() => "null"));
+}
+async function turns(watch) {
+    const journal = join(dirname(watch.settings.runtimeDirectory), "journal");
+    const found = [];
+    for (const key of await readdir(journal).catch(() => [])) {
+        const started = await stored(join(journal, key, "started.json"));
+        if (started === null)
+            continue;
+        const stream = await streamed(watch, join(journal, key, "turn.jsonl"));
+        found.push(turnOf({
+            key,
+            started,
+            result: await stored(join(journal, key, "result.json")),
+            lines: stream.lines,
+            activeAt: stream.activeAt,
+        }));
+    }
+    return found.toSorted((first, second) => first.startedAt < second.startedAt ? -1 : 1);
+}
+async function githubRecords(watch) {
+    const journal = join(dirname(watch.settings.runtimeDirectory), "github");
+    const keys = await readdir(journal).catch(() => []);
+    for (const key of keys) {
+        const known = watch.github.get(key);
+        if (known !== undefined && known.result !== null)
+            continue;
+        const started = known?.started ?? (await stored(join(journal, key, "started.json")));
+        if (started === null)
+            continue;
+        const result = await stored(join(journal, key, "result.json"));
+        watch.github.set(key, { started, result });
+    }
+    return keys.flatMap((key) => watch.github.get(key) ?? []);
+}
+async function snapshot(watch, runId) {
+    const updatedAt = new Date().toISOString();
+    const [read, journal, github] = await Promise.all([
+        runId === null ? watch.reader.read(updatedAt) : watch.reader.run(runId),
+        turns(watch),
+        githubRecords(watch),
+    ]);
+    return watchModel({
+        ...read,
+        home: homedir(),
+        client: watch.settings.client,
+        updatedAt,
+        turns: journal,
+        githubRecords: github,
+    });
+}
+async function answered(watch, request) {
+    const url = new URL(String(request.url), "http://localhost");
+    const path = url.pathname;
+    if (request.method !== "GET")
+        return notFound;
+    if (path === "/")
+        return {
+            status: 200,
+            type: "text/html; charset=utf-8",
+            body: pageDocument(),
+        };
+    if (path === "/preact.mjs")
+        return {
+            status: 200,
+            type: "text/javascript; charset=utf-8",
+            body: await readFile(libraryFile, "utf8"),
+        };
+    if (path !== "/data.json")
+        return notFound;
+    const runId = url.searchParams.get("runId");
+    const model = await snapshot(watch, runId);
+    if (runId !== null && model.runs.length === 0)
+        return notFound;
+    return {
+        status: 200,
+        type: "application/json",
+        body: JSON.stringify(runId === null ? model : { run: model.runs[0] }),
+    };
+}
+function replied(response, reply) {
+    response.writeHead(reply.status, {
+        "content-type": reply.type,
+        "cache-control": "no-store",
+    });
+    response.end(reply.body);
+}
+function subscribed(stream, exchange) {
+    const { request, response } = exchange;
+    const changed = () => {
+        response.write("data: change\n\n");
+    };
+    response.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-store",
+    });
+    changed();
+    request.once("close", stream.subscribe(changed));
+}
+export function watchServer(settings) {
+    const watch = {
+        settings,
+        reader: watchReader(settings.runtimeDirectory),
+        streams: new Map(),
+        github: new Map(),
+    };
+    const stream = watchStream({
+        runtimeDirectory: settings.runtimeDirectory,
+        journal: join(dirname(settings.runtimeDirectory), "journal"),
+        retryMilliseconds: 1000,
+    });
+    const server = createServer((request, response) => {
+        if (request.method === "GET" && request.url === "/events") {
+            subscribed(stream, { request, response });
+            return;
+        }
+        answered(watch, request).then((reply) => {
+            replied(response, reply);
+        }, () => {
+            replied(response, { ...notFound, status: 500, body: "failed" });
+        });
+    });
+    return new Promise((settle) => {
+        server.once("error", (error) => {
+            stream.close();
+            settings.complain(`watch-not-started: ${error.message}\n`);
+            settle(1);
+        });
+        server.listen(settings.port, "127.0.0.1", () => {
+            const bound = Reflect.get(Object(server.address()), "port");
+            settings.announce(`Watch page: http://127.0.0.1:${String(bound)}/\n`);
+        });
+        const closed = () => {
+            stream.close();
+            server.close();
+            server.closeAllConnections();
+            settle(0);
+        };
+        settings.stopped.then(closed, closed);
+    });
+}

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

@@ -0,0 +1,11 @@
+export interface StreamSettings {
+    readonly runtimeDirectory: string;
+    readonly journal: string;
+    readonly retryMilliseconds: number;
+}
+export interface WatchStream {
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly close: () => void;
+}
+export declare function throttled(notify: () => void, milliseconds: number): () => void;
+export declare function watchStream(settings: StreamSettings): WatchStream;

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

@@ -0,0 +1,128 @@
+import { watch } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { follow, send } from "./client.js";
+const burstMilliseconds = 100;
+export function throttled(notify, milliseconds) {
+    const burst = { open: false, again: false };
+    const fire = () => {
+        burst.open = true;
+        setTimeout(ended, milliseconds).unref();
+        notify();
+    };
+    const ended = () => {
+        burst.open = false;
+        if (!burst.again)
+            return;
+        burst.again = false;
+        fire();
+    };
+    return () => {
+        if (burst.open)
+            burst.again = true;
+        else
+            fire();
+    };
+}
+async function paused(stream) {
+    const { signal } = stream.stopping;
+    await delay(stream.settings.retryMilliseconds, undefined, { signal }).catch(() => undefined);
+}
+async function serviceFollowed(stream) {
+    const { runtimeDirectory } = stream.settings;
+    while (!stream.stopping.signal.aborted) {
+        const page = await send(runtimeDirectory, {
+            operation: "events",
+            parameters: { limit: 1 },
+        });
+        if (page.kind === "result") {
+            stream.notify();
+            const after = page.result["latestSequence"];
+            await follow(runtimeDirectory, {
+                request: { operation: "events", parameters: { after, follow: true } },
+                onEvent: stream.notify,
+                signal: stream.stopped,
+            });
+            stream.notify();
+        }
+        await paused(stream);
+    }
+}
+function present(file) {
+    return stat(file).then(() => true, () => false);
+}
+async function openTurns(journal) {
+    const files = [];
+    for (const folder of await readdir(journal).catch(() => [])) {
+        const started = await present(join(journal, folder, "started.json"));
+        const ended = await present(join(journal, folder, "result.json"));
+        if (started && !ended)
+            files.push(join(journal, folder, "turn.jsonl"));
+    }
+    return files;
+}
+function tailed(stream, file) {
+    if (stream.tails.has(file))
+        return;
+    try {
+        const watcher = watch(file, stream.notify);
+        watcher.on("error", stream.notify);
+        stream.tails.set(file, watcher);
+    }
+    catch {
+        return;
+    }
+    stream.notify();
+}
+async function tailsRefreshed(stream) {
+    const open = await openTurns(stream.settings.journal);
+    for (const [file, watcher] of stream.tails) {
+        if (open.includes(file))
+            continue;
+        watcher.close();
+        stream.tails.delete(file);
+        stream.notify();
+    }
+    for (const file of open)
+        tailed(stream, file);
+}
+async function journalWatched(stream) {
+    while (!stream.stopping.signal.aborted) {
+        await tailsRefreshed(stream);
+        await paused(stream);
+    }
+    for (const watcher of stream.tails.values())
+        watcher.close();
+}
+export function watchStream(settings) {
+    const listeners = new Set();
+    const stopping = new AbortController();
+    const stream = {
+        settings,
+        stopping,
+        stopped: new Promise((settle) => {
+            stopping.signal.addEventListener("abort", () => {
+                settle();
+            });
+        }),
+        notify: throttled(() => {
+            for (const listener of [...listeners])
+                listener();
+        }, burstMilliseconds),
+        tails: new Map(),
+    };
+    Promise.allSettled([serviceFollowed(stream), journalWatched(stream)]).then(() => undefined, () => undefined);
+    return {
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        close: () => {
+            listeners.clear();
+            stopping.abort();
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+import { type Shown } from "./watch-element.ts";
+import { type Copying, type WatchDecision, type WatchEvent, type WatchItem, type WatchTurn } from "./watch-render.ts";
+export declare function Item(props: {
+    readonly item: WatchItem;
+}): Shown;
+export declare function Group(props: {
+    readonly items: readonly WatchItem[];
+    readonly open: boolean;
+}): Shown;
+export declare function Turn(props: {
+    readonly turn: WatchTurn;
+    readonly now: string;
+}): Shown;
+export declare function Work(props: {
+    readonly turn: WatchTurn;
+}): Shown;
+export declare function Command(props: {
+    readonly label: string;
+    readonly command: string;
+    readonly copying: Copying;
+}): Shown;
+export declare function Decision(props: {
+    readonly decision: WatchDecision;
+    readonly turn: WatchTurn | undefined;
+    readonly copying: Copying;
+}): Shown;
+export declare function Events(props: {
+    readonly events: readonly WatchEvent[];
+}): Shown;

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

@@ -0,0 +1,130 @@
+import { component, element } from "./watch-element.js";
+import { clockTime, counted, groupActivity, turnTime, } from "./watch-render.js";
+export function Item(props) {
+    const { kind, text } = props.item;
+    const title = kind === "tool" ? text : undefined;
+    return element("div", { class: `item ${kind}`, title, children: text });
+}
+export function Group(props) {
+    const { items, open } = props;
+    const lines = items.map((item) => component(Item, { item }));
+    if (items.length < 2)
+        return lines;
+    const errors = items.filter((item) => item.kind === "error").length;
+    const failed = element("span", {
+        class: "bad",
+        children: counted(errors, "error"),
+    });
+    const summary = [
+        counted(items.length - errors, "tool call"),
+        errors === 0 ? null : [" · ", failed],
+        element("span", { class: "last", children: items.at(-1)?.text }),
+    ];
+    return element("details", {
+        class: "tools",
+        open,
+        children: [element("summary", { children: summary }), lines],
+    });
+}
+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 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", {
+        class: "turn code-window",
+        children: [
+            element("h3", {
+                class: "code-head",
+                children: heading.filter((part) => part !== "").join(" · "),
+            }),
+            element("p", { class: "meta", children: place }),
+            element("div", { class: "activity", children: activity }),
+        ],
+    });
+}
+export function Work(props) {
+    const { turn } = props;
+    const loose = turn.uncommitted.length;
+    const block = (lines) => element("pre", { children: lines.join("\n") });
+    const text = (tone, children) => element("p", { class: tone, children });
+    const branch = [
+        "Branch ",
+        element("code", { children: turn.branch }),
+        ` · ${counted(turn.commits.length, "commit")}`,
+    ];
+    const commits = turn.commits.length === 0
+        ? text("bad", "The worker made no commit.")
+        : [text("fact", branch), block(turn.commits), block(turn.files)];
+    const left = `${counted(loose, "file")} ${loose === 1 ? "is" : "are"} not committed:`;
+    const state = loose === 0
+        ? text("good", "All the work is committed.")
+        : [text("bad", left), block(turn.uncommitted)];
+    const report = element("details", {
+        open: true,
+        children: [
+            element("summary", { children: "Report of the worker" }),
+            element("div", { class: "report", children: turn.summary }),
+        ],
+    });
+    return [commits, state, report];
+}
+export function Command(props) {
+    const { label, command, copying } = props;
+    const onClick = () => {
+        copying.onCopy(command);
+    };
+    const shown = copying.command === command ? copying.label : "Copy";
+    return element("div", {
+        class: "command code-window",
+        children: [
+            element("span", { class: "label code-head", children: label }),
+            element("code", { children: command }),
+            element("button", { type: "button", onClick, children: shown }),
+        ],
+    });
+}
+export function Decision(props) {
+    const { decision, turn, copying } = props;
+    const request = element("details", {
+        open: turn === undefined,
+        children: [
+            element("summary", { children: "Full text of the request" }),
+            element("pre", { children: decision.prompt }),
+        ],
+    });
+    return element("section", {
+        class: "decision",
+        children: [
+            element("h3", { children: `Your decision · ${decision.type}` }),
+            turn === undefined ? null : component(Work, { turn }),
+            request,
+            component(Command, {
+                label: "Approve",
+                command: decision.approve,
+                copying,
+            }),
+            component(Command, { label: "Deny", command: decision.deny, copying }),
+        ],
+    });
+}
+export function Events(props) {
+    const { events } = props;
+    const rows = events.map((event) => element("div", {
+        class: "event",
+        children: `${clockTime(event.recordedAt)} ${event.type}`,
+    }));
+    return element("details", {
+        class: "events code-window",
+        children: [
+            element("summary", {
+                class: "code-head",
+                children: `All events (${String(events.length)})`,
+            }),
+            rows,
+        ],
+    });
+}

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

@@ -0,0 +1,39 @@
+import { type Shown } from "./watch-element.ts";
+import { type Copying, type WatchModel, type WatchPhase, type WatchRun } from "./watch-render.ts";
+interface Timed {
+    readonly run: WatchRun;
+    readonly now: string;
+}
+export declare const clove: {
+    viewBox: string;
+    paths: string[];
+};
+export declare function BannerDetail(props: Timed): Shown;
+export declare function Banner(props: Timed): Shown;
+export declare function Phases(props: {
+    readonly phases: readonly WatchPhase[];
+    readonly now: string;
+}): Shown;
+export declare function Review(props: {
+    readonly run: WatchRun;
+    readonly round: number;
+}): Shown;
+export declare function PullRequest(props: {
+    readonly run: WatchRun;
+}): Shown;
+export declare function Run(props: Timed & {
+    readonly copying: Copying;
+}): Shown;
+export declare function Header(props: {
+    readonly model: WatchModel | null;
+    readonly stale: boolean;
+}): Shown;
+export interface PageProps {
+    readonly model: WatchModel | null;
+    readonly selected: string;
+    readonly now: string;
+    readonly stale: boolean;
+    readonly copying: Copying;
+}
+export declare function Page(props: PageProps): Shown;
+export {};