@litfamily/litclaude 1.0.21 → 1.0.23

package/plugins/litclaude/lib/mod/layout.mjs

@@ -0,0 +1,53 @@
+// Terminal cell arithmetic for the LIT band. The band is laid out by LitClaude itself rather than
+// left to wrap, so every width here is in terminal cells: Hangul, CJK and emoji take two, combining
+// marks and variation selectors none. Pure functions only; the mod runs them inside Claude Code and
+// the tests run them under Node.
+
+const ZERO_WIDTH = /[\p{Mn}\p{Me}​-‏︀-️]/u;
+const EMOJI = /\p{Emoji_Presentation}/u;
+
+const isWide = (code) =>
+  (code >= 0x1100 && code <= 0x115f)
+  || (code >= 0x2e80 && code <= 0x303e)
+  || (code >= 0x3041 && code <= 0x33ff)
+  || (code >= 0x3400 && code <= 0x4dbf)
+  || (code >= 0x4e00 && code <= 0x9fff)
+  || (code >= 0xa000 && code <= 0xa4cf)
+  || (code >= 0xa960 && code <= 0xa97f)
+  || (code >= 0xac00 && code <= 0xd7a3)
+  || (code >= 0xf900 && code <= 0xfaff)
+  || (code >= 0xfe30 && code <= 0xfe4f)
+  || (code >= 0xff00 && code <= 0xff60)
+  || (code >= 0xffe0 && code <= 0xffe6)
+  || (code >= 0x20000 && code <= 0x3fffd);
+
+export const charWidth = (ch) => {
+  const code = ch.codePointAt(0) ?? 0;
+  if (code < 0x20 || (code >= 0x7f && code < 0xa0)) return 0;
+  if (ZERO_WIDTH.test(ch)) return 0;
+  if (EMOJI.test(ch) || isWide(code)) return 2;
+  return 1;
+};
+
+export const textWidth = (text) => {
+  let width = 0;
+  for (const ch of String(text)) width += charWidth(ch);
+  return width;
+};
+
+export const truncateToWidth = (text, cells, ellipsis = "…") => {
+  const value = String(text);
+  if (cells <= 0) return "";
+  if (textWidth(value) <= cells) return value;
+  const room = cells - textWidth(ellipsis);
+  if (room <= 0) return ellipsis.slice(0, cells);
+  let out = "";
+  let width = 0;
+  for (const ch of value) {
+    const w = charWidth(ch);
+    if (width + w > room) break;
+    out += ch;
+    width += w;
+  }
+  return `${out.trimEnd()}${ellipsis}`;
+};

package/plugins/litclaude/lib/mod/motion.mjs

