cloving 1.0.1 → 1.1.0

package/dist/src/workflow-contracts.js

@@ -1,3 +1,4 @@
+import { isTicketStatus } from "./ticket-status.js";
 const identifier = /^[A-Za-z0-9._:-]{1,128}$/;
 const reason = /^\S[\s\S]{0,255}$/;
 export function isBlockedReason(value) {
@@ -39,6 +40,7 @@ const outcomes = {
     },
     handoff_requested: {
         keys: ["cycleId", "kind", "promotionId"],
+        optional: ["ticketStatus", "issueUpdate"],
         parse: (fields) => {
             const cycleId = textField(fields, {
                 key: "cycleId",
@@ -50,12 +52,24 @@ const outcomes = {
             });
             if (cycleId === null || promotionId === null)
                 return null;
-            return { kind: "handoff_requested", cycleId, promotionId };
+            const ticketStatus = fields["ticketStatus"];
+            const issueUpdate = fields["issueUpdate"];
+            if (issueUpdate !== undefined && issueUpdate !== "failed")
+                return null;
+            if (ticketStatus !== undefined && !isTicketStatus(ticketStatus))
+                return null;
+            return {
+                kind: "handoff_requested",
+                cycleId,
+                promotionId,
+                ...(issueUpdate === "failed" ? { issueUpdate } : {}),
+                ...(ticketStatus === undefined ? {} : { ticketStatus }),
+            };
         },
     },
 };
 export function validateDevelopmentInput(value) {
-    const fields = exactFields(value, ["cycleId"]);
+    const fields = exactFields(value, { required: ["cycleId"] });
     const cycleId = fields && textField(fields, { key: "cycleId", pattern: identifier });
     if (!cycleId)
         return { kind: "invalid", reason: "invalid-development-input" };
@@ -66,18 +80,26 @@ export function validateCycleOutcome(value, input) {
     const contract = typeof kind === "string" && Object.hasOwn(outcomes, kind)
         ? outcomes[kind]
         : undefined;
-    const fields = contract && exactFields(value, contract.keys);
+    const fields = contract &&
+        exactFields(value, {
+            required: contract.keys,
+            optional: contract.optional ?? [],
+        });
     const outcome = fields && contract.parse(fields);
     if (!outcome || outcome.cycleId !== input.cycleId)
         return { kind: "invalid", reason: "invalid-cycle-outcome" };
     return { kind: "valid", value: outcome };
 }
-function exactFields(value, keys) {
+function exactFields(value, shape) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return null;
     const fields = Object.fromEntries(Object.entries(value));
+    const keys = shape?.required;
+    const optional = shape?.optional ?? [];
     if (keys &&
-        JSON.stringify(Object.keys(fields).sort()) !== JSON.stringify(keys))
+        JSON.stringify(Object.keys(fields)
+            .filter((key) => !optional.includes(key))
+            .sort()) !== JSON.stringify(keys))
         return null;
     return fields;
 }

package/dist/src/workflow-declaration.d.ts

@@ -2,7 +2,7 @@ import type { SubmissionContract } from "./submission.ts";
 export interface WorkflowDeclaration {
     readonly workflowId: string;
     readonly effectLimit: number;
-    readonly capabilities: readonly ("claude" | "github")[];
+    readonly capabilities: readonly ("claude" | "github" | "chats")[];
     readonly input: SubmissionContract;
 }
 export interface DeclaredWorkflow extends WorkflowDeclaration {

package/dist/src/workflow-declaration.js

@@ -52,6 +52,8 @@ export function isWorkflowDeclaration(value) {
         integer(effectLimit, { minimum: 1, maximum: 100 }) &&
         Array.isArray(capabilities) &&
         capabilities.length > 0 &&
-        capabilities.every((capability) => capability === "claude" || capability === "github") &&
+        capabilities.every((capability) => capability === "claude" ||
+            capability === "github" ||
+            capability === "chats") &&
         isInput(input));
 }

package/dist/src/workflows.d.ts

@@ -3,3 +3,4 @@ export { protectedEffect } from "./steps/protected-effect.ts";
 export { decisionGate } from "./steps/decision-gate.ts";
 export type { GateRequest, GateResult, ProtectedRequest, ProtectedResult, ProtectedScope, } from "./step-bridge.ts";
 export type { CycleOutcome, DevelopmentInput } from "./workflow-contracts.ts";
+export { ticketStatus, type TicketStatus } from "./ticket-status.ts";

package/dist/src/workflows.js

@@ -1,3 +1,4 @@
 export { loadCycle } from "./steps/load-cycle.js";
 export { protectedEffect } from "./steps/protected-effect.js";
 export { decisionGate } from "./steps/decision-gate.js";
+export { ticketStatus } from "./ticket-status.js";

package/dist/tools/self-host-processes.js

@@ -4,7 +4,7 @@ import { extname, join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
 import { selfUpdater } from "./self-update.js";
-import { workerTurnActive } from "./self-update-host.js";
+import { selfUpdateActive } from "./self-update-host.js";
 function launched(argumentsList, settings) {
     const child = spawn(process.execPath, argumentsList, {
         cwd: settings.directory,
@@ -58,7 +58,11 @@ async function polled(settings, lifecycle) {
         directory: settings.directory,
         git: updatingGit(settings, lifecycle.stopping),
         active: async () => lifecycle.stopping.aborted ||
-            (await workerTurnActive(settings.directory)),
+            (await selfUpdateActive({
+                directory: settings.directory,
+                runtimeDirectory: settings.runtime,
+                signal: lifecycle.stopping,
+            })),
         stop: async () => {
             if (lifecycle.stopping.aborted)
                 throw new Error("self-update-stopped");
@@ -102,6 +106,7 @@ function hostedChildren(settings) {
             environment: {
                 ...process.env,
                 CLOVING_RUNTIME_DIR: settings.runtime,
+                CLOVING_WATCH_REPOSITORY: settings.repository,
             },
         }),
     ];

package/dist/tools/self-host-workflows.d.ts

@@ -11,5 +11,5 @@ interface HostManifest {
 }
 export declare function workflowFiles(directory: string): Promise<string[]>;
 export declare function workflowDeclarations(directory: string, manifests: Readonly<Record<string, HostManifest>>): Promise<readonly DeclaredWorkflow[]>;
-export declare function workflowManifests(compiled: WorkflowManifest): Readonly<Record<string, HostManifest>>;
+export declare function workflowManifests(compiled: WorkflowManifest, declarations?: readonly DeclaredWorkflow[]): Readonly<Record<string, HostManifest>>;
 export {};

package/dist/tools/self-host-workflows.js

@@ -45,7 +45,7 @@ export async function workflowDeclarations(directory, manifests) {
     }
     return declarations;
 }
-export function workflowManifests(compiled) {
+export function workflowManifests(compiled, declarations = []) {
     const names = new Set();
     const steps = Object.values(compiled.steps ?? {})
         .flatMap((entries) => Object.values(entries))
@@ -68,7 +68,7 @@ export function workflowManifests(compiled) {
                     name: basename(file, extname(file)),
                     workflowId,
                     steps,
-                    capabilities: ["claude", "github"],
+                    capabilities: declarations.find((declaration) => declaration.functionName === functionName)?.capabilities ?? ["claude", "github"],
                     resources: [],
                     artifacts: "artifacts",
                 },

package/dist/tools/self-host.js

@@ -1,4 +1,5 @@
 import { isProfilesFile } from "../src/turn-profile.js";
+import { parseTokenPrices } from "../src/token-prices.js";
 import { execFileSync, spawn } from "node:child_process";
 import { copyFile, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
 import { dirname, extname, join, resolve } from "node:path";
@@ -156,13 +157,9 @@ async function registered() {
     const manifests = workflowManifests(compiled);
     const declarations = await workflowDeclarations(join(product, "workflows"), manifests);
     const paths = new Map();
-    for (const [functionName, manifest] of Object.entries(manifests)) {
+    for (const [functionName, manifest] of Object.entries(workflowManifests(compiled, declarations))) {
         const path = join(project, `${manifest.name}.workflow.json`);
-        const declared = declarations.find((entry) => entry.functionName === functionName);
-        await writeFile(path, JSON.stringify({
-            ...manifest,
-            capabilities: declared?.capabilities ?? manifest.capabilities,
-        }));
+        await writeFile(path, JSON.stringify(manifest));
         paths.set(functionName, path);
     }
     return { manifests: Object.fromEntries(paths), declarations };
@@ -229,6 +226,7 @@ async function prepared() {
         throw new Error("The workflows did not compile.");
     return registered();
 }
+const tokenPrices = parseTokenPrices(process.env["CLOVING_TOKEN_PRICES"]);
 const profiles = await profilesFile();
 const worker = selectedWorker();
 const command = worker === "codex"
@@ -239,12 +237,14 @@ const ticketCommand = listed("CLOVING_TICKET_COMMAND");
 const queueMilliseconds = queueInterval({ nextCommand, ticketCommand });
 const manifests = await prepared();
 await launchers({
+    tokenPrices,
     worker,
     profiles,
     command,
     ticketCommand,
     nextCommand,
     queueMilliseconds,
+    resetQueue: flags.includes("--reset-queue"),
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
     checkCommand: listed("CLOVING_CHECK_COMMAND"),

package/dist/tools/self-update-host.d.ts

@@ -1,6 +1,13 @@
+interface ActivitySettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly signal?: AbortSignal;
+}
+export declare function selfUpdateActive(settings: ActivitySettings): Promise<boolean>;
 export declare function selfUpdateMilliseconds(settings: {
     readonly seconds: string | undefined;
     readonly repository: string;
     readonly product: string;
 }): Promise<number | undefined>;
 export declare function workerTurnActive(directory: string): Promise<boolean>;
+export {};

package/dist/tools/self-update-host.js

@@ -1,5 +1,52 @@
 import { access, readdir, realpath } from "node:fs/promises";
-import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { extname, join } from "node:path";
+import { promisify } from "node:util";
+import { record } from "../src/protocol.js";
+async function runPage(settings, after) {
+    const output = await promisify(execFile)(process.execPath, [
+        join(import.meta.dirname, `../src/cli${extname(import.meta.filename)}`),
+        "status",
+        "--json",
+        "--limit",
+        "500",
+        ...(after === "" ? [] : ["--after", after]),
+    ], {
+        env: { ...process.env, CLOVING_RUNTIME_DIR: settings.runtimeDirectory },
+        encoding: "utf8",
+        timeout: 30000,
+        signal: settings.signal,
+    });
+    const page = record(JSON.parse(output.stdout));
+    if (!page)
+        throw new Error("invalid-run-list");
+    return page;
+}
+export async function selfUpdateActive(settings) {
+    if (await present(join(settings.directory, "queue-submission")))
+        return true;
+    if (await workerTurnActive(settings.directory))
+        return true;
+    let after = "";
+    do {
+        const page = await runPage(settings, after);
+        const runs = page["runs"];
+        if (!Array.isArray(runs))
+            throw new Error("invalid-run-list");
+        if (runs.some((value) => {
+            const run = record(value);
+            if (!run)
+                throw new Error("invalid-run-status");
+            return !["completed", "failed", "cancelled"].includes(String(run["state"]));
+        }))
+            return true;
+        const next = page["next"];
+        if (next !== null && (typeof next !== "string" || next <= after))
+            throw new Error("invalid-run-page");
+        after = next;
+    } while (after !== null);
+    return false;
+}
 export async function selfUpdateMilliseconds(settings) {
     const { seconds } = settings;
     if (seconds === undefined)

package/dist/tools/self-update.d.ts

@@ -5,6 +5,7 @@ export interface SelfUpdateSettings {
     readonly stop: () => Promise<void>;
     readonly error: (line: string) => void;
 }
+export declare function lockRequiresInstall(before: string, after: string): boolean;
 export declare function selfUpdater(settings: SelfUpdateSettings): {
     readonly check: () => Promise<number | undefined>;
 };

package/dist/tools/self-update.js

@@ -1,3 +1,22 @@
+export function lockRequiresInstall(before, after) {
+    try {
+        return !isDeepStrictEqual(lockPackages(before), lockPackages(after));
+    }
+    catch {
+        return true;
+    }
+}
+function lockPackages(text) {
+    const lock = JSON.parse(text);
+    if (typeof lock !== "object" || lock === null || !("packages" in lock))
+        throw new Error("invalid package lock");
+    const packages = lock.packages;
+    if (typeof packages !== "object" ||
+        packages === null ||
+        Array.isArray(packages))
+        throw new Error("invalid package lock packages");
+    return Object.fromEntries(Object.entries(packages).filter(([path]) => path !== ""));
+}
 async function clean(git) {
     const status = await git([
         "status",
@@ -9,6 +28,24 @@ async function clean(git) {
         return false;
     return !/^[a-zS] /m.test(await git(["ls-files", "-v"]));
 }
+async function installRequired(git, update) {
+    try {
+        await git([
+            "diff",
+            "--exit-code",
+            update.head,
+            update.target,
+            "--",
+            "package-lock.json",
+        ]);
+        return false;
+    }
+    catch {
+        const before = await git(["show", `${update.head}:package-lock.json`]);
+        const after = await git(["show", `${update.target}:package-lock.json`]);
+        return lockRequiresInstall(before, after);
+    }
+}
 async function candidate(settings) {
     const git = settings.git;
     await git(["fetch", "origin"]);
@@ -26,10 +63,40 @@ async function candidate(settings) {
     await git(["merge-base", "--is-ancestor", head, target]);
     if (!(await clean(git)))
         return;
+    await markPending(settings.directory);
     if (await settings.active())
-        return;
+        return "waiting";
     return { branch, head, target };
 }
+async function markPending(directory, publication = "initial") {
+    if (publication === "renew") {
+        const timestamp = Number(await readFile(join(directory, "pending-self-update"), "utf8"));
+        if (timestamp > 0 && Date.now() - timestamp < 30 * 60 * 1000)
+            return;
+    }
+    await mkdir(directory, { recursive: true });
+    const temporary = join(directory, `pending-self-update-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, `${String(Date.now())}\n`, {
+            flag: "wx",
+            mode: 0o600,
+            flush: true,
+        });
+        if (publication === "renew") {
+            await rename(temporary, join(directory, "pending-self-update"));
+            return;
+        }
+        await link(temporary, join(directory, "pending-self-update")).catch((error) => {
+            if (!(error instanceof Error) ||
+                !("code" in error) ||
+                error.code !== "EEXIST")
+                throw error;
+        });
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
 async function failedTargets(directory) {
     try {
         return (await readFile(join(directory, "failed-self-updates"), "utf8")).split("\n");
@@ -70,21 +137,16 @@ export function selfUpdater(settings) {
             if (disabled || checking)
                 return;
             checking = true;
+            let waiting = false;
             try {
                 const update = await candidate(settings).catch(() => undefined);
-                if (!update)
+                if (update === "waiting") {
+                    waiting = true;
                     return;
-                try {
-                    await settings.git([
-                        "diff",
-                        "--exit-code",
-                        update.head,
-                        update.target,
-                        "--",
-                        "package-lock.json",
-                    ]);
                 }
-                catch {
+                if (!update)
+                    return;
+                if (await installRequired(settings.git, update).catch(() => true)) {
                     disabled = true;
                     settings.error("Self-update disabled: package-lock.json changed; update and install by hand.\n");
                     return;
@@ -92,14 +154,24 @@ export function selfUpdater(settings) {
                 const failed = await failedTargets(settings.directory).catch(() => undefined);
                 if (!failed || failed.includes(update.target))
                     return;
+                await markPending(settings.directory, "renew");
+                waiting = await settings.active().catch(() => true);
+                if (waiting)
+                    return;
                 disabled = true;
                 return await updated(settings, update);
             }
             finally {
                 checking = false;
+                if (!waiting)
+                    await rm(join(settings.directory, "pending-self-update"), {
+                        force: true,
+                    });
             }
         },
     };
 }
-import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { appendFile, link, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";

package/dist/workflows/analyze-chats.d.ts

@@ -0,0 +1,10 @@
+import type { CycleOutcome } from "cloving/workflows";
+interface AnalysisInput {
+    readonly cycleId: string;
+    readonly repository: string;
+    readonly input: {
+        readonly importId: string;
+    };
+}
+export declare function analyzeChats(input: AnalysisInput): Promise<CycleOutcome>;
+export {};

package/dist/workflows/analyze-chats.declaration.json

@@ -0,0 +1,9 @@
+{
+  "workflowId": "analyze-chats",
+  "effectLimit": 3,
+  "capabilities": ["chats", "claude"],
+  "input": {
+    "maximumBytes": 4096,
+    "fields": { "importId": { "type": "string" } }
+  }
+}

package/dist/workflows/analyze-chats.js

@@ -0,0 +1,73 @@
+import { protectedEffect } from "cloving/workflows/steps/protected-effect";
+function request(importId, step) {
+    const { operation, payload } = step;
+    return {
+        scope: { phase: "analysis", operation, round: 1 },
+        capability: operation === "turn-analysis" ? "claude" : "chats",
+        method: operation === "turn-analysis" ? "run-turn:analyze-chats" : operation,
+        target: importId,
+        payload: JSON.stringify(payload),
+        units: 1,
+    };
+}
+function blocked(cycleId, failure) {
+    const { operation, result } = failure;
+    return {
+        kind: "blocked",
+        cycleId,
+        evidenceId: operation,
+        reason: "reason" in result && result.reason !== null
+            ? result.reason
+            : result.kind,
+    };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function fields(result) {
+    try {
+        const value = JSON.parse(result ?? "null");
+        return record(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function analyzeChats(input) {
+    "use workflow";
+    const { cycleId } = input;
+    const { importId } = input.input;
+    const read = await protectedEffect(request(importId, { operation: "read-analysis", payload: { importId } }));
+    if (read.kind !== "completed")
+        return blocked(cycleId, { operation: "read-analysis", result: read });
+    const snapshot = fields(read.result)["snapshot"];
+    if (!record(snapshot) || snapshot["importId"] !== importId)
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: "analysis-input-refused",
+            evidenceId: "read-analysis",
+        };
+    const turn = await protectedEffect(request(importId, { operation: "turn-analysis", payload: { snapshot } }));
+    if (turn.kind !== "completed")
+        return blocked(cycleId, { operation: "turn-analysis", result: turn });
+    const reply = fields(turn.result)["reply"];
+    if (typeof reply !== "string")
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: "analysis-turn-failed",
+            evidenceId: "turn-analysis",
+        };
+    const save = await protectedEffect(request(importId, {
+        operation: "save-analysis",
+        payload: { importId, cycleId, snapshot, reply },
+    }));
+    if (save.kind !== "completed")
+        return blocked(cycleId, { operation: "save-analysis", result: save });
+    return {
+        kind: "handoff_requested",
+        cycleId,
+        promotionId: `analysis:${importId}:${cycleId}`,
+    };
+}

package/dist/workflows/develop-ticket.d.ts

@@ -1,11 +1,5 @@
 import type { CycleOutcome } from "cloving/workflows";
-interface Ticket {
-    readonly cycleId: string;
-    readonly ticket: string;
-    readonly ticketId?: string;
-    readonly repository: string;
-    readonly delivery?: string;
-}
+import { type Ticket } from "./ticket-prompts.ts";
 interface Decision {
     readonly gateId: string;
     readonly decision: string;