@groeponline/pi-wishcraft 1.1.0 → 1.2.0

package/src/config/appearance.ts

@@ -0,0 +1,230 @@
+/**
+ * appearance.ts
+ * ---------------------------------------------------------------------------
+ * Mixable appearance resolution for Wishcraft vNext. Users can pair any
+ * structural preset base with independent palette, signal layout, chrome,
+ * glyph, deck, welcome, and motion layers.
+ * ---------------------------------------------------------------------------
+ */
+
+import type {
+  AppearanceMixConfig,
+  ChromeSpec,
+  ColorScheme,
+  DeckSpec,
+  GlyphSet,
+  MotionRef,
+  PresetDef,
+  ResolvedAppearance,
+  SignalSpec,
+  StructuralPresetName,
+  WelcomeSpec,
+  WishcraftTokens,
+} from "./types.ts";
+import type { MotionEvent } from "../motion/types.ts";
+import { getMotion } from "../motion/catalog.ts";
+import { colorSchemeFromTokens, presetColorScheme, resolveTokens } from "./tokens.ts";
+import {
+  STRUCTURAL_PRESETS,
+  getStructuralPreset,
+  isStructuralPresetName,
+} from "./structural-presets.ts";
+
+function layerPreset(
+  config: AppearanceMixConfig,
+  key: keyof Pick<
+    AppearanceMixConfig,
+    "palette" | "signalLayout" | "chrome" | "glyphs" | "deck" | "welcome"
+  >,
+  base: StructuralPresetName,
+): StructuralPresetName {
+  return config[key] ?? base;
+}
+
+function resolveMotionLayer(
+  config: AppearanceMixConfig,
+  base: StructuralPresetName,
+): Partial<Record<MotionEvent, MotionRef>> {
+  if (!config.motion) {
+    return { ...STRUCTURAL_PRESETS[base].motion };
+  }
+  if (typeof config.motion === "string") {
+    return { ...STRUCTURAL_PRESETS[config.motion].motion };
+  }
+  return { ...STRUCTURAL_PRESETS[base].motion, ...config.motion };
+}
+
+/**
+ * Resolve a decoupled appearance mix into concrete tokens, chrome, signal,
+ * motion, deck, welcome, and glyph layers.
+ */
+export function resolveAppearanceMix(
+  config: AppearanceMixConfig = {},
+): ResolvedAppearance {
+  const baseName = config.base ?? "lanternwake";
+  const base = getStructuralPreset(baseName);
+
+  const paletteName = layerPreset(config, "palette", baseName);
+  const signalName = layerPreset(config, "signalLayout", baseName);
+  const chromeName = layerPreset(config, "chrome", baseName);
+  const glyphName = layerPreset(config, "glyphs", baseName);
+  const deckName = layerPreset(config, "deck", baseName);
+  const welcomeName = layerPreset(config, "welcome", baseName);
+
+  const palette = getStructuralPreset(paletteName);
+  const signalPreset = getStructuralPreset(signalName);
+
+  return {
+    base: baseName,
+    tokens: resolveTokens(palette.tokens),
+    chrome: cloneChrome(getStructuralPreset(chromeName).chrome),
+    signal: cloneSignal(signalPreset.signal),
+    motion: resolveMotionLayer(config, baseName),
+    deck: cloneDeck(getStructuralPreset(deckName).deck),
+    welcome: cloneWelcome(getStructuralPreset(welcomeName).welcome),
+    glyphs: cloneGlyphs(getStructuralPreset(glyphName).glyphs),
+  };
+}
+
+/** True when the user (or a structural layout name) has set any appearance layer. */
+export function appearanceHasExplicitLayers(mix: AppearanceMixConfig): boolean {
+  return Boolean(
+    mix.base ||
+      mix.palette ||
+      mix.signalLayout ||
+      mix.chrome ||
+      mix.glyphs ||
+      mix.deck ||
+      mix.welcome ||
+      mix.motion,
+  );
+}
+
+/**
+ * Layout colors stay until appearance is in effect. If `powerline.preset` is a
+ * structural name and appearance is empty, treat that name as `base`.
+ */
+export function effectiveAppearanceMix(
+  appearance: AppearanceMixConfig = {},
+  layoutPreset?: string,
+): AppearanceMixConfig {
+  if (appearanceHasExplicitLayers(appearance)) return appearance;
+  if (layoutPreset && isStructuralPresetName(layoutPreset)) {
+    return { base: layoutPreset };
+  }
+  return appearance;
+}
+
+/**
+ * Colors the live Signal should paint with. Layout preset colors win until an
+ * appearance mix is in effect; then structural tokens override segment colors.
+ */
+export function liveColorScheme(
+  layoutPreset: Pick<PresetDef, "colors" | "tokens">,
+  appearance: AppearanceMixConfig,
+  layoutPresetName: string | undefined,
+  defaults: () => Required<ColorScheme>,
+): ColorScheme {
+  const mix = effectiveAppearanceMix(appearance, layoutPresetName);
+  const layoutColors = presetColorScheme(layoutPreset, defaults);
+  if (!appearanceHasExplicitLayers(mix)) return layoutColors;
+  return {
+    ...layoutColors,
+    ...colorSchemeFromTokens(resolveAppearanceMix(mix).tokens),
+  };
+}
+
+/** Pick the model ornament for the active glyph mode. */
+export function resolveGlyphOrnament(
+  glyphs: GlyphSet,
+  useNerd: boolean,
+  role: "model" | "segment" = "model",
+): string {
+  if (role === "model") {
+    if (useNerd) return glyphs.model ?? "";
+    return glyphs.modelAscii ?? glyphs.model ?? "";
+  }
+  if (useNerd) return glyphs.segment ?? "";
+  return glyphs.segmentAscii ?? glyphs.segment ?? "";
+}
+
+/** Whether glyphs should use Nerd ornaments for this set. */
+export function glyphsPreferNerd(glyphs: GlyphSet, nerdAvailable: boolean): boolean {
+  switch (glyphs.mode) {
+    case "nerd":
+      return true;
+    case "ascii":
+      return false;
+    case "auto":
+      return nerdAvailable;
+  }
+}
+
+/** Validate that every motion ref in a resolved appearance exists in the catalog. */
+export function validateAppearanceMotions(
+  appearance: ResolvedAppearance,
+): { ok: true } | { ok: false; missing: string[] } {
+  const missing: string[] = [];
+  for (const [event, ref] of Object.entries(appearance.motion) as Array<
+    [MotionEvent, MotionRef | undefined]
+  >) {
+    if (ref && !getMotion(ref)) {
+      missing.push(`${event}:${ref}`);
+    }
+  }
+  if (appearance.welcome.motionId && !getMotion(appearance.welcome.motionId)) {
+    missing.push(`welcome:${appearance.welcome.motionId}`);
+  }
+  if (!getMotion(appearance.signal.animation)) {
+    missing.push(`signal:${appearance.signal.animation}`);
+  }
+  return missing.length === 0 ? { ok: true } : { ok: false, missing };
+}
+
+function cloneChrome(chrome: ChromeSpec): ChromeSpec {
+  return {
+    ...chrome,
+    corners: { ...chrome.corners },
+    dividers: { ...chrome.dividers },
+  };
+}
+
+function cloneSignal(signal: SignalSpec): SignalSpec {
+  return {
+    ...signal,
+    separators: { ...signal.separators },
+    caps: { ...signal.caps },
+  };
+}
+
+function cloneDeck(deck: DeckSpec): DeckSpec {
+  return { ...deck };
+}
+
+function cloneWelcome(welcome: WelcomeSpec): WelcomeSpec {
+  return { ...welcome };
+}
+
+function cloneGlyphs(glyphs: GlyphSet): GlyphSet {
+  return { ...glyphs };
+}
+
+/** Merge structural personality fields onto a layout preset without mutating it. */
+export function withStructuralPersonality(
+  preset: import("./types.ts").PresetDef,
+  structural: StructuralPresetName,
+): import("./types.ts").PresetDef {
+  const personality = getStructuralPreset(structural);
+  return {
+    ...preset,
+    tokens: personality.tokens,
+    chrome: personality.chrome,
+    signal: personality.signal,
+    motion: personality.motion,
+    deck: personality.deck,
+    welcome: personality.welcome,
+    glyphs: personality.glyphs,
+  };
+}
+
+export type { WishcraftTokens };