@@ -0,0 +1,101 @@
+// Motion vocabulary for the LIT band: easing curves, the approved timings, animated channels and
+// colour mixing. Entrances pop with ease-out-back, fills and colour changes run ease-in-out, exits
+// accelerate with ease-in. A channel is plain data ({ from, to, at, dur }) sampled against the
+// surface's frame clock, so the band module keeps no timers beyond the frames it is animating.
+
+export const EASE = Object.freeze({
+  linear: (x) => x,
+  outCubic: (x) => 1 - (1 - x) ** 3,
+  inCubic: (x) => x ** 3,
+  inOutCubic: (x) => (x < 0.5 ? 4 * x ** 3 : 1 - (-2 * x + 2) ** 3 / 2),
+  outBack: (x) => 1 + 2.7 * (x - 1) ** 3 + 1.7 * (x - 1) ** 2,
+});
+
+// Milliseconds. The user approved this faster set in the motion preview; `completion` bounds the
+// whole finish moment (shimmer plus embers) and `frame` is the redraw interval while animating.
+export const TIMINGS = Object.freeze({
+  stagger: 60,
+  entry: 160,
+  fill: 300,
+  flash: 400,
+  noticeIn: 220,
+  noticeOut: 150,
+  noticeHold: 4000,
+  crossfade: 140,
+  shimmer: 400,
+  embers: 1000,
+  completion: 1200,
+  exit: 150,
+  frame: 33,
+});
+
+// full: the approved motion. subtle: no overshoot, no shimmer or embers, three quarters the time.
+// off: every duration is zero, so the band draws its final frame and never starts a frame timer.
+export const motionProfile = (mode) => {
+  if (mode === "off") {
+    return { mode, duration: () => 0, enterEase: EASE.linear, noticeEase: EASE.linear, shimmer: false, embers: false };
+  }
+  if (mode === "subtle") {
+    return { mode, duration: (ms) => Math.round(ms * 0.75), enterEase: EASE.outCubic, noticeEase: EASE.outCubic, shimmer: false, embers: false };
+  }
+  return { mode: "full", duration: (ms) => ms, enterEase: EASE.outBack, noticeEase: EASE.outBack, shimmer: true, embers: true };
+};
+
+export const clamp01 = (x) => (x <= 0 ? 0 : x >= 1 ? 1 : x);
+
+// Progress through a window that opens at `at` and lasts `dur`; a zero-length window is complete.
+export const phase = (now, at, dur) => (dur <= 0 ? (now >= at ? 1 : 0) : clamp01((now - at) / dur));
+
+export const still = (value) => ({ from: value, to: value, at: 0, dur: 0 });
+
+export const sample = (channel, now, ease = EASE.inOutCubic) =>
+  channel.from + (channel.to - channel.from) * ease(phase(now, channel.at, channel.dur));
+
+export const retarget = (channel, to, now, dur) => {
+  if (channel.to === to) return channel;
+  const from = sample(channel, now);
+  return from === to ? still(to) : { from, to, at: now, dur };
+};
+
+export const isSettled = (channel, now) => channel.from === channel.to || now >= channel.at + channel.dur;
+
+const hexToRgb = (hex) => {
+  const value = String(hex).replace(/^#/u, "");
+  return [0, 2, 4].map((i) => Number.parseInt(value.slice(i, i + 2), 16) || 0);
+};
+
+export const lerpColor = (a, b, t) => {
+  const from = hexToRgb(a);
+  const to = hexToRgb(b);
+  const k = clamp01(t);
+  return `#${from.map((v, i) => Math.round(v + (to[i] - v) * k).toString(16).padStart(2, "0")).join("")}`;
+};
+
+export const gradientAt = (stops, position) => {
+  if (stops.length === 1) return lerpColor(stops[0], stops[0], 0);
+  const scaled = clamp01(position) * (stops.length - 1);
+  const index = Math.min(stops.length - 2, Math.floor(scaled));
+  return lerpColor(stops[index], stops[index + 1], scaled - index);
+};
+
+export const BAR_STOPS = Object.freeze(["#ff2d95", "#00e5ff"]);
+export const BAR_TRACK = "#30363d";
+
+// A bar of `cells` cells filled to `fraction`. Whole cells take the pink-to-cyan gradient; the
+// cell the fill is inside fades from the track colour to its gradient colour by how far it is
+// filled, so the bar moves continuously in colour rather than in eighth-cell glyphs (a glyph-only
+// change is not repainted inside a Claude Code Client region). While the bar moves, `glow` (0 to 1)
+// brightens that leading cell. Every filled or fading cell is a solid `█`; the rest is the track.
+export const barCells = (fraction, cells, glow = 0) => {
+  const filled = clamp01(fraction) * cells;
+  const full = Math.floor(filled + 1e-9);
+  const part = full < cells ? filled - full : 0;
+  const head = part > 1e-6 ? full : full - 1;
+  const gradient = (i) => gradientAt(BAR_STOPS, cells <= 1 ? 0 : i / (cells - 1));
+  const shine = (i, color) => (i === head && glow > 0 ? lerpColor(color, "#ffffff", glow * 0.7) : color);
+  return Array.from({ length: cells }, (_, i) => {
+    if (i < full) return { glyph: "█", color: shine(i, gradient(i)) };
+    if (i === full && part > 1e-6) return { glyph: "█", color: shine(i, lerpColor(BAR_TRACK, gradient(i), part)) };
+    return { glyph: "░", color: BAR_TRACK };
+  });
+};

package/plugins/litclaude/lib/mod/render.mjs

@@ -0,0 +1,20 @@
+// Draws composed rows (frame.mjs) with a surface's element table: one row Box of Text spans per
+// line. The LIT card draws its own border as text, so its title and figures sit in the edges. It
+// calls the element constructors directly, so the band's surface module, the mod's static fallback
+// and the tests share it.
+
+const textProps = (part) => {
+  const props = { children: part.text, wrap: "truncate-end" };
+  if (part.fg) props.color = part.fg;
+  if (part.bg) props.backgroundColor = part.bg;
+  if (part.bold) props.bold = true;
+  return props;
+};
+
+export const renderRows = ({ Box, Text }, rows) =>
+  rows.map((row) => {
+    const parts = row.filter(({ text }) => text.length > 0);
+    return Box({ flexDirection: "row", children: parts.length ? parts.map((part) => Text(textProps(part))) : [Text({ children: " " })] });
+  });
+
+export const renderBand = (elements, frame) => elements.Box({ flexDirection: "column", children: renderRows(elements, frame.rows) });

package/plugins/litclaude/lib/mod/settings.mjs

@@ -0,0 +1,105 @@
+// The LIT band's three userConfig options. The manifest declares them as plain strings without an
+// `options` list, because Claude Code 2.1.270 and older refuse a whole plugin whose userConfig has
+// one; the values are checked here instead, and anything unknown falls back to the default (the
+// first choice).
+
+const CHOICES = Object.freeze({
+  motion: ["full", "subtle", "off"],
+  glyphs: ["auto", "nerd", "basic"],
+  band: ["always", "auto", "off"],
+});
+
+const pick = (value, choices) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return choices.includes(normalized) ? normalized : choices[0];
+};
+
+export const normalizeModSettings = (options) => ({
+  motion: pick(options?.motion, CHOICES.motion),
+  glyphs: pick(options?.glyphs, CHOICES.glyphs),
+  band: pick(options?.band, CHOICES.band),
+});
+
+// The glyph set one surface draws. Private-use Nerd Font glyphs only reach the terminal, which
+// draws with the person's own fonts; `auto` uses them there when the icon font is installed. The
+// desktop app and the other surfaces always get the basic set.
+export const resolveGlyphs = (preference, surface, iconFontPresent) => {
+  if (surface !== "terminal") return "basic";
+  if (preference === "auto") return iconFontPresent ? "nerd" : "basic";
+  return preference === "nerd" ? "nerd" : "basic";
+};
+
+const BASIC = Object.freeze({
+  capLeft: "",
+  capRight: "",
+  done: "✓",
+  now: "●",
+  warn: "⚠",
+  link: "─",
+  rail: "━",
+  next: "▸",
+  lane: "●",
+  idleLane: "◌",
+  loop: "⟳",
+  fail: "✗",
+  flag: "⚑",
+  bolt: "⚡",
+  recentBolt: "↯",
+  branch: "git",
+});
+
+const NERD = Object.freeze({
+  ...BASIC,
+  capLeft: "",
+  capRight: "",
+  done: "",
+  warn: "",
+  bolt: "",
+  recentBolt: "",
+  branch: "",
+});
+
+export const glyphSet = (glyphs) => (glyphs === "nerd" ? NERD : BASIC);
+
+// The status line's accents (hud-accent-palette.mjs HUD_ACCENT_THEMES, kept equal by a test) as
+// xterm 256-colour codes. The mod cannot import that file, so the card reads the same names here.
+export const ACCENT_CODES = Object.freeze({
+  cyan: 81,
+  blue: 39,
+  teal: 49,
+  green: 118,
+  lavender: 177,
+  rose: 198,
+  gold: 220,
+  orange: 208,
+  slate: 75,
+  gray: 231,
+});
+
+const CUBE = [0, 95, 135, 175, 215, 255];
+const hex2 = (value) => value.toString(16).padStart(2, "0");
+
+export const xterm256Hex = (code) => {
+  if (code >= 232) {
+    const level = 8 + (code - 232) * 10;
+    return `#${hex2(level).repeat(3)}`;
+  }
+  const index = code - 16;
+  return `#${[Math.floor(index / 36), Math.floor(index / 6) % 6, index % 6].map((step) => hex2(CUBE[step])).join("")}`;
+};
+
+export const accentHex = (name) => xterm256Hex(ACCENT_CODES[String(name ?? "").trim().toLowerCase()] ?? ACCENT_CODES.cyan);
+
+const knownAccent = (name) => {
+  const normalized = String(name ?? "").trim().toLowerCase();
+  return Object.hasOwn(ACCENT_CODES, normalized) ? normalized : null;
+};
+
+// The accent the status line draws with: the installer writes it into the statusLine command
+// (`LITCLAUDE_HUD_ACCENT=<name> node …`) and records it under the `litclaude` settings key; an
+// accent exported in the shell is the last resort, as for a hand-written status line.
+export const accentFromSettings = (settings, envValue) => {
+  const command = typeof settings?.statusLine?.command === "string" ? settings.statusLine.command : "";
+  const inline = /\bLITCLAUDE_HUD_ACCENT=([A-Za-z]+)/u.exec(command)?.[1];
+  return accentHex(knownAccent(inline) ?? knownAccent(settings?.litclaude?.hudAccent) ?? knownAccent(envValue) ?? "cyan");
+};

