@stevezhou/sisu 0.1.5 → 0.1.7

package/dist/logo.js

@@ -4,6 +4,8 @@ exports.sisuTreeLines = exports.sisuTreeArt = exports.sisuMarkLines = exports.si
 exports.sisuMobiusArt = sisuMobiusArt;
 exports.sisuWordmark = sisuWordmark;
 exports.displayWidth = displayWidth;
+exports.sisuSplashFrame = sisuSplashFrame;
+exports.sisuSplashHeight = sisuSplashHeight;
 exports.sisuSplash = sisuSplash;
 exports.sisuWelcomeCopy = sisuWelcomeCopy;
 exports.sisuBanner = sisuBanner;
@@ -16,19 +18,10 @@ Object.defineProperty(exports, "sisuTreeArt", { enumerable: true, get: function
 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),
@@ -76,17 +69,6 @@ function lockup(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}`;
 }
@@ -95,61 +77,36 @@ function center(text, width) {
     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) {
-    const raw = (0, tree_2.sisuTreeLines)(columns);
-    const painted = (0, tree_2.sisuTreeArt)(columns, color).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);
-    });
+function centerBlock(lines, width) {
+    return lines.map((line) => center(line, width));
 }
+const STILL_PHASE = 0.85;
 /**
- * Login-page splash: lockup + 思有所溯 + 题跋 over the 溯源之树.
- * Side-by-side on a wide terminal; stacked when the sheet is narrow.
+ * Möbius splash. `phase` slides the half-twist around the single face.
+ * Line count is stable for a given width so the intro can rewrite in place.
  */
-function sisuSplash(columns = 80, color = true) {
+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);
-    const tree = treeColumn(width, color);
-    if (width >= 100) {
-        const gap = 3;
-        const leftW = Math.max(...copy.map((line) => displayWidth(line)));
-        const rightW = width - leftW - gap;
-        const right = treeColumn(rightW, color);
-        const rows = Math.max(copy.length, right.length);
-        const merged = [''];
-        for (let i = 0; i < rows; i += 1) {
-            const left = copy[i] ?? '';
-            const pad = Math.max(0, leftW + gap - displayWidth(left));
-            merged.push(`${left}${' '.repeat(pad)}${right[i] ?? ''}`);
-        }
-        merged.push('');
-        return merged.join('\n');
-    }
-    return ['', ...copy, '', ...tree, ''].join('\n');
+    const ringW = (0, mobius_1.mobiusFrameWidth)(width);
+    const ring = (0, mobius_1.renderMobiusFrame)({
+        cols: ringW,
+        rows: (0, mobius_1.mobiusFrameHeight)(width),
+        phase,
+        color,
+    }).split('\n');
+    const pad = Math.max(0, Math.floor((width - ringW) / 2));
+    const art = ring.map((line) => padLeft(line, pad));
+    const caption = centerBlock([
+        `${infinityMark(color)}  ${paint('思溯', INK, color)}   ${paint('SiSu', INK_DIM, color)}`,
+        paint(HEADLINE, INK, color),
+    ], width);
+    return [...art, '', ...caption].join('\n');
+}
+function sisuSplashHeight(columns = 80) {
+    return sisuSplashFrame(columns, false).split('\n').length;
+}
+function sisuSplash(columns = 80, color = true) {
+    return sisuSplashFrame(columns, color, STILL_PHASE, 1);
 }
 function sisuWelcomeCopy(guest, color = true) {
     const lines = [
@@ -165,8 +122,8 @@ function sisuWelcomeCopy(guest, color = true) {
     }
     return lines;
 }
-function sisuBanner(columns = 80, _phase = 0, color = false) {
-    return sisuSplash(columns, color);
+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 (welcome tree)
+  sisu                 interactive TUI (Möbius splash)
   sisu help
 
 Auth and workspaces live in $SISU_HOME (default ~/.sisu), shared with Desktop.

package/dist/mobius.js

@@ -1,22 +1,23 @@
 "use strict";
-/** Volumetric Möbius ring: half-twist ribbon with thickness, perspective, and lighting. */
+/** Volumetric ∞ Möbius: lemniscate centerline, half-twist ribbon, traveling glint. */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mobiusRgb = mobiusRgb;
 exports.mobiusPoint = mobiusPoint;
+exports.logoPoint = logoPoint;
 exports.renderMobiusFrame = renderMobiusFrame;
 exports.mobiusFrameHeight = mobiusFrameHeight;
 exports.mobiusFrameWidth = mobiusFrameWidth;
 const RESET = '\x1b[0m';
 const SHADE_RAMP = ' .:-=+*#%@';
-const RADIUS = 1.88;
-const HALF_WIDTH = 0.34;
-const THICKNESS = 0.08;
+const SCALE = 1.72;
+const HALF_WIDTH = 0.3;
+const THICKNESS = 0.045;
 const CELL_ASPECT = 0.5;
-const CAM = 8.6;
-const FOCAL = 5.1;
-const KEY = norm([-0.58, 0.78, 0.24]);
-const FILL = norm([0.48, 0.12, 0.86]);
-const VIEW = [0, 0.12, 1];
+const CAM = 6.4;
+const FOCAL = 5.2;
+const KEY = norm([-0.55, 0.7, 0.45]);
+const FILL = norm([0.52, 0.1, 0.85]);
+const VIEW = [0, 0.06, 1];
 function clamp(value, lo, hi) {
     return Math.max(lo, Math.min(hi, value));
 }
@@ -37,7 +38,7 @@ function cross(a, b) {
 function dot(a, b) {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }
-/** Brand gradient along the band: blue → purple → gold, matching sisu-mark. */
+/** Brand gradient along the band: blue → purple → gold. */
 function mobiusRgb(t) {
     const u = ((t / (Math.PI * 2)) % 1 + 1) % 1;
     if (u < 0.5) {
@@ -68,24 +69,10 @@ function rotateY(x, z, angle) {
     const s = Math.sin(angle);
     return [x * c + z * s, -x * s + z * c];
 }
-function rotateZ(x, y, angle) {
-    const c = Math.cos(angle);
-    const s = Math.sin(angle);
-    return [x * c - y * s, x * s + y * c];
-}
-function transform(x, y, z, tilt, spin) {
-    // Spin around the ring axis so the half-twist travels; then a fixed 3/4 view.
-    ;
-    [x, y] = rotateZ(x, y, spin);
-    [y, z] = rotateX(y, z, tilt);
-    [x, z] = rotateY(x, z, 0.32);
-    return [x, y, z];
-}
 /**
- * Standard Möbius strip: a ring of radius R with a half-twist in the width.
- * After one full trip around θ, the normal flips — one-sided surface.
+ * Circular Möbius (unit tests): after one full trip around θ the width flips.
  */
-function mobiusPoint(theta, width, radius = RADIUS, halfWidth = HALF_WIDTH) {
+function mobiusPoint(theta, width, radius = 1.88, halfWidth = 0.34) {
     const twist = theta / 2;
     const ring = radius + width * halfWidth * Math.cos(twist);
     return [
@@ -94,24 +81,45 @@ function mobiusPoint(theta, width, radius = RADIUS, halfWidth = HALF_WIDTH) {
         width * halfWidth * Math.sin(twist),
     ];
 }
-function mobiusNormal(theta, width, radius = RADIUS, halfWidth = HALF_WIDTH) {
-    const twist = theta / 2;
-    const c = Math.cos(theta);
-    const s = Math.sin(theta);
-    const c2 = Math.cos(twist);
-    const s2 = Math.sin(twist);
-    const ring = radius + width * halfWidth * c2;
-    const dTheta = [
-        -ring * s - width * halfWidth * 0.5 * s2 * c,
-        ring * c - width * halfWidth * 0.5 * s2 * s,
-        width * halfWidth * 0.5 * c2,
-    ];
-    const dWidth = [
-        halfWidth * c2 * c,
-        halfWidth * c2 * s,
-        halfWidth * s2,
-    ];
-    return norm(cross(dTheta, dWidth));
+/** Gerono lemniscate — the ∞ of the SiSu mark. */
+function lemniscate(t) {
+    return [SCALE * Math.sin(t), SCALE * Math.sin(t) * Math.cos(t), 0];
+}
+function lemniscateTangent(t) {
+    return norm([Math.cos(t), Math.cos(2 * t), 0]);
+}
+/**
+ * Ribbon around the ∞: width offset in a frame that half-twists once per lap.
+ * phase slides the twist so the single face travels without a seam.
+ */
+function logoPoint(t, width, phase = 0) {
+    const [cx, cy, cz] = lemniscate(t);
+    const tangent = lemniscateTangent(t);
+    const binormal = [0, 0, 1];
+    const normal = norm(cross(binormal, tangent));
+    const twist = (t + phase) / 2;
+    const ox = normal[0] * Math.cos(twist) + binormal[0] * Math.sin(twist);
+    const oy = normal[1] * Math.cos(twist) + binormal[1] * Math.sin(twist);
+    const oz = normal[2] * Math.cos(twist) + binormal[2] * Math.sin(twist);
+    const w = width * HALF_WIDTH;
+    return [cx + ox * w, cy + oy * w, cz + oz * w];
+}
+function logoNormal(t, phase) {
+    const tangent = lemniscateTangent(t);
+    const binormal = [0, 0, 1];
+    const normal = norm(cross(binormal, tangent));
+    const twist = (t + phase) / 2;
+    return norm([
+        normal[0] * Math.cos(twist) + binormal[0] * Math.sin(twist),
+        normal[1] * Math.cos(twist) + binormal[1] * Math.sin(twist),
+        normal[2] * Math.cos(twist) + binormal[2] * Math.sin(twist),
+    ]);
+}
+function transform(x, y, z, tilt, yaw) {
+    ;
+    [y, z] = rotateX(y, z, tilt);
+    [x, z] = rotateY(x, z, yaw);
+    return [x, y, z];
 }
 function shadeChar(shade) {
     return SHADE_RAMP[Math.round(clamp(shade, 0, 1) * (SHADE_RAMP.length - 1))] || '@';
@@ -122,125 +130,93 @@ function renderMobiusFrame(options = {}) {
     const phase = options.phase ?? 0;
     const color = options.color !== false;
     const grid = Array.from({ length: rows }, () => Array(cols).fill(null));
-    const tilt = 0.88;
-    const samples = [];
-    const thetaSteps = 580;
+    const tilt = 0.42;
+    const yaw = 0.18 * Math.sin(phase * 0.5);
+    const thetaSteps = 520;
+    const scale = Math.min((cols - 2) / 4.15, (rows - 2) / (2.15 * CELL_ASPECT));
     for (let i = 0; i < thetaSteps; i += 1) {
         const theta = (i / thetaSteps) * Math.PI * 2;
         for (let j = -4; j <= 4; j += 1) {
             const width = j / 4;
-            const base = mobiusPoint(theta, width);
-            const n0 = mobiusNormal(theta, width);
-            // Faces of the thin solid, plus the mid-surface; skip the interior fill.
+            const base = logoPoint(theta, width, phase);
+            const n0 = logoNormal(theta, phase);
             const thicks = j === -4 || j === 4 ? [-1, 0, 1] : [-1, 1];
-            for (const k of thicks) {
-                const thick = k;
+            for (const thick of thicks) {
                 let x = base[0] + n0[0] * thick * THICKNESS;
                 let y = base[1] + n0[1] * thick * THICKNESS;
                 let z = base[2] + n0[2] * thick * THICKNESS;
-                let nx = n0[0];
-                let ny = n0[1];
-                let nz = n0[2];
-                if (thick < 0) {
-                    nx = -nx;
-                    ny = -ny;
-                    nz = -nz;
-                }
-                ;
-                [x, y, z] = transform(x, y, z, tilt, phase);
-                [nx, ny, nz] = transform(nx, ny, nz, tilt, phase);
+                let nx = thick < 0 ? -n0[0] : n0[0];
+                let ny = thick < 0 ? -n0[1] : n0[1];
+                let nz = thick < 0 ? -n0[2] : n0[2];
+                [x, y, z] = transform(x, y, z, tilt, yaw);
+                [nx, ny, nz] = transform(nx, ny, nz, tilt, yaw);
+                if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+                    continue;
                 let normal = [nx, ny, nz];
                 const facing = dot(normal, VIEW);
                 const back = facing < 0;
                 if (back)
                     normal = [-normal[0], -normal[1], -normal[2]];
                 const depth = CAM - z;
-                if (depth < 0.35)
+                if (depth < 0.4 || !Number.isFinite(depth))
                     continue;
                 const px = (x * FOCAL) / depth;
                 const py = (y * FOCAL) / depth;
+                if (!Number.isFinite(px) || !Number.isFinite(py))
+                    continue;
                 const lambert = Math.max(0, dot(normal, KEY));
                 const fill = Math.max(0, dot(normal, FILL)) * 0.2;
-                const camFill = Math.max(0, dot(normal, VIEW)) * 0.22;
+                const camFill = 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)), 28);
-                const edge = Math.max(Math.abs(width), Math.abs(thick));
-                const rim = Math.pow(1 - Math.abs(dot(normal, VIEW)), 2.2) * (0.1 + 0.5 * Math.pow(edge, 2));
-                const ambient = back ? 0.09 : 0.18;
-                const lit = ambient + lambert * (back ? 0.3 : 0.74) + fill + camFill + spec * 0.5 + rim;
-                const shade = clamp(Math.pow(lit, 1.2), 0.07, 1);
-                samples.push({
-                    px,
-                    py,
-                    depth,
-                    shade,
-                    spec,
-                    t: theta + (back ? Math.PI : 0),
-                });
+                const spec = Math.pow(Math.max(0, dot(normal, half)), 26);
+                const edge = Math.abs(width);
+                const rim = Math.pow(1 - Math.abs(dot(normal, VIEW)), 2.2) * (0.12 + 0.45 * edge * edge);
+                const rider = Math.pow(Math.max(0, Math.cos(theta - phase)), 18);
+                const ambient = back ? 0.1 : 0.2;
+                const lit = ambient + lambert * (back ? 0.32 : 0.7) + fill + camFill + spec * 0.45 + rim + rider * 0.55;
+                const shade = clamp(Math.pow(lit, 1.12), 0.07, 1);
+                const fog = 0.5 + 0.5 * clamp(1 - (depth - 5.2) / 3.4, 0, 1);
+                const col = Math.round(px * scale + (cols - 1) / 2);
+                const row = Math.round(-py * scale * CELL_ASPECT + (rows - 1) / 2);
+                if (col < 0 || col >= cols || row < 0 || row >= rows)
+                    continue;
+                const prev = grid[row][col];
+                if (!prev || depth < prev.z) {
+                    grid[row][col] = {
+                        z: depth,
+                        shade: clamp(shade * fog, 0.06, 1),
+                        t: theta + phase,
+                        spec: (spec + rider) * fog,
+                    };
+                }
             }
         }
     }
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
-    let minD = Infinity;
-    let maxD = -Infinity;
-    for (const sample of samples) {
-        const sx = sample.px;
-        const sy = sample.py * CELL_ASPECT;
-        if (sx < minX)
-            minX = sx;
-        if (sx > maxX)
-            maxX = sx;
-        if (sy < minY)
-            minY = sy;
-        if (sy > maxY)
-            maxY = sy;
-        if (sample.depth < minD)
-            minD = sample.depth;
-        if (sample.depth > maxD)
-            maxD = sample.depth;
-    }
-    const spanX = Math.max(0.001, maxX - minX);
-    const spanY = Math.max(0.001, maxY - minY);
-    const scale = Math.min((cols - 4) / spanX, (rows - 2) / spanY);
-    const midX = (minX + maxX) / 2;
-    const midY = (minY + maxY) / 2;
-    const depthSpan = Math.max(0.001, maxD - minD);
-    for (const sample of samples) {
-        const fog = 0.4 + 0.6 * (1 - (sample.depth - minD) / depthSpan);
-        const col = Math.round((sample.px - midX) * scale + (cols - 1) / 2);
-        const row = Math.round(-((sample.py * CELL_ASPECT) - midY) * scale + (rows - 1) / 2);
-        if (col < 0 || col >= cols || row < 0 || row >= rows)
-            continue;
-        const prev = grid[row][col];
-        if (!prev || sample.depth < prev.z) {
-            grid[row][col] = {
-                z: sample.depth,
-                shade: clamp(sample.shade * fog, 0.06, 1),
-                t: sample.t,
-                spec: sample.spec * fog,
-            };
-        }
-    }
-    return grid.map((line) => line.map((cell) => {
+    return grid
+        .map((line) => line
+        .map((cell) => {
         if (!cell)
             return ' ';
         const ch = shadeChar(cell.shade);
         if (!color)
             return ch;
         let [r, g, b] = mobiusRgb(cell.t);
-        const lift = 0.18 + cell.shade * 0.95 + cell.spec * 0.7;
+        const lift = 0.2 + cell.shade * 0.92 + cell.spec * 0.55;
         r = clamp(Number.isFinite(r * lift) ? Math.round(r * lift) : 180, 0, 255);
         g = clamp(Number.isFinite(g * lift) ? Math.round(g * lift) : 180, 0, 255);
         b = clamp(Number.isFinite(b * lift) ? Math.round(b * lift) : 180, 0, 255);
         return `${ansiRgb(r, g, b)}${ch}${RESET}`;
-    }).join('')).join('\n');
+    })
+        .join(''))
+        .join('\n');
 }
 function mobiusFrameHeight(columns = 80) {
-    return columns < 56 ? 13 : 20;
+    return columns < 52 ? 11 : columns < 72 ? 15 : 18;
 }
 function mobiusFrameWidth(columns = 80) {
-    return columns < 56 ? 44 : Math.min(76, Math.max(56, columns - 4));
+    if (columns < 52)
+        return Math.max(32, columns);
+    if (columns < 72)
+        return Math.min(60, columns);
+    return Math.min(72, columns);
 }

package/dist/pager/render.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripAnsi = void 0;
 exports.renderPager = renderPager;
 const logo_1 = require("../logo");
+const mobius_1 = require("../mobius");
 const model_1 = require("./model");
 const theme_1 = require("./theme");
 Object.defineProperty(exports, "stripAnsi", { enumerable: true, get: function () { return theme_1.stripAnsi; } });
@@ -107,16 +108,12 @@ function center(text, width, vis = (0, logo_1.displayWidth)(text)) {
 }
 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];
+    const ringW = height >= 16 && width >= 48 ? (0, mobius_1.mobiusFrameWidth)(Math.min(width, 72)) : Math.min(width, 44);
+    const ringH = Math.min((0, mobius_1.mobiusFrameHeight)(ringW), Math.max(8, height - 7));
+    const painted = (0, logo_1.sisuMobiusArt)(ringW, 0.85, true).split('\n').slice(0, ringH);
+    const pad = Math.max(0, Math.floor((width - ringW) / 2));
+    const ring = painted.map((line) => `${' '.repeat(pad)}${line}`);
+    return [...copy, '', ...ring];
 }
 function slashMenuLines(state, theme) {
     if (!state.slashOpen)

package/dist/tree.js

@@ -1,116 +1,331 @@
 "use strict";
-/** 溯源之树 — hand-inked ASCII of the login welcome painting. */
+/** 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 INK = [196, 186, 170];
-const INK_DIM = [130, 120, 108];
-const FRUIT = [184, 90, 58];
-const HILL = [90, 82, 70];
-/**
- * Desktop login tree. Trunk sits near center; crown opens into an airy
- * fan with terracotta tips — the same 图景 as BrandCanvas, not a Möbius.
- */
-const TREE_WIDE = [
-    '                      •    •      •  •      •    •     •',
-    '                 •  •    •    •     •   •    •     •  •   •',
-    '              •     •  •   •   •  •    •  •    •  •    •   •',
-    '           •     •    ╲  •   ╲  •   ╱ •   ╲   •    •    •',
-    '         •      ╲    ╱ ╲    ╲    ╱ ╲     ╱ ╲   ╲    ╲  ╱',
-    '        •        ╲  ╱   ╲    ╲  ╱   ╲   ╱   ╲   ╲    ╲╱',
-    '         ╲        ╲╱     ╲    ╲╱     ╲ ╱     ╲   ╲    ╱',
-    '          ╲       ╱       ╲   ╱       Y       ╲   ╲  ╱',
-    '           ╲     ╱         ╲ ╱       ╱         ╲   ╲╱',
-    '            ╲   ╱           Y       ╱           ╲  ╱',
-    '             ╲ ╱           ╱ ╲     ╱             ╲╱',
-    '              Y           ╱   ╲   ╱              ╱',
-    '              │          ╱     ╲ ╱',
-    '              │         ╱       Y',
-    '              │        ╱',
-    '              │',
-    '▁▁▁▂▂▁▁▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
-const TREE_MID = [
-    '                •   •    •  •    •   •   •',
-    '            •  •   •  •    •   •   •    •  •',
-    '         •    •  ╲  •  ╲ •   ╱ •  ╲   •   •',
-    '       •    ╲   ╱ ╲   ╲   ╱ ╲    ╱ ╲   ╲ ╱',
-    '        ╲    ╲ ╱   ╲   ╲ ╱   ╲  ╱   ╲   Y',
-    '         ╲    Y     ╲   Y     ╲╱     ╲ ╱',
-    '          ╲  ╱       ╲ ╱      ╱       Y',
-    '           ╲╱         Y      ╱       ╱',
-    '           │         ╱ ╲    ╱',
-    '           │        ╱   ╲  ╱',
-    '           │       ╱     ╲╱',
-    '           │',
-    '▁▁▂▂▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
-const TREE_NARROW = [
-    '          •  •   •  •  •',
-    '       •   ╲ • ╱ •  ╲  •',
-    '      ╲   ╱ ╲ ╱ ╲  ╱ ╲╱',
-    '       ╲ ╱   Y   ╲╱   ╱',
-    '        Y   ╱     ╲  ╱',
-    '        │  ╱       ╲╱',
-    '        │',
-    '▁▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁',
-];
+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 paintRgb(ch, rgb) {
-    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${ch}`;
+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 inkAt(x, width) {
-    const t = width <= 1 ? 0 : x / (width - 1);
+function cross(a, b) {
     return [
-        Math.round(lerp(INK[0], INK_DIM[0], t * 0.45)),
-        Math.round(lerp(INK[1], INK_DIM[1], t * 0.45)),
-        Math.round(lerp(INK[2], INK_DIM[2], t * 0.45)),
+        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 paintLine(line, color) {
-    if (!color)
-        return line;
-    let out = '';
-    for (let i = 0; i < line.length; i += 1) {
-        const ch = line[i];
-        if (ch === ' ') {
-            out += ' ';
-            continue;
+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);
         }
-        if (ch === '•') {
-            out += paintRgb(ch, FRUIT);
-            continue;
+    };
+    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');
         }
-        if (ch === '▁' || ch === '▂') {
-            out += paintRgb(ch, HILL);
+    }
+}
+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');
         }
-        out += paintRgb(ch, inkAt(i, line.length));
     }
-    return `${out}${RESET}`;
 }
