@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/config/__tests__/loader.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  ensureConfigDirs,
+  getGlobalConfigDir,
+  getGlobalConfigPath,
+  getProjectConfigDir,
+  getProjectConfigPath,
+  loadConfig,
+  writeGlobalConfig,
+  writeProjectConfig,
+} from '../loader';
+import { LogLevel } from '../../logger';
+
+describe('Renx Config Loader', () => {
+  let tmpDir: string;
+  let globalDir: string;
+  let renxHome: string;
+  const originalRenxHome = process.env.RENX_HOME;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'renx-config-test-'));
+    renxHome = path.join(tmpDir, 'renx-home');
+    globalDir = path.join(tmpDir, '.renx-global');
+    process.env.RENX_HOME = renxHome;
+  });
+
+  afterEach(() => {
+    if (originalRenxHome === undefined) {
+      delete process.env.RENX_HOME;
+    } else {
+      process.env.RENX_HOME = originalRenxHome;
+    }
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('path helpers', () => {
+    it('should return global config dir', () => {
+      expect(getGlobalConfigDir()).toBe(renxHome);
+    });
+
+    it('should return project config dir', () => {
+      expect(getProjectConfigDir(path.join(path.sep, 'my', 'project'))).toBe(
+        path.join(path.sep, 'my', 'project', '.renx')
+      );
+    });
+
+    it('should return global config path', () => {
+      expect(getGlobalConfigPath()).toBe(path.join(renxHome, 'config.json'));
+    });
+
+    it('should return project config path', () => {
+      expect(getProjectConfigPath(path.join(path.sep, 'my', 'project'))).toBe(
+        path.join(path.sep, 'my', 'project', '.renx', 'config.json')
+      );
+    });
+  });
+
+  describe('loadConfig with defaults', () => {
+    it('should initialize and load default global config when no files exist', () => {
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        loadEnv: false,
+        env: { RENX_HOME: renxHome },
+      });
+
+      expect(config.log.level).toBe(LogLevel.INFO);
+      expect(config.log.format).toBe('pretty');
+      expect(config.log.console).toBe(false);
+      expect(config.log.file).toBe(true);
+      expect(config.agent.maxSteps).toBe(10000);
+      expect(config.agent.confirmationMode).toBe('manual');
+      expect(config.agent.defaultModel).toBe('qwen3.5-plus');
+      expect(config.storage.fileHistory.enabled).toBe(true);
+      expect(config.sources.global).toBe(path.join(globalDir, 'config.json'));
+      expect(config.sources.project).toBeNull();
+      expect(fs.existsSync(path.join(globalDir, 'config.json'))).toBe(true);
+    });
+  });
+
+  describe('loadConfig with global config', () => {
+    it('should merge global config over defaults', () => {
+      fs.mkdirSync(globalDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(globalDir, 'config.json'),
+        JSON.stringify({
+          log: { level: 'DEBUG', format: 'json' },
+          agent: { defaultModel: 'gpt-5.3' },
+        })
+      );
+
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        loadEnv: false,
+        env: { RENX_HOME: renxHome },
+      });
+
+      expect(config.log.level).toBe(LogLevel.DEBUG);
+      expect(config.log.format).toBe('json');
+      expect(config.agent.defaultModel).toBe('gpt-5.3');
+      expect(config.log.console).toBe(false);
+      expect(config.agent.maxSteps).toBe(10000);
+      expect(config.sources.global).toBe(path.join(globalDir, 'config.json'));
+      expect(config.sources.project).toBeNull();
+    });
+  });
+
+  describe('loadConfig with project config', () => {
+    it('should merge project config over global config', () => {
+      fs.mkdirSync(globalDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(globalDir, 'config.json'),
+        JSON.stringify({
+          log: { level: 'DEBUG', format: 'json' },
+          agent: { defaultModel: 'gpt-5.3', maxSteps: 100 },
+        })
+      );
+
+      const projectConfigDir = path.join(tmpDir, '.renx');
+      fs.mkdirSync(projectConfigDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(projectConfigDir, 'config.json'),
+        JSON.stringify({
+          log: { level: 'ERROR' },
+          agent: { defaultModel: 'openrouter/hunter-alpha' },
+        })
+      );
+
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        loadEnv: false,
+        env: { RENX_HOME: renxHome },
+      });
+
+      expect(config.log.level).toBe(LogLevel.ERROR);
+      expect(config.agent.defaultModel).toBe('openrouter/hunter-alpha');
+      expect(config.log.format).toBe('json');
+      expect(config.agent.maxSteps).toBe(100);
+      expect(config.sources.global).toBe(path.join(globalDir, 'config.json'));
+      expect(config.sources.project).toBe(path.join(projectConfigDir, 'config.json'));
+    });
+  });
+
+  describe('loadConfig with env overrides', () => {
+    it('should apply env overrides over file configs', () => {
+      const projectConfigDir = path.join(tmpDir, '.renx');
+      fs.mkdirSync(projectConfigDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(projectConfigDir, 'config.json'),
+        JSON.stringify({
+          log: { level: 'INFO' },
+          agent: { defaultModel: 'glm-5' },
+        })
+      );
+
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        env: {
+          RENX_HOME: renxHome,
+          AGENT_LOG_LEVEL: 'FATAL',
+          AGENT_MODEL: 'qwen3.5-max',
+          AGENT_TOOL_CONFIRMATION_MODE: 'manual',
+        },
+      });
+
+      expect(config.log.level).toBe(LogLevel.FATAL);
+      expect(config.agent.defaultModel).toBe('qwen3.5-max');
+      expect(config.agent.confirmationMode).toBe('manual');
+    });
+
+    it('should use AGENT_* env vars directly', () => {
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        env: {
+          RENX_HOME: renxHome,
+          AGENT_LOG_LEVEL: 'WARN',
+          AGENT_LOG_FORMAT: 'json',
+          AGENT_TOOL_CONFIRMATION_MODE: 'auto-deny',
+        },
+      });
+
+      expect(config.log.level).toBe(LogLevel.WARN);
+      expect(config.log.format).toBe('json');
+      expect(config.agent.confirmationMode).toBe('auto-deny');
+    });
+  });
+
+  describe('writeProjectConfig', () => {
+    it('should write project config file', () => {
+      const configPath = writeProjectConfig(
+        { log: { level: 'DEBUG' }, agent: { defaultModel: 'gpt-5.3' } },
+        tmpDir
+      );
+
+      expect(fs.existsSync(configPath)).toBe(true);
+      const content = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      expect(content.log.level).toBe('DEBUG');
+      expect(content.agent.defaultModel).toBe('gpt-5.3');
+    });
+  });
+
+  describe('writeGlobalConfig', () => {
+    it('should write global config file', () => {
+      const configPath = writeGlobalConfig({ log: { level: 'WARN' } });
+
+      expect(fs.existsSync(configPath)).toBe(true);
+      const content = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      expect(content.log.level).toBe('WARN');
+    });
+  });
+
+  describe('ensureConfigDirs', () => {
+    it('should create config directories', () => {
+      ensureConfigDirs(tmpDir);
+
+      expect(fs.existsSync(path.join(tmpDir, '.renx'))).toBe(true);
+      expect(fs.existsSync(renxHome)).toBe(true);
+    });
+  });
+
+  describe('resolved paths', () => {
+    it('should resolve runtime paths under RENX_HOME', () => {
+      const config = loadConfig({
+        projectRoot: tmpDir,
+        globalDir,
+        loadEnv: false,
+        env: { RENX_HOME: renxHome },
+      });
+
+      expect(path.isAbsolute(config.log.dir)).toBe(true);
+      expect(path.isAbsolute(config.log.filePath)).toBe(true);
+      expect(path.isAbsolute(config.storage.root)).toBe(true);
+      expect(path.isAbsolute(config.db.path)).toBe(true);
+      expect(config.log.dir).toBe(path.join(renxHome, 'logs'));
+      expect(config.storage.root).toBe(path.join(renxHome, 'storage'));
+      expect(config.db.path).toBe(path.join(renxHome, 'data.db'));
+      expect(config.log.filePath.startsWith(path.join(renxHome, 'logs'))).toBe(true);
+    });
+  });
+});

