@kud/gh-ink 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erwann Mest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @kud/gh-ink
+
+Controlled [Ink](https://github.com/vadimdemedes/ink) components for rendering
+GitHub PR domain objects in the terminal. Presentation-first: data comes in as
+props (the consuming surface owns the fetch), mutations run against
+[`@kud/gh`](../gh). Built on [`@kud/ink-ui`](https://github.com/kud/ink-ui).
+
+Consumed by the standalone `gh-pr-*` CLIs **and** by cockpit — one component, many
+surfaces.
+
+## Install
+
+```sh
+npm install @kud/gh-ink @kud/gh
+```
+
+`ink` and `react` are peer dependencies.
+
+## Exports
+
+| Export                                          | What                                                                                                                      |
+| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `CommentsPanel` (`CommentsPanelProps`)          | Selectable review-thread + conversation panel — resolve (`x`), reply (`r`), show/hide resolved (`R`).                     |
+| `healthDisplay` / `healthGlyph` / `healthColor` | Map a `@kud/gh` `Health` token → glyph + `@kud/ink-ui` colour. Glyph distinguishes (colourblind-safe); colour reinforces. |
+| `healthLegend`                                  | Ordered `[Health, label]` pairs for a help legend.                                                                        |
+| `renderMarkdown`                                | GitHub-flavoured markdown → styled terminal lines.                                                                        |
+
+## Design
+
+Every component is controlled — the parent owns loading and passes `data` in — so
+the same panel drops into a full-screen CLI or a single pane of a dashboard. The
+core (`@kud/gh`) decides the semantic token; this layer maps it to a colour. Same
+seam as `@kud/jenkins` → `@kud/jenkins-ink`.
+
+## Development
+
+```sh
+npm run typecheck
+npm run test
+npm run build
+```
+
+## Licence
+
+MIT © Erwann Mest

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+import { PrComments, PrHealthData, PrCheck, Health } from '@kud/gh';
+import { StyledLine } from '@kud/ink-ui';
+
+type CommentsPanelProps = {
+    repo: string;
+    number: number;
+    data: PrComments | null;
+    error: string | null;
+    reload: () => void;
+    onReplyingChange?: (active: boolean) => void;
+};
+declare const CommentsPanel: ({ repo, number, data, error, reload, onReplyingChange, }: CommentsPanelProps) => React.JSX.Element;
+
+type HealthPanelProps = {
+    repo: string;
+    number: number;
+    data: PrHealthData | null;
+    error: string | null;
+    reload: () => void;
+    onOpenCheck: (check: PrCheck) => void;
+};
+declare const HealthPanel: ({ repo, number, data, error, reload, onOpenCheck, }: HealthPanelProps) => React.JSX.Element;
+
+declare const renderMarkdown: (raw: string, width: number, fileLink?: (path: string, line?: number) => string) => StyledLine[];
+
+declare const healthDisplay: Record<Health, {
+    glyph: string;
+    color: string;
+}>;
+declare const healthGlyph: (h: Health) => string;
+declare const healthColor: (h: Health) => string;
+declare const healthLegend: [Health, string][];
+
+export { CommentsPanel, type CommentsPanelProps, HealthPanel, type HealthPanelProps, healthColor, healthDisplay, healthGlyph, healthLegend, renderMarkdown };

package/dist/index.js

@@ -0,0 +1,600 @@
+import React2, { useState } from 'react';
+import { useWindowSize, useInput, Text, Box } from 'ink';
+import { colors, ScrollView, TextInput } from '@kud/ink-ui';
+import { isPassCheck, isFailCheck, resolveThread, unresolveThread, replyToThread, rerunFailedRun, mergePr, reRequestReviewer } from '@kud/gh';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
+
+// src/components/comments-panel.tsx
+var ENTITIES = {
+  "&lt;": "<",
+  "&gt;": ">",
+  "&amp;": "&",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+  "&nbsp;": " ",
+  "&mdash;": "\u2014",
+  "&ndash;": "\u2013",
+  "&hellip;": "\u2026",
+  "&bull;": "\u2022",
+  "&rarr;": "\u2192",
+  "&larr;": "\u2190",
+  "&check;": "\u2713"
+};
+var decodeEntities = (s) => s.replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(
+  /&#x([0-9a-f]+);/gi,
+  (_, n) => String.fromCodePoint(parseInt(n, 16))
+).replace(/&[a-z]+;/gi, (m) => ENTITIES[m.toLowerCase()] ?? "");
+var htmlToText = (s) => s.replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|h[1-6]|tr|ul|ol|table|thead|tbody|blockquote)>/gi, "\n").replace(/<li[^>]*>/gi, "\n\u2022 ").replace(/<\/(td|th)>/gi, " \xB7 ").replace(/<(td|th)[^>]*>/gi, "").replace(/<img[^>]*alt="([^"]*)"[^>]*>/gi, "[img: $1]").replace(/<img[^>]*>/gi, "[img]").replace(/<[^>]+>/g, "");
+var stripInline = (line) => line.replace(/!\[([^\]]*)\]\([^)]*\)/g, "[img: $1]").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/\*\*(.+?)\*\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/(^|[^*])\*(?!\*)([^*]+?)\*(?!\*)/g, "$1$2").replace(/`([^`]+)`/g, "$1");
+var wrap = (text, width) => {
+  if (width <= 0) return [text];
+  const words = text.split(/\s+/);
+  const lines = [];
+  let cur = "";
+  for (const word of words) {
+    if (word.length > width) {
+      if (cur) {
+        lines.push(cur);
+        cur = "";
+      }
+      let rest = word;
+      while (rest.length > width) {
+        lines.push(rest.slice(0, width));
+        rest = rest.slice(width);
+      }
+      cur = rest;
+      continue;
+    }
+    if (!cur) cur = word;
+    else if (cur.length + 1 + word.length <= width) cur += " " + word;
+    else {
+      lines.push(cur);
+      cur = word;
+    }
+  }
+  if (cur) lines.push(cur);
+  return lines.length ? lines : [""];
+};
+var CODE_COLOR = "#8FBCBB";
+var linkify = (s) => s.replace(/!\[([^\]]*)\]\([^)]*\)/g, "[img: $1]").replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+var INLINE_RE = /(\*\*(.+?)\*\*|`([^`]+)`|\*([^*\s][^*]*?)\*)/g;
+var parseInline = (text) => {
+  const spans = [];
+  const re = new RegExp(INLINE_RE);
+  let last = 0;
+  let m;
+  while (m = re.exec(text)) {
+    if (m.index > last) spans.push({ text: text.slice(last, m.index) });
+    if (m[2] != null) spans.push({ text: m[2], bold: true });
+    else if (m[3] != null) spans.push({ text: m[3], color: CODE_COLOR });
+    else if (m[4] != null) spans.push({ text: m[4], italic: true });
+    last = re.lastIndex;
+  }
+  if (last < text.length) spans.push({ text: text.slice(last) });
+  return spans;
+};
+var sameStyle = (a, b) => a.color === b.color && a.bold === b.bold && a.dim === b.dim && a.italic === b.italic;
+var wrapSpans = (spans, width) => {
+  const words = [];
+  for (const s of spans)
+    for (const w of s.text.split(/\s+/).filter(Boolean))
+      words.push({ text: w, color: s.color, bold: s.bold, italic: s.italic });
+  const lines = [];
+  let cur = [];
+  const curLen = () => cur.reduce((n, sp) => n + sp.text.length, 0);
+  for (const w of words) {
+    const sep = cur.length ? 1 : 0;
+    if (cur.length && curLen() + sep + w.text.length > width) {
+      lines.push(cur);
+      cur = [];
+    }
+    const prefix = cur.length ? " " : "";
+    const last = cur[cur.length - 1];
+    if (last && sameStyle(last, w)) last.text += prefix + w.text;
+    else cur.push({ ...w, text: prefix + w.text });
+  }
+  if (cur.length) lines.push(cur);
+  return lines.length ? lines : [[]];
+};
+var EMOJI = {
+  ":rocket:": "\u{1F680}",
+  ":tada:": "\u{1F389}",
+  ":sparkles:": "\u2728",
+  ":+1:": "\u{1F44D}",
+  ":-1:": "\u{1F44E}",
+  ":white_check_mark:": "\u2705",
+  ":heavy_check_mark:": "\u2714\uFE0F",
+  ":x:": "\u274C",
+  ":warning:": "\u26A0\uFE0F",
+  ":rotating_light:": "\u{1F6A8}",
+  ":fire:": "\u{1F525}",
+  ":eyes:": "\u{1F440}",
+  ":bug:": "\u{1F41B}",
+  ":memo:": "\u{1F4DD}",
+  ":point_right:": "\u{1F449}"
+};
+var decodeShortcodes = (s) => s.replace(/:[a-z0-9_+-]+:/g, (m) => EMOJI[m] ?? m);
+var FILE_REF_RE = /^((?:[\w.@-]+\/)+[\w.@-]+\.[A-Za-z]\w*)(?::(\d+))?$/;
+var fileRef = (s) => {
+  const m = s.trim().match(FILE_REF_RE);
+  return m ? { path: m[1], line: m[2] ? Number(m[2]) : void 0 } : null;
+};
+var isSeparatorRow = (l) => l.includes("|") && /^[\s|:-]*-[\s|:-]*$/.test(l.trim());
+var tableCells = (l) => l.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim());
+var renderMarkdown = (raw, width, fileLink) => {
+  if (!raw || !raw.trim()) return [];
+  const normalised = decodeShortcodes(
+    htmlToText(decodeEntities(raw.replace(/\r\n?/g, "\n")))
+  );
+  const out = [];
+  const push = (text, style, indent = 0) => {
+    for (const w of wrap(text, width - indent))
+      out.push({ text: " ".repeat(indent) + w, ...style });
+  };
+  const emitSpans = (raw2, indent = 0, prefix = "") => {
+    const avail = Math.max(8, width - indent - prefix.length);
+    const wrapped = wrapSpans(parseInline(linkify(raw2)), avail);
+    wrapped.forEach((lineSpans, k) => {
+      const lead = k === 0 ? " ".repeat(indent) + prefix : " ".repeat(indent + prefix.length);
+      out.push({ text: "", spans: [{ text: lead }, ...lineSpans] });
+    });
+  };
+  const renderTable = (header, rows) => {
+    for (const row of rows) {
+      const first = stripInline(row[0] ?? "");
+      if (first) {
+        push(first, { color: colors.accent, bold: true });
+        if (fileLink) {
+          const ref = fileRef(first);
+          if (ref) push(fileLink(ref.path, ref.line), { dim: true }, 2);
+        }
+      }
+      for (let c = 1; c < row.length; c++) {
+        const val = stripInline(row[c] ?? "");
+        if (!val) continue;
+        const label = header.length > 2 && header[c] ? `${stripInline(header[c])}: ` : "";
+        push(label + val, {}, 2);
+      }
+      out.push({ text: "" });
+    }
+  };
+  const src = normalised.split("\n");
+  let inFence = false;
+  let i = 0;
+  while (i < src.length) {
+    const line = src[i].replace(/\s+$/, "");
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      i++;
+      continue;
+    }
+    if (inFence) {
+      out.push({ text: "  " + line, color: CODE_COLOR });
+      i++;
+      continue;
+    }
+    if (line.includes("|") && i + 1 < src.length && isSeparatorRow(src[i + 1])) {
+      const header = tableCells(line);
+      i += 2;
+      const rows = [];
+      while (i < src.length && src[i].includes("|") && src[i].trim()) {
+        rows.push(tableCells(src[i]));
+        i++;
+      }
+      renderTable(header, rows);
+      continue;
+    }
+    if (/^\s*([-*_])\1{2,}\s*$/.test(line)) {
+      out.push({ text: "\u2500".repeat(Math.min(width, 40)), dim: true });
+      i++;
+      continue;
+    }
+    const heading = line.match(/^\s*(#{1,6})\s+(.*)$/);
+    if (heading) {
+      push(stripInline(heading[2]), { color: colors.accent, bold: true });
+      i++;
+      continue;
+    }
+    if (fileLink) {
+      const ref = fileRef(line);
+      if (ref) {
+        push(ref.path + (ref.line ? `:${ref.line}` : ""), {
+          color: colors.accent,
+          bold: true
+        });
+        push(fileLink(ref.path, ref.line), { dim: true }, 2);
+        i++;
+        continue;
+      }
+    }
+    if (/^\s*>\s?/.test(line)) {
+      const quote = stripInline(line.replace(/^\s*>\s?/, ""));
+      for (const w of wrap(quote, width - 2))
+        out.push({ text: "\u2502 " + w, color: colors.info });
+      i++;
+      continue;
+    }
+    const bullet = line.match(/^(\s*)[-*+]\s+(.*)$/);
+    if (bullet) {
+      emitSpans(bullet[2], bullet[1].length, "\u2022 ");
+      i++;
+      continue;
+    }
+    if (!line.trim()) {
+      out.push({ text: "" });
+      i++;
+      continue;
+    }
+    emitSpans(line.trimStart(), line.length - line.trimStart().length);
+    i++;
+  }
+  const isBlank = (l) => !!l && !l.spans && l.text === "";
+  const collapsed = [];
+  for (const l of out) {
+    if (isBlank(l) && isBlank(collapsed[collapsed.length - 1])) continue;
+    collapsed.push(l);
+  }
+  while (isBlank(collapsed[collapsed.length - 1])) collapsed.pop();
+  return collapsed;
+};
+var clamp = (n, lo, hi) => Math.max(lo, Math.min(n, hi));
+var commentLines = ({ author, body }, width, fileLink, indent = 0) => {
+  const pad = " ".repeat(indent);
+  const fill = Math.max(3, width - indent - author.length - 4);
+  const lines = [
+    {
+      text: "",
+      spans: [
+        { text: pad + "\u2500\u2500 ", dim: true },
+        { text: author, color: colors.accent, bold: true },
+        { text: " " + "\u2500".repeat(fill), dim: true }
+      ]
+    }
+  ];
+  const bodyLines = renderMarkdown(body, width - indent, fileLink);
+  if (bodyLines.length === 0) lines.push({ text: pad + "(empty)", dim: true });
+  else
+    for (const l of bodyLines)
+      lines.push(
+        l.spans ? { ...l, spans: [{ text: pad }, ...l.spans] } : { ...l, text: pad + l.text }
+      );
+  lines.push({ text: "" });
+  return lines;
+};
+var CommentsPanel = ({
+  repo,
+  number,
+  data,
+  error,
+  reload,
+  onReplyingChange
+}) => {
+  const [showResolved, setShowResolved] = useState(true);
+  const [threadSel, setThreadSel] = useState(0);
+  const [replying, setReplying] = useState(false);
+  const [status, setStatus] = useState(null);
+  const { columns } = useWindowSize();
+  const width = Math.max(20, columns - 2);
+  const setReply = (v) => {
+    setReplying(v);
+    onReplyingChange?.(v);
+  };
+  const fileLink = (path, line) => `https://github.com/${repo}/blob/${data?.headRef ?? "HEAD"}/${path}` + (line ? `#L${line}` : "");
+  const conversation = data?.conversation ?? [];
+  const allThreads = data?.threads ?? [];
+  const threads = showResolved ? allThreads : allThreads.filter((t) => !t.isResolved && !t.isOutdated);
+  const hiddenThreads = allThreads.length - threads.length;
+  const sel = clamp(threadSel, 0, Math.max(0, threads.length - 1));
+  const selThread = threads[sel] ?? null;
+  const doResolveToggle = async () => {
+    if (!selThread) return;
+    const resolving = !selThread.isResolved;
+    setStatus(resolving ? "Resolving\u2026" : "Unresolving\u2026");
+    try {
+      if (resolving) await resolveThread(selThread.id);
+      else await unresolveThread(selThread.id);
+      setStatus(null);
+      reload();
+    } catch (e) {
+      setStatus(`Failed: ${e.message}`);
+    }
+  };
+  const submitReply = async (body) => {
+    setReply(false);
+    const trimmed = body.trim();
+    if (!selThread || !trimmed) return;
+    const root = selThread.comments[0];
+    if (!root?.databaseId) {
+      setStatus("Nothing to reply to on this thread");
+      return;
+    }
+    setStatus("Replying\u2026");
+    try {
+      await replyToThread({
+        repo,
+        pull: number,
+        inReplyTo: root.databaseId,
+        body: trimmed
+      });
+      setStatus(null);
+      reload();
+    } catch (e) {
+      setStatus(`Reply failed: ${e.message}`);
+    }
+  };
+  useInput(
+    (_input, key) => {
+      if (key.escape) setReply(false);
+    },
+    { isActive: replying }
+  );
+  useInput(
+    (input, key) => {
+      if (input === "R") return setShowResolved((s) => !s);
+      if (!threads.length) return;
+      if (key.upArrow || input === "k")
+        setThreadSel(() => clamp(sel - 1, 0, threads.length - 1));
+      else if (key.downArrow || input === "j")
+        setThreadSel(() => clamp(sel + 1, 0, threads.length - 1));
+      else if (input === "x") void doResolveToggle();
+      else if (input === "r" && selThread) setReply(true);
+    },
+    { isActive: !replying }
+  );
+  const lines = [];
+  let anchor = 0;
+  if (error) lines.push({ text: `Error: ${error}`, color: colors.error });
+  else if (!data) lines.push({ text: "Fetching comments\u2026", color: colors.info });
+  else {
+    if (status)
+      lines.push(
+        { text: status, color: colors.warning, bold: true },
+        { text: "" }
+      );
+    if (conversation.length === 0 && allThreads.length === 0)
+      lines.push({ text: "No comments on this PR.", dim: true });
+    if (conversation.length > 0) {
+      lines.push({
+        text: `Conversation (${conversation.length})`,
+        color: colors.info,
+        bold: true
+      });
+      lines.push({ text: "" });
+      for (const c of conversation)
+        lines.push(...commentLines(c, width, fileLink));
+    }
+    if (threads.length > 0) {
+      lines.push({
+        text: `Review threads (${threads.length})`,
+        color: colors.info,
+        bold: true
+      });
+      lines.push({ text: "" });
+      threads.forEach((t, i) => {
+        if (i === sel) anchor = lines.length;
+        const active = i === sel;
+        const loc = (t.path ?? "conversation") + (t.line ? `:${t.line}` : "");
+        const tags = (t.isResolved ? " [resolved]" : "") + (t.isOutdated ? " [outdated]" : "");
+        lines.push({
+          text: "",
+          spans: [
+            { text: active ? "\u276F " : "  ", color: colors.info, bold: true },
+            {
+              text: loc,
+              color: active ? colors.accent : colors.muted,
+              bold: active
+            },
+            ...tags ? [{ text: tags, dim: true }] : []
+          ]
+        });
+        for (const c of t.comments)
+          lines.push(...commentLines(c, width, fileLink, 2));
+      });
+    }
+    if (hiddenThreads > 0)
+      lines.push({
+        text: `${hiddenThreads} resolved/outdated hidden \u2014 R to show`,
+        dim: true
+      });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ScrollView, { lines, initialStart: anchor, isActive: !replying }),
+    replying ? /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        placeholder: `Reply to ${selThread?.path ?? "thread"}\u2026 (\u21B5 send \xB7 esc cancel)`,
+        onSubmit: submitReply
+      }
+    ) : null
+  ] });
+};
+var checkIcon = (c) => isPassCheck(c) ? ["\u2713", colors.success] : isFailCheck(c) ? ["\u2717", colors.error] : ["\xB7", colors.warning];
+var checkLabel = (c) => {
+  const name = c.context ?? c.name ?? "";
+  return c.workflowName ? `${c.workflowName} / ${name}` : name;
+};
+var checkUrl = (c) => c.detailsUrl ?? c.targetUrl ?? "";
+var runIdOf = (url) => url.match(/\/runs\/(\d+)/)?.[1] ?? null;
+var reviewIcon = (state) => state === "APPROVED" ? ["\u2713", colors.success] : state === "CHANGES_REQUESTED" ? ["~", colors.warning] : ["\xB7", colors.muted];
+var MERGE = {
+  CLEAN: ["ready", colors.success],
+  BLOCKED: ["blocked", colors.error],
+  DIRTY: ["has conflicts", colors.error],
+  UNSTABLE: ["unstable", colors.warning],
+  BEHIND: ["behind base", colors.warning]
+};
+var mergeText = (status) => MERGE[status] ?? ["checking\u2026", colors.warning];
+var Summary = ({
+  label,
+  icon,
+  parts
+}) => /* @__PURE__ */ jsxs(Box, { children: [
+  /* @__PURE__ */ jsx(Text, { children: "  " }),
+  /* @__PURE__ */ jsx(Text, { bold: true, children: label.padEnd(10) }),
+  /* @__PURE__ */ jsx(Text, { children: icon + "  " }),
+  parts.map(([text, color], i) => /* @__PURE__ */ jsxs(React2.Fragment, { children: [
+    i > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
+    /* @__PURE__ */ jsx(Text, { color, children: text })
+  ] }, text + i))
+] });
+var HealthPanel = ({
+  repo,
+  number,
+  data,
+  error,
+  reload,
+  onOpenCheck
+}) => {
+  const [cursor, setCursor] = useState(0);
+  const [note, setNote] = useState(null);
+  const [confirm, setConfirm] = useState(null);
+  const [busy, setBusy] = useState(false);
+  const checks = (data?.statusCheckRollup ?? []).filter(
+    (c) => (c.name ?? c.context)?.trim()
+  );
+  const reviewers = data ? Object.entries(
+    data.reviews.reduce(
+      (acc, r) => r.author?.login && r.author.login !== data.author?.login ? { ...acc, [r.author.login]: r.state } : acc,
+      {}
+    )
+  ) : [];
+  const focusCount = checks.length + reviewers.length;
+  const safeCursor = Math.min(cursor, Math.max(0, focusCount - 1));
+  const selected = safeCursor < checks.length ? checks[safeCursor] : void 0;
+  const selectedReviewer = safeCursor >= checks.length ? reviewers[safeCursor - checks.length] : void 0;
+  const flash = (msg) => {
+    setNote(msg);
+    setTimeout(() => setNote(null), 2500);
+  };
+  const act = async (msg, run) => {
+    setBusy(true);
+    setNote(`\u22EF ${msg}\u2026`);
+    try {
+      await run();
+      flash(`\u2713 ${msg}`);
+      reload();
+    } catch {
+      flash(`\u2717 ${msg} failed`);
+    } finally {
+      setBusy(false);
+    }
+  };
+  const retrigger = () => {
+    const failing = checks.find((c) => isFailCheck(c) && runIdOf(checkUrl(c)));
+    const runId = failing && runIdOf(checkUrl(failing));
+    if (!runId) return flash("No failed Actions run to retrigger");
+    void act("retrigger CI", () => rerunFailedRun(repo, runId));
+  };
+  useInput((input, key) => {
+    if (busy) return;
+    if (confirm === "merge") {
+      if (input === "y" || input === "Y")
+        void act("merge", () => mergePr(repo, number));
+      setConfirm(null);
+      return;
+    }
+    if (key.upArrow || input === "k") setCursor((c) => Math.max(0, c - 1));
+    if (key.downArrow || input === "j")
+      setCursor((c) => Math.min(Math.max(0, focusCount - 1), c + 1));
+    if (input === "r") return retrigger();
+    if (input === "m") return void setConfirm("merge");
+    if (key.return || input === "l") {
+      if (selected) onOpenCheck(selected);
+      else if (selectedReviewer) {
+        const login = selectedReviewer[0];
+        void act(
+          `re-request ${login}`,
+          () => reRequestReviewer(repo, number, login)
+        );
+      }
+    }
+  });
+  if (error) return /* @__PURE__ */ jsxs(Text, { color: colors.error, children: [
+    "Error: ",
+    error
+  ] });
+  if (!data) return /* @__PURE__ */ jsx(Text, { color: colors.info, children: "Fetching status\u2026" });
+  const reviewerMap = Object.fromEntries(reviewers);
+  const passed = checks.filter(isPassCheck).length;
+  const failed = checks.filter(isFailCheck).length;
+  const pending = checks.length - passed - failed;
+  const approved = Object.values(reviewerMap).filter(
+    (s) => s === "APPROVED"
+  ).length;
+  const changesReq = Object.values(reviewerMap).filter(
+    (s) => s === "CHANGES_REQUESTED"
+  ).length;
+  const checkParts = [[`${passed} passed`, colors.success]];
+  if (failed > 0) checkParts.push([`${failed} failed`, colors.error]);
+  if (pending > 0) checkParts.push([`${pending} pending`, colors.warning]);
+  const reviewParts = [
+    approved > 0 ? [`${approved} approved`, colors.success] : ["0 approved", "white"]
+  ];
+  if (changesReq > 0)
+    reviewParts.push([`${changesReq} changes requested`, colors.error]);
+  if (data.reviewDecision === "REVIEW_REQUIRED")
+    reviewParts.push(["review required", colors.warning]);
+  const [mText, mColor] = mergeText(data.mergeStateStatus);
+  const checksIcon = failed > 0 ? "\u2717" : pending > 0 ? "\xB7" : "\u2713";
+  const reviewsIcon = changesReq > 0 ? "\u2717" : approved > 0 ? "\u2713" : "\xB7";
+  const mergeIcon = data.mergeStateStatus === "CLEAN" ? "\u2713" : "\xB7";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Summary, { label: "Checks", icon: checksIcon, parts: checkParts }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: checks.map((c, i) => {
+      const [icon, color] = checkIcon(c);
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: colors.info, children: i === safeCursor ? "  \u276F " : "    " }),
+        /* @__PURE__ */ jsx(Text, { color, children: icon + " " }),
+        /* @__PURE__ */ jsx(Text, { bold: i === safeCursor, children: checkLabel(c) }),
+        i === safeCursor ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u21B5 open" }) : null
+      ] }, checkLabel(c) + i);
+    }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Summary, { label: "Reviews", icon: reviewsIcon, parts: reviewParts }) }),
+    reviewers.map(([login, state], j) => {
+      const [icon, color] = reviewIcon(state);
+      const active = safeCursor === checks.length + j;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: colors.info, children: active ? "  \u276F " : "    " }),
+        /* @__PURE__ */ jsx(Text, { color, children: icon + " " }),
+        /* @__PURE__ */ jsx(Text, { bold: active, children: login }),
+        active ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u21B5 re-request" }) : null
+      ] }, login);
+    }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Summary, { label: "Merge", icon: mergeIcon, parts: [[mText, mColor]] }) }),
+    confirm === "merge" ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: colors.warning, children: [
+      `  Merge #${number}?  `,
+      /* @__PURE__ */ jsx(Text, { color: colors.success, children: "y" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " confirm \xB7 any other key cancels" })
+    ] }) }) : note ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: colors.success, children: "  " + note }) }) : null
+  ] });
+};
+var healthDisplay = {
+  none: { glyph: " ", color: colors.muted },
+  draft: { glyph: "~", color: colors.muted },
+  "ci-fail": { glyph: "\u2717", color: colors.error },
+  conflict: { glyph: "!", color: colors.accent },
+  "changes-req": { glyph: "\xB1", color: colors.warning },
+  threads: { glyph: "\u25C6", color: colors.accent },
+  pending: { glyph: "*", color: colors.warning },
+  approved: { glyph: "\u2713", color: colors.success },
+  waiting: { glyph: "\xB7", color: colors.muted },
+  merged: { glyph: "\xBB", color: colors.muted },
+  closed: { glyph: "\xD7", color: colors.muted }
+};
+var healthGlyph = (h) => healthDisplay[h].glyph;
+var healthColor = (h) => healthDisplay[h].color;
+var healthLegend = [
+  ["approved", "Approved \xB7 ready to merge"],
+  ["pending", "Checks running"],
+  ["ci-fail", "CI failing"],
+  ["conflict", "Merge conflict"],
+  ["changes-req", "Changes requested"],
+  ["threads", "Open threads \xB7 your reply"],
+  ["waiting", "Awaiting review"],
+  ["draft", "Draft"],
+  ["merged", "Merged"],
+  ["closed", "Closed"]
+];
+
+export { CommentsPanel, HealthPanel, healthColor, healthDisplay, healthGlyph, healthLegend, renderMarkdown };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@kud/gh-ink",
+  "version": "0.1.0",
+  "description": "Ink components for rendering GitHub PR review comments and health — controlled, presentation-only, built on @kud/ink-ui and fed by @kud/gh.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "github",
+    "pull-request",
+    "ink",
+    "cli",
+    "react",
+    "terminal",
+    "components"
+  ],
+  "author": "Erwann Mest <m@kud.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kud/gh",
+    "directory": "packages/gh-ink"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "ink": ">=7",
+    "react": ">=19"
+  },
+  "dependencies": {
+    "@kud/gh": "0.1.0",
+    "@kud/ink-ui": "0.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.1",
+    "@types/react": "19.2.17",
+    "ink": "7.1.0",
+    "ink-testing-library": "4.0.0",
+    "react": "19.2.7",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.1.10"
+  }
+}