@renxqoo/renx-code 0.0.9 → 0.0.12

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

@@ -1,621 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-
-import { resolveSlashCommand } from '../commands/slash-commands';
-import {
-  getAgentModelAttachmentCapabilities,
-  getAgentModelLabel,
-  runAgentPrompt,
-} from '../agent/runtime/runtime';
-import type {
-  AgentContextUsageEvent,
-  AgentToolConfirmDecision,
-  AgentToolConfirmEvent,
-  AgentUsageEvent,
-} from '../agent/runtime/types';
-import { requestExit } from '../runtime/exit';
-import type { ChatTurn, ReplySegmentType } from '../types/chat';
-import type { PromptFileSelection } from '../files/types';
-import { buildAgentEventHandlers } from './agent-event-handlers';
-import {
-  buildHelpSegments,
-  buildUnsupportedSegments,
-  extractErrorMessage,
-} from './chat-local-replies';
-import {
-  appendNoteLine,
-  appendToSegment,
-  createStreamingReply,
-  orderReplySegments,
-  patchTurn,
-  setReplyStatus,
-} from './turn-updater';
-import {
-  DEFAULT_ATTACHMENT_MODEL_CAPABILITIES,
-  type AttachmentModelCapabilities,
-} from '../files/attachment-capabilities';
-import { buildPromptContent } from '../files/attachment-content';
-import { buildPromptDisplay } from '../files/prompt-display';
-
-export type UseAgentChatResult = {
-  turns: ChatTurn[];
-  inputValue: string;
-  selectedFiles: PromptFileSelection[];
-  isThinking: boolean;
-  modelLabel: string;
-  contextUsagePercent: number | null;
-  pendingToolConfirm: (AgentToolConfirmEvent & { selectedAction: 'approve' | 'deny' }) | null;
-  setInputValue: (value: string) => void;
-  setSelectedFiles: (files: PromptFileSelection[]) => void;
-  appendSelectedFiles: (files: PromptFileSelection[]) => void;
-  removeSelectedFile: (absolutePath: string) => void;
-  submitInput: () => void;
-  stopActiveReply: () => void;
-  clearInput: () => void;
-  resetConversation: () => void;
-  setModelLabelDisplay: (label: string) => void;
-  setToolConfirmSelection: (selection: 'approve' | 'deny') => void;
-  submitToolConfirmSelection: () => void;
-  rejectPendingToolConfirm: () => void;
-};
-
-const INITIAL_MODEL_LABEL = process.env.AGENT_MODEL?.trim() || '';
-
-const normalizeTokenCount = (value: number | undefined): number | undefined => {
-  if (typeof value !== 'number' || !Number.isFinite(value)) {
-    return undefined;
-  }
-  return Math.max(0, Math.round(value));
-};
-
-/** Normalizes context usage percent, ensuring it's a finite non-negative number. */
-const normalizeContextUsagePercent = (value: unknown): number | null => {
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return Math.max(0, value);
-  }
-  return null;
-};
-
-const toReplyUsage = (
-  usage?: AgentUsageEvent
-):
-  | {
-      usagePromptTokens?: number;
-      usageCompletionTokens?: number;
-      usageTotalTokens?: number;
-    }
-  | undefined => {
-  if (!usage) {
-    return undefined;
-  }
-
-  const usagePromptTokens = normalizeTokenCount(usage.cumulativePromptTokens ?? usage.promptTokens);
-  const usageCompletionTokens = normalizeTokenCount(
-    usage.cumulativeCompletionTokens ?? usage.completionTokens
-  );
-  const usageTotalTokens = normalizeTokenCount(usage.cumulativeTotalTokens ?? usage.totalTokens);
-
-  if (
-    typeof usagePromptTokens !== 'number' &&
-    typeof usageCompletionTokens !== 'number' &&
-    typeof usageTotalTokens !== 'number'
-  ) {
-    return undefined;
-  }
-
-  return {
-    usagePromptTokens,
-    usageCompletionTokens,
-    usageTotalTokens,
-  };
-};
-
-export const resolveReplyStatus = (completionReason: string): 'done' | 'error' => {
-  return completionReason === 'error' ? 'error' : 'done';
-};
-
-export const useAgentChat = (): UseAgentChatResult => {
-  const [turns, setTurns] = useState<ChatTurn[]>([]);
-  const [inputValue, setInputValue] = useState('');
-  const [selectedFiles, setSelectedFiles] = useState<PromptFileSelection[]>([]);
-  const [isThinking, setIsThinking] = useState(false);
-  const [modelLabel, setModelLabel] = useState(INITIAL_MODEL_LABEL);
-  const [contextUsagePercent, setContextUsagePercent] = useState<number | null>(null);
-  const [attachmentCapabilities, setAttachmentCapabilities] = useState<AttachmentModelCapabilities>(
-    DEFAULT_ATTACHMENT_MODEL_CAPABILITIES
-  );
-  const [pendingToolConfirm, setPendingToolConfirm] = useState<
-    (AgentToolConfirmEvent & { selectedAction: 'approve' | 'deny' }) | null
-  >(null);
-
-  const removeSelectedFile = useCallback((absolutePath: string) => {
-    setSelectedFiles(current => current.filter(file => file.absolutePath !== absolutePath));
-  }, []);
-
-  const appendSelectedFiles = useCallback((files: PromptFileSelection[]) => {
-    if (files.length === 0) {
-      return;
-    }
-    setSelectedFiles(current => {
-      const seen = new Set(current.map(file => file.absolutePath));
-      const next = [...current];
-      for (const file of files) {
-        if (seen.has(file.absolutePath)) {
-          continue;
-        }
-        next.push(file);
-        seen.add(file.absolutePath);
-      }
-      return next;
-    });
-  }, []);
-
-  const turnIdRef = useRef(1);
-  const requestIdRef = useRef(0);
-  const activeTurnIdRef = useRef<number | null>(null);
-  const activeAbortControllerRef = useRef<AbortController | null>(null);
-  const activeRunPromiseRef = useRef<Promise<void> | null>(null);
-  const pendingToolConfirmResolverRef = useRef<
-    ((decision: AgentToolConfirmDecision) => void) | null
-  >(null);
-
-  const resolvePendingToolConfirm = useCallback((decision: AgentToolConfirmDecision) => {
-    const resolver = pendingToolConfirmResolverRef.current;
-    pendingToolConfirmResolverRef.current = null;
-    setPendingToolConfirm(null);
-    resolver?.(decision);
-  }, []);
-
-  useEffect(() => {
-    let disposed = false;
-    void getAgentModelLabel()
-      .then(label => {
-        if (!disposed) {
-          setModelLabel(label);
-        }
-      })
-      .catch(() => {});
-    void getAgentModelAttachmentCapabilities()
-      .then(capabilities => {
-        if (!disposed) {
-          setAttachmentCapabilities(capabilities);
-        }
-      })
-      .catch(() => {});
-
-    return () => {
-      disposed = true;
-    };
-  }, []);
-
-  useEffect(() => {
-    return () => {
-      // 清理活动的Promise以防止内存泄漏
-      const currentPromise = activeRunPromiseRef.current;
-      if (currentPromise) {
-        currentPromise.catch(() => {}); // 防止未处理的rejection
-      }
-      activeAbortControllerRef.current?.abort();
-      const resolver = pendingToolConfirmResolverRef.current;
-      pendingToolConfirmResolverRef.current = null;
-      resolver?.({
-        approved: false,
-        message: 'Tool confirmation cancelled because the UI was closed.',
-      });
-    };
-  }, []);
-
-  const appendSegment = useCallback(
-    (turnId: number, segmentId: string, type: ReplySegmentType, chunk: string, data?: unknown) => {
-      setTurns(prev =>
-        patchTurn(prev, turnId, turn => {
-          if (!turn.reply) {
-            return turn;
-          }
-          return {
-            ...turn,
-            reply: {
-              ...turn.reply,
-              segments: orderReplySegments(
-                appendToSegment(turn.reply.segments, segmentId, type, chunk, data)
-              ),
-            },
-          };
-        })
-      );
-    },
-    []
-  );
-
-  const appendEventLine = useCallback((turnId: number, text: string) => {
-    setTurns(prev =>
-      patchTurn(prev, turnId, turn => {
-        if (!turn.reply) {
-          return turn;
-        }
-        return {
-          ...turn,
-          reply: {
-            ...turn.reply,
-            segments: orderReplySegments(
-              appendNoteLine(turn.reply.segments, `${turnId}:events`, text)
-            ),
-          },
-        };
-      })
-    );
-  }, []);
-
-  const stopActiveReply = useCallback(() => {
-    if (!isThinking) {
-      return;
-    }
-
-    requestIdRef.current += 1;
-    activeAbortControllerRef.current?.abort();
-    activeAbortControllerRef.current = null;
-    setIsThinking(false);
-
-    const activeTurnId = activeTurnIdRef.current;
-    activeTurnIdRef.current = null;
-    if (typeof activeTurnId !== 'number') {
-      return;
-    }
-
-    appendEventLine(activeTurnId, '[stop] aborted by user');
-    setTurns(prev =>
-      setReplyStatus(prev, activeTurnId, 'done', {
-        completionReason: 'cancelled',
-        completionMessage: 'Stopped by user.',
-      })
-    );
-  }, [appendEventLine, isThinking]);
-
-  const resetConversation = useCallback(() => {
-    resolvePendingToolConfirm({
-      approved: false,
-      message: 'Tool confirmation cancelled because the conversation was reset.',
-    });
-    requestIdRef.current += 1;
-    activeAbortControllerRef.current?.abort();
-    activeAbortControllerRef.current = null;
-    activeTurnIdRef.current = null;
-    setIsThinking(false);
-    setTurns([]);
-    setSelectedFiles([]);
-    setContextUsagePercent(() => null);
-  }, [resolvePendingToolConfirm]);
-
-  const addTurn = useCallback(
-    (prompt: string, withStreamingReply = false, files: PromptFileSelection[] = []): number => {
-      const turnId = turnIdRef.current++;
-      const displayPrompt = buildPromptDisplay(prompt, files);
-      setTurns(prev => [
-        ...prev,
-        {
-          id: turnId,
-          prompt: displayPrompt,
-          files: files.map(file => file.relativePath),
-          createdAtMs: Date.now(),
-          reply: withStreamingReply ? createStreamingReply(modelLabel) : undefined,
-        },
-      ]);
-      return turnId;
-    },
-    [modelLabel]
-  );
-
-  const setImmediateReply = useCallback(
-    (
-      turnId: number,
-      segments: Array<{ id: string; type: 'thinking' | 'text'; content: string }>
-    ) => {
-      setTurns(prev =>
-        patchTurn(prev, turnId, turn => ({
-          ...turn,
-          reply: {
-            ...createStreamingReply(modelLabel),
-            status: 'done',
-            durationSeconds: 0,
-            segments,
-          },
-        }))
-      );
-    },
-    [modelLabel]
-  );
-
-  const runCommand = useCallback(
-    (commandText: string): boolean => {
-      const command = resolveSlashCommand(commandText);
-      if (!command) {
-        return false;
-      }
-
-      if (command.action === 'clear') {
-        resetConversation();
-        return true;
-      }
-
-      if (command.action === 'exit') {
-        requestExit(0);
-        return true;
-      }
-
-      if (command.action === 'help') {
-        const turnId = addTurn(commandText.trim(), true);
-        setImmediateReply(turnId, buildHelpSegments(turnId));
-        return true;
-      }
-
-      const turnId = addTurn(commandText.trim(), true);
-      setImmediateReply(turnId, buildUnsupportedSegments(turnId, command.name));
-      return true;
-    },
-    [addTurn, resetConversation, setImmediateReply]
-  );
-
-  const submitInput = useCallback(() => {
-    const text = inputValue.trim();
-    const attachedFiles = selectedFiles;
-    if ((text.length === 0 && attachedFiles.length === 0) || isThinking) {
-      return;
-    }
-
-    setInputValue('');
-
-    if (attachedFiles.length === 0 && text.startsWith('/') && runCommand(text)) {
-      return;
-    }
-
-    setSelectedFiles([]);
-
-    void (async () => {
-      const previousRun = activeRunPromiseRef.current;
-      if (previousRun) {
-        await previousRun.catch(error => {
-          console.debug(
-            'Previous run failed:',
-            error instanceof Error ? error.message : String(error)
-          );
-        });
-      }
-
-      const turnId = addTurn(text, true, attachedFiles);
-      activeTurnIdRef.current = turnId;
-      const currentRequestId = ++requestIdRef.current;
-      const isCurrentRequest = () => currentRequestId === requestIdRef.current;
-      const abortController = new AbortController();
-      activeAbortControllerRef.current = abortController;
-
-      setIsThinking(true);
-
-      const baseHandlers = buildAgentEventHandlers({
-        turnId,
-        isCurrentRequest,
-        appendSegment,
-        appendEventLine,
-      });
-      const handlers = {
-        ...baseHandlers,
-        onToolConfirmRequest: (event: AgentToolConfirmEvent) => {
-          if (!isCurrentRequest()) {
-            return Promise.resolve({
-              approved: false,
-              message: 'Tool confirmation denied because the request is no longer active.',
-            });
-          }
-
-          if (pendingToolConfirmResolverRef.current) {
-            pendingToolConfirmResolverRef.current({
-              approved: false,
-              message: 'Superseded by a newer tool confirmation request.',
-            });
-            pendingToolConfirmResolverRef.current = null;
-          }
-
-          return new Promise<AgentToolConfirmDecision>(resolve => {
-            pendingToolConfirmResolverRef.current = resolve;
-            setPendingToolConfirm({
-              ...event,
-              selectedAction: 'approve',
-            });
-          });
-        },
-        onUsage: (event: AgentUsageEvent) => {
-          if (!isCurrentRequest()) {
-            return;
-          }
-          const normalized = normalizeContextUsagePercent(event.contextUsagePercent);
-          if (normalized !== null) {
-            setContextUsagePercent(normalized);
-          }
-          const replyUsage = toReplyUsage(event);
-          if (!replyUsage) {
-            return;
-          }
-          setTurns(prev =>
-            patchTurn(prev, turnId, turn => {
-              if (!turn.reply) {
-                return turn;
-              }
-              return {
-                ...turn,
-                reply: {
-                  ...turn.reply,
-                  ...replyUsage,
-                },
-              };
-            })
-          );
-        },
-        onContextUsage: (event: AgentContextUsageEvent) => {
-          if (!isCurrentRequest()) {
-            return;
-          }
-          const normalized = normalizeContextUsagePercent(event.contextUsagePercent);
-          if (normalized !== null) {
-            setContextUsagePercent(normalized);
-          }
-        },
-      };
-
-      const runPromise = buildPromptContent(text, attachedFiles, attachmentCapabilities)
-        .then(promptContent =>
-          runAgentPrompt(promptContent, handlers, {
-            abortSignal: abortController.signal,
-          })
-        )
-        .then(result => {
-          if (!isCurrentRequest()) {
-            return;
-          }
-
-          setModelLabel(result.modelLabel);
-          if (result.usage) {
-            const normalized = normalizeContextUsagePercent(result.usage.contextUsagePercent);
-            if (normalized !== null) {
-              setContextUsagePercent(normalized);
-            }
-          }
-          const replyUsage = toReplyUsage(result.usage);
-          setTurns(prev => {
-            const withFallbackText = patchTurn(prev, turnId, turn => {
-              if (!turn.reply || !result.text) {
-                return turn;
-              }
-
-              const hasAssistantText = turn.reply.segments.some(
-                segment =>
-                  (segment.type === 'text' || segment.type === 'thinking') &&
-                  segment.content.trim().length > 0
-              );
-              if (hasAssistantText) {
-                return turn;
-              }
-
-              return {
-                ...turn,
-                reply: {
-                  ...turn.reply,
-                  segments: orderReplySegments(
-                    appendToSegment(turn.reply.segments, `${turnId}:text`, 'text', result.text)
-                  ),
-                },
-              };
-            });
-
-            return setReplyStatus(
-              withFallbackText,
-              turnId,
-              resolveReplyStatus(result.completionReason),
-              {
-                durationSeconds: result.durationSeconds,
-                completionReason: result.completionReason,
-                completionMessage: result.completionMessage,
-                modelLabel: result.modelLabel,
-                ...(replyUsage ?? {}),
-              }
-            );
-          });
-        })
-        .catch(error => {
-          if (!isCurrentRequest()) {
-            return;
-          }
-          appendEventLine(turnId, `[error] ${extractErrorMessage(error)}`);
-          setTurns(prev => setReplyStatus(prev, turnId, 'error'));
-        })
-        .finally(() => {
-          if (activeAbortControllerRef.current === abortController) {
-            activeAbortControllerRef.current = null;
-          }
-          if (activeTurnIdRef.current === turnId) {
-            activeTurnIdRef.current = null;
-          }
-          if (!isCurrentRequest()) {
-            return;
-          }
-          setIsThinking(false);
-        });
-
-      const trackedRunPromise = runPromise.finally(() => {
-        if (activeRunPromiseRef.current === trackedRunPromise) {
-          activeRunPromiseRef.current = null;
-        }
-      });
-      activeRunPromiseRef.current = trackedRunPromise;
-      await trackedRunPromise;
-    })();
-  }, [
-    addTurn,
-    appendEventLine,
-    appendSegment,
-    attachmentCapabilities,
-    inputValue,
-    isThinking,
-    runCommand,
-    selectedFiles,
-  ]);
-
-  const clearInput = useCallback(() => {
-    setInputValue('');
-    setSelectedFiles([]);
-  }, []);
-
-  const setModelLabelDisplay = useCallback((label: string) => {
-    setModelLabel(label);
-    void getAgentModelAttachmentCapabilities()
-      .then(capabilities => {
-        setAttachmentCapabilities(capabilities);
-      })
-      .catch(() => {});
-  }, []);
-
-  const setToolConfirmSelection = useCallback((selection: 'approve' | 'deny') => {
-    setPendingToolConfirm(current =>
-      current ? { ...current, selectedAction: selection } : current
-    );
-  }, []);
-
-  const rejectPendingToolConfirm = useCallback(() => {
-    resolvePendingToolConfirm({
-      approved: false,
-      message: 'Tool call denied by user.',
-    });
-  }, [resolvePendingToolConfirm]);
-
-  const submitToolConfirmSelection = useCallback(() => {
-    if (!pendingToolConfirm) {
-      return;
-    }
-
-    if (pendingToolConfirm.selectedAction === 'deny') {
-      rejectPendingToolConfirm();
-      return;
-    }
-
-    resolvePendingToolConfirm({ approved: true });
-  }, [pendingToolConfirm, rejectPendingToolConfirm, resolvePendingToolConfirm]);
-
-  return {
-    turns,
-    inputValue,
-    selectedFiles,
-    isThinking,
-    modelLabel,
-    contextUsagePercent,
-    pendingToolConfirm,
-    setInputValue,
-    setSelectedFiles,
-    appendSelectedFiles,
-    removeSelectedFile,
-    submitInput,
-    stopActiveReply,
-    clearInput,
-    resetConversation,
-    setModelLabelDisplay,
-    setToolConfirmSelection,
-    submitToolConfirmSelection,
-    rejectPendingToolConfirm,
-  };
-};