@renxqoo/renx-code 0.0.9 → 0.0.12

package/src/agent/runtime/tool-call-buffer.ts

@@ -1,60 +0,0 @@
-import type { AgentToolUseEvent } from './types';
-
-const readToolCallId = (event: AgentToolUseEvent): string | undefined => {
-  const maybeId = (event as { id?: unknown }).id;
-  return typeof maybeId === 'string' && maybeId.length > 0 ? maybeId : undefined;
-};
-
-export class ToolCallBuffer {
-  private readonly plannedOrder: string[] = [];
-  private readonly plannedIds = new Set<string>();
-  private readonly toolCallsById = new Map<string, AgentToolUseEvent>();
-  private readonly emittedIds = new Set<string>();
-
-  register(
-    toolCall: AgentToolUseEvent,
-    emit: (event: AgentToolUseEvent) => void,
-    executing = false
-  ) {
-    const toolCallId = readToolCallId(toolCall);
-    if (!toolCallId) {
-      emit(toolCall);
-      return;
-    }
-
-    this.toolCallsById.set(toolCallId, toolCall);
-    if (!this.plannedIds.has(toolCallId)) {
-      this.plannedIds.add(toolCallId);
-      this.plannedOrder.push(toolCallId);
-    }
-
-    if (executing) {
-      this.emit(toolCallId, emit);
-    }
-  }
-
-  flush(emit: (event: AgentToolUseEvent) => void) {
-    for (const toolCallId of this.plannedOrder) {
-      this.emit(toolCallId, emit);
-    }
-  }
-
-  ensureEmitted(toolCallId: string | undefined, emit: (event: AgentToolUseEvent) => void) {
-    if (!toolCallId) {
-      return;
-    }
-    this.emit(toolCallId, emit);
-  }
-
-  private emit(toolCallId: string, emit: (event: AgentToolUseEvent) => void) {
-    if (this.emittedIds.has(toolCallId)) {
-      return;
-    }
-    const toolCall = this.toolCallsById.get(toolCallId);
-    if (!toolCall) {
-      return;
-    }
-    this.emittedIds.add(toolCallId);
-    emit(toolCall);
-  }
-}

package/src/agent/runtime/tool-confirmation.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import type { AgentEventHandlers, AgentToolConfirmEvent } from './types';
-
-const TOOL_CONFIRM_EVENT: AgentToolConfirmEvent = {
-  toolCallId: 'call_1',
-  toolName: 'glob',
-  args: {
-    pattern: '**/*sandbox*',
-    path: '/tmp/project',
-  },
-  rawArgs: {
-    pattern: '**/*sandbox*',
-    path: '/tmp/project',
-  },
-  reason: 'SEARCH_PATH_NOT_ALLOWED: /tmp/project is outside allowed directories: /workspace',
-  metadata: {
-    requestedPath: '/tmp/project',
-    allowedDirectories: ['/workspace'],
-  },
-};
-
-describe('resolveToolConfirmDecision', () => {
-  it('asks the UI callback when registered', async () => {
-    const { resolveToolConfirmDecision } =
-      await vi.importActual<typeof import('./tool-confirmation')>('./tool-confirmation');
-    const calls: AgentToolConfirmEvent[] = [];
-    const onToolConfirmRequest: NonNullable<
-      AgentEventHandlers['onToolConfirmRequest']
-    > = async event => {
-      calls.push(event);
-      return {
-        approved: false,
-        message: 'Denied by user',
-      };
-    };
-
-    const decision = await resolveToolConfirmDecision(TOOL_CONFIRM_EVENT, { onToolConfirmRequest });
-
-    expect(decision).toEqual({
-      approved: false,
-      message: 'Denied by user',
-    });
-    expect(calls).toEqual([TOOL_CONFIRM_EVENT]);
-  });
-
-  it('falls back to approve when no UI callback is registered', async () => {
-    const { resolveToolConfirmDecision } =
-      await vi.importActual<typeof import('./tool-confirmation')>('./tool-confirmation');
-    const decision = await resolveToolConfirmDecision(TOOL_CONFIRM_EVENT, {});
-
-    expect(decision).toEqual({
-      approved: true,
-    });
-  });
-});

package/src/agent/runtime/tool-confirmation.ts

