@stevezhou/sisu 0.1.0

package/dist/pager/history.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entriesFromMessages = entriesFromMessages;
+const toolSummary_1 = require("../toolSummary");
+const TOOL_BLOCKS = new Set(['tool_use', 'tool_status', 'tool_result', 'tool_start', 'tool_end']);
+const TOOL_TYPES = new Set(['tool_use', 'tool_result']);
+function lineCount(text) {
+    if (!text)
+        return 0;
+    return text.split('\n').length;
+}
+function isToolBlock(block) {
+    const type = String(block.type || '');
+    if (TOOL_BLOCKS.has(type))
+        return true;
+    return !type && Boolean(block.tool || block.name);
+}
+function toolBlockText(block) {
+    return (0, toolSummary_1.summarizePersistedTool)(block);
+}
+function asEntry(kind, text) {
+    return { kind, text, folded: kind === 'tool' && lineCount(text) > 8 };
+}
+function entriesFromMessages(messages, limit = 200) {
+    const raw = [];
+    for (const msg of messages) {
+        const blocks = (msg.content_blocks || []).filter(isToolBlock);
+        for (const block of blocks)
+            raw.push(asEntry('tool', toolBlockText(block)));
+        const content = (msg.content || '').trim();
+        const isToolMsg = TOOL_TYPES.has(String(msg.message_type || ''));
+        if (isToolMsg && blocks.length === 0 && content) {
+            raw.push(asEntry('tool', content));
+            continue;
+        }
+        if (isToolMsg)
+            continue;
+        if (!content)
+            continue;
+        if (msg.role !== 'user' && msg.role !== 'assistant')
+            continue;
+        if (blocks.length > 0 && content === toolBlockText(blocks[0]))
+            continue;
+        raw.push(asEntry(msg.role, content));
+    }
+    const truncated = raw.length > limit;
+    return { entries: truncated ? raw.slice(-limit) : raw, truncated };
+}

package/dist/pager/input.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeKeys = decodeKeys;
+/**
+ * Decode a raw terminal input chunk into pager keys.
+ * Incomplete CSI sequences are returned in `rest` so the next read can finish them.
+ * `\x03` (Ctrl+C) maps to escape; the app treats escape at empty draft as quit.
+ */
+function decodeKeys(chunk) {
+    const keys = [];
+    let i = 0;
+    while (i < chunk.length) {
+        const ch = chunk[i];
+        if (ch === '\x1b') {
+            // Incomplete CSI prefix — hold for the next chunk.
+            if (i + 1 === chunk.length) {
+                keys.push({ type: 'escape' });
+                i += 1;
+                continue;
+            }
+            if (chunk[i + 1] === '[') {
+                if (i + 2 >= chunk.length) {
+                    return { keys, rest: chunk.slice(i) };
+                }
+                const code = chunk[i + 2];
+                const arrow = code === 'A'
+                    ? 'up'
+                    : code === 'B'
+                        ? 'down'
+                        : code === 'C'
+                            ? 'right'
+                            : code === 'D'
+                                ? 'left'
+                                : null;
+                if (arrow) {
+                    keys.push({ type: arrow });
+                    i += 3;
+                    continue;
+                }
+                // Unknown completed CSI: treat ESC as escape and rescan from '['.
+                keys.push({ type: 'escape' });
+                i += 1;
+                continue;
+            }
+            // ESC not introducing CSI → escape
+            keys.push({ type: 'escape' });
+            i += 1;
+            continue;
+        }
+        if (ch === '\r' || ch === '\n') {
+            keys.push({ type: 'enter' });
+            i += 1;
+            continue;
+        }
+        if (ch === '\x7f' || ch === '\b') {
+            keys.push({ type: 'backspace' });
+            i += 1;
+            continue;
+        }
+        // Ctrl+C → escape (app treats escape at empty draft as quit)
+        if (ch === '\x03') {
+            keys.push({ type: 'escape' });
+            i += 1;
+            continue;
+        }
+        // Skip other C0 controls (except those handled above)
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 || code === 0x7f) {
+            i += 1;
+            continue;
+        }
+        // Printable UTF-16 code unit / surrogate pair as one char
+        const cp = chunk.codePointAt(i);
+        if (cp === undefined) {
+            i += 1;
+            continue;
+        }
+        const value = String.fromCodePoint(cp);
+        keys.push({ type: 'char', value });
+        i += value.length;
+    }
+    return { keys, rest: '' };
+}

