cloving 0.3.20 → 1.1.0

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

@@ -0,0 +1,135 @@
+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) {
+    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 = 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 }));
+    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("p", {
+                class: "turn-usage",
+                children: usageText(turn.usage),
+            }),
+            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 : (props.copyLabel ?? "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-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

@@ -0,0 +1,54 @@
+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;
+}
+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 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 {};

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

@@ -0,0 +1,267 @@
+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 { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
+import { Decision, Events, Turn } from "./watch-turn.js";
+import { StartRun } from "./watch-start-view.js";
+export const clove = {
+    viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
+    paths: [
+        "M41.47315,11.48535c-1.20117-0.12305-2.16211-1.08398-2.28418-2.28516c-0.17676-1.7334-1.01758-3.29492-2.36865-4.39648s-3.05078-1.61719-4.7832-1.43359c-3.34277,0.34082-5.86377,3.13086-5.86377,6.49121v14.13867c0,0.27637,0.22363,0.5,0.5,0.5H40.8125c3.59766,0,6.52441-2.92676,6.52441-6.52441C47.33692,14.61523,44.81592,11.82422,41.47315,11.48535z M35.56543,15.81543l-5.85791,5.85742c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703l5.85791-5.85742c0.19531-0.19531,0.51172-0.19531,0.70703,0C35.76073,15.30372,35.76074,15.62011,35.56543,15.81543z",
+        "M15.30225,0.66308c-3.36035,0-6.15088,2.52051-6.49121,5.86328C8.68897,7.72852,7.72852,8.68945,6.52686,8.81152c-1.7334,0.17578-3.29492,1.01758-4.396,2.36816s-1.61035,3.0498-1.43408,4.7832c0.34033,3.34277,3.13086,5.86328,6.49121,5.86328h14.13867c0.27637,0,0.5-0.22363,0.5-0.5V7.18751C21.82666,3.58984,18.8999,0.66308,15.30225,0.66308z M18.99951,19.00001c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85742-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703c0.19531-0.19531,0.51172-0.19531,0.70703,0l5.85742,5.8584C19.19482,18.48829,19.19482,18.80469,18.99951,19.00001z",
+        "M24,26.17383H9.86133c-3.59766,0-6.52441,2.92676-6.52441,6.52441c0,3.35938,2.52051,6.14941,5.86377,6.49023c1.20117,0.12207,2.16211,1.08301,2.28418,2.28418c0.17676,1.7334,1.01758,3.29492,2.36865,4.39648c1.17529,0.95801,2.61377,1.46777,4.11035,1.46777c0.22314,0,0.44775-0.01074,0.67285-0.03418C21.97949,46.96189,24.5,44.17186,24.5,40.81248V26.67383C24.5,26.39746,24.27637,26.17383,24,26.17383z M21.67334,29.70704l-5.85791,5.8584c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703L20.9663,29c0.19531-0.19531,0.51172-0.19531,0.70703,0S21.86865,29.51172,21.67334,29.70704z",
+        "M47.30322,32.03711c-0.34033-3.34277-3.13086-5.86328-6.49072-5.86328H26.67334c-0.27637,0-0.5,0.22363-0.5,0.5V40.8125c0,3.59766,2.92676,6.52441,6.52442,6.52441c3.36035,0,6.15088-2.52148,6.49121-5.86426c0.12207-1.20117,1.08301-2.16211,2.28418-2.28418c1.7334-0.17578,3.29492-1.01758,4.396-2.36816S47.47949,33.7705,47.30322,32.03711z M35.56543,35.56543c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85791-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703s0.51172-0.19531,0.70703,0l5.85791,5.8584C35.76074,35.05371,35.76074,35.37011,35.56543,35.56543z",
+    ],
+};
+export function BannerDetail(props) {
+    const { run, now } = props;
+    const turn = run.turns.at(-1);
+    if (run.state === "waiting_gate")
+        return waitingDetail(run, now);
+    if (run.state === "completed")
+        return completedDetail(run);
+    if (run.state !== "running" || turn?.outcome !== "in work")
+        return `${run.code}: ${run.detail}`;
+    const calls = turn.activity.filter((item) => item.kind === "tool").length;
+    const quiet = turn.activeAt === null
+        ? ""
+        : ` · last output ${elapsed(turn.activeAt, now)} ago`;
+    const last = turn.activity.at(-1)?.text ?? "The worker starts.";
+    return [
+        `Claude works for ${elapsed(turn.startedAt, now)} · ${counted(calls, "tool call")}${quiet}`,
+        element("span", { class: "now", children: last }),
+    ];
+}
+export function Banner(props) {
+    const { run, now } = props;
+    const { tone, icon, label } = runTone(run);
+    const name = element("span", { class: "name", children: runName(run) });
+    const words = [
+        element("h2", { children: [label, " ", name] }),
+        element("p", { children: component(BannerDetail, { run, now }) }),
+    ];
+    return element("section", {
+        class: `banner ${tone}`,
+        children: [
+            element("span", { class: "icon", children: icon }),
+            element("div", { children: words }),
+        ],
+    });
+}
+export function Phases(props) {
+    const marks = {
+        done: "✓",
+        active: "●",
+        failed: "✕",
+    };
+    const steps = props.phases.map((phase) => element("li", {
+        class: `phase ${phase.state}`,
+        children: [
+            element("span", { class: "mark", children: marks[phase.state] ?? "○" }),
+            element("span", { class: "name", children: phase.name }),
+            element("span", {
+                class: "time",
+                children: phaseTime(phase, props.now),
+            }),
+        ],
+    }));
+    return element("ol", { class: "phases", children: steps });
+}
+export function Review(props) {
+    const { run, round } = props;
+    const decisionId = `${run.runId}/review-${String(round)}`;
+    const denied = run.feedback.find((item) => item.decisionId === decisionId);
+    if (denied !== undefined)
+        return element("section", {
+            class: "review denied",
+            children: [
+                element("h3", { children: `Review ${String(round)} · denied` }),
+                element("p", { children: denied.text }),
+            ],
+        });
+    if (!run.decisions.some((item) => item.decisionId === decisionId))
+        return null;
+    return element("section", {
+        class: "review pending",
+        children: element("h3", {
+            children: `Review ${String(round)} · waits for your decision`,
+        }),
+    });
+}
+export function PullRequest(props) {
+    const { pullRequest, reviews, mergeCommit } = props.run;
+    if (pullRequest === null)
+        return null;
+    const link = element("a", {
+        href: pullRequest.url,
+        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)}`,
+    }));
+    const merge = mergeCommit === null
+        ? null
+        : element("p", {
+            class: "meta",
+            children: [
+                "Merge commit ",
+                element("code", { children: mergeCommit }),
+            ],
+        });
+    return element("section", {
+        class: "pull",
+        children: [
+            element("h3", { children: ["Pull request ", link] }),
+            element("ul", { class: "reviews", children: scores }),
+            merge,
+        ],
+    });
+}
+export function Run(props) {
+    const { run, now, copying } = props;
+    const turn = run.turns.at(-1);
+    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 turns = run.turns.length === 0
+        ? element("p", { class: "meta", children: none })
+        : run.turns.map((item, index) => [
+            component(Turn, { key: item.key, turn: item, now }),
+            component(Review, {
+                key: `review-${item.key}`,
+                run,
+                round: index + 1,
+            }),
+        ]);
+    const foot = [
+        `${run.workflowId} · ${run.runId}${budget}`,
+        element("br", {}),
+        `${run.code}: ${run.detail}`,
+    ];
+    return [
+        component(Banner, { run, now }),
+        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 })),
+        turns,
+        component(Events, { events: run.events }),
+        element("p", { class: "meta foot", children: foot }),
+    ];
+}
+export function Header(props) {
+    const { model, stale } = props;
+    const updated = model === null ? "" : `updated ${clockTime(model.updatedAt)}`;
+    const stamp = stale
+        ? element("span", {
+            class: "bad",
+            children: "The watch tool does not answer.",
+        })
+        : element("span", { children: updated });
+    return element("header", {
+        children: [
+            element("strong", {
+                class: "brand",
+                children: [
+                    element("svg", {
+                        xmlns: "http://www.w3.org/2000/svg",
+                        "aria-hidden": "true",
+                        focusable: "false",
+                        viewBox: clove.viewBox,
+                        children: clove.paths.map((d) => element("path", { fill: "currentColor", d })),
+                    }),
+                    "cloving",
+                ],
+            }),
+            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 Page(props) {
+    const { model, selected, now, stale, copying } = props;
+    const head = component(Header, { model, stale });
+    const text = (tone, children) => element("p", { class: tone, children });
+    const waits = "The page waits for the first data of the watch tool.";
+    if (model === null)
+        return [head, text("meta", waits)];
+    const lost = "The Cloving service does not answer. The page shows the last known records.";
+    const down = model.service === "up" ? null : text("down", lost);
+    const location = watchLocation(selected);
+    const workflowId = boardWorkflow(model, location.workflowId);
+    if (location.runId !== null) {
+        const run = model.runs.find((item) => item.runId === location.runId);
+        const back = run?.workflowId ?? location.workflowId ?? model.startWorkflowId;
+        return [
+            head,
+            down,
+            element("a", {
+                class: "back",
+                href: watchHash({ workflowId: back, runId: null }),
+                children: `← Back to ${back ?? "workflows"}`,
+            }),
+            run === undefined
+                ? text("meta", "This run is not available.")
+                : 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);
+    const start = props.start ?? { shown: false, onToggle: () => undefined };
+    return element("div", {
+        class: "board-page",
+        children: [
+            component(Header, { model, stale, start }),
+            down,
+            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,
+                            controls: props.columns,
+                            cardForm: model.cardForms?.find((form) => form.workflowId === workflowId),
+                            cards: props.cards,
+                        }),
+                ],
+            }),
+        ],
+    });
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import { addAbortListener } from "node:events";
+import { execFile, spawn } from "node:child_process";
+import { delimiter, dirname, extname, join } from "node:path";
+import { main } from "./cli/main.js";
+import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
+import { commandUsage } from "./cli/usage.js";
+const [command, ...options] = process.argv.slice(2);
+const watchCommand = async (request) => {
+    const [command = "", ...argumentsList] = request.command;
+    const completed = Promise.withResolvers();
+    const stderr = { text: "" };
+    const execution = execFile(command, argumentsList, {
+        cwd: request.directory,
+        signal: request.signal,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+        encoding: "utf8",
+    }, (error, stdout) => {
+        const code = error === null ? 0 : error.code;
+        completed.resolve({
+            stdout,
+            stderr: stderr.text,
+            status: typeof code === "number" ? code : null,
+            errorCode: typeof code === "string" ? code : null,
+        });
+    });
+    execution.stderr?.on("data", (chunk) => {
+        stderr.text += chunk.toString();
+    });
+    const closed = new Promise((resolve) => execution.once("close", () => {
+        resolve();
+    }));
+    const listener = addAbortListener(request.signal, () => {
+        execution.kill("SIGKILL");
+    });
+    try {
+        await closed;
+        return await completed.promise;
+    }
+    finally {
+        listener[Symbol.dispose]();
+    }
+};
+function started(runtime, argumentsList) {
+    const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
+    const located = [
+        "--runtime",
+        runtime,
+        "--repository",
+        process.cwd(),
+        "--client",
+        clientCommand(process.env),
+    ];
+    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
+        },
+    });
+    let stopping = false;
+    const interrupt = () => {
+        stopping = true;
+        child.kill("SIGINT");
+    };
+    const terminate = () => {
+        stopping = true;
+        child.kill("SIGTERM");
+    };
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", terminate);
+    return new Promise((settle) => {
+        child.once("close", (status) => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+            settle(stopping && status === 75 ? 0 : (status ?? 1));
+        });
+    });
+}
+async function start() {
+    if (options.includes("--help")) {
+        process.stdout.write(String(commandUsage["start"]));
+        return 0;
+    }
+    const runtime = runtimeDirectory(process.env);
+    if (runtime !== undefined) {
+        let status = await started(runtime, options);
+        const restarting = options.filter((option) => option !== "--reset-queue");
+        while (status === 75)
+            status = await started(runtime, restarting);
+        return status === 0 ? 0 : 1;
+    }
+    process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
+    return 1;
+}
+if (command === "start")
+    process.exitCode = await start();
+else
+    await main(process.argv.slice(2), {
+        repository: process.env["CLOVING_WATCH_REPOSITORY"],
+        githubCommand: process.env["CLOVING_GH_COMMAND"],
+        execute: watchCommand,
+    });

package/dist/src/daemon/analysis-launch.d.ts

@@ -0,0 +1,5 @@
+export { analysisInstruction } from "../chats/analysis-prompt.ts";
+export declare const analysisMethod = "run-turn:analyze-chats";
+export declare function analysisCommand(): readonly string[];
+export declare function analysisEnvironment(folder: string): NodeJS.ProcessEnv;
+export declare function analysisAvailable(folder: string): Promise<boolean>;