@stevezhou/sisu 0.1.0

package/dist/store.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_API_BASE = void 0;
+exports.getSisuHome = getSisuHome;
+exports.readAuth = readAuth;
+exports.writeAuth = writeAuth;
+exports.readSession = readSession;
+exports.writeSession = writeSession;
+exports.clearAuth = clearAuth;
+exports.readWorkspaces = readWorkspaces;
+exports.bindWorkspace = bindWorkspace;
+exports.requireAuth = requireAuth;
+exports.describeStatus = describeStatus;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.DEFAULT_API_BASE = 'https://www.sisu.chat';
+function getSisuHome() {
+    const override = (process.env.SISU_HOME || '').trim();
+    return override || path_1.default.join(os_1.default.homedir(), '.sisu');
+}
+function authPath() {
+    return path_1.default.join(getSisuHome(), 'auth.json');
+}
+function workspacePath() {
+    return path_1.default.join(getSisuHome(), 'workspace-paths.json');
+}
+function sessionPath() {
+    return path_1.default.join(getSisuHome(), 'session.json');
+}
+const HOME_MODE = 0o700;
+const FILE_MODE = 0o600;
+function ensureSisuHome() {
+    const home = getSisuHome();
+    fs_1.default.mkdirSync(home, { recursive: true, mode: HOME_MODE });
+    try {
+        fs_1.default.chmodSync(home, HOME_MODE);
+    }
+    catch {
+        // POSIX modes are ignored on some filesystems (e.g. Windows).
+    }
+    return home;
+}
+function readJson(file, fallback) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function writeJson(file, value) {
+    ensureSisuHome();
+    fs_1.default.writeFileSync(file, JSON.stringify(value, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: FILE_MODE,
+    });
+    try {
+        fs_1.default.chmodSync(file, FILE_MODE);
+    }
+    catch {
+        // POSIX modes are ignored on some filesystems (e.g. Windows).
+    }
+}
+function readAuth() {
+    const raw = readJson(authPath(), null);
+    if (!raw || typeof raw.token !== 'string' || !raw.token.trim())
+        return null;
+    return {
+        token: raw.token,
+        email: String(raw.email || ''),
+        user_id: String(raw.user_id || ''),
+        api_base: String(raw.api_base || exports.DEFAULT_API_BASE).replace(/\/+$/, ''),
+        plan_code: String(raw.plan_code || ''),
+        name: String(raw.name || ''),
+    };
+}
+function writeAuth(record) {
+    writeJson(authPath(), {
+        token: record.token,
+        email: record.email,
+        user_id: record.user_id,
+        api_base: record.api_base.replace(/\/+$/, '') || exports.DEFAULT_API_BASE,
+        plan_code: record.plan_code || '',
+        name: record.name || '',
+    });
+}
+function readSession() {
+    return readJson(sessionPath(), {});
+}
+function writeSession(record) {
+    writeJson(sessionPath(), record);
+}
+function clearAuth() {
+    try {
+        fs_1.default.unlinkSync(authPath());
+    }
+    catch {
+        // already logged out
+    }
+}
+function readWorkspaces() {
+    const raw = readJson(workspacePath(), {});
+    return raw && typeof raw === 'object' ? raw : {};
+}
+function bindWorkspace(projectId, requestedPath) {
+    if (!projectId.trim())
+        throw new Error('missing project id');
+    const trimmed = (requestedPath || '').trim();
+    if (!trimmed)
+        throw new Error('missing path');
+    if (!fs_1.default.existsSync(trimmed))
+        throw new Error('directory does not exist');
+    const stat = fs_1.default.statSync(trimmed);
+    if (!stat.isDirectory())
+        throw new Error('path is not a directory');
+    fs_1.default.accessSync(trimmed, fs_1.default.constants.R_OK);
+    const resolved = fs_1.default.realpathSync.native(trimmed);
+    const map = readWorkspaces();
+    map[projectId] = resolved;
+    writeJson(workspacePath(), map);
+    return { projectId, path: resolved };
+}
+function requireAuth() {
+    const auth = readAuth();
+    if (!auth)
+        throw new Error('not logged in — run sisu login');
+    return auth;
+}
+function describeStatus() {
+    const auth = readAuth();
+    return {
+        home: getSisuHome(),
+        logged_in: Boolean(auth),
+        email: auth?.email || '',
+        name: auth?.name || '',
+        plan_code: auth?.plan_code || '',
+        api_base: auth?.api_base || process.env.SISU_API_BASE || exports.DEFAULT_API_BASE,
+        workspaces: readWorkspaces(),
+    };
+}

