@stevezhou/sisu 0.1.10 → 0.2.0

package/dist/runtime/sessions.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalSession = createLocalSession;
+exports.loadLocalSession = loadLocalSession;
+exports.saveLocalSession = saveLocalSession;
+exports.listLocalSessions = listLocalSessions;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const store_1 = require("../store");
+function sessionsDir() {
+    return path_1.default.join((0, store_1.getSisuHome)(), 'sessions');
+}
+function sessionFile(id) {
+    return path_1.default.join(sessionsDir(), `${id}.json`);
+}
+function createLocalSession(title, cwd, model) {
+    const session = {
+        id: (0, crypto_1.randomUUID)(),
+        title: title.slice(0, 80) || 'session',
+        cwd,
+        model,
+        messages: [],
+        updatedAt: new Date().toISOString(),
+    };
+    saveLocalSession(session);
+    return session;
+}
+function loadLocalSession(id) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(sessionFile(id), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveLocalSession(session) {
+    fs_1.default.mkdirSync(sessionsDir(), { recursive: true, mode: 0o700 });
+    const file = sessionFile(session.id);
+    fs_1.default.writeFileSync(file, JSON.stringify({ ...session, updatedAt: new Date().toISOString() }, null, 2) + '\n', {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+function listLocalSessions() {
+    const dir = sessionsDir();
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    return fs_1.default
+        .readdirSync(dir)
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(path_1.default.join(dir, name), 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((row) => Boolean(row))
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}

package/dist/runtime/suite.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_COMPAT_PATH = exports.COMPLETE_PATH = exports.PRODUCT_BIN = exports.PRODUCT_NAME = exports.GROK_BUILD_SURFACE = void 0;
+exports.grokBuildRoot = grokBuildRoot;
+exports.grokBuildPath = grokBuildPath;
+exports.grokBuildSuitePresent = grokBuildSuitePresent;
+exports.assertGrokBuildSuite = assertGrokBuildSuite;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** Absolute path to the vendored grok-build first-party tree. */
+function grokBuildRoot() {
+    return path_1.default.resolve(__dirname, '..', '..', 'vendor', 'grok-build');
+}
+exports.GROK_BUILD_SURFACE = {
+    agent: 'crates/codegen/xai-grok-agent',
+    tools: 'crates/codegen/xai-grok-tools',
+    pager: 'crates/codegen/xai-grok-pager',
+    hooks: 'crates/codegen/xai-grok-hooks',
+    mcp: 'crates/codegen/xai-grok-mcp',
+    plugins: 'crates/codegen/xai-grok-plugin-marketplace',
+    subagents: 'crates/codegen/xai-grok-subagent-resolution',
+    skills: 'crates/codegen/xai-grok-tools/src/implementations/skills',
+};
+function grokBuildPath(surface) {
+    const root = grokBuildRoot();
+    if (surface === 'license')
+        return path_1.default.join(root, 'LICENSE');
+    if (surface === 'notice')
+        return path_1.default.join(root, 'NOTICE');
+    if (surface === 'thirdParty')
+        return path_1.default.join(root, 'THIRD-PARTY-NOTICES');
+    return path_1.default.join(root, exports.GROK_BUILD_SURFACE[surface]);
+}
+function grokBuildSuitePresent() {
+    const keys = [
+        'agent',
+        'tools',
+        'pager',
+        'hooks',
+        'mcp',
+        'plugins',
+        'subagents',
+        'skills',
+        'license',
+        'notice',
+    ];
+    return keys.map((surface) => {
+        const file = grokBuildPath(surface);
+        return { surface, path: file, ok: fs_1.default.existsSync(file) };
+    });
+}
+function assertGrokBuildSuite() {
+    const missing = grokBuildSuitePresent().filter((row) => !row.ok);
+    if (missing.length) {
+        throw new Error(`grok-build suite missing: ${missing.map((row) => row.surface).join(', ')}`);
+    }
+}
+exports.PRODUCT_NAME = 'SiSu';
+exports.PRODUCT_BIN = 'sisu';
+exports.COMPLETE_PATH = '/api/runtime/complete';
+exports.OPENAI_COMPAT_PATH = '/api/runtime/v1/chat/completions';

package/dist/runtime/tools.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_TOOL_NAMES = void 0;
+exports.localToolDefinitions = localToolDefinitions;
+exports.resolveWorkspaceRoot = resolveWorkspaceRoot;
+exports.resolveInWorkspace = resolveInWorkspace;
+exports.dispatchLocalTool = dispatchLocalTool;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const MAX_READ_BYTES = 256 * 1024;
+const MAX_RESULT = 40_000;
+exports.LOCAL_TOOL_NAMES = ['read_file', 'search_replace', 'grep', 'bash'];
+function localToolDefinitions() {
+    return [
+        {
+            type: 'function',
+            function: {
+                name: 'read_file',
+                description: 'Read a file from the local workspace. Path may be relative or absolute.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        target_file: { type: 'string' },
+                        path: { type: 'string' },
+                        offset: { type: 'integer' },
+                        limit: { type: 'integer' },
+                    },
+                },
+            },
+        },
+        {
+            type: 'function',
+            function: {
+                name: 'search_replace',
+                description: 'Edit a file. Empty old_string creates or overwrites. replace_all replaces every match.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        file_path: { type: 'string' },
+                        old_string: { type: 'string' },
+                        new_string: { type: 'string' },
+                        replace_all: { type: 'boolean' },
+                    },
+                    required: ['file_path', 'old_string', 'new_string'],
+                },
+            },
+        },
+        {
+            type: 'function',
+            function: {
+                name: 'grep',
+                description: 'Search file contents in the workspace (ripgrep if present).',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        pattern: { type: 'string' },
+                        path: { type: 'string' },
+                        glob: { type: 'string' },
+                    },
+                    required: ['pattern'],
+                },
+            },
+        },
+        {
+            type: 'function',
+            function: {
+                name: 'bash',
+                description: 'Run a shell command against the workspace cwd.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string' },
+                        cmd: { type: 'string' },
+                    },
+                    required: ['command'],
+                },
+            },
+        },
+    ];
+}
+function resolveWorkspaceRoot(cwd) {
+    const root = path_1.default.resolve(cwd || process.cwd());
+    if (!fs_1.default.existsSync(root) || !fs_1.default.statSync(root).isDirectory()) {
+        throw new Error(`workspace is not a directory: ${root}`);
+    }
+    return root;
+}
+function resolveInWorkspace(root, requested) {
+    const trimmed = (requested || '').trim() || '.';
+    const absolute = path_1.default.isAbsolute(trimmed) ? path_1.default.resolve(trimmed) : path_1.default.resolve(root, trimmed);
+    const rel = path_1.default.relative(root, absolute);
+    if (rel.startsWith('..') || path_1.default.isAbsolute(rel)) {
+        throw new Error(`path escapes workspace: ${requested}`);
+    }
+    return absolute;
+}
+function clip(text) {
+    if (text.length <= MAX_RESULT)
+        return text;
+    return `${text.slice(0, MAX_RESULT)}\n…truncated`;
+}
+function str(input, ...keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === 'string' && value)
+            return value;
+    }
+    return '';
+}
+function readFileTool(root, input) {
+    const target = str(input, 'target_file', 'path', 'file_path');
+    if (!target)
+        throw new Error('read_file requires target_file or path');
+    const file = resolveInWorkspace(root, target);
+    const raw = fs_1.default.readFileSync(file);
+    const start = Math.max(0, Number(input.offset) || 0);
+    const limit = Number(input.limit);
+    const text = raw.subarray(0, MAX_READ_BYTES).toString('utf8');
+    const lines = text.split('\n');
+    const slice = Number.isFinite(limit) && limit > 0 ? lines.slice(start, start + limit) : lines.slice(start);
+    return slice.join('\n');
+}
+function searchReplaceTool(root, input) {
+    const filePath = str(input, 'file_path', 'path', 'target_file');
+    if (!filePath)
+        throw new Error('search_replace requires file_path');
+    const oldString = typeof input.old_string === 'string' ? input.old_string : '';
+    const newString = typeof input.new_string === 'string' ? input.new_string : String(input.contents ?? input.content ?? '');
+    const file = resolveInWorkspace(root, filePath);
+    if (!oldString) {
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        fs_1.default.writeFileSync(file, newString, 'utf8');
+        return `The file ${filePath} has been created.`;
+    }
+    if (!fs_1.default.existsSync(file))
+        throw new Error(`file not found: ${filePath}`);
+    const before = fs_1.default.readFileSync(file, 'utf8');
+    if (!before.includes(oldString))
+        throw new Error(`old_string not found in ${filePath}`);
+    const replaceAll = Boolean(input.replace_all);
+    const after = replaceAll ? before.split(oldString).join(newString) : before.replace(oldString, newString);
+    fs_1.default.writeFileSync(file, after, 'utf8');
+    return `The file ${filePath} has been updated.`;
+}
+function walkFiles(dir, glob, acc) {
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name === '.git' || entry.name === 'node_modules')
+            continue;
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory())
+            walkFiles(full, glob, acc);
+        else if (!glob || matchGlob(entry.name, glob))
+            acc.push(full);
+    }
+}
+function matchGlob(name, glob) {
+    const escaped = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`).test(name);
+}
+function grepTool(root, input) {
+    const pattern = str(input, 'pattern');
+    if (!pattern)
+        throw new Error('grep requires pattern');
+    const searchRoot = resolveInWorkspace(root, str(input, 'path') || '.');
+    const glob = str(input, 'glob') || undefined;
+    const rg = (0, child_process_1.spawnSync)('rg', ['--line-number', '--no-heading', '--color', 'never', pattern, searchRoot], {
+        encoding: 'utf8',
+        timeout: 15_000,
+        maxBuffer: MAX_RESULT,
+    });
+    if (rg.error || rg.status === 127) {
+        const files = [];
+        if (fs_1.default.existsSync(searchRoot) && fs_1.default.statSync(searchRoot).isFile())
+            files.push(searchRoot);
+        else
+            walkFiles(searchRoot, glob, files);
+        const re = new RegExp(pattern);
+        const hits = [];
+        for (const file of files) {
+            let text = '';
+            try {
+                text = fs_1.default.readFileSync(file, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split('\n');
+            lines.forEach((line, index) => {
+                if (re.test(line))
+                    hits.push(`${file}:${index + 1}:${line}`);
+            });
+        }
+        return hits.length ? hits.join('\n') : 'no matches';
+    }
+    if (rg.status === 1)
+        return 'no matches';
+    if (rg.status !== 0)
+        throw new Error(rg.stderr || `rg failed (${rg.status})`);
+    return (rg.stdout || '').trim() || 'no matches';
+}
+function bashTool(root, input) {
+    const command = str(input, 'command', 'cmd');
+    if (!command)
+        throw new Error('bash requires command');
+    const result = (0, child_process_1.spawnSync)(command, {
+        cwd: root,
+        encoding: 'utf8',
+        shell: true,
+        timeout: 30_000,
+        maxBuffer: MAX_RESULT,
+        env: { ...process.env, SISU_WORKSPACE: root },
+    });
+    const out = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    if (result.error)
+        throw new Error(result.error.message);
+    if (result.status !== 0) {
+        return clip(out || `exit ${result.status}`);
+    }
+    return clip(out || '(ok)');
+}
+function dispatchLocalTool(root, call) {
+    try {
+        const name = call.name;
+        let content = '';
+        if (name === 'read_file')
+            content = readFileTool(root, call.arguments);
+        else if (name === 'search_replace')
+            content = searchReplaceTool(root, call.arguments);
+        else if (name === 'grep')
+            content = grepTool(root, call.arguments);
+        else if (name === 'bash' || name === 'run_terminal_cmd')
+            content = bashTool(root, call.arguments);
+        else
+            throw new Error(`unknown tool: ${name}`);
+        return { id: call.id, name, content: clip(content), ok: true };
+    }
+    catch (error) {
+        return {
+            id: call.id,
+            name: call.name,
+            content: error instanceof Error ? error.message : String(error),
+            ok: false,
+        };
+    }
+}

package/dist/runtime/transport.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalRuntimeTransport = createLocalRuntimeTransport;
+exports.execLocalTurn = execLocalTurn;
+const store_1 = require("../store");
+const adapter_1 = require("./adapter");
+const loop_1 = require("./loop");
+const models_1 = require("./models");
+const sessions_1 = require("./sessions");
+const tools_1 = require("./tools");
+function createLocalRuntimeTransport(http, options = {}) {
+    return {
+        async *send(prompt, sendOptions = {}) {
+            const cwd = (0, tools_1.resolveWorkspaceRoot)(options.cwd);
+            let conversationId = sendOptions.conversationId || (!sendOptions.newConversation ? (0, store_1.readSession)().last_conversation_id : '') || '';
+            let existing = conversationId ? (0, sessions_1.loadLocalSession)(conversationId) : null;
+            if (!existing || sendOptions.newConversation) {
+                existing = (0, sessions_1.createLocalSession)(prompt.trim().slice(0, 50), cwd, (0, store_1.readSession)().last_model);
+                conversationId = existing.id;
+            }
+            (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_conversation_id: conversationId });
+            const client = options.modelClient || cloudClient(http, options.client || 'tui');
+            const model = options.modelClient
+                ? existing.model || (0, store_1.readSession)().last_model || 'stub'
+                : await (0, models_1.resolveRuntimeModel)(http, { explicit: existing.model || (0, store_1.readSession)().last_model });
+            const gen = (0, loop_1.runLocalTurn)({
+                prompt,
+                cwd,
+                model,
+                client,
+                messages: existing.messages,
+                conversationId,
+            });
+            let step = await gen.next();
+            while (!step.done) {
+                const event = step.value;
+                yield event;
+                step = await gen.next();
+            }
+            const result = step.value;
+            existing.messages.push({ role: 'user', content: prompt });
+            if (result.text)
+                existing.messages.push({ role: 'assistant', content: result.text });
+            (0, sessions_1.saveLocalSession)(existing);
+            return { conversationId: result.conversationId };
+        },
+        async listConversations() {
+            return (0, sessions_1.listLocalSessions)().map((row) => ({ id: row.id, title: row.title, client: 'tui' }));
+        },
+        async getConversation(id) {
+            const row = (0, sessions_1.loadLocalSession)(id);
+            if (!row)
+                throw new Error('conversation not found');
+            const messages = row.messages.map((message, index) => ({
+                id: `${row.id}-${index}`,
+                role: message.role === 'tool' ? 'assistant' : message.role,
+                content: message.content,
+                ...(message.role === 'tool' ? { message_type: 'tool_result' } : {}),
+            }));
+            return { id: row.id, title: row.title, messages };
+        },
+    };
+}
+async function execLocalTurn(prompt, options = {}) {
+    const cwd = (0, tools_1.resolveWorkspaceRoot)(options.cwd);
+    let conversationId = options.conversationId || (!options.newConversation ? (0, store_1.readSession)().last_conversation_id : '') || '';
+    let existing = conversationId ? (0, sessions_1.loadLocalSession)(conversationId) : null;
+    if (!existing) {
+        existing = (0, sessions_1.createLocalSession)(prompt.trim().slice(0, 50), cwd, options.model);
+        conversationId = existing.id;
+    }
+    const client = options.modelClient || (options.http ? cloudClient(options.http, options.client || 'cli') : undefined);
+    if (!client)
+        throw new Error('model client required');
+    const result = await (0, loop_1.collectLocalTurn)({
+        prompt,
+        cwd,
+        model: options.model || existing.model || (0, store_1.readSession)().last_model || 'stub',
+        client,
+        messages: existing.messages,
+        conversationId,
+    });
+    existing.messages.push({ role: 'user', content: prompt });
+    if (result.text)
+        existing.messages.push({ role: 'assistant', content: result.text });
+    (0, sessions_1.saveLocalSession)(existing);
+    (0, store_1.writeSession)({ ...(0, store_1.readSession)(), last_conversation_id: result.conversationId, last_model: options.model || (0, store_1.readSession)().last_model });
+    return { conversationId: result.conversationId, text: result.text, toolResults: result.toolResults };
+}
+function cloudClient(http, client) {
+    const auth = (0, store_1.requireAuth)();
+    return (0, adapter_1.createSisuCloudModel)(http, { apiBase: auth.api_base, token: auth.token, client });
+}

package/dist/runtime/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/store.js

@@ -140,5 +140,6 @@ function describeStatus() {
         plan_code: auth?.plan_code || '',
         api_base: auth?.api_base || process.env.SISU_API_BASE || exports.DEFAULT_API_BASE,
         workspaces: readWorkspaces(),
+        model: readSession().last_model || '',
     };
 }

package/dist/transport.js

@@ -64,6 +64,7 @@ function createFastApiTransport(http) {
                     headers: (0, http_1.authHeaders)(auth.token),
                     body: JSON.stringify({
                         title: text.slice(0, 50),
+                        model: session.last_model || undefined,
                         project_id: session.last_project_id || undefined,
                         client: stamp.client,
                         client_version: stamp.client_version,
@@ -87,6 +88,7 @@ function createFastApiTransport(http) {
                 body: JSON.stringify({
                     conversation_id: conversationId,
                     message: text,
+                    model: session.last_model || undefined,
                     task_category: 'coding',
                     client: stamp.client,
                     client_version: stamp.client_version,

package/dist/tui.js

@@ -17,7 +17,9 @@ 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");
+const launch_1 = require("./runtime/launch");
+const transport_1 = require("./runtime/transport");
+const child_process_1 = require("child_process");
 function shouldAnimateSplash(env = process.env, tty = Boolean(process.stdout.isTTY)) {
     if (env.SISU_TUI_STATIC === '1')
         return false;
@@ -171,9 +173,14 @@ async function promptLogin(io, login) {
 function tuiHelp() {
     return [
         '/login      sign in with the browser',
+        '/logout     sign out',
+        '/model      switch model (alias /m)',
+        '/models     list available models',
+        '/copy       copy last reply to ~/.sisu/last-copy.txt',
+        '/export     write the thread to a markdown file',
         '/status     account and quota',
         '/ls         local workspace files',
-        '/history    saved cloud conversations',
+        '/history    saved local sessions',
         '/open <id>  continue a saved conversation',
         '/new        start a new conversation',
         '/training on|off   allow or refuse training use of new turns',
@@ -217,13 +224,28 @@ async function runTui(io, deps = {}) {
                 },
             }, http);
         };
+        if (usePager && !deps.pager) {
+            const grokBin = (0, launch_1.findGrokBuildBinary)();
+            if (grokBin && process.stdout.isTTY) {
+                (0, launch_1.writeSisuGrokConfig)();
+                io.close?.();
+                const child = (0, child_process_1.spawn)(grokBin, [], { stdio: 'inherit', env: (0, launch_1.sisuGrokBuildEnv)(), cwd: process.cwd() });
+                return await new Promise((resolve) => {
+                    child.on('exit', (code) => resolve(code ?? 1));
+                    child.on('error', () => resolve(1));
+                });
+            }
+        }
         if (usePager) {
             io.close?.();
-            const transport = (0, transport_1.createFastApiTransport)(http);
+            const transport = (0, transport_1.createLocalRuntimeTransport)(http, { client: 'tui' });
             return await (deps.pager ?? app_1.runPager)((0, stdio_1.stdioPagerIo)(), transport, {
                 columns,
                 email: account?.email,
                 login: startWebLogin,
+                logout: commands_1.logoutCommand,
+                models: () => (0, commands_1.listModelsCommand)(http),
+                setModel: (name) => (0, commands_1.setModelCommand)(name, http),
                 intro: animate,
                 sleep: deps.sleep,
                 quota: async () => (0, commands_1.formatQuota)(await (0, commands_1.fetchBalance)(http)),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stevezhou/sisu",
-  "version": "0.1.10",
-  "description": "SiSu CLI — one login, cloud quota, local workspace",
+  "version": "0.2.0",
+  "description": "SiSu CLI — local grok-build runtime, SiSu cloud models",
   "license": "UNLICENSED",
   "homepage": "https://www.sisu.chat",
   "bugs": {
@@ -22,7 +22,8 @@
   "main": "dist/main.js",
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "NOTICE"
   ],
   "publishConfig": {
     "access": "public"