@pellux/goodvibes-agent 0.1.0

package/src/renderer/status-token.ts

@@ -0,0 +1,67 @@
+// ---------------------------------------------------------------------------
+// buildStatusToken — always glyph + color, never color-only.
+//
+// Maps a semantic state to a Unicode glyph AND a palette color so that
+// colorblind users and screen readers can distinguish states without color.
+//
+// Glyphs:
+//   good  ✓  (CHECK MARK)
+//   warn  ⚠  (WARNING SIGN)
+//   bad   ✕  (MULTIPLICATION X)
+//   info  ○  (WHITE CIRCLE)
+// ---------------------------------------------------------------------------
+
+import type { Cell } from '../types/grid.ts';
+import { DEFAULT_PANEL_PALETTE } from '../panels/polish.ts';
+import { type StatusState, STATE_GLYPHS } from './status-glyphs.ts';
+
+// Re-export for downstream consumers that import from this module.
+export type { StatusState } from './status-glyphs.ts';
+export { STATE_GLYPHS } from './status-glyphs.ts';
+
+const STATE_COLORS: Record<StatusState, string> = {
+  good: DEFAULT_PANEL_PALETTE.good,
+  warn: DEFAULT_PANEL_PALETTE.warn,
+  bad:  DEFAULT_PANEL_PALETTE.bad,
+  info: DEFAULT_PANEL_PALETTE.info,
+};
+
+export interface StatusTokenOpts {
+  /** Append a numeric count after the label, e.g. "label (3)". */
+  count?: number;
+  /** Override the default glyph for this state. */
+  glyph?: string;
+}
+
+/**
+ * Build a small sequence of styled cells: [glyph, space, label, optional count]
+ *
+ * Always prepends the glyph so colorblind users can parse the state.
+ * The color is applied to both glyph and label as a redundant cue.
+ *
+ * @param state   Semantic state — controls default glyph and color.
+ * @param label   Human-readable label string.
+ * @param opts    Optional count suffix or glyph override.
+ * @returns       Array of Cell objects ready to embed in a Line.
+ */
+export function buildStatusToken(
+  state: StatusState,
+  label: string,
+  opts?: StatusTokenOpts,
+): Cell[] {
+  const glyph = opts?.glyph ?? STATE_GLYPHS[state];
+  const color = STATE_COLORS[state];
+  const suffix = opts?.count !== undefined ? ` (${opts.count})` : '';
+  const text = `${glyph} ${label}${suffix}`;
+
+  return text.split('').map((char): Cell => ({
+    char,
+    fg: color,
+    bg: '',
+    bold: false,
+    dim: false,
+    underline: false,
+    italic: false,
+    strikethrough: false,
+  }));
+}

package/src/renderer/surface-layout.ts

@@ -0,0 +1,101 @@
+export interface SurfaceViewportRequest {
+  readonly viewportHeight: number;
+  readonly chromeRows: number;
+  readonly minContentRows?: number;
+  readonly maxContentRows?: number;
+  readonly targetRatio?: number;
+  readonly minTotalRows?: number;
+  readonly maxTotalRows?: number;
+}
+
+export interface VisibleWindow {
+  readonly start: number;
+  readonly end: number;
+  readonly count: number;
+  readonly total: number;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+export function getSurfaceContentRows(request: SurfaceViewportRequest): number {
+  const targetRatio = request.targetRatio ?? 0.48;
+  const minTotalRows = request.minTotalRows ?? 10;
+  const maxTotalRows = request.maxTotalRows ?? 14;
+  const minContentRows = request.minContentRows ?? 5;
+  const maxContentRows = request.maxContentRows ?? 8;
+
+  const safeViewportHeight = Math.max(8, request.viewportHeight);
+  const targetTotalRows = clamp(
+    Math.round(safeViewportHeight * targetRatio),
+    minTotalRows,
+    Math.min(safeViewportHeight, maxTotalRows),
+  );
+
+  return clamp(
+    targetTotalRows - request.chromeRows,
+    minContentRows,
+    Math.max(minContentRows, maxContentRows),
+  );
+}
+
+export function getVisibleWindow(
+  total: number,
+  selectedIndex: number,
+  visibleCount: number,
+): VisibleWindow {
+  if (total <= 0 || visibleCount <= 0) {
+    return { start: 0, end: 0, count: 0, total };
+  }
+
+  if (total <= visibleCount) {
+    return { start: 0, end: total, count: total, total };
+  }
+
+  const clampedSelected = clamp(selectedIndex, 0, total - 1);
+  const half = Math.floor(visibleCount / 2);
+  const start = clamp(clampedSelected - half, 0, total - visibleCount);
+  const end = Math.min(total, start + visibleCount);
+  return { start, end, count: end - start, total };
+}
+
+export function getTrackedVisibleWindow(
+  total: number,
+  selectedIndex: number,
+  visibleCount: number,
+  previousStart: number,
+  guardRows: number = 1,
+): VisibleWindow {
+  if (total <= 0 || visibleCount <= 0) {
+    return { start: 0, end: 0, count: 0, total };
+  }
+  if (total <= visibleCount) {
+    return { start: 0, end: total, count: total, total };
+  }
+  const clampedSelected = clamp(selectedIndex, 0, total - 1);
+  const clampedStart = clamp(previousStart, 0, total - visibleCount);
+  const guard = clamp(guardRows, 0, Math.max(0, visibleCount - 1));
+  let start = clampedStart;
+  let end = start + visibleCount;
+  if (clampedSelected < start + guard) {
+    start = clamp(clampedSelected - guard, 0, total - visibleCount);
+    end = start + visibleCount;
+  } else if (clampedSelected >= end - guard) {
+    start = clamp(clampedSelected - visibleCount + guard + 1, 0, total - visibleCount);
+    end = start + visibleCount;
+  }
+  return { start, end, count: end - start, total };
+}
+
+export function sliceVisibleWindow<T>(
+  items: readonly T[],
+  selectedIndex: number,
+  visibleCount: number,
+): { readonly items: readonly T[]; readonly window: VisibleWindow } {
+  const window = getVisibleWindow(items.length, selectedIndex, visibleCount);
+  return {
+    items: items.slice(window.start, window.end),
+    window,
+  };
+}