package/dist/toolSummary.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DETAIL_CAP = exports.TOOL_STATUS_PHASES = void 0;
+exports.boundToolText = boundToolText;
+exports.summarizeToolInput = summarizeToolInput;
+exports.summarizeLiveTool = summarizeLiveTool;
+exports.summarizePersistedTool = summarizePersistedTool;
+exports.TOOL_STATUS_PHASES = new Set(['start', 'executing', 'end']);
+exports.TOOL_DETAIL_CAP = 160;
+function boundToolText(value, cap = exports.TOOL_DETAIL_CAP) {
+    const one = value.replace(/\s+/g, ' ').trim();
+    if (!one)
+        return '';
+    if (one.length <= cap)
+        return one;
+    return `${one.slice(0, Math.max(1, cap - 1))}…`;
+}
+function summarizeToolInput(input) {
+    if (typeof input === 'string')
+        return boundToolText(input);
+    if (!input || typeof input !== 'object')
+        return '';
+    const rec = input;
+    for (const key of ['path', 'file', 'query', 'url', 'name']) {
+        if (typeof rec[key] === 'string' && rec[key].trim()) {
+            return boundToolText(`${key}=${rec[key]}`);
+        }
+    }
+    const keys = Object.keys(rec);
+    if (keys.length === 1 && typeof rec[keys[0]] === 'string') {
+        return boundToolText(`${keys[0]}=${rec[keys[0]]}`);
+    }
+    return boundToolText(keys.join(','));
+}
+function toolName(data) {
+    return String(data.tool || data.name || data.type || 'tool');
+}
+function startDetail(data) {
+    if (typeof data.description === 'string' && data.description.trim()) {
+        return boundToolText(data.description);
+    }
+    if (typeof data.text === 'string' && data.text.trim())
+        return boundToolText(data.text);
+    if (typeof data.content === 'string' && data.content.trim())
+        return boundToolText(data.content);
+    if (data.content && typeof data.content === 'object')
+        return summarizeToolInput(data.content);
+    if (data.input !== undefined)
+        return summarizeToolInput(data.input);
+    return '';
+}
+function endDetail(data) {
+    const ok = data.success === false ? 'fail' : data.success === true ? 'ok' : '';
+    const preview = typeof data.result_preview === 'string'
+        ? data.result_preview
+        : typeof data.result_summary === 'string'
+            ? data.result_summary
+            : typeof data.result === 'string'
+                ? data.result
+                : '';
+    const bits = [ok, preview ? boundToolText(preview) : ''].filter(Boolean);
+    return bits.join(' · ');
+}
+/** Live SSE tool_call / recognized tool_status. Returns null for ignored phases. */
+function summarizeLiveTool(data, eventName) {
+    const tool = toolName(data);
+    if (eventName === 'tool_status') {
+        const phase = String(data.event || '');
+        if (!exports.TOOL_STATUS_PHASES.has(phase))
+            return null;
+        if (phase === 'end') {
+            const detail = endDetail(data);
+            return detail ? `${tool} · end · ${detail}` : `${tool} · end`;
+        }
+        const detail = startDetail(data);
+        return detail ? `${tool} · ${phase} · ${detail}` : `${tool} · ${phase}`;
+    }
+    if (eventName === 'tool_call') {
+        const detail = startDetail(data);
+        return detail ? `${tool} · call · ${detail}` : `${tool} · call`;
+    }
+    return null;
+}
+/** Persisted content_blocks snapshot. */
+function summarizePersistedTool(block) {
+    const tool = toolName(block);
+    const type = String(block.type || '');
+    if (type === 'tool_end' || type === 'tool_result') {
+        const detail = endDetail(block);
+        if (detail)
+            return `${tool} · ${detail}`;
+    }
+    const detail = startDetail(block);
+    return detail ? `${tool} · ${detail}` : tool;
+}

