@renxqoo/renx-code 0.0.9 → 0.0.10

package/vendor/agent-root/src/agent/agent/__test__/compaction.test.ts

@@ -1,323 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { LLMProvider } from '../../../providers';
-import type { Message } from '../../types';
-
-const encodeMock = vi.hoisted(() =>
-  vi.fn((text: string) => Array.from(text).map((_ch, index) => index))
-);
-
-vi.mock('js-tiktoken', () => ({
-  getEncoding: vi.fn(() => ({
-    encode: encodeMock,
-  })),
-}));
-
-import { compact, estimateMessagesTokens, estimateTokens } from '../compaction';
-
-function createProvider(
-  overrides?: Partial<{
-    generate: LLMProvider['generate'];
-    getTimeTimeout: LLMProvider['getTimeTimeout'];
-    model: string;
-  }>
-): LLMProvider {
-  return {
-    config: { model: overrides?.model ?? 'mock-model' } as Record<string, unknown>,
-    generate:
-      overrides?.generate ||
-      (vi.fn().mockResolvedValue({
-        choices: [{ message: { content: 'mock summary' } }],
-      }) as unknown as LLMProvider['generate']),
-    generateStream: vi.fn() as unknown as LLMProvider['generateStream'],
-    getTimeTimeout: overrides?.getTimeTimeout || vi.fn(() => 50),
-    getLLMMaxTokens: vi.fn(() => 1000),
-    getMaxOutputTokens: vi.fn(() => 100),
-  } as unknown as LLMProvider;
-}
-
-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('renx compaction', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    encodeMock.mockImplementation((text: string) => Array.from(text).map((_ch, index) => index));
-  });
-
-  it('estimateTokens uses tiktoken encoder output length', () => {
-    expect(estimateTokens('abc')).toBe(3);
-    expect(estimateTokens('')).toBe(0);
-    expect(encodeMock).toHaveBeenCalledWith('abc');
-  });
-
-  it('estimateTokens falls back to heuristic when encoder throws', () => {
-    encodeMock.mockImplementationOnce(() => {
-      throw new Error('encode failed');
-    });
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-
-    expect(estimateTokens('中文ab')).toBe(5);
-    expect(warnSpy).toHaveBeenCalled();
-    warnSpy.mockRestore();
-  });
-
-  it('estimateMessagesTokens applies different costs for low/high image detail', () => {
-    const lowImageMessage = createMessage({
-      role: 'user',
-      type: 'user',
-      content: [{ type: 'image_url', image_url: { url: 'u', detail: 'low' } }],
-    });
-    const highImageMessage = createMessage({
-      role: 'user',
-      type: 'user',
-      content: [{ type: 'image_url', image_url: { url: 'u', detail: 'high' } }],
-    });
-
-    const low = estimateMessagesTokens([lowImageMessage]);
-    const high = estimateMessagesTokens([highImageMessage]);
-
-    expect(high - low).toBe(680);
-  });
-
-  it('estimateMessagesTokens includes tool_calls, tool_call_id and tools schema overhead', () => {
-    const base = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: 'hello',
-    });
-    const withToolMetadata = createMessage({
-      role: 'assistant',
-      type: 'tool-call',
-      content: 'hello',
-      tool_calls: [
-        {
-          id: 'call_1',
-          type: 'function',
-          function: { name: 'bash', arguments: '{"cmd":"echo"}' },
-        },
-      ] as Message['tool_calls'],
-      tool_call_id: 'call_1',
-    });
-
-    const withoutExtra = estimateMessagesTokens([base]);
-    const withExtra = estimateMessagesTokens([withToolMetadata], [
-      {
-        type: 'function',
-        function: { name: 'bash', description: 'run shell', parameters: { type: 'object' } },
-      },
-    ] as never);
-
-    expect(withExtra).toBeGreaterThan(withoutExtra);
-  });
-
-  it('estimateMessagesTokens counts name field and array text parts', () => {
-    const msg = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: [{ type: 'text', text: 'chunk-text' }],
-    }) as Message & { name?: string };
-    msg.name = 'assistant_name';
-
-    const baseline = createMessage({
-      role: 'assistant',
-      type: 'assistant-text',
-      content: '',
-    });
-
-    const tokensWithNameAndParts = estimateMessagesTokens([msg]);
-    const baselineTokens = estimateMessagesTokens([baseline]);
-    expect(tokensWithNameAndParts).toBeGreaterThan(baselineTokens);
-  });
-
-  it('compact builds summary and returns removed message ids', async () => {
-    const generateMock = vi.fn().mockResolvedValue({
-      choices: [{ message: { content: 'Summary text' } }],
-    });
-    const provider = createProvider({
-      generate: generateMock as unknown as LLMProvider['generate'],
-    });
-    const logger = { info: vi.fn(), warn: vi.fn() };
-    const messages: Message[] = [
-      createMessage({
-        messageId: 's1',
-        type: 'system',
-        role: 'system',
-        content: 'sys',
-        timestamp: 1,
-      }),
-      createMessage({
-        messageId: 'u1',
-        type: 'user',
-        role: 'user',
-        content: 'old question',
-        timestamp: 2,
-      }),
-      createMessage({
-        messageId: 'a1',
-        type: 'assistant-text',
-        role: 'assistant',
-        content: 'old answer',
-        timestamp: 3,
-      }),
-      createMessage({
-        messageId: 'u2',
-        type: 'user',
-        role: 'user',
-        content: 'latest question',
-        timestamp: 4,
-      }),
-    ];
-
-    const result = await compact(messages, { provider, keepMessagesNum: 1, logger });
-
-    expect(result.summaryMessage).toMatchObject({
-      role: 'assistant',
-      type: 'summary',
-    });
-    expect(String(result.summaryMessage?.content)).toContain('Summary text');
-    expect(result.removedMessageIds.sort()).toEqual(['a1', 'u1']);
-    expect(result.messages.map((m) => m.messageId)).toEqual([
-      's1',
-      result.summaryMessage!.messageId,
-      'u2',
-    ]);
-    const secondArg = (generateMock as unknown as { mock: { calls: unknown[][] } }).mock
-      .calls[0]?.[1] as {
-      model?: string;
-      abortSignal?: AbortSignal;
-    };
-    expect(secondArg.model).toBe('mock-model');
-    expect(secondArg.abortSignal).toBeDefined();
-    expect(
-      (logger.info as unknown as { mock: { calls: unknown[][] } }).mock.calls.length
-    ).toBeGreaterThan(0);
-  });
-
-  it('compact handles invalid summary response and returns null summary', async () => {
-    const provider = createProvider({
-      generate: vi.fn().mockResolvedValue(null) as unknown as LLMProvider['generate'],
-      getTimeTimeout: vi.fn(() => 0),
-    });
-    const logger = { info: vi.fn(), warn: vi.fn() };
-    const messages = [
-      createMessage({ messageId: 's1', type: 'system', role: 'system', content: 'sys' }),
-      createMessage({ messageId: 'u1', type: 'user', role: 'user', content: 'u1' }),
-      createMessage({ messageId: 'u2', type: 'user', role: 'user', content: 'u2' }),
-    ];
-
-    const result = await compact(messages, {
-      provider,
-      keepMessagesNum: 1,
-      logger,
-    });
-
-    expect(result.summaryMessage).toBeNull();
-    expect(logger.warn).toHaveBeenCalled();
-  });
-
-  it('compact skips llm summary generation when pending is empty', async () => {
-    const generateMock = vi.fn();
-    const provider = createProvider({
-      generate: generateMock as unknown as LLMProvider['generate'],
-    });
-    const messages = [
-      createMessage({ messageId: 's1', type: 'system', role: 'system', content: 'sys' }),
-      createMessage({ messageId: 'u1', type: 'user', role: 'user', content: 'u1' }),
-    ];
-
-    const result = await compact(messages, { provider, keepMessagesNum: 10 });
-
-    expect(result.summaryMessage).toBeNull();
-    expect(generateMock).not.toHaveBeenCalled();
-  });
-
-  it('compact handles provider.generate throw and logs warning', async () => {
-    const provider = createProvider({
-      generate: vi
-        .fn()
-        .mockRejectedValue(new Error('network failed')) as unknown as LLMProvider['generate'],
-    });
-    const logger = { info: vi.fn(), warn: vi.fn() };
-    const messages = [
-      createMessage({ messageId: 's1', type: 'system', role: 'system', content: 'sys' }),
-      createMessage({ messageId: 'a1', type: 'assistant-text', role: 'assistant', content: 'a1' }),
-      createMessage({ messageId: 'u1', type: 'user', role: 'user', content: 'u1' }),
-    ];
-
-    const result = await compact(messages, {
-      provider,
-      keepMessagesNum: 1,
-      logger,
-    });
-
-    expect(result.summaryMessage).toBeNull();
-    expect(logger.warn).toHaveBeenCalled();
-  });
-
-  it('compact passes previous summary block and handles empty choices response', async () => {
-    const generateMock = vi.fn().mockResolvedValue({ choices: [] });
-    const provider = createProvider({
-      generate: generateMock as unknown as LLMProvider['generate'],
-      model: '   ',
-      getTimeTimeout: vi.fn(() => 0),
-    });
-
-    const messages = [
-      createMessage({ messageId: 's1', type: 'system', role: 'system', content: 'sys' }),
-      createMessage({
-        messageId: 'sum_1',
-        type: 'summary',
-        role: 'assistant',
-        content: '[Conversation Summary]\nold summary',
-      }),
-      createMessage({ messageId: 'u2', type: 'user', role: 'user', content: 'latest' }),
-    ];
-
-    const result = await compact(messages, { provider, keepMessagesNum: 1 });
-    expect(result.summaryMessage).toBeNull();
-
-    const callArgs = (generateMock as unknown as { mock: { calls: unknown[][] } }).mock.calls[0];
-    const requestMessages = callArgs?.[0] as Array<{ role: string; content: string }>;
-    const options = callArgs?.[1] as { model?: string; abortSignal?: AbortSignal };
-    expect(requestMessages[1]?.content).toContain('<previous_summary>');
-    expect(options.model).toBeUndefined();
-    expect(options.abortSignal).toBeUndefined();
-  });
-
-  it('compact ignores AbortSignal.timeout failure and still requests summary', async () => {
-    const timeoutSpy = vi.spyOn(AbortSignal, 'timeout').mockImplementation(() => {
-      throw new Error('timeout unsupported');
-    });
-    const generateMock = vi.fn().mockResolvedValue({
-      choices: [{ message: { content: 'summary ok' } }],
-    });
-
-    const provider = createProvider({
-      generate: generateMock as unknown as LLMProvider['generate'],
-      getTimeTimeout: vi.fn(() => 10),
-    });
-
-    const messages = [
-      createMessage({ messageId: 's1', type: 'system', role: 'system', content: 'sys' }),
-      createMessage({ messageId: 'u1', type: 'user', role: 'user', content: 'old q' }),
-      createMessage({ messageId: 'u2', type: 'user', role: 'user', content: 'latest q' }),
-    ];
-
-    const result = await compact(messages, { provider, keepMessagesNum: 1 });
-    expect(result.summaryMessage?.content).toContain('summary ok');
-    const options = (generateMock as unknown as { mock: { calls: unknown[][] } }).mock
-      .calls[0]?.[1] as {
-      abortSignal?: AbortSignal;
-    };
-    expect(options.abortSignal).toBeUndefined();
-    timeoutSpy.mockRestore();
-  });
-});

