@lchase/kiln 0.0.0-stage → 0.3.0

package/dist/delivery.js

@@ -0,0 +1,245 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { HostError } from "./host.js";
+import { readJobSpec } from "./jobs.js";
+import { jobBasename } from "./paths.js";
+/**
+ * Derived per run, under `<kilnDir>/deliveries/<jobId>.json`. Not the job file.
+ * `pushed` is true once origin has this branch at `sha`. Re-tick uses it, and
+ * `gh pr list --head`, so a crash between push and create does not open a
+ * second pull request or push the same commit again.
+ */
+export const DeliveryRecordSchema = z.object({
+    jobId: z.string().min(1),
+    runId: z.string().min(1),
+    branch: z.string().min(1),
+    base: z.string().min(1),
+    sha: z.string().min(1).optional(),
+    pushed: z.boolean(),
+    prNumber: z.number().int().positive().optional(),
+    prUrl: z.string().min(1).optional(),
+    error: z.string().min(1).optional(),
+});
+export function deliveryPath(kilnDir, jobId) {
+    return join(kilnDir, "deliveries", `${jobBasename(jobId)}.json`);
+}
+export function readDelivery(kilnDir, jobId) {
+    const path = deliveryPath(kilnDir, jobId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return DeliveryRecordSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeDelivery(kilnDir, record) {
+    const path = deliveryPath(kilnDir, record.jobId);
+    mkdirSync(join(kilnDir, "deliveries"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(DeliveryRecordSchema.parse(record), null, 2)}\n`);
+}
+const LAUNCH_ERROR = z.object({ error: z.string().min(1) });
+export function launchErrorPath(kilnDir, jobId) {
+    return join(kilnDir, "launch-errors", `${jobBasename(jobId)}.json`);
+}
+export function readLaunchError(kilnDir, jobId) {
+    const path = launchErrorPath(kilnDir, jobId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return LAUNCH_ERROR.parse(JSON.parse(readFileSync(path, "utf8"))).error;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeLaunchError(kilnDir, jobId, error) {
+    const path = launchErrorPath(kilnDir, jobId);
+    mkdirSync(join(kilnDir, "launch-errors"), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ error }, null, 2)}\n`);
+}
+export function clearLaunchError(kilnDir, jobId) {
+    rmSync(launchErrorPath(kilnDir, jobId), { force: true });
+}
+/**
+ * Full SHA the worktree is cut from. Passed to yak as `--from` and to the
+ * workflow as `baseRef`.
+ *
+ * `deliver=local` without `--stack` is checkout HEAD.
+ * `deliver=pr` fetches and uses `origin/<base>` (configured, or origin's default).
+ * A stacked job uses the upstream `yak/<run-id>` tip in this checkout.
+ */
+export function resolveLaunchBase(input) {
+    if (input.stack) {
+        if (!input.upstreamBranch) {
+            throw new HostError("This stacked job has no upstream branch to start from yet.");
+        }
+        return input.git.revParse(input.checkout, input.upstreamBranch);
+    }
+    if (input.deliver === "pr") {
+        input.git.fetch(input.checkout);
+        const base = input.configuredBase ?? input.git.defaultBranch(input.checkout);
+        return input.git.revParse(input.checkout, `origin/${base}`);
+    }
+    return input.git.revParse(input.checkout, "HEAD");
+}
+/**
+ * Push `yak/<run-id>` and open one draft pull request. A later tick looks up
+ * the branch's pull request and skips both when the remote SHA already matches.
+ * Failures stay on this job (`HostError` text) and do not escape.
+ */
+export function deliverJob(request) {
+    const branch = `yak/${request.runId}`;
+    const prior = readDelivery(request.config.kilnDir, request.job.id);
+    const sameRun = prior?.runId === request.runId ? prior : undefined;
+    try {
+        const localSha = request.host.git.revParse(request.checkout, branch);
+        if (sameRun?.prNumber && sameRun.prUrl && sameRun.sha === localSha) {
+            return { ok: true, detail: sameRun.prUrl, prUrl: sameRun.prUrl, prNumber: sameRun.prNumber };
+        }
+        // Ask gh before pushing so a missing or logged-out CLI does not publish the branch.
+        let existing = request.host.github.findByHead(request.checkout, branch);
+        const remoteSha = request.host.git.remoteBranchSha(request.checkout, branch);
+        if (remoteSha !== localSha) {
+            request.host.git.pushBranch(request.checkout, branch, request.baseBranch);
+        }
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            sha: localSha,
+            pushed: true,
+            ...(sameRun?.prNumber ? { prNumber: sameRun.prNumber, prUrl: sameRun.prUrl } : {}),
+        });
+        if (!existing)
+            existing = request.host.github.findByHead(request.checkout, branch);
+        const pr = existing ??
+            (sameRun?.prNumber && sameRun.prUrl
+                ? {
+                    number: sameRun.prNumber,
+                    url: sameRun.prUrl,
+                    state: "OPEN",
+                    mergedAt: null,
+                    head: branch,
+                    base: request.baseBranch,
+                }
+                : request.host.github.createDraft({
+                    checkout: request.checkout,
+                    head: branch,
+                    base: request.baseBranch,
+                    title: request.job.title,
+                    body: pullRequestBody(request),
+                }));
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            sha: localSha,
+            pushed: true,
+            prNumber: pr.number,
+            prUrl: pr.url,
+        });
+        return { ok: true, detail: pr.url, prUrl: pr.url, prNumber: pr.number };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const kept = readDelivery(request.config.kilnDir, request.job.id);
+        const base = kept?.runId === request.runId ? kept : sameRun;
+        writeDelivery(request.config.kilnDir, {
+            jobId: request.job.id,
+            runId: request.runId,
+            branch,
+            base: request.baseBranch,
+            ...(base?.sha ? { sha: base.sha } : {}),
+            pushed: base?.pushed ?? false,
+            ...(base?.prNumber ? { prNumber: base.prNumber, prUrl: base.prUrl } : {}),
+            error: message,
+        });
+        return { ok: false, detail: message };
+    }
+}
+/** First paragraph of the job spec, capped, plus the job id and reviewer verdicts. */
+export function pullRequestBody(request) {
+    const spec = readJobSpec(request.config.kilnDir, request.job);
+    const summary = specSummary(spec);
+    const reviews = reviewerLines(join(request.checkout, ".runs", request.runId, "artifacts"));
+    return [
+        summary,
+        "",
+        `Kiln job: ${request.job.id}`,
+        "",
+        "## Reviewers",
+        ...(reviews.length > 0 ? reviews : ["- (no reviewer artifacts)"]),
+        "",
+    ].join("\n");
+}
+export function specSummary(specText) {
+    const lines = specText.split(/\r?\n/);
+    const body = [];
+    let skippedTitle = false;
+    for (const line of lines) {
+        if (!skippedTitle && /^#\s+/.test(line)) {
+            skippedTitle = true;
+            continue;
+        }
+        body.push(line);
+    }
+    const paragraph = (body.join("\n").trim().split(/\n\s*\n/)[0] ?? "").trim().replace(/\s+/g, " ");
+    if (!paragraph)
+        return "(empty spec)";
+    if (paragraph.length <= 500)
+        return paragraph;
+    return `${paragraph.slice(0, 497)}...`;
+}
+function reviewerLines(artifactsDir) {
+    const lines = [];
+    for (const name of ["security", "ux", "ui", "code"]) {
+        const verdict = verdictOf(latestArtifact(artifactsDir, name));
+        if (verdict)
+            lines.push(`- ${name}: ${verdict}`);
+    }
+    const decision = verdictOf(latestArtifact(artifactsDir, "decision"), "decision");
+    if (decision)
+        lines.push(`- approver: ${decision}`);
+    return lines;
+}
+function verdictOf(value, field = "verdict") {
+    if (typeof value !== "object" || value === null || !(field in value))
+        return undefined;
+    const verdict = value[field];
+    return typeof verdict === "string" && verdict.length > 0 ? verdict : undefined;
+}
+function latestArtifact(dir, name) {
+    if (!existsSync(dir))
+        return undefined;
+    let best;
+    for (const file of readdirSync(dir)) {
+        if (file === `${name}.json`) {
+            if (!best || best.n <= 0)
+                best = { n: 0, file };
+            continue;
+        }
+        const match = new RegExp(`^${name}\\.(\\d+)\\.json$`).exec(file);
+        if (!match?.[1])
+            continue;
+        const n = Number(match[1]);
+        if (!best || n >= best.n)
+            best = { n, file };
+    }
+    if (!best)
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(join(dir, best.file), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** True when `gh pr view` says the pull request is merged, including a squash. */
+export function isMerged(pr) {
+    return pr.state === "MERGED" || (typeof pr.mergedAt === "string" && pr.mergedAt.length > 0);
+}