@lchase/kiln 0.3.0 → 0.5.0

package/assets/serve.js

@@ -0,0 +1,361 @@
+(function () {
+  var KEY = "kiln-needs-you";
+  var body = document.body;
+  var board = document.getElementById("board");
+  var count = Number(body.getAttribute("data-needs-you") || "0");
+  document.title = "(" + count + ") Kiln";
+
+  function note(n) {
+    var raw = null;
+    try { raw = localStorage.getItem(KEY); } catch (err) { raw = null; }
+    try { localStorage.setItem(KEY, String(n)); } catch (err) { /* private mode */ }
+    if (raw === null) return;
+    var prev = Number(raw);
+    if (!isFinite(prev) || n <= prev) return;
+    if (typeof Notification === "undefined" || Notification.permission !== "granted") return;
+    var added = n - prev;
+    try {
+      new Notification("Kiln", { body: added === 1 ? "1 job needs you" : added + " jobs need you" });
+    } catch (err) { /* the browser refused the notification */ }
+  }
+  note(count);
+
+  var compact = true;
+  try { compact = localStorage.getItem("kiln-compact") !== "off"; } catch (err) { compact = true; }
+  var repo = "";
+  try { repo = localStorage.getItem("kiln-repo") || ""; } catch (err) { repo = ""; }
+
+  var COMPACT = {
+    on: ["expand empty columns", '<path d="M3 12h7m0 0-3-3m3 3-3 3M21 12h-7m0 0 3-3m-3 3 3 3M12 4v16"/>'],
+    off: ["collapse empty columns", '<path d="M10 12H3m0 0 3-3m-3 3 3 3M14 12h7m0 0-3-3m3 3-3 3M12 4v16"/>'],
+  };
+
+  function renderCompact() {
+    var pair = COMPACT[compact ? "on" : "off"];
+    var button = document.getElementById("compact");
+    if (!button) return;
+    button.setAttribute("data-tip", pair[0]);
+    button.setAttribute("aria-label", pair[0]);
+    button.setAttribute("aria-pressed", compact ? "true" : "false");
+    button.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true">' + pair[1] + "</svg>";
+  }
+
+  function layout() {
+    if (!board) return;
+    var tracks = [];
+    var columns = board.querySelectorAll(".col");
+    for (var i = 0; i < columns.length; i++) {
+      var col = columns[i];
+      var cards = col.querySelectorAll(".card");
+      var visible = 0;
+      for (var c = 0; c < cards.length; c++) if (!cards[c].hidden) visible += 1;
+      var slim = compact && visible === 0;
+      col.classList.toggle("slim", slim);
+      var fullCount = col.querySelector(".full .count");
+      if (fullCount) fullCount.textContent = visible ? String(visible) : "";
+      var slimCount = col.querySelector(".slim-face .count");
+      if (slimCount) slimCount.textContent = String(visible);
+      var empty = col.querySelector(".empty");
+      if (empty) empty.hidden = visible !== 0;
+      tracks.push(slim ? "40px" : "minmax(0, 1fr)");
+    }
+    board.style.setProperty("--cols", tracks.join(" "));
+  }
+
+  function applyRepo() {
+    var cards = document.querySelectorAll(".board .card");
+    for (var i = 0; i < cards.length; i++) {
+      var cardRepo = cards[i].getAttribute("data-repo") || "";
+      cards[i].hidden = Boolean(repo) && cardRepo !== repo;
+    }
+    var chips = document.querySelectorAll(".repo-f");
+    for (var j = 0; j < chips.length; j++) {
+      chips[j].setAttribute("aria-pressed", (chips[j].getAttribute("data-repo") || "") === repo ? "true" : "false");
+    }
+    layout();
+  }
+
+  function visibleSheet() {
+    var sheets = document.querySelectorAll(".sheet");
+    for (var i = 0; i < sheets.length; i++) if (!sheets[i].hidden) return sheets[i];
+    return null;
+  }
+
+  function esc(value) {
+    return String(value == null ? "" : value).replace(/[&<>"']/g, function (ch) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch];
+    });
+  }
+
+  function verdictTone(first) {
+    if (/^(VERDICT:\s*PASS|APPROVE|STATUS:\s*READY)/.test(first)) return "good";
+    if (/^VERDICT:\s*CHANGES/.test(first)) return "warn";
+    if (/^(ESCALATE|STATUS:\s*BLOCKED|VERDICT:\s*ESCALATE|VERDICT:\s*BLOCKED)/.test(first)) return "stop";
+    return "";
+  }
+
+  function inline(value) {
+    var codes = [];
+    var text = esc(value)
+      .replace(/`([^`]+)`/g, function (_match, code) {
+        codes.push(code);
+        return "\u0000" + (codes.length - 1) + "\u0000";
+      })
+      .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+      .replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+    return text.replace(/\u0000(\d+)\u0000/g, function (_match, index) {
+      return "<code>" + codes[Number(index)] + "</code>";
+    });
+  }
+
+  function markdown(src) {
+    var lines = String(src).replace(/\r/g, "").split("\n");
+    var i = 0;
+    var html = "";
+    var tone = verdictTone(lines[0] ? lines[0].trim() : "");
+    if (tone) {
+      html += '<div class="verdict ' + tone + '">' + esc(lines[0].trim()) + "</div>";
+      i = 1;
+    }
+    function isList(line) { return /^\s*([-*+]|\d+\.)\s+/.test(line); }
+    function isBlock(line) { return /^(#{1,6}\s|```|\|)/.test(line) || isList(line); }
+    while (i < lines.length) {
+      var line = lines[i];
+      if (!line.trim()) { i += 1; continue; }
+      if (line.indexOf("```") === 0) {
+        var fence = [];
+        i += 1;
+        while (i < lines.length && lines[i].indexOf("```") !== 0) fence.push(lines[i++]);
+        i += 1;
+        html += "<pre><code>" + esc(fence.join("\n")) + "</code></pre>";
+        continue;
+      }
+      var heading = /^(#{1,6})\s+(.*)$/.exec(line);
+      if (heading) {
+        var level = Math.min(heading[1].length, 3);
+        html += "<h" + level + ">" + inline(heading[2]) + "</h" + level + ">";
+        i += 1;
+        continue;
+      }
+      if (line.indexOf("|") === 0) {
+        var rows = [];
+        while (i < lines.length && lines[i].indexOf("|") === 0) rows.push(lines[i++]);
+        html += "<table>";
+        var bodyRow = 0;
+        for (var r = 0; r < rows.length; r++) {
+          if (/^\|[\s:|-]+\|$/.test(rows[r])) continue;
+          var cells = rows[r].replace(/^\||\|$/g, "").split("|");
+          var tag = bodyRow === 0 ? "th" : "td";
+          html += "<tr>";
+          for (var cell = 0; cell < cells.length; cell++) html += "<" + tag + ">" + inline(cells[cell].trim()) + "</" + tag + ">";
+          html += "</tr>";
+          bodyRow += 1;
+        }
+        html += "</table>";
+        continue;
+      }
+      if (isList(line)) {
+        var ordered = /^\s*\d+\./.test(line);
+        var items = [];
+        while (i < lines.length && (isList(lines[i]) || (/^\s{2,}\S/.test(lines[i]) && items.length))) {
+          var item = lines[i++];
+          if (isList(item)) items.push(item.replace(/^\s*([-*+]|\d+\.)\s+/, ""));
+          else items[items.length - 1] += " " + item.trim();
+        }
+        html += ordered ? "<ol>" : "<ul>";
+        for (var n = 0; n < items.length; n++) html += "<li>" + inline(items[n]) + "</li>";
+        html += ordered ? "</ol>" : "</ul>";
+        continue;
+      }
+      var paragraph = [];
+      while (i < lines.length && lines[i].trim() && !isBlock(lines[i])) paragraph.push(lines[i++]);
+      html += "<p>" + inline(paragraph.join(" ")) + "</p>";
+    }
+    return html;
+  }
+
+  function renderFile(sheet) {
+    var current = sheet.querySelector("button.file.on");
+    var id = current ? current.getAttribute("data-file") || "" : "";
+    var src = null;
+    if (id && window.CSS && CSS.escape) src = sheet.querySelector('.src[data-file="' + CSS.escape(id) + '"]');
+    var view = sheet.querySelector("[data-view]");
+    if (!view) return;
+    var text = src ? src.textContent || "" : "";
+    view.innerHTML = text ? markdown(localizeIso(text)) : '<p class="empty">Nothing written yet.</p>';
+  }
+
+  function localTime(iso, withDate) {
+    var date = new Date(iso);
+    if (!isFinite(date.getTime())) return iso;
+    if (!withDate) return date.toLocaleTimeString(undefined, { hour: "numeric", minute: "2-digit" });
+    return date.toLocaleString();
+  }
+
+  function localizeIso(text) {
+    return String(text).replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})/g, function (iso) {
+      return localTime(iso, true);
+    });
+  }
+
+  function localizeTimes(root) {
+    var nodes = (root || document).querySelectorAll("time[datetime]");
+    for (var i = 0; i < nodes.length; i++) {
+    var iso = nodes[i].getAttribute("datetime");
+    if (iso) nodes[i].textContent = localTime(iso, nodes[i].getAttribute("data-time") !== "clock");
+    }
+  }
+
+  function openJob(id) {
+    if (!id) return;
+    var sheets = document.querySelectorAll(".sheet");
+    var found = null;
+    for (var i = 0; i < sheets.length; i++) {
+      var match = sheets[i].getAttribute("data-job") === id;
+      sheets[i].hidden = !match;
+      if (match) found = sheets[i];
+    }
+    if (!found) return;
+    body.classList.add("open");
+    renderFile(found);
+    try { localStorage.setItem("kiln-drawer", id); } catch (err) { /* private mode */ }
+  }
+
+  function closeDrawer() {
+    body.classList.remove("open");
+    var sheets = document.querySelectorAll(".sheet");
+    for (var i = 0; i < sheets.length; i++) sheets[i].hidden = true;
+    try { localStorage.removeItem("kiln-drawer"); } catch (err) { /* private mode */ }
+  }
+
+  function notifyLabel() {
+    var button = document.getElementById("notify");
+    if (!button) return;
+    if (typeof Notification === "undefined") {
+      button.hidden = true;
+      return;
+    }
+    button.hidden = false;
+    if (Notification.permission === "granted") {
+      button.setAttribute("data-tip", "Notifications on");
+      button.setAttribute("aria-label", "Notifications on");
+    } else if (Notification.permission === "denied") {
+      button.setAttribute("data-tip", "Notifications blocked");
+      button.setAttribute("aria-label", "Notifications blocked");
+    } else {
+      button.setAttribute("data-tip", "Notify me");
+      button.setAttribute("aria-label", "Notify me");
+    }
+  }
+
+  document.addEventListener("click", function (event) {
+    var target = event.target;
+    if (!target || !target.closest) return;
+    if (target.closest("#compact")) {
+      compact = !compact;
+      try { localStorage.setItem("kiln-compact", compact ? "on" : "off"); } catch (err) { /* private mode */ }
+      renderCompact();
+      layout();
+      return;
+    }
+    if (target.closest("#notify")) {
+      if (typeof Notification === "undefined" || Notification.permission !== "default") return;
+      Notification.requestPermission().then(notifyLabel);
+      return;
+    }
+    var act = target.closest("[data-act]");
+    if (act) {
+      var name = act.getAttribute("data-act");
+      var sheet = visibleSheet();
+      if (!sheet || !name) return;
+      if (name === "pr") {
+        var url = sheet.getAttribute("data-pr");
+        if (url) window.open(url, "_blank", "noopener");
+        return;
+      }
+      var form = sheet.querySelector("form." + name);
+      if (form && form.submit) form.submit();
+      return;
+    }
+    var chip = target.closest(".repo-f");
+    if (chip) {
+      repo = chip.getAttribute("data-repo") || "";
+      try {
+        if (repo) localStorage.setItem("kiln-repo", repo);
+        else localStorage.removeItem("kiln-repo");
+      } catch (err) { /* private mode */ }
+      applyRepo();
+      return;
+    }
+    if (target.closest("a[href]")) return;
+    if (target.closest("[data-close]")) {
+      closeDrawer();
+      return;
+    }
+    var file = target.closest("button.file");
+    if (file) {
+      var fileSheet = file.closest(".sheet");
+      if (!fileSheet) return;
+      var buttons = fileSheet.querySelectorAll("button.file");
+      for (var i = 0; i < buttons.length; i++) buttons[i].classList.toggle("on", buttons[i] === file);
+      var doc = fileSheet.querySelector(".doc");
+      if (doc) doc.scrollTop = 0;
+      renderFile(fileSheet);
+      return;
+    }
+    var card = target.closest(".card");
+    if (card) openJob(card.getAttribute("data-job") || "");
+  });
+
+  document.addEventListener("keydown", function (event) {
+    if (event.key === "Escape") closeDrawer();
+    var el = event.target;
+    if ((event.key === "Enter" || event.key === " ") && el && el.classList && el.classList.contains("card")) {
+      event.preventDefault();
+      openJob(el.getAttribute("data-job") || "");
+    }
+  });
+
+  function stamp(ok) {
+    var el = document.getElementById("status");
+    if (!el) return;
+    if (!ok) {
+      el.className = "status err";
+      el.textContent = "Failed to fetch";
+      return;
+    }
+    el.className = "status";
+    var jobs = document.querySelectorAll(".board .card").length;
+    el.textContent = jobs + (jobs === 1 ? " job · " : " jobs · ") + new Date().toLocaleTimeString();
+    localizeTimes(document);
+  }
+
+  function poll() {
+    fetch("/api/jobs", { cache: "no-store", headers: { Accept: "application/json" } })
+      .then(function (response) {
+        if (!response.ok) throw new Error("status");
+        return response.json();
+      })
+      .then(function (data) {
+        var rev = data && data.attention && data.attention.revision;
+        var current = body.getAttribute("data-revision");
+        if (rev && current && rev !== current) {
+          location.reload();
+          return;
+        }
+        stamp(true);
+      })
+      .catch(function () { stamp(false); });
+  }
+
+  renderCompact();
+  notifyLabel();
+  applyRepo();
+  stamp(true);
+  try {
+    var open = localStorage.getItem("kiln-drawer");
+    if (open) openJob(open);
+  } catch (err) { /* private mode */ }
+  poll();
+  setInterval(poll, 3000);
+})();

