@groeponline/pi-wishcraft 1.0.5 → 1.2.0

package/src/signal/integration.ts

@@ -0,0 +1,42 @@
+import type { MotionEvent } from "../motion/index.ts";
+import { effectiveAppearanceMix, resolveAppearanceMix } from "../config/appearance.ts";
+import type { AppearanceMixConfig } from "../config/types.ts";
+import { config } from "../extension/core/state.ts";
+import type { RuntimeState } from "../extension/core/types.ts";
+import { setSignalEvent, stopSignal } from "./controller.ts";
+
+export function dispatchSignalEvent(
+  rt: RuntimeState,
+  appearance: AppearanceMixConfig,
+  event: MotionEvent,
+  activity?: string,
+): void {
+  const resolved = resolveAppearanceMix(
+    effectiveAppearanceMix(appearance, config.preset),
+  );
+  setSignalEvent(rt.signal, rt.motionScheduler, rt.motionPolicy, event, {
+    activity,
+    motionId: resolved.motion[event] ?? resolved.signal.animation,
+    maxTicks: isFiniteEvent(event) ? 6 : undefined,
+  });
+  rt.lastLayoutResult = null;
+  rt.tuiRef?.requestRender();
+}
+
+export function settleSignal(rt: RuntimeState): void {
+  stopSignal(rt.signal, rt.motionScheduler, rt.motionPolicy);
+  rt.lastLayoutResult = null;
+  rt.tuiRef?.requestRender();
+}
+
+function isFiniteEvent(event: MotionEvent): boolean {
+  return (
+    event === "tool.end" ||
+    event === "idea.capture" ||
+    event === "skill.insert" ||
+    event === "policy.deny" ||
+    event === "success" ||
+    event === "warning" ||
+    event === "error"
+  );
+}

package/src/signal/render.ts

