cloving 0.3.19 → 1.0.1

package/dist/workflows/develop-ticket.js

@@ -0,0 +1,301 @@
+import { decisionGate } from "cloving/workflows/steps/decision-gate";
+import { protectedEffect } from "cloving/workflows/steps/protected-effect";
+import { finishIssue, labelIssue } from "./issue-labels.js";
+const lastRound = 3;
+const lastFix = 3;
+const publicRule = "The branch becomes a public pull request. Do not write local file paths, such as the path of your home folder, in files or in commit messages.";
+function instructions(repository) {
+    return [
+        "You work on one ticket of this repository. Your current directory is a git work tree on its own branch.",
+        `The main repository is at ${repository}. Do not change files there.`,
+        `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.",
+        "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.",
+    ].join("\n");
+}
+function named(input) {
+    return input.ticketId === undefined
+        ? "this ticket"
+        : `the ticket ${input.ticketId}`;
+}
+function fields(text) {
+    const value = JSON.parse(text ?? "{}");
+    return typeof value === "object" && value !== null ? { ...value } : {};
+}
+function part(turn, name) {
+    const value = turn[name];
+    if (Array.isArray(value))
+        return value.join("\n");
+    if (typeof value === "number")
+        return value.toFixed(2);
+    return typeof value === "string" ? value : "";
+}
+function denial(round) {
+    return round < lastRound
+        ? "Deny with a feedback text to send the work back to the worker for one more round. Deny with no text to reject the work."
+        : "Deny to reject the work. This is the last round.";
+}
+function review(input, turnResult) {
+    const turn = fields(turnResult.result);
+    return [
+        `Review the work of the Claude worker for ${named(input)}.`,
+        `Round: ${String(turnResult.round)} of ${String(lastRound)}`,
+        `Branch: ${part(turn, "branch")}`,
+        `Work tree: ${part(turn, "worktree")}`,
+        `Cost (USD): ${part(turn, "costUsd")}`,
+        "",
+        "Commits:",
+        part(turn, "commits"),
+        "",
+        "Changed files:",
+        part(turn, "files"),
+        "",
+        "Not committed:",
+        part(turn, "uncommitted"),
+        "",
+        "Report of the worker:",
+        part(turn, "summary"),
+        "",
+        "Approve to accept the branch, then merge the branch yourself.",
+        denial(turnResult.round),
+    ].join("\n");
+}
+function blocked(cycleId, cause) {
+    return { kind: "blocked", cycleId, ...cause };
+}
+function prompt(input, round) {
+    const ticket = `${instructions(input.repository)}\n\nThe text of ${named(input)}:\n\n${input.ticket}`;
+    if (round.feedback === null)
+        return ticket;
+    return `${ticket}\n\nThis is round ${String(round.number)}. The branch has the commits of the earlier rounds. The operator denied the work of round ${String(round.number - 1)} with this feedback:\n\n${round.feedback}`;
+}
+function decided(cycleId, decision) {
+    const number = Number(decision.gateId.slice("review-".length));
+    if (decision.decision === "approved")
+        return {
+            kind: "handoff_requested",
+            cycleId,
+            promotionId: `cloving-${cycleId}`,
+        };
+    if (decision.answer === null)
+        return blocked(cycleId, {
+            reason: "The operator denied the work.",
+            evidenceId: decision.gateId,
+        });
+    if (number >= lastRound)
+        return blocked(cycleId, {
+            reason: `The operator denied the work of round ${String(number)}, and a run has at most ${String(lastRound)} rounds.`,
+            evidenceId: decision.gateId,
+        });
+    return { number: number + 1, feedback: decision.answer };
+}
+function pullPrompt(input) {
+    return `${instructions(input.repository)}\n${publicRule}\n\nThe text of ${named(input)}:\n\n${input.ticket}`;
+}
+function findingLines(findings) {
+    if (!Array.isArray(findings))
+        return "";
+    return findings
+        .map((item) => {
+        const finding = fields(JSON.stringify(item));
+        const line = finding["line"];
+        const place = typeof line === "number" ? `:${String(line)}` : "";
+        return `- ${part(finding, "path")}${place}: ${part(finding, "body")}`;
+    })
+        .join("\n");
+}
+function turnPrompt(input, fix) {
+    if (fix === null)
+        return pullPrompt(input);
+    const { round, pull, review } = fix;
+    if (typeof review["reason"] === "string")
+        return [
+            pullPrompt(input),
+            "",
+            `This is round ${String(round)}. The merge of the pull request ${pull.url} needs a fix: ${review["reason"]}.`,
+            review["reason"] === "merge-conflict"
+                ? "Merge the default branch of origin into the branch, resolve each conflict, run the tests, and commit."
+                : "The check failed on the tree of the merge of the branch with the newest commit of the default branch. Fix the cause and commit the fix.",
+            "",
+            part(review, "output"),
+        ].join("\n");
+    return [
+        pullPrompt(input),
+        "",
+        `This is round ${String(round)}. The branch has the commits of the earlier rounds. Greptile reviewed the pull request ${pull.url} at the commit ${pull.commit.slice(0, 7)} and gave the confidence score ${String(review["score"])}/5. Fix each problem of the review, then commit the fixes. Cloving merges the pull request when the score is 5/5.`,
+        "",
+        "Summary of the review:",
+        "",
+        part(review, "summary"),
+        "",
+        "Findings on lines:",
+        "",
+        findingLines(review["findings"]),
+    ].join("\n");
+}
+function pullTitle(input) {
+    const [first = ""] = input.ticket.split("\n", 1);
+    return first.startsWith("# ")
+        ? first.slice(2).trim().slice(0, 200)
+        : `Cloving task ${input.cycleId}`;
+}
+function pullBody(input) {
+    const issue = /^GitHub issue: ([\w.-]+[/][\w.-]+#\d+)/m.exec(input.ticket);
+    const about = `Cloving made this change for ${named(input)}. Greptile reviews the pull request, and Cloving merges it when the confidence score is 5/5.`;
+    return issue === null ? about : `Closes ${String(issue[1])}\n\n${about}`;
+}
+async function stepped(input, call) {
+    const { phase, operation, round, capability, method, payload } = call;
+    const done = await protectedEffect({
+        scope: { phase, operation, round },
+        capability,
+        method,
+        target: input.cycleId,
+        payload,
+        units: 1,
+    });
+    if (done.kind === "completed")
+        return { kind: "done", result: fields(done.result) };
+    const cause = "reason" in done && done.reason !== null ? ` (${done.reason})` : "";
+    return blocked(input.cycleId, {
+        reason: `The step ${operation} has the result ${done.kind}${cause}.`,
+        evidenceId: operation,
+    });
+}
+function github(input, call) {
+    return stepped(input, {
+        phase: "pull-request",
+        operation: `github-${call.method}`,
+        capability: "github",
+        method: call.method,
+        round: call.round,
+        payload: JSON.stringify(call.payload),
+    });
+}
+function pullOf(result) {
+    return {
+        number: Number(result["number"]),
+        url: part(result, "url"),
+        commit: part(result, "commit"),
+    };
+}
+async function merged(input, done) {
+    const { number, commit } = done.pull;
+    const merge = await github(input, {
+        method: "merge",
+        round: done.round,
+        payload: { number, commit },
+    });
+    if (merge.kind !== "done")
+        return merge;
+    if (typeof merge.result["reason"] !== "string")
+        return {
+            kind: "handoff_requested",
+            cycleId: input.cycleId,
+            promotionId: `pull-request-${String(number)}`,
+        };
+    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}`,
+            evidenceId: "github-merge",
+        });
+    return { round: done.round + 1, pull: done.pull, review: merge.result };
+}
+async function pullRequest(input) {
+    const prepared = await github(input, {
+        method: "prepare",
+        round: 1,
+        payload: {},
+    });
+    if (prepared.kind !== "done")
+        return prepared;
+    await labelIssue(input, { key: "start", round: 1 });
+    let fix = null;
+    for (let round = 1;; round += 1) {
+        const turn = await stepped(input, {
+            phase: "implement",
+            operation: "claude-turn",
+            capability: "claude",
+            method: "run-turn",
+            round,
+            payload: turnPrompt(input, fix),
+        });
+        if (turn.kind !== "done")
+            return finishIssue(input, { round, outcome: turn });
+        const opened = await github(input, {
+            method: "open-pr",
+            round,
+            payload: { title: pullTitle(input), body: pullBody(input) },
+        });
+        if (opened.kind !== "done")
+            return finishIssue(input, { round, outcome: opened });
+        const pull = pullOf(opened.result);
+        const reviewed = await github(input, {
+            method: "wait-review",
+            round,
+            payload: { number: pull.number, commit: pull.commit },
+        });
+        if (reviewed.kind !== "done")
+            return finishIssue(input, { round, outcome: reviewed });
+        const score = reviewed.result["score"];
+        if (score === 5) {
+            const result = await merged(input, { round, pull });
+            if ("kind" in result)
+                return finishIssue(input, { round, outcome: result });
+            fix = result;
+            continue;
+        }
+        if (round > lastFix)
+            return finishIssue(input, {
+                round,
+                outcome: blocked(input.cycleId, {
+                    reason: `Greptile gave the confidence score ${String(score)}/5 in round ${String(round)}, and a run has at most ${String(lastFix)} fix rounds. The pull request stays open: ${pull.url}`,
+                    evidenceId: "github-wait-review",
+                }),
+            });
+        fix = { round: round + 1, pull, review: reviewed.result };
+    }
+}
+export async function developTicket(input, decision) {
+    "use workflow";
+    if (input.delivery === "pull-request")
+        return pullRequest(input);
+    const { cycleId } = input;
+    const round = decision === undefined
+        ? { number: 1, feedback: null }
+        : decided(cycleId, decision);
+    if ("kind" in round)
+        return round;
+    const gateId = `review-${String(round.number)}`;
+    const turn = await protectedEffect({
+        scope: {
+            phase: "implement",
+            operation: "claude-turn",
+            round: round.number,
+        },
+        capability: "claude",
+        method: "run-turn",
+        target: cycleId,
+        payload: prompt(input, round),
+        units: 1,
+    });
+    if (turn.kind !== "completed")
+        return blocked(cycleId, {
+            reason: `The Claude turn has the result ${turn.kind}.`,
+            evidenceId: "claude-turn",
+        });
+    const gate = await decisionGate({
+        gateId,
+        kind: "approval",
+        prompt: review(input, { round: round.number, result: turn.result }),
+    });
+    if (gate.kind !== "opened")
+        return blocked(cycleId, {
+            reason: `The review gate has the result ${gate.kind}.`,
+            evidenceId: gateId,
+        });
+    return { kind: "waiting_for_decision", cycleId, decisionId: gate.decisionId };
+}

