cloving 1.1.0 → 1.2.0

package/dist/workflows/analyze-chats.js

@@ -1,8 +1,9 @@
+import { decisionGate } from "cloving/workflows/steps/decision-gate";
 import { protectedEffect } from "cloving/workflows/steps/protected-effect";
 function request(importId, step) {
     const { operation, payload } = step;
     return {
-        scope: { phase: "analysis", operation, round: 1 },
+        scope: { phase: "analysis", operation, round: step.round ?? 1 },
         capability: operation === "turn-analysis" ? "claude" : "chats",
         method: operation === "turn-analysis" ? "run-turn:analyze-chats" : operation,
         target: importId,
@@ -33,14 +34,72 @@ function fields(result) {
         return {};
     }
 }
-export async function analyzeChats(input) {
-    "use workflow";
+function usableDraft(cycleId, draft) {
+    return (draft["cycleId"] === cycleId &&
+        typeof draft["candidateDigest"] === "string" &&
+        /^[a-f0-9]{64}$/.test(draft["candidateDigest"]) &&
+        typeof draft["expiresAt"] === "string" &&
+        record(draft["question"]));
+}
+function draftAnswer(draft, decision) {
+    if (decision.decision === "expired")
+        return "analysis-answer-missing";
+    const question = draft["question"];
+    const choices = record(question) ? question["choices"] : undefined;
+    if (decision.gateId !== "analysis-question" ||
+        decision.decision !== "answered" ||
+        typeof decision.answer !== "string" ||
+        !Array.isArray(choices) ||
+        !choices.some((choice) => record(choice) && choice["id"] === decision.answer))
+        return "analysis-answer-invalid";
+    return null;
+}
+async function askDraft(cycleId, continuation) {
+    const { draft, decision } = continuation;
+    if (!usableDraft(cycleId, draft))
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: "analysis-input-refused",
+            evidenceId: "save-analysis",
+        };
+    if (decision !== undefined) {
+        const reason = draftAnswer(draft, decision);
+        if (reason === null)
+            return { kind: "answered", answer: decision.answer ?? "" };
+        return {
+            kind: "blocked",
+            cycleId,
+            reason,
+            evidenceId: "analysis-question",
+        };
+    }
+    const gate = await decisionGate({
+        gateId: "analysis-question",
+        kind: "question",
+        prompt: JSON.stringify({
+            candidateDigest: draft["candidateDigest"],
+            question: draft["question"],
+        }),
+        expiresAt: draft.expiresAt,
+    });
+    if (gate.kind !== "opened")
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: gate.reason,
+            evidenceId: "analysis-question",
+        };
+    return { kind: "waiting_for_decision", cycleId, decisionId: gate.decisionId };
+}
+async function firstTurn(input) {
     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"];
+    const captured = fields(read.result);
+    const snapshot = captured["snapshot"];
     if (!record(snapshot) || snapshot["importId"] !== importId)
         return {
             kind: "blocked",
@@ -48,7 +107,29 @@ export async function analyzeChats(input) {
             reason: "analysis-input-refused",
             evidenceId: "read-analysis",
         };
-    const turn = await protectedEffect(request(importId, { operation: "turn-analysis", payload: { snapshot } }));
+    return runTurn(input, batchData(captured, snapshot));
+}
+function batchData(value, snapshot) {
+    const context = value["context"];
+    const batch = value["batch"];
+    return {
+        snapshot,
+        ...(record(context) ? { context } : {}),
+        ...(record(batch) ? { batch } : {}),
+    };
+}
+async function runTurn(input, data) {
+    const { cycleId } = input;
+    const { snapshot, followUp, context } = data;
+    const turn = await protectedEffect(request(input.input.importId, {
+        operation: "turn-analysis",
+        payload: {
+            snapshot,
+            ...(context === undefined ? {} : { context }),
+            ...(followUp === undefined ? {} : { followUp }),
+        },
+        round: turnRound(data),
+    }));
     if (turn.kind !== "completed")
         return blocked(cycleId, { operation: "turn-analysis", result: turn });
     const reply = fields(turn.result)["reply"];
@@ -59,15 +140,111 @@ export async function analyzeChats(input) {
             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: "analyzed", data, reply };
+}
+function handoff(cycleId, importId) {
     return {
         kind: "handoff_requested",
         cycleId,
         promotionId: `analysis:${importId}:${cycleId}`,
     };
 }
+function turnRound(data) {
+    if (data.followUp !== undefined)
+        return data.batch === undefined ? 2 : 5;
+    return Number(data.batch?.["batchIndex"] ?? 0) + 1;
+}
+async function saveTurn(input, turn) {
+    const { batch, followUp } = turn.data;
+    return protectedEffect(request(input.input.importId, {
+        operation: "save-analysis",
+        round: turnRound(turn.data),
+        payload: {
+            importId: input.input.importId,
+            cycleId: input.cycleId,
+            reply: turn.reply,
+            ...(batch === undefined ? {} : { batch }),
+            ...(followUp === undefined ? {} : { followUp }),
+        },
+    }));
+}
+export async function analyzeChats(input, decision) {
+    "use workflow";
+    const { cycleId } = input;
+    const { importId } = input.input;
+    let analyzed = await firstTurn(input);
+    let answered = false;
+    while (analyzed.kind === "analyzed") {
+        const { data, reply } = analyzed;
+        const save = await saveTurn(input, analyzed);
+        if (save.kind !== "completed")
+            return blocked(cycleId, { operation: "save-analysis", result: save });
+        const saved = fields(save.result);
+        if (saved["kind"] === "analysis_draft") {
+            analyzed = await questionTurn(input, {
+                saved,
+                data,
+                reply,
+                decision,
+                answered,
+            });
+            answered = true;
+            continue;
+        }
+        if (saved["kind"] !== "analysis_batch")
+            return finishBatch(input, {
+                saved,
+                decision: answered ? undefined : decision,
+            });
+        const nextSnapshot = saved["snapshot"];
+        if (!record(nextSnapshot) || nextSnapshot["importId"] !== importId)
+            return blocked(cycleId, {
+                operation: "save-analysis",
+                result: { kind: "refused", reason: "analysis-input-refused" },
+            });
+        analyzed = await runTurn(input, batchData(saved, nextSnapshot));
+    }
+    return analyzed;
+}
+async function questionTurn(input, continuation) {
+    const { saved, data, reply, decision, answered } = continuation;
+    if (answered)
+        return blocked(input.cycleId, {
+            operation: "save-analysis",
+            result: { kind: "refused", reason: "analysis-question-limit" },
+        });
+    const answer = await askDraft(input.cycleId, { draft: saved, decision });
+    if (answer.kind !== "answered")
+        return answer;
+    return runTurn(input, {
+        ...data,
+        followUp: { draft: fields(reply), answer: answer.answer },
+    });
+}
+function finishBatch(input, result) {
+    const { cycleId } = input;
+    const { importId } = input.input;
+    const { saved, decision } = result;
+    if (saved["kind"] === "analysis_partial")
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: String(saved["reason"]),
+            evidenceId: "save-analysis",
+        };
+    if (decision !== undefined)
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: "analysis-answer-invalid",
+            evidenceId: "analysis-question",
+        };
+    if (saved["kind"] !== "handoff_requested")
+        return {
+            kind: "blocked",
+            cycleId,
+            reason: "analysis-input-refused",
+            evidenceId: "save-analysis",
+        };
+    return handoff(cycleId, importId);
+}

