@renxqoo/renx-code 0.0.8 → 0.0.10

package/src/hooks/chat-local-replies.fixed.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import {
-  extractErrorMessage,
-  buildHelpSegments,
-  buildUnsupportedSegments,
-} from './chat-local-replies';
-
-describe('chat-local-replies', () => {
-  describe('extractErrorMessage', () => {
-    it('should extract message from Error object', () => {
-      const error = new Error('Test error message');
-      const result = extractErrorMessage(error);
-
-      expect(result).toBe('Error: Test error message');
-    });
-
-    it('should extract message from Error with custom name', () => {
-      const error = new TypeError('Type error occurred');
-      const result = extractErrorMessage(error);
-
-      expect(result).toBe('TypeError: Type error occurred');
-    });
-
-    it('should handle non-Error values', () => {
-      expect(extractErrorMessage('string error')).toBe('string error');
-      expect(extractErrorMessage(123)).toBe('123');
-      expect(extractErrorMessage(null)).toBe('null');
-      expect(extractErrorMessage(undefined)).toBe('undefined');
-      expect(extractErrorMessage({ toString: () => 'custom object' })).toBe('custom object');
-    });
-
-    it('should handle edge cases gracefully', () => {
-      // 测试函数不会抛出错误
-      expect(() => extractErrorMessage({})).not.toThrow();
-      expect(() => extractErrorMessage([])).not.toThrow();
-      expect(() => extractErrorMessage(() => {})).not.toThrow();
-
-      // 结果应该是字符串
-      expect(typeof extractErrorMessage({})).toBe('string');
-    });
-  });
-
-  describe('buildHelpSegments', () => {
-    it('should build help segments with correct structure', () => {
-      const turnId = 1;
-      const segments = buildHelpSegments(turnId);
-
-      expect(segments).toBeArray();
-      expect(segments).toHaveLength(2);
-
-      // 检查第一个segment（thinking）
-      const thinkingSegment = segments[0]!;
-      expect(thinkingSegment.id).toBe(`${turnId}:thinking`);
-      expect(thinkingSegment.type).toBe('thinking');
-      expect(thinkingSegment.content).toBeString();
-      expect(thinkingSegment.content).toContain('OpenTUI Agent CLI');
-
-      // 检查第二个segment（text）
-      const textSegment = segments[1]!;
-      expect(textSegment.id).toBe(`${turnId}:text`);
-      expect(textSegment.type).toBe('text');
-      expect(textSegment.content).toBeString();
-      expect(textSegment.content).toContain('Available commands:');
-    });
-
-    it('should generate unique IDs for different turn IDs', () => {
-      const segments1 = buildHelpSegments(1);
-      const segments2 = buildHelpSegments(2);
-
-      expect(segments1[0]!.id).toBe('1:thinking');
-      expect(segments1[1]!.id).toBe('1:text');
-      expect(segments2[0]!.id).toBe('2:thinking');
-      expect(segments2[1]!.id).toBe('2:text');
-    });
-
-    it('should include all command information', () => {
-      const segments = buildHelpSegments(1);
-      const textContent = segments[1]!.content;
-
-      expect(textContent).toContain('/help (/commands) - show help');
-      expect(textContent).toContain('/clear (/new) - clear all turns');
-      expect(textContent).toContain('/exit (/quit /q) - exit app');
-      expect(textContent).toContain('/models (/model) - open model selector');
-    });
-  });
-
-  describe('buildUnsupportedSegments', () => {
-    it('should build unsupported segments with command name', () => {
-      const turnId = 1;
-      const commandName = 'export';
-      const segments = buildUnsupportedSegments(turnId, commandName);
-
-      expect(segments).toBeArray();
-      expect(segments).toHaveLength(2);
-
-      const thinkingSegment = segments[0]!;
-      expect(thinkingSegment.id).toBe(`${turnId}:thinking`);
-      expect(thinkingSegment.type).toBe('thinking');
-      expect(thinkingSegment.content).toContain(commandName);
-
-      const textSegment = segments[1]!;
-      expect(textSegment.id).toBe(`${turnId}:text`);
-      expect(textSegment.type).toBe('text');
-      expect(textSegment.content).toContain(`/${commandName}`);
-    });
-
-    it('should handle different command names', () => {
-      const testCases = ['fork', 'init', 'sessions', 'review'];
-
-      for (const command of testCases) {
-        const segments = buildUnsupportedSegments(1, command);
-        const textContent = segments[1]!.content;
-
-        expect(textContent).toContain(`/${command}`);
-      }
-    });
-  });
-});

