@renxqoo/renx-code 0.0.8 → 0.0.10

package/src/agent/runtime/event-format.ts

@@ -1,258 +0,0 @@
-import type {
-  AgentLoopEvent,
-  AgentStepEvent,
-  AgentStopEvent,
-  AgentToolConfirmEvent,
-  AgentToolResultEvent,
-  AgentToolStreamEvent,
-  AgentToolUseEvent,
-} from './types';
-
-const MAX_TOOL_TEXT = 12000;
-
-const stringify = (value: unknown): string => {
-  if (value === undefined) {
-    return '';
-  }
-  if (typeof value === 'string') {
-    return value;
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-};
-
-const stringifyPretty = (value: unknown): string => {
-  if (typeof value === 'string') {
-    return value;
-  }
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
-  }
-};
-
-const limitText = (value: string): string => {
-  if (value.length <= MAX_TOOL_TEXT) {
-    return value;
-  }
-  return `${value.slice(0, MAX_TOOL_TEXT)}\n... (truncated)`;
-};
-
-const hasNonEmptyText = (value: unknown): value is string => {
-  return typeof value === 'string' && value.length > 0;
-};
-
-type ToolCallLike = {
-  id?: string;
-  function?: {
-    name?: string;
-    arguments?: string;
-  };
-};
-
-type ToolResultLike = {
-  success?: boolean;
-  data?: unknown;
-  error?: string;
-};
-
-const asObject = (value: unknown): Record<string, unknown> => {
-  if (!value || typeof value !== 'object') {
-    return {};
-  }
-  return value as Record<string, unknown>;
-};
-
-const toToolCall = (value: unknown): ToolCallLike => {
-  const objectValue = asObject(value);
-  const functionValue = asObject(objectValue.function);
-  return {
-    id: typeof objectValue.id === 'string' ? objectValue.id : undefined,
-    function: {
-      name: typeof functionValue.name === 'string' ? functionValue.name : undefined,
-      arguments: typeof functionValue.arguments === 'string' ? functionValue.arguments : undefined,
-    },
-  };
-};
-
-const parseToolArguments = (raw?: string): Record<string, unknown> => {
-  if (!raw) {
-    return {};
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return asObject(parsed);
-  } catch {
-    return { raw };
-  }
-};
-
-const pickString = (value: unknown): string | undefined => {
-  return typeof value === 'string' ? value : undefined;
-};
-
-const formatToolUseAsCode = (toolCall: ToolCallLike): string => {
-  const toolName = toolCall.function?.name ?? 'tool';
-  const callId = toolCall.id ?? 'unknown';
-  const args = parseToolArguments(toolCall.function?.arguments);
-
-  if (toolName === 'bash') {
-    const command = pickString(args.command) ?? '';
-    const timeout = args.timeout;
-    const lines = [`# Tool: bash (${callId})`, `$ ${command}`];
-    if (typeof timeout === 'number') {
-      lines.push(`# timeout: ${timeout}ms`);
-    }
-    return lines.join('\n');
-  }
-
-  if (toolName.startsWith('file_')) {
-    const path = pickString(args.path);
-    const action = pickString(args.action);
-    const lines = [`# Tool: ${toolName} (${callId})`];
-    if (action) {
-      lines.push(`# action: ${action}`);
-    }
-    if (path) {
-      lines.push(`# path: ${path}`);
-    }
-    const rest = { ...args };
-    delete rest.action;
-    delete rest.path;
-    if (Object.keys(rest).length > 0) {
-      lines.push(stringifyPretty(rest));
-    }
-    return lines.join('\n');
-  }
-
-  return [`# Tool: ${toolName} (${callId})`, stringifyPretty(args)].join('\n');
-};
-
-const omitOutputField = (value: Record<string, unknown>): Record<string, unknown> => {
-  const cloned = { ...value };
-  delete cloned.output;
-  delete cloned.summary;
-  return cloned;
-};
-
-const formatToolResultAsCode = (
-  event: AgentToolResultEvent,
-  opts?: { suppressOutput?: boolean }
-): string => {
-  const toolCall = toToolCall(event.toolCall);
-  const toolName = toolCall.function?.name ?? 'tool';
-  const callId = toolCall.id ?? 'unknown';
-
-  const result = asObject(event.result) as ToolResultLike;
-  const data = asObject(result.data);
-  const lines = [`# Result: ${toolName} (${callId}) ${result.success ? 'success' : 'error'}`];
-
-  if (result.error) {
-    lines.push(result.error);
-  }
-
-  const summary = pickString(data.summary);
-  const output = pickString(data.output);
-  if (!opts?.suppressOutput && hasNonEmptyText(output)) {
-    lines.push(output);
-    return limitText(lines.join('\n'));
-  }
-
-  if (summary) {
-    lines.push(summary);
-  }
-
-  if (output === '') {
-    if (!summary) {
-      lines.push('no output');
-    }
-    return limitText(lines.join('\n'));
-  }
-
-  const normalizedData = opts?.suppressOutput ? omitOutputField(data) : data;
-  if (Object.keys(normalizedData).length > 0) {
-    lines.push(stringifyPretty(normalizedData));
-    return limitText(lines.join('\n'));
-  }
-
-  if (opts?.suppressOutput && hasNonEmptyText(output)) {
-    return limitText(lines.join('\n'));
-  }
-
-  const raw = stringifyPretty(event.result);
-  if (raw) {
-    lines.push(raw);
-  }
-
-  return limitText(lines.join('\n'));
-};
-
-export const formatToolConfirmEvent = (event: AgentToolConfirmEvent): string => {
-  const reason = event.reason ? ` reason=${event.reason}` : '';
-  const args = stringify(event.args);
-  return `[tool-confirm:${event.toolName}:${event.toolCallId}]${reason} args=${args}`;
-};
-
-export const formatToolUseEvent = (event: AgentToolUseEvent): string => {
-  return `[tool-use] ${stringify(event)}`;
-};
-
-export const formatToolUseEventCode = (event: AgentToolUseEvent): string => {
-  return formatToolUseAsCode(toToolCall(event));
-};
-
-export const formatToolResultEvent = (event: AgentToolResultEvent): string => {
-  return `[tool-result] ${stringify(event)}`;
-};
-
-export const formatToolResultEventCode = (
-  event: AgentToolResultEvent,
-  opts?: { suppressOutput?: boolean }
-): string => {
-  return formatToolResultAsCode(event, opts);
-};
-
-export const formatStepEvent = (event: AgentStepEvent): string => {
-  const finish = event.finishReason ?? 'unknown';
-  return `[step] index=${event.stepIndex} finishReason=${finish} toolCalls=${event.toolCallsCount}`;
-};
-
-export const formatLoopEvent = (event: AgentLoopEvent): string => {
-  return `[loop] index=${event.loopIndex} steps=${event.steps}`;
-};
-
-export const formatStopEvent = (event: AgentStopEvent): string => {
-  if (event.message) {
-    return `[stop] reason=${event.reason} message=${event.message}`;
-  }
-  return `[stop] reason=${event.reason}`;
-};
-
-export const formatToolStreamEvent = (
-  event: AgentToolStreamEvent
-): { note?: string; codeChunk?: string; segmentKey?: string } => {
-  const prefix = `[tool:${event.toolName}:${event.toolCallId}:${event.type}#${event.sequence}]`;
-
-  if (event.type === 'stdout' || event.type === 'stderr') {
-    const channel = event.type === 'stderr' ? 'stderr' : 'stdout';
-    const chunk = event.content ?? '';
-    return {
-      codeChunk: chunk.endsWith('\n') ? chunk : `${chunk}\n`,
-      segmentKey: `${event.toolCallId}:${channel}`,
-    };
-  }
-
-  if (event.content) {
-    return { note: `${prefix} ${event.content}` };
-  }
-
-  if (event.data !== undefined) {
-    return { note: `${prefix} ${stringify(event.data)}` };
-  }
-
-  return { note: prefix };
-};