package/dist/transport.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSseEventToTurn = mapSseEventToTurn;
+exports.createFastApiTransport = createFastApiTransport;
+const client_1 = require("./client");
+const toolSummary_1 = require("./toolSummary");
+const http_1 = require("./http");
+const sse_1 = require("./sse");
+const store_1 = require("./store");
+function errorEventText(event) {
+    if (typeof event.data === 'string')
+        return event.data;
+    if (event.data && typeof event.data === 'object') {
+        const message = event.data.message;
+        if (typeof message === 'string' && message)
+            return message;
+    }
+    return 'stream error';
+}
+function mapSseEventToTurn(event) {
+    if (event.type === 'error')
+        return { type: 'error', text: errorEventText(event) };
+    if (event.type === 'text') {
+        const text = (0, sse_1.sseEventText)(event);
+        return text ? { type: 'text', text } : null;
+    }
+    if (event.name === 'tool_call' || event.name === 'tool_status') {
+        const data = event.data && typeof event.data === 'object' ? event.data : {};
+        const text = (0, toolSummary_1.summarizeLiveTool)(data, event.name);
+        return text ? { type: 'tool', text } : null;
+    }
+    return null;
+}
+async function* responseChunks(response) {
+    if (response.stream) {
+        yield* response.stream();
+        return;
+    }
+    yield await response.text();
+}
+function turnEventsFrom(buffer) {
+    const parsed = (0, sse_1.consumeSse)(buffer);
+    const events = [];
+    for (const event of parsed.events) {
+        const mapped = mapSseEventToTurn(event);
+        if (mapped)
+            events.push(mapped);
+    }
+    return { events, rest: parsed.rest };
+}
+function createFastApiTransport(http) {
+    return {
+        async *send(prompt, options = {}) {
+            const auth = (0, store_1.requireAuth)();
+            const text = prompt.trim();
+            if (!text)
+                throw new Error('prompt is required');
+            const stamp = (0, client_1.clientStamp)('tui');
+            const session = (0, store_1.readSession)();
+            let conversationId = options.conversationId || (!options.newConversation ? session.last_conversation_id : '') || '';
+            if (!conversationId) {
+                const created = await http(`${auth.api_base}/api/chat/conversations`, {
+                    method: 'POST',
+                    headers: (0, http_1.authHeaders)(auth.token),
+                    body: JSON.stringify({
+                        title: text.slice(0, 50),
+                        project_id: session.last_project_id || undefined,
+                        client: stamp.client,
+                        client_version: stamp.client_version,
+                    }),
+                });
+                const body = await created.json().catch(() => ({}));
+                if (!created.ok)
+                    throw new Error((0, http_1.errorDetail)(body, `create conversation failed (${created.status})`));
+                conversationId = String(body.id || '');
+                if (!conversationId)
+                    throw new Error('create conversation missing id');
+            }
+            (0, store_1.writeSession)({
+                ...(0, store_1.readSession)(),
+                last_conversation_id: conversationId,
+            });
+            yield { type: 'bound', text: conversationId };
+            const sent = await http(`${auth.api_base}/api/chat/send`, {
+                method: 'POST',
+                headers: (0, http_1.authHeaders)(auth.token),
+                body: JSON.stringify({
+                    conversation_id: conversationId,
+                    message: text,
+                    task_category: 'coding',
+                    client: stamp.client,
+                    client_version: stamp.client_version,
+                    client_request_id: stamp.client_request_id,
+                }),
+            });
+            if (!sent.ok) {
+                const body = await sent.json().catch(() => ({}));
+                throw new Error((0, http_1.errorDetail)(body, `exec failed (${sent.status})`));
+            }
+            let buffer = '';
+            for await (const chunk of responseChunks(sent)) {
+                const parsed = turnEventsFrom(buffer + chunk);
+                buffer = parsed.rest;
+                for (const event of parsed.events)
+                    yield event;
+            }
+            if (buffer.trim()) {
+                const parsed = turnEventsFrom(`${buffer}\n\n`);
+                for (const event of parsed.events)
+                    yield event;
+            }
+            return { conversationId };
+        },
+        async listConversations() {
+            const auth = (0, store_1.requireAuth)();
+            const response = await http(`${auth.api_base}/api/chat/conversations?limit=30`, {
+                headers: (0, http_1.authHeaders)(auth.token),
+            });
+            const body = await response.json().catch(() => []);
+            if (!response.ok)
+                throw new Error((0, http_1.errorDetail)(body, `history failed (${response.status})`));
+            const rows = Array.isArray(body) ? body : [];
+            return rows.map((row) => ({
+                id: String(row.id || ''),
+                title: String(row.title || ''),
+                ...(row.client ? { client: String(row.client) } : {}),
+            }));
+        },
+        async getConversation(id) {
+            const auth = (0, store_1.requireAuth)();
+            const trimmed = id.trim();
+            if (!trimmed)
+                throw new Error('conversation id is required');
+            const response = await http(`${auth.api_base}/api/chat/conversations/${encodeURIComponent(trimmed)}`, {
+                headers: (0, http_1.authHeaders)(auth.token),
+            });
+            const body = await response.json().catch(() => ({}));
+            if (!response.ok)
+                throw new Error((0, http_1.errorDetail)(body, `conversation failed (${response.status})`));
+            const messages = Array.isArray(body.messages) ? body.messages : [];
+            return {
+                id: String(body.id || trimmed),
+                title: String(body.title || ''),
+                messages: messages.map((row) => ({
+                    id: String(row.id || ''),
+                    role: String(row.role || ''),
+                    content: String(row.content || ''),
+                    ...(row.message_type ? { message_type: String(row.message_type) } : {}),
+                    ...(row.content_blocks ? { content_blocks: row.content_blocks } : {}),
+                })),
+            };
+        },
+    };
+}

