feat(tui): rename the dance easter egg to hatch

Author: elkaix

apps/pythinker-code/src/tui/commands/dispatch.ts

@@ -9,7 +9,7 @@ import type { AuthFlowController } from '../controllers/auth-flow';
 import type { BtwPanelController } from '../controllers/btw-panel';
 import type { StreamingUIController } from '../controllers/streaming-ui';
 import type { TasksBrowserController } from '../controllers/tasks-browser';
-import { tryHandleDanceCommand } from '../easter-eggs/dance';
+import { tryHandleHatchCommand } from '../easter-eggs/hatch';
 import type { ResolvedTheme } from '../theme/colors';
 import type { TUIState } from '../tui-state';
 import type {
@@ -378,10 +378,10 @@ async function executeSlashCommand(host: SlashCommandHost, input: string): Promi
       return;
     }
     case 'message':
-      // Unknown slash command: let /dance claim it before it falls through to
+      // Unknown slash command: let /hatch claim it before it falls through to
       // the model as a normal message. This runs *after* builtin and skill
       // resolution, so a real command or a same-named skill always wins.
-      if (parsedCommand !== null && tryHandleDanceCommand(host, parsedCommand)) {
+      if (parsedCommand !== null && tryHandleHatchCommand(host, parsedCommand)) {
         return;
       }
       host.sendNormalUserInput(intent.input);

apps/pythinker-code/src/tui/components/chrome/welcome.ts

@@ -6,10 +6,10 @@
 import type { Component } from '@pymodel/pi-tui';
 
 import {
-  isRainbowDancing,
-  renderDanceWelcomeLogo,
-  renderDanceWelcomeText,
-} from '#/tui/easter-eggs/dance';
+  isRainbowHatching,
+  renderHatchWelcomeLogo,
+  renderHatchWelcomeText,
+} from '#/tui/easter-eggs/hatch';
 import type { AppState } from '#/tui/types';
 import type { GitStatusCache } from '#/utils/git/git-status';
 
