@wangzhizhi/remi 0.0.1-alpha

package/dist/tui/commands.js

@@ -0,0 +1,427 @@
+import { loadRemiConfig, readProjectRemiConfig, writeProjectRemiConfig } from '@remi/config';
+import { defaultResponseStyleId, responseStylePresets } from '@remi/core';
+import { createModelRouter } from '@remi/llm';
+import { buildSkillInvocationPrompt, loadSkillContent, loadSkillIndex } from '@remi/skills';
+import { buildInitPrompt } from '../initPrompt.js';
+import { languageLabel, parseLanguageArg, supportedLanguages, t } from '../i18n.js';
+import { runModelCommand } from '../model.js';
+import { formatPermissionProfileChanged, parsePermissionProfileArg, permissionProfileOptions, resolveConfiguredPermissionProfile, } from '../permissions.js';
+import { formatResponseStyleChanged, parseResponseStyleArg, styleDescription } from '../style.js';
+import { formatSyntaxThemeChanged, parseSyntaxThemeArg, syntaxThemeOptions } from '../syntaxTheme.js';
+import { defaultStatusLineItems, getStatusLineCatalog } from '../statusline.js';
+const textMessage = (text, level = 'info') => ({
+    kind: 'message',
+    message: {
+        kind: 'system',
+        level,
+        text,
+    },
+});
+const slashCommandDefinitions = [
+    {
+        name: '/init',
+        aliases: ['init'],
+        descriptionKey: 'slash.init.description',
+        execute: () => ({ kind: 'prompt', prompt: buildInitPrompt() }),
+    },
+    {
+        name: '/model',
+        aliases: ['model'],
+        descriptionKey: 'slash.model.description',
+        execute: (context, args) => {
+            if (args.length > 0) {
+                return textMessage(runModelCommand(args, context.cwd).output);
+            }
+            return {
+                kind: 'message',
+                message: createModelPanelMessage(context.cwd, context.mainModelAlias, context.language),
+            };
+        },
+    },
+    {
+        name: '/permissions',
+        aliases: ['permissions'],
+        descriptionKey: 'slash.permissions.description',
+        execute: (context, args) => {
+            const [profileArg] = args;
+            if (!profileArg) {
+                return {
+                    kind: 'message',
+                    message: createPermissionProfilePanelMessage(context.cwd, context.permissionProfile, context.language),
+                };
+            }
+            const profile = parsePermissionProfileArg(profileArg);
+            if (!profile) {
+                return textMessage(t(context.language, 'permissions.unknown', { profile: profileArg }), 'warn');
+            }
+            return {
+                kind: 'permission-profile',
+                profile,
+                message: {
+                    kind: 'system',
+                    level: 'info',
+                    text: formatPermissionProfileChanged(profile, context.language),
+                },
+            };
+        },
+    },
+    {
+        name: '/style',
+        aliases: ['style'],
+        descriptionKey: 'slash.style.description',
+        execute: (context, args) => {
+            const [styleArg] = args;
+            if (!styleArg || styleArg === 'list') {
+                return {
+                    kind: 'message',
+                    message: createStylePanelMessage(context.responseStyle, context.language),
+                };
+            }
+            const styleId = parseResponseStyleArg(styleArg);
+            if (!styleId) {
+                return textMessage(t(context.language, 'style.unknown', { style: styleArg }), 'warn');
+            }
+            return {
+                kind: 'style',
+                styleId,
+                message: {
+                    kind: 'system',
+                    level: 'info',
+                    text: formatResponseStyleChanged(styleId, false, context.language),
+                },
+            };
+        },
+    },
+    {
+        name: '/theme',
+        aliases: ['theme', 'syntax-theme'],
+        descriptionKey: 'slash.theme.description',
+        execute: (context, args) => {
+            const [themeArg] = args;
+            if (!themeArg || themeArg === 'list') {
+                return {
+                    kind: 'message',
+                    message: createSyntaxThemePanelMessage(context.syntaxTheme, context.language),
+                };
+            }
+            const themeId = parseSyntaxThemeArg(themeArg);
+            if (!themeId) {
+                return textMessage(t(context.language, 'theme.unknown', { theme: themeArg }), 'warn');
+            }
+            return {
+                kind: 'syntax-theme',
+                themeId,
+                message: {
+                    kind: 'system',
+                    level: 'info',
+                    text: formatSyntaxThemeChanged(themeId, false, context.language),
+                },
+            };
+        },
+    },
+    {
+        name: '/statusline',
+        aliases: ['statusline'],
+        descriptionKey: 'slash.statusline.description',
+        execute: context => ({
+            kind: 'message',
+            message: createStatusLinePanelMessage(context.statusLineItems, context.language),
+        }),
+    },
+    {
+        name: '/skills',
+        aliases: ['skills'],
+        descriptionKey: 'slash.skills.description',
+        execute: (context, args) => {
+            const [action, skillName, ...skillArgs] = args;
+            if (!action) {
+                return {
+                    kind: 'message',
+                    message: createSkillsActionPanelMessage(context.cwd, context.language),
+                };
+            }
+            if (action === 'list') {
+                return {
+                    kind: 'message',
+                    message: createSkillsListPanelMessage(context.cwd, context.language, 'list'),
+                };
+            }
+            if ((action === 'enable' || action === 'disable') && skillName) {
+                const nextDisabled = updateProjectDisabledSkills(context.cwd, skillName, action === 'disable');
+                const index = loadSkillIndex({ cwd: context.cwd, disabled: nextDisabled });
+                return textMessage(t(context.language, 'skills.saved', {
+                    enabled: index.skills.filter(skill => skill.enabled).length,
+                    disabled: index.skills.filter(skill => !skill.enabled).length,
+                }));
+            }
+            const disabled = loadRemiConfig({ cwd: context.cwd }).config.skills?.disabled;
+            const skill = loadSkillContent(disabled ? { cwd: context.cwd, disabled, name: action } : { cwd: context.cwd, name: action });
+            if (!skill) {
+                return textMessage(t(context.language, 'skills.unknown', { name: action }), 'warn');
+            }
+            return { kind: 'prompt', prompt: buildSkillInvocationPrompt(skill, [skillName, ...skillArgs].filter((arg) => Boolean(arg))) };
+        },
+    },
+    {
+        name: '/language',
+        aliases: ['language'],
+        descriptionKey: 'slash.language.description',
+        execute: (context, args) => {
+            const [languageArg] = args;
+            if (!languageArg) {
+                return {
+                    kind: 'message',
+                    message: createLanguagePanelMessage(context.language),
+                };
+            }
+            const language = parseLanguageArg(languageArg);
+            if (!language) {
+                return textMessage(t(context.language, 'language.unknown', { language: languageArg }), 'warn');
+            }
+            return {
+                kind: 'language',
+                language,
+                message: {
+                    kind: 'system',
+                    level: 'info',
+                    text: t(language, 'language.saved', { label: languageLabel(language) }),
+                },
+            };
+        },
+    },
+    {
+        name: '/compact',
+        aliases: ['compact'],
+        descriptionKey: 'slash.compact.description',
+        execute: context => {
+            if (!context.sessionId) {
+                return textMessage(t(context.language, 'compact.noActive'), 'warn');
+            }
+            return { kind: 'compact' };
+        },
+    },
+    {
+        name: '/new',
+        aliases: ['new'],
+        descriptionKey: 'slash.new.description',
+        execute: () => ({ kind: 'new-session' }),
+    },
+    {
+        name: '/exit',
+        aliases: ['/quit', 'exit', 'quit'],
+        descriptionKey: 'slash.exit.description',
+        execute: () => ({ kind: 'exit' }),
+    },
+];
+export const slashCommands = createSlashCommands();
+function createSlashCommands(language) {
+    return slashCommandDefinitions.map(command => ({
+        name: command.name,
+        aliases: command.aliases,
+        execute: command.execute,
+        description: t(language, command.descriptionKey),
+    }));
+}
+function createStatusLinePanelMessage(activeItems = defaultStatusLineItems, language) {
+    const enabled = new Set(activeItems);
+    const items = getStatusLineCatalog(language).map(item => ({
+        id: item.id,
+        label: item.label,
+        description: item.description,
+        enabled: enabled.has(item.id),
+    }));
+    return {
+        kind: 'statusline-panel',
+        title: t(language, 'statusline.panel.title'),
+        subtitle: t(language, 'statusline.panel.subtitle'),
+        searchLabel: t(language, 'statusline.panel.search'),
+        helpText: t(language, 'statusline.panel.help'),
+        query: '',
+        selectedIndex: 0,
+        items,
+    };
+}
+function createModelPanelMessage(cwd, mainModelAlias, language) {
+    try {
+        const loaded = loadRemiConfig({ cwd });
+        const router = createModelRouter(loaded.config);
+        const active = router.resolve('main');
+        const models = router.models.list().map(model => ({
+            alias: model.alias,
+            displayName: model.displayName ?? model.alias,
+        }));
+        const activeAlias = mainModelAlias ?? active.alias;
+        const activeModel = models.find(model => model.alias === activeAlias);
+        const activeDisplayName = activeModel?.displayName ?? active.displayName ?? active.alias;
+        const selectedIndex = Math.max(0, models.findIndex(model => model.alias === activeAlias));
+        return {
+            kind: 'model-panel',
+            title: t(language, 'model.panel.title'),
+            subtitle: t(language, 'model.panel.subtitle', {
+                profile: active.profile,
+                model: activeDisplayName,
+                effort: active.effort ?? 'unset',
+            }),
+            activeAlias,
+            currentLabel: t(language, 'model.current'),
+            selectedIndex,
+            models,
+        };
+    }
+    catch (error) {
+        return {
+            kind: 'system',
+            level: 'error',
+            text: error instanceof Error ? error.message : t(language, 'model.error.load'),
+        };
+    }
+}
+function createStylePanelMessage(activeStyle = defaultResponseStyleId, language) {
+    const styles = responseStylePresets.map(style => ({
+        id: style.id,
+        label: style.label,
+        description: styleDescription(style.id, language),
+    }));
+    const selectedIndex = Math.max(0, styles.findIndex(style => style.id === activeStyle));
+    return {
+        kind: 'style-panel',
+        title: t(language, 'style.panel.title'),
+        subtitle: t(language, 'style.panel.subtitle'),
+        activeId: activeStyle,
+        currentLabel: t(language, 'style.current'),
+        selectedIndex,
+        styles,
+    };
+}
+function createSyntaxThemePanelMessage(activeTheme = 'default', language) {
+    const themes = syntaxThemeOptions();
+    const selectedIndex = Math.max(0, themes.findIndex(theme => theme.id === activeTheme));
+    return {
+        kind: 'syntax-theme-panel',
+        title: t(language, 'theme.panel.title'),
+        subtitle: t(language, 'theme.panel.subtitle'),
+        searchLabel: t(language, 'theme.panel.search'),
+        helpText: t(language, 'theme.panel.help'),
+        query: '',
+        activeId: activeTheme,
+        currentLabel: t(language, 'theme.current'),
+        selectedIndex,
+        themes,
+    };
+}
+function createLanguagePanelMessage(activeLanguage = 'en') {
+    const selectedIndex = Math.max(0, supportedLanguages.findIndex(language => language.code === activeLanguage));
+    return {
+        kind: 'language-panel',
+        title: t(activeLanguage, 'language.panel.title'),
+        subtitle: t(activeLanguage, 'language.panel.subtitle'),
+        activeCode: activeLanguage,
+        currentLabel: t(activeLanguage, 'language.current'),
+        selectedIndex,
+        languages: supportedLanguages,
+    };
+}
+function createPermissionProfilePanelMessage(cwd, activeProfile, language) {
+    const profile = activeProfile ?? resolveConfiguredPermissionProfile(cwd);
+    const profiles = permissionProfileOptions(language);
+    const selectedIndex = Math.max(0, profiles.findIndex(option => option.id === profile));
+    return {
+        kind: 'permission-profile-panel',
+        title: t(language, 'permissions.panel.title'),
+        subtitle: t(language, 'permissions.panel.subtitle'),
+        activeProfile: profile,
+        currentLabel: t(language, 'permissions.current'),
+        selectedIndex,
+        profiles,
+    };
+}
+export function createSkillsActionPanelMessage(cwd, language) {
+    const index = loadSkillIndexForCwd(cwd);
+    const subtitle = index.skills.length > 0 ? t(language, 'skills.panel.subtitle') : t(language, 'skills.none');
+    return {
+        kind: 'skills-panel',
+        title: t(language, 'skills.panel.title'),
+        subtitle,
+        helpText: t(language, 'skills.panel.help'),
+        mode: 'actions',
+        selectedIndex: 0,
+        actions: [
+            {
+                id: 'list',
+                label: t(language, 'skills.panel.list'),
+                description: t(language, 'skills.panel.listDescription'),
+            },
+            {
+                id: 'toggle',
+                label: t(language, 'skills.panel.toggle'),
+                description: t(language, 'skills.panel.toggleDescription'),
+            },
+        ],
+    };
+}
+export function createSkillsListPanelMessage(cwd, language, mode = 'list') {
+    const index = loadSkillIndexForCwd(cwd);
+    const skills = index.skills.map(skill => ({
+        name: skill.name,
+        displayName: skill.displayName,
+        description: skill.description,
+        source: skill.source,
+        enabled: skill.enabled,
+        filePath: skill.filePath,
+    }));
+    return {
+        kind: 'skills-panel',
+        title: t(language, 'skills.panel.title'),
+        subtitle: mode === 'toggle'
+            ? t(language, 'skills.panel.toggleSubtitle')
+            : skills.length > 0
+                ? t(language, 'skills.panel.listSubtitle', { count: skills.length })
+                : t(language, 'skills.none'),
+        helpText: t(language, 'skills.panel.help'),
+        mode,
+        selectedIndex: 0,
+        skills,
+    };
+}
+function loadSkillIndexForCwd(cwd) {
+    const disabled = loadRemiConfig({ cwd }).config.skills?.disabled;
+    return loadSkillIndex(disabled ? { cwd, disabled } : { cwd });
+}
+export function saveProjectDisabledSkills(cwd, disabled) {
+    const config = readProjectRemiConfig(cwd);
+    const uniqueDisabled = Array.from(new Set(disabled.map(skill => skill.trim().toLowerCase()).filter(Boolean))).sort();
+    writeProjectRemiConfig({
+        ...config,
+        skills: {
+            ...config.skills,
+            disabled: uniqueDisabled,
+        },
+    }, cwd);
+}
+function updateProjectDisabledSkills(cwd, skillName, disabled) {
+    const config = readProjectRemiConfig(cwd);
+    const current = new Set((config.skills?.disabled ?? []).map(skill => skill.trim().toLowerCase()).filter(Boolean));
+    const normalized = skillName.trim().toLowerCase();
+    if (disabled) {
+        current.add(normalized);
+    }
+    else {
+        current.delete(normalized);
+    }
+    const next = Array.from(current).sort();
+    saveProjectDisabledSkills(cwd, next);
+    return next;
+}
+export function listSlashCommands(language) {
+    return createSlashCommands(language);
+}
+export function executeSlashCommand(input, context) {
+    const [commandName = '', ...args] = input.trim().split(/\s+/);
+    const command = slashCommands.find(candidate => {
+        return candidate.name === commandName || candidate.aliases.includes(commandName);
+    });
+    if (!command) {
+        return textMessage(t(context.language, 'command.unknown', { command: commandName }), 'warn');
+    }
+    return command.execute(context, args);
+}

