@stevezhou/sisu 0.1.0

package/dist/mobius.js

@@ -0,0 +1,246 @@
+"use strict";
+/** Volumetric Möbius ring: half-twist ribbon with thickness, perspective, and lighting. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mobiusRgb = mobiusRgb;
+exports.mobiusPoint = mobiusPoint;
+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 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];
+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[0],
+    ];
+}
+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. */
+function mobiusRgb(t) {
+    const u = ((t / (Math.PI * 2)) % 1 + 1) % 1;
+    if (u < 0.5) {
+        const k = u / 0.5;
+        return [
+            Math.round(lerp(37, 124, k)),
+            Math.round(lerp(99, 58, k)),
+            Math.round(lerp(235, 237, k)),
+        ];
+    }
+    const k = (u - 0.5) / 0.5;
+    return [
+        Math.round(lerp(124, 217, k)),
+        Math.round(lerp(58, 119, k)),
+        Math.round(lerp(237, 6, k)),
+    ];
+}
+function ansiRgb(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+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 rotateY(x, z, angle) {
+    const c = Math.cos(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.
+ */
+function mobiusPoint(theta, width, radius = RADIUS, halfWidth = HALF_WIDTH) {
+    const twist = theta / 2;
+    const ring = radius + width * halfWidth * Math.cos(twist);
+    return [
+        ring * Math.cos(theta),
+        ring * Math.sin(theta),
+        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));
+}
+function shadeChar(shade) {
+    return SHADE_RAMP[Math.round(clamp(shade, 0, 1) * (SHADE_RAMP.length - 1))] || '@';
+}
+function renderMobiusFrame(options = {}) {
+    const cols = Math.max(28, options.cols ?? 64);
+    const rows = Math.max(10, options.rows ?? 16);
+    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;
+    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 thicks = j === -4 || j === 4 ? [-1, 0, 1] : [-1, 1];
+            for (const k of thicks) {
+                const thick = k;
+                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 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)
+                    continue;
+                const px = (x * FOCAL) / depth;
+                const py = (y * FOCAL) / depth;
+                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 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),
+                });
+            }
+        }
+    }
+    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) => {
+        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;
+        r = clamp(Math.round(r * lift), 0, 255);
+        g = clamp(Math.round(g * lift), 0, 255);
+        b = clamp(Math.round(b * lift), 0, 255);
+        return `${ansiRgb(r, g, b)}${ch}${RESET}`;
+    }).join('')).join('\n');
+}
+function mobiusFrameHeight(columns = 80) {
+    return columns < 56 ? 13 : 20;
+}
+function mobiusFrameWidth(columns = 80) {
+    return columns < 56 ? 44 : Math.min(76, Math.max(56, columns - 4));
+}

package/dist/pager/app.js