package/src/hooks/chat-local-replies.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import {
-  extractErrorMessage,
-  buildHelpSegments,
-  buildUnsupportedSegments,
-} from './chat-local-replies';
-
-describe('chat-local-replies', () => {
-  describe('extractErrorMessage', () => {
-    it('should extract message from Error object', () => {
-      const error = new Error('Test error message');
-      const result = extractErrorMessage(error);
-
-      expect(result).toBe('Error: Test error message');
-    });
-
-    it('should extract message from Error with custom name', () => {
-      const error = new TypeError('Type error occurred');
-      const result = extractErrorMessage(error);
-
-      expect(result).toBe('TypeError: Type error occurred');
-    });
-
-    it('should handle non-Error values', () => {
-      expect(extractErrorMessage('string error')).toBe('string error');
-      expect(extractErrorMessage(123)).toBe('123');
-      expect(extractErrorMessage(null)).toBe('null');
-      expect(extractErrorMessage(undefined)).toBe('undefined');
-      expect(extractErrorMessage({ toString: () => 'custom object' })).toBe('custom object');
-    });
-
-    it('should handle objects without toString', () => {
-      const obj = Object.create(null);
-      const result = extractErrorMessage(obj);
-
-      expect(result).toBe('[object Object]');
-    });
-  });
-
-  describe('buildHelpSegments', () => {
-    it('should build help segments with correct structure', () => {
-      const turnId = 1;
-      const segments = buildHelpSegments(turnId);
-
-      expect(segments).toBeArray();
-      expect(segments).toHaveLength(2);
-
-      // 检查第一个segment（thinking）
-      const thinkingSegment = segments[0]!;
-      expect(thinkingSegment.id).toBe(`${turnId}:thinking`);
-      expect(thinkingSegment.type).toBe('thinking');
-      expect(thinkingSegment.content).toBeString();
-      expect(thinkingSegment.content).toContain('OpenTUI Agent CLI');
-
-      // 检查第二个segment（text）
-      const textSegment = segments[1]!;
-      expect(textSegment.id).toBe(`${turnId}:text`);
-      expect(textSegment.type).toBe('text');
-      expect(textSegment.content).toBeString();
-      expect(textSegment.content).toContain('Available commands:');
-      expect(textSegment.content).toContain('/help');
-      expect(textSegment.content).toContain('/clear');
-      expect(textSegment.content).toContain('/exit');
-      expect(textSegment.content).toContain('/models');
-      expect(textSegment.content).toContain('/files');
-      expect(textSegment.content).toContain('Keyboard shortcuts:');
-    });
-
-    it('should generate unique IDs for different turn IDs', () => {
-      const segments1 = buildHelpSegments(1);
-      const segments2 = buildHelpSegments(2);
-
-      expect(segments1[0]!.id).toBe('1:thinking');
-      expect(segments1[1]!.id).toBe('1:text');
-      expect(segments2[0]!.id).toBe('2:thinking');
-      expect(segments2[1]!.id).toBe('2:text');
-    });
-
-    it('should include all command information', () => {
-      const segments = buildHelpSegments(1);
-      const textContent = segments[1]!.content;
-
-      expect(textContent).toContain('/help (/commands) - show help');
-      expect(textContent).toContain('/clear (/new) - clear all turns');
-      expect(textContent).toContain('/exit (/quit /q) - exit app');
-      expect(textContent).toContain('/models (/model) - open model selector');
-      expect(textContent).toContain('/files (/file) - attach workspace files');
-    });
-
-    it('should include keyboard shortcuts', () => {
-      const segments = buildHelpSegments(1);
-      const textContent = segments[1]!.content;
-
-      expect(textContent).toContain('Esc - stop current response when the agent is thinking');
-      expect(textContent).toContain('Ctrl+L - clear conversation panel');
-      expect(textContent).toContain('Use /files to attach local workspace files');
-    });
-  });
-
-  describe('buildUnsupportedSegments', () => {
-    it('should build unsupported segments with command name', () => {
-      const turnId = 1;
-      const commandName = 'export';
-      const segments = buildUnsupportedSegments(turnId, commandName);
-
-      expect(segments).toBeArray();
-      expect(segments).toHaveLength(2);
-
-      // 检查thinking segment
-      const thinkingSegment = segments[0]!;
-      expect(thinkingSegment.id).toBe(`${turnId}:thinking`);
-      expect(thinkingSegment.type).toBe('thinking');
-      expect(thinkingSegment.content).toBeString();
-      expect(thinkingSegment.content).toContain(commandName);
-      expect(thinkingSegment.content).toContain('not implemented');
-
-      // 检查text segment
-      const textSegment = segments[1]!;
-      expect(textSegment.id).toBe(`${turnId}:text`);
-      expect(textSegment.type).toBe('text');
-      expect(textSegment.content).toBeString();
-      expect(textSegment.content).toContain(`/${commandName}`);
-      expect(textSegment.content).toContain('not implemented yet');
-    });
-
-    it('should handle different command names', () => {
-      const testCases = [
-        { command: 'fork', expected: 'fork' },
-        { command: 'init', expected: 'init' },
-        { command: 'sessions', expected: 'sessions' },
-        { command: 'review', expected: 'review' },
-      ];
-
-      for (const testCase of testCases) {
-        const segments = buildUnsupportedSegments(1, testCase.command);
-        const textContent = segments[1]!.content;
-
-        expect(textContent).toContain(`/${testCase.command}`);
-      }
-    });
-
-    it('should generate unique IDs for different turn IDs', () => {
-      const segments1 = buildUnsupportedSegments(1, 'export');
-      const segments2 = buildUnsupportedSegments(2, 'export');
-
-      expect(segments1[0]!.id).toBe('1:thinking');
-      expect(segments1[1]!.id).toBe('1:text');
-      expect(segments2[0]!.id).toBe('2:thinking');
-      expect(segments2[1]!.id).toBe('2:text');
-    });
-  });
-});