package/dist/workflows/issue-labels.d.ts

@@ -0,0 +1,14 @@
+import type { CycleOutcome } from "cloving/workflows";
+interface IssueTicket {
+    readonly cycleId: string;
+    readonly ticket: string;
+}
+export declare function labelIssue(input: IssueTicket, state: {
+    readonly key: "start" | "blocked" | "done";
+    readonly round: number;
+}): Promise<void>;
+export declare function finishIssue(input: IssueTicket, ending: {
+    readonly round: number;
+    readonly outcome: CycleOutcome;
+}): Promise<CycleOutcome>;
+export {};

package/dist/workflows/issue-labels.js

@@ -0,0 +1,36 @@
+import { protectedEffect } from "cloving/workflows/steps/protected-effect";
+export async function labelIssue(input, state) {
+    const issue = /^GitHub issue: ([\w.-]+)\/([\w.-]+)#(\d+)/m.exec(input.ticket);
+    if (issue === null)
+        return;
+    const additions = {
+        start: ["cloving: in progress"],
+        blocked: ["cloving: blocked"],
+        done: [],
+    };
+    const add = additions[state.key];
+    const remove = state.key === "start"
+        ? ["cloving: ready", "cloving: blocked"]
+        : ["cloving: in progress"];
+    await protectedEffect({
+        scope: { phase: "pull-request", operation: "github-label", ...state },
+        capability: "github",
+        method: "label",
+        target: input.cycleId,
+        units: 1,
+        payload: JSON.stringify({
+            owner: issue[1],
+            repository: issue[2],
+            number: Number(issue[3]),
+            add,
+            remove,
+        }),
+    });
+}
+export async function finishIssue(input, ending) {
+    await labelIssue(input, {
+        round: ending.round,
+        key: ending.outcome.kind === "blocked" ? "blocked" : "done",
+    });
+    return ending.outcome;
+}

