cloving 1.2.0 → 1.3.0

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,7 +1,15 @@
-import { type WorkerUsage, type WorkerAttemptUsage } 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;
@@ -13,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>>;
@@ -35,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;