package/vendor/agent-root/src/config/__tests__/runtime.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createLoggerFromEnv, loadEnvFiles, loadRuntimeConfigFromEnv } from '../runtime';
+
+describe('runtime config from env', () => {
+  const loggers: Array<ReturnType<typeof createLoggerFromEnv>> = [];
+  const tempDirs: string[] = [];
+
+  afterEach(async () => {
+    for (const logger of loggers.splice(0, loggers.length)) {
+      logger.close();
+    }
+
+    for (const dir of tempDirs.splice(0, tempDirs.length)) {
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+
+    delete process.env.AGENT_LOG_LEVEL;
+    delete process.env.RENX_HOME;
+  });
+
+  it('should load default runtime logging config', () => {
+    const config = loadRuntimeConfigFromEnv({});
+
+    expect(config.log.consoleEnabled).toBe(false);
+    expect(config.log.fileEnabled).toBe(true);
+    expect(config.log.format).toBe('pretty');
+    expect(config.log.filePath.endsWith('.log')).toBe(true);
+  });
+
+  it('should derive logging paths from RENX_HOME', async () => {
+    const renxHome = await fs.mkdtemp(path.join(os.tmpdir(), 'renx-home-'));
+    tempDirs.push(renxHome);
+    const config = loadRuntimeConfigFromEnv({
+      RENX_HOME: renxHome,
+      AGENT_LOG_LEVEL: 'debug',
+      AGENT_LOG_CONSOLE: '0',
+      AGENT_LOG_FILE_ENABLED: '1',
+      AGENT_LOG_FORMAT: 'json',
+    });
+
+    expect(config.log.level).toBe(10);
+    expect(config.log.consoleEnabled).toBe(false);
+    expect(config.log.fileEnabled).toBe(true);
+    expect(config.log.filePath.startsWith(path.join(renxHome, 'logs'))).toBe(true);
+    expect(config.log.format).toBe('json');
+  });
+
+  it('should throw on invalid log level', () => {
+    expect(() => loadRuntimeConfigFromEnv({ AGENT_LOG_LEVEL: 'verbose' })).toThrow(
+      'Invalid AGENT_LOG_LEVEL'
+    );
+  });
+
+  it('should throw on invalid log format', () => {
+    expect(() => loadRuntimeConfigFromEnv({ AGENT_LOG_FORMAT: 'xml' })).toThrow(
+      'Invalid AGENT_LOG_FORMAT'
+    );
+  });
+
+  it('should load env files', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'config-test-'));
+    tempDirs.push(tmpDir);
+
+    await fs.writeFile(
+      path.join(tmpDir, '.env'),
+      'AGENT_LOG_LEVEL=debug\nRENX_HOME=./custom-home\n'
+    );
+
+    const loaded = await loadEnvFiles(tmpDir, { files: ['.env'], override: true });
+    expect(loaded).toHaveLength(1);
+    expect(process.env.AGENT_LOG_LEVEL).toBe('debug');
+    expect(process.env.RENX_HOME).toBe('./custom-home');
+  });
+
+  it('should create logger from env', () => {
+    const logger = createLoggerFromEnv({
+      AGENT_LOG_LEVEL: 'info',
+      AGENT_LOG_CONSOLE: 'true',
+    });
+    loggers.push(logger);
+    expect(logger).toBeDefined();
+    expect(typeof logger.info).toBe('function');
+    expect(typeof logger.error).toBe('function');
+  });
+});

