@renxqoo/renx-code 0.0.3 → 0.0.5

package/vendor/agent-root/src/agent/utils/__tests__/message.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, it } from 'vitest';
+import type { Message } from '../../types';
+import {
+  contentToText,
+  getAssistantToolCalls,
+  getToolCallId,
+  isSummaryMessage,
+  processToolCallPairs,
+  rebuildMessages,
+  splitMessages,
+  stringifyContentPart,
+} from '../message';
+
+function createMessage(partial: Partial<Message>): Message {
+  return {
+    messageId: partial.messageId || crypto.randomUUID(),
+    type: partial.type || 'assistant-text',
+    role: partial.role || 'assistant',
+    content: partial.content || '',
+    timestamp: partial.timestamp ?? Date.now(),
+    ...partial,
+  };
+}
+
+describe('message utils', () => {
+  it('contentToText handles empty, string and multimodal content', () => {
+    expect(contentToText(undefined)).toBe('');
+    expect(contentToText('hello')).toBe('hello');
+
+    expect(
+      contentToText([
+        { type: 'text', text: 'line1' },
+        { type: 'image_url', image_url: { url: 'http://img' } },
+        { type: 'file', file: { filename: 'a.txt' } },
+        { type: 'input_audio', input_audio: { data: 'x', format: 'mp3' } },
+        { type: 'input_video', input_video: { file_id: 'v1' } },
+      ])
+    ).toBe('line1\n[image] http://img\n[file] a.txt\n[audio]\n[video] v1');
+  });
+
+  it('stringifyContentPart returns empty string for unknown part', () => {
+    expect(stringifyContentPart({ type: 'text', text: 'x' })).toBe('x');
+    expect(stringifyContentPart({ type: 'image_url', image_url: { url: 'u' } })).toBe('[image] u');
+    expect(stringifyContentPart({ type: 'file', file: { file_id: 'f1' } })).toBe('[file] f1');
+    expect(
+      stringifyContentPart({ type: 'input_audio', input_audio: { data: 'd', format: 'wav' } })
+    ).toBe('[audio]');
+    expect(stringifyContentPart({ type: 'input_video', input_video: { url: 'v' } })).toBe(
+      '[video] v'
+    );
+    expect(stringifyContentPart({ type: 'unknown' } as never)).toBe('');
+  });
+
+  it('assistant tool call and tool_call_id helpers return expected values', () => {
+    const assistantWithCalls = createMessage({
+      role: 'assistant',
+      type: 'tool-call',
+      tool_calls: [
+        { id: 'call_1', type: 'function', index: 0, function: { name: 'x', arguments: '{}' } },
+        { id: 'call_2', type: 'function', index: 1, function: { name: 'y', arguments: '{}' } },
+      ],
+    });
+    const toolMessage = createMessage({
+      role: 'tool',
+      type: 'tool-result',
+      tool_call_id: 'call_1',
+      content: 'ok',
+    });
+    const userMessage = createMessage({ role: 'user', type: 'user', content: 'u' });
+
+    expect(getAssistantToolCalls(assistantWithCalls)).toEqual([{ id: 'call_1' }, { id: 'call_2' }]);
+    expect(getAssistantToolCalls(userMessage)).toEqual([]);
+    expect(getToolCallId(toolMessage)).toBe('call_1');
+    expect(getToolCallId(userMessage)).toBeUndefined();
+  });
+
+  it('recognizes summary message prefixes', () => {
+    expect(
+      isSummaryMessage(
+        createMessage({
+          role: 'assistant',
+          type: 'summary',
+          content: '[Conversation Summary]\nabc',
+        })
+      )
+    ).toBe(true);
+    expect(
+      isSummaryMessage(
+        createMessage({
+          role: 'assistant',
+          type: 'summary',
+          content: '[对话摘要]\nabc',
+        })
+      )
+    ).toBe(true);
+    expect(
+      isSummaryMessage(
+        createMessage({ role: 'assistant', type: 'assistant-text', content: 'normal' })
+      )
+    ).toBe(false);
+  });
+
+  it('splitMessages preserves system and adjusts split point to last user', () => {
+    const messages: Message[] = [
+      createMessage({
+        messageId: 's',
+        type: 'system',
+        role: 'system',
+        content: 'sys',
+        timestamp: 1,
+      }),
+      createMessage({
+        messageId: 'a0',
+        type: 'assistant-text',
+        role: 'assistant',
+        content: 'a0',
+        timestamp: 2,
+      }),
+      createMessage({ messageId: 'u1', type: 'user', role: 'user', content: 'u1', timestamp: 3 }),
+      createMessage({
+        messageId: 'a2',
+        type: 'assistant-text',
+        role: 'assistant',
+        content: 'a2',
+        timestamp: 4,
+      }),
+      createMessage({
+        messageId: 'a3',
+        type: 'assistant-text',
+        role: 'assistant',
+        content: 'a3',
+        timestamp: 5,
+      }),
+    ];
+
+    const result = splitMessages(messages, 1);
+    expect(result.systemMessage?.messageId).toBe('s');
+    expect(result.pending.map((m) => m.messageId)).toEqual(['a0']);
+    expect(result.active.map((m) => m.messageId)).toEqual(['u1', 'a2', 'a3']);
+  });
+
+  it('processToolCallPairs keeps assistant/tool pairs together', () => {
+    const assistantPending = createMessage({
+      messageId: 'a_pending',
+      role: 'assistant',
+      type: 'tool-call',
+      tool_calls: [
+        { id: 'c1', type: 'function', index: 0, function: { name: 'bash', arguments: '{}' } },
+      ],
+    });
+    const pendingTool = createMessage({
+      messageId: 't_pending',
+      role: 'tool',
+      type: 'tool-result',
+      tool_call_id: 'c1',
+      content: 'pending',
+    });
+    const pendingUser = createMessage({
+      messageId: 'u_pending',
+      role: 'user',
+      type: 'user',
+      content: 'u',
+    });
+    const activeTool = createMessage({
+      messageId: 't_active',
+      role: 'tool',
+      type: 'tool-result',
+      tool_call_id: 'c1',
+      content: 'active',
+    });
+    const activeUser = createMessage({
+      messageId: 'u_active',
+      role: 'user',
+      type: 'user',
+      content: 'u2',
+    });
+
+    const result = processToolCallPairs(
+      [assistantPending, pendingTool, pendingUser],
+      [activeTool, activeUser]
+    );
+
+    expect(result.pending.map((m) => m.messageId)).toEqual(['u_pending']);
+    expect(result.active.map((m) => m.messageId)).toEqual(['a_pending', 't_active', 'u_active']);
+  });
+
+  it('processToolCallPairs returns original arrays when no active tools need pairing', () => {
+    const pending = [createMessage({ messageId: 'p1', role: 'user', type: 'user', content: 'p1' })];
+    const active = [
+      createMessage({ messageId: 'a1', role: 'assistant', type: 'assistant-text', content: 'a1' }),
+    ];
+    const result = processToolCallPairs(pending, active);
+    expect(result.pending).toBe(pending);
+    expect(result.active).toBe(active);
+  });
+
+  it('rebuildMessages combines system, summary and active messages in order', () => {
+    const system = createMessage({
+      messageId: 's',
+      role: 'system',
+      type: 'system',
+      content: 'sys',
+    });
+    const summary = createMessage({
+      messageId: 'sum',
+      role: 'assistant',
+      type: 'summary',
+      content: 'summary',
+    });
+    const active = [
+      createMessage({ messageId: 'u1', role: 'user', type: 'user', content: 'u1' }),
+      createMessage({ messageId: 'a1', role: 'assistant', type: 'assistant-text', content: 'a1' }),
+    ];
+
+    expect(rebuildMessages(system, summary, active).map((m) => m.messageId)).toEqual([
+      's',
+      'sum',
+      'u1',
+      'a1',
+    ]);
+    expect(rebuildMessages(undefined, null, active).map((m) => m.messageId)).toEqual(['u1', 'a1']);
+  });
+});

