@chrisjowen/wheelhouse 0.1.1 → 0.2.1

package/build/server/chunks/chunks/hand.js-BA9yKAan.js

@@ -0,0 +1,25 @@
+import { ac as spread_props } from './index.js-B0NFhRTN.js';
+import { I as Icon } from './Icon.js-CVZZ-yuB.js';
+
+function Hand($$renderer, $$props) {
+  let { $$slots, $$events, ...props } = $$props;
+  const iconData = {
+    "name": "hand",
+    "size": 24,
+    "node": [
+      ["path", { "d": "M18 11V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2" }],
+      ["path", { "d": "M14 10V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2" }],
+      ["path", { "d": "M10 10.5V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2v8" }],
+      [
+        "path",
+        {
+          "d": "M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"
+        }
+      ]
+    ]
+  };
+  Icon($$renderer, spread_props([props, { icon: iconData }]));
+}
+
+export { Hand as H };
+//# sourceMappingURL=hand.js-BA9yKAan.js.map

package/build/server/chunks/chunks/harbour.js-PHLHOFea.js

@@ -0,0 +1,117 @@
+const LANDED_RECENT_MS = 24 * 3600 * 1e3;
+const TROUBLE = /* @__PURE__ */ new Set(["blocked", "failed", "lost", "unknown"]);
+const isTrouble = (t) => TROUBLE.has(t.status);
+const needsYou = (t) => t.attention?.owner === "captain";
+function landedAt(t) {
+  if (t.mergedAt) return Date.parse(t.mergedAt);
+  if (t.completedOn) {
+    const d = Date.parse(`${t.completedOn}T23:59:59`);
+    return Number.isNaN(d) ? null : d;
+  }
+  return null;
+}
+const STATUS_ORDER = {
+  blocked: 0,
+  failed: 0,
+  lost: 1,
+  unknown: 1,
+  waiting: 2,
+  done: 3,
+  working: 4
+};
+const progress = (t) => t.passage.steps.length > 1 ? t.passage.current / (t.passage.steps.length - 1) : 0;
+function chartColumns(tasks) {
+  const order = [];
+  const labels = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    let after = -1;
+    for (const s of t.passage.steps) {
+      let at = order.indexOf(s.column);
+      if (at < 0) {
+        order.splice(after + 1, 0, s.column);
+        at = after + 1;
+      }
+      after = at;
+      const own = s.key === s.column;
+      const prev = labels.get(s.column);
+      if (!prev || own && !prev.own) labels.set(s.column, { label: s.label, own });
+    }
+  }
+  return order.map((key) => ({ key, label: labels.get(key)?.label ?? key }));
+}
+function harbour(tasks, now) {
+  const h = {
+    needsYou: [],
+    waitingOnFirstmate: [],
+    waitingOnReviewers: [],
+    underWay: [],
+    queued: [],
+    landedRecent: [],
+    landedOlder: [],
+    trouble: [],
+    live: null,
+    stepFailed: []
+  };
+  for (const t of tasks) {
+    if (needsYou(t)) h.needsYou.push(t);
+    else if (t.status === "with-firstmate") h.waitingOnFirstmate.push(t);
+    else if (t.status === "with-reviewers") h.waitingOnReviewers.push(t);
+    else if (t.status === "queued") h.queued.push(t);
+    else if (t.status === "landed") {
+      const at = landedAt(t);
+      (at !== null && now - at <= LANDED_RECENT_MS ? h.landedRecent : h.landedOlder).push(t);
+    } else {
+      h.underWay.push(t);
+      if (isTrouble(t)) h.trouble.push(t);
+    }
+  }
+  h.underWay.sort(
+    (a, b) => (STATUS_ORDER[a.status] ?? 5) - (STATUS_ORDER[b.status] ?? 5) || progress(b) - progress(a)
+  );
+  const byLanded = (a, b) => (landedAt(b) ?? 0) - (landedAt(a) ?? 0);
+  h.landedRecent.sort(byLanded);
+  h.landedOlder.sort(byLanded);
+  if (tasks.some((t) => t.passage.live !== null)) {
+    h.live = h.landedRecent.filter((t) => t.passage.live === true);
+  }
+  h.stepFailed = [...h.underWay, ...h.landedRecent].filter(
+    (t) => t.passage.steps[t.passage.current]?.failed
+  );
+  return h;
+}
+const shelfOf = (view) => view === "completed" ? "completed" : "under-way";
+const isCompleted = (t) => t.status === "landed" || t.status === "done";
+const ms = (iso) => {
+  const t = iso ? Date.parse(iso) : NaN;
+  return Number.isNaN(t) ? null : t;
+};
+const completedAt = (t) => landedAt(t) ?? ms(t.current?.observedAt) ?? ms(t.since);
+function shelf(tasks, which) {
+  if (which === "under-way") return tasks.filter((t) => !isCompleted(t));
+  return tasks.filter(isCompleted).sort((a, b) => (completedAt(b) ?? 0) - (completedAt(a) ?? 0));
+}
+function headline(h) {
+  const parts = [];
+  const n = h.needsYou.length;
+  parts.push(
+    n === 0 ? "Nothing needs you." : `${n} ${n === 1 ? "thing needs" : "things need"} you.`
+  );
+  const landed = [`${h.landedRecent.length} landed in the last day`];
+  if (h.live) landed.push(`${h.live.length} live`);
+  if (h.stepFailed.length) {
+    const at = [...new Set(h.stepFailed.map((t) => t.passage.steps[t.passage.current].label))];
+    landed.push(`${h.stepFailed.length} failed at ${at.join(" or ")}`);
+  }
+  parts.push(`${landed.join(", ")}.`);
+  const extra = [];
+  if (h.waitingOnFirstmate.length)
+    extra.push(`${h.waitingOnFirstmate.length} waiting on Firstmate`);
+  if (h.waitingOnReviewers.length)
+    extra.push(`${h.waitingOnReviewers.length} waiting on reviewers`);
+  if (h.trouble.length) extra.push(`${h.trouble.length} with Firstmate keeping an eye on them`);
+  parts.push(`${h.underWay.length} under way${extra.length ? `, ${extra.join(", ")}` : ""}.`);
+  return parts.join(" ");
+}
+
+export { LANDED_RECENT_MS as L, isCompleted as a, headline as b, completedAt as c, chartColumns as d, shelfOf as e, harbour as h, isTrouble as i, landedAt as l, needsYou as n, progress as p, shelf as s };
+//# sourceMappingURL=harbour.js-PHLHOFea.js.map