@@ -0,0 +1,420 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatChromeStatus = formatChromeStatus;
+exports.chromeShortQuota = chromeShortQuota;
+exports.runPager = runPager;
+const store_1 = require("../store");
+const input_1 = require("./input");
+const model_1 = require("./model");
+const history_1 = require("./history");
+const render_1 = require("./render");
+const ALT_ENTER = '\x1b[?1049h\x1b[?25l';
+const ALT_LEAVE = '\x1b[?1049l\x1b[?25h';
+const CLEAR_HOME = '\x1b[2J\x1b[H';
+function formatChromeStatus(email, quota, conversationId) {
+    const parts = [
+        (email || '').trim(),
+        (quota || '').trim() || 'quota unavailable',
+        conversationId || 'new',
+        'client=tui',
+    ].filter((part) => part.length > 0);
+    return parts.join(' · ');
+}
+/** Short chrome fragment: `quota unlimited`, first `quota N pts`, or `quota unavailable`. */
+function chromeShortQuota(full) {
+    const text = (full || '').trim();
+    if (!text)
+        return 'quota unavailable';
+    const first = text.split(' · ')[0].trim();
+    if (first === 'quota unlimited')
+        return 'quota unlimited';
+    if (/^quota\s+\d+\s+pts$/.test(first))
+        return first;
+    if (first === 'quota unavailable' || first.startsWith('quota unavailable'))
+        return 'quota unavailable';
+    return 'quota unavailable';
+}
+let nextAppEntryId = 1;
+function pushEntry(state, kind, text) {
+    const folded = kind === 'tool' && text.split('\n').length > 8;
+    const entry = { id: `p${nextAppEntryId}`, kind, text, folded };
+    nextAppEntryId += 1;
+    const entries = [...state.entries, entry];
+    return { ...state, entries, selected: entries.length - 1 };
+}
+function clearDraft(state) {
+    return { ...state, draft: '', slashOpen: false, slashIndex: 0 };
+}
+function submittedText(state) {
+    const raw = state.draft.trim();
+    if (state.slashOpen && !/\s/.test(raw)) {
+        const items = (0, model_1.filterSlash)(state.draft);
+        const picked = items[state.slashIndex];
+        if (picked)
+            return picked.name;
+    }
+    return raw;
+}
+function commandHead(text) {
+    const token = text.split(/\s+/, 1)[0] || text;
+    if (token === '/exit')
+        return '/quit';
+    if (token === '/clear')
+        return '/new';
+    if (token === '/history')
+        return '/resume';
+    return token;
+}
+async function resolveText(value) {
+    return value;
+}
+async function runPager(io, transport, options = {}) {
+    const cols = options.columns ?? io.columns;
+    const rows = options.rows ?? io.rows;
+    let theme = options.theme ?? 'dark';
+    let quotaLine = 'quota unavailable';
+    const withChrome = (next) => ({
+        ...next,
+        statusLine: formatChromeStatus(options.email, quotaLine, next.conversationId),
+    });
+    const refreshQuota = async () => {
+        if (!options.quota)
+            return;
+        try {
+            quotaLine = chromeShortQuota((await resolveText(options.quota())).trim() || 'quota unavailable');
+        }
+        catch {
+            quotaLine = 'quota unavailable';
+        }
+    };
+    let state = withChrome((0, model_1.createPagerState)());
+    let rest = '';
+    let newConversation = false;
+    let pickMode = false;
+    const pickableIds = new Map();
+    let running = true;
+    let processing = false;
+    const pending = [];
+    let unsubscribe = () => undefined;
+    const paint = () => {
+        if (!running)
+            return;
+        io.write(`${CLEAR_HOME}${(0, render_1.renderPager)(state, cols, rows, theme)}`);
+    };
+    let removeTerm = () => undefined;
+    let settle;
+    let abortWait;
+    const finish = (code) => {
+        if (!running)
+            return;
+        running = false;
+        pending.length = 0;
+        unsubscribe();
+        abortWait?.();
+        settle?.(code);
+    };
+    try {
+        io.enterRaw();
+        io.write(ALT_ENTER);
+        const onTerm = () => finish(0);
+        process.on('SIGTERM', onTerm);
+        removeTerm = () => {
+            process.removeListener('SIGTERM', onTerm);
+            removeTerm = () => undefined;
+        };
+        paint();
+        await Promise.race([
+            refreshQuota(),
+            new Promise((resolve) => { abortWait = resolve; }),
+        ]);
+        if (!running)
+            return 0;
+        state = withChrome(state);
+        return await new Promise((resolve, reject) => {
+            settle = resolve;
+            paint();
+            const fail = (err) => {
+                if (!running)
+                    return;
+                running = false;
+                pending.length = 0;
+                unsubscribe();
+                reject(err);
+            };
+            const persistOpen = (boundId) => {
+                (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_conversation_id: boundId });
+            };
+            const openConversation = async (id) => {
+                pickMode = false;
+                newConversation = false;
+                persistOpen(id);
+                state = withChrome({ ...state, conversationId: id, entries: [], selected: 0 });
+                try {
+                    const row = await transport.getConversation(id);
+                    if (!running)
+                        return;
+                    const bound = row.id || id;
+                    persistOpen(bound);
+                    const mapped = (0, history_1.entriesFromMessages)(row.messages);
+                    const seeded = mapped.entries.map((entry) => {
+                        const next = { ...entry, id: `p${nextAppEntryId}` };
+                        nextAppEntryId += 1;
+                        return next;
+                    });
+                    const entries = mapped.truncated
+                        ? [...seeded, { id: `p${nextAppEntryId++}`, kind: 'status', text: 'showing last 200 messages', folded: false }]
+                        : seeded;
+                    state = withChrome({
+                        ...state,
+                        conversationId: bound,
+                        entries,
+                        selected: Math.max(0, entries.length - 1),
+                    });
+                }
+                catch (err) {
+                    if (!running)
+                        return;
+                    state = pushEntry(state, 'status', err instanceof Error ? err.message : String(err));
+                    state = withChrome(state);
+                }
+            };
+            const submitSlash = async (text) => {
+                const head = commandHead(text);
+                state = clearDraft(state);
+                if (head === '/quit') {
+                    finish(0);
+                    return;
+                }
+                if (head === '/new') {
+                    pickMode = false;
+                    pickableIds.clear();
+                    state = withChrome({
+                        ...state,
+                        entries: [],
+                        selected: 0,
+                        conversationId: '',
+                    });
+                    newConversation = true;
+                    paint();
+                    return;
+                }
+                if (head === '/resume') {
+                    pickMode = false;
+                    pickableIds.clear();
+                    try {
+                        const rowsList = await transport.listConversations();
+                        if (!running)
+                            return;
+                        if (!rowsList.length) {
+                            state = pushEntry(state, 'status', 'no conversations');
+                        }
+                        else {
+                            pickMode = true;
+                            // API is last_activity_at DESC (newest first). Append oldest-first so
+                            // the newest row is last, selected, and visible above the prompt.
+                            const oldestFirst = rowsList.slice().reverse();
+                            oldestFirst.forEach((row, index) => {
+                                const client = row.client ? ` [${row.client}]` : '';
+                                state = pushEntry(state, 'status', `${index + 1}. ${row.id}  ${row.title}${client}`);
+                                const entry = state.entries[state.entries.length - 1];
+                                if (row.id)
+                                    pickableIds.set(entry.id, row.id);
+                            });
+                        }
+                    }
+                    catch (err) {
+                        if (!running)
+                            return;
+                        state = pushEntry(state, 'status', err instanceof Error ? err.message : String(err));
+                    }
+                    paint();
+                    return;
+                }
+                if (head === '/open') {
+                    const id = text.slice('/open'.length).trim();
+                    if (!id) {
+                        state = pushEntry(state, 'status', 'usage: /open <id>');
+                    }
+                    else {
+                        await openConversation(id);
+                    }
+                    paint();
+                    return;
+                }
+                if (head === '/status') {
+                    const body = options.status ? await resolveText(options.status()) : 'not wired';
+                    if (!running)
+                        return;
+                    state = pushEntry(state, 'status', body);
+                    paint();
+                    return;
+                }
+                if (head === '/ls') {
+                    const body = options.ls ? await resolveText(options.ls()) : 'not wired';
+                    if (!running)
+                        return;
+                    state = pushEntry(state, 'status', body);
+                    paint();
+                    return;
+                }
+                if (head === '/training') {
+                    const arg = text.slice('/training'.length).trim();
+                    if (!options.training) {
+                        state = pushEntry(state, 'status', 'not wired');
+                    }
+                    else if (arg !== 'on' && arg !== 'off') {
+                        state = pushEntry(state, 'status', 'usage: /training on|off');
+                    }
+                    else {
+                        const body = await resolveText(options.training(arg === 'on'));
+                        if (!running)
+                            return;
+                        state = pushEntry(state, 'status', body);
+                    }
+                    paint();
+                    return;
+                }
+                if (head === '/theme') {
+                    theme = theme === 'dark' ? 'light' : 'dark';
+                    state = pushEntry(state, 'status', `theme ${theme}`);
+                    paint();
+                    return;
+                }
+                if (head === '/help') {
+                    state = pushEntry(state, 'status', model_1.SLASH_COMMANDS.map((item) => `${item.name}  ${item.hint}`).join('\n'));
+                    paint();
+                    return;
+                }
+                state = pushEntry(state, 'status', `unknown command ${text}`);
+                paint();
+            };
+            const sendTurn = async (prompt) => {
+                state = pushEntry(state, 'user', prompt);
+                state = (0, model_1.startAssistant)(state);
+                state = clearDraft(state);
+                paint();
+                const sendOptions = {
+                    conversationId: newConversation ? undefined : state.conversationId || undefined,
+                    newConversation,
+                };
+                try {
+                    const gen = transport.send(prompt, sendOptions);
+                    let step = await gen.next();
+                    while (running && !step.done) {
+                        const event = step.value;
+                        if (event.type === 'bound' && event.text) {
+                            state = withChrome({ ...state, conversationId: event.text });
+                            newConversation = false;
+                        }
+                        else if (event.type === 'text' && event.text) {
+                            state = (0, model_1.appendText)(state, event.text);
+                        }
+                        else if (event.type === 'error') {
+                            state = pushEntry(state, 'status', event.text || 'stream error');
+                        }
+                        else if (event.type === 'status' && event.text) {
+                            state = pushEntry(state, 'status', event.text);
+                        }
+                        else if (event.type === 'tool' && event.text) {
+                            const folded = event.text.split('\n').length > 8;
+                            const entry = { id: `p${nextAppEntryId}`, kind: 'tool', text: event.text, folded };
+                            nextAppEntryId += 1;
+                            state = (0, model_1.insertToolBeforeLiveAssistant)(state, entry);
+                        }
+                        paint();
+                        if (!running)
+                            return;
+                        step = await gen.next();
+                    }
+                    if (!running || !step.done)
+                        return;
+                    const conversationId = step.value.conversationId;
+                    if (conversationId) {
+                        state = withChrome({ ...state, conversationId });
+                        newConversation = false;
+                    }
+                    await refreshQuota();
+                    state = withChrome(state);
+                    paint();
+                }
+                catch (err) {
+                    if (!running)
+                        return;
+                    state = pushEntry(state, 'status', err instanceof Error ? err.message : String(err));
+                    await refreshQuota();
+                    state = withChrome(state);
+                    paint();
+                }
+            };
+            const handleKey = async (key) => {
+                if (!running)
+                    return;
+                if (key.type === 'escape' && !state.slashOpen && state.draft === '') {
+                    finish(0);
+                    return;
+                }
+                if (key.type === 'enter') {
+                    const text = submittedText(state);
+                    if (!text) {
+                        const selected = state.entries[state.selected];
+                        const picked = pickMode && selected ? pickableIds.get(selected.id) : undefined;
+                        if (picked) {
+                            await openConversation(picked);
+                            paint();
+                            return;
+                        }
+                        state = (0, model_1.applyKey)(state, key);
+                        paint();
+                        return;
+                    }
+                    if (text.startsWith('/')) {
+                        await submitSlash(text);
+                        return;
+                    }
+                    await sendTurn(text);
+                    return;
+                }
+                state = (0, model_1.applyKey)(state, key);
+                paint();
+            };
+            const drain = async () => {
+                if (processing)
+                    return;
+                processing = true;
+                try {
+                    while (running && pending.length) {
+                        const key = pending.shift();
+                        if (!key)
+                            break;
+                        await handleKey(key);
+                    }
+                }
+                catch (err) {
+                    fail(err);
+                }
+                finally {
+                    processing = false;
+                    if (running && pending.length)
+                        void drain();
+                }
+            };
+            unsubscribe = io.onData((chunk) => {
+                const decoded = (0, input_1.decodeKeys)(rest + chunk);
+                rest = decoded.rest;
+                pending.push(...decoded.keys);
+                void drain();
+            });
+            options.ready?.();
+        });
+    }
+    finally {
+        running = false;
+        removeTerm();
+        try {
+            io.write(ALT_LEAVE);
+        }
+        finally {
+            io.leaveRaw();
+        }
+    }
+}