package/plugins/litclaude/lib/mod/skills.mjs

@@ -0,0 +1,81 @@
+// Which LitFamily skills fired in this session, for the chips row of the LIT card. The mod notes a
+// firing from a Skill tool call, a skill prompt expansion (a typed `/litclaude:<name>` or the Skill
+// tool) and a new ignition record from the prompt hook (bare `lit` routing); only LitClaude's own
+// skills and commands become chips. Pure: the mod keeps the list, the card draws it.
+
+// canonical-skill-catalog.mjs canonicalSkillIds, kept equal by a test; the catalog pulls in the
+// resource manifest, which the mod has no reason to load.
+export const LIT_SKILL_IDS = Object.freeze([
+  "autoconference",
+  "autoresearch",
+  "browser-drive",
+  "comment-checker",
+  "debugging",
+  "deep-interview",
+  "frontend-ui-ux",
+  "lit-burnoff",
+  "lit-burnoff-file",
+  "lit-code",
+  "lit-commit",
+  "lit-comprehend",
+  "lit-crucible",
+  "lit-diagram-drawer",
+  "lit-docx",
+  "lit-handoff",
+  "lit-humanizer",
+  "lit-init",
+  "lit-loop",
+  "lit-plan",
+  "lit-pptx",
+  "lit-recap",
+  "lit-scientific-visualization",
+  "lit-team",
+  "lit-typographic-motion",
+  "litgoal",
+  "litresearch",
+  "litwork",
+  "lsp",
+  "lsp-setup",
+  "readme-studio",
+  "refactor",
+  "review-work",
+  "rules",
+  "start-work",
+  "structural-search",
+  "visual-qa",
+  "wikify",
+]);
+
+const KNOWN = new Set(LIT_SKILL_IDS);
+const PLUGIN_PREFIX = "litclaude:";
+const KEEP = 12;
+// A Skill call and the prompt expansion it causes arrive moments apart; they are one firing.
+const SAME_FIRING_MS = 1500;
+
+/** The chip id for a skill or command name, or null when it is not LitClaude's. */
+export const litSkillId = (name) => {
+  const raw = typeof name === "string" ? name.trim() : "";
+  if (raw.startsWith(PLUGIN_PREFIX)) {
+    const id = raw.slice(PLUGIN_PREFIX.length);
+    return /^[a-z0-9][a-z0-9-]{0,63}$/u.test(id) ? id : null;
+  }
+  return KNOWN.has(raw) ? raw : null;
+};
+
+/** Notes one firing at `at`: newest first, one entry per skill, a short history. */
+export const noteSkill = (fired, id, at) => {
+  const previous = fired.find((entry) => entry.id === id);
+  if (previous && at >= previous.at && at - previous.at < SAME_FIRING_MS) return fired;
+  return [{ id, at }, ...fired.filter((entry) => entry.id !== id)].slice(0, KEEP);
+};
+
+/**
+ * Each chip's state: `current` when it fired after `settledAt` (the end of the last finished
+ * request), `recent` otherwise. Current chips come first; each group keeps newest first.
+ */
+export const chipStates = (fired, settledAt) => {
+  const ordered = [...fired].sort((a, b) => b.at - a.at);
+  const current = ordered.filter(({ at }) => at > settledAt).map((entry) => ({ ...entry, state: "current" }));
+  const recent = ordered.filter(({ at }) => at <= settledAt).map((entry) => ({ ...entry, state: "recent" }));
+  return [...current, ...recent];
+};