package/src/hooks/chat-local-replies.ts

@@ -1,63 +0,0 @@
-export type LocalReplySegment = {
-  id: string;
-  type: 'thinking' | 'text';
-  content: string;
-};
-
-export const extractErrorMessage = (error: unknown): string => {
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}`;
-  }
-  try {
-    return String(error);
-  } catch {
-    return Object.prototype.toString.call(error);
-  }
-};
-
-export const buildHelpSegments = (turnId: number): LocalReplySegment[] => {
-  return [
-    {
-      id: `${turnId}:thinking`,
-      type: 'thinking',
-      content: 'This is the command help for OpenTUI Agent CLI.',
-    },
-    {
-      id: `${turnId}:text`,
-      type: 'text',
-      content: [
-        'Available commands:',
-        '/help (/commands) - show help',
-        '/clear (/new) - clear all turns',
-        '/exit (/quit /q) - exit app',
-        '/models (/model) - open model selector',
-        '/files (/file) - attach workspace files',
-        'Type @/ to attach workspace files inline',
-        '',
-        'Keyboard shortcuts:',
-        'Esc - stop current response when the agent is thinking',
-        'Ctrl+L - clear conversation panel',
-        'Use /files to attach local workspace files',
-        'Use @/path to search and attach files inline',
-      ].join('\n'),
-    },
-  ];
-};
-
-export const buildUnsupportedSegments = (
-  turnId: number,
-  commandName: string
-): LocalReplySegment[] => {
-  return [
-    {
-      id: `${turnId}:thinking`,
-      type: 'thinking',
-      content: `The user selected /${commandName}. This command is not implemented in current demo.`,
-    },
-    {
-      id: `${turnId}:text`,
-      type: 'text',
-      content: `Command /${commandName} is not implemented yet in this CLI demo.`,
-    },
-  ];
-};

package/src/hooks/turn-updater.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { createStreamingReply, orderReplySegments } from './turn-updater';
-import type { ReplySegment } from '../types/chat';
-
-describe('createStreamingReply', () => {
-  it('initializes startedAtMs for realtime duration display', () => {
-    const before = Date.now();
-    const reply = createStreamingReply('glm-5');
-    const after = Date.now();
-
-    expect(typeof reply.startedAtMs).toBe('number');
-    expect((reply.startedAtMs as number) >= before).toBe(true);
-    expect((reply.startedAtMs as number) <= after).toBe(true);
-    expect(reply.status).toBe('streaming');
-    expect(reply.durationSeconds).toBe(0);
-  });
-});
-
-describe('orderReplySegments', () => {
-  it('keeps each tool-result adjacent to its tool-use for concurrent multi-tool calls', () => {
-    const input: ReplySegment[] = [
-      { id: '1:thinking:1', type: 'thinking', content: '先并发调用4个工具。' },
-      { id: '1:tool-use:call_a', type: 'code', content: '# Tool A\n' },
-      { id: '1:tool-use:call_b', type: 'code', content: '# Tool B\n' },
-      { id: '1:tool-use:call_c', type: 'code', content: '# Tool C\n' },
-      { id: '1:tool-use:call_d', type: 'code', content: '# Tool D\n' },
-      { id: '1:tool-result:call_c', type: 'code', content: '# Result C\n' },
-      { id: '1:tool-result:call_a', type: 'code', content: '# Result A\n' },
-      { id: '1:tool-result:call_d', type: 'code', content: '# Result D\n' },
-      { id: '1:tool-result:call_b', type: 'code', content: '# Result B\n' },
-      { id: '1:text:2', type: 'text', content: '工具执行结束。' },
-    ];
-
-    const ordered = orderReplySegments(input);
-    expect(ordered.map(segment => segment.id)).toEqual([
-      '1:thinking:1',
-      '1:tool-use:call_a',
-      '1:tool-result:call_a',
-      '1:tool-use:call_b',
-      '1:tool-result:call_b',
-      '1:tool-use:call_c',
-      '1:tool-result:call_c',
-      '1:tool-use:call_d',
-      '1:tool-result:call_d',
-      '1:text:2',
-    ]);
-  });
-
-  it('keeps stream output between its tool-use and tool-result', () => {
-    const input: ReplySegment[] = [
-      { id: '1:tool-use:call_1', type: 'code', content: '# Tool 1\n' },
-      { id: '1:tool-use:call_2', type: 'code', content: '# Tool 2\n' },
-      { id: '1:tool:call_2:stdout', type: 'code', content: 'line2\n' },
-      { id: '1:tool:call_1:stdout', type: 'code', content: 'line1\n' },
-      { id: '1:tool-result:call_2', type: 'code', content: '# Result 2\n' },
-      { id: '1:tool-result:call_1', type: 'code', content: '# Result 1\n' },
-    ];
-
-    const ordered = orderReplySegments(input);
-    expect(ordered.map(segment => segment.id)).toEqual([
-      '1:tool-use:call_1',
-      '1:tool:call_1:stdout',
-      '1:tool-result:call_1',
-      '1:tool-use:call_2',
-      '1:tool:call_2:stdout',
-      '1:tool-result:call_2',
-    ]);
-  });
-});

package/src/hooks/turn-updater.ts

@@ -1,166 +0,0 @@
-import type {
-  AssistantReply,
-  ChatTurn,
-  ReplySegment,
-  ReplySegmentType,
-  ReplyStatus,
-} from '../types/chat';
-
-const DEFAULT_AGENT_LABEL = '';
-
-export const createStreamingReply = (modelLabel: string): AssistantReply => ({
-  agentLabel: DEFAULT_AGENT_LABEL,
-  modelLabel,
-  startedAtMs: Date.now(),
-  durationSeconds: 0,
-  segments: [],
-  status: 'streaming',
-});
-
-export const patchTurn = (
-  turns: ChatTurn[],
-  turnId: number,
-  patch: (turn: ChatTurn) => ChatTurn
-): ChatTurn[] => {
-  return turns.map(turn => (turn.id === turnId ? patch(turn) : turn));
-};
-
-export const ensureSegment = (
-  segments: ReplySegment[],
-  segmentId: string,
-  type: ReplySegmentType,
-  data?: unknown
-): ReplySegment[] => {
-  if (segments.some(segment => segment.id === segmentId)) {
-    return segments;
-  }
-  return [
-    ...segments,
-    { id: segmentId, type, content: '', ...(data !== undefined ? { data } : {}) },
-  ];
-};
-
-export const appendToSegment = (
-  segments: ReplySegment[],
-  segmentId: string,
-  type: ReplySegmentType,
-  chunk: string,
-  data?: unknown
-): ReplySegment[] => {
-  const base = ensureSegment(segments, segmentId, type, data);
-  return base.map(segment =>
-    segment.id === segmentId
-      ? {
-          ...segment,
-          content: `${segment.content}${chunk}`,
-          ...(data !== undefined ? { data } : {}),
-        }
-      : segment
-  );
-};
-
-type ToolSegmentKind = 'use' | 'stream' | 'result';
-
-const parseToolSegment = (
-  segmentId: string
-): {
-  toolCallId: string;
-  kind: ToolSegmentKind;
-} | null => {
-  const toolUseMatch = segmentId.match(/^\d+:tool-use:(.+)$/);
-  if (toolUseMatch && toolUseMatch[1]) {
-    return { toolCallId: toolUseMatch[1], kind: 'use' };
-  }
-
-  const toolResultMatch = segmentId.match(/^\d+:tool-result:(.+)$/);
-  if (toolResultMatch && toolResultMatch[1]) {
-    return { toolCallId: toolResultMatch[1], kind: 'result' };
-  }
-
-  const toolStreamMatch = segmentId.match(/^\d+:tool:([^:]+):/);
-  if (toolStreamMatch && toolStreamMatch[1]) {
-    return { toolCallId: toolStreamMatch[1], kind: 'stream' };
-  }
-
-  return null;
-};
-
-export const orderReplySegments = (segments: ReplySegment[]): ReplySegment[] => {
-  type ToolGroup = {
-    use: ReplySegment[];
-    stream: ReplySegment[];
-    result: ReplySegment[];
-  };
-
-  const groups = new Map<string, ToolGroup>();
-  const emittedGroupIds = new Set<string>();
-  const ordered: Array<ReplySegment | { groupId: string }> = [];
-
-  for (const segment of segments) {
-    const parsed = parseToolSegment(segment.id);
-    if (!parsed) {
-      ordered.push(segment);
-      continue;
-    }
-
-    const existing = groups.get(parsed.toolCallId) ?? {
-      use: [],
-      stream: [],
-      result: [],
-    };
-    existing[parsed.kind].push(segment);
-    groups.set(parsed.toolCallId, existing);
-
-    if (!emittedGroupIds.has(parsed.toolCallId)) {
-      emittedGroupIds.add(parsed.toolCallId);
-      ordered.push({ groupId: parsed.toolCallId });
-    }
-  }
-
-  const normalized: ReplySegment[] = [];
-  for (const item of ordered) {
-    if ('id' in item) {
-      normalized.push(item);
-      continue;
-    }
-
-    const group = groups.get(item.groupId);
-    if (!group) {
-      continue;
-    }
-    normalized.push(...group.use, ...group.stream, ...group.result);
-  }
-
-  return normalized;
-};
-
-export const appendNoteLine = (
-  segments: ReplySegment[],
-  segmentId: string,
-  text: string
-): ReplySegment[] => {
-  const line = text.endsWith('\n') ? text : `${text}\n`;
-  return appendToSegment(segments, segmentId, 'note', line);
-};
-
-export const setReplyStatus = (
-  turns: ChatTurn[],
-  turnId: number,
-  status: ReplyStatus,
-  extras?: Partial<AssistantReply>
-): ChatTurn[] => {
-  return patchTurn(turns, turnId, turn => {
-    const reply = turn.reply;
-    if (!reply) {
-      return turn;
-    }
-    return {
-      ...turn,
-      reply: {
-        ...reply,
-        ...extras,
-        status,
-      },
-    };
-  });
-};

package/src/hooks/use-agent-chat.context.test.ts

@@ -1,10 +0,0 @@
-import { describe, it } from 'vitest';
-
-describe('useAgentChat context behavior', () => {
-  it.todo(
-    'keeps the previous context usage visible when a resend starts until the first fresh context update arrives'
-  );
-  it.todo(
-    'updates context usage from realtime onContextUsage before the final usage event is emitted'
-  );
-});

package/src/hooks/use-agent-chat.status.test.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { resolveReplyStatus } from './use-agent-chat';
-
-describe('resolveReplyStatus', () => {
-  it('maps server-side error completions to reply error state', () => {
-    expect(resolveReplyStatus('error')).toBe('error');
-  });
-
-  it('keeps non-error completions as done state', () => {
-    expect(resolveReplyStatus('stop')).toBe('done');
-    expect(resolveReplyStatus('cancelled')).toBe('done');
-  });
-});

package/src/hooks/use-agent-chat.test.ts

@@ -1,80 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('../commands/slash-commands', () => ({
-  resolveSlashCommand: vi.fn(),
-}));
-
-vi.mock('../agent/runtime/runtime', () => ({
-  getAgentModelAttachmentCapabilities: vi.fn(),
-  getAgentModelLabel: vi.fn(),
-  runAgentPrompt: vi.fn(),
-}));
-
-vi.mock('../runtime/exit', () => ({
-  requestExit: vi.fn(),
-}));
-
-import * as runtime from '../agent/runtime/runtime';
-import { useAgentChat } from './use-agent-chat';
-
-describe('useAgentChat', () => {
-  const mockGetAgentModelLabel = runtime.getAgentModelLabel as unknown as ReturnType<typeof vi.fn>;
-  const mockGetAgentModelAttachmentCapabilities =
-    runtime.getAgentModelAttachmentCapabilities as unknown as ReturnType<typeof vi.fn>;
-  const mockRunAgentPrompt = runtime.runAgentPrompt as unknown as ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetAgentModelLabel.mockResolvedValue('glm-5');
-    mockGetAgentModelAttachmentCapabilities.mockResolvedValue({
-      image: false,
-      audio: false,
-      video: false,
-    });
-    mockRunAgentPrompt.mockResolvedValue({ success: true });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('initializes with default state and resolves the model label', async () => {
-    const { result } = renderHook(() => useAgentChat());
-
-    expect(result.current.turns).toEqual([]);
-    expect(result.current.inputValue).toBe('');
-    expect(result.current.isThinking).toBe(false);
-    expect(result.current.contextUsagePercent).toBe(null);
-    expect(result.current.pendingToolConfirm).toBe(null);
-
-    await waitFor(() => {
-      expect(result.current.modelLabel).toBe('glm-5');
-    });
-  });
-
-  it('updates input value', () => {
-    const { result } = renderHook(() => useAgentChat());
-
-    act(() => {
-      result.current.setInputValue('test input');
-    });
-
-    expect(result.current.inputValue).toBe('test input');
-  });
-
-  it('clears input', () => {
-    const { result } = renderHook(() => useAgentChat());
-
-    act(() => {
-      result.current.setInputValue('test input');
-    });
-    expect(result.current.inputValue).toBe('test input');
-
-    act(() => {
-      result.current.clearInput();
-    });
-
-    expect(result.current.inputValue).toBe('');
-  });
-});