package/dist/tui/index.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { stdin, stdout, stderr } from 'node:process';
+import { render } from 'ink';
+import { resolveActiveSessionId } from '@remi/sessions';
+import { RemiApp } from './RemiApp.js';
+import { formatResumeInstruction } from '../resume.js';
+import { resolveConfiguredLanguage } from '../i18n.js';
+import { addTokenUsage, createEmptyTokenUsage, formatTokenUsage } from '../usage.js';
+export async function startTui(options = {}) {
+    const output = options.output ?? stdout;
+    const cwd = options.cwd ?? process.cwd();
+    let usageTotals = createEmptyTokenUsage();
+    let activeSessionId = options.sessionId ?? resolveActiveSessionId(cwd);
+    const remiAppProps = {
+        cwd,
+        initialSessionId: activeSessionId,
+        onSessionId: (sessionId) => {
+            activeSessionId = sessionId;
+        },
+        onTokenUsage: (usage) => {
+            usageTotals = addTokenUsage(usageTotals, usage);
+        },
+    };
+    const instance = render(_jsx(RemiApp, { ...remiAppProps }), {
+        stdin: options.input ?? stdin,
+        stdout: output,
+        stderr: options.error ?? stderr,
+        exitOnCtrlC: false,
+        interactive: options.interactive ?? true,
+        incrementalRendering: true,
+    });
+    await instance.waitUntilExit();
+    output.write(formatTuiExitFooter(usageTotals, activeSessionId, cwd));
+}
+export function formatTuiExitFooter(usageTotals, sessionId, cwd = process.cwd()) {
+    const language = resolveConfiguredLanguage(cwd);
+    const lines = ['', formatTokenUsage(usageTotals, language)];
+    if (sessionId) {
+        lines.push(formatResumeInstruction(sessionId));
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/tui/renderers/Header.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { userInfo } from 'node:os';
+import { Box, Text } from 'ink';
+import { compactPath } from './StatusLine.js';
+import { remiDarkTheme } from '../theme.js';
+export function Header({ status, width = 100 }) {
+    const username = currentUsername();
+    const cwdWidth = Math.max(24, Math.min(48, width - 22));
+    const directory = compactPath(status.cwd, cwdWidth);
+    const contentWidth = Math.max(42, Math.min(64, Math.max(displayLength('=^ω^= Remi CLI'), displayLength(`Welcome back, ${username}`), displayLength(`model:     ${status.model}`), displayLength(`directory: ${directory}`)) + 4));
+    const cardWidth = Math.min(Math.max(46, width - 2), contentWidth + 4);
+    return (_jsxs(Box, { borderColor: remiDarkTheme.border, borderStyle: "single", flexDirection: "column", flexShrink: 0, paddingX: 1, width: cardWidth, children: [_jsxs(Text, { children: [_jsx(Text, { color: remiDarkTheme.accent, children: "=^\u03C9^=" }), _jsx(Text, { color: remiDarkTheme.text, bold: true, children: ' Remi CLI' })] }), _jsxs(Text, { children: [_jsx(Text, { color: remiDarkTheme.text, children: "Welcome back, " }), _jsx(Text, { color: remiDarkTheme.accent, children: username })] }), _jsx(Box, { height: 1 }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: remiDarkTheme.muted, children: "model:     " }), _jsx(Text, { color: remiDarkTheme.text, children: status.model })] }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: remiDarkTheme.muted, children: "directory: " }), _jsx(Text, { color: remiDarkTheme.text, children: directory })] })] }));
+}
+function displayLength(value) {
+    let length = 0;
+    for (const char of value) {
+        length += char.charCodeAt(0) > 0xff ? 2 : 1;
+    }
+    return length;
+}
+function currentUsername() {
+    try {
+        return userInfo().username || 'developer';
+    }
+    catch {
+        return 'developer';
+    }
+}