cloving 1.1.0 → 1.3.0

package/dist/src/cli.js

@@ -1,11 +1,27 @@
 #!/usr/bin/env node
+import { createProbeRunner } from "./cli/probe-command.js";
+import { settingsEnvironment } from "./cli/project-settings.js";
 import { addAbortListener } from "node:events";
-import { execFile, spawn } from "node:child_process";
-import { delimiter, dirname, extname, join } from "node:path";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { delimiter, dirname, extname, join, resolve } from "node:path";
 import { main } from "./cli/main.js";
-import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
+import { parseInvocation } from "./cli/arguments.js";
+import { adoptionRecordPath, clientCommand, legacyRuntimeDirectory, runtimeDirectory, } from "./cli/runtime-directory.js";
 import { commandUsage } from "./cli/usage.js";
 const [command, ...options] = process.argv.slice(2);
+function repositoryDirectory(directory) {
+    try {
+        return realpathSync(execFileSync("git", ["-C", resolve(directory), "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim());
+    }
+    catch {
+        return undefined;
+    }
+}
 const watchCommand = async (request) => {
     const [command = "", ...argumentsList] = request.command;
     const completed = Promise.withResolvers();
@@ -42,17 +58,30 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
-function started(runtime, argumentsList) {
-    const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
+function startArguments(input) {
+    const { runtime, repository, argumentsList } = input;
     const located = [
         "--runtime",
-        runtime,
+        runtimeDirectory(process.env, repository) ?? runtime,
         "--repository",
-        process.cwd(),
+        repository ?? process.cwd(),
         "--client",
-        clientCommand(process.env),
+        clientCommand(process.env, repository),
     ];
-    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
+    const record = repository === undefined
+        ? undefined
+        : adoptionRecordPath(process.env, repository);
+    const legacy = legacyRuntimeDirectory(process.env);
+    if (!process.env["CLOVING_RUNTIME_DIR"] &&
+        record !== undefined &&
+        !existsSync(record) &&
+        legacy !== undefined)
+        located.push("--legacy-runtime", resolve(legacy), "--adoption-record", resolve(record));
+    return [...located, ...argumentsList];
+}
+function toolProcess(input) {
+    const program = join(import.meta.dirname, "..", "tools", `${input.tool}${extname(import.meta.filename)}`);
+    const child = spawn(process.execPath, [program, ...input.argumentsList], {
         stdio: "inherit",
         env: {
             ...process.env,
@@ -78,27 +107,81 @@ function started(runtime, argumentsList) {
         });
     });
 }
+function started(input) {
+    return toolProcess({
+        tool: "self-host",
+        argumentsList: startArguments(input),
+    });
+}
 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;
+    const parsed = parseArgs({
+        args: options,
+        options: { repository: { type: "string" } },
+        strict: false,
+        allowPositionals: true,
+    });
+    const selected = parsed.values["repository"];
+    if (Object.hasOwn(parsed.values, "repository") &&
+        (typeof selected !== "string" || selected === "")) {
+        process.stderr.write("missing-value: --repository needs a directory.\n");
+        return 1;
     }
-    process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
-    return 1;
+    if (parsed.positionals.length > 0) {
+        process.stderr.write("unexpected-argument: run cloving start --help for usage.\n");
+        return 1;
+    }
+    const repository = repositoryDirectory(typeof selected === "string" ? selected : process.cwd());
+    const runtime = runtimeDirectory(process.env, repository);
+    if (runtime === undefined) {
+        process.stderr.write("repository-unknown: Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.\n");
+        return 1;
+    }
+    let status = await started({ runtime, argumentsList: options, repository });
+    const restarting = options.filter((option) => option !== "--reset-queue");
+    while (status === 75)
+        status = await started({
+            runtime,
+            argumentsList: restarting,
+            repository,
+        });
+    return status === 0 ? 0 : 1;
 }
-if (command === "start")
+if (command === "workflows" && ["list", "test"].includes(options[0] ?? ""))
+    process.exitCode = await toolProcess({
+        tool: "workflow-command",
+        argumentsList: options,
+    });
+else if (command === "templates")
+    process.exitCode = await toolProcess({
+        tool: "template-command",
+        argumentsList: options,
+    });
+else if (command === "start")
     process.exitCode = await start();
-else
+else {
+    const invocation = parseInvocation(process.argv.slice(2));
+    const repository = repositoryDirectory("repository" in invocation
+        ? (invocation.repository ?? process.cwd())
+        : process.cwd());
+    const settingsRepository = process.env["CLOVING_WATCH_REPOSITORY"] ?? repository;
+    const environment = invocation.kind === "watch" && settingsRepository !== undefined
+        ? settingsEnvironment(process.env, settingsRepository)
+        : process.env;
     await main(process.argv.slice(2), {
-        repository: process.env["CLOVING_WATCH_REPOSITORY"],
-        githubCommand: process.env["CLOVING_GH_COMMAND"],
-        execute: watchCommand,
+        repository,
+        environment,
+        doctorProbe: createProbeRunner({
+            spawn: (input) => spawn(input.executable, input.arguments, input.options),
+            kill: (identifier, signal) => process.kill(identifier, signal),
+        }),
+        watchPr: {
+            repository: process.env["CLOVING_WATCH_REPOSITORY"],
+            githubCommand: environment["CLOVING_GH_COMMAND"],
+            execute: watchCommand,
+        },
     });
+}

package/dist/src/command-settings.d.ts

@@ -0,0 +1,16 @@
+export type LocalCommands = Readonly<Record<string, readonly string[]>>;
+export declare const commandLimits: {
+    stdoutBytes: number;
+    stderrBytes: number;
+    resultBytes: number;
+};
+export interface CommandEffect {
+    readonly operationId: string;
+    readonly name: string;
+    readonly state: string;
+    readonly exitCode: number | null;
+    readonly durationMilliseconds: number | null;
+}
+export type CommandEffects = (effects: readonly CommandEffect[]) => Promise<readonly CommandEffect[]>;
+export declare function parseCommands(text: string | undefined): LocalCommands;
+export declare function parseCommandSeconds(text: string | undefined): number;

package/dist/src/command-settings.js

@@ -0,0 +1,42 @@
+import { record } from "./protocol.js";
+export const commandLimits = {
+    stdoutBytes: 1_048_576,
+    stderrBytes: 65_536,
+    resultBytes: 3_145_728,
+};
+function argumentsList(value) {
+    return (Array.isArray(value) &&
+        typeof value[0] === "string" &&
+        value[0].startsWith("/") &&
+        Array.from(value).every((argument) => typeof argument === "string" && !argument.includes("\u0000")));
+}
+export function parseCommands(text) {
+    if (text === undefined)
+        return {};
+    try {
+        const fields = record(JSON.parse(text));
+        if (fields === undefined)
+            throw new Error("invalid-commands");
+        const commands = {};
+        for (const [name, argumentList] of Object.entries(fields)) {
+            if (!/^[A-Za-z0-9-]{1,64}$/.test(name) || !argumentsList(argumentList))
+                throw new Error("invalid-commands");
+            commands[name] = [...argumentList];
+        }
+        return commands;
+    }
+    catch {
+        throw new Error("invalid-commands");
+    }
+}
+export function parseCommandSeconds(text) {
+    if (text === undefined)
+        return 60;
+    const seconds = Number(text);
+    if (!/^\d+$/.test(text) ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 3600)
+        throw new Error("invalid-command-seconds");
+    return seconds;
+}

package/dist/src/configuration-change.d.ts

@@ -0,0 +1,11 @@
+export interface SettingChange {
+    readonly field: string;
+    readonly action: "set" | "unset";
+    readonly value?: string;
+    readonly scope: "project" | "private";
+}
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [name: string]: JsonValue;
+};
+export declare function settingValue(text: string): JsonValue;
+export declare function changedConfiguration(contents: string | undefined, change: SettingChange): string;

package/dist/src/configuration-change.js

@@ -0,0 +1,62 @@
+import { configuration, settingScope, validateSetting, } from "./configuration-schema.js";
+import { configurationValues, parseConfiguration } from "./project-settings.js";
+import { record } from "./protocol.js";
+function isJsonValue(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    const object = record(value);
+    return object !== undefined && Object.values(object).every(isJsonValue);
+}
+export function settingValue(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    if (!isJsonValue(value))
+        throw new Error("invalid-setting-value");
+    return value;
+}
+function trimHarness(root, field) {
+    const order = ["harness.name", "harness.kind", "harness.path"];
+    const index = order.indexOf(field);
+    const harness = record(root["harness"]);
+    if (index < 0 || harness === undefined)
+        return;
+    const names = ["name", "kind", "path"].slice(0, index + 1);
+    root["harness"] = Object.fromEntries(Object.entries(harness).filter(([name]) => names.includes(name)));
+}
+function assign(root, change) {
+    const [name = "", ...tail] = change.field.split(".");
+    if (tail.length === 0 && change.action === "unset")
+        return Object.fromEntries(Object.entries(root).filter(([key]) => key !== name));
+    if (tail.length === 0)
+        return { ...root, [name]: settingValue(change.value ?? "") };
+    const child = assign({ ...record(root[name]) }, { ...change, field: tail.join(".") });
+    if (Object.keys(child).length === 0)
+        return Object.fromEntries(Object.entries(root).filter(([key]) => key !== name));
+    return { ...root, [name]: child };
+}
+export function changedConfiguration(contents, change) {
+    settingScope(change.field);
+    if (change.action === "set")
+        validateSetting(change.field, settingValue(change.value ?? ""));
+    const previous = parseConfiguration(contents, change.scope);
+    const root = {
+        version: 1,
+        ...previous,
+    };
+    if (change.action === "unset" ||
+        configurationValues(previous)[change.field] !==
+            settingValue(change.value ?? ""))
+        trimHarness(root, change.field);
+    const next = assign(root, change);
+    configuration(next, change.scope);
+    return JSON.stringify(next, null, 2) + "\n";
+}

package/dist/src/configuration-display.d.ts

@@ -0,0 +1,21 @@
+import { type SettingValue } from "./project-settings.ts";
+import { type JsonValue } from "./configuration-change.ts";
+import type { TurnProfiles } from "./turn-profile.ts";
+type Source = "environment" | "private" | "project" | "default";
+type DisplayValue = SettingValue | JsonValue;
+interface ValueSource {
+    readonly value: DisplayValue;
+    readonly source: Source;
+}
+export interface SettingEntry extends ValueSource {
+    readonly field: string;
+    readonly hidden: readonly ValueSource[];
+}
+export declare function configurationEntries(input: {
+    readonly project: string | undefined;
+    readonly private: string | undefined;
+    readonly environment: Readonly<NodeJS.ProcessEnv>;
+    readonly field?: string;
+    readonly profiles?: TurnProfiles;
+}): readonly SettingEntry[];
+export {};

package/dist/src/configuration-display.js

@@ -0,0 +1,69 @@
+import { settingFields, settingScope } from "./configuration-schema.js";
+import { configurationValues, parseConfiguration, settingVariables, } from "./project-settings.js";
+import { settingValue } from "./configuration-change.js";
+import { harnessDefaults, nativeHarness } from "./harness-defaults.js";
+import { builtInPriceTable, parseTokenPrices } from "./token-prices.js";
+const defaults = {
+    "queue.lanes": 1,
+    "harness.name": "claude",
+    "harness.output": "text",
+    tokenPrices: builtInPriceTable.prices,
+    fallbackModels: [],
+    profiles: {},
+    "watch.port": 3663,
+    "watch.actions": "on",
+    "github.command": ["gh"],
+};
+function effectiveValue(setting) {
+    const { field, value } = setting;
+    if (field === "tokenPrices")
+        return parseTokenPrices(JSON.stringify(value));
+    return value;
+}
+export function configurationEntries(input) {
+    const project = configurationValues(parseConfiguration(input.project, "project"));
+    const privateFile = configurationValues(parseConfiguration(input.private, "private"));
+    const name = input.environment["CLOVING_WORKER"] ?? privateFile["harness.name"];
+    const harness = typeof name === "string" && !nativeHarness(name)
+        ? undefined
+        : harnessDefaults(name);
+    const environment = Object.fromEntries(Object.entries({
+        ...settingVariables,
+        profiles: "CLOVING_PROFILES",
+        ...(harness?.variable === undefined
+            ? {}
+            : { "harness.command": harness.variable }),
+    }).flatMap(([field, variable]) => {
+        const value = input.environment[variable];
+        return value === undefined ? [] : [[field, settingValue(value)]];
+    }));
+    if (input.profiles !== undefined)
+        environment["profiles"] = input.profiles;
+    const effectiveDefaults = {
+        ...defaults,
+        ...(harness === undefined ? {} : { "harness.command": harness.command }),
+    };
+    const fields = input.field === undefined ? settingFields() : [input.field];
+    const layers = [
+        ["environment", environment],
+        ["private", privateFile],
+        ["project", project],
+    ];
+    return fields.map((field) => {
+        settingScope(field);
+        const [effective, ...hidden] = layers.flatMap(([source, values]) => {
+            const value = values[field];
+            return value === undefined ? [] : [{ source, value }];
+        });
+        const selected = effective ?? {
+            source: "default",
+            value: effectiveDefaults[field] ?? null,
+        };
+        return {
+            field,
+            ...selected,
+            value: effectiveValue({ field, value: selected.value }),
+            hidden,
+        };
+    });
+}

package/dist/src/configuration-schema.d.ts

@@ -0,0 +1,49 @@
+import type { TurnProfiles } from "./turn-profile.ts";
+import type { TokenPrices } from "./token-prices.ts";
+export interface Configuration {
+    readonly version: 1;
+    readonly checks?: {
+        readonly beforeMerge?: readonly string[];
+        readonly required?: readonly string[];
+    };
+    readonly tickets?: {
+        readonly command?: readonly string[];
+        readonly nextCommand?: readonly string[];
+    };
+    readonly queue?: {
+        readonly everySeconds?: number;
+        readonly lanes?: number;
+    };
+    readonly harness?: {
+        readonly name?: string;
+        readonly turn?: readonly string[];
+        readonly output?: "text";
+        readonly kind?: "file" | "shell";
+        readonly path?: string;
+        readonly command?: readonly string[];
+    };
+    readonly profiles?: TurnProfiles;
+    readonly fallbackModels?: readonly string[];
+    readonly tokenPrices?: TokenPrices;
+    readonly privateTexts?: readonly string[];
+    readonly notify?: {
+        readonly command?: readonly string[];
+    };
+    readonly watch?: {
+        readonly port?: number | "off";
+        readonly actions?: "on" | "off";
+    };
+    readonly selfUpdate?: {
+        readonly everySeconds?: number;
+    };
+    readonly github?: {
+        readonly command?: readonly string[];
+    };
+    readonly workflows?: {
+        readonly folder?: string;
+    };
+}
+export declare function configuration(value: unknown, scope: "project" | "private"): Configuration;
+export declare function settingScope(field: string): "project" | "private";
+export declare function validateSetting(field: string, value: unknown): void;
+export declare function settingFields(): readonly string[];

package/dist/src/configuration-schema.js

@@ -0,0 +1,159 @@
+import project from "./project-config.schema.json" with { type: "json" };
+import privateConfig from "./private-config.schema.json" with { type: "json" };
+import { record } from "./protocol.js";
+import { isTurnCommand } from "./harness-defaults.js";
+const schemas = {
+    project,
+    private: privateConfig,
+};
+function invalid(field) {
+    throw new Error(`invalid-setting: ${field}`);
+}
+function text(value, { schema, field }) {
+    if (typeof value !== "string")
+        invalid(field);
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value))
+        invalid(field);
+}
+function number(value, { schema, field }) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        invalid(field);
+    if (schema.type === "integer" && !Number.isInteger(value))
+        invalid(field);
+    bounds(value, { schema, field });
+}
+function bounds(value, { schema, field }) {
+    if (schema.minimum !== undefined && value < schema.minimum)
+        invalid(field);
+    if (schema.maximum !== undefined && value > schema.maximum)
+        invalid(field);
+    if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum)
+        invalid(field);
+}
+function scalar(value, checked) {
+    const { schema, field } = checked;
+    if (field === "harness.turn" && !isTurnCommand(value))
+        invalid(field);
+    if ("const" in schema && value !== schema.const)
+        invalid(field);
+    if (schema.enum !== undefined && !schema.enum.includes(value))
+        invalid(field);
+    if (schema.type === "string")
+        text(value, checked);
+    if (schema.type === "number" || schema.type === "integer")
+        number(value, checked);
+}
+function childSchema(name, { schema, field }) {
+    const properties = schema.properties ?? {};
+    const child = Object.hasOwn(properties, name)
+        ? properties[name]
+        : schema.additionalProperties;
+    if (child === false || child === undefined)
+        throw new Error(`unknown-setting: ${field}`);
+    if (schema.propertyNames !== undefined &&
+        !new RegExp(schema.propertyNames.pattern).test(name))
+        invalid(field);
+    return child;
+}
+function validateObject(value, { schema, field }) {
+    const object = record(value);
+    if (object === undefined)
+        invalid(field);
+    for (const required of schema.required ?? [])
+        if (!Object.hasOwn(object, required))
+            invalid(`${field}.${required}`);
+    for (const [name, item] of Object.entries(object)) {
+        const path = field === "" ? name : `${field}.${name}`;
+        const child = childSchema(name, { schema, field: path });
+        if (typeof child === "object")
+            validate(item, { schema: child, field: path });
+    }
+}
+function matches(value, schema) {
+    try {
+        validate(value, { schema, field: "" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validate(value, checked) {
+    const { schema, field } = checked;
+    if (schema.anyOf !== undefined) {
+        if (!schema.anyOf.some((option) => matches(value, option)))
+            invalid(field);
+        return;
+    }
+    scalar(value, checked);
+    if (schema.type === "object")
+        validateObject(value, checked);
+    if (schema.type !== "array")
+        return;
+    if (!Array.isArray(value))
+        invalid(field);
+    if (schema.maxItems !== undefined && value.length > schema.maxItems)
+        invalid(field);
+    if (schema.items === undefined)
+        return;
+    for (const [index, item] of value.entries())
+        validate(item, {
+            schema: schema.items,
+            field: `${field}.${String(index)}`,
+        });
+}
+function validateConfiguration(value, scope) {
+    const object = record(value);
+    if (object === undefined)
+        invalid("$");
+    if (object["version"] !== 1)
+        throw new Error("unsupported-config-version: version");
+    if (scope === "project") {
+        for (const field of Object.keys(object))
+            if (Object.hasOwn(privateConfig.properties, field) &&
+                !Object.hasOwn(project.properties, field))
+                throw new Error(`private-setting-in-project-file: ${field}`);
+    }
+    validate(object, { schema: schemas[scope] ?? {}, field: "" });
+}
+export function configuration(value, scope) {
+    validateConfiguration(value, scope);
+    return value;
+}
+export function settingScope(field) {
+    fieldSchema(field);
+    const root = field.split(".")[0] ?? "";
+    return Object.hasOwn(project.properties, root) ? "project" : "private";
+}
+function fieldSchema(field) {
+    if (!settingFields().includes(field))
+        throw new Error(`unknown-setting: ${field}`);
+    let schema = privateConfig;
+    for (const name of field.split(".")) {
+        if (schema.type !== "object")
+            throw new Error(`unknown-setting: ${field}`);
+        const child = childSchema(name, { schema, field });
+        if (typeof child !== "object")
+            throw new Error(`unknown-setting: ${field}`);
+        schema = child;
+    }
+    return schema;
+}
+export function validateSetting(field, value) {
+    const schema = fieldSchema(field);
+    if (schema.minimum !== undefined &&
+        schema.maximum !== undefined &&
+        typeof value === "number" &&
+        (value < schema.minimum || value > schema.maximum))
+        throw new Error(`invalid-setting: ${field} must be from ${String(schema.minimum)} to ${String(schema.maximum)}`);
+    validate(value, { schema, field });
+}
+export function settingFields() {
+    return Object.entries(privateConfig.properties).flatMap(([name, schema]) => {
+        if (name === "version")
+            return [];
+        return "properties" in schema
+            ? Object.keys(schema.properties).map((child) => `${name}.${child}`)
+            : [name];
+    });
+}

package/dist/src/daemon/claude-turn.d.ts

@@ -1,6 +1,15 @@
-import { type WorkerUsage } from "../worker-usage.ts";
-export type Worker = "claude" | "codex";
+import type { ReviewVerdict } from "../review-subject.ts";
+import type { TicketStatus } from "../ticket-status.ts";
+import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
+export type Worker = string;
 export interface StreamResult {
+    readonly reviewFeedback?: string;
+    readonly reviewVerdict?: ReviewVerdict | null;
+    readonly models?: readonly WorkerModelUsage[];
+    readonly ticketStatusTooLarge?: true;
+    readonly ticketStatus?: TicketStatus;
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    readonly pricingModel?: string | null;
     readonly subtype?: string;
     readonly errorType?: string;
     readonly model: string | null;
@@ -12,13 +21,16 @@ export interface StreamResult {
     readonly turns: number | null;
 }
 export interface TurnEnd {
+    readonly reason?: string;
+    readonly detail?: string;
     readonly stopped?: boolean;
     readonly exitCode: number | null;
     readonly result: StreamResult | undefined;
 }
 export interface TurnStart {
-    readonly mode?: "analysis";
-    readonly analysisToken?: string;
+    readonly resultBytes?: number;
+    readonly output?: "text";
+    readonly shell?: string;
     readonly worker?: Worker;
     readonly turnId?: string;
     readonly environment?: Readonly<Record<string, string>>;
@@ -34,5 +46,8 @@ export interface RunningTurn {
     readonly stop: (graceMilliseconds: number) => void;
 }
 export declare function capacityRefusal(result: StreamResult | undefined): boolean;
-export declare function streamResult(line: string): StreamResult | undefined;
+export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
+export declare function succeeded(end: TurnEnd): boolean;
+export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;
+export declare function turnEnvironment(configuration: string, start: TurnStart): NodeJS.ProcessEnv;
 export declare function startTurn(start: TurnStart): RunningTurn;