package/src/config/parse.ts

@@ -17,6 +17,7 @@ import {
 import { normalizeDisabledSegments, normalizeLayout } from "./segment-ids.ts";
 import { normalizeSegmentOptions } from "./segment-options.ts";
 import type {
+  AppearanceMixConfig,
   CustomSegmentConfig,
   CustomStatusItem,
   PowerlinePlacement,
@@ -26,6 +27,8 @@ import type {
   StatusLineSegmentOptions,
   StatusLineSeparatorStyle,
 } from "./types.ts";
+import { isStructuralPresetName } from "./structural-presets.ts";
+import { isMotionLevel, type MotionLevel } from "../motion/accessibility.ts";
 
 export interface PowerlineConfig {
   preset: StatusLinePreset;
@@ -51,6 +54,10 @@ export interface PowerlineConfig {
   presets: Record<string, import("./types.ts").CustomPresetConfig>;
   /** Per-segment custom text label shown before the value (e.g. tps -> "speed"). */
   segmentLabels: Record<string, string>;
+  /** Independently mixable vNext structural appearance layers. */
+  appearance: AppearanceMixConfig;
+  /** Persisted motion sensitivity. Environment can still force off. */
+  motionLevel: MotionLevel;
 }
 
 export function parsePowerlineConfig(
@@ -76,6 +83,8 @@ export function parsePowerlineConfig(
     segments: {},
     presets: {},
     segmentLabels: {},
+    appearance: {},
+    motionLevel: "full",
   };
 
   const directPreset = normalizePreset(value, presets);
@@ -139,5 +148,37 @@ export function parsePowerlineConfig(
     segments: customSegments,
     presets: customPresetDefs,
     segmentLabels: normalizeSegmentLabels(value.segmentLabels),
+    appearance: normalizeAppearance(value.appearance),
+    motionLevel: isMotionLevel(value.motionLevel) ? value.motionLevel : "full",
   };
 }
+
+function normalizeAppearance(value: unknown): AppearanceMixConfig {
+  if (!isRecord(value)) return {};
+  const result: AppearanceMixConfig = {};
+  const presetKeys = [
+    "base",
+    "palette",
+    "signalLayout",
+    "chrome",
+    "glyphs",
+    "deck",
+    "welcome",
+  ] as const;
+  for (const key of presetKeys) {
+    const candidate = value[key];
+    if (typeof candidate === "string" && isStructuralPresetName(candidate)) {
+      result[key] = candidate;
+    }
+  }
+  if (typeof value.motion === "string" && isStructuralPresetName(value.motion)) {
+    result.motion = value.motion;
+  } else if (isRecord(value.motion)) {
+    const refs: Record<string, string> = {};
+    for (const [event, ref] of Object.entries(value.motion)) {
+      if (typeof ref === "string" && ref.trim()) refs[event] = ref.trim();
+    }
+    result.motion = refs as AppearanceMixConfig["motion"];
+  }
+  return result;
+}

package/src/config/presets.ts

@@ -1,6 +1,7 @@
 import type { ColorScheme, PresetDef, StatusLinePreset } from "./types.ts";
 import { getDefaultColors } from "../theme/theme.ts";
 import type { CustomPresetConfig } from "./types.ts";
+import { createTokens, deriveColorSchemeFromTokens } from "../theme/tokens/mapping.ts";
 
 // Get base colors from theme.ts (single source of truth)
 const DEFAULT_COLORS: ColorScheme = getDefaultColors();
@@ -30,6 +31,100 @@ const CHEF_COLORS: ColorScheme = {
   queue: "dim",
 };
 
+// ---------------------------------------------------------------------------
+// 10 vNext Structural Signature Presets
+// ---------------------------------------------------------------------------
+
+const LANTERNWAKE_TOKENS = createTokens({
+  primary: "#f59e0b",
+  accent: "#ea580c",
+  surface: "#0f172a",
+  surfaceRaised: "#1e293b",
+  motionHot: "#fbbf24",
+  motionTrail: "#78350f",
+});
+
+const THREADBOUND_TOKENS = createTokens({
+  primary: "#6366f1",
+  secondary: "#818cf8",
+  accent: "#ec4899",
+  surface: "#18181b",
+  surfaceRaised: "#27272a",
+  motionHot: "#a855f7",
+});
+
+const SCRYGLASS_TOKENS = createTokens({
+  primary: "#06b6d4",
+  secondary: "#38bdf8",
+  accent: "#8b5cf6",
+  surface: "#090d16",
+  surfaceRaised: "#161e2e",
+  motionHot: "#22d3ee",
+});
+
+const RUNEBLOOM_TOKENS = createTokens({
+  primary: "#10b981",
+  secondary: "#34d399",
+  accent: "#eab308",
+  surface: "#0c140f",
+  surfaceRaised: "#19261e",
+  motionHot: "#facc15",
+});
+
+const MOONWELL_TOKENS = createTokens({
+  primary: "#94a3b8",
+  secondary: "#cbd5e1",
+  accent: "#38bdf8",
+  surface: "#020617",
+  surfaceRaised: "#0f172a",
+  motionHot: "#e2e8f0",
+});
+
+const HEXFORGE_TOKENS = createTokens({
+  primary: "#f97316",
+  secondary: "#fb923c",
+  accent: "#ef4444",
+  surface: "#1c1917",
+  surfaceRaised: "#292524",
+  motionHot: "#ffedd5",
+});
+
+const VELLUM_TOKENS = createTokens({
+  primary: "#d97706",
+  secondary: "#b45309",
+  accent: "#a16207",
+  surface: "#1a1815",
+  surfaceRaised: "#292520",
+  motionHot: "#f59e0b",
+});
+
+const WISP_TOKENS = createTokens({
+  primary: "#cbd5e1",
+  secondary: "#94a3b8",
+  accent: "#38bdf8",
+  surface: "#0b0f19",
+  surfaceRaised: "#111827",
+  motionHot: "#67e8f9",
+});
+
+const STARWEAVE_TOKENS = createTokens({
+  primary: "#a855f7",
+  secondary: "#c084fc",
+  accent: "#38bdf8",
+  surface: "#050515",
+  surfaceRaised: "#13112c",
+  motionHot: "#f472b6",
+});
+
+const CRUCIBLE_TOKENS = createTokens({
+  primary: "#ec4899",
+  secondary: "#f43f5e",
+  accent: "#fb7185",
+  surface: "#110b11",
+  surfaceRaised: "#241424",
+  motionHot: "#fda4af",
+});
+
 export const PRESETS: Record<StatusLinePreset, PresetDef> = {
   // v2 preset lineup — an explicit information ladder:
   //   minimal (branch only) → compact (+ short commit) → default (full git,
@@ -276,6 +371,94 @@ export const PRESETS: Record<StatusLinePreset, PresetDef> = {
       openPorts: { includeUdp: false },
     },
   },
+
+  // 10 vNext Structural Presets
+  lanternwake: {
+    leftSegments: ["model", "thinking", "shell_mode", "path", "git", "session", "queue"],
+    rightSegments: ["token_in", "token_out", "cost", "context_pct", "time_spent"],
+    secondarySegments: ["extension_statuses"],
+    separator: "powerline",
+    colors: deriveColorSchemeFromTokens(LANTERNWAKE_TOKENS),
+    tokens: LANTERNWAKE_TOKENS,
+    motion: {
+      streaming: "ember-relay",
+      thinking: "ember-relay",
+      "tool.start": "hex-relay",
+      success: "rune-bloom",
+    },
+  },
+
+  threadbound: {
+    leftSegments: ["model", "path", "git", "queue"],
+    rightSegments: ["tps", "cost", "context_pct"],
+    separator: "powerline-thin",
+    colors: deriveColorSchemeFromTokens(THREADBOUND_TOKENS),
+    tokens: THREADBOUND_TOKENS,
+  },
+
+  scryglass: {
+    leftSegments: ["model", "path", "git"],
+    rightSegments: ["token_total", "cost", "context_pct"],
+    separator: "chevron",
+    colors: deriveColorSchemeFromTokens(SCRYGLASS_TOKENS),
+    tokens: SCRYGLASS_TOKENS,
+  },
+
+  runebloom: {
+    leftSegments: ["model", "git", "queue"],
+    rightSegments: ["context_pct", "time_spent"],
+    separator: "dot",
+    colors: deriveColorSchemeFromTokens(RUNEBLOOM_TOKENS),
+    tokens: RUNEBLOOM_TOKENS,
+  },
+
+  moonwell: {
+    leftSegments: ["model", "thinking", "git"],
+    rightSegments: ["context_pct", "time"],
+    separator: "slash",
+    colors: deriveColorSchemeFromTokens(MOONWELL_TOKENS),
+    tokens: MOONWELL_TOKENS,
+  },
+
+  hexforge: {
+    leftSegments: ["hostname", "model", "shell_mode", "git", "queue"],
+    rightSegments: ["tps", "open_ports", "cost", "context_pct"],
+    separator: "block",
+    colors: deriveColorSchemeFromTokens(HEXFORGE_TOKENS),
+    tokens: HEXFORGE_TOKENS,
+  },
+
+  vellum: {
+    leftSegments: ["model", "path", "git"],
+    rightSegments: ["cost", "context_pct"],
+    separator: "none",
+    colors: deriveColorSchemeFromTokens(VELLUM_TOKENS),
+    tokens: VELLUM_TOKENS,
+  },
+
+  wisp: {
+    leftSegments: ["model", "git"],
+    rightSegments: ["context_pct"],
+    separator: "none",
+    colors: deriveColorSchemeFromTokens(WISP_TOKENS),
+    tokens: WISP_TOKENS,
+  },
+
+  starweave: {
+    leftSegments: ["model", "path", "git", "subagents"],
+    rightSegments: ["token_in", "token_out", "context_pct"],
+    separator: "star",
+    colors: deriveColorSchemeFromTokens(STARWEAVE_TOKENS),
+    tokens: STARWEAVE_TOKENS,
+  },
+
+  crucible: {
+    leftSegments: ["model", "thinking", "shell_mode", "git"],
+    rightSegments: ["tps", "cost", "context_pct"],
+    separator: "block",
+    colors: deriveColorSchemeFromTokens(CRUCIBLE_TOKENS),
+    tokens: CRUCIBLE_TOKENS,
+  },
 };
 
 export function getPreset(name: string): PresetDef {
@@ -298,6 +481,7 @@ export function registerCustomPresets(
       separator: def.separator ?? "slash",
       segmentOptions: def.segmentOptions,
       colors: def.colors,
+      tokens: def.tokens,
     };
     customPresets.set(name, presetDef);
   }