@@ -45,7 +45,7 @@ export class WelcomeComponent implements Component, WelcomeLogoAnimationHost {
   ) {
     this.state = state;
     this.gitCache = createWelcomeGitCache(state.workDir);
-    if (requestRender !== undefined && welcomeLogoAnimationEnabled() && !isRainbowDancing()) {
+    if (requestRender !== undefined && welcomeLogoAnimationEnabled() && !isRainbowHatching()) {
       this.eyeAnimator = new WelcomeLogoAnimator(this, requestRender);
       queueMicrotask(() => this.eyeAnimator?.start());
     }
@@ -70,21 +70,21 @@ export class WelcomeComponent implements Component, WelcomeLogoAnimationHost {
 
   render(width: number): string[] {
     const isLoggedOut = !this.state.model;
-    const copy = isRainbowDancing()
+    const copy = isRainbowHatching()
       ? (() => {
           const text = buildWelcomeCopyText(isLoggedOut);
           return {
-            head: renderDanceWelcomeText(text.head, 2, true),
-            strapline: renderDanceWelcomeText(text.strapline, 5),
-            prompt: renderDanceWelcomeText(text.prompt),
+            head: renderHatchWelcomeText(text.head, 2, true),
+            strapline: renderHatchWelcomeText(text.strapline, 5),
+            prompt: renderHatchWelcomeText(text.prompt),
           };
         })()
       : buildWelcomeCopy(isLoggedOut);
     const logoLines = renderPythinkerLogoWithEyes(
       this.eyeBlinkState,
       this.antennaFrame ?? undefined,
     );
-    const renderedLogo = isRainbowDancing() ? renderDanceWelcomeLogo(logoLines) : logoLines;
+    const renderedLogo = isRainbowHatching() ? renderHatchWelcomeLogo(logoLines) : logoLines;
 
     return renderWelcomeBanner({
       width,

apps/pythinker-code/src/tui/constant/tips.ts

@@ -19,7 +19,7 @@ export const WORKING_TIPS: readonly ToolbarTip[] = [
   { text: 'ctrl-s to add guidance without waiting for the turn to finish', priority: 2, solo: true },
   { text: '/tasks to check progress and status for background tasks', priority: 2 },
   { text: '/init: generate AGENTS.md', priority: 2 },
-  { text: 'Try /dance for a hidden Easter egg' },
+  { text: 'Try /hatch for a hidden Easter egg' },
   {
     text: '/plugins: manage plugins — try the "Pythinker Datasource" for reliable financial, economic, and academic data',
     solo: true,

…hinker-code/src/tui/easter-eggs/dance.ts …hinker-code/src/tui/easter-eggs/hatch.tsapps/pythinker-code/src/tui/easter-eggs/dance.ts renamed to apps/pythinker-code/src/tui/easter-eggs/hatch.ts apps/pythinker-code/src/tui/easter-eggs/dance.ts renamed to apps/pythinker-code/src/tui/easter-eggs/hatch.ts

@@ -1,5 +1,5 @@
 /**
- * `/dance` easter egg — everything it needs lives in this one file: the
+ * `/hatch` easter egg — everything it needs lives in this one file: the
  * rainbow text coloring, the animation state machine, and the command handler.
  * Removing the feature is "delete this file + its import sites".
  *
@@ -16,9 +16,9 @@ import type { ParsedSlashInput } from '../commands/types';
 import { currentTheme } from '../theme';
 
 /** Frame interval for the rainbow flow animation. */
-export const DANCE_FRAME_MS = 110;
+export const HATCH_FRAME_MS = 110;
 /** How long the rainbow flows before settling (fading out, or freezing). */
-export const DANCE_FLOW_MS = 3000;
+export const HATCH_FLOW_MS = 3000;
 
 const DARK_RAINBOW = [
   '#4FA8FF',
@@ -43,7 +43,7 @@ const LIGHT_RAINBOW = [
   '#354CB5',
 ] as const;
 
-function getDanceRainbowPalette(): readonly [string, ...string[]] {
+function getHatchRainbowPalette(): readonly [string, ...string[]] {
   return currentTheme.palette.text === '#1A1A1A' ? LIGHT_RAINBOW : DARK_RAINBOW;
 }
 
@@ -66,69 +66,69 @@ export function rainbowText(
     .join('');
 }
 
-/** Read-only view of the dance state for components that only render it. */
-export interface RainbowDanceView {
+/** Read-only view of the hatch state for components that only render it. */
+export interface RainbowHatchView {
   /** Whether consumers should paint themselves in rainbow at all. */
   readonly colored: boolean;
   /** Palette offset, advancing while the rainbow flows. */
   readonly phase: number;
 }
 
-export interface RainbowDanceController extends RainbowDanceView {
+export interface RainbowHatchController extends RainbowHatchView {
   start(opts: { hold: boolean }): void;
   stop(): void;
   dispose(): void;
 }
 
-let currentDanceController: RainbowDanceController | undefined;
-let currentDanceView: RainbowDanceView | undefined;
+let currentHatchController: RainbowHatchController | undefined;
+let currentHatchView: RainbowHatchView | undefined;
 
-export function setRainbowDance(dance: RainbowDanceController | undefined): void {
-  currentDanceController = dance;
-  currentDanceView = dance;
+export function setRainbowHatch(hatch: RainbowHatchController | undefined): void {
+  currentHatchController = hatch;
+  currentHatchView = hatch;
 }
 
-export function installRainbowDance(requestRender: () => void): () => void {
-  currentDanceController?.dispose();
-  const dance = new RainbowDance(requestRender);
-  setRainbowDance(dance);
+export function installRainbowHatch(requestRender: () => void): () => void {
+  currentHatchController?.dispose();
+  const hatch = new RainbowHatch(requestRender);
+  setRainbowHatch(hatch);
   return () => {
-    dance.dispose();
-    if (currentDanceController === dance) {
-      setRainbowDance(undefined);
+    hatch.dispose();
+    if (currentHatchController === hatch) {
+      setRainbowHatch(undefined);
     }
   };
 }
 
-export function getRainbowDanceView(): RainbowDanceView | undefined {
-  return currentDanceView;
+export function getRainbowHatchView(): RainbowHatchView | undefined {
+  return currentHatchView;
 }
 
-export function isRainbowDancing(): boolean {
-  return currentDanceView?.colored === true;
+export function isRainbowHatching(): boolean {
+  return currentHatchView?.colored === true;
 }
 
-export function renderDanceWelcomeText(
+export function renderHatchWelcomeText(
   text: string,
   offset = 0,
   bold = false,
 ): string {
   return rainbowText(
     text,
-    getDanceRainbowPalette(),
-    (currentDanceView?.phase ?? 0) + offset,
+    getHatchRainbowPalette(),
+    (currentHatchView?.phase ?? 0) + offset,
     bold,
   );
 }
 
-export function renderDanceWelcomeLogo(logoLines: readonly string[]): string[] {
-  const phase = currentDanceView?.phase ?? 0;
-  const palette = getDanceRainbowPalette();
+export function renderHatchWelcomeLogo(logoLines: readonly string[]): string[] {
+  const phase = currentHatchView?.phase ?? 0;
+  const palette = getHatchRainbowPalette();
   return logoLines.map((line, index) => rainbowText(line, palette, phase + index * 3));
 }
 
-export function renderDanceFooterModel(modelLabel: string): string {
-  return rainbowText(modelLabel, getDanceRainbowPalette(), currentDanceView?.phase ?? 0);
+export function renderHatchFooterModel(modelLabel: string): string {
+  return rainbowText(modelLabel, getHatchRainbowPalette(), currentHatchView?.phase ?? 0);
 }
 
 /**
@@ -137,7 +137,7 @@ export function renderDanceFooterModel(modelLabel: string): string {
  * scrolling away or being rebuilt never disturbs the animation. Three states:
  * off (default), flowing, and a frozen static rainbow.
  */
-export class RainbowDance implements RainbowDanceController {
+export class RainbowHatch implements RainbowHatchController {
   private currentPhase = 0;
   private isColored = false;
   private frameTimer: ReturnType<typeof setInterval> | null = null;
@@ -157,7 +157,7 @@ export class RainbowDance implements RainbowDanceController {
   }
 
   /**
-   * Flow the rainbow for `DANCE_FLOW_MS`, then settle:
+   * Flow the rainbow for `HATCH_FLOW_MS`, then settle:
    *  - `hold: false` → fade back to the default (uncolored) banner.
    *  - `hold: true`  → freeze into a static rainbow that stays on.
    */
@@ -166,13 +166,13 @@ export class RainbowDance implements RainbowDanceController {
     this.isColored = true;
     this.frameTimer = setInterval(() => {
       // Phase just increments; rainbowText() takes it modulo the *current*
-      // palette length, so the dance never needs to know the palette size.
+      // palette length, so the hatch never needs to know the palette size.
       this.currentPhase += 1;
       this.requestRender();
-    }, DANCE_FRAME_MS);
+    }, HATCH_FRAME_MS);
     this.flowStopTimer = setTimeout(() => {
       this.settle(opts.hold);
-    }, DANCE_FLOW_MS);
+    }, HATCH_FLOW_MS);
     this.requestRender();
   }
 
@@ -215,16 +215,16 @@ export class RainbowDance implements RainbowDanceController {
 }
 
 /**
- * Handle `/dance`:
- *   /dance       flow for a few seconds, then fade back to the default colors
- *   /dance on    flow, then freeze into a static rainbow that stays on
- *   /dance off   turn the rainbow off
+ * Handle `/hatch`:
+ *   /hatch       flow for a few seconds, then fade back to the default colors
+ *   /hatch on    flow, then freeze into a static rainbow that stays on
+ *   /hatch off   turn the rainbow off
  *
  * Returns true when it claimed the input.
  */
-export function tryHandleDanceCommand(host: SlashCommandHost, parsed: ParsedSlashInput): boolean {
-  if (parsed.name !== 'dance') return false;
-  if (currentDanceController === undefined) return false;
+export function tryHandleHatchCommand(host: SlashCommandHost, parsed: ParsedSlashInput): boolean {
+  if (parsed.name !== 'hatch') return false;
+  if (currentHatchController === undefined) return false;
 
   // The status line dims the whole message, which buried the command in the
   // hint. Paint just the command in the brand color (bold) so it reads as a
@@ -233,13 +233,13 @@ export function tryHandleDanceCommand(host: SlashCommandHost, parsed: ParsedSlas
 
   const sub = parsed.args.trim().toLowerCase();
   if (sub === 'off') {
-    currentDanceController.stop();
+    currentHatchController.stop();
   } else if (sub === 'on') {
-    currentDanceController.start({ hold: true });
-    host.showStatus(`Dancing — use ${cmd('/dance off')} to turn it off.`);
+    currentHatchController.start({ hold: true });
+    host.showStatus(`Hatching — use ${cmd('/hatch off')} to turn it off.`);
   } else {
-    currentDanceController.start({ hold: false });
-    host.showStatus(`Use ${cmd('/dance on')} to keep the rainbow on.`);
+    currentHatchController.start({ hold: false });
+    host.showStatus(`Use ${cmd('/hatch on')} to keep the rainbow on.`);
   }
   return true;
 }

apps/pythinker-code/test/tui/components/chrome/welcome.test.ts

@@ -8,7 +8,7 @@ import {
   renderWelcomeBanner,
 } from '#/tui/components/chrome/welcome-banner';
 import { WelcomeComponent } from '#/tui/components/chrome/welcome';
-import { setRainbowDance, type RainbowDanceController } from '#/tui/easter-eggs/dance';
+import { setRainbowHatch, type RainbowHatchController } from '#/tui/easter-eggs/hatch';
 import type { AppState } from '#/tui/types';
 
 const TRUECOLOR_PATTERN = /\u001B\[38;2;(\d+);(\d+);(\d+)m/g;
@@ -59,15 +59,15 @@ function headerOf(lines: string[]): string {
   return [lines[3], lines[4]].join('\n');
 }
 
-function setDanceView(colored: boolean, phase: number): void {
-  const dance: RainbowDanceController = {
+function setHatchView(colored: boolean, phase: number): void {
+  const hatch: RainbowHatchController = {
     colored,
     phase,
     start: () => {},
     stop: () => {},
     dispose: () => {},
   };
-  setRainbowDance(dance);
+  setRainbowHatch(hatch);
 }
 
 describe('WelcomeComponent', () => {
@@ -79,27 +79,27 @@ describe('WelcomeComponent', () => {
 
   afterEach(() => {
     chalk.level = previousChalkLevel;
-    setRainbowDance(undefined);
+    setRainbowHatch(undefined);
   });
 
   it('renders the branded banner with semantic logo colors by default', () => {
     const codes = truecolorCodes(headerOf(new WelcomeComponent(appState).render(80)));
 
     // The static logo uses themed accent, body, and border tokens; rainbow is
-    // still off until /dance is activated.
+    // still off until /hatch is activated.
     expect(codes.size).toBeGreaterThanOrEqual(3);
   });
 
   it('paints the banner in rainbow while colored', () => {
-    setDanceView(true, 0);
+    setHatchView(true, 0);
     const codes = truecolorCodes(headerOf(new WelcomeComponent(appState).render(80)));
 
     expect(codes.size).toBeGreaterThanOrEqual(5);
   });
 
   it('renders exactly the default banner when not colored', () => {
     const base = headerOf(new WelcomeComponent(appState).render(80));
-    setDanceView(false, 5);
+    setHatchView(false, 5);
     const off = headerOf(new WelcomeComponent(appState).render(80));
 
     expect(off).toBe(base);