package/dist/pager/model.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLASH_COMMANDS = void 0;
+exports.createPagerState = createPagerState;
+exports.filterSlash = filterSlash;
+exports.startAssistant = startAssistant;
+exports.insertToolBeforeLiveAssistant = insertToolBeforeLiveAssistant;
+exports.appendText = appendText;
+exports.applyKey = applyKey;
+exports.SLASH_COMMANDS = [
+    { name: '/new', hint: 'Start a new conversation (alias: /clear)' },
+    { name: '/resume', hint: 'Resume a conversation (alias: /history)' },
+    { name: '/status', hint: 'Show session status' },
+    { name: '/ls', hint: 'List local workspace files' },
+    { name: '/training', hint: 'Training mode' },
+    { name: '/theme', hint: 'Toggle theme' },
+    { name: '/help', hint: 'Show help' },
+    { name: '/quit', hint: 'Quit the pager (alias: /exit)' },
+];
+/** Alias token → primary slash command name. */
+const SLASH_ALIASES = {
+    '/clear': '/new',
+    '/history': '/resume',
+    '/exit': '/quit',
+};
+let nextEntryId = 1;
+function entryId() {
+    const id = `e${nextEntryId}`;
+    nextEntryId += 1;
+    return id;
+}
+function createPagerState() {
+    return {
+        entries: [],
+        selected: 0,
+        draft: '',
+        slashOpen: false,
+        conversationId: '',
+        slashIndex: 0,
+    };
+}
+function clampSelected(entries, selected) {
+    if (entries.length === 0)
+        return 0;
+    if (selected < 0)
+        return 0;
+    if (selected >= entries.length)
+        return entries.length - 1;
+    return selected;
+}
+function clampSlashIndex(draft, slashIndex) {
+    const items = filterSlash(draft);
+    if (items.length === 0)
+        return 0;
+    if (slashIndex < 0)
+        return items.length - 1;
+    if (slashIndex >= items.length)
+        return 0;
+    return slashIndex;
+}
+function withDraft(state, draft, slashOpen) {
+    const open = slashOpen ?? (draft.startsWith('/') ? state.slashOpen || draft === '/' : false);
+    return {
+        ...state,
+        draft,
+        slashOpen: open && draft.startsWith('/'),
+        slashIndex: open && draft.startsWith('/') ? clampSlashIndex(draft, state.slashIndex) : 0,
+    };
+}
+function setEntryFold(state, folded) {
+    if (state.entries.length === 0)
+        return state;
+    const selected = clampSelected(state.entries, state.selected);
+    const entries = state.entries.map((entry, index) => index === selected ? { ...entry, folded } : entry);
+    return { ...state, entries, selected };
+}
+function filterSlash(draft) {
+    const query = draft.trim().toLowerCase();
+    if (!query.startsWith('/'))
+        return [];
+    const matched = new Map();
+    for (const cmd of exports.SLASH_COMMANDS) {
+        if (cmd.name.startsWith(query) || query.startsWith(cmd.name)) {
+            matched.set(cmd.name, cmd);
+        }
+    }
+    for (const [alias, primary] of Object.entries(SLASH_ALIASES)) {
+        if (alias.startsWith(query) || query.startsWith(alias)) {
+            const cmd = exports.SLASH_COMMANDS.find((item) => item.name === primary);
+            if (cmd)
+                matched.set(cmd.name, cmd);
+        }
+    }
+    // Preserve canonical order
+    return exports.SLASH_COMMANDS.filter((cmd) => matched.has(cmd.name));
+}
+function startAssistant(state) {
+    const entry = {
+        id: entryId(),
+        kind: 'assistant',
+        text: '',
+        folded: false,
+    };
+    const entries = [...state.entries, entry];
+    return {
+        ...state,
+        entries,
+        selected: entries.length - 1,
+    };
+}
+/** Insert a tool card before the live (last) assistant so the answer stays the turn tail. */
+function insertToolBeforeLiveAssistant(state, entry) {
+    let live = -1;
+    for (let i = state.entries.length - 1; i >= 0; i -= 1) {
+        if (state.entries[i].kind === 'assistant') {
+            live = i;
+            break;
+        }
+    }
+    if (live < 0) {
+        const entries = [...state.entries, entry];
+        return { ...state, entries, selected: entries.length - 1 };
+    }
+    const entries = [...state.entries.slice(0, live), entry, ...state.entries.slice(live)];
+    return { ...state, entries, selected: live + 1 };
+}
+function appendText(state, text) {
+    if (!text)
+        return state;
+    // Append onto the last assistant entry (the live stream target).
+    for (let i = state.entries.length - 1; i >= 0; i -= 1) {
+        if (state.entries[i].kind === 'assistant') {
+            const entries = state.entries.slice();
+            entries[i] = { ...entries[i], text: entries[i].text + text };
+            return { ...state, entries };
+        }
+    }
+    // No assistant yet — create one and seed it.
+    const seeded = startAssistant(state);
+    return appendText(seeded, text);
+}
+function applyKey(state, key) {
+    switch (key.type) {
+        case 'char': {
+            const draft = state.draft + key.value;
+            if (key.value === '/' && state.draft === '') {
+                return { ...state, draft: '/', slashOpen: true, slashIndex: 0 };
+            }
+            if (state.slashOpen || draft.startsWith('/')) {
+                return withDraft(state, draft, draft.startsWith('/'));
+            }
+            return { ...state, draft };
+        }
+        case 'backspace': {
+            if (!state.draft)
+                return state;
+            const draft = state.draft.slice(0, -1);
+            if (state.slashOpen) {
+                if (!draft.startsWith('/')) {
+                    return { ...state, draft, slashOpen: false, slashIndex: 0 };
+                }
+                return withDraft(state, draft, true);
+            }
+            return { ...state, draft };
+        }
+        case 'escape': {
+            if (state.slashOpen) {
+                return { ...state, slashOpen: false, slashIndex: 0 };
+            }
+            return state;
+        }
+        case 'enter': {
+            // Command execution is owned by the app layer; model only retains draft.
+            return state;
+        }
+        case 'left':
+            return setEntryFold(state, true);
+        case 'right':
+            return setEntryFold(state, false);
+        case 'up': {
+            if (state.slashOpen) {
+                const items = filterSlash(state.draft);
+                if (items.length === 0)
+                    return state;
+                const slashIndex = (state.slashIndex - 1 + items.length) % items.length;
+                return { ...state, slashIndex };
+            }
+            if (state.draft === '' && state.entries.length > 0) {
+                const selected = clampSelected(state.entries, state.selected - 1);
+                return { ...state, selected };
+            }
+            return state;
+        }
+        case 'down': {
+            if (state.slashOpen) {
+                const items = filterSlash(state.draft);
+                if (items.length === 0)
+                    return state;
+                const slashIndex = (state.slashIndex + 1) % items.length;
+                return { ...state, slashIndex };
+            }
+            if (state.draft === '' && state.entries.length > 0) {
+                const selected = clampSelected(state.entries, state.selected + 1);
+                return { ...state, selected };
+            }
+            return state;
+        }
+        default:
+            return state;
+    }
+}

