@wangzhizhi/remi 0.0.1-alpha

package/dist/index.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { formatDoctor, runDoctor } from './doctor.js';
+import { formatHelp } from './help.js';
+import { runModelCommand } from './model.js';
+import { startRepl } from './repl.js';
+import { runSetupCommand } from './setup.js';
+import { startTui } from './tui/index.js';
+import { version } from './version.js';
+import { sessionExists } from '@remi/sessions';
+export const cliPackageName = '@remi/cli';
+export function shouldUseTui(env = process.env, input = process.stdin, output = process.stdout) {
+    if (env['REMI_PLAIN'] === '1' || env['REMI_PLAIN'] === 'true') {
+        return false;
+    }
+    if (env['CI'] === '1' || env['CI'] === 'true') {
+        return false;
+    }
+    return input.isTTY === true && output.isTTY === true;
+}
+export function isDirectCliEntrypoint(metaUrl, argvPath = process.argv[1]) {
+    if (!argvPath) {
+        return false;
+    }
+    const modulePath = fileURLToPath(metaUrl);
+    try {
+        return realpathSync(modulePath) === realpathSync(argvPath);
+    }
+    catch {
+        return modulePath === argvPath;
+    }
+}
+export async function runCli(args = process.argv.slice(2)) {
+    const forceTui = args.includes('--tui');
+    const forcePlain = args.includes('--plain');
+    const commandArgs = args.filter(arg => arg !== '--tui' && arg !== '--plain');
+    const [command] = commandArgs;
+    if (!command || command === 'repl' || command === 'chat' || command === 'code') {
+        if (forceTui || (!forcePlain && shouldUseTui())) {
+            await startTui();
+        }
+        else {
+            await startRepl();
+        }
+        return 0;
+    }
+    if (command === 'resume') {
+        const sessionId = commandArgs[1];
+        if (!sessionId) {
+            console.error('Usage: remi resume <session-id>');
+            return 1;
+        }
+        const cwd = process.cwd();
+        if (!sessionExists(cwd, sessionId)) {
+            console.error(`Session not found: ${sessionId}`);
+            return 1;
+        }
+        if (forceTui || (!forcePlain && shouldUseTui())) {
+            await startTui({ cwd, sessionId });
+        }
+        else {
+            await startRepl({ cwd, sessionId });
+        }
+        return 0;
+    }
+    if (command === '--help' || command === '-h' || command === 'help') {
+        console.log(formatHelp());
+        return 0;
+    }
+    if (command === '--version' || command === '-v' || command === '-V' || command === 'version') {
+        console.log(version);
+        return 0;
+    }
+    if (command === 'doctor') {
+        const report = runDoctor();
+        console.log(formatDoctor(report));
+        return report.ok ? 0 : 1;
+    }
+    if (command === 'model') {
+        const result = runModelCommand(commandArgs.slice(1));
+        console.log(result.output);
+        return result.code;
+    }
+    if (command === 'setup') {
+        const result = runSetupCommand(commandArgs.slice(1));
+        console.log(result.output);
+        return result.code;
+    }
+    console.error(`Unknown command: ${command}`);
+    console.error('Run remi --help for usage.');
+    return 1;
+}
+if (isDirectCliEntrypoint(import.meta.url)) {
+    const exitCode = await runCli();
+    process.exitCode = exitCode;
+}

package/dist/initPrompt.js

@@ -0,0 +1,17 @@
+export function buildInitPrompt() {
+    return `Set up a minimal AGENTS.md for this repository. AGENTS.md is loaded into future Remi sessions, so keep it concise and only include information that would prevent mistakes.
+
+Work in this order:
+
+1. Explore the repository before writing. Read key files such as README, package manifests, workspace config, build/test config, Makefile, CI config, and any existing AI-agent instruction files: AGENTS.md, AGENT.md, CLAUDE.md, REMI.md, .cursor/rules, .cursorrules, .github/copilot-instructions.md, .windsurfrules, or .clinerules.
+2. Identify only non-obvious guidance: build/test/lint commands, package manager/runtime requirements, architecture boundaries, repo workflow, local setup gotchas, testing quirks, generated files, security rules, or user/team preferences already documented in the repo.
+3. If AGENTS.md already exists, read it first and update it narrowly. Do not silently overwrite existing guidance.
+4. Create or update AGENTS.md at the project root with a short, practical structure. Start it with:
+
+# AGENTS.md
+
+This file provides guidance to Remi when working in this repository.
+
+5. Exclude generic advice, obvious commands directly inferable from manifests, file-by-file inventories, long tutorials, secrets, API keys, tokens, credentials, and anything likely to go stale unless it references a source file to check.
+6. After writing, briefly summarize what was added or changed and mention any uncertainty that needs user confirmation.`;
+}