package/build/server/chunks/chunks/html.js-FW6Ia4bL.js

@@ -0,0 +1,8 @@
+function html(value) {
+  var html2 = String(value ?? "");
+  var open = "<!---->";
+  return open + html2 + "<!---->";
+}
+
+export { html as h };
+//# sourceMappingURL=html.js-FW6Ia4bL.js.map

package/build/server/chunks/chunks/http.js-CBM8xgUM.js

@@ -0,0 +1,25 @@
+import { j as json } from './utils.js-BJgm9WbO.js';
+
+const NO_STORE = { "cache-control": "no-store" };
+async function readJson(request, maxBytes) {
+  const refuse = (message, status) => ({
+    ok: false,
+    response: json({ message }, { status, headers: NO_STORE })
+  });
+  if (!(request.headers.get("content-type") ?? "").includes("application/json")) {
+    return refuse("Send the request as JSON.", 415);
+  }
+  const raw = await request.text();
+  if (Buffer.byteLength(raw) > maxBytes) return refuse("The request is too large.", 413);
+  try {
+    const body = JSON.parse(raw);
+    if (body && typeof body === "object" && !Array.isArray(body)) {
+      return { ok: true, body };
+    }
+  } catch {
+  }
+  return refuse("The request is not valid JSON.", 400);
+}
+
+export { NO_STORE as N, readJson as r };
+//# sourceMappingURL=http.js-CBM8xgUM.js.map

package/build/server/chunks/chunks/inbox.js-Dv8a1ecX.js

