@renxqoo/renx-code 0.0.2 → 0.0.4

package/src/files/attachment-content.ts

@@ -0,0 +1,153 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+
+import type { InputContentPart, MessageContent } from '../types/message-content';
+import type { PromptFileSelection } from './types';
+import {
+  type AttachmentModelCapabilities,
+  isAudioSelection,
+  isImageSelection,
+  isVideoSelection,
+} from './attachment-capabilities';
+
+const IMAGE_MIME_BY_EXTENSION: Record<string, string> = {
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.webp': 'image/webp',
+};
+
+const VIDEO_MIME_BY_EXTENSION: Record<string, string> = {
+  '.avi': 'video/x-msvideo',
+  '.m4v': 'video/mp4',
+  '.mkv': 'video/x-matroska',
+  '.mov': 'video/quicktime',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+};
+
+const AUDIO_MIME_BY_EXTENSION: Record<string, string> = {
+  '.aac': 'audio/aac',
+  '.flac': 'audio/flac',
+  '.m4a': 'audio/mp4',
+  '.mp3': 'audio/mpeg',
+  '.ogg': 'audio/ogg',
+  '.wav': 'audio/wav',
+};
+
+const FALLBACK_FILE_MIME = 'application/octet-stream';
+const MAX_ATTACHMENT_BYTES = 2 * 1024 * 1024;
+const MAX_TEXT_ATTACHMENT_CHARS = 80_000;
+const TEXT_DECODER = new TextDecoder('utf-8', { fatal: false });
+
+const formatFileFence = (path: string, content: string, truncated: boolean) => {
+  const suffix = truncated ? '\n\n[truncated for prompt size]' : '';
+  return `Attached file: ${path}\n\n\`\`\`\n${content}\n\`\`\`${suffix}`;
+};
+
+const inferMimeType = (path: string) => {
+  const extension = extname(path).toLowerCase();
+  return (
+    IMAGE_MIME_BY_EXTENSION[extension] ??
+    VIDEO_MIME_BY_EXTENSION[extension] ??
+    AUDIO_MIME_BY_EXTENSION[extension] ??
+    FALLBACK_FILE_MIME
+  );
+};
+
+const isImageMimeType = (mimeType: string) => mimeType.startsWith('image/');
+const isAudioMimeType = (mimeType: string) => mimeType.startsWith('audio/');
+const isVideoMimeType = (mimeType: string) => mimeType.startsWith('video/');
+
+const toImagePart = (file: PromptFileSelection, buffer: Uint8Array): InputContentPart => {
+  const mimeType = inferMimeType(file.relativePath);
+  const dataUrl = `data:${mimeType};base64,${Buffer.from(buffer).toString('base64')}`;
+  return {
+    type: 'image_url',
+    image_url: {
+      url: dataUrl,
+      detail: 'auto',
+    },
+  };
+};
+
+const toTextPart = (file: PromptFileSelection, buffer: Uint8Array): InputContentPart => {
+  const rawText = TEXT_DECODER.decode(buffer);
+  const normalized = rawText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  const truncated = normalized.length > MAX_TEXT_ATTACHMENT_CHARS;
+  const content = truncated ? normalized.slice(0, MAX_TEXT_ATTACHMENT_CHARS) : normalized;
+  return {
+    type: 'text',
+    text: formatFileFence(file.relativePath, content, truncated),
+  };
+};
+
+const toAudioTextPart = (file: PromptFileSelection): InputContentPart => {
+  return {
+    type: 'text',
+    text: `Attached audio: ${file.relativePath}`,
+  };
+};
+
+const toVideoTextPart = (file: PromptFileSelection): InputContentPart => {
+  return {
+    type: 'text',
+    text: `Attached video: ${file.relativePath}`,
+  };
+};
+
+const toFileParts = async (
+  file: PromptFileSelection,
+  capabilities: AttachmentModelCapabilities
+): Promise<InputContentPart[]> => {
+  const buffer = await readFile(file.absolutePath);
+  if (buffer.byteLength > MAX_ATTACHMENT_BYTES) {
+    throw new Error(`Attachment too large: ${file.relativePath}`);
+  }
+
+  const mimeType = inferMimeType(file.relativePath);
+  if (isImageMimeType(mimeType) && capabilities.image && isImageSelection(file)) {
+    return [
+      {
+        type: 'text',
+        text: `Attached image: ${file.relativePath}`,
+      },
+      toImagePart(file, buffer),
+    ];
+  }
+
+  if (isAudioMimeType(mimeType) && capabilities.audio && isAudioSelection(file)) {
+    return [toAudioTextPart(file)];
+  }
+
+  if (isVideoMimeType(mimeType) && capabilities.video && isVideoSelection(file)) {
+    return [toVideoTextPart(file)];
+  }
+
+  return [toTextPart(file, buffer)];
+};
+
+export const buildPromptContent = async (
+  prompt: string,
+  files: PromptFileSelection[],
+  capabilities: AttachmentModelCapabilities
+): Promise<MessageContent> => {
+  if (files.length === 0) {
+    return prompt;
+  }
+
+  const parts: InputContentPart[] = [];
+  if (prompt.trim().length > 0) {
+    parts.push({
+      type: 'text',
+      text: prompt,
+    });
+  }
+
+  for (const file of files) {
+    parts.push(...(await toFileParts(file, capabilities)));
+  }
+
+  return parts;
+};

