@lchase/kiln 0.13.0 → 0.15.0

package/dist/jobs.js

@@ -102,6 +102,15 @@ export function writeJob(config, input) {
     });
     return { job, jsonPath };
 }
+/** Record a cancel on the job file. A second call leaves the file as it is. */
+export function markJobCancelled(config, job, now = new Date()) {
+    if (job.cancelledAt)
+        return job;
+    const next = JobSchema.parse({ ...job, cancelledAt: now.toISOString() });
+    const jsonPath = jobFilePath(config.jobsDir, job.id);
+    writeFileSync(jsonPath, `${JSON.stringify(next, null, 2)}\n`);
+    return next;
+}
 export function renderAddedJob(job, jsonPath) {
     const lines = [`added ${job.id}`, `repo ${job.repo}`, `workflow ${job.workflow}`, `spec ${job.spec}`];
     if (job.issue)

package/dist/markdown.js

@@ -0,0 +1,91 @@
+/**
+ * A small markdown subset for the board. Text is escaped before any tag is
+ * added, so a draft cannot inject HTML or a script. Links are http(s) only.
+ */
+export function renderMarkdown(src) {
+    const lines = src.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    let index = 0;
+    let html = "";
+    while (index < lines.length) {
+        const line = lines[index] ?? "";
+        if (!line.trim()) {
+            index += 1;
+            continue;
+        }
+        if (line.startsWith("```")) {
+            const fence = [];
+            index += 1;
+            while (index < lines.length && !(lines[index] ?? "").startsWith("```")) {
+                fence.push(lines[index] ?? "");
+                index += 1;
+            }
+            index += 1;
+            html += `<pre><code>${escapeHtml(fence.join("\n"))}</code></pre>`;
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading?.[1] && heading[2] !== undefined) {
+            const level = Math.min(heading[1].length, 3);
+            html += `<h${level}>${inline(heading[2])}</h${level}>`;
+            index += 1;
+            continue;
+        }
+        if (line.startsWith(">")) {
+            const quote = [];
+            while (index < lines.length && (lines[index] ?? "").startsWith(">")) {
+                quote.push((lines[index] ?? "").replace(/^>\s?/, ""));
+                index += 1;
+            }
+            html += `<blockquote>${inline(quote.join(" "))}</blockquote>`;
+            continue;
+        }
+        if (isList(line)) {
+            const ordered = /^\s*\d+\./.test(line);
+            const items = [];
+            while (index < lines.length && (isList(lines[index] ?? "") || (/^\s{2,}\S/.test(lines[index] ?? "") && items.length > 0))) {
+                const item = lines[index] ?? "";
+                index += 1;
+                if (isList(item))
+                    items.push(item.replace(/^\s*(?:[-*+]|\d+\.)\s+/, ""));
+                else
+                    items[items.length - 1] = `${items[items.length - 1]} ${item.trim()}`;
+            }
+            const tag = ordered ? "ol" : "ul";
+            html += `<${tag}>${items.map((item) => `<li>${inline(item)}</li>`).join("")}</${tag}>`;
+            continue;
+        }
+        const paragraph = [];
+        while (index < lines.length && (lines[index] ?? "").trim() && !isBlock(lines[index] ?? "")) {
+            paragraph.push(lines[index] ?? "");
+            index += 1;
+        }
+        html += `<p>${inline(paragraph.join(" "))}</p>`;
+    }
+    return html;
+}
+function isList(line) {
+    return /^\s*(?:[-*+]|\d+\.)\s+/.test(line);
+}
+function isBlock(line) {
+    return /^(?:#{1,6}\s|```|>)/.test(line) || isList(line);
+}
+function inline(raw) {
+    const codes = [];
+    const slotted = raw.replace(/`([^`]+)`/g, (_match, code) => {
+        codes.push(escapeHtml(code));
+        return `\u0000${codes.length - 1}\u0000`;
+    });
+    let html = escapeHtml(slotted);
+    html = html.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+    html = html.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>");
+    html = html.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, '<a href="$2" rel="noopener noreferrer">$1</a>');
+    return html.replace(/\u0000(\d+)\u0000/g, (_match, slot) => `<code>${codes[Number(slot)] ?? ""}</code>`);
+}
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}

package/dist/project.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { basename, join, relative, sep } from "node:path";
+import { basename, dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 import { appendEvent } from "./events.js";
 import { costFromJournal, decideFailure } from "./failure.js";
 import { jobBasename, packageRoot } from "./paths.js";
@@ -24,7 +25,31 @@ export function projectRunJournal(input) {
         console.error(`kiln: event log: ${message}`);
     }
 }
+/**
+ * Version of the `@lchase/kiln` package that contains this file.
+ * Walks up from the running module so a parent package.json (the workspace
+ * root has none) cannot supply a stale or missing version.
+ */
 export function kilnVersion() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+        const pkgPath = join(dir, "package.json");
+        if (existsSync(pkgPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(pkgPath, "utf8"));
+                if (parsed.name === "@lchase/kiln" && typeof parsed.version === "string" && parsed.version) {
+                    return parsed.version;
+                }
+            }
+            catch {
+                // An unreadable file is not the running package. Keep walking.
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
     return packageVersion(join(packageRoot(), "package.json"));
 }
 export function yakVersion() {

package/dist/reconcile.js

@@ -35,6 +35,7 @@ function inFlight(job, observation) {
  * | launching breadcrumb | running |
  * | dependencies unmet | blocked |
  * | launch error | failed |
+ * | cancelled before start | cancelled |
  * | otherwise | queued |
  *
  * `deliver=local`: `done` is a finished run whose gate says approve.
@@ -51,6 +52,8 @@ export function jobState(job, observation) {
         return "in-review";
     if (job.launching && (!job.run || job.runRetired || job.fixInProgress))
         return "running";
+    if (job.cancelled && !job.run && !job.launching)
+        return "cancelled";
     if ((job.feedbackExhausted || job.feedbackAmbiguous) && isLanded(job) && !job.fixInProgress) {
         if (job.delivery?.merged || job.delivery?.prState === "MERGED")
             return "done";
@@ -165,7 +168,7 @@ function needsDelivery(job) {
     return true;
 }
 function canLaunch(job, observation) {
-    if (job.error || job.run || job.launching || job.launchFailed || job.fixInProgress)
+    if (job.cancelled || job.error || job.run || job.launching || job.launchFailed || job.fixInProgress)
         return false;
     return dependenciesMet(job, observation);
 }
@@ -177,7 +180,7 @@ function canStartFix(job) {
 }
 /** A recorded transient failure whose backoff has elapsed. One retry per tick, ahead of a new job. */
 function canRetry(job, observation, now) {
-    if (job.error || job.launching || job.retriesExhausted || job.stopReason || job.ledgerError)
+    if (job.cancelled || job.error || job.launching || job.retriesExhausted || job.stopReason || job.ledgerError)
         return false;
     if (job.run && !job.runRetired)
         return false;

package/dist/schemas.js

@@ -48,6 +48,11 @@ export const RepoEntrySchema = z.object({
         .int("Max fix rounds must be a whole number.")
         .min(1, "Max fix rounds must be at least 1.")
         .optional(),
+    /**
+     * GitHub label `review-requests` searches for in this checkout.
+     * Overrides the trigger `label`. Omitted uses that label, which defaults to `kiln-review`.
+     */
+    reviewLabel: z.string().min(1).optional(),
 });
 /** Repo map shared by the config file and the settings API. */
 export const KilnReposSchema = z.record(z.string().regex(REPO_NAME, "must start with a letter or digit and contain only letters, digits, dots, underscores, and hyphens"), RepoEntrySchema);
@@ -135,6 +140,10 @@ const TRIGGER_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
  * `schedule` uses `cron` (5 fields, local time). `jira` uses `jql` or
  * `label` / `status` (compiled to JQL) and `every` (default `5m`).
  * `pr` is the built-in Kiln-owned pull request source.
+ * On `review-requests`, `label` is the GitHub label a pull request must
+ * carry (default `kiln-review`). `maxNew` is how many new review jobs one
+ * fire may create (default 3). `maxQueued` is how many review jobs may be
+ * queued or running at once (default 5).
  */
 export const TriggerConfigSchema = z
     .object({
@@ -147,6 +156,10 @@ export const TriggerConfigSchema = z
     jql: z.string().min(1).optional(),
     label: z.string().min(1).optional(),
     status: z.string().min(1).optional(),
+    /** Review jobs created on one fire of `review-requests`. Default 3. */
+    maxNew: z.number().int().min(1).optional(),
+    /** Queued or running review jobs at once. Default 5. */
+    maxQueued: z.number().int().min(1).optional(),
 })
     .strict();
 /** Maps a trigger id to create a job or attach to one. Hot-reloaded with the config. */
@@ -240,6 +253,11 @@ export const JobSchema = z.object({
     issue: z.string().regex(ISSUE_KEY).optional(),
     source: JobSourceSchema.optional(),
     createdAt: z.string().min(1),
+    /**
+     * Set when a person cancels the job before it starts.
+     * Tick does not launch it. Cancelling does not delete a branch.
+     */
+    cancelledAt: z.string().min(1).optional(),
 });
 /**
  * Derived from the yak journal, gate files, and (for `deliver=pr`) the
@@ -255,7 +273,8 @@ export const JobSchema = z.object({
  * after-merged dependent. A stacked job unblocks when its one upstream has
  * landed, which includes `in-review`. A job that has used its attempt cap,
  * fix-round cap, or fingerprint breaker is `needs-human`. `dead` is a run
- * whose process died and has not been recorded yet. Attempts live under
+ * whose process died and has not been recorded yet. `cancelled` is a job
+ * cancelled before it started. Attempts live under
  * the kiln directory, not in this file.
  */
 export const JOB_STATES = [
@@ -269,4 +288,5 @@ export const JOB_STATES = [
     "dead",
     "in-review",
     "done",
+    "cancelled",
 ];