@delorenj/pjangler 1.5.18 → 1.5.21

package/dist/crank/tui.js

@@ -0,0 +1,447 @@
+// src/crank/tui.tsx
+import { Box as Box3, Text as Text3, useInput as useInput2, useWindowSize } from "ink";
+import { useCallback, useState as useState2 } from "react";
+
+// src/tui/RadioGroup.tsx
+import { Box, Text, useInput } from "ink";
+
+// src/utils/style.ts
+var env = process.env;
+function detectColor() {
+  if ("NO_COLOR" in env && env.NO_COLOR !== "") return false;
+  const force = env.FORCE_COLOR;
+  if (force === "0" || force === "false") return false;
+  if (force !== void 0 && force !== "") return true;
+  if (env.TERM === "dumb") return false;
+  return Boolean(process.stdout.isTTY);
+}
+var colorEnabled = detectColor();
+function sgr(open, close) {
+  const prefix = `\x1B[${open}m`;
+  const suffix = `\x1B[${close}m`;
+  return (value) => colorEnabled ? `${prefix}${value}${suffix}` : String(value);
+}
+var bold = sgr(1, 22);
+var dim = sgr(2, 22);
+var italic = sgr(3, 23);
+var underline = sgr(4, 24);
+var red = sgr(31, 39);
+var green = sgr(32, 39);
+var yellow = sgr(33, 39);
+var blue = sgr(34, 39);
+var magenta = sgr(35, 39);
+var cyan = sgr(36, 39);
+var gray = sgr(90, 39);
+var glyph = {
+  pass: "\u2714",
+  fail: "\u2716",
+  warn: "\u26A0",
+  skip: "\u25CB",
+  info: "\u2139",
+  arrow: "\u21B3",
+  bullet: "\u2022",
+  dot: "\xB7",
+  add: "+",
+  chevron: "\u25B8",
+  pointer: "\u276F"
+};
+var STATUS_STYLES = {
+  pass: { glyph: glyph.pass, color: green, label: "pass" },
+  fail: { glyph: glyph.fail, color: red, label: "fail" },
+  warn: { glyph: glyph.warn, color: yellow, label: "warn" },
+  skip: { glyph: glyph.skip, color: gray, label: "skip" },
+  applied: { glyph: glyph.pass, color: green, label: "applied" },
+  noop: { glyph: glyph.skip, color: gray, label: "noop" },
+  blocked: { glyph: glyph.fail, color: red, label: "blocked" },
+  skipped: { glyph: glyph.skip, color: gray, label: "skipped" },
+  partial: { glyph: glyph.warn, color: yellow, label: "partial" }
+};
+
+// src/tui/theme.ts
+var INK_COLOR = {
+  accent: "cyan",
+  ok: "green",
+  warn: "yellow",
+  fail: "red",
+  muted: "gray"
+};
+function themeColor(role) {
+  return colorEnabled ? INK_COLOR[role] : void 0;
+}
+var marks = {
+  radioOn: "(\u2022)",
+  radioOff: "( )",
+  dotOn: "\u25CF",
+  dotOff: "\u25CB",
+  pointer: "\u276F",
+  dot: "\xB7"
+};
+
+// src/tui/RadioGroup.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function RadioGroup({
+  options,
+  value,
+  onChange,
+  orientation = "horizontal",
+  isActive = true,
+  numberKeys = true
+}) {
+  const index = Math.max(0, options.findIndex((option) => option.value === value));
+  useInput(
+    (input, key) => {
+      const prev = orientation === "horizontal" ? key.leftArrow : key.upArrow;
+      const next = orientation === "horizontal" ? key.rightArrow : key.downArrow;
+      if (prev && index > 0) onChange(options[index - 1].value);
+      else if (next && index < options.length - 1) onChange(options[index + 1].value);
+      else if (numberKeys && /^[1-9]$/.test(input)) {
+        const picked = options[Number(input) - 1];
+        if (picked) onChange(picked.value);
+      }
+    },
+    { isActive }
+  );
+  return /* @__PURE__ */ jsx(Box, { flexDirection: orientation === "horizontal" ? "row" : "column", columnGap: 2, children: options.map((option, i) => {
+    const selected = option.value === value;
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: selected ? themeColor("accent") : void 0, bold: selected, children: [
+        selected ? marks.radioOn : marks.radioOff,
+        " ",
+        option.label
+      ] }),
+      option.badge ? /* @__PURE__ */ jsxs(Text, { color: themeColor("muted"), children: [
+        " ",
+        option.badge
+      ] }) : null,
+      numberKeys ? /* @__PURE__ */ jsxs(Text, { color: themeColor("muted"), children: [
+        " ",
+        i + 1
+      ] }) : null
+    ] }, option.value);
+  }) });
+}
+
+// src/tui/KeyHints.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function KeyHints({ hints }) {
+  return /* @__PURE__ */ jsx2(Box2, { flexWrap: "wrap", columnGap: 1, children: hints.map((hint, i) => /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: themeColor("accent"), children: hint.keys }),
+    /* @__PURE__ */ jsxs2(Text2, { color: themeColor("muted"), children: [
+      " ",
+      hint.label,
+      i < hints.length - 1 ? ` ${marks.dot}` : ""
+    ] })
+  ] }, hint.keys)) });
+}
+
+// src/tui/run.tsx
+import { render } from "ink";
+
+// src/tui/load.ts
+var TuiUnavailableError = class extends Error {
+};
+function isInteractive(streams = {}) {
+  const stdin = streams.stdin ?? process.stdin;
+  const stdout = streams.stdout ?? process.stdout;
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+
+// src/tui/run.tsx
+async function runInk(build, options = {}) {
+  if (!isInteractive({ stdin: options.stdin, stdout: options.stdout })) {
+    throw new TuiUnavailableError("this needs an interactive terminal (stdin and stdout must be a TTY)");
+  }
+  let result;
+  let instance;
+  let finished = false;
+  const finish = (value) => {
+    if (finished) return;
+    finished = true;
+    result = value;
+    instance?.unmount();
+  };
+  instance = render(build(finish), {
+    ...options.ink,
+    stdin: options.stdin,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    alternateScreen: options.alternateScreen ?? false,
+    exitOnCtrlC: true
+  });
+  if (finished) instance.unmount();
+  await instance.waitUntilExit();
+  return result;
+}
+
+// src/tui/hooks.ts
+import { useEffect, useState } from "react";
+function useNow(ms = 1e3, clock = Date.now) {
+  const [now, setNow] = useState(clock);
+  useEffect(() => {
+    const timer = setInterval(() => setNow(clock()), ms);
+    return () => clearInterval(timer);
+  }, [ms, clock]);
+  return now;
+}
+function useInterval(tick, ms) {
+  useEffect(() => {
+    const timer = setInterval(tick, ms);
+    return () => clearInterval(timer);
+  }, [tick, ms]);
+}
+
+// src/utils/version.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var PJANGLER_VERSION = (() => {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 4; i++) {
+      try {
+        const raw = readFileSync(join(dir, "package.json"), "utf8");
+        return JSON.parse(raw).version ?? "0.0.0";
+      } catch {
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+})();
+
+// src/crank/index.ts
+var ZCRANK_INTERVALS = ["5m", "1h", "6h", "1d"];
+var INTERVAL_SECONDS = { "5m": 300, "1h": 3600, "6h": 21600, "1d": 86400 };
+var ZCRANK_CRON_SECONDS = 300;
+var ZCRANK_GRACE_SECONDS = 300;
+function nextRunMs(input) {
+  if (!input.enabled) return void 0;
+  const tick = ZCRANK_CRON_SECONDS * 1e3;
+  let earliest = input.nowMs;
+  if (INTERVAL_SECONDS[input.interval] > ZCRANK_CRON_SECONDS && input.lastRun !== void 0) {
+    earliest = Math.max(earliest, input.lastRun + (INTERVAL_SECONDS[input.interval] - ZCRANK_GRACE_SECONDS) * 1e3);
+  }
+  return Math.ceil(earliest / tick) * tick;
+}
+function formatDuration(totalSeconds) {
+  const s = Math.max(0, Math.round(totalSeconds));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ${String(s % 60).padStart(2, "0")}s`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h ${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m`;
+  return `${Math.floor(s / 86400)}d ${Math.floor(s % 86400 / 3600)}h`;
+}
+function formatAge(thenMs, nowMs) {
+  const s = Math.max(0, Math.round((nowMs - thenMs) / 1e3));
+  if (s < 60) return `${s}s ago`;
+  return `${formatDuration(s)} ago`;
+}
+function renderLogRow(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const ts = typeof parsed.ts === "string" ? parsed.ts : "";
+    const state = typeof parsed.state === "string" ? parsed.state : "?";
+    const action = typeof parsed.action === "string" ? parsed.action : "";
+    return `${ts}  ${state.padEnd(12)}${action}`;
+  } catch {
+    return null;
+  }
+}
+
+// src/crank/tui.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function intervalOptions(global) {
+  return ZCRANK_INTERVALS.map((value) => ({ value, label: value, badge: value === global ? "global" : void 0 }));
+}
+function inheritanceNote(inherited, global) {
+  return inherited ? `inherits global (${global})` : `project override (global is ${global})`;
+}
+function IntervalPicker({ slug, tab, effective, inherited, global, onDone }) {
+  const [value, setValue] = useState2(effective);
+  useInput2((input, key) => {
+    if (key.return) onDone(value);
+    else if (key.escape || input === "q") onDone(null);
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("accent"), bold: true, children: "crank interval" }),
+      /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        " ",
+        marks.dot,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: slug }),
+      /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        " ",
+        marks.pointer,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: tab })
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+      "How often may the crank beat touch this tab? Now: ",
+      inheritanceNote(inherited, global),
+      "."
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { marginY: 1, children: /* @__PURE__ */ jsx3(RadioGroup, { options: intervalOptions(global), value, onChange: setValue }) }),
+    /* @__PURE__ */ jsx3(KeyHints, { hints: [{ keys: "\u2190/\u2192 1-4", label: "choose" }, { keys: "enter", label: "enable" }, { keys: "esc q", label: "abort" }] })
+  ] });
+}
+async function pickInterval(props, run = {}) {
+  const choice = await runInk((finish) => /* @__PURE__ */ jsx3(IntervalPicker, { ...props, onDone: finish }), run);
+  return choice ?? null;
+}
+function clockTime(ms) {
+  const d = new Date(ms);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function describeMatch(view) {
+  const { resolution } = view;
+  if (resolution.storedAsIs) return `no live tab or key matches "${view.name}" - stored under the project name`;
+  const how = resolution.source.replace("-", " ");
+  return resolution.liveTab ? `live tab "${resolution.liveTab}" via ${how} "${resolution.matched}"` : `stored key via ${how} "${resolution.matched}"`;
+}
+function CrankDashboard({ controller, refreshMs = 5e3, clock = Date.now, onQuit }) {
+  const [view, setView] = useState2(() => controller.read(clock()));
+  const [error, setError] = useState2();
+  const [flash, setFlash] = useState2();
+  const now = useNow(1e3, clock);
+  const { rows } = useWindowSize();
+  const refresh = useCallback(() => {
+    try {
+      setView(controller.read(clock()));
+      setError(void 0);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    }
+  }, [controller, clock]);
+  useInterval(refresh, refreshMs);
+  const act = (label, fn) => {
+    try {
+      const note = fn();
+      setFlash(note || label);
+      setError(void 0);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    }
+    refresh();
+  };
+  const snap = view.snapshot;
+  const isOn = snap.enabled === true;
+  const toggle = () => act(isOn ? "crank OFF" : "crank ON", () => {
+    if (isOn) {
+      controller.disable();
+      return;
+    }
+    const result = controller.enable();
+    return result.renamed.length ? `crank ON (renamed ${result.renamed.map((r) => `${r.from} -> ${r.to}`).join(", ")})` : void 0;
+  });
+  useInput2((input, key) => {
+    if (key.escape || input === "q") onQuit();
+    else if (input === " " || input === "t") toggle();
+    else if (input === "r") act(`interval reset to global (${snap.global})`, () => controller.setInterval(void 0));
+  });
+  const onInterval = (interval) => act(`interval ${interval}`, () => controller.setInterval(interval));
+  const next = nextRunMs({ enabled: isOn, interval: snap.interval, lastRun: snap.lastRunMs, nowMs: now });
+  const logRows = Math.max(3, (rows || 24) - 19);
+  const tail = snap.log.slice(-logRows);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("accent"), bold: true, children: "pj crank" }),
+      /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        " ",
+        marks.dot,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: view.slug }),
+      /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        " (",
+        view.name,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), wrap: "truncate-end", children: [
+      "tab ",
+      /* @__PURE__ */ jsx3(Text3, { color: void 0, bold: true, children: snap.tab }),
+      "  ",
+      describeMatch(view)
+    ] }),
+    view.resolution.storedAsIs ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("warn"), children: `no tab matched yet - toggling stores "${snap.tab}" as-is` }) : null,
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Crank      " }),
+      isOn ? /* @__PURE__ */ jsxs3(Text3, { color: themeColor("ok"), bold: true, children: [
+        marks.dotOn,
+        " ON"
+      ] }) : /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        marks.dotOff,
+        " OFF"
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Interval   " }),
+      /* @__PURE__ */ jsx3(RadioGroup, { options: intervalOptions(snap.global), value: snap.interval, onChange: onInterval })
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+      "           ",
+      inheritanceNote(snap.inherited, snap.global)
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Next run   " }),
+      next === void 0 ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "off" }) : /* @__PURE__ */ jsxs3(Text3, { children: [
+        next <= now ? "now" : `in ${formatDuration((next - now) / 1e3)}`,
+        " ",
+        /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+          "(",
+          clockTime(next),
+          ")"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "Last runs" }),
+      snap.beats.length === 0 ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: "  none yet" }) : snap.beats.map((beat, i) => /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate-end", children: [
+        "  ",
+        formatAge(beat.tsMs, now).padEnd(10),
+        " ",
+        beat.state.padEnd(9),
+        " ",
+        /* @__PURE__ */ jsx3(Text3, { color: themeColor("muted"), children: beat.action })
+      ] }, `${beat.ts}-${i}`))
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: themeColor("muted"), children: [
+        "Log (",
+        snap.log.length,
+        " rows)"
+      ] }),
+      tail.map((raw, i) => /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate-end", color: themeColor("muted"), children: [
+        "  ",
+        renderLogRow(raw) ?? raw
+      ] }, i))
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, flexDirection: "column", children: [
+      error ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("fail"), children: `${marks.dot} ${error}` }) : flash ? /* @__PURE__ */ jsx3(Text3, { color: themeColor("ok"), children: `${marks.dot} ${flash}` }) : /* @__PURE__ */ jsx3(Text3, { children: " " }),
+      /* @__PURE__ */ jsx3(KeyHints, { hints: [
+        { keys: "space t", label: "toggle" },
+        { keys: "\u2190/\u2192 1-4", label: "interval" },
+        { keys: "r", label: "reset to global" },
+        { keys: "q esc", label: "quit" }
+      ] })
+    ] })
+  ] });
+}
+async function runCrankDashboard(controller, run = {}) {
+  const { refreshMs, ...ink } = run;
+  await runInk((finish) => /* @__PURE__ */ jsx3(CrankDashboard, { controller, refreshMs, onQuit: () => finish() }), { alternateScreen: true, ...ink });
+}
+export {
+  CrankDashboard,
+  IntervalPicker,
+  intervalOptions,
+  pickInterval,
+  runCrankDashboard
+};
+//# sourceMappingURL=tui.js.map