@groeponline/pi-wishcraft 0.20.0 → 0.22.0

package/src/extension/ui/menu-items.ts

@@ -0,0 +1,379 @@
+import type { SelectItem } from "@earendil-works/pi-tui";
+
+import type { PowerlineConfig } from "../../config/powerline-config.ts";
+import { mergeSegmentsWithCustomItems } from "../../config/powerline-config.ts";
+import { getPreset } from "../../config/presets.ts";
+import {
+  BUILTIN_STATUS_LINE_SEGMENT_IDS,
+  type CustomPresetConfig,
+  type CustomStatusItem,
+  type PresetDef,
+  type SegmentContext,
+  type StatusLineSegmentId,
+  type StatusLineSeparatorStyle,
+} from "../../config/types.ts";
+import type { OpenPortProcess } from "../../segments/system.ts";
+import { formatUsdCost } from "../../usage/rates.ts";
+import { renderSegmentWithWidth } from "./layout.ts";
+
+const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;]*m/g, "");
+
+export interface SegmentMenuItem {
+  id: StatusLineSegmentId;
+  /** ANSI-stripped rendered value shown next to the id in the navigator. */
+  value: string;
+}
+
+export interface DetailLine {
+  label: string;
+  value: string;
+}
+
+/**
+ * Segment ids in the active preset/layout order (custom items merged in).
+ * Disabled segments are intentionally kept so the toggle view can re-enable
+ * them; callers that render the live bar must filter those themselves.
+ */
+export function collectSegmentIds(
+  config: PowerlineConfig,
+  customItems: readonly CustomStatusItem[] = config.customItems,
+): StatusLineSegmentId[] {
+  const presetDef = getPreset(config.preset);
+  const merged = mergeSegmentsWithCustomItems(presetDef, customItems, {
+    layout: config.layout,
+  });
+  return [
+    ...merged.leftSegments,
+    ...merged.rightSegments,
+    ...merged.secondarySegments,
+  ];
+}
+
+/**
+ * Build navigator entries from the live segment context. Pure: given the same
+ * context + config it returns the same items, so it can be unit-tested.
+ * Disabled and currently-hidden segments are skipped (the bar never shows
+ * them, so there is nothing to navigate into).
+ */
+export function buildSegmentItems(
+  segCtx: SegmentContext,
+  config: PowerlineConfig,
+): SegmentMenuItem[] {
+  const disabled = new Set(config.disabledSegments);
+  const items: SegmentMenuItem[] = [];
+  for (const id of collectSegmentIds(config, segCtx.effectiveCustomItems)) {
+    if (disabled.has(id)) continue;
+    const rendered = renderSegmentWithWidth(id, segCtx);
+    if (!rendered.visible) continue;
+    const value = stripAnsi(rendered.content).trim() || "(empty)";
+    items.push({ id, value });
+  }
+  return items;
+}
+
+export function segmentItemsToSelectItems(
+  items: SegmentMenuItem[],
+): SelectItem[] {
+  const selectItems: SelectItem[] = items.map((item) => ({
+    label: `● ${item.id}  ${item.value}`,
+    value: item.id,
+  }));
+  if (selectItems.length === 0) {
+    selectItems.push({ label: "(no visible segments)", value: "__none__" });
+  }
+  return selectItems;
+}
+
+/**
+ * Index into `items` to keep the selection stable across a live refresh. The
+ * navigator rebuilds its item list on a timer; restoring by segment id (value)
+ * keeps the highlight on the same segment even when labels shift. Falls back to
+ * the first item when the previous selection no longer exists.
+ */
+export function selectIndexForValue(
+  items: SelectItem[],
+  previousValue: string | null,
+): number {
+  if (previousValue === null) return 0;
+  const index = items.findIndex((item) => item.value === previousValue);
+  return index >= 0 ? index : 0;
+}
+
+/** Configure sub-menu choices as plain data (label only; order is the menu). */
+export function buildConfigureItems(): string[] {
+  return [
+    "Change preset",
+    "Set TPS value (POWERLINE_TPS)",
+    "Clear TPS override (use live)",
+    "Toggle UDP in open-ports",
+    "Toggle segment visibility…",
+    "Set segment label…",
+    "Build custom preset…",
+    "Show current config",
+  ];
+}
+
+const CONFIGURE_ITEM_DESCRIPTIONS: Record<string, string> = {
+  "Change preset": "Switch left/right segment layout preset",
+  "Set TPS value (POWERLINE_TPS)": "Override tokens/sec display with a fixed value",
+  "Clear TPS override (use live)": "Remove POWERLINE_TPS and use the live rate",
+  "Toggle UDP in open-ports": "Include or exclude UDP listeners in the port count",
+  "Toggle segment visibility…": "Enable or disable individual segments",
+  "Set segment label…": "Override the label prefix for one segment",
+  "Build custom preset…": "Compose a new preset from segment groups",
+  "Show current config": "Notify a one-line summary of active settings",
+};
+
+/** Configure sub-menu as SelectList items (CHE-42 overlay). */
+export function configureItemsToSelectItems(): SelectItem[] {
+  return buildConfigureItems().map((label) => ({
+    label,
+    value: label,
+    description: CONFIGURE_ITEM_DESCRIPTIONS[label],
+  }));
+}
+
+/**
+ * Every segment id a user can place while building a custom preset: built-ins
+ * plus `custom:<id>` for explicit custom items and user-defined computed
+ * segments (command/env/static).
+ */
+export function buildCustomPresetSegmentIds(
+  config: PowerlineConfig,
+): StatusLineSegmentId[] {
+  const ids: StatusLineSegmentId[] = [...BUILTIN_STATUS_LINE_SEGMENT_IDS];
+  const seen = new Set<string>(ids);
+  for (const item of config.customItems) {
+    const id = `custom:${item.id}` as StatusLineSegmentId;
+    if (!seen.has(id)) {
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+  for (const id of Object.keys(config.segments)) {
+    const segmentId = `custom:${id}` as StatusLineSegmentId;
+    if (!seen.has(segmentId)) {
+      seen.add(segmentId);
+      ids.push(segmentId);
+    }
+  }
+  return ids;
+}
+
+/** Normalize a user-entered preset name to a lowercase safe id, or null. */
+export function validatePresetName(name: string): string | null {
+  const trimmed = name.trim().toLowerCase();
+  return /^[a-z0-9_-]+$/.test(trimmed) && trimmed.length > 0 ? trimmed : null;
+}
+
+/**
+ * Choices for one "add segment to this preset group" picker: a done sentinel
+ * first, then every not-yet-chosen id. Pure so the picker can be unit-tested.
+ */
+export function buildPresetEditorAddItems(
+  all: readonly StatusLineSegmentId[],
+  chosen: readonly StatusLineSegmentId[],
+): SelectItem[] {
+  const chosenSet = new Set(chosen);
+  const items: SelectItem[] = [
+    {
+      label:
+        chosen.length > 0 ? `— done — (${chosen.length} selected)` : "— done —",
+      value: "__done__",
+    },
+  ];
+  for (const id of all) {
+    if (chosenSet.has(id)) continue;
+    items.push({ label: `+ ${id}`, value: id });
+  }
+  return items;
+}
+
+/**
+ * Assemble a `CustomPresetConfig` from a base preset (colors + segment options
+ * are inherited) plus the user's chosen segment groups and separator.
+ */
+export function buildCustomPresetDef(
+  base: PresetDef,
+  left: readonly StatusLineSegmentId[],
+  right: readonly StatusLineSegmentId[],
+  secondary: readonly StatusLineSegmentId[],
+  separator: StatusLineSeparatorStyle,
+): CustomPresetConfig {
+  const def: CustomPresetConfig = {
+    left: [...left],
+    right: [...right],
+    separator,
+  };
+  if (secondary.length > 0) def.secondary = [...secondary];
+  if (base.colors) def.colors = { ...base.colors };
+  if (base.segmentOptions) def.segmentOptions = { ...base.segmentOptions };
+  return def;
+}
+
+/**
+ * Key/value detail rows for the per-segment detail view (`→`/`tab`).
+ * `openPortProcesses` is the live (already cached) `listOpenPortProcesses()`
+ * result, passed in so this builder stays pure and unit-testable.
+ */
+export function buildSegmentDetailLines(
+  id: StatusLineSegmentId,
+  segCtx: SegmentContext,
+  openPortProcesses: readonly OpenPortProcess[] = [],
+): DetailLine[] {
+  const usage = segCtx.usageStats;
+  const label = segCtx.segmentLabels.get(id);
+  const common: DetailLine[] = [{ label: "segment", value: id }];
+  if (label) common.push({ label: "label", value: label });
+
+  switch (id) {
+    case "tps": {
+      const override = process.env.POWERLINE_TPS;
+      const windowMs = segCtx.options.tps?.windowMs;
+      const lines: DetailLine[] = [
+        ...common,
+        {
+          label: "value",
+          value: override ? `${override} (override)` : "live 1s window",
+        },
+      ];
+      if (windowMs) lines.push({ label: "window", value: `${windowMs} ms` });
+      return lines;
+    }
+    case "open_ports": {
+      const host = segCtx.options.openPorts?.host;
+      const lines: DetailLine[] = [
+        ...common,
+        {
+          label: "UDP",
+          value: segCtx.options.openPorts?.includeUdp ? "on" : "off",
+        },
+      ];
+      if (host) lines.push({ label: "host", value: host });
+      if (openPortProcesses.length > 0) {
+        for (const p of openPortProcesses) {
+          lines.push({
+            label: `${p.proto}:${p.port}`,
+            value: p.process ?? "(unknown)",
+          });
+        }
+      } else {
+        lines.push({ label: "processes", value: "(none / ss -p unavailable)" });
+      }
+      return lines;
+    }
+    case "git": {
+      const git = segCtx.git;
+      const lines: DetailLine[] = [...common];
+      if (git.branch) {
+        lines.push({ label: "branch", value: git.branch });
+        lines.push({
+          label: "changes",
+          value: `+${git.staged} ~${git.unstaged} ?${git.untracked}`,
+        });
+        lines.push({
+          label: "upstream",
+          value: `↑${git.ahead} ↓${git.behind}`,
+        });
+        if (git.commit) {
+          lines.push({
+            label: "head",
+            value: `${git.commit.short} ${git.commit.subject}`,
+          });
+        }
+      } else {
+        lines.push({ label: "branch", value: "(no repo)" });
+      }
+      return lines;
+    }
+    case "cost": {
+      const currency = segCtx.options.cost?.currency ?? "USD";
+      const total = usage.cost + usage.subagentCost;
+      return [
+        ...common,
+        {
+          label: "cost",
+          value: formatUsdCost(usage.cost, currency) ?? `$${usage.cost.toFixed(2)}`,
+        },
+        {
+          label: "subagents",
+          value:
+            formatUsdCost(usage.subagentCost, currency) ??
+            `$${usage.subagentCost.toFixed(2)}`,
+        },
+        {
+          label: "total",
+          value: formatUsdCost(total, currency) ?? `$${total.toFixed(2)}`,
+        },
+      ];
+    }
+    case "context_pct":
+    case "context_total":
+      return [
+        ...common,
+        { label: "tokens", value: String(segCtx.contextTokens) },
+        { label: "window", value: String(segCtx.contextWindow) },
+        { label: "percent", value: `${segCtx.contextPercent.toFixed(1)}%` },
+        {
+          label: "auto-compact",
+          value: segCtx.autoCompactEnabled ? "on" : "off",
+        },
+      ];
+    case "model":
+      return [
+        ...common,
+        {
+          label: "model",
+          value: segCtx.model?.name ?? segCtx.model?.id ?? "(unknown)",
+        },
+        { label: "thinking", value: segCtx.thinkingLevel },
+      ];
+    case "queue": {
+      const queue = segCtx.queueSummary;
+      const lines: DetailLine[] = [
+        ...common,
+        { label: "queued", value: String(queue.queueCount) },
+        { label: "ideas", value: String(queue.ideaCount) },
+        { label: "blocked", value: String(queue.blockedCount) },
+      ];
+      if (queue.leadingText) lines.push({ label: "next", value: queue.leadingText });
+      return lines;
+    }
+    case "token_in":
+      return [...common, { label: "input", value: String(usage.input) }];
+    case "token_out":
+      return [...common, { label: "output", value: String(usage.output) }];
+    case "token_total":
+      return [
+        ...common,
+        {
+          label: "total",
+          value: String(
+            usage.input + usage.output + usage.cacheRead + usage.cacheWrite,
+          ),
+        },
+      ];
+    case "cache_read":
+      return [...common, { label: "cache read", value: String(usage.cacheRead) }];
+    case "cache_write":
+      return [
+        ...common,
+        { label: "cache write", value: String(usage.cacheWrite) },
+      ];
+    case "time_spent":
+      return [
+        ...common,
+        {
+          label: "session start",
+          value: new Date(segCtx.sessionStartTime).toLocaleTimeString(),
+        },
+      ];
+    default: {
+      const rendered = renderSegmentWithWidth(id, segCtx);
+      const value = rendered.visible
+        ? stripAnsi(rendered.content).trim() || "(empty)"
+        : "(hidden)";
+      return [...common, { label: "value", value }];
+    }
+  }
+}