package/src/agent/runtime/model-types.ts

@@ -1,13 +0,0 @@
-export type AgentModelOption = {
-  id: string;
-  name: string;
-  provider: string;
-  apiKeyEnv: string;
-  configured: boolean;
-  current: boolean;
-};
-
-export type AgentModelSwitchResult = {
-  modelId: string;
-  modelLabel: string;
-};

package/src/agent/runtime/runtime.context-usage.test.ts

@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('./tool-confirmation', () => ({
-  resolveToolConfirmDecision: vi.fn(),
-}));
-
-vi.mock('./source-modules', () => ({
-  getSourceModules: vi.fn(),
-  resolveWorkspaceRoot: vi.fn(),
-}));
-
-import { disposeAgentRuntime, runAgentPrompt } from './runtime';
-import * as sourceModules from './source-modules';
-import type { AgentContextUsageEvent, AgentEventHandlers } from './types';
-
-describe('runAgentPrompt context usage forwarding', () => {
-  const mockGetSourceModules = sourceModules.getSourceModules as unknown as ReturnType<
-    typeof vi.fn
-  >;
-  const mockResolveWorkspaceRoot = sourceModules.resolveWorkspaceRoot as unknown as ReturnType<
-    typeof vi.fn
-  >;
-  const originalApiKey = process.env.TEST_API_KEY;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env.TEST_API_KEY = 'test-key';
-    mockResolveWorkspaceRoot.mockReturnValue('/test/workspace');
-
-    class FakeToolManager {
-      registerTool = vi.fn();
-      getTools = vi.fn(() => []);
-    }
-
-    class FakeTool {
-      toToolSchema() {
-        return {
-          type: 'function',
-          function: {
-            name: 'fake_tool',
-          },
-        };
-      }
-    }
-
-    class FakeAgent {
-      on = vi.fn();
-      off = vi.fn();
-    }
-
-    class FakeAppService {
-      async listContextMessages() {
-        return [];
-      }
-
-      async runForeground(
-        _request: unknown,
-        callbacks?: {
-          onContextUsage?: (usage: {
-            stepIndex: number;
-            messageCount: number;
-            contextTokens: number;
-            contextLimitTokens: number;
-            contextUsagePercent: number;
-          }) => void | Promise<void>;
-          onUsage?: (usage: {
-            sequence: number;
-            stepIndex: number;
-            messageId: string;
-            usage: {
-              prompt_tokens: number;
-              completion_tokens: number;
-              total_tokens: number;
-            };
-            cumulativeUsage: {
-              prompt_tokens: number;
-              completion_tokens: number;
-              total_tokens: number;
-            };
-            contextTokens?: number;
-            contextLimitTokens?: number;
-            contextUsagePercent?: number;
-          }) => void | Promise<void>;
-        }
-      ) {
-        await callbacks?.onContextUsage?.({
-          stepIndex: 1,
-          messageCount: 1,
-          contextTokens: 123,
-          contextLimitTokens: 1000,
-          contextUsagePercent: 12.3,
-        });
-
-        return {
-          executionId: 'exec_ctx',
-          conversationId: 'conv_ctx',
-          messages: [
-            {
-              messageId: 'msg_assistant',
-              role: 'assistant',
-              type: 'assistant-text',
-              content: 'done',
-            },
-          ],
-          finishReason: 'stop' as const,
-          steps: 1,
-          run: {},
-        };
-      }
-    }
-
-    mockGetSourceModules.mockResolvedValue({
-      ProviderRegistry: {
-        getModelIds: () => ['test-model'],
-        getModelConfig: () => ({
-          name: 'Test Model',
-          envApiKey: 'TEST_API_KEY',
-          model: 'test-model',
-        }),
-        createFromEnv: () => ({}),
-      },
-      loadEnvFiles: vi.fn().mockResolvedValue([]),
-      loadConfigToEnv: vi.fn().mockReturnValue([]),
-      buildSystemPrompt: vi.fn(() => 'Test system prompt'),
-      resolveRenxDatabasePath: vi.fn(() => '/tmp/renx/data.db'),
-      resolveRenxTaskDir: vi.fn(() => '/tmp/renx/task'),
-      createLoggerFromEnv: vi.fn(() => ({ info: vi.fn(), warn: vi.fn(), error: vi.fn() })),
-      createAgentLoggerAdapter: vi.fn((logger: Record<string, unknown>) => ({
-        info: typeof logger.info === 'function' ? logger.info.bind(logger) : undefined,
-        warn: typeof logger.warn === 'function' ? logger.warn.bind(logger) : undefined,
-        error: typeof logger.error === 'function' ? logger.error.bind(logger) : undefined,
-      })),
-      StatelessAgent: FakeAgent,
-      AgentAppService: FakeAppService,
-      createSqliteAgentAppStore: () => ({
-        prepare: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-      }),
-      DefaultToolManager: FakeToolManager,
-      BashTool: FakeTool,
-      WriteFileTool: FakeTool,
-      FileReadTool: FakeTool,
-      FileEditTool: FakeTool,
-      FileHistoryListTool: FakeTool,
-      FileHistoryRestoreTool: FakeTool,
-      GlobTool: FakeTool,
-      GrepTool: FakeTool,
-      SkillTool: FakeTool,
-      TaskTool: FakeTool,
-      TaskCreateTool: FakeTool,
-      TaskGetTool: FakeTool,
-      TaskListTool: FakeTool,
-      TaskUpdateTool: FakeTool,
-      TaskStopTool: FakeTool,
-      TaskOutputTool: FakeTool,
-      TaskStore: class {},
-      RealSubagentRunnerAdapter: class {},
-    } as unknown as Awaited<ReturnType<typeof sourceModules.getSourceModules>>);
-  });
-
-  afterEach(async () => {
-    await disposeAgentRuntime();
-    if (originalApiKey === undefined) {
-      delete process.env.TEST_API_KEY;
-    } else {
-      process.env.TEST_API_KEY = originalApiKey;
-    }
-  });
-
-  it('forwards realtime context usage to TUI handlers before final usage', async () => {
-    const onContextUsage = vi.fn();
-    const onUsage = vi.fn();
-    const handlers = {
-      onContextUsage,
-      onUsage,
-    } as AgentEventHandlers & {
-      onContextUsage: (event: AgentContextUsageEvent) => void;
-    };
-
-    await runAgentPrompt('show context', handlers);
-
-    expect(onContextUsage).toHaveBeenCalledTimes(1);
-    expect(onContextUsage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        contextTokens: 123,
-        contextLimit: 1000,
-        contextUsagePercent: 12.3,
-      })
-    );
-    expect(onUsage).not.toHaveBeenCalled();
-  });
-});