@@ -1,15 +0,0 @@
-import type { AgentEventHandlers, AgentToolConfirmDecision, AgentToolConfirmEvent } from './types';
-
-const DEFAULT_FALLBACK_DECISION: AgentToolConfirmDecision = { approved: true };
-
-export const resolveToolConfirmDecision = async (
-  event: AgentToolConfirmEvent,
-  handlers: AgentEventHandlers
-): Promise<AgentToolConfirmDecision> => {
-  if (!handlers.onToolConfirmRequest) {
-    return DEFAULT_FALLBACK_DECISION;
-  }
-
-  const decision = await handlers.onToolConfirmRequest(event);
-  return decision ?? { approved: false, message: 'Tool confirmation was not resolved.' };
-};

package/src/agent/runtime/types.ts

@@ -1,99 +0,0 @@
-export type AgentTextDeltaEvent = {
-  text: string;
-  isReasoning?: boolean;
-};
-
-export type AgentToolStreamEvent = {
-  toolCallId: string;
-  toolName: string;
-  type: string;
-  sequence: number;
-  timestamp: number;
-  content?: string;
-  data?: unknown;
-};
-
-export type AgentToolConfirmEvent = {
-  toolCallId: string;
-  toolName: string;
-  args: Record<string, unknown>;
-  rawArgs: Record<string, unknown>;
-  reason?: string;
-  metadata?: Record<string, unknown>;
-};
-
-export type AgentToolConfirmDecision = {
-  approved: boolean;
-  message?: string;
-};
-
-export type AgentStepEvent = {
-  stepIndex: number;
-  finishReason?: string;
-  toolCallsCount: number;
-};
-
-export type AgentToolUseEvent = {
-  [key: string]: unknown;
-};
-
-export type AgentToolResultEvent = {
-  toolCall: unknown;
-  result: unknown;
-};
-
-export type AgentLoopEvent = {
-  loopIndex: number;
-  steps: number;
-};
-
-export type AgentStopEvent = {
-  reason: string;
-  message?: string;
-};
-
-export type AgentUsageEvent = {
-  promptTokens: number;
-  completionTokens: number;
-  totalTokens: number;
-  cumulativePromptTokens?: number;
-  cumulativeCompletionTokens?: number;
-  cumulativeTotalTokens?: number;
-  contextTokens?: number;
-  contextLimit?: number;
-  contextUsagePercent?: number;
-};
-
-export type AgentContextUsageEvent = {
-  stepIndex: number;
-  messageCount: number;
-  contextTokens: number;
-  contextLimit: number;
-  contextUsagePercent: number;
-};
-
-export type AgentEventHandlers = {
-  onTextDelta?: (event: AgentTextDeltaEvent) => void;
-  onTextComplete?: (text: string) => void;
-  onToolStream?: (event: AgentToolStreamEvent) => void;
-  onToolConfirm?: (event: AgentToolConfirmEvent) => void;
-  onToolConfirmRequest?: (
-    event: AgentToolConfirmEvent
-  ) => AgentToolConfirmDecision | Promise<AgentToolConfirmDecision>;
-  onToolUse?: (event: AgentToolUseEvent) => void;
-  onToolResult?: (event: AgentToolResultEvent) => void;
-  onStep?: (event: AgentStepEvent) => void;
-  onLoop?: (event: AgentLoopEvent) => void;
-  onStop?: (event: AgentStopEvent) => void;
-  onContextUsage?: (event: AgentContextUsageEvent) => void;
-  onUsage?: (event: AgentUsageEvent) => void;
-};
-
-export type AgentRunResult = {
-  text: string;
-  completionReason: string;
-  completionMessage?: string;
-  durationSeconds: number;
-  modelLabel: string;
-  usage?: AgentUsageEvent;
-};

package/src/commands/slash-commands.test.ts