package/dist/pager/render.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPager = renderPager;
+const model_1 = require("./model");
+const theme_1 = require("./theme");
+const PROMPT_PREFIX = '› ';
+const PROMPT_BOX_ROWS = 2;
+const STATUS_ROWS = 1;
+const MARK_WIDTH = 2;
+/** Pad (and clip reserved chrome) to exactly `cols` cells. */
+function pad(line, cols) {
+    const width = Math.max(0, cols);
+    if (width === 0)
+        return '';
+    const plain = (0, theme_1.stripAnsi)(line);
+    if (plain.length === width)
+        return plain;
+    if (plain.length > width)
+        return plain.slice(0, width);
+    return plain.padEnd(width, ' ');
+}
+function wrapPlain(text, width) {
+    const max = Math.max(1, width);
+    if (!text)
+        return [''];
+    const out = [];
+    for (const paragraph of text.split('\n')) {
+        if (!paragraph) {
+            out.push('');
+            continue;
+        }
+        for (let i = 0; i < paragraph.length; i += max) {
+            out.push(paragraph.slice(i, i + max));
+        }
+    }
+    return out;
+}
+function lineCount(text) {
+    if (!text)
+        return 0;
+    return text.split('\n').length;
+}
+function entryBodyLines(entry, wrapWidth) {
+    if (entry.folded) {
+        const n = lineCount(entry.text);
+        const unit = n === 1 ? 'line' : 'lines';
+        return wrapPlain(`${entry.kind} · ${n} ${unit}`, wrapWidth);
+    }
+    if (!entry.text)
+        return [''];
+    return wrapPlain(entry.text, wrapWidth);
+}
+function layoutScrollback(state, cols) {
+    const wrapWidth = Math.max(1, cols - MARK_WIDTH);
+    const lines = [];
+    const entryOf = [];
+    for (let i = 0; i < state.entries.length; i += 1) {
+        const entry = state.entries[i];
+        const body = entryBodyLines(entry, wrapWidth);
+        const mark = i === state.selected && state.entries.length > 0 ? '▸ ' : '  ';
+        for (let j = 0; j < body.length; j += 1) {
+            lines.push(j === 0 ? `${mark}${body[j]}` : `  ${body[j]}`);
+            entryOf.push(i);
+        }
+    }
+    return { lines, entryOf };
+}
+function windowAroundSelected(lines, entryOf, selected, budget, lastEntry) {
+    if (budget <= 0)
+        return [];
+    if (lines.length <= budget)
+        return lines;
+    if (selected >= lastEntry)
+        return lines.slice(lines.length - budget);
+    let start = -1;
+    let end = -1;
+    for (let i = 0; i < entryOf.length; i += 1) {
+        if (entryOf[i] !== selected)
+            continue;
+        if (start < 0)
+            start = i;
+        end = i;
+    }
+    if (start < 0)
+        return lines.slice(lines.length - budget);
+    if (end - start + 1 >= budget)
+        return lines.slice(start, start + budget);
+    const windowStart = Math.max(0, Math.min(start, end + 1 - budget));
+    return lines.slice(windowStart, windowStart + budget);
+}
+function slashMenuLines(state) {
+    if (!state.slashOpen)
+        return [];
+    const items = (0, model_1.filterSlash)(state.draft);
+    return items.map((item, index) => {
+        const mark = index === state.slashIndex ? '› ' : '  ';
+        return `${mark}${item.name}  ${item.hint}`;
+    });
+}
+/**
+ * Pure fixed-grid frame: always `rows` lines, each exactly `cols` characters.
+ * `theme` selects the SiSu palette via `getTheme` for future colored paint; the
+ * frame itself is plain so `line.length === cols` for the tty writer.
+ * Deterministic: no clock, no I/O.
+ */
+function renderPager(state, cols, rows, theme = 'dark') {
+    // Bind palette so dark/light stays on the public pure path (app may recolor).
+    (0, theme_1.getTheme)(theme);
+    const height = Math.max(0, rows);
+    const width = Math.max(0, cols);
+    if (height === 0)
+        return '';
+    const promptRows = Math.min(PROMPT_BOX_ROWS, height);
+    const statusRows = height > promptRows ? Math.min(STATUS_ROWS, height - promptRows) : 0;
+    const chrome = promptRows + statusRows;
+    const bodyBudget = Math.max(0, height - chrome);
+    const slash = slashMenuLines(state);
+    const slashTake = Math.min(slash.length, bodyBudget);
+    const scrollBudget = bodyBudget - slashTake;
+    const laid = layoutScrollback(state, width);
+    const lastEntry = Math.max(0, state.entries.length - 1);
+    const visibleScroll = windowAroundSelected(laid.lines, laid.entryOf, state.selected, scrollBudget, lastEntry);
+    const body = [];
+    // Top-pad scrollback so newest content sits just above slash/status/prompt.
+    while (body.length + visibleScroll.length < scrollBudget) {
+        body.push('');
+    }
+    body.push(...visibleScroll);
+    body.push(...slash.slice(0, slashTake));
+    const lines = body.map((line) => pad(line, width));
+    if (statusRows > 0) {
+        lines.push(pad(state.statusLine ?? '', width));
+    }
+    if (promptRows >= 2) {
+        // Prompt box: border row + draft row (`› {draft}`).
+        lines.push(pad('─'.repeat(width), width));
+        lines.push(pad(`${PROMPT_PREFIX}${state.draft}`, width));
+    }
+    else if (promptRows === 1) {
+        lines.push(pad(`${PROMPT_PREFIX}${state.draft}`, width));
+    }
+    while (lines.length < height)
+        lines.push(pad('', width));
+    if (lines.length > height)
+        lines.length = height;
+    return lines.map((line) => pad(line, width)).join('\n');
+}