package/dist/model.js

@@ -0,0 +1,116 @@
+import { loadRemiConfig, modelRoles } from '@remi/config';
+import { createModelRouter } from '@remi/llm';
+export function runModelCommand(args, cwd = process.cwd()) {
+    const subcommand = args[0] ?? 'list';
+    const loaded = loadRemiConfig({ cwd });
+    const router = createModelRouter(loaded.config);
+    if (subcommand === 'list') {
+        return { code: 0, output: formatModelList(loaded, router) };
+    }
+    if (subcommand === 'providers') {
+        return { code: 0, output: formatProviderList(loaded, router) };
+    }
+    if (subcommand === 'profiles') {
+        return { code: 0, output: formatProfileList(loaded) };
+    }
+    if (subcommand === 'doctor') {
+        return { code: 0, output: formatModelDoctor(loaded, router) };
+    }
+    return {
+        code: 1,
+        output: `Unknown model command: ${subcommand}\nRun remi model list, providers, profiles, or doctor.`,
+    };
+}
+export function formatModelList(loaded, router) {
+    const lines = ['Remi models', '', `active profile: ${loaded.config.activeProfile ?? 'unset'}`, ''];
+    const models = router.models.list();
+    if (models.length === 0) {
+        return [...lines, 'No models configured.'].join('\n');
+    }
+    lines.push('alias              name                  provider   model                 ctx       tools  reasoning  used by');
+    for (const model of models) {
+        lines.push([
+            pad(model.alias, 18),
+            pad(model.displayName ?? model.alias, 22),
+            pad(model.provider, 10),
+            pad(model.model, 21),
+            pad(formatContext(model.contextWindow), 9),
+            pad(model.supportsTools ? 'yes' : 'no', 7),
+            pad(model.supportsReasoning ? 'yes' : 'no', 10),
+            model.usedBy.join(', ') || '-',
+        ].join(''));
+    }
+    return lines.join('\n');
+}
+export function formatProviderList(_loaded, router) {
+    const providers = router.providers.list();
+    const lines = ['Remi model providers', ''];
+    if (providers.length === 0) {
+        return [...lines, 'No providers configured.'].join('\n');
+    }
+    lines.push('alias       type                  key         baseURL');
+    for (const provider of providers) {
+        lines.push([
+            pad(provider.alias, 12),
+            pad(provider.type, 22),
+            pad(provider.apiKeyStatus, 12),
+            provider.baseURL,
+        ].join(''));
+    }
+    return lines.join('\n');
+}
+export function formatProfileList(loaded) {
+    const profiles = Object.entries(loaded.config.profiles ?? {});
+    const lines = ['Remi model profiles', '', `active profile: ${loaded.config.activeProfile ?? 'unset'}`, ''];
+    if (profiles.length === 0) {
+        return [...lines, 'No profiles configured.'].join('\n');
+    }
+    for (const [name, profile] of profiles) {
+        lines.push(`${name}${name === loaded.config.activeProfile ? ' (active)' : ''}`);
+        if (profile.extends) {
+            lines.push(`  extends: ${profile.extends}`);
+        }
+        if (profile.effort) {
+            lines.push(`  effort: ${profile.effort}`);
+        }
+        for (const role of modelRoles) {
+            const alias = profile.roles[role];
+            if (alias) {
+                lines.push(`  ${role}: ${alias}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+export function formatModelDoctor(loaded, router) {
+    const lines = ['Remi model doctor', ''];
+    lines.push(`active profile: ${loaded.config.activeProfile ?? 'unset'}`);
+    lines.push(`providers: ${router.providers.list().length}`);
+    lines.push(`models: ${router.models.list().length}`);
+    const providerIssues = router.providers
+        .list()
+        .filter(provider => provider.apiKeyStatus === 'missing')
+        .map(provider => provider.alias);
+    if (providerIssues.length > 0) {
+        lines.push(`missing API key: ${providerIssues.join(', ')}`);
+    }
+    else {
+        lines.push('API keys: configured');
+    }
+    for (const diagnostic of loaded.diagnostics) {
+        lines.push(`${diagnostic.level}: ${diagnostic.message}`);
+    }
+    return lines.join('\n');
+}
+function pad(value, length) {
+    return value.length >= length ? `${value} ` : value.padEnd(length);
+}
+function formatContext(contextWindow) {
+    if (contextWindow >= 1_000_000) {
+        return `${contextWindow / 1_000_000}M`;
+    }
+    if (contextWindow >= 1_000) {
+        return `${contextWindow / 1_000}K`;
+    }
+    return String(contextWindow);
+}

package/dist/modelSelection.js

@@ -0,0 +1,34 @@
+import { loadRemiConfig, readProjectRemiConfig, writeProjectRemiConfig } from '@remi/config';
+import { createModelRouter } from '@remi/llm';
+export function saveProjectMainModel(cwd, modelAlias) {
+    const loaded = loadRemiConfig({ cwd });
+    const router = createModelRouter(loaded.config);
+    if (!router.models.get(modelAlias)) {
+        throw new Error(`Unknown model alias: ${modelAlias}`);
+    }
+    const activeProfile = router.getActiveProfile();
+    const projectConfig = readProjectRemiConfig(cwd);
+    const existingProfile = projectConfig.profiles?.[activeProfile];
+    writeProjectRemiConfig({
+        ...projectConfig,
+        activeProfile: projectConfig.activeProfile ?? activeProfile,
+        profiles: {
+            ...projectConfig.profiles,
+            [activeProfile]: {
+                ...existingProfile,
+                roles: {
+                    ...(existingProfile?.roles ?? {}),
+                    main: modelAlias,
+                },
+            },
+        },
+    }, cwd);
+}
+export function resolveMainModelContextWindow(cwd) {
+    try {
+        return createModelRouter(loadRemiConfig({ cwd }).config).resolve('main').contextWindow;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/permissionDisplay.js

@@ -0,0 +1,46 @@
+import { t } from './i18n.js';
+export function formatPermissionFileAction(request, language) {
+    return formatPermissionFileActionFromParts(request.toolName, request.inputSummary, language, request.targetPath);
+}
+export function formatPermissionFileActionFromParts(toolName, inputSummary, language, targetPath) {
+    const path = targetPath ?? permissionRequestPath(inputSummary);
+    if (!path) {
+        return undefined;
+    }
+    const directory = permissionRequestDirectory(path, language);
+    if (toolName === 'write_file' || toolName === 'edit_file') {
+        return {
+            action: t(language, 'permission.request.action.modifyFilesIn', { directory }),
+            detail: t(language, 'permission.request.action.target', { path }),
+        };
+    }
+    return undefined;
+}
+function permissionRequestPath(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.length > 0 ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function permissionRequestDirectory(path, language) {
+    const normalized = path.replace(/\\/g, '/');
+    const lastSeparator = normalized.lastIndexOf('/');
+    if (lastSeparator < 0) {
+        return t(language, 'permission.request.path.currentDirectory');
+    }
+    if (lastSeparator === 0) {
+        return '/';
+    }
+    const directory = normalized.slice(0, lastSeparator);
+    if (!directory || directory === '.') {
+        return t(language, 'permission.request.path.currentDirectory');
+    }
+    return normalized.startsWith('/') ? directory : `${directory}/`;
+}

package/dist/permissions.js

@@ -0,0 +1,206 @@
+import { normalizePermissionProfile, permissionProfiles, readProjectRemiConfig, transitionPermissionProfile, writeProjectRemiConfig, loadRemiConfig, } from '@remi/config';
+import { resolve } from 'node:path';
+import { t } from './i18n.js';
+export function permissionProfileOptions(language) {
+    return permissionProfiles.map(profile => ({
+        id: profile,
+        label: permissionProfileLabel(profile, language),
+        description: permissionProfileDescription(profile, language),
+    }));
+}
+export function permissionProfileLabel(profile, language) {
+    return t(language, permissionProfileLabelKeys[profile]);
+}
+export function permissionProfileDescription(profile, language) {
+    return t(language, permissionProfileDescriptionKeys[profile]);
+}
+const permissionProfileLabelKeys = {
+    default: 'permissions.profile.default.label',
+    'auto-review': 'permissions.profile.auto-review.label',
+    'full-access': 'permissions.profile.full-access.label',
+};
+const permissionProfileDescriptionKeys = {
+    default: 'permissions.profile.default.description',
+    'auto-review': 'permissions.profile.auto-review.description',
+    'full-access': 'permissions.profile.full-access.description',
+};
+export function parsePermissionProfileArg(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (['default', 'normal', 'safe', '默认'].includes(normalized)) {
+        return 'default';
+    }
+    if (['auto-review', 'autoreview', 'auto', 'review', '自动审查'].includes(normalized)) {
+        return 'auto-review';
+    }
+    if (['full-access', 'fullaccess', 'full', 'bypass', 'danger', '完全访问'].includes(normalized)) {
+        return 'full-access';
+    }
+    return undefined;
+}
+export function resolveConfiguredPermissionProfile(cwd) {
+    try {
+        return normalizePermissionProfile(loadRemiConfig({ cwd }).config.permissions);
+    }
+    catch {
+        return 'default';
+    }
+}
+export function saveProjectPermissionProfile(cwd, profile) {
+    const config = readProjectRemiConfig(cwd);
+    writeProjectRemiConfig(transitionPermissionProfile(config, profile), cwd);
+}
+export function formatPermissionProfileChanged(profile, language) {
+    return t(language, 'permissions.saved', { label: permissionProfileLabel(profile, language) });
+}
+export function formatPermissionProfileList(active, language) {
+    return permissionProfileOptions(language)
+        .map(option => `${option.id === active ? '*' : ' '} ${option.label}: ${option.description}`)
+        .join('\n');
+}
+export function saveProjectPermissionRule(cwd, ruleOrPrefix) {
+    const rule = typeof ruleOrPrefix === 'string' ? { kind: 'shell-prefix', prefix: ruleOrPrefix } : ruleOrPrefix;
+    const config = readProjectRemiConfig(cwd);
+    const currentRules = config.permissions?.allow ?? [];
+    const nextRule = normalizePermissionRule(rule, cwd);
+    if (!nextRule) {
+        return;
+    }
+    const nextRules = mergePermissionRule(currentRules, nextRule);
+    if (nextRules === currentRules) {
+        return;
+    }
+    writeProjectRemiConfig({
+        ...config,
+        permissions: {
+            ...config.permissions,
+            allow: nextRules,
+        },
+    }, cwd);
+}
+export const saveProjectShellPermissionRule = saveProjectPermissionRule;
+export function addSessionPermissionRules(currentRules, cwd, rules) {
+    let nextRules = currentRules;
+    for (const rule of rules) {
+        const normalized = normalizePermissionRule(rule, cwd);
+        if (!normalized) {
+            continue;
+        }
+        nextRules = mergePermissionRule(nextRules, normalized);
+    }
+    return nextRules;
+}
+export function formatPermissionRuleScope(rule, language) {
+    if (rule.kind === 'filesystem-write-root') {
+        const operationLabel = formatFilesystemOperations(rule.operations, language);
+        if (operationLabel) {
+            return t(language, 'permission.rule.filesystemOperations', { operations: operationLabel, root: rule.root });
+        }
+        return t(language, 'permission.rule.filesystem', { root: rule.root });
+    }
+    if (rule.cwd) {
+        return t(language, 'permission.rule.scoped', { prefix: rule.prefix, cwd: rule.cwd });
+    }
+    return t(language, 'permission.rule.prefix', { prefix: rule.prefix });
+}
+export function formatPermissionRulesScope(rules, language) {
+    if (rules.length === 1 && rules[0]) {
+        return formatPermissionRuleScope(rules[0], language);
+    }
+    if (rules.every(rule => rule.kind === 'shell-prefix')) {
+        const firstCwd = rules[0]?.cwd;
+        const sameCwd = firstCwd && rules.every(rule => rule.kind === 'shell-prefix' && rule.cwd === firstCwd);
+        const prefixes = rules.map(rule => (rule.kind === 'shell-prefix' ? `\`${rule.prefix}\`` : '')).join(', ');
+        if (sameCwd) {
+            return t(language, 'permission.rule.multipleScoped', { prefixes, cwd: firstCwd });
+        }
+        return t(language, 'permission.rule.multiple', { prefixes });
+    }
+    return rules.map(rule => formatPermissionRuleScope(rule, language)).join(', ');
+}
+function normalizePermissionRule(rule, cwd) {
+    if (rule.kind === 'shell-prefix') {
+        const normalizedPrefix = rule.prefix.trim();
+        if (!normalizedPrefix) {
+            return undefined;
+        }
+        const normalizedCwd = typeof rule.cwd === 'string' && rule.cwd.trim().length > 0 ? rule.cwd.trim() : undefined;
+        return {
+            kind: 'shell-prefix',
+            prefix: normalizedPrefix,
+            ...(normalizedCwd ? { cwd: normalizedCwd } : {}),
+            createdAt: new Date().toISOString(),
+        };
+    }
+    const root = rule.root.trim();
+    if (!root) {
+        return undefined;
+    }
+    const operations = normalizeFilesystemOperations(rule.operations);
+    return {
+        kind: 'filesystem-write-root',
+        root: resolve(cwd, root),
+        ...(operations.length > 0 ? { operations } : {}),
+        createdAt: new Date().toISOString(),
+    };
+}
+function mergePermissionRule(currentRules, nextRule) {
+    if (nextRule.kind === 'shell-prefix') {
+        if (currentRules.some(existing => existing.kind === 'shell-prefix' &&
+            existing.prefix === nextRule.prefix &&
+            (existing.cwd ?? undefined) === (nextRule.cwd ?? undefined))) {
+            return currentRules;
+        }
+        return [...currentRules, nextRule];
+    }
+    const existingIndex = currentRules.findIndex(existing => existing.kind === 'filesystem-write-root' && existing.root === nextRule.root);
+    if (existingIndex < 0) {
+        return [...currentRules, nextRule];
+    }
+    const existing = currentRules[existingIndex];
+    if (!existing || existing.kind !== 'filesystem-write-root') {
+        return currentRules;
+    }
+    const mergedOperations = normalizeFilesystemOperations([...(existing.operations ?? []), ...(nextRule.operations ?? [])]);
+    const existingOperations = normalizeFilesystemOperations(existing.operations);
+    if (existingOperations.join('\0') === mergedOperations.join('\0')) {
+        return currentRules;
+    }
+    const mergedRule = {
+        ...existing,
+        operations: mergedOperations,
+    };
+    const nextRules = [...currentRules];
+    nextRules[existingIndex] = mergedRule;
+    return nextRules;
+}
+function normalizeFilesystemOperations(operations) {
+    const order = ['create', 'write', 'edit', 'delete'];
+    const values = Array.isArray(operations) ? operations : [];
+    return order.filter(operation => values.includes(operation));
+}
+function formatFilesystemOperations(operations, language) {
+    const normalized = normalizeFilesystemOperations(operations);
+    if (normalized.length === 0 || normalized.length === 4) {
+        return '';
+    }
+    if (normalized.length === 2 && normalized.includes('write') && normalized.includes('edit')) {
+        return language === 'zh-Hans' ? '修改' : 'modifying';
+    }
+    const labels = language === 'zh-Hans'
+        ? {
+            create: '创建',
+            write: '写入',
+            edit: '编辑',
+            delete: '删除',
+        }
+        : {
+            create: 'creating',
+            write: 'writing',
+            edit: 'editing',
+            delete: 'deleting',
+        };
+    return normalized.map(operation => labels[operation]).join(language === 'zh-Hans' ? '、' : ', ');
+}