@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/config/dist/index.js

@@ -0,0 +1,426 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const configPackageName = '@remi/config';
+export const languageCodes = ['en', 'zh-Hans'];
+export const modelRoles = ['main', 'planning', 'subagent', 'compact', 'memory', 'toolRepair', 'embedding'];
+export const statusLineItemIds = [
+    'model',
+    'cwd',
+    'git-branch',
+    'branch-changes',
+    'context-remaining',
+    'used-tokens',
+    'total-input-tokens',
+    'total-output-tokens',
+    'run-state',
+    'permissions',
+];
+export const permissionProfiles = ['default', 'auto-review', 'full-access'];
+const deepSeekApiKey = '${DEEPSEEK_API_KEY}';
+const defaultAnthropicBaseURL = 'https://api.anthropic.com';
+export function createDeepSeekPresetConfig() {
+    return {
+        activeProfile: 'daily',
+        providers: {
+            deepseek: {
+                type: 'openai-compatible',
+                baseURL: 'https://api.deepseek.com',
+                apiKey: deepSeekApiKey,
+                apiKeyEnv: 'DEEPSEEK_API_KEY',
+            },
+        },
+        models: {
+            'deepseek.flash': {
+                provider: 'deepseek',
+                model: 'deepseek-v4-flash',
+                displayName: 'DeepSeek-V4-Flash',
+                contextWindow: 1_000_000,
+                maxOutputTokens: 384_000,
+                supportsTools: true,
+                supportsReasoning: true,
+                tokenEstimator: 'deepseek-local-tokenizer',
+                tokenEstimateProfile: 'code-heavy',
+                usageShape: 'openai-compatible',
+                cacheUsageShape: 'openai-prompt-token-details',
+            },
+            'deepseek.pro': {
+                provider: 'deepseek',
+                model: 'deepseek-v4-pro',
+                displayName: 'DeepSeek-V4-Pro',
+                contextWindow: 1_000_000,
+                maxOutputTokens: 384_000,
+                supportsTools: true,
+                supportsReasoning: true,
+                tokenEstimator: 'deepseek-local-tokenizer',
+                tokenEstimateProfile: 'code-heavy',
+                usageShape: 'openai-compatible',
+                cacheUsageShape: 'openai-prompt-token-details',
+            },
+        },
+        modelSets: {
+            deepseek: ['deepseek.flash', 'deepseek.pro'],
+        },
+        profiles: {
+            daily: {
+                roles: {
+                    main: 'deepseek.flash',
+                    planning: 'deepseek.pro',
+                    subagent: 'deepseek.flash',
+                    compact: 'deepseek.flash',
+                    memory: 'deepseek.flash',
+                    toolRepair: 'deepseek.flash',
+                },
+                effort: 'medium',
+            },
+            pro: {
+                extends: 'daily',
+                roles: {
+                    main: 'deepseek.pro',
+                    planning: 'deepseek.pro',
+                    compact: 'deepseek.pro',
+                },
+                effort: 'high',
+            },
+            flash: {
+                extends: 'daily',
+                roles: {
+                    main: 'deepseek.flash',
+                    planning: 'deepseek.flash',
+                    compact: 'deepseek.flash',
+                },
+                effort: 'low',
+            },
+        },
+    };
+}
+export function createClaudeCodeEnvConfig(env = process.env) {
+    const mainModel = env['ANTHROPIC_MODEL'];
+    const smallModel = env['ANTHROPIC_SMALL_FAST_MODEL'] ?? mainModel;
+    const apiKeyEnv = env['ANTHROPIC_AUTH_TOKEN'] ? 'ANTHROPIC_AUTH_TOKEN' : env['ANTHROPIC_API_KEY'] ? 'ANTHROPIC_API_KEY' : undefined;
+    const baseURL = env['ANTHROPIC_BASE_URL'] ?? defaultAnthropicBaseURL;
+    const config = {};
+    if (apiKeyEnv || env['ANTHROPIC_BASE_URL']) {
+        config.providers = {
+            claudeCode: {
+                type: 'anthropic-compatible',
+                baseURL,
+                ...(apiKeyEnv ? { apiKey: `\${${apiKeyEnv}}`, apiKeyEnv } : {}),
+            },
+        };
+    }
+    if (!mainModel) {
+        return config;
+    }
+    const models = {
+        'claude-code.main': createClaudeCodeModelConfig(mainModel),
+    };
+    const mainAlias = 'claude-code.main';
+    let smallAlias = mainAlias;
+    if (smallModel && smallModel !== mainModel) {
+        smallAlias = 'claude-code.small';
+        models[smallAlias] = createClaudeCodeModelConfig(smallModel);
+    }
+    const envImportConfig = {
+        activeProfile: 'claude-code',
+        models,
+        modelSets: {
+            'claude-code': Object.keys(models),
+        },
+        profiles: {
+            'claude-code': {
+                roles: {
+                    main: mainAlias,
+                    planning: mainAlias,
+                    subagent: smallAlias,
+                    compact: smallAlias,
+                    memory: smallAlias,
+                    toolRepair: smallAlias,
+                },
+                effort: 'medium',
+            },
+        },
+    };
+    if (config.providers) {
+        envImportConfig.providers = config.providers;
+    }
+    return mergeRemiConfig(config, envImportConfig);
+}
+export function configPaths(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const homeDir = options.homeDir ?? homedir();
+    const sources = [
+        { kind: 'user', path: userConfigPath(homeDir), exists: false },
+        { kind: 'project', path: join(cwd, '.agent', 'config.json'), exists: false },
+        { kind: 'local', path: join(cwd, '.agent', 'config.local.json'), exists: false },
+    ];
+    return sources.map(source => ({ ...source, exists: existsSync(source.path) }));
+}
+export function userConfigPath(homeDir = homedir()) {
+    return join(homeDir, '.remi', 'config.json');
+}
+export function readUserRemiConfig(homeDir = homedir()) {
+    const path = userConfigPath(homeDir);
+    if (!existsSync(path)) {
+        return {};
+    }
+    return parseConfigFile(path);
+}
+export function writeUserRemiConfig(config, homeDir = homedir()) {
+    mkdirSync(join(homeDir, '.remi'), { recursive: true });
+    writeFileSync(userConfigPath(homeDir), `${JSON.stringify(config, null, 2)}\n`);
+}
+export function projectConfigPath(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'config.json');
+}
+export function readProjectRemiConfig(cwd = process.cwd()) {
+    const path = projectConfigPath(cwd);
+    if (!existsSync(path)) {
+        return {};
+    }
+    return parseConfigFile(path);
+}
+export function writeProjectRemiConfig(config, cwd = process.cwd()) {
+    mkdirSync(join(cwd, '.agent'), { recursive: true });
+    writeFileSync(projectConfigPath(cwd), `${JSON.stringify(config, null, 2)}\n`);
+}
+export function isPermissionProfile(value) {
+    return typeof value === 'string' && permissionProfiles.includes(value);
+}
+export function normalizePermissionProfile(permissions) {
+    if (isPermissionProfile(permissions?.profile)) {
+        return permissions.profile;
+    }
+    if (permissions?.mode === 'bypass') {
+        return 'full-access';
+    }
+    return 'default';
+}
+export function permissionProfileToToolMode(profile) {
+    if (profile === 'full-access') {
+        return 'bypass';
+    }
+    return 'auto';
+}
+export function resolveToolPermissionMode(permissions) {
+    if (isPermissionProfile(permissions?.profile)) {
+        return permissionProfileToToolMode(permissions.profile);
+    }
+    return permissions?.mode ?? permissionProfileToToolMode('default');
+}
+export function transitionPermissionProfile(config, profile) {
+    const permissions = {
+        ...config.permissions,
+        profile,
+        mode: permissionProfileToToolMode(profile),
+    };
+    return {
+        ...config,
+        permissions,
+    };
+}
+export function interpolateEnv(value, env = process.env) {
+    const match = /^\$\{([A-Z0-9_]+)\}$/.exec(value);
+    if (!match) {
+        return value;
+    }
+    const envName = match[1];
+    if (!envName) {
+        return undefined;
+    }
+    return env[envName];
+}
+export function providerApiKeyStatus(provider, env = process.env) {
+    return resolveProviderApiKey(provider, env) ? 'configured' : 'missing';
+}
+export function resolveProviderApiKey(provider, env = process.env) {
+    if (provider.apiKeyEnv && env[provider.apiKeyEnv]) {
+        return env[provider.apiKeyEnv];
+    }
+    if (provider.apiKey) {
+        return interpolateEnv(provider.apiKey, env);
+    }
+    return undefined;
+}
+export function hasProviderApiKey(provider, env = process.env) {
+    if (provider.apiKeyEnv && env[provider.apiKeyEnv]) {
+        return true;
+    }
+    if (provider.apiKey && interpolateEnv(provider.apiKey, env)) {
+        return true;
+    }
+    return false;
+}
+export function mergeRemiConfig(...configs) {
+    return configs.reduce((merged, config) => {
+        const result = {};
+        const schema = config.$schema ?? merged.$schema;
+        const activeProfile = config.activeProfile ?? merged.activeProfile;
+        const language = config.language ?? merged.language;
+        const responseStyle = config.responseStyle ?? merged.responseStyle;
+        const syntaxTheme = config.syntaxTheme ?? merged.syntaxTheme;
+        const permissions = config.permissions || merged.permissions
+            ? {
+                ...merged.permissions,
+                ...config.permissions,
+            }
+            : undefined;
+        const agent = config.agent || merged.agent
+            ? {
+                ...merged.agent,
+                ...config.agent,
+            }
+            : undefined;
+        const statusLine = config.statusLine || merged.statusLine
+            ? {
+                ...merged.statusLine,
+                ...config.statusLine,
+            }
+            : undefined;
+        const mergedDisabledSkills = uniqueStrings([...(merged.skills?.disabled ?? []), ...(config.skills?.disabled ?? [])]);
+        const skills = config.skills || merged.skills
+            ? {
+                ...merged.skills,
+                ...config.skills,
+                ...(mergedDisabledSkills ? { disabled: mergedDisabledSkills } : {}),
+            }
+            : undefined;
+        const providers = {
+            ...merged.providers,
+            ...config.providers,
+        };
+        const models = {
+            ...merged.models,
+            ...config.models,
+        };
+        const modelSets = {
+            ...merged.modelSets,
+            ...config.modelSets,
+        };
+        const profiles = mergeProfiles(merged.profiles, config.profiles);
+        if (schema !== undefined)
+            result.$schema = schema;
+        if (activeProfile !== undefined)
+            result.activeProfile = activeProfile;
+        if (language !== undefined)
+            result.language = language;
+        if (responseStyle !== undefined)
+            result.responseStyle = responseStyle;
+        if (syntaxTheme !== undefined)
+            result.syntaxTheme = syntaxTheme;
+        if (permissions !== undefined)
+            result.permissions = permissions;
+        if (agent !== undefined)
+            result.agent = agent;
+        if (statusLine !== undefined)
+            result.statusLine = statusLine;
+        if (skills !== undefined)
+            result.skills = skills;
+        if (Object.keys(providers).length > 0)
+            result.providers = providers;
+        if (Object.keys(models).length > 0)
+            result.models = models;
+        if (Object.keys(modelSets).length > 0)
+            result.modelSets = modelSets;
+        if (profiles !== undefined)
+            result.profiles = profiles;
+        return result;
+    }, {});
+}
+function mergeProfiles(base, next) {
+    if (!base && !next) {
+        return undefined;
+    }
+    const result = { ...(base ?? {}) };
+    for (const [name, profile] of Object.entries(next ?? {})) {
+        const previous = result[name];
+        const mergedProfile = {
+            roles: {
+                ...(previous?.roles ?? {}),
+                ...profile.roles,
+            },
+        };
+        const extendedFrom = profile.extends ?? previous?.extends;
+        const effort = profile.effort ?? previous?.effort;
+        if (extendedFrom !== undefined)
+            mergedProfile.extends = extendedFrom;
+        if (effort !== undefined)
+            mergedProfile.effort = effort;
+        result[name] = mergedProfile;
+    }
+    return result;
+}
+export function loadRemiConfig(options = {}) {
+    const sources = configPaths(options);
+    const diagnostics = [];
+    const env = options.env ?? process.env;
+    const envConfig = createClaudeCodeEnvConfig(env);
+    const envSource = { kind: 'env', path: 'environment:claude-code', exists: hasConfigContent(envConfig) };
+    const configs = envSource.exists ? [envConfig] : [];
+    for (const source of sources) {
+        if (!source.exists) {
+            continue;
+        }
+        try {
+            configs.push(parseConfigFile(source.path));
+        }
+        catch (error) {
+            diagnostics.push({
+                level: 'error',
+                path: source.path,
+                message: error instanceof Error ? error.message : 'Failed to parse config file',
+            });
+        }
+    }
+    return {
+        config: mergeRemiConfig(...configs),
+        sources: [envSource, ...sources],
+        diagnostics,
+    };
+}
+function createClaudeCodeModelConfig(model) {
+    const lower = model.toLowerCase();
+    const isDeepSeek = lower.includes('deepseek');
+    const isSmall = lower.includes('small') || lower.includes('haiku') || lower.includes('flash') || lower.includes('chat');
+    return {
+        provider: 'claudeCode',
+        model,
+        displayName: model,
+        contextWindow: isDeepSeek ? 1_000_000 : 200_000,
+        maxOutputTokens: isDeepSeek ? 384_000 : 64_000,
+        supportsTools: true,
+        supportsReasoning: !isSmall,
+        tokenEstimator: isDeepSeek ? 'deepseek-local-tokenizer' : 'anthropic-count-tokens',
+        tokenEstimateProfile: isDeepSeek ? 'code-heavy' : 'default',
+        usageShape: 'anthropic-compatible',
+        cacheUsageShape: 'anthropic-cache-input',
+    };
+}
+function hasConfigContent(config) {
+    return Boolean(config.activeProfile ||
+        config.language ||
+        config.responseStyle ||
+        config.syntaxTheme ||
+        config.statusLine ||
+        config.permissions ||
+        config.agent ||
+        config.skills ||
+        Object.keys(config.providers ?? {}).length > 0 ||
+        Object.keys(config.models ?? {}).length > 0 ||
+        Object.keys(config.modelSets ?? {}).length > 0 ||
+        Object.keys(config.profiles ?? {}).length > 0);
+}
+function parseConfigFile(path) {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isRecord(parsed)) {
+        throw new Error('Config root must be a JSON object');
+    }
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function uniqueStrings(values) {
+    const unique = Array.from(new Set(values.map(value => value.trim()).filter(Boolean)));
+    return unique.length > 0 ? unique : undefined;
+}

package/node_modules/@remi/config/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@remi/config",
+  "version": "0.0.1-alpha",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  }
+}