package/vendor/agent-root/src/agent/utils/__tests__/token.test.ts

@@ -0,0 +1,42 @@
+/**
+ * estimateTokens 测试
+ */
+
+import { describe, it, expect } from 'vitest';
+import { estimateTokens } from '../token';
+
+describe('estimateTokens', () => {
+  it('should return 0 for empty string', () => {
+    expect(estimateTokens('')).toBe(0);
+  });
+
+  it('should return 1 for whitespace-only short text', () => {
+    expect(estimateTokens('   ')).toBe(1);
+  });
+
+  it('should estimate English text correctly', () => {
+    const text = 'Hello world this is a test';
+    expect(estimateTokens(text)).toBe(7);
+  });
+
+  it('should estimate Chinese text correctly', () => {
+    const text = '你好世界这是一个测试';
+    expect(estimateTokens(text)).toBe(15);
+  });
+
+  it('should estimate mixed text within reasonable range', () => {
+    const text = 'Hello 你好 World 世界';
+    const tokens = estimateTokens(text);
+    expect(tokens).toBeGreaterThanOrEqual(9);
+    expect(tokens).toBeLessThanOrEqual(10);
+  });
+
+  it('should handle special characters', () => {
+    const text = '!@#$%^&*()';
+    expect(estimateTokens(text)).toBe(3);
+  });
+
+  it('should round up fractional token counts', () => {
+    expect(estimateTokens('abcde')).toBe(2);
+  });
+});

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

