@renxqoo/renx-code 0.0.9 → 0.0.12

package/src/files/attachment-content.ts

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

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

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

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

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

package/src/files/workspace-files.ts

@@ -1,61 +0,0 @@
-import { readdir, stat } 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 fileStat = await stat(absolutePath).catch(() => undefined);
-    if (!fileStat || !fileStat.isFile()) {
-      continue;
-    }
-
-    output.push({
-      relativePath: relative(root, absolutePath),
-      absolutePath,
-      size: fileStat.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

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

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