package/vendor/agent-root/src/agent/agent/__test__/concurrency.test.ts

@@ -1,290 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { buildExecutionWaves, runWithConcurrencyAndLock } from '../concurrency';
-import type { ToolCall } from '../../../providers';
-import type { ToolConcurrencyPolicy } from '../../tool/types';
-
-function createToolCall(name: string, id: string = `call_${name}`): ToolCall {
-  return {
-    id,
-    type: 'function',
-    index: 0,
-    function: {
-      name,
-      arguments: '{}',
-    },
-  };
-}
-
-function createPlan(
-  toolCall: ToolCall,
-  mode: ToolConcurrencyPolicy['mode'] = 'exclusive',
-  lockKey?: string
-): { toolCall: ToolCall; policy: ToolConcurrencyPolicy } {
-  return {
-    toolCall,
-    policy: { mode, lockKey },
-  };
-}
-
-describe('buildExecutionWaves', () => {
-  it('returns empty array for empty input', () => {
-    expect(buildExecutionWaves([])).toEqual([]);
-  });
-
-  it('creates exclusive wave for single exclusive plan', () => {
-    const plan = createPlan(createToolCall('bash'));
-    const waves = buildExecutionWaves([plan]);
-
-    expect(waves).toHaveLength(1);
-    expect(waves[0].type).toBe('exclusive');
-    expect(waves[0].plans).toHaveLength(1);
-    expect(waves[0].plans[0]).toBe(plan);
-  });
-
-  it('creates parallel wave for single parallel-safe plan', () => {
-    const plan = createPlan(createToolCall('file_read'), 'parallel-safe');
-    const waves = buildExecutionWaves([plan]);
-
-    expect(waves).toHaveLength(1);
-    expect(waves[0].type).toBe('parallel');
-    expect(waves[0].plans).toHaveLength(1);
-    expect(waves[0].plans[0]).toBe(plan);
-  });
-
-  it('groups consecutive parallel-safe plans into single wave', () => {
-    const plans = [
-      createPlan(createToolCall('file_read'), 'parallel-safe'),
-      createPlan(createToolCall('glob'), 'parallel-safe'),
-      createPlan(createToolCall('grep'), 'parallel-safe'),
-    ];
-
-    const waves = buildExecutionWaves(plans);
-
-    expect(waves).toHaveLength(1);
-    expect(waves[0].type).toBe('parallel');
-    expect(waves[0].plans).toHaveLength(3);
-  });
-
-  it('creates separate waves for exclusive plans', () => {
-    const plans = [
-      createPlan(createToolCall('bash'), 'exclusive'),
-      createPlan(createToolCall('write_file'), 'exclusive'),
-    ];
-
-    const waves = buildExecutionWaves(plans);
-
-    expect(waves).toHaveLength(2);
-    expect(waves[0].type).toBe('exclusive');
-    expect(waves[1].type).toBe('exclusive');
-  });
-
-  it('creates mixed waves correctly', () => {
-    const plans = [
-      createPlan(createToolCall('file_read'), 'parallel-safe'),
-      createPlan(createToolCall('bash'), 'exclusive'),
-      createPlan(createToolCall('glob'), 'parallel-safe'),
-      createPlan(createToolCall('grep'), 'parallel-safe'),
-      createPlan(createToolCall('write_file'), 'exclusive'),
-    ];
-
-    const waves = buildExecutionWaves(plans);
-
-    expect(waves).toHaveLength(4);
-    expect(waves[0].type).toBe('parallel');
-    expect(waves[0].plans).toHaveLength(1);
-    expect(waves[1].type).toBe('exclusive');
-    expect(waves[1].plans).toHaveLength(1);
-    expect(waves[2].type).toBe('parallel');
-    expect(waves[2].plans).toHaveLength(2);
-    expect(waves[3].type).toBe('exclusive');
-    expect(waves[3].plans).toHaveLength(1);
-  });
-
-  it('handles parallel-safe with lock keys', () => {
-    const plans = [
-      createPlan(createToolCall('file_read'), 'parallel-safe', 'file:read'),
-      createPlan(createToolCall('file_read'), 'parallel-safe', 'file:read'),
-      createPlan(createToolCall('file_read'), 'parallel-safe', 'file:write'),
-    ];
-
-    const waves = buildExecutionWaves(plans);
-
-    expect(waves).toHaveLength(1);
-    expect(waves[0].type).toBe('parallel');
-    expect(waves[0].plans).toHaveLength(3);
-  });
-});
-
-describe('runWithConcurrencyAndLock', () => {
-  it('returns empty array for empty tasks', async () => {
-    const result = await runWithConcurrencyAndLock([], 5);
-    expect(result).toEqual([]);
-  });
-
-  it('runs single task successfully', async () => {
-    const task = { run: vi.fn().mockResolvedValue('result') };
-    const result = await runWithConcurrencyAndLock([task], 5);
-
-    expect(result).toEqual(['result']);
-    expect(task.run).toHaveBeenCalledOnce();
-  });
-
-  it('runs multiple tasks concurrently within limit', async () => {
-    const executionOrder: string[] = [];
-    const tasks = [
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task1-start');
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          executionOrder.push('task1-end');
-          return 'result1';
-        }),
-      },
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task2-start');
-          await new Promise((resolve) => setTimeout(resolve, 5));
-          executionOrder.push('task2-end');
-          return 'result2';
-        }),
-      },
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task3-start');
-          await new Promise((resolve) => setTimeout(resolve, 15));
-          executionOrder.push('task3-end');
-          return 'result3';
-        }),
-      },
-    ];
-
-    const result = await runWithConcurrencyAndLock(tasks, 2);
-
-    expect(result).toEqual(['result1', 'result2', 'result3']);
-    expect(executionOrder).toContain('task1-start');
-    expect(executionOrder).toContain('task2-start');
-    expect(executionOrder).toContain('task3-start');
-  });
-
-  it('respects lock keys', async () => {
-    const executionOrder: string[] = [];
-    const tasks = [
-      {
-        lockKey: 'resource:1',
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task1-start');
-          await new Promise((resolve) => setTimeout(resolve, 20));
-          executionOrder.push('task1-end');
-          return 'result1';
-        }),
-      },
-      {
-        lockKey: 'resource:1',
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task2-start');
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          executionOrder.push('task2-end');
-          return 'result2';
-        }),
-      },
-      {
-        lockKey: 'resource:2',
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task3-start');
-          await new Promise((resolve) => setTimeout(resolve, 5));
-          executionOrder.push('task3-end');
-          return 'result3';
-        }),
-      },
-    ];
-
-    const result = await runWithConcurrencyAndLock(tasks, 3);
-
-    expect(result).toEqual(['result1', 'result2', 'result3']);
-    // Tasks with same lock key should not run concurrently
-    const task1End = executionOrder.indexOf('task1-end');
-    const task2Start = executionOrder.indexOf('task2-start');
-
-    // Task2 should start after task1 ends (same lock key)
-    expect(task2Start).toBeGreaterThan(task1End);
-  });
-
-  it('handles task failure', async () => {
-    const error = new Error('Task failed');
-    const tasks = [
-      { run: vi.fn().mockResolvedValue('success') },
-      { run: vi.fn().mockRejectedValue(error) },
-    ];
-
-    await expect(runWithConcurrencyAndLock(tasks, 2)).rejects.toThrow('Task failed');
-  });
-
-  it('handles concurrent limit of 1', async () => {
-    const executionOrder: string[] = [];
-    const tasks = [
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task1');
-          return 'result1';
-        }),
-      },
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task2');
-          return 'result2';
-        }),
-      },
-    ];
-
-    const result = await runWithConcurrencyAndLock(tasks, 1);
-
-    expect(result).toEqual(['result1', 'result2']);
-    expect(executionOrder).toEqual(['task1', 'task2']);
-  });
-
-  it('handles tasks without lock keys', async () => {
-    const tasks = [
-      { run: vi.fn().mockResolvedValue('result1') },
-      { run: vi.fn().mockResolvedValue('result2') },
-      { run: vi.fn().mockResolvedValue('result3') },
-    ];
-
-    const result = await runWithConcurrencyAndLock(tasks, 2);
-
-    expect(result).toEqual(['result1', 'result2', 'result3']);
-  });
-
-  it('handles mixed lock keys and no lock keys', async () => {
-    const executionOrder: string[] = [];
-    const tasks = [
-      {
-        lockKey: 'resource:1',
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task1');
-          return 'result1';
-        }),
-      },
-      {
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task2');
-          return 'result2';
-        }),
-      },
-      {
-        lockKey: 'resource:1',
-        run: vi.fn().mockImplementation(async () => {
-          executionOrder.push('task3');
-          return 'result3';
-        }),
-      },
-    ];
-
-    const result = await runWithConcurrencyAndLock(tasks, 3);
-
-    expect(result).toEqual(['result1', 'result2', 'result3']);
-    // Task3 should wait for task1 to complete (same lock key)
-    const task1Index = executionOrder.indexOf('task1');
-    const task3Index = executionOrder.indexOf('task3');
-    expect(task3Index).toBeGreaterThan(task1Index);
-  });
-});