@@ -0,0 +1,178 @@
+/**
+ * Three-lane Signal renderer.
+ *
+ * Left: model/repository state. Center: live semantic activity and motion rail.
+ * Right: context/queue/usage. Modules retain the existing per-segment fault
+ * isolation because every item still renders through `renderSegment`.
+ */
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type {
+  PresetDef,
+  SegmentContext,
+  SignalSpec,
+  StatusLineSegmentId,
+  StatusLineSeparatorStyle,
+} from "../config/types.ts";
+import { mergeSegmentsWithCustomItems } from "../config/powerline-config.ts";
+import { renderSegment } from "../segments/index.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../theme/colors.ts";
+import { getSeparator } from "../theme/separators.ts";
+import { frameAt, getMotion } from "../motion/index.ts";
+import type { SignalRuntime } from "./controller.ts";
+
+export interface SignalRenderOptions {
+  separatorStyle: StatusLineSeparatorStyle;
+  signal: SignalSpec;
+  ascii?: boolean;
+  layout?: import("../config/types.ts").StatusLineLayout | null;
+  disabledSegments?: StatusLineSegmentId[];
+}
+
+interface Module {
+  content: string;
+  width: number;
+}
+
+export function renderSignal(
+  ctx: SegmentContext,
+  preset: PresetDef,
+  runtime: SignalRuntime,
+  availableWidth: number,
+  options: SignalRenderOptions,
+): { topContent: string; secondaryContent: string } {
+  const merged = mergeSegmentsWithCustomItems(
+    preset,
+    ctx.effectiveCustomItems,
+    {
+      layout: options.layout ?? null,
+      disabledSegments: options.disabledSegments ?? [],
+    },
+  );
+  const left = renderModules(merged.leftSegments, ctx);
+  const right = renderModules(merged.rightSegments, ctx);
+  const secondary = renderModules(merged.secondarySegments, ctx);
+  const separator = getSeparator(options.separatorStyle).left;
+
+  const center = renderActivity(runtime, options.signal, options.ascii);
+  const top = fitLanes(left, center, right, separator, availableWidth);
+  return {
+    topContent: top,
+    secondaryContent: joinModules(secondary, separator, availableWidth),
+  };
+}
+
+function renderModules(ids: readonly StatusLineSegmentId[], ctx: SegmentContext): Module[] {
+  const modules: Module[] = [];
+  for (const id of ids) {
+    // renderSegment is the established per-module error boundary.
+    const rendered = renderSegment(id, ctx);
+    if (!rendered.visible || !rendered.content) continue;
+    modules.push({
+      content: rendered.content,
+      width: visibleWidth(rendered.content),
+    });
+  }
+  return modules;
+}
+
+export function renderActivity(
+  runtime: SignalRuntime,
+  spec: SignalSpec,
+  ascii = false,
+): string {
+  const def = getMotion(runtime.motionId) ?? getMotion(spec.animation);
+  const glyph = def
+    ? frameAt(def, runtime.tick, ascii)
+    : ascii
+      ? "*"
+      : "◆";
+  const label = runtime.activity || "ready";
+  const open = spec.caps.leftOpen ?? "";
+  const close = spec.caps.leftClose ?? "";
+  const dim = getFgAnsiCode("sep");
+  const reset = colorEnabled() ? ansi.reset : "";
+  const rail = runtime.active
+    ? `${spec.separators.left}${glyph}${spec.separators.right}`
+    : `${spec.separators.left}${spec.separators.right}`;
+  return `${dim}${open}${rail}${close}${reset} ${label}`;
+}
+
+function fitLanes(
+  leftInput: Module[],
+  center: string,
+  rightInput: Module[],
+  separator: string,
+  availableWidth: number,
+): string {
+  if (availableWidth <= 0) return "";
+  const left = [...leftInput];
+  const right = [...rightInput];
+  const sep = styledSeparator(separator);
+  const centerWidth = visibleWidth(center);
+
+  const lane = (modules: Module[]) => modules.map((module) => module.content).join(sep);
+  const totalWidth = () => {
+    const leftText = lane(left);
+    const rightText = lane(right);
+    return (
+      visibleWidth(leftText) +
+      visibleWidth(rightText) +
+      centerWidth +
+      (leftText ? 2 : 0) +
+      (rightText ? 2 : 0)
+    );
+  };
+
+  // Preserve the model/git side first, then context/queue. Remove the least
+  // important outer modules until all three lanes fit.
+  while (totalWidth() + 2 > availableWidth && right.length > 1) right.shift();
+  while (totalWidth() + 2 > availableWidth && left.length > 1) left.pop();
+  while (totalWidth() + 2 > availableWidth && right.length > 0) right.shift();
+  while (totalWidth() + 2 > availableWidth && left.length > 0) left.pop();
+
+  const leftText = lane(left);
+  const rightText = lane(right);
+  if (centerWidth + 2 > availableWidth) {
+    return ` ${truncatePlain(center, Math.max(0, availableWidth - 2))} `;
+  }
+
+  const contentWidth =
+    visibleWidth(leftText) +
+    visibleWidth(rightText) +
+    centerWidth +
+    (leftText ? 2 : 0) +
+    (rightText ? 2 : 0);
+  const flexible = Math.max(0, availableWidth - 2 - contentWidth);
+  const before = leftText ? "  " : "";
+  const after = rightText ? "  " : "";
+  // Extra space lives between center and right, keeping state metrics pinned.
+  return ` ${leftText}${before}${center}${after}${" ".repeat(flexible)}${rightText} `;
+}
+
+function joinModules(modules: Module[], separator: string, width: number): string {
+  if (modules.length === 0) return "";
+  const sep = styledSeparator(separator);
+  const fitted: Module[] = [];
+  let used = 2;
+  for (const module of modules) {
+    const next = module.width + (fitted.length ? visibleWidth(separator) + 2 : 0);
+    if (used + next > width) break;
+    fitted.push(module);
+    used += next;
+  }
+  return fitted.length ? ` ${fitted.map((module) => module.content).join(sep)} ` : "";
+}
+
+function styledSeparator(separator: string): string {
+  const color = getFgAnsiCode("sep");
+  const reset = colorEnabled() ? ansi.reset : "";
+  return ` ${color}${separator}${reset} `;
+}
+
+function truncatePlain(text: string, width: number): string {
+  if (width <= 0) return "";
+  // Activity labels are ASCII; strip ANSI before this emergency narrow path.
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, "");
+  return plain.length <= width ? plain : plain.slice(0, Math.max(0, width - 1)) + "…";
+}

