@askdkc/dsh-cli 0.11.3

package/lib/types/components/trajectory/WaveBand.js

@@ -0,0 +1,150 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import chalk from 'chalk';
+import { Box, Text, useTheme } from '../../ui.js';
+import { getTheme } from '../../theme.js';
+import { alert, alive, mix } from '../../trajectory/motion.js';
+import { parseRGB } from '../Spinner/spinnerUtils.js';
+import { dominantChannel } from '../../dsh-adapter/trajectory/index.js';
+/**
+ * The wake — the whole session drawn as one row of glyphs.
+ *
+ * A session is a shape before it is a list: dense here, idle there, one red
+ * mark where it broke. Three lanes of coloured blocks (the form the official
+ * web overview uses, where vertical space is free) collapse badly into a
+ * terminal, so they are composed into a single band whose **height** carries
+ * cost and whose **colour** carries what kind of work it was.
+ *
+ * ## One row, two rows deep in information
+ *
+ * A two-row stack was tried for the extra eight levels of resolution and read
+ * WORSE: with a log scale anchored at the smallest column, a typical column
+ * lands near 55%, which in a two-row bar means "lower row solid, upper row a
+ * sliver" — the band turns into a slab. One row of eight levels, over weights
+ * that now carry real cost, produces the varied silhouette the band is for.
+ * The rows saved go to the ledger, which always wants more.
+ *
+ * ## Failures ride in the band, not above it
+ *
+ * A dedicated marker row spends a whole line to show three glyphs. A failed
+ * column is simply drawn in the failure colour instead: red among amber and
+ * violet is unmissable, and the failure becomes *part of* the session's shape
+ * rather than an annotation over it.
+ *
+ * Every animated cell changes colour only — never a glyph count, never a row
+ * count (see `trajectory/motion.ts`).
+ */
+/** Eight fill levels. */
+const BLOCKS = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'];
+const FULL = '█';
+/** A column with no activity at all. */
+const IDLE = '·';
+/** The live edge. */
+const RUNNING = '▶';
+const LEVELS = BLOCKS.length;
+/** Lane colour per channel, resolved from the active theme. */
+function channelColor(channel, theme) {
+    switch (channel) {
+        case 'input': return theme.professionalBlue;
+        case 'tool': return theme.chromeYellow;
+        case 'model': return theme.autoAccept;
+        default: return theme.subtle;
+    }
+}
+export function WaveBand({ band, width, cursorColumn, viewportStart, viewportEnd, matches, tick, alertTick, onColumnClick, }) {
+    const [themeName] = useTheme();
+    const theme = getTheme(themeName);
+    if (band.buckets.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Text, { color: "subtle", children: IDLE.repeat(Math.max(0, width)) }), _jsx(Text, { color: "subtle", children: ' '.repeat(Math.max(0, width)) })] }));
+    }
+    // Normalize between the smallest non-empty column and the p95 column, both
+    // in log space: the smallest real activity is one level, the busiest tops
+    // out, and four orders of magnitude in between stay distinguishable.
+    const logFloor = Math.log1p(Math.max(0, band.floor));
+    const logSpan = Math.max(1e-6, Math.log1p(Math.max(1, band.peak)) - logFloor);
+    const alertPhase = alert(tick, alertTick);
+    const breath = alive(tick);
+    let wave = '';
+    for (let column = 0; column < band.buckets.length; column++) {
+        const bucket = band.buckets[column];
+        const dimmed = matches !== undefined && !matches.has(column);
+        const isCursor = column === cursorColumn;
+        if (bucket.count === 0) {
+            wave += chalk.hex(toHex(theme.subtle))(IDLE);
+            continue;
+        }
+        if (bucket.running) {
+            wave += chalk.hex(toHex(mix(theme.success, theme.planMode, breath)))(RUNNING);
+            continue;
+        }
+        // 1..LEVELS — a non-empty column is never invisible.
+        const level = Math.min(LEVELS, Math.max(1, Math.round(((Math.log1p(bucket.weight) - logFloor) / logSpan) * (LEVELS - 1)) + 1));
+        const failed = bucket.error || bucket.retry;
+        const base = failed
+            ? mix(theme.error, theme.warningShimmer, alertPhase)
+            : channelColor(dominantChannel(bucket), theme);
+        const colour = dimmed
+            ? theme.subtle
+            : isCursor
+                ? mix(base, theme.permissionShimmer, 0.55)
+                : base;
+        const hex = toHex(colour);
+        // A failed column is never allowed to be one pixel tall: it is raised to
+        // at least half height so the red is visible at a glance, which is the
+        // whole point of colouring it.
+        const shown = failed ? Math.max(level, Math.ceil(LEVELS / 2)) : level;
+        wave += chalk.hex(hex)(shown >= LEVELS ? FULL : BLOCKS[shown - 1]);
+    }
+    // ── ruler: turn numbers plus the viewport bracket ─────────────────────────
+    const ruler = Array.from({ length: band.buckets.length }, () => ' ');
+    // Turn numbers, not anonymous ticks: the ruler is how `{ }` navigation is
+    // aimed. A label that would collide with the previous one degrades to a
+    // tick rather than overwriting digits into nonsense.
+    let lastLabelEnd = -Infinity;
+    for (const [turn, column] of band.turns) {
+        if (column >= ruler.length)
+            continue;
+        const label = String(turn);
+        if (column - 1 <= lastLabelEnd) {
+            ruler[column] = '╵';
+            continue;
+        }
+        for (let offset = 0; offset < label.length && column + offset < ruler.length; offset++) {
+            ruler[column + offset] = label[offset];
+        }
+        lastLabelEnd = column + label.length;
+    }
+    const from = Math.max(0, Math.min(band.buckets.length - 1, viewportStart));
+    const to = Math.max(from, Math.min(band.buckets.length - 1, viewportEnd));
+    let rulerText = '';
+    for (let column = 0; column < ruler.length; column++) {
+        const inViewport = column >= from && column <= to;
+        const glyph = inViewport ? (column === from ? '▐' : column === to ? '▌' : '▀') : ruler[column];
+        rulerText += inViewport
+            ? chalk.hex(toHex(theme.permission))(glyph)
+            : chalk.hex(toHex(theme.subtle))(glyph);
+    }
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, onClick: onColumnClick === undefined
+            ? undefined
+            : (event) => {
+                const column = Math.max(0, Math.min(band.buckets.length - 1, event.localCol));
+                onColumnClick(column, event);
+            }, children: [_jsx(Text, { children: wave }), _jsx(Text, { children: rulerText })] }));
+}
+/**
+ * Convert a theme colour to the `#rrggbb` form chalk needs.
+ *
+ * Theme values are `rgb(r,g,b)` strings; a custom theme may instead carry an
+ * ANSI name, which cannot be blended — those fall back to a neutral grey
+ * rather than crashing chalk's hex parser.
+ */
+function toHex(colour) {
+    if (colour.startsWith('#'))
+        return colour;
+    const parsed = parseRGB(colour);
+    if (parsed === null)
+        return '#8D95A6';
+    const hex = (value) => value.toString(16).padStart(2, '0');
+    return `#${hex(parsed.r)}${hex(parsed.g)}${hex(parsed.b)}`;
+}
+/** Shared by the scene so every chalk colour goes through one conversion. */
+export { toHex as waveHex };