package/src/files/file-mention-query.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'bun:test';
+
+import { findTrailingFileMention, removeTrailingFileMention } from './file-mention-query';
+
+describe('file-mention-query', () => {
+  it('finds trailing @/ mention at input start', () => {
+    expect(findTrailingFileMention('@/src')).toEqual({
+      token: '@/src',
+      query: 'src',
+      start: 0,
+      end: 5,
+    });
+  });
+
+  it('finds trailing @/ mention after text', () => {
+    expect(findTrailingFileMention('check @/src/app')).toEqual({
+      token: '@/src/app',
+      query: 'src/app',
+      start: 6,
+      end: 15,
+    });
+  });
+
+  it('returns null when mention is not trailing token', () => {
+    expect(findTrailingFileMention('use @/src and continue')).toBeNull();
+    expect(findTrailingFileMention('plain text')).toBeNull();
+  });
+
+  it('removes trailing mention token and keeps prior text', () => {
+    expect(removeTrailingFileMention('@/src')).toBe('');
+    expect(removeTrailingFileMention('check @/src/app')).toBe('check ');
+    expect(removeTrailingFileMention('plain text')).toBe('plain text');
+  });
+});

package/src/files/file-mention-query.ts

@@ -0,0 +1,32 @@
+export type FileMentionMatch = {
+  token: string;
+  query: string;
+  start: number;
+  end: number;
+};
+
+const FILE_MENTION_PATTERN = /(^|\s)(@\/[^\s]*)$/;
+
+export const findTrailingFileMention = (value: string): FileMentionMatch | null => {
+  const match = value.match(FILE_MENTION_PATTERN);
+  const token = match?.[2];
+  if (!token) {
+    return null;
+  }
+
+  const start = value.length - token.length;
+  return {
+    token,
+    query: token.slice(2),
+    start,
+    end: value.length,
+  };
+};
+
+export const removeTrailingFileMention = (value: string): string => {
+  const match = findTrailingFileMention(value);
+  if (!match) {
+    return value;
+  }
+  return value.slice(0, match.start);
+};

package/src/files/prompt-display.ts

@@ -0,0 +1,13 @@
+import type { PromptFileSelection } from './types';
+
+const formatSelectedFiles = (files: PromptFileSelection[]) => {
+  return files.map(file => `@${file.relativePath}`).join(' ');
+};
+
+export const buildPromptDisplay = (prompt: string, files: PromptFileSelection[]): string => {
+  const normalizedPrompt = prompt.trim();
+  if (normalizedPrompt.length > 0) {
+    return normalizedPrompt;
+  }
+  return files.length > 0 ? formatSelectedFiles(files) : '';
+};

package/src/files/types.ts

@@ -0,0 +1,5 @@
+export type PromptFileSelection = {
+  relativePath: string;
+  absolutePath: string;
+  size: number;
+};

package/src/files/workspace-files.ts

@@ -0,0 +1,63 @@
+import { readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+
+import { resolveWorkspaceRoot } from '../agent/runtime/source-modules';
+import type { PromptFileSelection } from './types';
+
+const IGNORED_DIR_NAMES = new Set([
+  '.git',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.turbo',
+]);
+
+const comparePaths = (a: PromptFileSelection, b: PromptFileSelection) => {
+  return a.relativePath.localeCompare(b.relativePath);
+};
+
+const visitDirectory = async (
+  root: string,
+  directory: string,
+  output: PromptFileSelection[]
+): Promise<void> => {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+
+  const sortedEntries = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of sortedEntries) {
+    const absolutePath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORED_DIR_NAMES.has(entry.name)) {
+        continue;
+      }
+      await visitDirectory(root, absolutePath, output);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const stat = await Bun.file(absolutePath)
+      .stat()
+      .catch(() => undefined);
+    if (!stat || !stat.isFile()) {
+      continue;
+    }
+
+    output.push({
+      relativePath: relative(root, absolutePath),
+      absolutePath,
+      size: stat.size,
+    });
+  }
+};
+
+export const listWorkspaceFiles = async (): Promise<PromptFileSelection[]> => {
+  const workspaceRoot = resolveWorkspaceRoot();
+  const files: PromptFileSelection[] = [];
+  await visitDirectory(workspaceRoot, workspaceRoot, files);
+  return files.sort(comparePaths);
+};