@@ -0,0 +1,16 @@
+/**
+ * 工具函数导出
+ */
+
+export {
+  contentToText,
+  stringifyContentPart,
+  getAssistantToolCalls,
+  getToolCallId,
+  isSummaryMessage,
+  splitMessages,
+  processToolCallPairs,
+  rebuildMessages,
+} from './message';
+
+export { estimateTokens } from './token';

package/vendor/agent-root/src/agent/utils/message.ts

@@ -0,0 +1,171 @@
+/**
+ * Message utility helpers for renx.
+ */
+
+import type { InputContentPart, MessageContent } from '../../providers';
+import type { Message } from '../types';
+
+type ToolCallLike = { id?: string };
+
+export function contentToText(content: MessageContent | undefined): string {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+
+  return content
+    .map((part) => stringifyContentPart(part))
+    .filter(Boolean)
+    .join('\n');
+}
+
+export function stringifyContentPart(part: InputContentPart): string {
+  switch (part.type) {
+    case 'text':
+      return part.text || '';
+    case 'image_url':
+      return `[image] ${part.image_url?.url || ''}`.trim();
+    case 'file':
+      return `[file] ${part.file?.filename || part.file?.file_id || ''}`.trim();
+    case 'input_audio':
+      return '[audio]';
+    case 'input_video':
+      return `[video] ${part.input_video?.url || part.input_video?.file_id || ''}`.trim();
+    default:
+      return '';
+  }
+}
+
+export function getAssistantToolCalls(message: Message): ToolCallLike[] {
+  if (message.role !== 'assistant') return [];
+  const rawToolCalls = message.tool_calls;
+  if (!Array.isArray(rawToolCalls)) return [];
+  return rawToolCalls.map((call) => ({ id: call.id }));
+}
+
+export function getToolCallId(message: Message): string | undefined {
+  if (message.role !== 'tool') return undefined;
+  const toolCallId = message.tool_call_id;
+  return typeof toolCallId === 'string' ? toolCallId : undefined;
+}
+
+export function isSummaryMessage(message: Message): boolean {
+  const text = contentToText(message.content);
+  return text.startsWith('[Conversation Summary]') || text.startsWith('[对话摘要]');
+}
+
+export function splitMessages(
+  messages: Message[],
+  keepMessagesNum: number
+): {
+  systemMessage: Message | undefined;
+  pending: Message[];
+  active: Message[];
+} {
+  const systemMessage = messages.find((m) => m.role === 'system');
+  const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+
+  let lastUserIndex = -1;
+  for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+    if (nonSystemMessages[i].role === 'user') {
+      lastUserIndex = i;
+      break;
+    }
+  }
+
+  let splitPoint = nonSystemMessages.length - keepMessagesNum;
+  if (lastUserIndex !== -1 && lastUserIndex < splitPoint) {
+    splitPoint = lastUserIndex;
+  }
+  splitPoint = Math.max(0, splitPoint);
+
+  return {
+    systemMessage,
+    pending: nonSystemMessages.slice(0, splitPoint),
+    active: nonSystemMessages.slice(splitPoint),
+  };
+}
+
+export function processToolCallPairs(
+  pending: Message[],
+  active: Message[]
+): { pending: Message[]; active: Message[] } {
+  const toolCallToAssistant = new Map<string, Message>();
+
+  for (const msg of [...pending, ...active]) {
+    for (const call of getAssistantToolCalls(msg)) {
+      if (call.id) {
+        toolCallToAssistant.set(call.id, msg);
+      }
+    }
+  }
+
+  const toolsNeedingPair = active.filter((msg) => {
+    if (msg.role !== 'tool') return false;
+    const toolCallId = getToolCallId(msg);
+    return typeof toolCallId === 'string' && toolCallToAssistant.has(toolCallId);
+  });
+
+  if (toolsNeedingPair.length === 0) {
+    return { pending, active };
+  }
+
+  const assistantsToMove = new Set<Message>();
+  const toolCallIdsToMove = new Set<string>();
+
+  for (const toolMsg of toolsNeedingPair) {
+    const toolCallId = getToolCallId(toolMsg);
+    if (!toolCallId) continue;
+    const assistantMsg = toolCallToAssistant.get(toolCallId);
+    if (assistantMsg) {
+      assistantsToMove.add(assistantMsg);
+      toolCallIdsToMove.add(toolCallId);
+    }
+  }
+
+  const newPending = pending.filter((msg) => {
+    if (assistantsToMove.has(msg)) return false;
+    if (msg.role === 'tool') {
+      const toolCallId = getToolCallId(msg);
+      if (toolCallId && toolCallIdsToMove.has(toolCallId)) return false;
+    }
+    return true;
+  });
+
+  const newActive: Message[] = [];
+  const addedMessages = new Set<Message>();
+
+  for (const assistantMsg of assistantsToMove) {
+    newActive.push(assistantMsg);
+    addedMessages.add(assistantMsg);
+
+    for (const call of getAssistantToolCalls(assistantMsg)) {
+      if (call.id) {
+        const toolMsg = active.find((m) => m.role === 'tool' && getToolCallId(m) === call.id);
+        if (toolMsg && !addedMessages.has(toolMsg)) {
+          newActive.push(toolMsg);
+          addedMessages.add(toolMsg);
+        }
+      }
+    }
+  }
+
+  for (const msg of active) {
+    if (!addedMessages.has(msg)) {
+      newActive.push(msg);
+    }
+  }
+
+  return { pending: newPending, active: newActive };
+}
+
+export function rebuildMessages(
+  systemMessage: Message | undefined,
+  summaryMessage: Message | null,
+  active: Message[]
+): Message[] {
+  const messages: Message[] = [];
+  if (systemMessage) messages.push(systemMessage);
+  if (summaryMessage) messages.push(summaryMessage);
+  messages.push(...active);
+  return messages;
+}