package/dist/attention.js

@@ -0,0 +1,264 @@
+import { createHash } from "node:crypto";
+import { INVESTIGATION_WORKFLOW } from "./findings.js";
+/**
+ * Attention order for `kiln serve`. Built from the same derived jobs as
+ * `kiln status`. The console renders this and does not classify jobs again.
+ *
+ * Needs you: a person has to act, a run is dead or failed with no automatic
+ * retry left, or a pull request is open. A failed job that still has a
+ * scheduled retry is in flight, not here.
+ * In flight: work is moving, waiting to launch, waiting to retry, or waiting
+ * on another job.
+ * Done recently: finished or rejected, collapsed in the page.
+ */
+const NEEDS_YOU = ["needs-human", "dead", "failed", "in-review", "invalid"];
+const IN_FLIGHT = ["running", "approved", "queued", "blocked"];
+const SETTLED = ["done", "rejected"];
+/** Reasons an automatic retry is allowed to schedule. A rejected gate is not one of these. */
+const RETRYABLE_REASONS = new Set(["stalled", "crashed", "orphaned", "failed"]);
+/**
+ * A failed job the driver will launch again on its own.
+ * Needs human, the `(N)` title, and desktop notifications all use this,
+ * so a waiting retry is not a call for a person.
+ */
+export function scheduledRetry(job) {
+    if (job.state !== "failed")
+        return false;
+    if (!job.nextRetryAt || !Number.isFinite(Date.parse(job.nextRetryAt)))
+        return false;
+    const max = job.maxAttempts;
+    if (max === undefined || !((job.attemptCount ?? 0) < max))
+        return false;
+    return job.lastFailureReason !== undefined && RETRYABLE_REASONS.has(job.lastFailureReason);
+}
+export function buildAttention(jobs) {
+    const indexed = jobs.map((job, index) => ({ job, index }));
+    const needsYou = indexed
+        .filter((entry) => !scheduledRetry(entry.job) && NEEDS_YOU.includes(entry.job.state))
+        .sort((left, right) => byRank(NEEDS_YOU, left, right))
+        .map((entry) => toItem(entry.job));
+    const inFlight = indexed
+        .filter((entry) => scheduledRetry(entry.job) || IN_FLIGHT.includes(entry.job.state))
+        .sort((left, right) => byFlight(left, right))
+        .map((entry) => toItem(entry.job));
+    const doneRecently = indexed
+        .filter((entry) => SETTLED.includes(entry.job.state))
+        .sort(byRecent)
+        .map((entry) => toItem(entry.job));
+    const graph = attentionGraph(jobs);
+    const revision = attentionRevision(needsYou, inFlight, doneRecently, graph);
+    return {
+        needsYou,
+        inFlight,
+        doneRecently,
+        graph,
+        needsYouCount: needsYou.length,
+        revision,
+    };
+}
+export function attentionGraph(jobs) {
+    const nodes = jobs.map((job) => ({
+        jobId: job.jobId,
+        title: job.title || job.jobId,
+        repo: job.repo,
+        state: job.state,
+    }));
+    const known = new Set(nodes.map((node) => node.jobId));
+    const edges = [];
+    for (const job of jobs) {
+        for (const dep of job.dependsOn) {
+            if (!known.has(dep.jobId)) {
+                known.add(dep.jobId);
+                nodes.push({
+                    jobId: dep.jobId,
+                    title: dep.jobId,
+                    repo: "",
+                    state: dep.state,
+                });
+            }
+            edges.push({ from: dep.jobId, to: job.jobId, stack: job.stack });
+        }
+    }
+    return { nodes, edges };
+}
+function toItem(job) {
+    const tail = job.state === "failed" || job.state === "dead" ? errorTail(job) : undefined;
+    const findings = findingsOf(job);
+    const since = job.startedAt ?? job.createdAt;
+    return {
+        job,
+        reason: attentionReason(job, tail),
+        ...(tail ? { errorTail: tail } : {}),
+        ...(findings ? { findings } : {}),
+        retry: job.state === "failed" || job.state === "dead",
+        ...(since ? { since } : {}),
+    };
+}
+export function attentionReason(job, tail = errorTail(job)) {
+    switch (job.state) {
+        case "needs-human": {
+            if (job.feedbackReason)
+                return job.feedbackReason;
+            const question = gateQuestion(job);
+            return question ? `Gate: ${oneLine(question)}` : "Waiting on a person";
+        }
+        case "dead":
+            return "Run died before it finished";
+        case "failed": {
+            const why = firstLine(job.launchError) || firstLine(job.deliveryError) || firstLine(job.failureDetail) || firstLine(tail) || "Run failed";
+            return `Failed: ${oneLine(why)}`;
+        }
+        case "in-review":
+            if (job.prNumber)
+                return `Pull request #${job.prNumber} is open`;
+            if (job.prPending)
+                return "Pull request not opened yet";
+            return "In review";
+        case "invalid":
+            return job.invalidReason ? `Invalid: ${oneLine(job.invalidReason)}` : "Job file is invalid";
+        case "blocked":
+            return oneLine(waitingOn(job));
+        case "running": {
+            const current = job.steps.find((step) => step.phase === "current" || step.phase === "failed");
+            return current ? `Running ${current.id}` : "Running";
+        }
+        case "approved":
+            return "Approved, still finishing";
+        case "queued":
+            return "Queued, ready to launch";
+        case "done":
+            return job.prUrl ? "Merged" : "Done";
+        case "rejected":
+            return "Rejected";
+        default:
+            return job.state;
+    }
+}
+function waitingOn(job) {
+    const details = job.dependsOn.map((dep) => dep.blockedDetail).filter((detail) => Boolean(detail));
+    if (details.length > 0)
+        return details.join("; ");
+    if (job.dependsOn.length === 0)
+        return "Blocked";
+    return `Waiting on ${job.dependsOn.map((dep) => `${dep.jobId} (${dep.state})`).join(", ")}`;
+}
+function gateQuestion(job) {
+    const gate = job.gates[0];
+    if (!gate)
+        return undefined;
+    const first = gate.rendered?.split("\n")[0]?.trim();
+    return first || gate.prompt;
+}
+function findingsOf(job) {
+    if (job.state !== "needs-human" || job.workflow !== INVESTIGATION_WORKFLOW)
+        return undefined;
+    const rendered = job.gates.map((gate) => gate.rendered).find((text) => text && text.includes("\n"));
+    if (!rendered)
+        return undefined;
+    const body = rendered.split("\n").slice(1).join("\n").trim();
+    return body || undefined;
+}
+function errorTail(job) {
+    const parts = [];
+    if (job.launchError?.trim())
+        parts.push(job.launchError.trim());
+    if (job.deliveryError?.trim())
+        parts.push(job.deliveryError.trim());
+    if (job.failureDetail?.trim())
+        parts.push(job.failureDetail.trim());
+    if (job.prClosedUnmerged && job.prNumber) {
+        parts.push(`Pull request #${job.prNumber} was closed without merging`);
+    }
+    if (job.noReadableApproval)
+        parts.push("No readable approval decision");
+    if (job.logTail?.trim() && !parts.includes(job.logTail.trim()))
+        parts.push(job.logTail.trim());
+    if (parts.length === 0)
+        return undefined;
+    return parts.join("\n");
+}
+function byFlight(left, right) {
+    const rank = flightRank(left.job) - flightRank(right.job);
+    if (rank !== 0)
+        return rank;
+    return left.index - right.index;
+}
+/** Running first, then a job waiting out its backoff, then the rest of the in-flight states. */
+function flightRank(job) {
+    if (scheduledRetry(job))
+        return 1;
+    switch (job.state) {
+        case "running":
+            return 0;
+        case "approved":
+            return 2;
+        case "queued":
+            return 3;
+        case "blocked":
+            return 4;
+        default:
+            return 5;
+    }
+}
+function byRank(order, left, right) {
+    const rank = order.indexOf(left.job.state) - order.indexOf(right.job.state);
+    if (rank !== 0)
+        return rank;
+    return left.index - right.index;
+}
+function byRecent(left, right) {
+    const leftAt = left.job.finishedAt ?? "";
+    const rightAt = right.job.finishedAt ?? "";
+    if (leftAt !== rightAt) {
+        if (!leftAt)
+            return 1;
+        if (!rightAt)
+            return -1;
+        return rightAt < leftAt ? -1 : 1;
+    }
+    return right.index - left.index;
+}
+function attentionRevision(needsYou, inFlight, doneRecently, graph) {
+    const body = JSON.stringify({
+        needsYou: needsYou.map((item) => [
+            item.job.jobId,
+            item.job.state,
+            item.reason,
+            item.job.attemptCount,
+            item.job.lastFailureReason ?? "",
+            item.job.nextRetryAt ?? "",
+            feedbackStamp(item.job),
+        ]),
+        inFlight: inFlight.map((item) => [
+            item.job.jobId,
+            item.job.state,
+            item.reason,
+            item.job.steps.map((step) => `${step.id}:${step.phase}`).join(","),
+            item.job.attemptCount,
+            item.job.lastFailureReason ?? "",
+            item.job.nextRetryAt ?? "",
+            feedbackStamp(item.job),
+        ]),
+        doneRecently: doneRecently.map((item) => [item.job.jobId, item.job.state]),
+        edges: graph.edges.map((edge) => [edge.from, edge.to, edge.stack]),
+    });
+    return createHash("sha256").update(body).digest("hex").slice(0, 16);
+}
+function feedbackStamp(job) {
+    const rounds = (job.feedbackRounds ?? [])
+        .map((round) => `${round.round}:${round.trigger}:${round.outcome ?? ""}:${round.headSha}`)
+        .join("|");
+    return `${job.feedbackReason ?? ""}:${rounds}`;
+}
+function oneLine(text, max = 180) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    if (flat.length <= max)
+        return flat;
+    return `${flat.slice(0, max - 1)}…`;
+}
+function firstLine(text) {
+    if (!text)
+        return undefined;
+    const line = text.split("\n").find((candidate) => candidate.trim().length > 0);
+    return line?.trim();
+}