@lchase/kiln 0.12.0 → 0.14.0

package/dist/driver.js

@@ -13,16 +13,17 @@ import { ensureFixTrailers } from "./fix-commit.js";
 import { holdDetail, pausedFrom, recordDailyCap, reviseNotesSinceRun, spendSnapshot, stopReasonFromEvents, withReviseNotes, } from "./rails.js";
 import { appendInvestigationFindings, existingFindingsPath, findingsFilePath, INVESTIGATION_WORKFLOW, readFindingsMarkdown, writeFindings, } from "./findings.js";
 import { defaultHost } from "./host.js";
-import { readJobSpec, resolveJobSpec } from "./jobs.js";
+import { markJobCancelled, readJobSpec, resolveJobSpec } from "./jobs.js";
 import { jobBasename, packageRoot } from "./paths.js";
 import { decide, isLanded, jobState, } from "./reconcile.js";
 import { fileMtimeMs, isPidAlive, readAttemptLedger, recoverRuns, resetAttemptLedger, } from "./reliability.js";
 import { projectRunJournal, promptsHash } from "./project.js";
+import { postApprovedReview, reviewPostForJob } from "./review-post.js";
 import { gateAnswerCommand, renderStatus, renderTick, statusView, yakCliPath, sandboxFailureDetail, } from "./report.js";
 import { AGENT_SANDBOX_IMAGE, injectAgentSandbox, jobIsSandboxed, probeSandboxEnvironment, PROXY_SANDBOX_IMAGE, requiredSandboxImages, resolveSandbox, sandboxIsEnabled, sandboxPreflight, sandboxPreflightFor, } from "./sandbox.js";
 import { JobSchema } from "./schemas.js";
 import { ensureReviewHead, evaluateTriggers, recordOwnedPullRequest, reviewHeadOf, } from "./triggers.js";