package/dist/tui.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldAnimateSplash = shouldAnimateSplash;
+exports.playMobiusIntro = playMobiusIntro;
+exports.defaultTuiIo = defaultTuiIo;
+exports.tuiHelp = tuiHelp;
+exports.runTui = runTui;
+const readline_1 = __importDefault(require("readline"));
+const commands_1 = require("./commands");
+const http_1 = require("./http");
+const logo_1 = require("./logo");
+const mobius_1 = require("./mobius");
+const app_1 = require("./pager/app");
+const stdio_1 = require("./pager/stdio");
+const store_1 = require("./store");
+const transport_1 = require("./transport");
+function shouldAnimateSplash(env = process.env, tty = Boolean(process.stdout.isTTY)) {
+    if (env.SISU_TUI_STATIC === '1')
+        return false;
+    return tty;
+}
+function shouldUsePager(deps, env = process.env) {
+    if (deps.animate === false)
+        return false;
+    if (env.SISU_TUI_STATIC === '1')
+        return false;
+    return Boolean(process.stdout.isTTY);
+}
+async function playMobiusIntro(io, options = {}) {
+    const columns = options.columns ?? process.stdout.columns ?? 80;
+    const frames = options.frames ?? 32;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const color = options.color ?? Boolean(process.stdout.isTTY);
+    const rows = (0, mobius_1.mobiusFrameHeight)(columns);
+    io.write('\x1b[?25l');
+    for (let i = 0; i < frames; i += 1) {
+        const phase = (i / frames) * Math.PI * 2;
+        const art = (0, logo_1.sisuMobiusArt)(columns, phase, color);
+        if (i === 0)
+            io.write(`${art}\n`);
+        else
+            io.write(`\x1b[${rows}A${art}\n`);
+        await sleep(38);
+    }
+    io.write('\x1b[?25h');
+    io.write(`\n${(0, logo_1.sisuWordmark)()}\n\n`);
+}
+function defaultTuiIo() {
+    let rl;
+    const ensureRl = () => {
+        if (!rl) {
+            rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+        }
+        return rl;
+    };
+    const io = {
+        write(text) {
+            process.stdout.write(text);
+        },
+        question(prompt) {
+            return new Promise((resolve) => {
+                ensureRl().question(prompt, (answer) => resolve(answer));
+            });
+        },
+        questionPassword(prompt) {
+            if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+                return readHiddenPassword(io, prompt);
+            }
+            return io.question(prompt);
+        },
+        close() {
+            rl?.close();
+            rl = undefined;
+        },
+    };
+    return io;
+}
+async function readHiddenPassword(io, prompt) {
+    io.close?.();
+    io.write(prompt);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (typeof stdin.setRawMode === 'function')
+        stdin.setRawMode(true);
+    stdin.resume();
+    try {
+        return await new Promise((resolve, reject) => {
+            let password = '';
+            const finish = (value, error) => {
+                stdin.off('data', onData);
+                stdin.off('error', onError);
+                io.write('\n');
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            const onError = (error) => finish('', error);
+            const onData = (chunk) => {
+                const text = String(chunk);
+                for (const ch of text) {
+                    if (ch === '\n' || ch === '\r') {
+                        finish(password);
+                        return;
+                    }
+                    if (ch === '\u0003') {
+                        finish('\u0003');
+                        return;
+                    }
+                    if (ch === '\u007f' || ch === '\b') {
+                        password = password.slice(0, -1);
+                        continue;
+                    }
+                    password += ch;
+                }
+            };
+            stdin.on('data', onData);
+            stdin.on('error', onError);
+        });
+    }
+    finally {
+        if (typeof stdin.setRawMode === 'function')
+            stdin.setRawMode(Boolean(wasRaw));
+    }
+}
+async function promptLogin(io, login) {
+    const email = (await io.question('Email: ')).trim();
+    if (!email) {
+        io.write('login cancelled\n');
+        return 'cancelled';
+    }
+    const password = await (io.questionPassword ?? io.question)('Password: ');
+    if (password === '\u0003') {
+        io.write('login cancelled\n');
+        return 'cancelled';
+    }
+    try {
+        const loggedIn = await login({ email, password });
+        io.write(`logged in as ${loggedIn}\n`);
+        return 'ok';
+    }
+    catch (error) {
+        io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        return 'failed';
+    }
+}
+function tuiHelp() {
+    return [
+        '/status     account and quota',
+        '/ls         local workspace files',
+        '/history    saved cloud conversations',
+        '/open <id>  continue a saved conversation',
+        '/new        start a new conversation',
+        '/training on|off   allow or refuse training use of new turns',
+        '/help       this list',
+        '/quit       leave',
+        'otherwise   send a turn (billed to your SiSu account)',
+    ].join('\n');
+}
+async function runTui(io, deps = {}) {
+    const http = deps.http ?? http_1.defaultHttp;
+    const status = deps.status ?? commands_1.statusCommand;
+    const exec = deps.exec ?? commands_1.execCommand;
+    const ls = deps.ls ?? commands_1.listLocalCommand;
+    const history = deps.history ?? commands_1.listConversationsCommand;
+    const openThread = deps.openThread ?? commands_1.openConversationCommand;
+    const training = deps.training ?? commands_1.setTrainingCommand;
+    const auth = deps.auth ?? store_1.readAuth;
+    const columns = deps.columns ?? process.stdout.columns ?? 80;
+    const animate = deps.animate ?? shouldAnimateSplash();
+    const color = deps.color ?? Boolean(process.stdout.isTTY);
+    try {
+        if (animate) {
+            await playMobiusIntro(io, { columns, sleep: deps.sleep, color });
+        }
+        else {
+            io.write(`${(0, logo_1.sisuBanner)(columns, 0.35, color)}\n`);
+        }
+        let account = auth();
+        if (!account) {
+            const login = deps.login ?? commands_1.loginCommand;
+            const result = await promptLogin(io, login);
+            if (result !== 'ok')
+                return 2;
+            account = auth();
+            if (!account) {
+                io.write('login did not persist auth\n');
+                return 2;
+            }
+        }
+        if (deps.pager || shouldUsePager(deps)) {
+            io.close?.();
+            const transport = (0, transport_1.createFastApiTransport)(http);
+            return await (deps.pager ?? app_1.runPager)((0, stdio_1.stdioPagerIo)(), transport, {
+                columns,
+                email: account.email,
+                quota: async () => (0, commands_1.formatQuota)(await (0, commands_1.fetchBalance)(http)),
+                status: () => status(http),
+                ls: () => {
+                    try {
+                        return ls();
+                    }
+                    catch (error) {
+                        return error instanceof Error ? error.message : String(error);
+                    }
+                },
+                training: (on) => training(on, http),
+            });
+        }
+        io.write(`${await status(http)}\n`);
+        io.write(`${tuiHelp()}\n\n`);
+        let newConversation = false;
+        while (true) {
+            const raw = (await io.question('› ')).trim();
+            if (!raw)
+                continue;
+            if (raw === '/quit' || raw === '/exit') {
+                io.write('bye\n');
+                return 0;
+            }
+            if (raw === '/help') {
+                io.write(`${tuiHelp()}\n`);
+                continue;
+            }
+            if (raw === '/status') {
+                io.write(`${await status(http)}\n`);
+                continue;
+            }
+            if (raw === '/ls') {
+                try {
+                    io.write(`${ls()}\n`);
+                }
+                catch (error) {
+                    io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            if (raw === '/new') {
+                newConversation = true;
+                io.write('next turn starts a new conversation\n');
+                continue;
+            }
+            if (raw === '/history') {
+                try {
+                    io.write(`${await history(http)}\n`);
+                }
+                catch (error) {
+                    io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            if (raw.startsWith('/open ')) {
+                try {
+                    io.write(`${openThread(raw.slice(6).trim())}\n`);
+                    newConversation = false;
+                }
+                catch (error) {
+                    io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            if (raw === '/training on' || raw === '/training off') {
+                try {
+                    io.write(`${await training(raw.endsWith('on'), http)}\n`);
+                }
+                catch (error) {
+                    io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            try {
+                const result = await exec(raw, { newConversation, client: 'tui' }, http);
+                newConversation = false;
+                io.write(`${result.text || '(empty reply)'}\n`);
+            }
+            catch (error) {
+                io.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    }
+    finally {
+        io.close?.();
+    }
+}