package/src/theme/colors.ts

@@ -12,6 +12,18 @@ export const ansi: AnsiColors = {
   reset: "\x1b[0m",
 };
 
+// ponytail: NO_COLOR (de-facto standard — present and non-empty) disables all
+// wishcraft color so the status bar stays plain text in no-color terminals
+// and color-blind pipelines. Computed lazily so test env changes take effect.
+let _colorEnabled: boolean | undefined;
+export function colorEnabled(): boolean {
+  if (_colorEnabled === undefined) {
+    const v = process.env.NO_COLOR;
+    _colorEnabled = !(v != null && v !== "");
+  }
+  return _colorEnabled;
+}
+
 function hexToRgb(hex: string): [number, number, number] {
   const cleanHex = hex.startsWith("#") ? hex.slice(1) : hex;
   if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
@@ -51,10 +63,12 @@ for (const key of Object.keys(PALETTE)) {
 }
 
 export function fgOnly(color: ColorName, text: string): string {
+  if (!colorEnabled()) return text;
   const code = ansiCodeCache.get(color as string) ?? "";
   return code ? `${code}${text}` : text;
 }
 
 export function getFgAnsiCode(color: ColorName): string {
+  if (!colorEnabled()) return "";
   return ansiCodeCache.get(color as string) ?? "";
 }

package/src/theme/detect.ts

@@ -0,0 +1,48 @@
+/**
+ * Terminal and host capability detection. Pure: reads an env map, no process
+ * globals except the default argument. Motion policy is assembled elsewhere
+ * so this file stays free of the motion engine.
+ */
+
+export interface TerminalEnvironment {
+  noColor: boolean;
+  lowColor: boolean;
+  screenReader: boolean;
+  reducedMotion: boolean;
+  dumb: boolean;
+}
+
+const MOTION_LEVELS = ["full", "reduced", "functional", "off"] as const;
+
+export function detectEnvironment(
+  env: NodeJS.ProcessEnv = process.env,
+): TerminalEnvironment {
+  const term = (env.TERM ?? "").toLowerCase();
+  const colorterm = (env.COLORTERM ?? "").toLowerCase();
+  const noColor = env.NO_COLOR !== undefined && env.NO_COLOR !== "";
+  const dumb = term === "dumb" || term === "";
+  const lowColor =
+    !colorterm.includes("truecolor") &&
+    !colorterm.includes("24bit") &&
+    (term.includes("vt100") || term === "linux" || /\bansi\b/.test(term));
+  const screenReader =
+    env.WISHCRAFT_SCREEN_READER === "1" ||
+    env.ACCESSIBILITY_SCREEN_READER === "1" ||
+    env.NVDA !== undefined ||
+    env.VOICEOVER === "1";
+  const reducedMotion =
+    env.WISHCRAFT_REDUCED_MOTION === "1" ||
+    env.PREFER_REDUCED_MOTION === "1" ||
+    env.MOZ_PREFER_REDUCED_MOTION === "1";
+
+  return { noColor, lowColor: lowColor && !noColor, screenReader, reducedMotion, dumb };
+}
+
+export function motionLevelFromEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): (typeof MOTION_LEVELS)[number] | null {
+  const raw = (env.WISHCRAFT_MOTION ?? "").toLowerCase();
+  return (MOTION_LEVELS as readonly string[]).includes(raw)
+    ? (raw as (typeof MOTION_LEVELS)[number])
+    : null;
+}

package/src/theme/tokens/index.ts

@@ -0,0 +1,9 @@
+/**
+ * src/theme/tokens/index.ts
+ * ---------------------------------------------------------------------------
+ * Public exports for Wishcraft Semantic Design Tokens.
+ * ---------------------------------------------------------------------------
+ */
+
+export * from "./types.ts";
+export * from "./mapping.ts";