@@ -0,0 +1,184 @@
+const CHOICES = ["approve", "fix", "skip"];
+const closable = (c) => c.kind !== "hold" && c.kind !== "merge" && !/^open-\d+$/.test(c.key);
+const LABEL = { approve: "Approve", fix: "Fix", skip: "Skip" };
+const KIND_LABEL = {
+  preview: { fix: "Request changes" }
+};
+const MEANING = {
+  review: {
+    approve: "Keep the code as it is.",
+    fix: "Have the worker fix it.",
+    skip: "Defer it: no change in this work."
+  },
+  decision: {
+    approve: "Go ahead as proposed.",
+    fix: "Change course (say how in a note).",
+    skip: "Leave the call to Firstmate."
+  },
+  blocked: {
+    approve: "Go ahead as proposed.",
+    fix: "Try another way (say how in a note).",
+    skip: "Leave it to Firstmate to unblock."
+  },
+  hold: {
+    approve: "Go ahead.",
+    fix: "Not like this (say what to change in a note).",
+    skip: "Not now: leave it held."
+  },
+  merge: {
+    approve: "Merge the pull request.",
+    fix: "Request changes (say what in a note).",
+    skip: "Hold off merging for now."
+  },
+  preview: {
+    approve: "Sign off the preview.",
+    fix: "Request changes (say what in a note).",
+    skip: "Not now: sign it off later."
+  }
+};
+const PICKS_LABEL = "Send picks";
+const PICKS_MEANING = "Go ahead with the picks below.";
+function optionsFor(kind, picks = false) {
+  return CHOICES.map(
+    (choice) => picks && choice === "approve" ? { choice, label: PICKS_LABEL, meaning: PICKS_MEANING } : {
+      choice,
+      label: KIND_LABEL[kind]?.[choice] ?? LABEL[choice],
+      meaning: MEANING[kind][choice]
+    }
+  );
+}
+const choiceLabel = (card, c) => c === "close" ? "Close" : card.options.find((o) => o.choice === c)?.label ?? LABEL[c];
+const KIND_WORDS = {
+  review: "review question",
+  decision: "decision",
+  blocked: "blocker",
+  hold: "captain hold",
+  merge: "merge call",
+  preview: "preview sign-off"
+};
+const NOTE_MAX = 2e3;
+const WRITTEN_MAX = 300;
+function resolvePicks(choices, picks) {
+  const out = {};
+  for (const call of choices.calls) {
+    const own = picks[call.id]?.trim();
+    const rec = call.options.find((o) => o.recommended)?.id;
+    const v = own || rec;
+    if (v) out[call.id] = v;
+  }
+  return out;
+}
+const unpicked = (choices, picks) => choices.calls.filter((c) => c.required && !resolvePicks(choices, picks)[c.id]);
+function callName(call) {
+  const prompt = call.prompt ? oneLine(call.prompt, 48) : "";
+  if (call.number === null) return prompt;
+  return prompt ? `${call.number}) ${prompt}` : `${call.number})`;
+}
+const callRef = (call) => callName(call) || "this question";
+function picksLine(choices, picks) {
+  const known = new Set(choices.calls.map((c) => c.id));
+  const stray = Object.keys(picks).find((id) => !known.has(id));
+  if (stray) return { ok: false, error: "A pick names a call this question does not ask." };
+  const all = resolvePicks(choices, picks);
+  const parts = [];
+  for (const call of choices.calls) {
+    const v = all[call.id];
+    if (!v) {
+      if (call.required) return { ok: false, error: `Pick an option for ${callRef(call)}.` };
+      continue;
+    }
+    let answer;
+    if (call.options.length) {
+      const o = call.options.find((x) => x.id === v);
+      if (!o) return { ok: false, error: `That is not an option for ${callRef(call)}.` };
+      answer = o.detail ? `${o.label} (${oneLine(o.detail, 60)})` : oneLine(o.label, 80);
+    } else {
+      if (v.length > WRITTEN_MAX) {
+        return { ok: false, error: `Answers are limited to ${WRITTEN_MAX} characters.` };
+      }
+      answer = oneLine(v, WRITTEN_MAX);
+    }
+    const name = callName(call);
+    parts.push(name ? `${name}${/[?:]$/.test(name) ? "" : ":"} ${answer}` : answer);
+  }
+  return parts.length ? { ok: true, line: parts.join("  ") } : { ok: false, error: "Make a pick first." };
+}
+function answerText(card, choice, note, picks = null) {
+  const option = card.options.find((o) => o.choice === choice);
+  const lines = heading(card, "answer");
+  if (card.kind === "merge" && card.evidence.pr)
+    lines.push(`Pull request: ${card.evidence.pr.url}`);
+  lines.push(`Answer: ${option.label} - ${option.meaning}`);
+  if (picks) lines.push(`Picks: ${picks}`);
+  return withNote(lines, note);
+}
+function closeText(card, note) {
+  const lines = heading(card, "close");
+  lines.push(
+    `Close: The captain closed this question without choosing an answer. Record it resolved on key ${card.key} so it leaves the open decisions, and settle anything the worker still waits for under your own rules.`
+  );
+  return withNote(lines, note);
+}
+function heading(card, what) {
+  return [
+    `Decision inbox ${what} (${KIND_WORDS[card.kind]}).`,
+    `Task: ${card.taskId} (${card.taskTitle})`,
+    `Decision key: ${card.key}`,
+    `Question: ${questionLine(card.question)}`
+  ];
+}
+function withNote(lines, note) {
+  const n = note?.trim();
+  if (n) lines.push(`Note: ${n}`);
+  return lines.join("\n");
+}
+const oneLine = (s, max) => {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? t.slice(0, max - 1).trimEnd() + "…" : t;
+};
+const questionLine = (question) => oneLine(question, 300);
+const labelChoice = (label) => label === PICKS_LABEL ? "approve" : CHOICES.find(
+  (c) => LABEL[c] === label || Object.values(KIND_LABEL).some((l) => l?.[c] === label)
+);
+function answerOf(text) {
+  const closing = text.startsWith("Decision inbox close");
+  if (!closing && !text.startsWith("Decision inbox answer")) return null;
+  const key = /^Decision key: (.+)$/m.exec(text)?.[1]?.trim();
+  const label = closing ? null : /^Answer: (.+?) - /m.exec(text)?.[1];
+  const choice = closing ? "close" : label ? labelChoice(label) : void 0;
+  if (!key || !choice) return null;
+  const question = /^Question: (.*)$/m.exec(text)?.[1] ?? null;
+  const picks = /^Picks: (.*)$/m.exec(text)?.[1]?.trim() || null;
+  const note = /^Note: ([\s\S]*)$/m.exec(text)?.[1]?.trim() || null;
+  return { key, question, choice, picks, note };
+}
+const SNOOZE_MS = 4 * 3600 * 1e3;
+const SNOOZE_KEY = "wheelhouse-inbox-snoozed";
+function liveSnoozes(s, now) {
+  return Object.fromEntries(Object.entries(s).filter(([, until]) => until > now));
+}
+function parseSnoozes(raw, now) {
+  if (!raw) return {};
+  try {
+    const v = JSON.parse(raw);
+    if (typeof v !== "object" || v === null || Array.isArray(v)) return {};
+    const out = {};
+    for (const [k, until] of Object.entries(v)) if (typeof until === "number") out[k] = until;
+    return liveSnoozes(out, now);
+  } catch {
+    return {};
+  }
+}
+function visibleCards(cards, snoozed, now) {
+  const live = liveSnoozes(snoozed, now);
+  const open = cards.filter(awaitsAnswer);
+  const shown = open.filter((c) => !live[c.id]);
+  return { shown, snoozed: open.length - shown.length };
+}
+const awaitsAnswer = (c) => !c.sent || c.sent.delivery === "failed";
+const openCount = (cards, snoozed, now) => visibleCards(cards, snoozed, now).shown.length;
+const holdCardId = (taskId) => `${taskId}:captain-hold`;
+const cardHref = (cardId) => `/inbox#card-${encodeURIComponent(cardId)}`;
+
+export { CHOICES as C, NOTE_MAX as N, SNOOZE_KEY as S, WRITTEN_MAX as W, answerOf as a, closable as b, cardHref as c, closeText as d, answerText as e, choiceLabel as f, awaitsAnswer as g, holdCardId as h, parseSnoozes as i, openCount as j, SNOOZE_MS as k, liveSnoozes as l, callName as m, callRef as n, optionsFor as o, picksLine as p, questionLine as q, resolvePicks as r, unpicked as u, visibleCards as v };
+//# sourceMappingURL=inbox.js-Dv8a1ecX.js.map