package/package.json

@@ -1,86 +1,93 @@
 {
   "name": "cloving",
-  "version": "0.3.19",
-  "packageManager": "yarn@1.22.22",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc && cp package.json dist/package.json && cp src/utils/prompts/*.md dist/utils/prompts/",
-    "start": "node dist/index.js",
-    "watch": "tsc -w",
-    "check": "bash -c 'npx tsc --noEmit --skipLibCheck'",
-    "test": "bash -c jest",
-    "prepare": "husky",
-    "format": "prettier --write \"src/**/*.ts\""
-  },
-  "bin": "./dist/index.js",
-  "files": [
-    "dist",
-    "!**/test/**"
-  ],
-  "keywords": [],
-  "author": "Lucas Carlson",
+  "version": "1.0.1",
+  "description": "Local durable development workflow service",
   "license": "MIT",
-  "description": "",
-  "lint-staged": {
-    "*.ts": [
-      "yarn run check",
-      "prettier --write"
-    ]
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloving-ai/cloving-ai.git"
+  },
+  "homepage": "https://github.com/cloving-ai/cloving-ai#readme",
+  "bugs": {
+    "url": "https://github.com/cloving-ai/cloving-ai/issues"
   },
-  "lint-prepush": {
-    "base": "main",
-    "tasks": {
-      "*.ts": [
-        "yarn run check",
-        "yarn run test",
-        "yarn run format"
-      ]
+  "type": "module",
+  "imports": {
+    "#package": "./package.json"
+  },
+  "bin": {
+    "cloving": "dist/src/cli.js"
+  },
+  "exports": {
+    "./workflows": {
+      "types": "./dist/src/workflows.d.ts",
+      "import": "./dist/src/workflows.js"
+    },
+    "./workflows/steps/load-cycle": {
+      "types": "./dist/src/steps/load-cycle.d.ts",
+      "import": "./dist/src/steps/load-cycle.js"
+    },
+    "./workflows/steps/protected-effect": {
+      "types": "./dist/src/steps/protected-effect.d.ts",
+      "import": "./dist/src/steps/protected-effect.js"
+    },
+    "./workflows/steps/decision-gate": {
+      "types": "./dist/src/steps/decision-gate.d.ts",
+      "import": "./dist/src/steps/decision-gate.js"
     }
   },
-  "dependencies": {
-    "@inquirer/prompts": "^7.3.2",
-    "axios": "^1.7.9",
-    "cli-highlight": "^2.1.11",
-    "colors": "^1.4.0",
-    "commander": "^13.1.0",
-    "copy-paste": "^1.5.3",
-    "eslint": "^9.20.1",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-config-raine": "^0.5.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-jsdoc": "^50.6.3",
-    "eslint-plugin-n": "^17.15.1",
-    "eslint-plugin-promise": "^7.2.1",
-    "express": "^4.21.2",
-    "ignore": "^7.0.3",
-    "ini": "^5.0.0",
-    "isbinaryfile": "^5.0.4",
-    "nock": "^14.0.1",
-    "vite": "^6.1.1",
-    "vite-node": "^3.0.6"
+  "files": [
+    "dist/src",
+    "dist/tools",
+    "dist/workflows"
+  ],
+  "engines": {
+    "node": ">=26.9.0 <27",
+    "npm": ">=11.19.1 <12"
+  },
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && node tools/copy-workflow-declarations.ts workflows dist/workflows",
+    "build:workflows": "node tools/compile-workflows.ts",
+    "check:setup": "tsc --project tsconfig.json --noEmit",
+    "check:quality": "node tools/check-quality.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",
+    "test:scale": "node --test --test-concurrency=1 test/authority-opening-scale.benchmark.ts",
+    "check": "node tools/quality-pending.ts",
+    "test:concurrency": "node tools/quality-pending.ts"
   },
   "devDependencies": {
-    "@types/body-parser": "^1.19.5",
-    "@types/copy-paste": "^1.1.33",
-    "@types/express": "^5.0.0",
-    "@types/ini": "^4.1.1",
-    "@types/inquirer": "^9.0.7",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.4",
-    "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "lint-prepush": "^3.0.2",
-    "lint-staged": "^15.4.3",
-    "prettier": "^3.5.1",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.3"
+    "@eslint/js": "10.0.1",
+    "@types/istanbul-lib-coverage": "2.0.6",
+    "@types/node": "26.6.4",
+    "acorn": "8.16.0",
+    "ast-v8-to-istanbul": "1.0.5",
+    "eslint": "10.12.0",
+    "eslint-plugin-sonarjs": "4.2.2",
+    "istanbul-lib-coverage": "3.2.2",
+    "jscpd": "5.4.0",
+    "prettier": "3.9.9",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.71.1"
+  },
+  "overrides": {
+    "@workflow/core": {
+      "devalue": "5.9.4",
+      "nanoid": "5.1.16"
+    }
   },
-  "resolutions": {
-    "eslint": "8.57.0",
-    "eslint-plugin-n": "16.6.2",
-    "eslint-plugin-import": "2.29.1",
-    "eslint-plugin-promise": "6.6.0"
+  "dependencies": {
+    "@workflow/builders": "5.0.2",
+    "entities": "8.1.0",
+    "preact": "11.0.0",
+    "solid-objects": "0.17.8",
+    "workflow": "5.1.0"
   }
 }