package/vendor/agent-root/src/config/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Renx config module.
+ *
+ * Sources:
+ * - global config: ~/.renx/config.json (or RENX_HOME/config.json)
+ * - project config: <project>/.renx/config.json
+ * - environment variables
+ *
+ * Effective precedence:
+ * env > project config > global config > defaults
+ */
+
+// Type exports
+export type {
+  RenxConfig,
+  ResolvedConfig,
+  LoadConfigOptions,
+  LogConfig,
+  StorageConfig,
+  FileHistoryConfig,
+  AgentConfig,
+} from './types';
+
+// Config loaders
+export {
+  loadConfig,
+  loadConfigToEnv,
+  getGlobalConfigDir,
+  getProjectConfigDir,
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  ensureConfigDirs,
+  writeProjectConfig,
+  writeGlobalConfig,
+} from './loader';
+
+// Runtime env helpers
+export type { LogFormat, RuntimeLogConfig, RuntimeConfig, LoadEnvFilesOptions } from './runtime';
+
+export {
+  loadEnvFiles,
+  loadRuntimeConfigFromEnv,
+  createLoggerFromRuntimeConfig,
+  createLoggerFromEnv,
+} from './runtime';
+
+export {
+  RENX_HOME_ENV,
+  resolveRenxHome,
+  resolveRenxLogsDir,
+  resolveRenxStorageRoot,
+  resolveRenxTaskDir,
+  resolveRenxDatabasePath,
+} from './paths';