package/src/agent/runtime/runtime.error-handling.test.ts

@@ -1,235 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('./tool-confirmation', () => ({
-  resolveToolConfirmDecision: vi.fn(),
-}));
-
-vi.mock('./source-modules', () => ({
-  getSourceModules: vi.fn(),
-  resolveWorkspaceRoot: vi.fn(),
-}));
-
-import { disposeAgentRuntime, runAgentPrompt } from './runtime';
-import * as sourceModules from './source-modules';
-
-describe('runAgentPrompt error handling', () => {
-  const mockGetSourceModules = sourceModules.getSourceModules as ReturnType<typeof vi.fn>;
-  const mockResolveWorkspaceRoot = sourceModules.resolveWorkspaceRoot as ReturnType<typeof vi.fn>;
-  const originalApiKey = process.env.TEST_API_KEY;
-  const createLoggerFromEnv = vi.fn(() => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    close: vi.fn(),
-  }));
-  let buildModules: (
-    AppServiceClass: new () => {
-      listContextMessages: () => Promise<unknown[]>;
-      runForeground: (...args: any[]) => Promise<unknown>;
-    }
-  ) => Awaited<ReturnType<typeof sourceModules.getSourceModules>>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env.TEST_API_KEY = 'test-key';
-    mockResolveWorkspaceRoot.mockReturnValue('/test/workspace');
-
-    class FakeToolManager {
-      registerTool = vi.fn();
-      getTools = vi.fn(() => []);
-    }
-
-    class FakeTool {
-      toToolSchema() {
-        return {
-          type: 'function',
-          function: {
-            name: 'fake_tool',
-          },
-        };
-      }
-    }
-
-    class FakeAgent {
-      on = vi.fn();
-      off = vi.fn();
-    }
-
-    class FakeAppService {
-      async listContextMessages() {
-        return [];
-      }
-
-      async runForeground(
-        _request: unknown,
-        callbacks?: {
-          onError?: (error: Error) => void | Promise<void>;
-        }
-      ) {
-        await callbacks?.onError?.(new Error('502 Bad Gateway: Upstream request failed'));
-
-        return {
-          executionId: 'exec_error',
-          conversationId: 'conv_error',
-          messages: [],
-          finishReason: 'error' as const,
-          steps: 1,
-          run: {},
-        };
-      }
-    }
-
-    buildModules = AppServiceClass =>
-      ({
-        ProviderRegistry: {
-          getModelIds: () => ['test-model'],
-          getModelConfig: () => ({
-            name: 'Test Model',
-            envApiKey: 'TEST_API_KEY',
-            model: 'test-model',
-          }),
-          createFromEnv: () => ({}),
-        },
-        loadEnvFiles: vi.fn().mockResolvedValue([]),
-        loadConfigToEnv: vi.fn().mockReturnValue([]),
-        buildSystemPrompt: vi.fn(() => 'Test system prompt'),
-        resolveRenxDatabasePath: vi.fn(() => '/tmp/renx/data.db'),
-        resolveRenxTaskDir: vi.fn(() => '/tmp/renx/task'),
-        createLoggerFromEnv,
-        createAgentLoggerAdapter: vi.fn(() => ({
-          info: vi.fn(),
-          warn: vi.fn(),
-          error: vi.fn(),
-        })),
-        StatelessAgent: FakeAgent,
-        AgentAppService: AppServiceClass,
-        createSqliteAgentAppStore: () => ({
-          prepare: vi.fn().mockResolvedValue(undefined),
-          close: vi.fn().mockResolvedValue(undefined),
-        }),
-        DefaultToolManager: FakeToolManager,
-        BashTool: FakeTool,
-        WriteFileTool: FakeTool,
-        FileReadTool: FakeTool,
-        FileEditTool: FakeTool,
-        FileHistoryListTool: FakeTool,
-        FileHistoryRestoreTool: FakeTool,
-        GlobTool: FakeTool,
-        GrepTool: FakeTool,
-        SkillTool: FakeTool,
-        TaskTool: FakeTool,
-        TaskCreateTool: FakeTool,
-        TaskGetTool: FakeTool,
-        TaskListTool: FakeTool,
-        TaskUpdateTool: FakeTool,
-        TaskStopTool: FakeTool,
-        TaskOutputTool: FakeTool,
-        TaskStore: class {},
-        RealSubagentRunnerAdapter: class {},
-      }) as unknown as Awaited<ReturnType<typeof sourceModules.getSourceModules>>;
-
-    mockGetSourceModules.mockResolvedValue(buildModules(FakeAppService));
-  });
-
-  afterEach(async () => {
-    await disposeAgentRuntime();
-    if (originalApiKey === undefined) {
-      delete process.env.TEST_API_KEY;
-    } else {
-      process.env.TEST_API_KEY = originalApiKey;
-    }
-  });
-
-  it('disables console logging for the TUI runtime', async () => {
-    await runAgentPrompt('hello', {});
-
-    expect(createLoggerFromEnv).toHaveBeenCalledWith(
-      expect.objectContaining({
-        AGENT_LOG_CONSOLE: 'false',
-      }),
-      '/test/workspace'
-    );
-  });
-
-  it('uses onError messages as the completion message when the run fails', async () => {
-    const result = await runAgentPrompt('hello', {});
-
-    expect(result.completionReason).toBe('error');
-    expect(result.completionMessage).toBe('502 Bad Gateway: Upstream request failed');
-  });
-
-  it('does not emit a terminal error stop for a retryable stream error that later succeeds', async () => {
-    class FakeAppServiceWithRetryableError {
-      async listContextMessages() {
-        return [];
-      }
-
-      async runForeground(
-        _request: unknown,
-        callbacks?: {
-          onError?: (error: Error) => void | Promise<void>;
-          onEvent?: (event: { eventType: string; data: Record<string, unknown> }) => Promise<void>;
-        }
-      ) {
-        await callbacks?.onError?.(new Error('Network connection lost. (chunk: gen-retryable)'));
-        await callbacks?.onEvent?.({
-          eventType: 'error',
-          data: {
-            message: 'Network connection lost. (chunk: gen-retryable)',
-          },
-        });
-        await callbacks?.onEvent?.({
-          eventType: 'chunk',
-          data: {
-            content: 'recovered response',
-          },
-        });
-        await callbacks?.onEvent?.({
-          eventType: 'done',
-          data: {
-            finishReason: 'stop',
-          },
-        });
-
-        return {
-          executionId: 'exec_retry_success',
-          conversationId: 'conv_retry_success',
-          messages: [],
-          finishReason: 'stop' as const,
-          steps: 2,
-          run: {},
-        };
-      }
-    }
-
-    mockGetSourceModules.mockResolvedValue(buildModules(FakeAppServiceWithRetryableError));
-
-    const handlers = {
-      onStop: vi.fn(),
-      onTextComplete: vi.fn(),
-    };
-
-    const result = await runAgentPrompt('hello', handlers);
-
-    expect(handlers.onStop).toHaveBeenCalledTimes(1);
-    expect(handlers.onStop).toHaveBeenCalledWith({ reason: 'stop' });
-    expect(handlers.onTextComplete).toHaveBeenCalledWith('recovered response');
-    expect(result.completionReason).toBe('stop');
-    expect(result.completionMessage).toBeUndefined();
-    expect(result.text).toBe('recovered response');
-  });
-
-  it('emits a terminal error stop after the run settles with finishReason=error', async () => {
-    const handlers = {
-      onStop: vi.fn(),
-    };
-
-    await runAgentPrompt('hello', handlers);
-
-    expect(handlers.onStop).toHaveBeenCalledTimes(1);
-    expect(handlers.onStop).toHaveBeenCalledWith({
-      reason: 'error',
-      message: undefined,
-    });
-  });
-});

package/src/agent/runtime/runtime.simple.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-// 简单测试runtime模块的基础功能
-describe('runtime module exports', () => {
-  it('should have expected exports', async () => {
-    // 动态导入以避免全局模拟问题
-    const runtimeModule = await import('./runtime');
-
-    expect(typeof runtimeModule.runAgentPrompt).toBe('function');
-    expect(typeof runtimeModule.getAgentModelLabel).toBe('function');
-    expect(typeof runtimeModule.getAgentModelId).toBe('function');
-    expect(typeof runtimeModule.listAgentModels).toBe('function');
-    expect(typeof runtimeModule.switchAgentModel).toBe('function');
-    expect(typeof runtimeModule.disposeAgentRuntime).toBe('function');
-  });
-});