package/dist/pager/stdio.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stdioPagerIo = stdioPagerIo;
+function stdioPagerIo() {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let previousRaw = false;
+    return {
+        write(text) {
+            stdout.write(text);
+        },
+        onData(handler) {
+            const listener = (chunk) => {
+                handler(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+            };
+            stdin.on('data', listener);
+            return () => {
+                stdin.off('data', listener);
+            };
+        },
+        enterRaw() {
+            if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+                previousRaw = Boolean(stdin.isRaw);
+                stdin.setRawMode(true);
+            }
+            stdin.setEncoding('utf8');
+            stdin.resume();
+        },
+        leaveRaw() {
+            if (stdin.isTTY && typeof stdin.setRawMode === 'function') {
+                stdin.setRawMode(previousRaw);
+            }
+            stdin.pause();
+        },
+        get columns() {
+            return stdout.columns || 80;
+        },
+        get rows() {
+            return stdout.rows || 24;
+        },
+    };
+}

package/dist/pager/theme.js

@@ -0,0 +1,39 @@
+"use strict";
+/** SiSu pager palette: blue → purple → gold (same anchors as mobiusRgb). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTheme = getTheme;
+exports.stripAnsi = stripAnsi;
+const RESET = '\x1b[0m';
+function ansiRgb(r, g, b) {
+    return `\x1b[38;2;${r};${g};${b}m`;
+}
+function paint(prefix) {
+    return (s) => (s ? `${prefix}${s}${RESET}` : s);
+}
+/** Brand anchors from mobiusRgb (blue, purple, gold). */
+const BLUE = ansiRgb(37, 99, 235);
+const PURPLE = ansiRgb(124, 58, 237);
+const GOLD = ansiRgb(217, 119, 6);
+const DARK = {
+    text: paint(ansiRgb(230, 232, 240)),
+    dim: paint(ansiRgb(120, 126, 150)),
+    accent: paint(GOLD),
+    error: paint(ansiRgb(239, 68, 68)),
+    border: paint(PURPLE),
+    reset: RESET,
+};
+const LIGHT = {
+    text: paint(ansiRgb(24, 28, 40)),
+    dim: paint(ansiRgb(100, 108, 128)),
+    accent: paint(GOLD),
+    error: paint(ansiRgb(185, 28, 28)),
+    border: paint(BLUE),
+    reset: RESET,
+};
+function getTheme(name = 'dark') {
+    return name === 'light' ? LIGHT : DARK;
+}
+/** Strip 24-bit / SGR sequences for visible-width measurement. */
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/dist/sse.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumeSse = consumeSse;
+exports.sseEventText = sseEventText;
+exports.extractSseText = extractSseText;
+function parseSseData(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function classifyEvent(name) {
+    if (name === 'text')
+        return 'text';
+    if (name === 'error')
+        return 'error';
+    return 'other';
+}
+function parseSegment(segment) {
+    if (!segment.trim())
+        return null;
+    const eventMatch = segment.match(/^event: (.+)$/m);
+    const dataMatch = segment.match(/^data: (.+)$/m);
+    if (!eventMatch || !dataMatch)
+        return null;
+    const name = eventMatch[1].trim();
+    return {
+        type: classifyEvent(name),
+        name,
+        data: parseSseData(dataMatch[1]),
+    };
+}
+function consumeSse(buffer) {
+    const events = [];
+    const segments = buffer.split('\n\n');
+    const rest = segments.pop() ?? '';
+    for (const segment of segments) {
+        const event = parseSegment(segment);
+        if (event)
+            events.push(event);
+    }
+    return { events, rest };
+}
+function sseEventText(event) {
+    if (event.type === 'error') {
+        const message = typeof event.data === 'string'
+            ? event.data
+            : event.data?.message || 'stream error';
+        throw new Error(String(message));
+    }
+    if (event.type !== 'text')
+        return '';
+    const data = event.data;
+    if (typeof data === 'string')
+        return data;
+    if (data && typeof data === 'object') {
+        const record = data;
+        const piece = record.text ?? record.content ?? record.delta;
+        if (typeof piece === 'string')
+            return piece;
+    }
+    return '';
+}
+function extractSseText(stream) {
+    const { events } = consumeSse(stream.endsWith('\n\n') ? stream : `${stream}\n\n`);
+    const chunks = [];
+    for (const event of events) {
+        if (event.type === 'error') {
+            // sseEventText throws on error
+            sseEventText(event);
+        }
+        if (event.type === 'text') {
+            const piece = sseEventText(event);
+            if (piece)
+                chunks.push(piece);
+        }
+    }
+    return chunks.join('');
+}