package/dist/workflows/develop-prd.js

@@ -1,4 +1,5 @@
 import { protectedEffect } from "cloving/workflows/steps/protected-effect";
+import { handoff } from "cloving/workflows/steps/handoff";
 const draft = "cloving-prd-draft.md";
 const noCommit = "Do not commit and do not push. Work only in this work tree.";
 function issueNumber(result) {
@@ -67,9 +68,76 @@ function requests(input) {
         units: 1,
     }));
 }
+function readyIssue(input, issueResult) {
+    const { number, result } = issueResult;
+    const created = JSON.parse(result ?? "null");
+    const url = typeof created === "object" && created !== null && "url" in created
+        ? created.url
+        : undefined;
+    const issue = typeof url === "string"
+        ? /^https?:\/\/[^/\s]+\/([\w.-]+)\/([\w.-]+)\/issues\/([1-9]\d*)$/.exec(url)
+        : null;
+    if (issue === null || Number(issue[3]) !== number)
+        throw new Error("invalid-issue-result");
+    return {
+        scope: { phase: "prd", operation: "github-ready", round: 1 },
+        capability: "github",
+        method: "label",
+        target: input.cycleId,
+        units: 1,
+        payload: JSON.stringify({
+            owner: issue[1],
+            repository: issue[2],
+            number,
+            add: ["cloving: ready"],
+            remove: [],
+        }),
+    };
+}
+async function handoffIssue(input, created) {
+    const { number } = created;
+    const outcome = {
+        kind: "handoff_requested",
+        cycleId: input.cycleId,
+        promotionId: `issue-${String(number)}`,
+    };
+    try {
+        await handoff({
+            workflowId: "develop-issue",
+            input: { ticket: String(number) },
+        });
+        return outcome;
+    }
+    catch (error) {
+        const reason = handoffReason(error);
+        const queued = await protectedEffect(readyIssue(input, created));
+        return {
+            ...outcome,
+            reason,
+            ...(queued.kind === "completed" ? {} : { issueUpdate: "failed" }),
+        };
+    }
+}
+function handoffReason(error) {
+    const cause = typeof error === "object" && error !== null && "cause" in error
+        ? error.cause
+        : error;
+    if (typeof cause !== "object" ||
+        cause === null ||
+        !("message" in cause) ||
+        typeof cause.message !== "string")
+        return "handoff-failed";
+    return /^[a-z][a-z0-9-]{0,127}$/.test(cause.message)
+        ? cause.message
+        : "handoff-failed";
+}
 export async function developPrd(input) {
     "use workflow";
-    let promotionId = "";
+    let outcome = {
+        kind: "handoff_requested",
+        cycleId: input.cycleId,
+        promotionId: "",
+    };
     for (const request of requests(input)) {
         const result = await protectedEffect(request);
         if (result.kind !== "completed")
@@ -91,7 +159,7 @@ export async function developPrd(input) {
                 reason: "invalid-issue-result",
                 evidenceId: request.scope.operation,
             };
-        promotionId = `issue-${String(number)}`;
+        outcome = await handoffIssue(input, { number, result: result.result });
     }
-    return { kind: "handoff_requested", cycleId: input.cycleId, promotionId };
+    return outcome;
 }

