@wangzhizhi/remi 0.0.1-alpha

package/dist/repl.js

@@ -0,0 +1,346 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { runChatTurn } from '@remi/core';
+import { createNewSession, readSessionPermissionRules, resolveActiveSessionId, writeSessionPermissionRules } from '@remi/sessions';
+import { buildInitPrompt } from './initPrompt.js';
+import { languageLabel, parseLanguageArg, resolveConfiguredLanguage, saveProjectLanguage, t } from './i18n.js';
+import { runModelCommand } from './model.js';
+import { addSessionPermissionRules, formatPermissionProfileChanged, formatPermissionProfileList, formatPermissionRulesScope, parsePermissionProfileArg, resolveConfiguredPermissionProfile, saveProjectPermissionRule, saveProjectPermissionProfile, } from './permissions.js';
+import { formatPermissionFileAction } from './permissionDisplay.js';
+import { formatResumeInstruction } from './resume.js';
+import { formatResponseStyleChanged, formatResponseStyleList, parseResponseStyleArg, resolveConfiguredResponseStyle, saveProjectResponseStyle, } from './style.js';
+import { formatSyntaxThemeChanged, formatSyntaxThemeList, parseSyntaxThemeArg, resolveConfiguredSyntaxTheme, saveProjectSyntaxTheme, } from './syntaxTheme.js';
+import { addTokenUsage, createEmptyTokenUsage, formatTokenUsage } from './usage.js';
+import { version } from './version.js';
+export async function startRepl(options = {}) {
+    const out = options.output ?? output;
+    const cwd = options.cwd ?? process.cwd();
+    let sessionId = options.sessionId ?? resolveActiveSessionId(cwd);
+    const rl = createInterface({
+        input: options.input ?? input,
+        output: out,
+        prompt: '❯ ',
+        historySize: 200,
+    });
+    let isClosed = false;
+    let usageTotals = createEmptyTokenUsage();
+    let responseStyle = resolveConfiguredResponseStyle(cwd);
+    let syntaxTheme = resolveConfiguredSyntaxTheme(cwd);
+    let language = resolveConfiguredLanguage(cwd);
+    let permissionProfile = resolveConfiguredPermissionProfile(cwd);
+    let sessionPermissionRules = readSessionPermissionRules(cwd, sessionId);
+    rl.on('close', () => {
+        isClosed = true;
+    });
+    const write = (text = '') => {
+        out.write(`${text}\n`);
+    };
+    const prompt = () => {
+        if (!isClosed) {
+            rl.prompt();
+        }
+    };
+    write(`Remi ${version}`);
+    write('Commands: /init, /model, /permissions, /style, /theme, /language, /new, /exit');
+    prompt();
+    for await (const rawLine of rl) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+            prompt();
+            continue;
+        }
+        if (line === '/exit' || line === '/quit' || line === 'exit' || line === 'quit') {
+            break;
+        }
+        if (line === '/model' || line.startsWith('/model ')) {
+            const args = line.slice('/model'.length).trim().split(/\s+/).filter(Boolean);
+            write(runModelCommand(args, cwd).output);
+            prompt();
+            continue;
+        }
+        if (line === '/permissions' || line.startsWith('/permissions ')) {
+            const args = line.slice('/permissions'.length).trim().split(/\s+/).filter(Boolean);
+            const profileArg = args[0];
+            if (!profileArg) {
+                write(formatPermissionProfileList(permissionProfile, language));
+                prompt();
+                continue;
+            }
+            const nextProfile = parsePermissionProfileArg(profileArg);
+            if (!nextProfile) {
+                write(t(language, 'permissions.unknown', { profile: profileArg }));
+                prompt();
+                continue;
+            }
+            permissionProfile = nextProfile;
+            saveProjectPermissionProfile(cwd, permissionProfile);
+            write(formatPermissionProfileChanged(permissionProfile, language));
+            prompt();
+            continue;
+        }
+        if (line === '/new') {
+            write(formatTokenUsage(usageTotals, language));
+            sessionId = createNewSession(cwd);
+            sessionPermissionRules = readSessionPermissionRules(cwd, sessionId);
+            write(`${t(language, 'session.new')} ${sessionId}`);
+            prompt();
+            continue;
+        }
+        if (line === '/language' || line.startsWith('/language ')) {
+            const args = line.slice('/language'.length).trim().split(/\s+/).filter(Boolean);
+            const nextLanguage = parseLanguageArg(args[0]);
+            if (!nextLanguage) {
+                write(t(language, 'language.unknown', { language: args[0] ?? '' }));
+                prompt();
+                continue;
+            }
+            language = nextLanguage;
+            saveProjectLanguage(cwd, language);
+            write(t(language, 'language.saved', { label: languageLabel(language) }));
+            prompt();
+            continue;
+        }
+        if (line === '/style' || line.startsWith('/style ')) {
+            const args = line.slice('/style'.length).trim().split(/\s+/).filter(Boolean);
+            const styleArg = args[0];
+            if (!styleArg || styleArg === 'list') {
+                write(formatResponseStyleList(responseStyle, language));
+                prompt();
+                continue;
+            }
+            const styleId = parseResponseStyleArg(styleArg);
+            if (!styleId) {
+                write(t(language, 'style.unknown', { style: styleArg }));
+                prompt();
+                continue;
+            }
+            responseStyle = styleId;
+            saveProjectResponseStyle(cwd, responseStyle);
+            write(formatResponseStyleChanged(responseStyle, true, language));
+            prompt();
+            continue;
+        }
+        if (line === '/theme' || line.startsWith('/theme ')) {
+            const args = line.slice('/theme'.length).trim().split(/\s+/).filter(Boolean);
+            const themeArg = args[0];
+            if (!themeArg || themeArg === 'list') {
+                write(formatSyntaxThemeList(syntaxTheme));
+                prompt();
+                continue;
+            }
+            const themeId = parseSyntaxThemeArg(themeArg);
+            if (!themeId) {
+                write(t(language, 'theme.unknown', { theme: themeArg }));
+                prompt();
+                continue;
+            }
+            syntaxTheme = themeId;
+            saveProjectSyntaxTheme(cwd, syntaxTheme);
+            write(formatSyntaxThemeChanged(syntaxTheme, true, language));
+            prompt();
+            continue;
+        }
+        const chatInput = line === '/init' ? buildInitPrompt() : line;
+        if (line.startsWith('/') && line !== '/init') {
+            write(t(language, 'command.unknown', { command: line }));
+            prompt();
+            continue;
+        }
+        const requestToolPermission = async (request, decision) => {
+            const fileAction = formatPermissionFileAction(request, language);
+            write(t(language, fileAction ? 'permission.request.title.action' : 'permission.request.title'));
+            write(t(language, 'permission.request.reason', { reason: decision.reason }));
+            if (fileAction) {
+                write(fileAction.action);
+                write(fileAction.detail);
+            }
+            else {
+                write(`$ ${request.command?.commandLine ?? `${request.toolName} ${request.inputSummary}`}`);
+            }
+            if (request.command?.capability) {
+                write(formatCommandCapabilityForDisplay(request.command.capability));
+            }
+            const explicitSuggestedRules = request.suggestedRules?.length
+                ? request.suggestedRules
+                : request.command?.suggestedRules?.length
+                    ? request.command.suggestedRules
+                    : request.command?.suggestedRule
+                        ? [request.command.suggestedRule]
+                        : request.command?.suggestedPrefix
+                            ? [{ kind: 'shell-prefix', prefix: request.command.suggestedPrefix }]
+                            : [];
+            const fallbackSuggestedRules = explicitSuggestedRules.length > 0 ? [] : fallbackFilesystemPermissionRules(request);
+            const suggestedRules = explicitSuggestedRules.length > 0 ? explicitSuggestedRules : fallbackSuggestedRules;
+            const ruleLabel = suggestedRules.length > 0 ? formatPermissionRulesScope(suggestedRules, language) : '';
+            const canOfferRule = ((request.canPersist ?? request.command?.canPersist ?? false) || fallbackSuggestedRules.length > 0) && suggestedRules.length > 0;
+            const filesystemRulesOnly = suggestedRules.length > 0 && suggestedRules.every(rule => rule.kind === 'filesystem-write-root');
+            const shellRulesOnly = suggestedRules.length > 0 && suggestedRules.every(rule => rule.kind === 'shell-prefix');
+            const persistHint = canOfferRule && filesystemRulesOnly
+                ? `, s=session ${ruleLabel}`
+                : canOfferRule && shellRulesOnly
+                    ? `, p=don't-ask-again ${ruleLabel}`
+                    : '';
+            const answer = (await rl.question(`Allow? y=yes${persistHint}, n=no: `)).trim().toLowerCase();
+            if (answer === 's' && canOfferRule && filesystemRulesOnly) {
+                sessionPermissionRules = addSessionPermissionRules(sessionPermissionRules, cwd, suggestedRules);
+                writeSessionPermissionRules(cwd, sessionId, sessionPermissionRules);
+                write(t(language, 'permission.savedRules', { rule: ruleLabel }));
+                return { status: 'allow', reason: 'User approved and saved a permission rule.', requirements: decision.requirements };
+            }
+            if (answer === 'p' && canOfferRule && shellRulesOnly) {
+                for (const rule of suggestedRules) {
+                    saveProjectPermissionRule(cwd, rule);
+                }
+                write(t(language, 'permission.savedPersistentRules', { rule: ruleLabel }));
+                return { status: 'allow', reason: 'User approved and saved a persistent permission rule.', requirements: decision.requirements };
+            }
+            if (answer === 'y' || answer === 'yes') {
+                return { status: 'allow', reason: 'User approved this tool call once.', requirements: decision.requirements };
+            }
+            return { status: 'deny', reason: 'User denied the permission request.', requirements: decision.requirements };
+        };
+        let sawUsageEvent = false;
+        for await (const event of runChatTurn(chatInput, {
+            cwd,
+            sessionId,
+            responseStyle,
+            permissionProfile,
+            requestToolPermission,
+            permissionRules: () => sessionPermissionRules,
+        })) {
+            if (event.type === 'start') {
+                sessionId = event.sessionId;
+                write(`model ${event.model.displayName ?? event.model.alias} (${event.model.model})`);
+            }
+            else if (event.type === 'compact') {
+                write(t(language, 'compact.done', { count: event.sourceEventCount, tokens: event.estimatedTokens }));
+            }
+            else if (event.type === 'delta') {
+                out.write(event.text);
+            }
+            else if (event.type === 'tool_call') {
+                write(`tool ${event.toolName} ${event.summary}`);
+            }
+            else if (event.type === 'tool_result') {
+                if (event.recoverable) {
+                    continue;
+                }
+                write(`${event.ok ? 'result' : 'error'} ${event.toolName} ${event.summary}`);
+            }
+            else if (event.type === 'plan_update') {
+                write('Plan');
+                for (const item of event.items) {
+                    const marker = item.status === 'completed' ? '✓' : item.status === 'in_progress' ? '▸' : '□';
+                    write(`  ${marker} ${item.content}`);
+                }
+            }
+            else if (event.type === 'usage') {
+                sawUsageEvent = true;
+                usageTotals = addTokenUsage(usageTotals, event.usage);
+            }
+            else if (event.type === 'done') {
+                if (event.usage && !sawUsageEvent) {
+                    usageTotals = addTokenUsage(usageTotals, event.usage);
+                }
+                write('');
+            }
+            else if (event.type === 'error') {
+                write(`error ${event.message}`);
+            }
+        }
+        prompt();
+    }
+    if (!isClosed) {
+        rl.close();
+    }
+    write(formatTokenUsage(usageTotals, language));
+    write(formatResumeInstruction(sessionId));
+}
+function formatCommandCapabilityForDisplay(capability) {
+    if (!capability) {
+        return '';
+    }
+    const parts = [`capability: ${capability.id}`, `risk: ${capability.risk}`];
+    if (capability.platform) {
+        parts.push(`platform: ${capability.platform}`);
+    }
+    if (capability.target) {
+        parts.push(`target: ${capability.target}`);
+    }
+    if (capability.packageManager) {
+        parts.push(`manager: ${capability.packageManager}`);
+    }
+    if (capability.requiresAdmin) {
+        parts.push('admin required');
+    }
+    return parts.join(' · ');
+}
+function fallbackFilesystemPermissionRules(request) {
+    const operations = permissionFilesystemOperationsForTool(request.toolName);
+    const targetPath = request.targetPath ?? parsePermissionRequestPath(request.inputSummary);
+    if (operations.length === 0 || !targetPath) {
+        return [];
+    }
+    const root = fallbackFilesystemPermissionRoot(targetPath, request.cwd, request.toolName);
+    return root ? [{ kind: 'filesystem-write-root', root, operations }] : [];
+}
+function permissionFilesystemOperationForTool(toolName) {
+    if (toolName === 'create_directory') {
+        return 'create';
+    }
+    if (toolName === 'write_file') {
+        return 'write';
+    }
+    if (toolName === 'edit_file') {
+        return 'edit';
+    }
+    if (toolName === 'delete_file' || toolName === 'delete_directory') {
+        return 'delete';
+    }
+    return undefined;
+}
+function permissionFilesystemOperationsForTool(toolName) {
+    const operation = permissionFilesystemOperationForTool(toolName);
+    if (!operation) {
+        return [];
+    }
+    if (operation === 'write' || operation === 'edit') {
+        return ['write', 'edit'];
+    }
+    return [operation];
+}
+function fallbackFilesystemPermissionRoot(targetPath, cwd, toolName) {
+    const absolutePath = isAbsolute(targetPath) ? resolve(targetPath) : resolve(cwd, targetPath);
+    const resolvedCwd = resolve(cwd);
+    if (isPathInsideOrEqual(absolutePath, resolvedCwd)) {
+        return resolvedCwd;
+    }
+    const desktop = resolve(homedir(), 'Desktop');
+    if (isPathInsideOrEqual(absolutePath, desktop)) {
+        const rel = relative(desktop, absolutePath);
+        const [project] = rel.split(sep).filter(Boolean);
+        if (project) {
+            return resolve(desktop, project);
+        }
+    }
+    return toolName === 'delete_directory' ? absolutePath : dirname(absolutePath);
+}
+function isPathInsideOrEqual(target, root) {
+    const rel = relative(root, target);
+    return rel === '' || (!rel.startsWith('..') && !isAbsolute(rel));
+}
+function parsePermissionRequestPath(inputSummary) {
+    try {
+        const parsed = JSON.parse(inputSummary);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        const path = parsed['path'];
+        return typeof path === 'string' && path.trim().length > 0 ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/resume.js

@@ -0,0 +1,3 @@
+export function formatResumeInstruction(sessionId, _env = process.env) {
+    return `To continue this session, run remi resume ${sessionId}`;
+}

package/dist/setup.js

@@ -0,0 +1,62 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { createDeepSeekPresetConfig, userConfigPath, writeUserRemiConfig } from '@remi/config';
+export function runSetupCommand(args = [], options = {}) {
+    const force = args.includes('--force');
+    const help = args.includes('--help') || args.includes('-h');
+    const unknown = args.find(arg => arg !== '--force' && arg !== '--help' && arg !== '-h');
+    if (help) {
+        return { code: 0, output: formatSetupHelp() };
+    }
+    if (unknown) {
+        return { code: 1, output: `Unknown setup option: ${unknown}\n\n${formatSetupHelp()}` };
+    }
+    const homeDir = options.homeDir ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const path = userConfigPath(homeDir);
+    const existed = existsSync(path);
+    if (!existed || force) {
+        writeUserRemiConfig(createDeepSeekPresetConfig(), homeDir);
+    }
+    return {
+        code: 0,
+        output: formatSetupResult({ path, wrote: !existed || force, platform }),
+    };
+}
+export function formatSetupHelp() {
+    return [
+        'Usage:',
+        '  remi setup           Create ~/.remi/config.json if it does not exist',
+        '  remi setup --force   Rewrite ~/.remi/config.json with the default preset',
+        '',
+        'The generated config references DEEPSEEK_API_KEY by environment variable and never stores a raw key.',
+    ].join('\n');
+}
+function formatSetupResult({ path, wrote, platform }) {
+    return [
+        'Remi setup',
+        '',
+        `${wrote ? 'created' : 'exists '} config    ${path}`,
+        '',
+        'Next steps:',
+        ...platformSetupHints(platform),
+    ].join('\n');
+}
+export function platformSetupHints(platform) {
+    if (platform === 'win32') {
+        return [
+            '  1. Set your API key in PowerShell:',
+            '     [Environment]::SetEnvironmentVariable("DEEPSEEK_API_KEY", "<your-key>", "User")',
+            '  2. Restart the terminal so the new user environment is loaded.',
+            '  3. If remi is not found after npm install -g, add the npm global bin directory to PATH.',
+            '     Usually this is %APPDATA%\\npm; confirm with: npm prefix -g',
+        ];
+    }
+    return [
+        '  1. Add your API key to your shell profile:',
+        '     export DEEPSEEK_API_KEY="<your-key>"',
+        '  2. Restart the terminal or source the profile.',
+        '  3. If remi is not found after npm install -g, add the npm global bin directory to PATH.',
+        '     Usually this is $(npm prefix -g)/bin; confirm with: npm prefix -g',
+    ];
+}

package/dist/statusline.js

@@ -0,0 +1,59 @@
+import { loadRemiConfig, readProjectRemiConfig, statusLineItemIds, writeProjectRemiConfig } from '@remi/config';
+import { t } from './i18n.js';
+export const defaultStatusLineItems = ['model', 'context-remaining', 'cwd'];
+export const statusLineCatalog = [
+    { id: 'model', label: 'model', description: 'Current main model' },
+    { id: 'cwd', label: 'cwd', description: 'Current working directory' },
+    { id: 'git-branch', label: 'git-branch', description: 'Current Git branch (hidden when unavailable)' },
+    { id: 'branch-changes', label: 'branch-changes', description: 'Working tree line changes, such as +8 -1' },
+    { id: 'context-remaining', label: 'context-remaining', description: 'Percentage of context window remaining' },
+    { id: 'used-tokens', label: 'used-tokens', description: 'Total tokens used in the current session' },
+    { id: 'total-input-tokens', label: 'total-input-tokens', description: 'Total input tokens used in the current session' },
+    { id: 'total-output-tokens', label: 'total-output-tokens', description: 'Total output tokens used in the current session' },
+    { id: 'run-state', label: 'run-state', description: 'Compact session run-state text' },
+    { id: 'permissions', label: 'permissions', description: 'Current permission profile' },
+];
+const statusLineDescriptionKeys = {
+    model: 'statusline.catalog.model',
+    cwd: 'statusline.catalog.cwd',
+    'git-branch': 'statusline.catalog.git-branch',
+    'branch-changes': 'statusline.catalog.branch-changes',
+    'context-remaining': 'statusline.catalog.context-remaining',
+    'used-tokens': 'statusline.catalog.used-tokens',
+    'total-input-tokens': 'statusline.catalog.total-input-tokens',
+    'total-output-tokens': 'statusline.catalog.total-output-tokens',
+    'run-state': 'statusline.catalog.run-state',
+    permissions: 'statusline.catalog.permissions',
+};
+export function getStatusLineCatalog(language) {
+    return statusLineCatalog.map(item => ({
+        ...item,
+        description: t(language, statusLineDescriptionKeys[item.id]),
+    }));
+}
+export function normalizeStatusLineItems(items) {
+    if (!Array.isArray(items)) {
+        return defaultStatusLineItems;
+    }
+    const allowed = new Set(statusLineItemIds);
+    const normalized = items.filter((item) => typeof item === 'string' && allowed.has(item));
+    return normalized.length > 0 ? Array.from(new Set(normalized)) : defaultStatusLineItems;
+}
+export function resolveConfiguredStatusLineItems(cwd) {
+    try {
+        return normalizeStatusLineItems(loadRemiConfig({ cwd }).config.statusLine?.items);
+    }
+    catch {
+        return defaultStatusLineItems;
+    }
+}
+export function saveProjectStatusLineItems(cwd, items) {
+    const projectConfig = readProjectRemiConfig(cwd);
+    writeProjectRemiConfig({
+        ...projectConfig,
+        statusLine: {
+            ...projectConfig.statusLine,
+            items: normalizeStatusLineItems(items),
+        },
+    }, cwd);
+}

package/dist/style.js

@@ -0,0 +1,48 @@
+import { defaultResponseStyleId, isResponseStyleId, responseStylePresets, } from '@remi/core';
+import { loadRemiConfig, readProjectRemiConfig, writeProjectRemiConfig } from '@remi/config';
+import { t } from './i18n.js';
+export function parseResponseStyleArg(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === '极简') {
+        return 'minimal';
+    }
+    if (isResponseStyleId(normalized)) {
+        return normalized;
+    }
+    return responseStylePresets.find(style => style.label.toLowerCase() === normalized)?.id;
+}
+export function formatResponseStyleList(activeStyle = defaultResponseStyleId, language) {
+    return [
+        'Response styles:',
+        ...responseStylePresets.map(style => {
+            const marker = style.id === activeStyle ? '*' : ' ';
+            return ` ${marker} ${style.id.padEnd(8)} ${style.label.padEnd(8)} ${styleDescription(style.id, language)}`;
+        }),
+    ].join('\n');
+}
+export function resolveConfiguredResponseStyle(cwd) {
+    return parseResponseStyleArg(loadRemiConfig({ cwd }).config.responseStyle) ?? defaultResponseStyleId;
+}
+export function saveProjectResponseStyle(cwd, styleId) {
+    const config = readProjectRemiConfig(cwd);
+    writeProjectRemiConfig({ ...config, responseStyle: styleId }, cwd);
+}
+export function formatResponseStyleChanged(styleId, saved = false, language) {
+    const style = responseStylePresets.find(candidate => candidate.id === styleId);
+    const label = style?.label ?? styleId;
+    return saved ? t(language, 'style.saved', { label }) : t(language, 'style.selected', { label });
+}
+export function styleDescription(styleId, language) {
+    if (styleId === 'brief')
+        return t(language, 'style.description.brief');
+    if (styleId === 'explain')
+        return t(language, 'style.description.explain');
+    if (styleId === 'mentor')
+        return t(language, 'style.description.mentor');
+    if (styleId === 'minimal')
+        return t(language, 'style.description.minimal');
+    return t(language, 'style.description.remi');
+}

package/dist/syntaxTheme.js

@@ -0,0 +1,39 @@
+import { loadRemiConfig, readProjectRemiConfig, writeProjectRemiConfig } from '@remi/config';
+import { listTerminalSyntaxThemes, resolveTerminalSyntaxThemeId, terminalSyntaxThemeLabel, } from '@remi/terminal-markdown';
+import { t } from './i18n.js';
+export function syntaxThemeOptions() {
+    return listTerminalSyntaxThemes();
+}
+export function parseSyntaxThemeArg(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    const option = listTerminalSyntaxThemes().find(theme => {
+        return theme.id === normalized || theme.label.toLowerCase() === normalized;
+    });
+    return option?.id;
+}
+export function resolveConfiguredSyntaxTheme(cwd) {
+    try {
+        return resolveTerminalSyntaxThemeId(loadRemiConfig({ cwd }).config.syntaxTheme);
+    }
+    catch {
+        return 'default';
+    }
+}
+export function saveProjectSyntaxTheme(cwd, themeId) {
+    const config = readProjectRemiConfig(cwd);
+    writeProjectRemiConfig({ ...config, syntaxTheme: themeId }, cwd);
+}
+export function formatSyntaxThemeChanged(themeId, saved = false, language) {
+    return t(language, saved ? 'theme.saved' : 'theme.selected', { label: terminalSyntaxThemeLabel(themeId) });
+}
+export function formatSyntaxThemeList(activeTheme = 'default') {
+    return syntaxThemeOptions()
+        .map(theme => {
+        const marker = theme.id === activeTheme ? '*' : ' ';
+        return `${marker} ${theme.id.padEnd(24)} ${theme.label}`;
+    })
+        .join('\n');
+}