@stevezhou/sisu 0.1.4 → 0.1.6

package/dist/logo.js

@@ -1,16 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sisuMarkLines = exports.sisuMarkArt = void 0;
+exports.sisuTreeLines = exports.sisuTreeArt = exports.sisuMarkLines = exports.sisuMarkArt = void 0;
 exports.sisuMobiusArt = sisuMobiusArt;
 exports.sisuWordmark = sisuWordmark;
+exports.displayWidth = displayWidth;
+exports.sisuSplashFrame = sisuSplashFrame;
+exports.sisuSplashHeight = sisuSplashHeight;
 exports.sisuSplash = sisuSplash;
+exports.sisuWelcomeCopy = sisuWelcomeCopy;
 exports.sisuBanner = sisuBanner;
 exports.stripAnsi = stripAnsi;
 var mark_1 = require("./mark");
 Object.defineProperty(exports, "sisuMarkArt", { enumerable: true, get: function () { return mark_1.sisuMarkArt; } });
 Object.defineProperty(exports, "sisuMarkLines", { enumerable: true, get: function () { return mark_1.sisuMarkLines; } });
+var tree_1 = require("./tree");
+Object.defineProperty(exports, "sisuTreeArt", { enumerable: true, get: function () { return tree_1.sisuTreeArt; } });
+Object.defineProperty(exports, "sisuTreeLines", { enumerable: true, get: function () { return tree_1.sisuTreeLines; } });
 const mark_2 = require("./mark");
 const mobius_1 = require("./mobius");