package/src/theme/tokens/mapping.ts

@@ -0,0 +1,62 @@
+/**
+ * src/theme/tokens/mapping.ts
+ * ---------------------------------------------------------------------------
+ * Default token mapping and legacy SemanticColor bridge for Wishcraft.
+ * ---------------------------------------------------------------------------
+ */
+
+import type { ColorScheme, SemanticColor } from "../../config/types.ts";
+import type { WishcraftTokens } from "./types.ts";
+
+export const DEFAULT_TOKENS: WishcraftTokens = {
+  surface: "#0f172a",
+  surfaceRaised: "#1e293b",
+  text: "#f8fafc",
+  textMuted: "dim",
+  primary: "#f59e0b",
+  secondary: "#00afaf",
+  accent: "#ea580c",
+  success: "success",
+  warning: "warning",
+  error: "error",
+  focus: "#38bdf8",
+  selection: "#334155",
+  motionDim: "dim",
+  motionHot: "#fbbf24",
+  motionTrail: "#78350f",
+};
+
+/**
+ * Derives legacy SemanticColor configuration from modern WishcraftTokens.
+ */
+export function deriveColorSchemeFromTokens(tokens: WishcraftTokens): Required<ColorScheme> {
+  return {
+    model: tokens.primary,
+    shellMode: tokens.accent,
+    path: tokens.secondary,
+    gitClean: tokens.success,
+    gitDirty: tokens.warning,
+    thinking: "thinkingOff",
+    thinkingMinimal: "thinkingMinimal",
+    thinkingLow: "thinkingLow",
+    thinkingMedium: "thinkingMedium",
+    context: tokens.textMuted,
+    contextWarn: tokens.warning,
+    contextError: tokens.error,
+    cost: tokens.text,
+    tokens: tokens.textMuted,
+    queue: tokens.accent,
+    separator: tokens.textMuted,
+    border: tokens.surfaceRaised,
+  };
+}
+
+/**
+ * Creates WishcraftTokens by merging overrides onto defaults.
+ */
+export function createTokens(overrides?: Partial<WishcraftTokens>): WishcraftTokens {
+  return {
+    ...DEFAULT_TOKENS,
+    ...overrides,
+  };
+}

package/src/theme/tokens/types.ts

@@ -0,0 +1,39 @@
+/**
+ * src/theme/tokens/types.ts
+ * ---------------------------------------------------------------------------
+ * Semantic Design Tokens for Wishcraft (Crush pattern).
+ * ---------------------------------------------------------------------------
+ */
+
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+export type ColorValue = ThemeColor | `#${string}`;
+
+export interface WishcraftTokens {
+  // Surfaces & Backgrounds
+  surface: ColorValue;
+  surfaceRaised: ColorValue;
+
+  // Typography
+  text: ColorValue;
+  textMuted: ColorValue;
+
+  // Brand & Accents
+  primary: ColorValue;
+  secondary: ColorValue;
+  accent: ColorValue;
+
+  // Feedback & State
+  success: ColorValue;
+  warning: ColorValue;
+  error: ColorValue;
+
+  // Interaction
+  focus: ColorValue;
+  selection: ColorValue;
+
+  // Motion & Animation Channels
+  motionDim: ColorValue;
+  motionHot: ColorValue;
+  motionTrail: ColorValue;
+}

package/src/welcome/renderer.ts

@@ -1,5 +1,5 @@
 import { visibleWidth } from "@earendil-works/pi-tui";
-import { ansi, fgOnly, getFgAnsiCode } from "../theme/colors.ts";
+import { ansi, colorEnabled, fgOnly, getFgAnsiCode } from "../theme/colors.ts";
 import { centerText, fitToWidth, getBoxLayout } from "./layout.ts";
 import type { WelcomeData, WelcomeWidget, WidgetRenderContext } from "./types.ts";
 