package/build/server/chunks/chunks/inbox.svelte.js-n7K3YnGB.js

@@ -0,0 +1,171 @@
+import { i as parseSnoozes, S as SNOOZE_KEY, v as visibleCards, j as openCount, g as awaitsAnswer, k as SNOOZE_MS, l as liveSnoozes, p as picksLine } from './inbox.js-Dv8a1ecX.js';
+import { S as SESSION_HEADER } from './messages.js-CFyGKoqq.js';
+
+class Inbox {
+  value = null;
+  snoozed = {};
+  /**
+   * Cards answered or closed here whose answer the server has not shown back
+   * yet, by card id, with the question they answered. Each is hidden at once,
+   * from every list; an answer that is not taken puts its card back with the
+   * reason. A taken one (posted) stays hidden until the server's view shows
+   * the answer, or the question closes or changes.
+   */
+  pending = {};
+  /** Why the latest answer could not be sent, by card id. */
+  errors = {};
+  timer = null;
+  loaded = false;
+  seed(v) {
+    if (v && !this.value) this.value = v;
+  }
+  /** Read the snoozes once, in the browser. */
+  load() {
+    if (this.loaded) return;
+    this.loaded = true;
+    try {
+      this.snoozed = parseSnoozes(localStorage.getItem(SNOOZE_KEY), Date.now());
+    } catch {
+      this.snoozed = {};
+    }
+  }
+  /** Re-read soon; repeated calls within the window coalesce. */
+  refresh(delayMs = 400) {
+    if (this.timer) return;
+    this.timer = setTimeout(
+      async () => {
+        this.timer = null;
+        await this.read();
+      },
+      delayMs
+    );
+  }
+  async read() {
+    try {
+      const r = await fetch("/api/inbox");
+      if (!r.ok) return;
+      const view = await r.json();
+      this.value = view;
+      const open = (id, question) => view.cards.some((c) => c.id === id && c.question === question && !c.sent);
+      this.pending = Object.fromEntries(Object.entries(this.pending).filter(([id, p]) => !p.posted || open(id, p.question)));
+    } catch {
+    }
+  }
+  /**
+   * The view, else the one the page loaded (`seed`), so a page drawn on the
+   * server, where this is never set, already shows the decisions it will show.
+   */
+  view(seed) {
+    return this.value ?? seed ?? null;
+  }
+  /** The cards as the server shows them, without those answered or closed here. */
+  cards(seed) {
+    return (this.view(seed)?.cards ?? []).filter((c) => this.pending[c.id]?.question !== c.question);
+  }
+  shown(now, seed) {
+    return visibleCards(this.cards(seed), this.snoozed, now);
+  }
+  open(now) {
+    return openCount(this.cards(), this.snoozed, now);
+  }
+  /** A task's questions still waiting, snoozed or not, without its merge call. */
+  forTask(taskId, seed) {
+    return this.cards(seed).filter((c) => c.taskId === taskId && c.kind !== "merge" && awaitsAnswer(c));
+  }
+  /** Whether the inbox has a question on a task other than its merge call, answered or not. */
+  hasDecision(taskId, seed) {
+    const view = this.view(seed);
+    return !!view?.available && view.cards.some((c) => c.taskId === taskId && c.kind !== "merge");
+  }
+  later(id) {
+    this.snoozed = {
+      ...liveSnoozes(this.snoozed, Date.now()),
+      [id]: Date.now() + SNOOZE_MS
+    };
+    this.save();
+  }
+  /** Show snoozed cards again: one, or all of them. */
+  wake(id) {
+    if (id && !this.snoozed[id]) return;
+    this.snoozed = id ? Object.fromEntries(Object.entries(this.snoozed).filter(([k]) => k !== id)) : {};
+    this.save();
+  }
+  save() {
+    try {
+      localStorage.setItem(SNOOZE_KEY, JSON.stringify(this.snoozed));
+    } catch {
+    }
+  }
+  /** Show why an answer cannot go yet, without sending it. */
+  complain(id, message) {
+    this.errors = { ...this.errors, [id]: message };
+  }
+  /**
+   * Send one answer, or a close, to Firstmate; Approve on a card with choices
+   * carries the picks. Returns whether it was taken.
+   */
+  async answer(card, choice, note, token, picks = null) {
+    const withPicks = choice === "approve" && card.choices ? picksLine(card.choices, picks ?? {}) : null;
+    if (withPicks && !withPicks.ok) {
+      this.complain(card.id, withPicks.error);
+      return false;
+    }
+    const { [card.id]: _, ...rest } = this.errors;
+    this.errors = rest;
+    const line = withPicks?.ok ? withPicks.line : null;
+    this.pending = {
+      ...this.pending,
+      [card.id]: {
+        choice,
+        picks: line,
+        note,
+        question: card.question,
+        posted: false
+      }
+    };
+    const requestId = `inbox-${crypto.randomUUID()}`;
+    try {
+      const r = await fetch("/api/inbox", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "idempotency-key": requestId,
+          [SESSION_HEADER]: token
+        },
+        body: JSON.stringify({
+          cardId: card.id,
+          choice,
+          note,
+          ...withPicks ? { picks: picks ?? {} } : {}
+        })
+      });
+      if (!r.ok) {
+        const body2 = await r.json().catch(() => null);
+        this.fail(card.id, body2?.message ?? `Wheelhouse could not send it (${r.status}).`);
+        if (r.status === 404) this.refresh(0);
+        return false;
+      }
+      const body = await r.json().catch(() => null);
+      if (body?.message?.delivery === "failed") {
+        this.fail(card.id, body.message.deliveryDetail ?? "Firstmate did not take the answer. Try again.");
+        return false;
+      }
+      const p = this.pending[card.id];
+      if (p) this.pending = { ...this.pending, [card.id]: { ...p, posted: true } };
+      this.refresh(0);
+      return true;
+    } catch {
+      this.fail(card.id, "Wheelhouse could not be reached. Try again.");
+      return false;
+    }
+  }
+  fail(id, message) {
+    const { [id]: _, ...rest } = this.pending;
+    this.pending = rest;
+    this.errors = { ...this.errors, [id]: message };
+  }
+}
+const inbox = new Inbox();
+
+export { inbox as i };
+//# sourceMappingURL=inbox.svelte.js-n7K3YnGB.js.map

package/build/server/chunks/chunks/index-server.js-DsObimPA.js

@@ -0,0 +1,9 @@
+const SvelteSet = globalThis.Set;
+const SvelteMap = globalThis.Map;
+function createSubscriber(_) {
+  return () => {
+  };
+}
+
+export { SvelteMap as S, SvelteSet as a, createSubscriber as c };
+//# sourceMappingURL=index-server.js-DsObimPA.js.map

package/build/server/chunks/chunks/index-server2.js-Fb2GE8KQ.js

@@ -0,0 +1,17 @@
+import { ad as ssr_context, ae as lifecycle_function_unavailable } from './index.js-B0NFhRTN.js';
+
+function onDestroy(fn) {
+  /** @type {SSRContext} */
+  ssr_context.r.on_destroy(fn);
+}
+function mount() {
+  lifecycle_function_unavailable("mount");
+}
+function unmount() {
+  lifecycle_function_unavailable("unmount");
+}
+async function tick() {
+}
+
+export { mount as m, onDestroy as o, tick as t, unmount as u };
+//# sourceMappingURL=index-server2.js-Fb2GE8KQ.js.map