@renxqoo/renx-code 0.0.3 → 0.0.5

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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,80 @@
+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('');
+  });
+});