jira-dashboard 0.1.0

package/dist/cli.js

@@ -0,0 +1,1347 @@
+#!/usr/bin/env node
+
+// src/cli.tsx
+import { render } from "ink";
+import { createRequire } from "node:module";
+
+// src/app.tsx
+import { Box as Box7, Text as Text7, useApp, useInput } from "ink";
+import { useCallback, useEffect as useEffect4, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
+// src/components/IssueList.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/components/PanelFrame.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var PANEL_HEADER_ROWS = 2;
+var PANEL_CHROME_ROWS = 3;
+function PanelFrame({
+  title,
+  focused,
+  height,
+  width,
+  flexGrow,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      height,
+      width,
+      flexGrow,
+      flexShrink: width === void 0 ? 1 : 0,
+      borderStyle: "round",
+      borderColor: focused ? "cyan" : "gray",
+      paddingX: 1,
+      overflow: "hidden",
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: focused ? "cyan" : "white", children: title }),
+        children
+      ]
+    }
+  );
+}
+
+// src/components/PanelStatus.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinnerChar(frame) {
+  return FRAMES[frame % FRAMES.length] ?? FRAMES[0] ?? "\xB7";
+}
+function Spinner({ label, frame }) {
+  return /* @__PURE__ */ jsxs2(Text2, { color: "cyan", children: [
+    spinnerChar(frame),
+    " ",
+    /* @__PURE__ */ jsx2(Text2, { color: "gray", children: label })
+  ] });
+}
+function PanelError({ error }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: "red", wrap: "truncate-end", children: [
+      "\u2716 ",
+      error.message
+    ] }),
+    error.hints.slice(0, 3).map((hint, index) => /* @__PURE__ */ jsx2(Text2, { color: "gray", wrap: "truncate-end", children: hint }, index)),
+    /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "Press r to retry." })
+  ] });
+}
+
+// src/components/IssueList.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function statusColor(category) {
+  switch (category.toLowerCase()) {
+    case "in progress":
+      return "yellow";
+    case "done":
+      return "green";
+    default:
+      return "blue";
+  }
+}
+var KEY_WIDTH = 10;
+var STATUS_WIDTH = 14;
+function IssueList({
+  state,
+  focused,
+  height,
+  width,
+  selectedIndex,
+  offset,
+  spinnerFrame
+}) {
+  const issues = state.data ?? [];
+  const visibleRows = Math.max(1, height - PANEL_CHROME_ROWS);
+  const summaryWidth = Math.max(8, width - 4 - 2 - KEY_WIDTH - STATUS_WIDTH);
+  const base = issues.length > visibleRows ? `my open tickets (${selectedIndex + 1}/${issues.length})` : `my open tickets (${issues.length})`;
+  const title = state.loading && issues.length > 0 ? `${spinnerChar(spinnerFrame)} ${base}` : base;
+  return /* @__PURE__ */ jsx3(PanelFrame, { title, focused, height, flexGrow: 1, children: state.loading && issues.length === 0 ? /* @__PURE__ */ jsx3(Spinner, { label: "loading tickets\u2026", frame: spinnerFrame }) : state.error ? /* @__PURE__ */ jsx3(PanelError, { error: state.error }) : issues.length === 0 ? /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "No open tickets matched the query." }) : /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: issues.slice(offset, offset + visibleRows).map((issue, index) => {
+    const selected = offset + index === selectedIndex;
+    return /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Box3, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: selected ? "\u25B8 " : "  " }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: KEY_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { bold: selected, color: selected ? "cyan" : "white", wrap: "truncate-end", children: issue.key }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: STATUS_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color: statusColor(issue.statusCategory), wrap: "truncate-end", children: issue.status }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: summaryWidth, flexShrink: 1, children: /* @__PURE__ */ jsx3(
+        Text3,
+        {
+          color: selected ? "white" : "gray",
+          bold: selected,
+          inverse: selected && focused,
+          wrap: "truncate-end",
+          children: issue.summary
+        }
+      ) })
+    ] }, issue.key);
+  }) }) });
+}
+
+// src/components/IssuePreview.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var FIELD_LABEL_WIDTH = 11;
+function formatUpdated(value) {
+  if (!value) return "unknown";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toLocaleString();
+}
+function formatDay(key) {
+  const [, month = "01", day = "01"] = key.split("-");
+  return `${day} ${MONTHS[Number(month) - 1] ?? month}`;
+}
+function formatHours(hours) {
+  if (hours === 0) return "0h";
+  return hours < 1 ? `${Math.round(hours * 60)}m` : `${hours.toFixed(1)}h`;
+}
+function breadcrumbs(issue) {
+  const parts = [issue.projectName, issue.parent && `${issue.parent.key} ${issue.parent.summary}`].filter((part) => Boolean(part)).map((part) => part.trim());
+  return [...parts, issue.key].join(" \u203A ");
+}
+function wrapLines(text, width) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (line.length <= width) {
+      out.push(line);
+      continue;
+    }
+    let rest = line;
+    while (rest.length > width) {
+      const cut = rest.lastIndexOf(" ", width);
+      const at = cut > width / 2 ? cut : width;
+      out.push(rest.slice(0, at));
+      rest = rest.slice(at).trimStart();
+    }
+    out.push(rest);
+  }
+  return out;
+}
+function Field({ label, value, color }) {
+  return /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsx4(Box4, { width: FIELD_LABEL_WIDTH, flexShrink: 0, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", children: label }) }),
+    /* @__PURE__ */ jsx4(Text4, { color, wrap: "truncate-end", children: value })
+  ] });
+}
+function IssuePreview({
+  issue,
+  worklog,
+  worklogWindowDays,
+  focused,
+  height,
+  width,
+  offset
+}) {
+  if (!issue) {
+    return /* @__PURE__ */ jsx4(PanelFrame, { title: "preview", focused, height, flexGrow: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "Select a ticket above to preview it." }) });
+  }
+  const loggedHours = worklog.reduce((sum, entry) => sum + entry.hours, 0);
+  const loggedDates = worklog.map((entry) => `${formatDay(entry.date)} (${formatHours(entry.hours)})`);
+  const myWork = worklog.length > 0 ? `${formatHours(loggedHours)} \xB7 ${loggedDates.join(", ")}` : `nothing in the last ${worklogWindowDays} days`;
+  const total = issue.totalTimeSpentSeconds !== null && issue.totalTimeSpentSeconds > 0 ? `${formatHours(issue.totalTimeSpentSeconds / 3600)} logged by everyone` : null;
+  const fieldRows = 11 + (total ? 1 : 0);
+  const lines = wrapLines(issue.description || "(no description)", Math.max(20, width - 4));
+  const available = Math.max(1, height - PANEL_CHROME_ROWS - fieldRows);
+  const start = Math.min(offset, Math.max(0, lines.length - available));
+  const bodyRows = lines.length - start > available ? Math.max(1, available - 1) : available;
+  const visible = lines.slice(start, start + bodyRows);
+  const more = lines.length - start - visible.length;
+  return /* @__PURE__ */ jsxs4(
+    PanelFrame,
+    {
+      title: `${issue.key} \xB7 ${issue.url}`,
+      focused,
+      height,
+      flexGrow: 1,
+      children: [
+        /* @__PURE__ */ jsx4(Text4, { color: "gray", wrap: "truncate-end", children: breadcrumbs(issue) }),
+        /* @__PURE__ */ jsx4(Text4, { bold: true, wrap: "truncate-end", children: issue.summary }),
+        /* @__PURE__ */ jsx4(Field, { label: "type", value: issue.issueType || "\u2014" }),
+        /* @__PURE__ */ jsx4(Field, { label: "status", value: issue.status }),
+        /* @__PURE__ */ jsx4(Field, { label: "sprint", value: issue.sprints.length > 0 ? issue.sprints.join(", ") : "None" }),
+        /* @__PURE__ */ jsx4(Field, { label: "assignee", value: issue.assignee ?? "Unassigned" }),
+        /* @__PURE__ */ jsx4(Field, { label: "reporter", value: issue.reporter ?? "\u2014" }),
+        /* @__PURE__ */ jsx4(Field, { label: "priority", value: issue.priority ?? "\u2014" }),
+        /* @__PURE__ */ jsx4(Field, { label: "labels", value: issue.labels.length > 0 ? issue.labels.join(", ") : "\u2014" }),
+        /* @__PURE__ */ jsx4(
+          Field,
+          {
+            label: "your work",
+            value: myWork,
+            color: worklog.length > 0 ? "green" : void 0
+          }
+        ),
+        total && /* @__PURE__ */ jsx4(Field, { label: "total work", value: total }),
+        /* @__PURE__ */ jsx4(Field, { label: "updated", value: formatUpdated(issue.updated) }),
+        /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+          visible.map((line, index) => /* @__PURE__ */ jsx4(Text4, { color: "white", wrap: "truncate-end", children: line || " " }, start + index)),
+          more > 0 && /* @__PURE__ */ jsxs4(Text4, { color: "gray", children: [
+            "\u2026 ",
+            more,
+            " more lines (\u2193 to scroll)"
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/WorkChartPanel.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var HOURS_PER_BAR = 4;
+var LABEL_ROWS = 1;
+var MIN_BAR_ROWS = 2;
+var FULL_BLOCK = "\u2588";
+var HALF_BLOCK = "\u2584";
+var TRACE_BLOCK = "\u2581";
+var PANEL_SIDE_COLUMNS = 5;
+var MONTHS2 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function chartWidthFor(dayCount, barWidth) {
+  const bars = dayCount * barWidth + Math.max(0, dayCount - 1);
+  return bars + PANEL_SIDE_COLUMNS;
+}
+function WorkChartPanel({
+  days,
+  issueKey,
+  state,
+  focused,
+  height,
+  width,
+  spinnerFrame
+}) {
+  if (state.loading && days.length === 0) {
+    return /* @__PURE__ */ jsx5(PanelFrame, { title: "logged work", focused, height, width, children: /* @__PURE__ */ jsx5(Spinner, { label: "loading\u2026", frame: spinnerFrame }) });
+  }
+  if (state.error) {
+    return /* @__PURE__ */ jsx5(PanelFrame, { title: "logged work", focused, height, width, children: /* @__PURE__ */ jsx5(PanelError, { error: state.error }) });
+  }
+  if (!issueKey || days.length === 0) {
+    return /* @__PURE__ */ jsx5(PanelFrame, { title: "logged work", focused, height, width, children: /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "Select a ticket to see your work on it." }) });
+  }
+  const barWidth = chartWidthFor(days.length, 2) <= width ? 2 : 1;
+  const tallest = days.reduce((max, day) => Math.max(max, day.hours), 0);
+  const roomForRows = Math.max(1, height - PANEL_CHROME_ROWS - LABEL_ROWS);
+  const barRows = Math.min(roomForRows, Math.max(MIN_BAR_ROWS, Math.ceil(tallest / HOURS_PER_BAR)));
+  const rows = Array.from({ length: barRows }, (_, index) => barRows - 1 - index);
+  const total = days.reduce((sum, day) => sum + day.hours, 0);
+  const clipped = tallest / HOURS_PER_BAR > barRows;
+  const title = `${issueKey} \xB7 ${total.toFixed(1)}h over ${days.length}d \xB7 ${HOURS_PER_BAR}h = 1 bar` + (clipped ? ` \xB7 peak ${tallest.toFixed(1)}h` : "");
+  return /* @__PURE__ */ jsx5(PanelFrame, { title, focused, height, width, children: /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", flexGrow: 1, justifyContent: "flex-end", children: [
+    total === 0 && /* @__PURE__ */ jsx5(Text5, { color: "gray", children: "no time logged in this window" }),
+    total > 0 && rows.map((rowFromBottom) => /* @__PURE__ */ jsx5(Text5, { children: days.map((day, index) => /* @__PURE__ */ jsxs5(Text5, { children: [
+      index > 0 ? " " : "",
+      /* @__PURE__ */ jsx5(Text5, { color: barColor(day), children: glyphFor(day.hours, rowFromBottom).repeat(barWidth) })
+    ] }, day.date)) }, rowFromBottom)),
+    barWidth >= 2 ? /* @__PURE__ */ jsx5(Text5, { children: days.map((day, index) => /* @__PURE__ */ jsxs5(Text5, { children: [
+      index > 0 ? " " : "",
+      /* @__PURE__ */ jsx5(Text5, { color: isToday(day.date) ? "cyan" : "gray", bold: isToday(day.date), children: dayOfMonth(day.date) })
+    ] }, day.date)) }) : (
+      // One column per bar leaves no room for a label per day; a date range
+      // reads better than a row of single digits.
+      /* @__PURE__ */ jsx5(Text5, { color: "gray", wrap: "truncate-end", children: rangeLabel(days) })
+    )
+  ] }) });
+}
+function glyphFor(hours, rowFromBottom) {
+  const rowsFilled = hours / HOURS_PER_BAR - rowFromBottom;
+  if (rowsFilled >= 1) return FULL_BLOCK;
+  if (rowsFilled >= 0.5) return HALF_BLOCK;
+  if (rowsFilled > 0) return TRACE_BLOCK;
+  return " ";
+}
+function barColor(day) {
+  if (day.hours === 0) return "gray";
+  return isWeekend(day.date) ? "blue" : "green";
+}
+function parseDate(key) {
+  const [year = "1970", month = "01", day = "01"] = key.split("-");
+  return new Date(Number(year), Number(month) - 1, Number(day));
+}
+function isWeekend(key) {
+  const weekday = parseDate(key).getDay();
+  return weekday === 0 || weekday === 6;
+}
+function isToday(key) {
+  return parseDate(key).toDateString() === (/* @__PURE__ */ new Date()).toDateString();
+}
+function dayOfMonth(key) {
+  const [, , day = "01"] = key.split("-");
+  return day.padStart(2, "0");
+}
+function rangeLabel(days) {
+  const format = (key) => {
+    const [, month = "01", day = "01"] = key.split("-");
+    return `${day} ${MONTHS2[Number(month) - 1] ?? month}`;
+  };
+  const first = days[0]?.date;
+  const last = days[days.length - 1]?.date;
+  return first && last ? `${format(first)} \u2192 ${format(last)}` : "";
+}
+
+// src/components/WorklogPanel.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTHS3 = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function formatDate(key) {
+  const [year = "1970", month = "01", day = "01"] = key.split("-");
+  const date = new Date(Number(year), Number(month) - 1, Number(day));
+  return `${WEEKDAYS[date.getDay()]} ${day} ${MONTHS3[date.getMonth()]}`;
+}
+function isWeekend2(key) {
+  const [year = "1970", month = "01", day = "01"] = key.split("-");
+  const weekday = new Date(Number(year), Number(month) - 1, Number(day)).getDay();
+  return weekday === 0 || weekday === 6;
+}
+function hoursColor(hours, weekend) {
+  if (hours === 0) return weekend ? "gray" : "red";
+  if (hours < 6) return "yellow";
+  return "green";
+}
+function WorklogPanel({
+  state,
+  focused,
+  height,
+  width,
+  offset,
+  spinnerFrame
+}) {
+  const days = state.data?.days ?? [];
+  const visibleRows = Math.max(1, height - PANEL_CHROME_ROWS);
+  const total = days.reduce((sum, day) => sum + day.hours, 0);
+  const keysWidth = Math.max(6, width - 4 - 12 - 7);
+  const base = days.length > 0 ? `last ${days.length} days \xB7 ${total.toFixed(1)}h total` : `last ${days.length || 14} days`;
+  const title = state.loading && days.length > 0 ? `${spinnerChar(spinnerFrame)} ${base}` : base;
+  return /* @__PURE__ */ jsx6(PanelFrame, { title, focused, height, width, children: state.loading && days.length === 0 ? /* @__PURE__ */ jsx6(Spinner, { label: "loading worklogs\u2026", frame: spinnerFrame }) : state.error ? /* @__PURE__ */ jsx6(PanelError, { error: state.error }) : /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: days.slice(offset, offset + visibleRows).map((day) => {
+    const weekend = isWeekend2(day.date);
+    const keys = day.issueKeys.length > 0 ? day.issueKeys.join(", ") : "\u2014";
+    return /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Box6, { width: 12, flexShrink: 0, children: /* @__PURE__ */ jsx6(Text6, { color: weekend ? "gray" : "white", children: formatDate(day.date) }) }),
+      /* @__PURE__ */ jsx6(Box6, { width: 7, flexShrink: 0, children: /* @__PURE__ */ jsx6(Text6, { color: hoursColor(day.hours, weekend), children: `${day.hours.toFixed(1)}h`.padStart(6) }) }),
+      /* @__PURE__ */ jsx6(Box6, { width: keysWidth, flexShrink: 1, children: /* @__PURE__ */ jsx6(Text6, { color: "gray", wrap: "truncate-end", children: keys }) })
+    ] }, day.date);
+  }) }) });
+}
+
+// src/data/adf.ts
+function adfToText(doc) {
+  if (typeof doc === "string") return doc;
+  if (typeof doc !== "object" || doc === null) return "";
+  return renderNodes(doc.content ?? [], 0).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function renderNodes(nodes, depth) {
+  return nodes.flatMap((node) => renderNode(node, depth));
+}
+function renderNode(node, depth) {
+  const indent = "  ".repeat(depth);
+  switch (node.type) {
+    case "text":
+      return [applyMarks(node)];
+    case "hardBreak":
+      return [""];
+    case "paragraph":
+      return [indent + inline(node.content ?? []), ""];
+    case "heading": {
+      const level = Number(node.attrs?.["level"] ?? 1);
+      return [`${"#".repeat(Math.min(level, 6))} ${inline(node.content ?? [])}`, ""];
+    }
+    case "bulletList":
+      return [...listItems(node, depth, () => "\u2022"), ""];
+    case "orderedList":
+      return [...listItems(node, depth, (i) => `${i + 1}.`), ""];
+    case "codeBlock": {
+      const lang = typeof node.attrs?.["language"] === "string" ? node.attrs["language"] : "";
+      const body = inline(node.content ?? []).split("\n");
+      return [`${indent}\`\`\`${lang}`, ...body.map((l) => indent + l), `${indent}\`\`\``, ""];
+    }
+    case "blockquote":
+      return [...renderNodes(node.content ?? [], depth).map((l) => `${indent}> ${l}`), ""];
+    case "rule":
+      return ["\u2500\u2500\u2500", ""];
+    case "mediaSingle":
+    case "mediaGroup":
+      return [`${indent}[attachment]`];
+    case "table":
+      return [...renderNodes(node.content ?? [], depth), ""];
+    case "tableRow":
+      return [indent + (node.content ?? []).map((cell) => inline(cell.content ?? [])).join(" | ")];
+    default:
+      return node.content ? renderNodes(node.content, depth) : [];
+  }
+}
+function listItems(node, depth, bullet) {
+  const indent = "  ".repeat(depth);
+  return (node.content ?? []).flatMap((item, index) => {
+    const lines = renderNodes(item.content ?? [], depth + 1).filter((l) => l.trim() !== "");
+    const [first = "", ...rest] = lines;
+    return [`${indent}${bullet(index)} ${first.trim()}`, ...rest];
+  });
+}
+function inline(nodes) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return applyMarks(node);
+      case "hardBreak":
+        return "\n";
+      case "mention":
+        return attr(node, "text") || "@unknown";
+      case "emoji":
+        return attr(node, "text") || attr(node, "shortName");
+      case "inlineCard":
+        return attr(node, "url");
+      case "date":
+        return attr(node, "timestamp");
+      case "status":
+        return `[${attr(node, "text")}]`;
+      default:
+        return node.content ? inline(node.content) : "";
+    }
+  }).join("");
+}
+function attr(node, name) {
+  const value = node.attrs?.[name];
+  return typeof value === "string" || typeof value === "number" ? String(value) : "";
+}
+function applyMarks(node) {
+  const text = node.text ?? "";
+  const link = node.marks?.find((m) => m.type === "link");
+  const href = link?.attrs?.["href"];
+  return typeof href === "string" && href !== text ? `${text} (${href})` : text;
+}
+
+// src/data/sprintField.ts
+var SPRINT_SCHEMA = "com.pyxis.greenhopper.jira:gh-sprint";
+var cached;
+async function resolveSprintFieldId(client) {
+  if (cached !== void 0) return cached;
+  try {
+    const fields = await client.get("/rest/api/3/field");
+    cached = fields.find((field) => field.schema?.custom === SPRINT_SCHEMA)?.id ?? null;
+  } catch {
+    cached = null;
+  }
+  return cached;
+}
+function sprintNames(value) {
+  if (!Array.isArray(value)) return [];
+  const sprints = value.map((entry) => {
+    if (typeof entry === "string") return parseLegacySprint(entry);
+    if (typeof entry === "object" && entry !== null) return entry;
+    return null;
+  }).filter((sprint) => Boolean(sprint?.name));
+  const rank = (state) => {
+    switch (state?.toLowerCase()) {
+      case "active":
+        return 0;
+      case "future":
+        return 1;
+      default:
+        return 2;
+    }
+  };
+  return sprints.sort((a, b) => rank(a.state) - rank(b.state)).map(
+    (sprint) => sprint.state && sprint.state.toLowerCase() !== "active" ? `${sprint.name ?? ""} (${sprint.state.toLowerCase()})` : sprint.name ?? ""
+  );
+}
+function parseLegacySprint(raw) {
+  const name = /\bname=([^,\]]+)/.exec(raw)?.[1];
+  const state = /\bstate=([^,\]]+)/.exec(raw)?.[1];
+  return name ? { name, state } : null;
+}
+
+// src/data/issues.ts
+var MAX_ISSUES = 100;
+var FIELDS = [
+  "summary",
+  "status",
+  "priority",
+  "assignee",
+  "reporter",
+  "labels",
+  "updated",
+  "description",
+  "issuetype",
+  "parent",
+  "project",
+  "aggregatetimespent",
+  "timespent"
+];
+async function fetchOpenIssues(client, config) {
+  const sprintFieldId = await resolveSprintFieldId(client);
+  const response = await client.post("/rest/api/3/search/jql", {
+    jql: config.issuesJql,
+    maxResults: MAX_ISSUES,
+    fields: sprintFieldId ? [...FIELDS, sprintFieldId] : FIELDS
+  });
+  return (response.issues ?? []).map((raw) => toIssue(raw, client, sprintFieldId));
+}
+function toIssue(raw, client, sprintFieldId) {
+  const fields = raw.fields ?? {};
+  return {
+    key: raw.key,
+    summary: fields.summary ?? "(no summary)",
+    status: fields.status?.name ?? "Unknown",
+    statusCategory: fields.status?.statusCategory?.name ?? "",
+    issueType: fields.issuetype?.name ?? "",
+    priority: fields.priority?.name ?? null,
+    assignee: fields.assignee?.displayName ?? null,
+    reporter: fields.reporter?.displayName ?? null,
+    labels: fields.labels ?? [],
+    updated: fields.updated ?? null,
+    description: adfToText(fields.description),
+    url: client.issueUrl(raw.key),
+    projectName: fields.project?.name ?? fields.project?.key ?? null,
+    parent: fields.parent?.key ? {
+      key: fields.parent.key,
+      summary: fields.parent.fields?.summary ?? "",
+      issueType: fields.parent.fields?.issuetype?.name ?? ""
+    } : null,
+    totalTimeSpentSeconds: fields.aggregatetimespent ?? fields.timespent ?? null,
+    sprints: sprintFieldId ? sprintNames(fields[sprintFieldId]) : []
+  };
+}
+
+// src/data/worklogs.ts
+var WORKLOG_PAGE_SIZE = 1e3;
+var CONCURRENCY = 5;
+function localDateKey(date) {
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${date.getFullYear()}-${month}-${day}`;
+}
+function startOfDay(daysAgo) {
+  const date = /* @__PURE__ */ new Date();
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() - daysAgo);
+  return date;
+}
+async function fetchWorklogDays(client, config, me) {
+  const days = config.worklogDays;
+  const windowStart = startOfDay(days - 1);
+  const search = await client.post("/rest/api/3/search/jql", {
+    jql: `worklogAuthor = currentUser() AND worklogDate >= -${days}d ORDER BY updated DESC`,
+    maxResults: 200,
+    fields: ["summary"]
+  });
+  const keys = (search.issues ?? []).map((issue) => issue.key);
+  const buckets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < days; i += 1) {
+    buckets.set(localDateKey(startOfDay(i)), { seconds: 0, keys: /* @__PURE__ */ new Set() });
+  }
+  const perIssue = /* @__PURE__ */ new Map();
+  const startedAfter = String(windowStart.getTime());
+  await forEachLimited(keys, CONCURRENCY, async (key) => {
+    const response = await client.get(`/rest/api/3/issue/${key}/worklog`, {
+      startedAfter,
+      maxResults: String(WORKLOG_PAGE_SIZE)
+    });
+    for (const entry of response.worklogs ?? []) {
+      if (entry.author?.accountId !== me.accountId || !entry.started) continue;
+      const started = new Date(entry.started);
+      if (Number.isNaN(started.getTime()) || started < windowStart) continue;
+      const date = localDateKey(started);
+      const bucket = buckets.get(date);
+      if (!bucket) continue;
+      const seconds = entry.timeSpentSeconds ?? 0;
+      bucket.seconds += seconds;
+      bucket.keys.add(key);
+      const issueDays = perIssue.get(key) ?? /* @__PURE__ */ new Map();
+      issueDays.set(date, (issueDays.get(date) ?? 0) + seconds);
+      perIssue.set(key, issueDays);
+    }
+  });
+  const byIssue = {};
+  for (const [key, issueDays] of perIssue) {
+    byIssue[key] = Array.from(issueDays.entries()).map(([date, seconds]) => ({ date, hours: seconds / 3600 })).sort((a, b) => a.date.localeCompare(b.date));
+  }
+  return {
+    days: Array.from(buckets.entries()).map(([date, { seconds, keys: issueKeys }]) => ({
+      date,
+      hours: seconds / 3600,
+      issueKeys: Array.from(issueKeys).sort(compareIssueKeys)
+    })).sort((a, b) => a.date.localeCompare(b.date)),
+    byIssue,
+    windowDays: days
+  };
+}
+function compareIssueKeys(a, b) {
+  const [aProject = a, aNumber = "0"] = a.split("-");
+  const [bProject = b, bNumber = "0"] = b.split("-");
+  return aProject === bProject ? Number(aNumber) - Number(bNumber) : aProject.localeCompare(bProject);
+}
+async function forEachLimited(items, limit, worker) {
+  let cursor = 0;
+  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (cursor < items.length) {
+      const item = items[cursor];
+      cursor += 1;
+      if (item !== void 0) await worker(item);
+    }
+  });
+  await Promise.all(runners);
+}
+
+// src/hooks/useHomeEndKeys.ts
+import { useEffect, useRef } from "react";
+import { useStdin } from "ink";
+var ESC = String.fromCharCode(27);
+var HOME_SEQUENCES = [`${ESC}[H`, `${ESC}[1~`, `${ESC}[7~`, `${ESC}OH`];
+var END_SEQUENCES = [`${ESC}[F`, `${ESC}[4~`, `${ESC}[8~`, `${ESC}OF`];
+function useHomeEndKeys(onHome, onEnd) {
+  const { stdin, isRawModeSupported } = useStdin();
+  const handlers = useRef({ onHome, onEnd });
+  handlers.current = { onHome, onEnd };
+  useEffect(() => {
+    if (!isRawModeSupported) return;
+    const onData = (data) => {
+      const text = typeof data === "string" ? data : data.toString("utf8");
+      if (HOME_SEQUENCES.some((sequence) => text.includes(sequence))) {
+        handlers.current.onHome();
+      } else if (END_SEQUENCES.some((sequence) => text.includes(sequence))) {
+        handlers.current.onEnd();
+      }
+    };
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
+    };
+  }, [stdin, isRawModeSupported]);
+}
+
+// src/hooks/useMouse.ts
+import { useEffect as useEffect2 } from "react";
+import { useStdin as useStdin2, useStdout } from "ink";
+var ESC2 = String.fromCharCode(27);
+var MOUSE_ON = `${ESC2}[?1000h${ESC2}[?1006h`;
+var MOUSE_OFF = `${ESC2}[?1006l${ESC2}[?1000l`;
+var SGR_MOUSE = new RegExp(`${ESC2}\\[<(\\d+);(\\d+);(\\d+)([Mm])`, "g");
+var SGR_PREFIX = `${ESC2}[<`;
+function isMouseSequence(input) {
+  return input.includes(SGR_PREFIX);
+}
+function useMouse(onEvent) {
+  const { stdin, isRawModeSupported } = useStdin2();
+  const { stdout } = useStdout();
+  useEffect2(() => {
+    if (!isRawModeSupported) return;
+    stdout.write(MOUSE_ON);
+    const disable = () => {
+      stdout.write(MOUSE_OFF);
+    };
+    process.on("exit", disable);
+    const onData = (data) => {
+      const text = typeof data === "string" ? data : data.toString("utf8");
+      SGR_MOUSE.lastIndex = 0;
+      for (let match = SGR_MOUSE.exec(text); match; match = SGR_MOUSE.exec(text)) {
+        const [, rawButton = "0", rawColumn = "1", rawRow = "1", kind] = match;
+        if (kind !== "M") continue;
+        const button = Number(rawButton);
+        const column = Number(rawColumn) - 1;
+        const row = Number(rawRow) - 1;
+        if (button & 64) {
+          onEvent({ type: "wheel", direction: (button & 1) === 0 ? "up" : "down", column, row });
+        } else if ((button & 3) === 0) {
+          onEvent({ type: "press", column, row });
+        }
+      }
+    };
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
+      process.off("exit", disable);
+      disable();
+    };
+  }, [stdin, stdout, isRawModeSupported, onEvent]);
+}
+
+// src/hooks/useTerminalSize.ts
+import { useEffect as useEffect3, useState } from "react";
+import { useStdout as useStdout2 } from "ink";
+function useTerminalSize() {
+  const { stdout } = useStdout2();
+  const [size, setSize] = useState(() => ({
+    columns: stdout.columns || 80,
+    rows: stdout.rows || 24
+  }));
+  useEffect3(() => {
+    const onResize = () => {
+      setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+    };
+    stdout.on("resize", onResize);
+    onResize();
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return size;
+}
+
+// src/openUrl.ts
+import { spawn } from "node:child_process";
+function opener() {
+  switch (process.platform) {
+    case "darwin":
+      return { command: "open", args: [] };
+    case "win32":
+      return { command: "cmd", args: ["/c", "start", ""] };
+    default:
+      return { command: "xdg-open", args: [] };
+  }
+}
+async function openUrl(url) {
+  const { command, args } = opener();
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args, url], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.once("error", (cause) => {
+      reject(
+        new Error(
+          cause.code === "ENOENT" ? `${command} is not installed, so the browser could not be opened.` : `${command} failed: ${cause.message}`
+        )
+      );
+    });
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+// src/types.ts
+var JiraError = class extends Error {
+  hints;
+  constructor(message, hints = []) {
+    super(message);
+    this.name = "JiraError";
+    this.hints = hints;
+  }
+};
+
+// src/app.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var PANEL_ORDER = ["worklog", "issues", "preview"];
+var MIN_TOP_HEIGHT = 6;
+var MIN_LEFT_WIDTH = 34;
+var SPINNER_INTERVAL_MS = 90;
+var NOTICE_TIMEOUT_MS = 3e3;
+var pending = (previous) => ({
+  data: previous?.data ?? null,
+  loading: true,
+  error: null
+});
+function toJiraError(cause) {
+  if (cause instanceof JiraError) return cause;
+  return new JiraError(cause instanceof Error ? cause.message : String(cause));
+}
+function App({ config, client, me }) {
+  const { exit } = useApp();
+  const { columns, rows } = useTerminalSize();
+  const [worklogs, setWorklogs] = useState2(() => pending());
+  const [issues, setIssues] = useState2(() => pending());
+  const [focus, setFocus] = useState2("issues");
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [issueOffset, setIssueOffset] = useState2(0);
+  const [worklogOffset, setWorklogOffset] = useState2(0);
+  const [previewOffset, setPreviewOffset] = useState2(0);
+  const [spinnerFrame, setSpinnerFrame] = useState2(0);
+  const [reloadToken, setReloadToken] = useState2(0);
+  const [notice, setNotice] = useState2(null);
+  const topHeight = Math.max(MIN_TOP_HEIGHT, Math.floor((rows - 1) / 2));
+  const bottomHeight = Math.max(MIN_TOP_HEIGHT, rows - 1 - topHeight);
+  const leftWidth = Math.max(MIN_LEFT_WIDTH, Math.min(52, Math.floor(columns * 0.42)));
+  const issueRows = Math.max(1, topHeight - 3);
+  const worklogRows = issueRows;
+  const dayCount = worklogs.data?.days.length ?? config.worklogDays;
+  const chartWidth = Math.min(
+    Math.floor(columns / 2),
+    Math.max(chartWidthFor(dayCount, 1), Math.min(chartWidthFor(dayCount, 2), columns - 40))
+  );
+  useEffect4(() => {
+    let cancelled = false;
+    setIssues(pending);
+    fetchOpenIssues(client, config).then((data) => {
+      if (!cancelled) setIssues({ data, loading: false, error: null });
+    }).catch((cause) => {
+      if (!cancelled) setIssues({ data: null, loading: false, error: toJiraError(cause) });
+    });
+    setWorklogs(pending);
+    fetchWorklogDays(client, config, me).then((data) => {
+      if (!cancelled) setWorklogs({ data, loading: false, error: null });
+    }).catch((cause) => {
+      if (!cancelled) setWorklogs({ data: null, loading: false, error: toJiraError(cause) });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, config, me, reloadToken]);
+  const loading = worklogs.loading || issues.loading;
+  useEffect4(() => {
+    if (!loading) return;
+    const timer = setInterval(() => {
+      setSpinnerFrame((frame) => frame + 1);
+    }, SPINNER_INTERVAL_MS);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [loading]);
+  const issueList = issues.data ?? [];
+  const selected = issueList[selectedIndex] ?? null;
+  useEffect4(() => {
+    setSelectedIndex((index) => Math.min(index, Math.max(0, issueList.length - 1)));
+  }, [issueList.length]);
+  useEffect4(() => {
+    setWorklogOffset(Math.max(0, (worklogs.data?.days.length ?? 0) - worklogRows));
+  }, [worklogs.data, worklogRows]);
+  useEffect4(() => {
+    setPreviewOffset(0);
+  }, [selected?.key]);
+  const selectIndex = useCallback(
+    (next) => {
+      if (issueList.length === 0) return;
+      const clamped = Math.max(0, Math.min(next, issueList.length - 1));
+      setSelectedIndex(clamped);
+      setIssueOffset((offset) => {
+        if (clamped < offset) return clamped;
+        if (clamped >= offset + issueRows) return clamped - issueRows + 1;
+        return offset;
+      });
+    },
+    [issueList.length, issueRows]
+  );
+  const scrollPanel = useCallback(
+    (panel, delta) => {
+      switch (panel) {
+        case "issues":
+          selectIndex(selectedIndex + delta);
+          break;
+        case "worklog":
+          setWorklogOffset(
+            (offset) => Math.max(0, Math.min(offset + delta, (worklogs.data?.days.length ?? 0) - worklogRows))
+          );
+          break;
+        case "preview":
+          setPreviewOffset((offset) => Math.max(0, offset + delta));
+          break;
+      }
+    },
+    [selectIndex, selectedIndex, worklogs.data?.days.length, worklogRows]
+  );
+  const chartDays = useMemo(() => {
+    const summary = worklogs.data;
+    if (!summary || !selected) return [];
+    const hoursByDate = new Map(
+      (summary.byIssue[selected.key] ?? []).map((entry) => [entry.date, entry.hours])
+    );
+    return summary.days.map((day) => ({
+      date: day.date,
+      hours: hoursByDate.get(day.date) ?? 0,
+      issueKeys: []
+    }));
+  }, [worklogs.data, selected]);
+  useEffect4(() => {
+    if (!notice) return;
+    const timer = setTimeout(() => {
+      setNotice(null);
+    }, NOTICE_TIMEOUT_MS);
+    return () => {
+      clearTimeout(timer);
+    };
+  }, [notice]);
+  const openSelected = useCallback(() => {
+    if (!selected) return;
+    openUrl(selected.url).then(() => {
+      setNotice({ text: `opened ${selected.key} in your browser`, error: false });
+    }).catch((cause) => {
+      setNotice({
+        text: cause instanceof Error ? cause.message : String(cause),
+        error: true
+      });
+    });
+  }, [selected]);
+  const goToStart = useCallback(() => {
+    switch (focus) {
+      case "issues":
+        selectIndex(0);
+        break;
+      case "worklog":
+        setWorklogOffset(0);
+        break;
+      case "preview":
+        setPreviewOffset(0);
+        break;
+    }
+  }, [focus, selectIndex]);
+  const goToEnd = useCallback(() => {
+    switch (focus) {
+      case "issues":
+        selectIndex(issueList.length - 1);
+        break;
+      case "worklog":
+        setWorklogOffset(Math.max(0, (worklogs.data?.days.length ?? 0) - worklogRows));
+        break;
+      case "preview":
+        break;
+    }
+  }, [focus, issueList.length, selectIndex, worklogs.data?.days.length, worklogRows]);
+  useHomeEndKeys(goToStart, goToEnd);
+  const layout = useRef2({ leftWidth, topHeight, issueRows, issueOffset });
+  layout.current = { leftWidth, topHeight, issueRows, issueOffset };
+  const onMouse = useCallback(
+    (event) => {
+      const { leftWidth: left, topHeight: top, issueRows: visible, issueOffset: offset } = layout.current;
+      const panel = event.row >= top ? "preview" : event.column >= left ? "issues" : "worklog";
+      if (event.type === "wheel") {
+        setFocus(panel);
+        scrollPanel(panel, event.direction === "up" ? -1 : 1);
+        return;
+      }
+      setFocus(panel);
+      if (panel !== "issues") return;
+      const row = event.row - PANEL_HEADER_ROWS;
+      if (row >= 0 && row < visible) selectIndex(offset + row);
+    },
+    [scrollPanel, selectIndex]
+  );
+  useMouse(onMouse);
+  useInput((input, key) => {
+    if (isMouseSequence(input)) return;
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (input === "r") {
+      setReloadToken((token) => token + 1);
+      return;
+    }
+    if (key.return && focus === "issues") {
+      openSelected();
+      return;
+    }
+    if (key.tab) {
+      const step = key.shift ? -1 : 1;
+      setFocus((current) => {
+        const next = (PANEL_ORDER.indexOf(current) + step + PANEL_ORDER.length) % PANEL_ORDER.length;
+        return PANEL_ORDER[next] ?? "issues";
+      });
+      return;
+    }
+    if (key.downArrow) scrollPanel(focus, 1);
+    else if (key.upArrow) scrollPanel(focus, -1);
+    else if (key.pageDown) scrollPanel(focus, issueRows);
+    else if (key.pageUp) scrollPanel(focus, -issueRows);
+    else if (/^j+$/.test(input)) scrollPanel(focus, input.length);
+    else if (/^k+$/.test(input)) scrollPanel(focus, -input.length);
+    else if (input === "g") scrollPanel(focus, -Number.MAX_SAFE_INTEGER);
+    else if (input === "G") selectIndex(issueList.length - 1);
+  });
+  const hint = useMemo(
+    () => focus === "issues" ? "\u2191\u2193/jk move \xB7 home/end first/last \xB7 enter open \xB7 tab panel \xB7 r reload \xB7 q quit" : "\u2191\u2193/jk scroll \xB7 home/end top/bottom \xB7 tab panel \xB7 r reload \xB7 q quit",
+    [focus]
+  );
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", width: columns, height: rows, children: [
+    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", height: topHeight, flexShrink: 0, children: [
+      /* @__PURE__ */ jsx7(
+        WorklogPanel,
+        {
+          state: worklogs,
+          focused: focus === "worklog",
+          height: topHeight,
+          width: leftWidth,
+          offset: worklogOffset,
+          spinnerFrame
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        IssueList,
+        {
+          state: issues,
+          focused: focus === "issues",
+          height: topHeight,
+          width: columns - leftWidth,
+          selectedIndex,
+          offset: issueOffset,
+          spinnerFrame
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { flexDirection: "row", height: bottomHeight, flexShrink: 0, children: [
+      /* @__PURE__ */ jsx7(
+        WorkChartPanel,
+        {
+          days: chartDays,
+          issueKey: selected?.key ?? null,
+          state: worklogs,
+          focused: false,
+          height: bottomHeight,
+          width: chartWidth,
+          spinnerFrame
+        }
+      ),
+      /* @__PURE__ */ jsx7(
+        IssuePreview,
+        {
+          issue: selected,
+          worklog: selected && worklogs.data?.byIssue[selected.key] || [],
+          worklogWindowDays: worklogs.data?.windowDays ?? config.worklogDays,
+          focused: focus === "preview",
+          height: bottomHeight,
+          width: columns - chartWidth,
+          offset: previewOffset
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { height: 1, flexShrink: 0, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: "gray", wrap: "truncate-end", children: [
+        " ",
+        hint
+      ] }),
+      notice ? /* @__PURE__ */ jsxs7(Text7, { color: notice.error ? "red" : "green", wrap: "truncate-end", children: [
+        notice.error ? "\u2716" : "\u2713",
+        " ",
+        notice.text,
+        " "
+      ] }) : loading ? /* @__PURE__ */ jsxs7(Text7, { color: "cyan", wrap: "truncate-end", children: [
+        spinnerChar(spinnerFrame),
+        " loading\u2026",
+        " "
+      ] }) : /* @__PURE__ */ jsxs7(Text7, { color: "gray", wrap: "truncate-end", children: [
+        me.displayName,
+        " "
+      ] })
+    ] })
+  ] });
+}
+
+// src/data/client.ts
+var REQUEST_TIMEOUT_MS = 2e4;
+var JiraClient = class {
+  baseUrl;
+  authHeader;
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.authHeader = `Basic ${Buffer.from(`${config.email}:${config.apiToken}`).toString("base64")}`;
+  }
+  /** Browser URL for an issue, for display in the preview panel. */
+  issueUrl(key) {
+    return `${this.baseUrl}/browse/${key}`;
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(params ?? {})) {
+      url.searchParams.set(key, value);
+    }
+    return this.request("GET", url.toString());
+  }
+  async post(path, body) {
+    return this.request("POST", `${this.baseUrl}${path}`, body);
+  }
+  async request(method, url, body) {
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers: {
+          Authorization: this.authHeader,
+          Accept: "application/json",
+          ...body === void 0 ? {} : { "Content-Type": "application/json" }
+        },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+    } catch (cause) {
+      throw asNetworkError(cause, this.baseUrl);
+    }
+    if (!response.ok) {
+      throw await asHttpError(response, url);
+    }
+    return await response.json();
+  }
+  /** Identify the caller; doubles as the credential check at startup. */
+  async myself() {
+    const me = await this.get("/rest/api/3/myself");
+    return { accountId: me.accountId, displayName: me.displayName };
+  }
+};
+function asNetworkError(cause, baseUrl) {
+  const name = cause instanceof Error ? cause.name : "";
+  if (name === "TimeoutError" || name === "AbortError") {
+    return new JiraError("Jira did not respond within 20s.", [
+      "Check your network connection or VPN, then press r to retry."
+    ]);
+  }
+  return new JiraError(`Could not reach ${baseUrl}.`, [
+    cause instanceof Error ? cause.message : String(cause),
+    "Verify JIRA_BASE_URL points at your Atlassian site."
+  ]);
+}
+async function asHttpError(response, url) {
+  const detail = await readErrorDetail(response);
+  switch (response.status) {
+    case 401:
+      return new JiraError("Jira rejected your credentials (401).", [
+        "JIRA_EMAIL must be your Atlassian account email and JIRA_API_TOKEN an API token",
+        "(not your password). Tokens: https://id.atlassian.com/manage-profile/security/api-tokens"
+      ]);
+    case 403:
+      return new JiraError("Jira denied access (403).", [
+        detail || "Your account may lack permission for this project."
+      ]);
+    case 400:
+      return new JiraError("Jira rejected the request (400).", [
+        detail || "The JQL query may be invalid for this site.",
+        'Adjust "issuesJql" in your config file.'
+      ]);
+    case 429:
+      return new JiraError("Jira rate-limited this client (429).", [
+        "Wait a moment, then press r to retry."
+      ]);
+    default:
+      return new JiraError(`Jira returned ${response.status} for ${new URL(url).pathname}.`, [
+        detail || response.statusText
+      ]);
+  }
+}
+async function readErrorDetail(response) {
+  try {
+    const body = await response.json();
+    if (typeof body !== "object" || body === null) return "";
+    const { errorMessages, errors } = body;
+    const parts = [];
+    if (Array.isArray(errorMessages)) parts.push(...errorMessages.map(String));
+    if (errors && typeof errors === "object") {
+      parts.push(...Object.entries(errors).map(([k, v]) => `${k}: ${String(v)}`));
+    }
+    return parts.join("; ");
+  } catch {
+    return "";
+  }
+}
+
+// src/data/config.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CONFIG_PATH = join(
+  process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config"),
+  "jira-dashboard",
+  "config.json"
+);
+var TOKEN_URL = "https://id.atlassian.com/manage-profile/security/api-tokens";
+var DEFAULT_ISSUES_JQL = [
+  "assignee = currentUser()",
+  "AND statusCategory != Done",
+  'AND status NOT IN ("Cancelled", "Closed", "Backlog")',
+  "ORDER BY updated DESC"
+].join(" ");
+var DEFAULT_WORKLOG_DAYS = 14;
+function readConfigFile() {
+  let raw;
+  try {
+    raw = readFileSync(CONFIG_PATH, "utf8");
+  } catch {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("expected a JSON object");
+    }
+    return parsed;
+  } catch (cause) {
+    throw new JiraError(`Config file at ${CONFIG_PATH} is not valid JSON.`, [
+      cause instanceof Error ? cause.message : String(cause),
+      "Fix the file, or delete it and use environment variables instead."
+    ]);
+  }
+}
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(trimmed)) {
+    throw new JiraError(`JIRA_BASE_URL must start with https:// (got "${trimmed}")`, [
+      "Example: https://your-team.atlassian.net"
+    ]);
+  }
+  return trimmed;
+}
+function loadConfig() {
+  const file = readConfigFile();
+  const baseUrl = process.env["JIRA_BASE_URL"] ?? file.baseUrl;
+  const email = process.env["JIRA_EMAIL"] ?? file.email;
+  const apiToken = process.env["JIRA_API_TOKEN"] ?? file.apiToken;
+  const missing = [];
+  if (!baseUrl) missing.push("JIRA_BASE_URL");
+  if (!email) missing.push("JIRA_EMAIL");
+  if (!apiToken) missing.push("JIRA_API_TOKEN");
+  if (missing.length > 0 || !baseUrl || !email || !apiToken) {
+    throw new JiraError(`Missing Jira credentials: ${missing.join(", ")}`, [
+      "Set them in your shell:",
+      '  export JIRA_BASE_URL="https://your-team.atlassian.net"',
+      '  export JIRA_EMAIL="you@example.com"',
+      '  export JIRA_API_TOKEN="..."',
+      "",
+      `Or write them to ${CONFIG_PATH}:`,
+      '  { "baseUrl": "...", "email": "...", "apiToken": "..." }',
+      "",
+      `Create an API token at ${TOKEN_URL}`
+    ]);
+  }
+  return {
+    baseUrl: normalizeBaseUrl(baseUrl),
+    email: email.trim(),
+    apiToken: apiToken.trim(),
+    issuesJql: file.issuesJql?.trim() || DEFAULT_ISSUES_JQL,
+    worklogDays: typeof file.worklogDays === "number" && file.worklogDays > 0 ? Math.floor(file.worklogDays) : DEFAULT_WORKLOG_DAYS
+  };
+}
+
+// src/cli.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var ESC3 = String.fromCharCode(27);
+var ALT_SCREEN_ON = `${ESC3}[?1049h`;
+var ALT_SCREEN_OFF = `${ESC3}[?1049l`;
+var CURSOR_SHOW = `${ESC3}[?25h`;
+var HELP = `
+  jdb \u2014 Jira dashboard in your terminal
+
+  Usage
+    $ jdb
+
+  Options
+    -h, --help       Show this help
+    -v, --version    Show the version
+
+  Configuration (environment variables take precedence)
+    JIRA_BASE_URL    https://your-team.atlassian.net
+    JIRA_EMAIL       your Atlassian account email
+    JIRA_API_TOKEN   https://id.atlassian.com/manage-profile/security/api-tokens
+
+    Or ${CONFIG_PATH}:
+      {
+        "baseUrl": "https://your-team.atlassian.net",
+        "email": "you@example.com",
+        "apiToken": "...",
+        "issuesJql": ${JSON.stringify(DEFAULT_ISSUES_JQL)},
+        "worklogDays": 14
+      }
+
+  Keys
+    \u2191 \u2193 / j k    move within the focused panel
+    home / end   jump to the first / last item
+    enter        open the selected ticket in your browser
+    tab          cycle panels (worklogs \u2192 tickets \u2192 preview)
+    click/wheel  select and scroll
+    r            reload
+    q / esc      quit
+`;
+function reportError(error) {
+  const jiraError = error instanceof JiraError ? error : null;
+  process.stderr.write(`
+jdb: ${jiraError?.message ?? String(error)}
+`);
+  for (const hint of jiraError?.hints ?? []) {
+    process.stderr.write(`  ${hint}
+`);
+  }
+  process.stderr.write("\n");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    process.stdout.write(`${HELP}
+`);
+    return 0;
+  }
+  if (args.includes("-v") || args.includes("--version")) {
+    process.stdout.write(`${version}
+`);
+    return 0;
+  }
+  if (!process.stdout.isTTY) {
+    process.stderr.write("jdb: needs an interactive terminal (stdout is not a TTY).\n");
+    return 1;
+  }
+  const config = loadConfig();
+  const client = new JiraClient(config);
+  const me = await client.myself();
+  let restored = false;
+  const restoreScreen = () => {
+    if (restored) return;
+    restored = true;
+    process.stdout.write(ALT_SCREEN_OFF + CURSOR_SHOW);
+  };
+  process.stdout.write(ALT_SCREEN_ON);
+  process.on("exit", restoreScreen);
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.once(signal, () => {
+      restoreScreen();
+      process.exit(signal === "SIGINT" ? 130 : 143);
+    });
+  }
+  try {
+    const { waitUntilExit } = render(/* @__PURE__ */ jsx8(App, { config, client, me }), {
+      exitOnCtrlC: true
+    });
+    await waitUntilExit();
+  } finally {
+    restoreScreen();
+  }
+  return 0;
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  reportError(error);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map