@@ -32,7 +32,7 @@ function bold(text: string): string {
 }
 
 export function dim(text: string): string {
-  return getFgAnsiCode("sep") + text + ansi.reset;
+  return getFgAnsiCode("sep") + text + (colorEnabled() ? ansi.reset : "");
 }
 
 function gradientLine(line: string): string {

package/src/welcome/whats-new.ts

@@ -16,6 +16,9 @@ import { getAgentPath } from "../paths/agent-dirs.ts";
 
 const MAX_WHATSNEW_LINES = 8;
 const WHATS_NEW_STATE_FILE = "whats-new.json";
+// First GroepOnline release. On a first run (no stored version) the welcome
+// panel shows history from here forward, never the pre-1.0 `0.x` prehistory.
+const FIRST_OWN_RELEASE = "1.0.0";
 
 const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -37,38 +40,71 @@ function isVersionNewer(version: string, lastSeen: string | null): boolean {
   return false;
 }
 
+function isVersionAtOrNewer(version: string, floor: string): boolean {
+  const next = parseVersion(version);
+  const min = parseVersion(floor);
+  if (!next || !min) return false;
+  for (let i = 0; i < 3; i++) {
+    if (next[i] > min[i]) return true;
+    if (next[i] < min[i]) return false;
+  }
+  return true;
+}
+
 /**
  * Extract the bullet lines from released changelog sections whose version is
- * strictly newer than `lastSeenVersion` (null = first run, so the newest
- * sections win). Markdown bold markers are stripped; backticks are kept so
- * commands like `/powerline doctor` stay readable in the terminal.
+ * strictly newer than `lastSeenVersion`. On a first run (`lastSeenVersion` is
+ * null) `floorVersion` becomes the lower bound, so the panel shows history from
+ * the first own release forward and skips the pre-1.0 prehistory. Sections are
+ * returned oldest-first (chronological "since your last version") and capped at
+ * `maxLines`. Markdown bold markers are stripped; backticks are kept so commands
+ * like `/powerline doctor` stay readable in the terminal.
  */
 export function parseChangelogDelta(
   changelog: string,
   lastSeenVersion: string | null,
   maxLines: number = MAX_WHATSNEW_LINES,
+  floorVersion: string | null = FIRST_OWN_RELEASE,
 ): string[] {
-  const entries: string[] = [];
-  let includeSection = false;
+  // The changelog is newest-first; collect per section, then reverse to read
+  // oldest-first before capping.
+  const sections: string[][] = [];
+  let current: string[] | null = null;
+  // A stored last-seen version is a strict lower bound (only strictly newer
+  // sections). On a first run the floor is inclusive, so the first own release
+  // itself is shown while the pre-1.0 prehistory is skipped.
+  const matchesBound =
+    lastSeenVersion !== null
+      ? (version: string) => isVersionNewer(version, lastSeenVersion)
+      : floorVersion !== null
+        ? (version: string) => isVersionAtOrNewer(version, floorVersion)
+        : () => true;
 
   for (const rawLine of changelog.split("\n")) {
     const line = rawLine.trimEnd();
     const versionMatch = line.match(/^##\s+\[([^\]]+)\]/);
     if (versionMatch) {
       const version = versionMatch[1].trim();
-      includeSection =
-        version !== "Unreleased" && isVersionNewer(version, lastSeenVersion);
+      const include = version !== "Unreleased" && matchesBound(version);
+      current = include ? [] : null;
+      if (current) sections.push(current);
       continue;
     }
-    if (!includeSection) continue;
+    if (!current) continue;
     if (!line.startsWith("- ")) continue;
 
     const cleaned = line.slice(2).trim().replace(/\*\*/g, "").trim();
     if (!cleaned) continue;
-    entries.push(cleaned);
-    if (entries.length >= maxLines) break;
+    current.push(cleaned);
   }
 
+  const entries: string[] = [];
+  for (const section of sections.reverse()) {
+    for (const entry of section) {
+      entries.push(entry);
+      if (entries.length >= maxLines) return entries;
+    }
+  }
   return entries;
 }