+const tree_2 = require("./tree");
+const RESET = '\x1b[0m';
+const TERRACOTTA = '\x1b[38;2;184;90;58m';
+const INK = '\x1b[38;2;220;214;204m';
+const INK_DIM = '\x1b[38;2;140;132;120m';
+const HEADLINE = '思有所溯';
+const TAGLINE = '为科研而生的工作台——记录退到思考之后，不打扰任何一念。';
+const COLOPHON = [
+    '对话、文献与数据，落笔成档',
+    '每个结论，都能沿枝回到它的根',
+    '众人的知识彼此嫁接，长成一片林',
+];
+const NUMERALS = ['一', '二', '三'];
 function sisuMobiusArt(columns = 80, phase = 0, color = false) {
     return (0, mobius_1.renderMobiusFrame)({
         cols: (0, mobius_1.mobiusFrameWidth)(columns),
@@ -22,16 +42,147 @@ function sisuMobiusArt(columns = 80, phase = 0, color = false) {
 function sisuWordmark() {
     return ['思溯', 'SISU'].join('\n');
 }
-/** Splash used on TUI enter: the web Möbius mark plus 思溯. */
+/** Terminal cells, not JS string length — CJK and ∞ must sit on the grid. */
+function displayWidth(text) {
+    let width = 0;
+    for (const ch of stripAnsi(text)) {
+        const code = ch.codePointAt(0) ?? 0;
+        width += isWide(code) ? 2 : 1;
+    }
+    return width;
+}
+function isWide(code) {
+    return ((code >= 0x1100 && code <= 0x115f) ||
+        (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe10 && code <= 0xfe19) ||
+        (code >= 0xfe30 && code <= 0xfe6f) ||
+        (code >= 0xff00 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6));
+}
+function paint(text, prefix, color) {
+    if (!color || !text)
+        return text;
+    return `${prefix}${text}${RESET}`;
+}
+function infinityMark(color) {
+    if (!color)
+        return '∞';
+    const [r, g, b] = (0, mark_2.markRgb)(0, 2);
+    return `\x1b[38;2;${r};${g};${b}m∞${RESET}`;
+}
+function lockup(color) {
+    const inf = infinityMark(color);
+    const name = paint('思溯', INK, color);
+    const latin = paint('SiSu', INK_DIM, color);
+    return [`${inf}  ${name}`, `   ${latin}`];
+}
+function colophon(columns, color) {
+    const lines = [];
+    for (let i = 0; i < COLOPHON.length; i += 1) {
+        const num = paint(NUMERALS[i], TERRACOTTA, color);
+        const body = paint(COLOPHON[i], INK_DIM, color);
+        const line = `${num}  ${body}`;
+        if (displayWidth(line) + 2 <= columns)
+            lines.push(line);
+    }
+    return lines;
+}
+function padLeft(text, n) {
+    return `${' '.repeat(Math.max(0, n))}${text}`;
+}
+function center(text, width) {
+    const vis = displayWidth(text);
+    const pad = Math.max(0, Math.floor((width - vis) / 2));
+    return padLeft(text, pad);
+}
+function copyColumn(columns, color, compact) {
+    const indent = 2;
+    const lines = [
+        ...lockup(color).map((line) => padLeft(line, indent)),
+        '',
+        padLeft(paint(HEADLINE, INK, color), indent),
+    ];
+    if (!compact && displayWidth(TAGLINE) + indent <= columns) {
+        lines.push(padLeft(paint(TAGLINE, INK_DIM, color), indent));
+    }
+    if (!compact) {
+        const notes = colophon(columns, color);
+        if (notes.length) {
+            lines.push('');
+            for (const note of notes)
+                lines.push(padLeft(note, indent));
+        }
+    }
+    return lines;
+}
+function treeColumn(columns, color, phase, grow) {
+    const raw = (0, tree_2.sisuTreeLines)(columns, phase, grow);
+    const painted = (0, tree_2.sisuTreeArt)(columns, color, phase, grow).split('\n');
+    const treeWidth = raw.reduce((max, line) => Math.max(max, line.length), 0);
+    const pad = Math.max(0, Math.floor((columns - treeWidth) / 2));
+    return painted.map((line, i) => {
+        const vis = raw[i]?.length ?? displayWidth(line);
+        return padLeft(`${line}${' '.repeat(Math.max(0, treeWidth - vis))}`, pad);
+    });
+}
+const STILL_PHASE = 2.05;
+/**
+ * Login-page splash. `phase` orbits the camera; `grow` is 0..1 paint progress.
+ * Line count is stable for a given width so the intro can rewrite in place.
+ */
+function sisuSplashFrame(columns = 80, color = true, phase = STILL_PHASE, grow = 1) {
+    const width = Math.max(20, Math.floor(columns));
+    const compact = width < 52;
+    const copy = copyColumn(width, color, compact);
+    if (width >= 72) {
+        const gap = 3;
+        const leftBudget = Math.min(44, Math.floor(width * 0.42));
+        const leftCopy = copyColumn(leftBudget, color, true);
+        const leftW = Math.max(...leftCopy.map((line) => displayWidth(line)), 22);
+        const rightW = Math.max(28, width - leftW - gap);
+        const right = treeColumn(rightW, color, phase, grow);
+        const rows = Math.max(leftCopy.length, right.length);
+        const merged = [];
+        for (let i = 0; i < rows; i += 1) {
+            const left = leftCopy[i] ?? '';
+            const pad = Math.max(0, leftW + gap - displayWidth(left));
+            merged.push(`${left}${' '.repeat(pad)}${right[i] ?? ''}`);
+        }
+        const notes = colophon(width, color);
+        if (notes.length) {
+            merged.push('');
+            for (const note of notes)
+                merged.push(padLeft(note, 2));
+        }
+        return merged.join('\n');
+    }
+    const tree = treeColumn(width, color, phase, grow);
+    return [...copy, '', ...tree].join('\n');
+}
+function sisuSplashHeight(columns = 80) {
+    return sisuSplashFrame(columns, false).split('\n').length;
+}
 function sisuSplash(columns = 80, color = true) {
-    const mark = (0, mark_2.sisuMarkArt)(columns, color);
-    const markWidth = (0, mark_2.sisuMarkLines)(columns)[0]?.length ?? 0;
-    const caption = '思溯   SISU';
-    const pad = Math.max(0, Math.floor((markWidth - caption.length) / 2));
-    return ['', mark, '', `${' '.repeat(pad)}${caption}`, ''].join('\n');
-}
-function sisuBanner(columns = 80, _phase = 0, color = false) {
-    return sisuSplash(columns, color);
+    return sisuSplashFrame(columns, color, STILL_PHASE, 1);
+}
+function sisuWelcomeCopy(guest, color = true) {
+    const lines = [
+        ...lockup(color),
+        paint(HEADLINE, INK, color),
+    ];
+    if (guest) {
+        lines.push(paint('Sign in to start a conversation.', INK_DIM, color));
+        lines.push(paint('/login  browser    /help  commands', INK_DIM, color));
+    }
+    else {
+        lines.push(paint('Ask anything, or type /help.', INK_DIM, color));
+    }
+    return lines;
+}
+function sisuBanner(columns = 80, phase = STILL_PHASE, color = false) {
+    return sisuSplashFrame(columns, color, phase, 1);
 }
 function stripAnsi(text) {
     return text.replace(/\x1b\[[0-9;]*m/g, '');

package/dist/main.js

@@ -28,7 +28,7 @@ Usage:
   sisu history
   sisu thread <conversation-id>
   sisu training --on|--off
-  sisu                 interactive TUI (Möbius splash)
+  sisu                 interactive TUI (3D welcome tree)
   sisu help
 
 Auth and workspaces live in $SISU_HOME (default ~/.sisu), shared with Desktop.

package/dist/pager/render.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripAnsi = void 0;
 exports.renderPager = renderPager;
-const mark_1 = require("../mark");
+const logo_1 = require("../logo");
 const model_1 = require("./model");
 const theme_1 = require("./theme");
 Object.defineProperty(exports, "stripAnsi", { enumerable: true, get: function () { return theme_1.stripAnsi; } });
@@ -101,28 +101,22 @@ function windowAroundSelected(lines, entryOf, selected, budget, lastEntry) {
 function isIdleWelcome(state) {
     return !state.conversationId && state.entries.length === 0;
 }
-function center(text, width, vis = (0, theme_1.stripAnsi)(text).length) {
+function center(text, width, vis = (0, logo_1.displayWidth)(text)) {
     const padLeft = Math.max(0, Math.floor((width - vis) / 2));
     return `${' '.repeat(padLeft)}${text}`;
 }
-function welcomeLines(guest, width, height, theme) {
-    const markCols = height >= 20 && width >= 48 ? width : 40;
-    const raw = (0, mark_1.sisuMarkLines)(markCols);
-    const painted = (0, mark_1.sisuMarkArt)(markCols, true).split('\n');
-    const mark = painted.map((line, i) => center(line, width, raw[i]?.length ?? (0, theme_1.stripAnsi)(line).length));
-    if (guest) {
-        return [
-            ...mark,
-            '',
-            theme.text(center('Sign in to start a conversation.', width)),
-            theme.dim(center('/login  browser    /help  commands', width)),
-        ];
-    }
-    return [
-        ...mark,
-        '',
-        theme.dim(center('Ask anything, or type /help.', width)),
-    ];
+function welcomeLines(guest, width, height, _theme) {
+    const copy = (0, logo_1.sisuWelcomeCopy)(guest, true).map((line) => center(line, width));
+    const treeCols = height >= 18 && width >= 48 ? Math.min(width, 72) : width >= 36 ? 44 : 28;
+    const raw = (0, logo_1.sisuTreeLines)(treeCols);
+    const painted = (0, logo_1.sisuTreeArt)(treeCols, true).split('\n');
+    const treeWidth = raw.reduce((max, line) => Math.max(max, line.length), 0);
+    const treePad = Math.max(0, Math.floor((width - treeWidth) / 2));
+    const tree = painted.map((line, i) => {
+        const vis = raw[i]?.length ?? (0, logo_1.displayWidth)(line);
+        return `${' '.repeat(treePad)}${line}${' '.repeat(Math.max(0, treeWidth - vis))}`;
+    });
+    return [...copy, '', ...tree];
 }
 function slashMenuLines(state, theme) {
     if (!state.slashOpen)

package/dist/tree.js

@@ -0,0 +1,331 @@
+"use strict";
+/** Volumetric 溯源之树: 3D L-system, z-buffer, lighting, grow + orbit. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTree3d = buildTree3d;
+exports.treeFrameHeight = treeFrameHeight;
+exports.treeFrameWidth = treeFrameWidth;
+exports.renderTreeFrame = renderTreeFrame;
+exports.sisuTreeLines = sisuTreeLines;
+exports.sisuTreeArt = sisuTreeArt;
+exports.sisuTreeWidth = sisuTreeWidth;
+exports.sisuTreeHeight = sisuTreeHeight;
+const RESET = '\x1b[0m';
+const SHADE = ' .:-=+*#%@';
+const CELL_ASPECT = 0.52;
+const CAM = 5.35;
+const FOCAL = 4.7;
+const LOOK_Y = 0.72;
+const KEY = norm([-0.62, 0.72, 0.32]);
+const FILL = norm([0.55, 0.18, 0.82]);
+const VIEW = [0, 0.08, 1];
+const INK = [198, 186, 168];
+const FRUIT_RGB = [184, 90, 58];
+const HILL_RGB = [92, 84, 72];
+const TREE_SEED = 20260817;
+const MAX_DEPTH = 5;
+function clamp(value, lo, hi) {
+    return Math.max(lo, Math.min(hi, value));
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function norm(v) {
+    const length = Math.hypot(v[0], v[1], v[2]) || 1;
+    return [v[0] / length, v[1] / length, v[2] / length];
+}
+function cross(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[2],
+    ];
+}
+function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function add(a, b, s = 1) {
+    return [a[0] + b[0] * s, a[1] + b[1] * s, a[2] + b[2] * s];
+}
+function rotateY(x, z, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [x * c + z * s, -x * s + z * c];
+}
+function rotateX(y, z, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return [y * c - z * s, y * s + z * c];
+}
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function perpFrame(dir) {
+    const helper = Math.abs(dir[1]) < 0.86 ? [0, 1, 0] : [1, 0, 0];
+    const n1 = norm(cross(dir, helper));
+    const n2 = norm(cross(dir, n1));
+    return [n1, n2];
+}
+let cached = null;
+function headingFrom(yaw, pitch) {
+    const sp = Math.sin(pitch);
+    return norm([sp * Math.sin(yaw), Math.cos(pitch), sp * Math.cos(yaw)]);
+}
+function buildTree3d(seed = TREE_SEED) {
+    if (cached && cached.seed === seed)
+        return cached.branches;
+    const rng = mulberry32(seed);
+    const branches = [];
+    const grow = (origin, yaw, pitch, len, radius, depth, t0) => {
+        if (depth > MAX_DEPTH || len < 0.08 || branches.length > 150)
+            return;
+        const heading = headingFrom(yaw, pitch);
+        const end = add(origin, heading, len);
+        const t1 = Math.min(1, t0 + len / 2.8);
+        const childCount = depth >= MAX_DEPTH ? 0 : rng() < 0.74 ? 2 : 3;
+        branches.push({
+            ax: origin[0],
+            ay: origin[1],
+            az: origin[2],
+            bx: end[0],
+            by: end[1],
+            bz: end[2],
+            radius,
+            depth,
+            t0,
+            t1,
+            tip: childCount === 0,
+        });
+        const baseYaw = yaw + (rng() - 0.5) * 0.4;
+        for (let i = 0; i < childCount; i += 1) {
+            const fork = ((i - (childCount - 1) / 2) * 2 * Math.PI) / childCount;
+            const childYaw = baseYaw + fork + (rng() - 0.5) * 0.35;
+            const childPitch = Math.min(0.98, pitch + (depth === 0 ? 0.4 : 0.26) + rng() * 0.22);
+            grow(end, childYaw, childPitch, len * (0.66 + rng() * 0.12), radius * 0.67, depth + 1, t1 + rng() * 0.02);
+        }
+    };
+    grow([0, 0, 0], 0.1, 0.03, 0.82, 0.095, 0, 0);
+    const tMax = branches.reduce((m, b) => Math.max(m, b.t1), 0) || 1;
+    for (const b of branches) {
+        b.t0 /= tMax;
+        b.t1 /= tMax;
+    }
+    cached = { seed, branches };
+    return branches;
+}
+function shadeChar(shade) {
+    return SHADE[Math.round(clamp(shade, 0, 1) * (SHADE.length - 1))] || '@';
+}
+function ansiRgb(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function plot(grid, col, row, depth, shade, spec, kind) {
+    if (col < 0 || row < 0 || row >= grid.length || col >= grid[0].length)
+        return;
+    if (!Number.isFinite(col) || !Number.isFinite(row) || !Number.isFinite(depth))
+        return;
+    const prev = grid[row][col];
+    if (!prev || depth < prev.z) {
+        grid[row][col] = { z: depth, shade: clamp(shade, 0.05, 1), spec, kind };
+    }
+}
+function project(x, y, z, yaw, pitch, cols, rows) {
+    ;
+    [x, z] = rotateY(x, z, yaw);
+    [y, z] = rotateX(y - LOOK_Y, z, pitch);
+    const depth = CAM - z;
+    if (depth < 0.45 || !Number.isFinite(depth))
+        return null;
+    const px = (x * FOCAL) / depth;
+    const py = (y * FOCAL) / depth;
+    if (!Number.isFinite(px) || !Number.isFinite(py))
+        return null;
+    const scale = Math.min((cols * 0.9) / 2.05, (rows * 0.88) / (1.85 * CELL_ASPECT));
+    const col = Math.round(px * scale + (cols - 1) / 2);
+    const row = Math.round(-py * scale * CELL_ASPECT + rows * 0.54);
+    return { col, row, depth };
+}
+function light(normal, back = false) {
+    const facing = dot(normal, VIEW);
+    if (facing < 0) {
+        normal = [-normal[0], -normal[1], -normal[2]];
+        back = true;
+    }
+    const lambert = Math.max(0, dot(normal, KEY));
+    const fill = Math.max(0, dot(normal, FILL)) * 0.22;
+    const cam = Math.max(0, dot(normal, VIEW)) * 0.2;
+    const half = norm([KEY[0] + VIEW[0], KEY[1] + VIEW[1], KEY[2] + VIEW[2]]);
+    const spec = Math.pow(Math.max(0, dot(normal, half)), 22);
+    const rim = Math.pow(1 - Math.abs(dot(normal, VIEW)), 2.1) * 0.22;
+    const ambient = back ? 0.1 : 0.2;
+    const lit = ambient + lambert * (back ? 0.28 : 0.72) + fill + cam + spec * 0.45 + rim;
+    return { shade: clamp(Math.pow(lit, 1.15), 0.07, 1), spec };
+}
+function swayAt(x, y, z, phase) {
+    const h = clamp(y / 2.3, 0, 1);
+    const gust = Math.sin(phase * 1.7 + x * 1.4 + z * 0.8);
+    const lean = 0.11 * h * h * gust;
+    return [x + lean, y, z + lean * 0.35];
+}
+function sampleBranch(grid, branch, grow, phase, yaw, pitch, cols, rows) {
+    if (grow <= branch.t0)
+        return;
+    const visible = clamp((grow - branch.t0) / Math.max(0.02, branch.t1 - branch.t0), 0, 1);
+    const along = Math.max(4, Math.ceil((branch.depth <= 1 ? 24 : branch.depth <= 3 ? 12 : 6) * visible));
+    const rings = branch.depth <= 1 ? 9 : branch.depth <= 3 ? 4 : 2;
+    const dx = branch.bx - branch.ax;
+    const dy = branch.by - branch.ay;
+    const dz = branch.bz - branch.az;
+    const dir = norm([dx, dy, dz]);
+    const [n1, n2] = perpFrame(dir);
+    for (let i = 0; i <= along; i += 1) {
+        const t = (i / along) * visible;
+        const px = branch.ax + dx * t;
+        const py = branch.ay + dy * t;
+        const pz = branch.az + dz * t;
+        const radius = branch.radius * (1 - t * 0.28);
+        for (let r = 0; r < rings; r += 1) {
+            const a = (r / rings) * Math.PI * 2 + phase * 0.05;
+            const ox = n1[0] * Math.cos(a) + n2[0] * Math.sin(a);
+            const oy = n1[1] * Math.cos(a) + n2[1] * Math.sin(a);
+            const oz = n1[2] * Math.cos(a) + n2[2] * Math.sin(a);
+            const [sx, sy, sz] = swayAt(px + ox * radius, py + oy * radius, pz + oz * radius, phase);
+            let nx = ox;
+            let ny = oy;
+            let nz = oz;
+            [nx, nz] = rotateY(nx, nz, yaw);
+            [ny, nz] = rotateX(ny, nz, pitch);
+            const hit = project(sx, sy, sz, yaw, pitch, cols, rows);
+            if (!hit)
+                continue;
+            const lit = light(norm([nx, ny, nz]));
+            const fog = 0.45 + 0.55 * clamp(1 - (hit.depth - 5.2) / 4.2, 0, 1);
+            plot(grid, hit.col, hit.row, hit.depth, lit.shade * fog, lit.spec * fog, 'wood');
+        }
+    }
+}
+function sampleFruit(grid, branches, grow, phase, yaw, pitch, cols, rows) {
+    const placed = [];
+    const gap = 0.28;
+    let count = 0;
+    for (const branch of branches) {
+        if (!branch.tip || grow < branch.t1)
+            continue;
+        if (placed.some((p) => Math.hypot(p[0] - branch.bx, p[1] - branch.by, p[2] - branch.bz) < gap))
+            continue;
+        placed.push([branch.bx, branch.by, branch.bz]);
+        const [bx, by, bz] = swayAt(branch.bx, branch.by, branch.bz, phase);
+        const hit = project(bx, by, bz, yaw, pitch, cols, rows);
+        if (!hit)
+            continue;
+        const twinkle = 0.88 + 0.12 * Math.sin(phase * 3.1 + branch.bx * 7);
+        plot(grid, hit.col, hit.row, hit.depth - 0.02, 0.92 * twinkle, 0.55, 'fruit');
+        count += 1;
+        if (count >= 22)
+            break;
+    }
+}
+function sampleGround(grid, phase, yaw, pitch, cols, rows) {
+    for (let ix = -16; ix <= 16; ix += 1) {
+        for (let iz = -14; iz <= 14; iz += 1) {
+            const x = ix * 0.12;
+            const z = iz * 0.12;
+            const rr = (x * x) / (1.85 * 1.85) + (z * z) / (1.45 * 1.45);
+            if (rr > 1)
+                continue;
+            if (rr < 0.88 && rr > 0.18 && (ix * 3 + iz * 5) % 4 !== 0)
+                continue;
+            const y = 0.05 * Math.sin(x * 1.6 + 0.5) * Math.cos(z * 1.25) +
+                0.018 * Math.sin(x * 3.0 + z * 2.1 + phase * 0.15);
+            const hit = project(x, y, z, yaw, pitch, cols, rows);
+            if (!hit)
+                continue;
+            const nx = -0.08 * Math.cos(x * 1.6 + 0.5);
+            const nz = 0.06 * Math.sin(z * 1.25);
+            let nnx = nx;
+            let nny = 1;
+            let nnz = nz;
+            [nnx, nnz] = rotateY(nnx, nnz, yaw);
+            [nny, nnz] = rotateX(nny, nnz, pitch);
+            const lit = light(norm([nnx, nny, nnz]), true);
+            const fog = 0.22 + 0.35 * clamp(1 - rr, 0, 1) * clamp(1 - (hit.depth - 5.2) / 4.8, 0, 1);
+            plot(grid, hit.col, hit.row, hit.depth + 0.1, lit.shade * fog, 0, 'ground');
+        }
+    }
+}
+function paintCell(cell, color) {
+    const ch = cell.kind === 'fruit' ? '\u2022' : shadeChar(cell.shade);
+    if (!color)
+        return ch;
+    const base = cell.kind === 'fruit' ? FRUIT_RGB : cell.kind === 'ground' ? HILL_RGB : INK;
+    const lift = 0.22 + cell.shade * 0.95 + cell.spec * 0.55;
+    const r = clamp(Math.round(base[0] * lift), 0, 255);
+    const g = clamp(Math.round(base[1] * lift), 0, 255);
+    const b = clamp(Math.round(base[2] * lift), 0, 255);
+    if (![r, g, b].every(Number.isFinite))
+        return ch;
+    return `${ansiRgb(r, g, b)}${ch}${RESET}`;
+}
+function treeFrameHeight(columns = 80) {
+    if (columns < 44)
+        return 10;
+    if (columns < 68)
+        return 14;
+    return 18;
+}
+function treeFrameWidth(columns = 80) {
+    if (columns < 44)
+        return Math.max(28, columns);
+    if (columns < 68)
+        return Math.min(52, columns);
+    return Math.min(72, Math.max(56, columns - 2));
+}
+function renderTreeFrame(options = {}) {
+    const cols = Math.max(24, Math.floor(options.cols ?? 64));
+    const rows = Math.max(8, Math.floor(options.rows ?? 16));
+    const phase = options.phase ?? 0.4;
+    const grow = clamp(options.grow ?? 1, 0, 1);
+    const color = options.color !== false;
+    const grid = Array.from({ length: rows }, () => Array(cols).fill(null));
+    const yaw = 0.42 + 0.62 * Math.sin(phase);
+    const pitch = 0.3 + 0.07 * Math.cos(phase * 0.85);
+    const branches = buildTree3d();
+    sampleGround(grid, phase, yaw, pitch, cols, rows);
+    for (const branch of branches)
+        sampleBranch(grid, branch, grow, phase, yaw, pitch, cols, rows);
+    sampleFruit(grid, branches, grow, phase, yaw, pitch, cols, rows);
+    return grid
+        .map((line) => line.map((cell) => (cell ? paintCell(cell, color) : ' ')).join(''))
+        .join('\n');
+}
+function sisuTreeLines(columns = 80, phase = 2.05, grow = 1) {
+    const art = renderTreeFrame({
+        cols: treeFrameWidth(columns),
+        rows: treeFrameHeight(columns),
+        phase,
+        grow,
+        color: false,
+    });
+    return art.split('\n');
+}
+function sisuTreeArt(columns = 80, color = true, phase = 2.05, grow = 1) {
+    return renderTreeFrame({
+        cols: treeFrameWidth(columns),
+        rows: treeFrameHeight(columns),
+        phase,
+        grow,
+        color,
+    });
+}
+function sisuTreeWidth(columns = 80) {
+    return treeFrameWidth(columns);
+}
+function sisuTreeHeight(columns = 80) {
+    return treeFrameHeight(columns);
+}

package/dist/tui.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldAnimateSplash = shouldAnimateSplash;
 exports.playMobiusIntro = playMobiusIntro;
+exports.playTreeIntro = playTreeIntro;
 exports.defaultTuiIo = defaultTuiIo;
 exports.tuiHelp = tuiHelp;
 exports.runTui = runTui;
@@ -48,6 +49,30 @@ async function playMobiusIntro(io, options = {}) {
     io.write('\x1b[?25h');
     io.write(`\n${(0, logo_1.sisuWordmark)()}\n\n`);
 }
+function easeOutCubic(t) {
+    return 1 - (1 - t) ** 3;
+}
+/** Grow the 溯源之树, then orbit so lighting and occlusion read as volume. */
+async function playTreeIntro(io, options = {}) {
+    const columns = options.columns ?? process.stdout.columns ?? 80;
+    const frames = Math.max(2, options.frames ?? 36);
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const color = options.color ?? Boolean(process.stdout.isTTY);
+    const rows = (0, logo_1.sisuSplashHeight)(columns);
+    io.write('\x1b[?25l');
+    for (let i = 0; i < frames; i += 1) {
+        const u = i / (frames - 1);
+        const grow = easeOutCubic(Math.min(1, u / 0.58));
+        const phase = 0.12 + u * 2.35;
+        const art = (0, logo_1.sisuSplashFrame)(columns, color, phase, grow);
+        if (i === 0)
+            io.write(`${art}\n`);
+        else
+            io.write(`\x1b[${rows}A${art}\n`);
+        await sleep(42);
+    }
+    io.write('\x1b[?25h');
+}
 function defaultTuiIo() {
     let rl;
     const ensureRl = () => {
@@ -174,9 +199,15 @@ async function runTui(io, deps = {}) {
     const columns = deps.columns ?? process.stdout.columns ?? 80;
     const animate = deps.animate ?? shouldAnimateSplash();
     try {
-        io.write(`${(0, logo_1.sisuSplash)(columns, true)}\n`);
         if (animate) {
-            await (deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))))(80);
+            await playTreeIntro(io, {
+                columns,
+                color: deps.color ?? true,
+                sleep: deps.sleep,
+            });
+        }
+        else {
+            io.write(`${(0, logo_1.sisuSplash)(columns, true)}\n`);
         }
         const account = auth();
         const startWebLogin = async (notify) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevezhou/sisu",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "SiSu CLI — one login, cloud quota, local workspace",
   "license": "UNLICENSED",
   "homepage": "https://www.sisu.chat",