package/lib/types/components/whaleFrames.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Pixel-whale animation frames for the startup splash, converted from
+ * the hand-drawn Excel art (the `dsh-ui-whale` frame set by @lhh010,
+ * https://github.com/lhh010/dsh-ui-whale — see also whaleIdle.ts for the
+ * ported settled-header behaviors; 25x40 cells,
+ * palette alphabet shared with Whale.tsx: D outline, B body, L belly,
+ * W mouth, H heart, Z sleep-Z, `.` transparent). All 22 source frames
+ * are here; `OPENING_SEQUENCES` packs them into three startup intros —
+ * the classic blink + spout + tail-wag combo, the heart pass, and the
+ * sleep-Z float — of which one is rolled every time the logo header
+ * mounts (see `pickOpeningSequence`): randomly at startup, and again on
+ * every `/deepseek` easter-egg replay. The header then settles static
+ * on the standard pose.
+ */
+/** One animation frame: 25 sprite rows of 40 palette characters. */
+export interface WhaleFrame {
+    /** Frame label from the source art (Chinese names kept for traceability). */
+    readonly name: string;
+    readonly rows: readonly string[];
+}
+/** The 22 hand-drawn frames (all poses from the source art, incl. heart and sleep). */
+export declare const WHALE_FRAMES: readonly WhaleFrame[];
+/** One step of an opening animation: frame index + dwell time. */
+export interface OpeningStep {
+    /** Index into WHALE_FRAMES. */
+    readonly frame: number;
+    /** How long the frame stays on screen, in milliseconds. */
+    readonly ms: number;
+}
+/** Named indices into WHALE_FRAMES (the order matches the source art). */
+export declare const WHALE_FRAME_INDEX: {
+    readonly standard: 0;
+    readonly blink: 1;
+    readonly fin1: 2;
+    readonly fin2: 3;
+    readonly spout1: 4;
+    readonly spout2: 5;
+    readonly spout3: 6;
+    readonly spout4: 7;
+    readonly spout5: 8;
+    readonly spout6: 9;
+    readonly tail1: 10;
+    readonly tail2: 11;
+    readonly tail3: 12;
+    readonly tail4: 13;
+    readonly heart1: 14;
+    readonly heart2: 15;
+    readonly heart3: 16;
+    readonly sleep1: 17;
+    readonly sleep2: 18;
+    readonly sleep3: 19;
+    readonly sleep4: 20;
+    readonly sleep5: 21;
+};
+/**
+ * The three intro animations; each one ends back on the standard pose.
+ * The base actions (blink, fin, tail, spout) stay bundled in the classic
+ * opener as they were — only the behaviors the TUI never had (heart,
+ * sleep) get their own standalone intro.
+ */
+export type WhaleIntroId = 'classic' | 'heart' | 'sleep';
+/** All intro ids, in a stable order (drives the random pick). */
+export declare const WHALE_INTRO_IDS: readonly WhaleIntroId[];
+/**
+ * One startup intro per behavior, mirroring the source plugin's cadence:
+ * classic = the shipped opener (blink → one-way water-spout bloom → full
+ * 1→2→3→4→3→2→1 tail wag); heart = a pink heart growing small→large in
+ * the top-left corner; sleep = gray Z's rising above the blowhole, then
+ * settling back to rest.
+ */
+export declare const OPENING_SEQUENCES: Record<WhaleIntroId, readonly OpeningStep[]>;
+/**
+ * Roll one intro id uniformly at random. Called once per logo header
+ * mount — the startup splash and every `/deepseek` replay each roll
+ * independently. `random` is a test seam (0-based, values in [0, 1)).
+ */
+export declare function pickOpeningSequence(random?: () => number): {
+    id: WhaleIntroId;
+    sequence: readonly OpeningStep[];
+};
+//# sourceMappingURL=whaleFrames.d.ts.map

package/lib/types/components/whaleFrames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whaleFrames.d.ts","sourceRoot":"","sources":["../../../src/components/whaleFrames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,oEAAoE;AACpE,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;CACjC;AAED,uFAAuF;AACvF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAqpB7C,CAAA;AAED,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CACpB;AAED,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;CAuBpB,CAAA;AAKV;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAA;AAExD,iEAAiE;AACjE,eAAO,MAAM,eAAe,EAAE,SAAS,YAAY,EAAkC,CAAA;AAErF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CA2C1E,CAAA;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,GAAE,MAAM,MAAoB,GACjC;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,CAKxD"}