package/src/hooks/agent-event-handlers.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, it } from 'vitest';
+
+import type {
+  AgentToolResultEvent,
+  AgentToolStreamEvent,
+  AgentToolUseEvent,
+} from '../agent/runtime/types';
+import { buildAgentEventHandlers } from './agent-event-handlers';
+import { appendToSegment } from './turn-updater';
+import type { ReplySegment } from '../types/chat';
+
+const buildHarness = () => {
+  const turnId = 1;
+  let segments: ReplySegment[] = [];
+  const notes: string[] = [];
+
+  const handlers = buildAgentEventHandlers({
+    turnId,
+    isCurrentRequest: () => true,
+    appendSegment: (_turnId, segmentId, type, chunk, data) => {
+      segments = appendToSegment(segments, segmentId, type, chunk, data);
+    },
+    appendEventLine: (_turnId, text) => {
+      notes.push(text);
+    },
+  });
+
+  return {
+    turnId,
+    handlers,
+    readSegments: () => segments,
+    notes,
+  };
+};
+
+const createToolUseEvent = (): AgentToolUseEvent => ({
+  id: 'call_1',
+  function: {
+    name: 'bash',
+    arguments: JSON.stringify({ command: 'ls -la' }),
+  },
+});
+
+const createStdoutStreamEvent = (): AgentToolStreamEvent => ({
+  toolCallId: 'call_1',
+  toolName: 'bash',
+  type: 'stdout',
+  sequence: 1,
+  timestamp: Date.now(),
+  content: 'total 80',
+});
+
+const createToolResultEvent = (): AgentToolResultEvent => ({
+  toolCall: {
+    id: 'call_1',
+    function: {
+      name: 'bash',
+      arguments: JSON.stringify({ command: 'ls -la' }),
+    },
+  },
+  result: {
+    success: true,
+    data: {
+      output: 'total 80',
+    },
+  },
+});
+
+const createEmptyToolResultEvent = (): AgentToolResultEvent => ({
+  toolCall: {
+    id: 'call_2',
+    function: {
+      name: 'bash',
+      arguments: JSON.stringify({ command: 'find /tmp -name missing' }),
+    },
+  },
+  result: {
+    success: true,
+    data: {
+      summary: 'Command completed successfully with no output.',
+    },
+  },
+});
+
+describe('buildAgentEventHandlers', () => {
+  it('keeps ordered stream segments as thinking -> text -> thinking -> tool -> tool result', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    handlers.onTextDelta?.({
+      text: '先想一下要做什么。',
+      isReasoning: true,
+    });
+    handlers.onTextDelta?.({
+      text: '当前目录看起来是一个 TypeScript 项目。',
+      isReasoning: false,
+    });
+    handlers.onTextDelta?.({
+      text: '我会先执行 ls -la 看目录结构。',
+      isReasoning: true,
+    });
+    handlers.onToolUse?.(createToolUseEvent());
+    handlers.onToolStream?.(createStdoutStreamEvent());
+    handlers.onToolResult?.(createToolResultEvent());
+    handlers.onTextDelta?.({
+      text: '当前目录包含以下内容。',
+      isReasoning: false,
+    });
+    handlers.onTextComplete?.('');
+
+    const segments = readSegments();
+    expect(segments.map(segment => segment.id)).toEqual([
+      `${turnId}:thinking:1`,
+      `${turnId}:text:2`,
+      `${turnId}:thinking:3`,
+      `${turnId}:tool-use:call_1`,
+      `${turnId}:tool:call_1:stdout`,
+      `${turnId}:tool-result:call_1`,
+      `${turnId}:text:4`,
+    ]);
+
+    const firstThinkingIndex = segments.findIndex(segment => segment.id === `${turnId}:thinking:1`);
+    const toolUseIndex = segments.findIndex(segment => segment.id === `${turnId}:tool-use:call_1`);
+    const toolResultIndex = segments.findIndex(
+      segment => segment.id === `${turnId}:tool-result:call_1`
+    );
+    expect(firstThinkingIndex).toBeGreaterThanOrEqual(0);
+    expect(toolUseIndex).toBeGreaterThan(firstThinkingIndex);
+    expect(toolResultIndex).toBeGreaterThan(toolUseIndex);
+  });
+
+  it('suppresses duplicated tool output in tool-result when stdout/stderr stream already exists', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    handlers.onToolUse?.(createToolUseEvent());
+    handlers.onToolStream?.(createStdoutStreamEvent());
+    handlers.onToolResult?.(createToolResultEvent());
+
+    const toolResult = readSegments().find(
+      segment => segment.id === `${turnId}:tool-result:call_1`
+    );
+    expect(toolResult?.content).toContain('# Result: bash (call_1) success');
+    expect(toolResult?.content).not.toContain('total 80');
+  });
+
+  it('keeps tool-result output when no stdout/stderr stream was emitted', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    handlers.onToolUse?.(createToolUseEvent());
+    handlers.onToolResult?.(createToolResultEvent());
+
+    const toolResult = readSegments().find(
+      segment => segment.id === `${turnId}:tool-result:call_1`
+    );
+    expect(toolResult?.content).toContain('# Result: bash (call_1) success');
+    expect(toolResult?.content).toContain('total 80');
+  });
+
+  it('renders a summary instead of an output wrapper when tool succeeds without output', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    handlers.onToolUse?.({
+      id: 'call_2',
+      function: {
+        name: 'bash',
+        arguments: JSON.stringify({ command: 'find /tmp -name missing' }),
+      },
+    });
+    handlers.onToolResult?.(createEmptyToolResultEvent());
+
+    const toolResult = readSegments().find(
+      segment => segment.id === `${turnId}:tool-result:call_2`
+    );
+    expect(toolResult?.content).toContain('# Result: bash (call_2) success');
+    expect(toolResult?.content).toContain('Command completed successfully with no output.');
+    expect(toolResult?.content).not.toContain('{"output":""}');
+  });
+
+  it('stores structured tool event data on tool-use and tool-result segments', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    const toolUseEvent = createToolUseEvent();
+    const toolResultEvent = createToolResultEvent();
+    handlers.onToolUse?.(toolUseEvent);
+    handlers.onToolResult?.(toolResultEvent);
+
+    const toolUse = readSegments().find(segment => segment.id === `${turnId}:tool-use:call_1`);
+    const toolResult = readSegments().find(
+      segment => segment.id === `${turnId}:tool-result:call_1`
+    );
+
+    expect(toolUse?.data).toEqual(toolUseEvent);
+    expect(toolResult?.data).toEqual(toolResultEvent);
+  });
+
+  it('deduplicates repeated tool-use events for the same toolCallId', () => {
+    const { handlers, readSegments, turnId } = buildHarness();
+
+    handlers.onToolUse?.(createToolUseEvent());
+    handlers.onToolUse?.(createToolUseEvent());
+    handlers.onToolUse?.(createToolUseEvent());
+
+    const toolUseSegments = readSegments().filter(
+      segment => segment.id === `${turnId}:tool-use:call_1`
+    );
+    expect(toolUseSegments.length).toBe(1);
+  });
+});