-import { leafStepIds, materializeWorkflow, REVIEW_WORKFLOW, workflowInputs, workflowNeedsTestCommand, workflowStepPlan, } from "./workflow.js";
+import { assertWorkflowName, leafStepIds, materializeWorkflow, REVIEW_WORKFLOW, workflowInputs, workflowNeedsTestCommand, workflowStepPlan, } from "./workflow.js";
 const TAG_PREFIX = "kiln:";
 export function jobTag(jobId) {
     return `${TAG_PREFIX}${jobId}`;
@@ -97,6 +98,19 @@ export function answerJob(config, jobId, choice, host = defaultHost()) {
     if (!gate) {
         throw new Error(`Job ${jobId} has no open gate that accepts ${choice}.`);
     }
+    if (choice === "approve" && job.workflow === REVIEW_WORKFLOW) {
+        postApprovedReview({
+            kilnDir: config.kilnDir,
+            jobId,
+            runId: job.run.runId,
+            repo: job.repo,
+            sourceRef: job.source?.kind === "trigger" ? job.source.ref : undefined,
+            checkout: job.run.checkout,
+            host,
+            paused: world.observation.paused === true,
+            spendBlocked: world.observation.spendBlocked === true,
+        });
+    }
     const command = gateAnswerCommand(job.run.checkout, job.run.runId, gate, choice, job.run.title ?? job.title);
     const result = spawnSync("sh", ["-c", command], { encoding: "utf8" });
     const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
@@ -123,14 +137,48 @@ export function answerJob(config, jobId, choice, host = defaultHost()) {
     return output.endsWith("\n") || output.length === 0 ? output : `${output}\n`;
 }
 /**
- * Run a failed or dead job again. The board Retry button and `kiln retry`
- * both call this.
- * A landed job whose only failure is opening the pull request is handed to
- * the same deliver path tick uses. Everything else is a new `yak run`, the
- * same launch tick uses. The attempt ledger is cleared either way, and the
- * current run id is ignored so a dead job is not stuck on the old journal.
- * A dead journal is cancelled first.
+ * Cancel queued jobs that have not started.
+ * A running, blocked, or finished job is left alone. Calling again is a no-op.
+ * The event log records `job.cancelled`. Branches are not deleted.
  */
+export function cancelQueuedJobs(config, options = {}, host = defaultHost()) {
+    return withTickLock(config.kilnDir, () => {
+        if (options.repo && !config.repos[options.repo]) {
+            throw new Error(`Unknown repo ${options.repo}.`);
+        }
+        if (options.workflow)
+            assertWorkflowName(options.workflow);
+        const now = options.now ?? new Date();
+        const world = observe(config, host, now);
+        const cancelled = [];
+        for (const observed of world.observation.jobs) {
+            if (observed.error)
+                continue;
+            if (options.repo && observed.repo !== options.repo)
+                continue;
+            if (options.workflow && observed.workflow !== options.workflow)
+                continue;
+            if (jobState(observed, world.observation) !== "queued")
+                continue;
+            const job = world.jobs.get(observed.jobId);
+            if (!job || job.cancelledAt)
+                continue;
+            markJobCancelled(config, job, now);
+            appendEvent(config.kilnDir, {
+                job_id: job.id,
+                event: "job.cancelled",
+                ts: now.toISOString(),
+                properties: {
+                    repo: job.repo,
+                    workflow: job.workflow,
+                    once: "job.cancelled",
+                },
+            });
+            cancelled.push(job.id);
+        }
+        return { cancelled };
+    });
+}
 export function retryJob(config, jobId, host = defaultHost()) {
     return withTickLock(config.kilnDir, () => {
         const world = observe(config, host);
@@ -321,6 +369,9 @@ function observe(config, host, now = new Date()) {
         const findingsPath = entry.job?.workflow === INVESTIGATION_WORKFLOW
             ? existingFindingsPath(config.kilnDir, entry.job.id)
             : undefined;
+        const reviewPost = entry.job
+            ? reviewPostForJob(events, { jobId: entry.job.id, repo: entry.job.repo, source: entry.job.source })
+            : {};
         const logTail = readLogTail(logPath);
         const stepPlan = entry.job ? workflowStepPlan(entry.job.workflow) : undefined;
         const diffSummary = run &&
@@ -340,6 +391,8 @@ function observe(config, host, now = new Date()) {
             ...(entry.job?.stack ? { stack: true } : {}),
             ...(delivery ? { delivery } : {}),
             ...(findingsPath ? { findingsPath } : {}),
+            ...(reviewPost.error ? { reviewPostError: reviewPost.error } : {}),
+            ...(reviewPost.url ? { reviewUrl: reviewPost.url } : {}),
             launching,
             launchFailed,
             ...(launchError ? { launchError } : {}),
@@ -347,6 +400,7 @@ function observe(config, host, now = new Date()) {
             ...(launchActivityMs !== undefined ? { launchActivityMs } : {}),
             ...(logPath ? { logPath } : {}),
             ...(entry.job?.createdAt ? { createdAt: entry.job.createdAt } : {}),
+            ...(entry.job?.cancelledAt ? { cancelled: true } : {}),
             ...(logTail ? { logTail } : {}),
             ...(diffSummary ? { diffSummary } : {}),
             ...(stepPlan && stepPlan.length > 0 ? { stepPlan } : {}),

package/dist/events.js

@@ -14,6 +14,7 @@ import { redactDeep } from "./redact.js";
  */
 export const EVENT_NAMES = [
     "job.added",
+    "job.cancelled",
     "job.retried",
     "run.started",
     "phase.started",
@@ -35,6 +36,8 @@ export const EVENT_NAMES = [
     "trigger.routed",
     "trigger.failed",
     "trigger.skipped",
+    "review.posted",
+    "review.failed",
 ];
 const ISO_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 const once = z.string().min(1).optional();
@@ -50,6 +53,11 @@ const JobRetried = z.object({
     repo: z.string().min(1),
     once,
 });
+const JobCancelled = z.object({
+    repo: z.string().min(1),
+    workflow: z.string().min(1),
+    once,
+});
 const RunStarted = z.object({
     kiln_version: z.string().min(1),
     yak_version: z.string().min(1),
@@ -161,7 +169,31 @@ const TriggerFailed = z.object({
 });
 const TriggerSkipped = z.object({
     trigger_id: z.string().min(1),
-    reason: z.enum(["paused", "capped"]),
+    reason: z.enum(["paused", "capped", "burst-cap", "queued-cap"]),
+    /** Pull request or issue the skip applies to, when the fire skipped one item. */
+    external_id: z.string().min(1).optional(),
+    once,
+});
+const ReviewPosted = z.object({
+    repo: z.string().min(1),
+    number: z.number().int().positive(),
+    sha: z.string().regex(/^[0-9a-f]{7,64}$/i),
+    review_id: z.string().min(1),
+    url: z.string().min(1),
+    findings: z.number().int().nonnegative(),
+    inline: z.number().int().nonnegative(),
+    skipped: z.number().int().nonnegative(),
+    /** `review:<repo>:<number>:<head sha>`. Same shape as the review-request dedupe. */
+    dedupe: z.string().min(1),
+    once,
+});
+const ReviewFailed = z.object({
+    repo: z.string().min(1),
+    number: z.number().int().positive(),
+    sha: z.string().regex(/^[0-9a-f]{7,64}$/i),
+    class: z.enum(["transient", "deterministic", "budget"]),
+    detail: z.string().min(1),
+    dedupe: z.string().min(1),
     once,
 });
 const envelope = {
@@ -172,6 +204,7 @@ const envelope = {
 };
 export const EventSchema = z.discriminatedUnion("event", [
     z.object({ ...envelope, event: z.literal("job.added"), job_id: z.string().min(1), properties: JobAdded }),
+    z.object({ ...envelope, event: z.literal("job.cancelled"), job_id: z.string().min(1), properties: JobCancelled }),
     z.object({ ...envelope, event: z.literal("job.retried"), job_id: z.string().min(1), properties: JobRetried }),
     z.object({ ...envelope, event: z.literal("run.started"), job_id: z.string().min(1), properties: RunStarted }),
     z.object({ ...envelope, event: z.literal("phase.started"), job_id: z.string().min(1), properties: PhaseStarted }),
@@ -233,6 +266,8 @@ export const EventSchema = z.discriminatedUnion("event", [
         job_id: z.string().min(1).nullable(),
         properties: TriggerSkipped,
     }),
+    z.object({ ...envelope, event: z.literal("review.posted"), job_id: z.string().min(1), properties: ReviewPosted }),
+    z.object({ ...envelope, event: z.literal("review.failed"), job_id: z.string().min(1), properties: ReviewFailed }),
 ]);
 const LOCK_WAIT_MS = 5_000;
 const pauseBuf = new Int32Array(new SharedArrayBuffer(4));

package/dist/host.js

@@ -15,6 +15,15 @@ export class HostError extends Error {
         this.name = "HostError";
     }
 }
+/** GitHub label `review-requests` requires when the trigger sets none. */
+export const DEFAULT_REVIEW_LABEL = "kiln-review";
+/** `gh pr list --search` query. Opt-in: the pull request must carry `label`. */
+export function reviewSearchQuery(label) {
+    const trimmed = label.trim();
+    if (!trimmed || /[\r\n]/.test(trimmed))
+        throw new Error("Review label must be a single line.");
+    return `review-requested:@me label:${quoteSearch(trimmed)}`;
+}
 export function defaultHost() {
     return { github: realGitHub, git: realGitRemote, feedback: realPullRequestFeedback };
 }
@@ -24,14 +33,27 @@ export function productionHost() {
 }
 /**
  * Open pull requests awaiting the authenticated user's review, per registered repo.
- * A remote that is not GitHub is skipped, so a local test origin does not call gh.
+ * The search is opt-in: a pull request must carry `label`, or `kiln-review` when
+ * that is omitted. A remote that is not GitHub is skipped, so a local test origin does not call gh.
  */
 export function listReviewRequests(repos) {
     const found = [];
     for (const repo of repos) {
         if (!githubRemote(repo.path))
             continue;
-        const result = spawnSync(ghBin(), ["pr", "list", "--search", "review-requested:@me", "--state", "open", "--limit", "50", "--json", "number,title,url,headRefOid"], {
+        const label = repo.label?.trim() || DEFAULT_REVIEW_LABEL;
+        const result = spawnSync(ghBin(), [
+            "pr",
+            "list",
+            "--search",
+            reviewSearchQuery(label),
+            "--state",
+            "open",
+            "--limit",
+            "50",
+            "--json",
+            "number,title,url,headRefOid,labels",
+        ], {
             cwd: repo.path,
             encoding: "utf8",
             timeout: 20_000,
@@ -57,6 +79,8 @@ export function listReviewRequests(repos) {
             const sha = typeof record.headRefOid === "string" ? record.headRefOid.trim().toLowerCase() : "";
             if (!Number.isInteger(number) || number <= 0 || !/^[0-9a-f]{7,64}$/.test(sha))
                 continue;
+            if (!carriesLabel(record.labels, label))
+                continue;
             const title = typeof record.title === "string" && record.title.trim() ? record.title.trim() : `PR ${number}`;
             const url = typeof record.url === "string" ? record.url : "";
             found.push({ repo: repo.name, number, title, url, headSha: sha });
@@ -64,6 +88,25 @@ export function listReviewRequests(repos) {
     }
     return found;
 }
+/** Missing `labels` trusts the search. A present list must include `label`. */
+function carriesLabel(labels, label) {
+    if (labels === undefined)
+        return true;
+    if (!Array.isArray(labels))
+        return false;
+    const want = label.trim().toLowerCase();
+    return labels.some((item) => {
+        if (typeof item === "string")
+            return item.trim().toLowerCase() === want;
+        if (typeof item !== "object" || item === null || !("name" in item))
+            return false;
+        const name = item.name;
+        return typeof name === "string" && name.trim().toLowerCase() === want;
+    });
+}
+function quoteSearch(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
 function githubRemote(checkout) {
     const result = gitResult(checkout, ["remote", "get-url", "origin"]);
     if (result.status !== 0)
@@ -174,11 +217,12 @@ export const realGitRemote = {
 function ghBin() {
     return process.env.KILN_GH && process.env.KILN_GH.length > 0 ? process.env.KILN_GH : "gh";
 }
-function runGh(checkout, args) {
+function runGh(checkout, args, input) {
     const bin = ghBin();
     const result = spawnSync(bin, args, {
         cwd: checkout,
         encoding: "utf8",
+        input,
         env: { ...process.env, GH_PROMPT_DISABLED: "1", GIT_TERMINAL_PROMPT: "0" },
     });
     if (result.error) {
@@ -304,4 +348,55 @@ export const realGitHub = {
         }
         return { state: asState(parsed.state), mergedAt: asMergedAt(parsed.mergedAt) };
     },
+    postCommentReview(input) {
+        return submitCommentReview(input);
+    },
 };
+/**
+ * `POST /repos/{owner}/{repo}/pulls/{number}/reviews` with `event: COMMENT`.
+ * One call submits the review. There is no pending-review step, no approve,
+ * and no merge.
+ */
+export function submitCommentReview(input) {
+    const repo = githubOwnerRepo(input.checkout);
+    const event = "COMMENT";
+    const payload = {
+        commit_id: input.commitId,
+        body: input.body,
+        event,
+    };
+    if (input.comments.length > 0) {
+        payload.comments = input.comments.map((comment) => ({
+            path: comment.path,
+            body: comment.body,
+            line: comment.line,
+            side: "RIGHT",
+        }));
+    }
+    const result = runGh(input.checkout, ["api", "--method", "POST", `repos/${repo.owner}/${repo.name}/pulls/${input.number}/reviews`, "--input", "-"], JSON.stringify(payload));
+    if (result.status !== 0) {
+        const detail = (result.stderr || result.stdout).trim() || "gh api failed";
+        throw new HostError(`Could not post the pull request review: ${detail}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new HostError("gh api returned data that is not a pull request review.");
+    }
+    const id = typeof parsed.id === "number" || typeof parsed.id === "string" ? String(parsed.id) : "";
+    const url = typeof parsed.html_url === "string" ? parsed.html_url.trim() : "";
+    if (!id || !url)
+        throw new HostError("gh api did not return a review id and URL.");
+    return { id, url };
+}
+function githubOwnerRepo(checkout) {
+    const result = runGh(checkout, ["repo", "view", "--json", "nameWithOwner", "--jq", ".nameWithOwner"]);
+    const name = result.stdout.trim();
+    const [owner, repo] = name.split("/");
+    if (result.status !== 0 || !owner || !repo || name.split("/").length !== 2) {
+        throw new HostError(`Could not read owner/name for the review: ${(result.stderr || result.stdout).trim() || name || "gh repo view failed"}`);
+    }
+    return { owner, name: repo };
+}