package/dist/workflows/develop-ticket.js

@@ -76,6 +76,11 @@ async function merged(input, done) {
             cycleId: input.cycleId,
             promotionId: `pull-request-${String(number)}`,
         };
+    if (merge.result["reason"] === "ci-pending")
+        return blocked(input.cycleId, {
+            reason: `The merge has the result ci-pending: ${part(merge.result, "output")}. The pull request stays open: ${done.pull.url}`,
+            evidenceId: "github-merge",
+        });
     if (done.round > lastFix)
         return blocked(input.cycleId, {
             reason: `The merge has the result ${merge.result["reason"]} in round ${String(done.round)}, and a run has at most ${String(lastFix)} fix rounds. The pull request stays open: ${done.pull.url}`,

package/dist/workflows/ticket-prompts.js

@@ -8,9 +8,10 @@ function instructions(repository) {
         `If this work tree has no node_modules folder and the main repository has one, make a copy-on-write clone: cp -c -R ${repository}/node_modules node_modules`,
         "Follow the instructions of the repository (AGENTS.md and CLAUDE.md).",
         "Use test-driven development: write a test that fails, see it fail, then write the code.",
-        "Run the checks of the repository before you finish.",
+        "Run the checks of the repository before you finish. Commit your work before the report. If the repository provides npm run check:clean, run it after committing.",
+        "Treat a check time warning as work to do in the same ticket when your change made the check slower.",
         "Commit your work on the current branch. Do not push. Do not change a different branch.",
-        "End with a short report: what you changed, the checks that you ran with their results, and what is not done. End the report with exactly one of the lines Ticket status: complete or Ticket status: partial. Before a partial status line, include Remaining: followed by a list with one item on each line, using a dash and a space before each item.",
+        "End with a short report: what you changed, the checks that you ran with their results, and what is not done. End the report with exactly one of the lines Ticket status: complete or Ticket status: partial. Before a partial status line, include Remaining: followed by a list with one item on each line, using a dash and a space before each item. Blank lines are allowed around and between list items.",
     ].join("\n");
 }
 function named(input) {
@@ -95,6 +96,15 @@ export function turnPrompt(input, fix) {
             "Reassess each remaining item before reporting Ticket status: complete. Keep every unfinished item in the next Remaining: list.",
         ].join("\n");
     const ticket = pullPrompt(input) + continuation;
+    if (review["reason"] === "ci-failed")
+        return [
+            ticket,
+            "",
+            `This is round ${String(round)}. The CI checks of the pull request ${pull.url} failed.`,
+            "Fix the failed CI checks, including failures that the pull request did not cause, and commit the fix.",
+            "",
+            part(review, "output"),
+        ].join("\n");
     if (typeof review["reason"] === "string")
         return [
             ticket,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloving",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Local durable development workflow service",
   "license": "MIT",
   "repository": {
@@ -34,12 +34,29 @@
     "./workflows/steps/decision-gate": {
       "types": "./dist/src/steps/decision-gate.d.ts",
       "import": "./dist/src/steps/decision-gate.js"
+    },
+    "./workflows/steps/handoff": {
+      "types": "./dist/src/steps/handoff.d.ts",
+      "import": "./dist/src/steps/handoff.js"
     }
   },
   "files": [
     "dist/src",
     "dist/tools",
-    "dist/workflows"
+    "dist/workflows",
+    "assets/watch-fonts/fira-code-latin-400-normal.woff2",
+    "assets/watch-fonts/fira-code-latin-500-normal.woff2",
+    "assets/watch-fonts/fira-code-OFL.md",
+    "assets/watch-fonts/heebo-latin-500-normal.woff2",
+    "assets/watch-fonts/heebo-latin-700-normal.woff2",
+    "assets/watch-fonts/heebo-latin-800-normal.woff2",
+    "assets/watch-fonts/heebo-OFL.md",
+    "assets/watch-fonts/space-grotesk-latin-400-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-500-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-600-normal.woff2",
+    "assets/watch-fonts/space-grotesk-latin-700-normal.woff2",
+    "assets/watch-fonts/space-grotesk-OFL.md",
+    "assets/watch-fonts/manifest.json"
   ],
   "engines": {
     "node": ">=26.9.0 <27",
@@ -58,6 +75,7 @@
     "build:workflows": "node tools/compile-workflows.ts",
     "check:setup": "tsc --project tsconfig.json --noEmit",
     "check:quality": "node tools/check-quality.ts",
+    "check:clean": "node tools/check-clean.ts",
     "check:lint": "eslint src tools quality test eslint.config.mjs --max-warnings 0",
     "check:format": "prettier --check src tools quality test eslint.config.mjs package.json tsconfig.json tsconfig.build.json",
     "test:quality": "node --test test/quality/*.test.ts",
@@ -76,7 +94,6 @@
     "istanbul-lib-coverage": "3.2.2",
     "jscpd": "5.4.0",
     "prettier": "3.9.9",
-    "typescript": "6.0.3",
     "typescript-eslint": "8.71.1"
   },
   "overrides": {
@@ -90,6 +107,7 @@
     "entities": "8.1.0",
     "preact": "11.0.0",
     "solid-objects": "0.17.8",
+    "typescript": "6.0.3",
     "workflow": "5.1.0"
   }
 }