@@ -1,216 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { SLASH_COMMANDS, filterSlashCommands, resolveSlashCommand } from './slash-commands';
-
-describe('slash-commands', () => {
-  describe('resolveSlashCommand', () => {
-    it('should return null for empty input', () => {
-      expect(resolveSlashCommand('')).toBe(null);
-      expect(resolveSlashCommand('   ')).toBe(null);
-      expect(resolveSlashCommand('\t\n')).toBe(null);
-    });
-
-    it('should return null for non-slash commands', () => {
-      expect(resolveSlashCommand('hello world')).toBe(null);
-      // 'help me' returns help command because the first token 'help' matches
-      // but the caller checks text.startsWith('/') before using runCommand
-      expect(resolveSlashCommand('help me')?.name).toBe('help');
-      expect(resolveSlashCommand('/invalid')).toBe(null);
-    });
-
-    it('should resolve commands by name', () => {
-      const helpCommand = resolveSlashCommand('/help');
-      expect(helpCommand).not.toBe(null);
-      expect(helpCommand?.name).toBe('help');
-      expect(helpCommand?.action).toBe('help');
-
-      const clearCommand = resolveSlashCommand('/clear');
-      expect(clearCommand?.name).toBe('clear');
-      expect(clearCommand?.action).toBe('clear');
-
-      const exitCommand = resolveSlashCommand('/exit');
-      expect(exitCommand?.name).toBe('exit');
-      expect(exitCommand?.action).toBe('exit');
-
-      const modelsCommand = resolveSlashCommand('/models');
-      expect(modelsCommand?.name).toBe('models');
-      expect(modelsCommand?.action).toBe('models');
-
-      const filesCommand = resolveSlashCommand('/files');
-      expect(filesCommand?.name).toBe('files');
-      expect(filesCommand?.action).toBe('files');
-    });
-
-    it('should resolve commands with aliases', () => {
-      // Test aliases for clear
-      const clearAlias1 = resolveSlashCommand('/new');
-      expect(clearAlias1?.name).toBe('clear');
-      expect(clearAlias1?.action).toBe('clear');
-
-      // Test aliases for exit
-      const exitAlias1 = resolveSlashCommand('/quit');
-      expect(exitAlias1?.name).toBe('exit');
-      expect(exitAlias1?.action).toBe('exit');
-
-      const exitAlias2 = resolveSlashCommand('/q');
-      expect(exitAlias2?.name).toBe('exit');
-      expect(exitAlias2?.action).toBe('exit');
-
-      // Test aliases for help
-      const helpAlias1 = resolveSlashCommand('/commands');
-      expect(helpAlias1?.name).toBe('help');
-      expect(helpAlias1?.action).toBe('help');
-
-      // Test aliases for models
-      const modelsAlias1 = resolveSlashCommand('/model');
-      expect(modelsAlias1?.name).toBe('models');
-      expect(modelsAlias1?.action).toBe('models');
-
-      const filesAlias1 = resolveSlashCommand('/file');
-      expect(filesAlias1?.name).toBe('files');
-      expect(filesAlias1?.action).toBe('files');
-    });
-
-    it('should resolve commands with extra text after command', () => {
-      const helpCommand = resolveSlashCommand('/help please');
-      expect(helpCommand?.name).toBe('help');
-
-      const clearCommand = resolveSlashCommand('/clear now');
-      expect(clearCommand?.name).toBe('clear');
-
-      const modelsCommand = resolveSlashCommand('/models with space');
-      expect(modelsCommand?.name).toBe('models');
-
-      const filesCommand = resolveSlashCommand('/files pick');
-      expect(filesCommand?.name).toBe('files');
-    });
-
-    it('should be case insensitive', () => {
-      expect(resolveSlashCommand('/HELP')?.name).toBe('help');
-      expect(resolveSlashCommand('/Help')?.name).toBe('help');
-      expect(resolveSlashCommand('/hElP')?.name).toBe('help');
-
-      expect(resolveSlashCommand('/CLEAR')?.name).toBe('clear');
-      expect(resolveSlashCommand('/Clear')?.name).toBe('clear');
-
-      expect(resolveSlashCommand('/MODELS')?.name).toBe('models');
-      expect(resolveSlashCommand('/Models')?.name).toBe('models');
-
-      expect(resolveSlashCommand('/FILES')?.name).toBe('files');
-      expect(resolveSlashCommand('/File')?.name).toBe('files');
-    });
-
-    it('should handle commands with leading/trailing spaces', () => {
-      expect(resolveSlashCommand('  /help  ')?.name).toBe('help');
-      expect(resolveSlashCommand('\t/clear\n')?.name).toBe('clear');
-      expect(resolveSlashCommand('  /models  please')?.name).toBe('models');
-      expect(resolveSlashCommand('  /files  now')?.name).toBe('files');
-    });
-
-    it('should return unsupported commands', () => {
-      const exportCommand = resolveSlashCommand('/export');
-      expect(exportCommand?.name).toBe('export');
-      expect(exportCommand?.action).toBe('unsupported');
-
-      const forkCommand = resolveSlashCommand('/fork');
-      expect(forkCommand?.name).toBe('fork');
-      expect(forkCommand?.action).toBe('unsupported');
-    });
-  });
-
-  describe('filterSlashCommands', () => {
-    it('should return all commands for empty query', () => {
-      const result = filterSlashCommands('');
-      expect(result).toEqual(SLASH_COMMANDS);
-
-      const result2 = filterSlashCommands('   ');
-      expect(result2).toEqual(SLASH_COMMANDS);
-    });
-
-    it('should filter commands by name prefix', () => {
-      const result = filterSlashCommands('h');
-      expect(result.length).toBeGreaterThan(0);
-      expect(
-        result.every(
-          cmd => cmd.name.includes('h') || cmd.aliases?.some(alias => alias.includes('h'))
-        )
-      ).toBe(true);
-
-      const result2 = filterSlashCommands('he');
-      const helpCommands = result2.filter(
-        cmd => cmd.name.startsWith('he') || cmd.aliases?.some(alias => alias.startsWith('he'))
-      );
-      expect(helpCommands.length).toBeGreaterThan(0);
-    });
-
-    it('should filter commands by name substring', () => {
-      const result = filterSlashCommands('elp'); // part of "help"
-      expect(result.length).toBeGreaterThan(0);
-      expect(result.some(cmd => cmd.name === 'help')).toBe(true);
-    });
-
-    it('should filter commands by alias', () => {
-      const result = filterSlashCommands('q'); // alias for exit
-      expect(result.some(cmd => cmd.name === 'exit')).toBe(true);
-
-      const result2 = filterSlashCommands('commands'); // alias for help
-      expect(result2.some(cmd => cmd.name === 'help')).toBe(true);
-    });
-
-    it('should be case insensitive', () => {
-      const result1 = filterSlashCommands('HELP');
-      const result2 = filterSlashCommands('help');
-      expect(result1).toEqual(result2);
-
-      const result3 = filterSlashCommands('CLEAR');
-      const result4 = filterSlashCommands('clear');
-      expect(result3).toEqual(result4);
-    });
-
-    it('should handle queries with spaces', () => {
-      const result = filterSlashCommands('  help  ');
-      expect(result.some(cmd => cmd.name === 'help')).toBe(true);
-    });
-
-    it('should return empty array for non-matching query', () => {
-      const result = filterSlashCommands('xyz123nonexistent');
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('SLASH_COMMANDS', () => {
-    it('should have required fields for all commands', () => {
-      SLASH_COMMANDS.forEach(command => {
-        expect(command.name).toBeDefined();
-        expect(command.description).toBeDefined();
-        expect(command.action).toBeDefined();
-        expect(['help', 'clear', 'exit', 'models', 'files', 'unsupported']).toContain(
-          command.action
-        );
-      });
-    });
-
-    it('should have unique names', () => {
-      const names = SLASH_COMMANDS.map(cmd => cmd.name);
-      const uniqueNames = new Set(names);
-      expect(names.length).toBe(uniqueNames.size);
-    });
-
-    it('should have proper aliases', () => {
-      const clearCommand = SLASH_COMMANDS.find(cmd => cmd.name === 'clear');
-      expect(clearCommand?.aliases).toEqual(['new']);
-
-      const exitCommand = SLASH_COMMANDS.find(cmd => cmd.name === 'exit');
-      expect(exitCommand?.aliases).toEqual(['quit', 'q']);
-
-      const helpCommand = SLASH_COMMANDS.find(cmd => cmd.name === 'help');
-      expect(helpCommand?.aliases).toEqual(['commands']);
-
-      const modelsCommand = SLASH_COMMANDS.find(cmd => cmd.name === 'models');
-      expect(modelsCommand?.aliases).toEqual(['model']);
-
-      const filesCommand = SLASH_COMMANDS.find(cmd => cmd.name === 'files');
-      expect(filesCommand?.aliases).toEqual(['file']);
-    });
-  });
-});

package/src/commands/slash-commands.ts

@@ -1,64 +0,0 @@
-export type SlashCommandAction = 'help' | 'clear' | 'exit' | 'models' | 'files' | 'unsupported';
-
-export type SlashCommandDefinition = {
-  name: string;
-  description: string;
-  action: SlashCommandAction;
-  aliases?: string[];
-};
-
-export const SLASH_COMMANDS: SlashCommandDefinition[] = [
-  { name: 'help', description: 'Help', action: 'help', aliases: ['commands'] },
-  { name: 'clear', description: 'Clear conversation', action: 'clear', aliases: ['new'] },
-  { name: 'exit', description: 'Exit app', action: 'exit', aliases: ['quit', 'q'] },
-  { name: 'export', description: 'Export session transcript', action: 'unsupported' },
-  { name: 'fork', description: 'Fork from message', action: 'unsupported' },
-  { name: 'init', description: 'create/update AGENTS.md', action: 'unsupported' },
-  { name: 'mcps', description: 'Toggle MCPs', action: 'unsupported', aliases: ['mcp'] },
-  { name: 'models', description: 'Switch model', action: 'models', aliases: ['model'] },
-  { name: 'files', description: 'Attach workspace files', action: 'files', aliases: ['file'] },
-  { name: 'rename', description: 'Rename session', action: 'unsupported' },
-  { name: 'review', description: 'Review changes', action: 'unsupported' },
-  { name: 'sessions', description: 'Switch session', action: 'unsupported', aliases: ['session'] },
-];
-
-const normalize = (value: string) => value.trim().toLowerCase();
-
-const getCommandToken = (value: string): string => {
-  const normalized = normalize(value);
-  const token = normalized.split(/\s+/, 1)[0] ?? '';
-  return token.startsWith('/') ? token.slice(1) : token;
-};
-
-export const resolveSlashCommand = (value: string): SlashCommandDefinition | null => {
-  const token = getCommandToken(value);
-  if (!token) {
-    return null;
-  }
-
-  return (
-    SLASH_COMMANDS.find(command => {
-      if (command.name === token) {
-        return true;
-      }
-      return command.aliases?.includes(token) ?? false;
-    }) ?? null
-  );
-};
-
-export const filterSlashCommands = (query: string): SlashCommandDefinition[] => {
-  const normalizedQuery = normalize(query);
-  if (!normalizedQuery) {
-    return SLASH_COMMANDS;
-  }
-
-  return SLASH_COMMANDS.filter(command => {
-    if (command.name.startsWith(normalizedQuery)) {
-      return true;
-    }
-    if (command.name.includes(normalizedQuery)) {
-      return true;
-    }
-    return command.aliases?.some(alias => alias.includes(normalizedQuery)) ?? false;
-  });
-};

package/src/components/chat/assistant-reply.test.tsx

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import type { AssistantReply as AssistantReplyType } from '../../types/chat';
-import { buildUsageItems, getCompletionErrorMessage } from './assistant-reply';
-
-const createReply = (overrides: Partial<AssistantReplyType> = {}): AssistantReplyType => ({
-  agentLabel: '',
-  modelLabel: 'glm-5',
-  durationSeconds: 0.8,
-  segments: [],
-  status: 'done',
-  ...overrides,
-});
-
-describe('assistant-reply helpers', () => {
-  it('extracts completion error messages for error replies', () => {
-    const reply = createReply({
-      status: 'error',
-      completionReason: 'error',
-      completionMessage: 'Server returned 500: upstream provider timeout',
-    });
-
-    expect(getCompletionErrorMessage(reply)).toBe('Server returned 500: upstream provider timeout');
-  });
-
-  it('ignores completion messages for non-error replies', () => {
-    const reply = createReply({
-      status: 'done',
-      completionReason: 'stop',
-      completionMessage: 'Should not be shown',
-    });
-
-    expect(getCompletionErrorMessage(reply)).toBeUndefined();
-  });
-
-  it('keeps usage items compact and directional', () => {
-    const reply = createReply({
-      usagePromptTokens: 1250,
-      usageCompletionTokens: 2400,
-    });
-
-    expect(buildUsageItems(reply)).toEqual([
-      { icon: '↑', value: '1.25k' },
-      { icon: '↓', value: '2.40k' },
-    ]);
-  });
-});