package/src/hooks/agent-event-handlers.ts

@@ -0,0 +1,196 @@
+import {
+  formatLoopEvent,
+  formatStepEvent,
+  formatStopEvent,
+  formatToolConfirmEvent,
+  formatToolResultEvent,
+  formatToolResultEventCode,
+  formatToolStreamEvent,
+  formatToolUseEvent,
+  formatToolUseEventCode,
+} from '../agent/runtime/event-format';
+import type {
+  AgentEventHandlers,
+  AgentToolResultEvent,
+  AgentToolUseEvent,
+} from '../agent/runtime/types';
+import type { ReplySegmentType } from '../types/chat';
+
+type BuildAgentEventHandlersParams = {
+  turnId: number;
+  isCurrentRequest: () => boolean;
+  appendSegment: (
+    turnId: number,
+    segmentId: string,
+    type: ReplySegmentType,
+    chunk: string,
+    data?: unknown
+  ) => void;
+  appendEventLine: (turnId: number, text: string) => void;
+};
+
+const shouldShowEventLog = () => {
+  const value = process.env.AGENT_SHOW_EVENTS?.trim().toLowerCase();
+  return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+};
+
+export const buildAgentEventHandlers = ({
+  turnId,
+  isCurrentRequest,
+  appendSegment,
+  appendEventLine,
+}: BuildAgentEventHandlersParams): AgentEventHandlers => {
+  const showEvents = shouldShowEventLog();
+  const streamedToolCallIds = new Set<string>();
+  const renderedToolUseIds = new Set<string>();
+  let anonymousToolUseCounter = 0;
+  let anonymousToolResultCounter = 0;
+  let streamSegmentCursor = 0;
+  let activeTextSegment: {
+    id: string;
+    type: 'thinking' | 'text';
+  } | null = null;
+
+  const createStreamSegmentId = (type: 'thinking' | 'text') => {
+    streamSegmentCursor += 1;
+    return `${turnId}:${type}:${streamSegmentCursor}`;
+  };
+
+  const appendTextDeltaInOrder = (text: string, isReasoning: boolean) => {
+    const type: 'thinking' | 'text' = isReasoning ? 'thinking' : 'text';
+    if (!activeTextSegment || activeTextSegment.type !== type) {
+      activeTextSegment = {
+        id: createStreamSegmentId(type),
+        type,
+      };
+    }
+    appendSegment(turnId, activeTextSegment.id, type, text);
+  };
+
+  const breakTextDeltaContinuation = () => {
+    activeTextSegment = null;
+  };
+
+  const readToolCallIdFromResult = (event: AgentToolResultEvent): string | undefined => {
+    if (!event.toolCall || typeof event.toolCall !== 'object') {
+      return undefined;
+    }
+    const maybeId = (event.toolCall as { id?: unknown }).id;
+    return typeof maybeId === 'string' ? maybeId : undefined;
+  };
+
+  const readToolCallIdFromUse = (event: AgentToolUseEvent): string | undefined => {
+    if (!event || typeof event !== 'object') {
+      return undefined;
+    }
+    const maybeId = (event as { id?: unknown }).id;
+    return typeof maybeId === 'string' ? maybeId : undefined;
+  };
+
+  const logEvent = (text: string) => {
+    if (!showEvents) {
+      return;
+    }
+    appendEventLine(turnId, text);
+  };
+
+  return {
+    onTextDelta: event => {
+      if (!isCurrentRequest() || !event.text) {
+        return;
+      }
+      appendTextDeltaInOrder(event.text, Boolean(event.isReasoning));
+    },
+    onTextComplete: () => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      breakTextDeltaContinuation();
+      logEvent('[text-complete]');
+    },
+    onToolStream: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      breakTextDeltaContinuation();
+      const mapped = formatToolStreamEvent(event);
+      if (mapped.codeChunk && mapped.segmentKey) {
+        appendSegment(turnId, `${turnId}:tool:${mapped.segmentKey}`, 'code', mapped.codeChunk);
+      }
+      if (
+        (event.type === 'stdout' || event.type === 'stderr') &&
+        typeof event.toolCallId === 'string' &&
+        event.toolCallId.length > 0
+      ) {
+        streamedToolCallIds.add(event.toolCallId);
+      }
+      if (mapped.note) {
+        logEvent(mapped.note);
+      }
+    },
+    onToolConfirm: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      logEvent(formatToolConfirmEvent(event));
+    },
+    onToolUse: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      breakTextDeltaContinuation();
+      const toolCallId = readToolCallIdFromUse(event);
+      if (toolCallId && renderedToolUseIds.has(toolCallId)) {
+        return;
+      }
+      if (toolCallId) {
+        renderedToolUseIds.add(toolCallId);
+      }
+      const segmentSuffix = toolCallId ?? `anonymous_${++anonymousToolUseCounter}`;
+      appendSegment(
+        turnId,
+        `${turnId}:tool-use:${segmentSuffix}`,
+        'code',
+        `${formatToolUseEventCode(event)}\n`,
+        event
+      );
+      logEvent(formatToolUseEvent(event));
+    },
+    onToolResult: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      breakTextDeltaContinuation();
+      const toolCallId = readToolCallIdFromResult(event);
+      const suppressOutput = Boolean(toolCallId && streamedToolCallIds.has(toolCallId));
+      const segmentSuffix = toolCallId ?? `anonymous_${++anonymousToolResultCounter}`;
+      appendSegment(
+        turnId,
+        `${turnId}:tool-result:${segmentSuffix}`,
+        'code',
+        `${formatToolResultEventCode(event, { suppressOutput })}\n`,
+        event
+      );
+      logEvent(formatToolResultEvent(event));
+    },
+    onStep: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      logEvent(formatStepEvent(event));
+    },
+    onLoop: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      logEvent(formatLoopEvent(event));
+    },
+    onStop: event => {
+      if (!isCurrentRequest()) {
+        return;
+      }
+      breakTextDeltaContinuation();
+      logEvent(formatStopEvent(event));
+    },
+  };
+};