package/vendor/agent-root/src/agent/utils/token.ts

@@ -0,0 +1,28 @@
+/**
+ * Token 估算工具
+ */
+
+/**
+ * 估算文本 Token 数
+ *
+ * 算法说明：
+ * - 中文字符（Unicode \u4e00-\u9fa5）：1 字符 ≈ 1.5 token
+ * - 其他字符（英文、数字、符号等）：1 字符 ≈ 0.25 token
+ */
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+
+  let cnCount = 0;
+  let otherCount = 0;
+
+  for (const char of text) {
+    if (char >= '\u4e00' && char <= '\u9fa5') {
+      cnCount++;
+    } else {
+      otherCount++;
+    }
+  }
+
+  const totalTokens = cnCount * 1.5 + otherCount * 0.25;
+  return Math.ceil(totalTokens);
+}

package/vendor/agent-root/src/config/__tests__/load-config-to-env.test.ts

@@ -0,0 +1,129 @@
+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 { loadConfigToEnv } from '../loader';
+
+describe('loadConfigToEnv', () => {
+  let tmpDir: string;
+  let globalDir: string;
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'renx-env-test-'));
+    globalDir = path.join(tmpDir, '.renx-global');
+    process.env = { ...originalEnv };
+
+    delete process.env.AGENT_LOG_LEVEL;
+    delete process.env.AGENT_LOG_FORMAT;
+    delete process.env.AGENT_LOG_FILE_ENABLED;
+    delete process.env.AGENT_LOG_CONSOLE;
+    delete process.env.AGENT_FILE_HISTORY_ENABLED;
+    delete process.env.AGENT_FILE_HISTORY_MAX_PER_FILE;
+    delete process.env.AGENT_FILE_HISTORY_MAX_AGE_DAYS;
+    delete process.env.AGENT_FILE_HISTORY_MAX_TOTAL_MB;
+    delete process.env.AGENT_TOOL_CONFIRMATION_MODE;
+    delete process.env.AGENT_MODEL;
+    delete process.env.AGENT_MAX_STEPS;
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should load global config.json into env', () => {
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({
+        log: { level: 'DEBUG', format: 'json', file: true },
+        agent: { defaultModel: 'gpt-5.4' },
+      })
+    );
+
+    const files = loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    expect(files).toHaveLength(1);
+    expect(process.env.AGENT_LOG_LEVEL).toBe('DEBUG');
+    expect(process.env.AGENT_LOG_FORMAT).toBe('json');
+    expect(process.env.AGENT_LOG_FILE_ENABLED).toBe('true');
+    expect(process.env.AGENT_MODEL).toBe('gpt-5.4');
+  });
+
+  it('should load project config.json over global', () => {
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({ log: { level: 'INFO' }, agent: { defaultModel: 'glm-5' } })
+    );
+
+    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: 'gpt-5.3' } })
+    );
+
+    const files = loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    expect(files).toHaveLength(2);
+    expect(process.env.AGENT_LOG_LEVEL).toBe('ERROR');
+    expect(process.env.AGENT_MODEL).toBe('gpt-5.3');
+  });
+
+  it('should not override existing env vars', () => {
+    process.env.AGENT_LOG_LEVEL = 'WARN';
+
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({ log: { level: 'DEBUG' } })
+    );
+
+    loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    expect(process.env.AGENT_LOG_LEVEL).toBe('WARN');
+  });
+
+  it('should initialize global config.json when no config files exist', () => {
+    const files = loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+    expect(files).toEqual([path.join(globalDir, 'config.json')]);
+    expect(fs.existsSync(path.join(globalDir, 'config.json'))).toBe(true);
+    expect(process.env.AGENT_MODEL).toBe('qwen3.5-plus');
+    expect(process.env.AGENT_TOOL_CONFIRMATION_MODE).toBe('manual');
+  });
+
+  it('should load storage config', () => {
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({
+        storage: {
+          fileHistory: { enabled: false, maxPerFile: 50 },
+        },
+      })
+    );
+
+    loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    expect(process.env.AGENT_FILE_HISTORY_ENABLED).toBe('false');
+    expect(process.env.AGENT_FILE_HISTORY_MAX_PER_FILE).toBe('50');
+  });
+
+  it('should load agent config', () => {
+    fs.mkdirSync(globalDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(globalDir, 'config.json'),
+      JSON.stringify({
+        agent: { confirmationMode: 'manual', defaultModel: 'qwen3.5-max', maxSteps: 100 },
+      })
+    );
+
+    loadConfigToEnv({ projectRoot: tmpDir, globalDir });
+
+    expect(process.env.AGENT_TOOL_CONFIRMATION_MODE).toBe('manual');
+    expect(process.env.AGENT_MODEL).toBe('qwen3.5-max');
+    expect(process.env.AGENT_MAX_STEPS).toBe('100');
+  });
+});