-function padBlock(lines) {
-    const width = lines.reduce((max, line) => Math.max(max, line.length), 0);
-    return lines.map((line) => line.padEnd(width, ' '));
+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) {
-    if (columns >= 68)
-        return padBlock(TREE_WIDE);
-    if (columns >= 44)
-        return padBlock(TREE_MID);
-    return padBlock(TREE_NARROW);
+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) {
-    return sisuTreeLines(columns).map((line) => paintLine(line, color)).join('\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 sisuTreeLines(columns).reduce((max, line) => Math.max(max, line.length), 0);
+    return treeFrameWidth(columns);
 }
 function sisuTreeHeight(columns = 80) {
-    return sisuTreeLines(columns).length;
+    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,26 @@ async function playMobiusIntro(io, options = {}) {
     io.write('\x1b[?25h');
     io.write(`\n${(0, logo_1.sisuWordmark)()}\n\n`);
 }
+/** Slide the half-twist around the ∞ so the single face loops. */
+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 phase = u * Math.PI * 2;
+        const art = (0, logo_1.sisuSplashFrame)(columns, color, phase);
+        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 +195,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.5",
+  "version": "0.1.7",
   "description": "SiSu CLI — one login, cloud quota, local workspace",
   "license": "UNLICENSED",
   "homepage": "https://www.sisu.chat",