aegiscode 3.1.10 → 3.4.2

package/src/ui/hooks/useCommandProcessor.ts

@@ -1,443 +0,0 @@
-/**
- * useCommandProcessor - Command processing hook
- *
- * Extracts the core command processing logic (slash commands, agent chat,
- * streaming, tool calls, auto-compaction) from AegisInterface.
- */
-
-import { useCallback, useRef } from 'react';
-import type { Agent } from '../../agent/Agent.js';
-import type { ContextManager } from '../../context/index.js';
-import { TokenCounter } from '../../context/index.js';
-import type { Message, ToolCall, ToolResult } from '../../agent/types.js';
-import type { SlashCommandResult } from '../../slash-commands/types.js';
-import {
-  sessionActions,
-  commandActions,
-  appActions,
-  getState,
-} from '../../store/index.js';
-import { classifyComplexity, resolveModelForTier } from '../../agent/router.js';
-import type { ComplexityTier } from '../../agent/router.js';
-import {
-  applyStreamEvent,
-  finishToolCallInBuffer,
-  getBufferedToolCalls,
-} from '../../store/streaming-buffer.js';
-import type { ConfirmationHandler } from './useConfirmation.js';
-
-export interface UseCommandProcessorOptions {
-  agentRef: React.MutableRefObject<Agent | null>;
-  contextManagerRef: React.MutableRefObject<ContextManager | null>;
-  modelRef: React.MutableRefObject<string | undefined>;
-  debugRef: React.MutableRefObject<boolean | undefined>;
-  getMessagesRef: React.MutableRefObject<() => any[]>;
-  confirmationHandlerRef: React.MutableRefObject<ConfirmationHandler>;
-  onSelectorRequest?: (state: {
-    title: string;
-    options: Array<{ value: string; label: string }>;
-    handler: 'theme' | 'model' | null;
-  }) => void;
-}
-
-export interface UseCommandProcessorResult {
-  processCommand: (value: string, options?: { silent?: boolean }) => Promise<void>;
-  handleSubmit: (value: string) => Promise<void>;
-  processQueue: () => Promise<void>;
-}
-
-export function useCommandProcessor(options: UseCommandProcessorOptions): UseCommandProcessorResult {
-  const {
-    agentRef,
-    contextManagerRef,
-    modelRef,
-    debugRef,
-    getMessagesRef,
-    confirmationHandlerRef,
-    onSelectorRequest,
-  } = options;
-
-  // Auto-router: lazily-created Agent instances per model id, keyed by config
-  // model id, reused across turns so picking the same tier twice in a row
-  // doesn't pay an Agent.create() again. Each entry also stores the settings
-  // snapshot it was built with — requireConfirmation/allowedTools/
-  // disallowedTools are frozen into the Agent at creation time, so if the
-  // user toggles e.g. /confirm for that model after it's cached, the stale
-  // Agent would keep prompting forever. Comparing the snapshot before reuse
-  // (mirrors the same fix already applied to the main agentRef in
-  // useAgent.ts's model-switch subscription) catches that drift.
-  const routerAgentCacheRef = useRef<Map<string, { agent: Agent; settingsSnapshot: string }>>(new Map());
-  // Which model id the auto-router last swapped agentRef.current to (or
-  // undefined if it's still whatever /model or initial setup left it as).
-  const routerActiveModelIdRef = useRef<string | undefined>(undefined);
-
-  const processCommand = useCallback(async (value: string, options?: { silent?: boolean }) => {
-    const { isSlashCommand, executeSlashCommand } = await import('../../slash-commands/index.js');
-    const { vanillaStore } = await import('../../store/vanilla.js');
-    const { startBatch, batchAddUserMessage, batchAddAssistantMessage, batchSetThinking, flushBatchWithStore, cancelBatch } = await import('../../store/streaming-buffer.js');
-    const streamingBuf = await import('../../store/streaming-buffer.js');
-
-    if (isSlashCommand(value)) {
-      // Phase 1: flush user message + thinking=true immediately
-      sessionActions().setCurrentCommand(value);
-      startBatch();
-      batchAddUserMessage(value);
-      batchSetThinking(true);
-      flushBatchWithStore(vanillaStore);
-
-      let streamingMsgId: string | null = null;
-      let streamingResult: SlashCommandResult | null = null;
-      try {
-        streamingMsgId = sessionActions().startStreamingMessage();
-      } catch { /* streaming not available */ }
-
-      const onContentDelta = streamingMsgId
-        ? (delta: string) => { streamingBuf.appendToBuffer(delta); }
-        : undefined;
-
-      try {
-        streamingResult = await executeSlashCommand(value, {
-          cwd: process.cwd(),
-          sessionId: getState().session.sessionId,
-          messages: getMessagesRef.current(),
-          contextManager: contextManagerRef.current,
-          chatService: agentRef.current?.getChatService(),
-          modelName: modelRef.current,
-          onContentDelta,
-          onThinkingDelta: streamingMsgId
-            ? (delta: string) => { streamingBuf.appendThinkingToBuffer(delta); }
-            : undefined,
-          confirmationHandler: confirmationHandlerRef.current,
-        });
-
-        if (streamingResult.type === 'selector' && streamingResult.selector) {
-          sessionActions().setCurrentCommand(null);
-          sessionActions().setThinking(false);
-          if (streamingMsgId) sessionActions().finishStreamingMessage(streamingMsgId);
-          // Rollback: remove user command message + empty streaming message
-          // so WelcomeScreen stays visible (messages.length === 0)
-          sessionActions().removeLastMessages(2);
-          onSelectorRequest?.(streamingResult.selector);
-          return;
-        }
-
-        if (streamingResult.sendToAgent && streamingResult.content) {
-          // Don't clear currentCommand — it continues via processCommand below
-          sessionActions().setThinking(false);
-          if (streamingMsgId) sessionActions().finishStreamingMessage(streamingMsgId);
-          await processCommand(streamingResult.content, { silent: true });
-          return;
-        }
-
-        if (streamingResult.type === 'silent') {
-          if (streamingMsgId) sessionActions().finishStreamingMessage(streamingMsgId);
-          sessionActions().setCurrentCommand(null);
-          sessionActions().setThinking(false);
-          return;
-        }
-
-        startBatch();
-        if (streamingResult.content) {
-          batchAddAssistantMessage(streamingResult.content);
-        } else if (streamingResult.message) {
-          batchAddAssistantMessage(streamingResult.message);
-        } else if (streamingResult.error) {
-          batchAddAssistantMessage('error: ' + streamingResult.error);
-        }
-      } catch (error) {
-        startBatch();
-        batchAddAssistantMessage(
-          'error: ' + (error instanceof Error ? error.message : String(error))
-        );
-      } finally {
-        if (streamingMsgId && streamingResult?.type !== 'silent') {
-          try { sessionActions().finishStreamingMessage(streamingMsgId); } catch {}
-        }
-        sessionActions().setCurrentCommand(null);
-        batchSetThinking(false);
-        flushBatchWithStore(vanillaStore);
-      }
-      return;
-    }
-
-    if (!agentRef.current || !contextManagerRef.current) return;
-
-    const ctxManager = contextManagerRef.current;
-
-    // ==================== Auto-router ====================
-    // Pick a model for this turn based on task complexity, unless the user
-    // has manually chosen one with /model this session. Never throws —
-    // a classification or Agent.create failure just leaves the current
-    // agent/model in place.
-    // Captured here, recorded after the chat call resolves/aborts below —
-    // this is the learning loop's only outcome signal (see routerStats.ts).
-    let routedTier: ComplexityTier | undefined;
-    let routedModelId: string | undefined;
-    try {
-      const routerState = getState();
-      const autoRouter = routerState.config.config?.autoRouter;
-      const defaultModelId = routerState.config.config?.currentModelId;
-      const activeModelId = routerActiveModelIdRef.current ?? defaultModelId;
-
-      if (autoRouter?.enabled && !routerState.app.manualModelOverride) {
-        const models = routerState.config.config?.models || [];
-        const tier = classifyComplexity(value);
-        const targetModel = resolveModelForTier(tier, models, autoRouter.tiers);
-        const targetId = targetModel?.id;
-        const targetLabel = targetModel ? (targetModel.model || targetId) : undefined;
-
-        if (targetModel && targetId && targetId !== activeModelId) {
-          const settingsSnapshot = JSON.stringify({
-            requireConfirmation: targetModel.requireConfirmation,
-            allowedTools: targetModel.allowedTools,
-            disallowedTools: targetModel.disallowedTools,
-          });
-          const cached = routerAgentCacheRef.current.get(targetId);
-          let agent = cached && cached.settingsSnapshot === settingsSnapshot ? cached.agent : undefined;
-          if (!agent) {
-            const { Agent } = await import('../../agent/Agent.js');
-            agent = await Agent.create({
-              apiKey: targetModel.apiKey!,
-              baseURL: targetModel.baseURL,
-              model: targetLabel!,
-              requireConfirmation: targetModel.requireConfirmation,
-            });
-            routerAgentCacheRef.current.set(targetId, { agent, settingsSnapshot });
-          }
-          agentRef.current = agent;
-          modelRef.current = targetLabel;
-          routerActiveModelIdRef.current = targetId;
-        }
-
-        if (targetId) {
-          routedTier = tier;
-          routedModelId = targetId;
-        }
-
-        appActions().setAutoRouterActiveModel(
-          targetId && targetId !== defaultModelId ? (targetLabel ?? null) : null
-        );
-      }
-    } catch { /* non-fatal — keep using whatever agent is already active */ }
-
-    // Capture the agent for this turn by value now that routing is decided.
-    // Several awaits follow before chat() actually dispatches; reading
-    // `agentRef.current` fresh at each of those points would let a
-    // concurrent /model switch (its Agent.create() resolves async, on its
-    // own timeline) retarget a request that's already committed to this turn.
-    const dispatchAgent = agentRef.current;
-
-    if (!options?.silent) {
-      sessionActions().addUserMessage(value);
-    }
-
-    sessionActions().setCurrentCommand(value);
-    sessionActions().setThinking(true);
-
-    const { onUserPromptSubmit } = await import('../../hooks/index.js');
-    const injectedContext = await onUserPromptSubmit(value, getState().session.sessionId, process.cwd());
-
-    if (injectedContext) {
-      if (debugRef.current) {
-        console.log('[DEBUG] Hook injected context:', injectedContext);
-      }
-      sessionActions().addAssistantMessage('[Hook] ' + injectedContext);
-    }
-
-    await ctxManager.addMessage('user', value);
-
-    // Auto-compact when context approaches 80% of the token limit
-    {
-      const currentTokens = ctxManager.getTokenCount();
-      const runtimeConfig = getState().config.config;
-      const maxCtx = runtimeConfig?.maxContextTokens ?? 200000;
-      if (currentTokens > 0 && currentTokens >= maxCtx * 0.8) {
-        try {
-          sessionActions().setCompacting(true);
-          sessionActions().addAssistantMessage('⟳ Context near limit - auto-compacting...');
-          const { CompactionService } = await import('../../context/CompactionService.js');
-          const ctxMsgs = ctxManager.getMessages();
-          const msgs = ctxMsgs.map((m: { role: string; content: string }) => ({
-            role: m.role as Message['role'],
-            content: m.content,
-          }));
-          const result = await CompactionService.compact(msgs, {
-            modelName: modelRef.current || 'claude-sonnet-4-6',
-            maxContextTokens: maxCtx,
-            chatService: dispatchAgent?.getChatService(),
-            trigger: 'auto',
-            actualPreTokens: currentTokens,
-          });
-          if (result.success) {
-            const { nanoid } = await import('nanoid');
-            ctxManager.replaceMessages(result.compactedMessages.map((m: Message) => ({
-              id: nanoid(),
-              role: m.role as 'user' | 'assistant' | 'system' | 'tool',
-              content: m.content,
-              timestamp: Date.now(),
-            })));
-            ctxManager.updateTokenCount(result.postTokens);
-            const saved = result.preTokens - result.postTokens;
-            sessionActions().addAssistantMessage(
-              `✓ Auto-compact: ${result.preTokens.toLocaleString()} → ${result.postTokens.toLocaleString()} tokens (−${saved.toLocaleString()})`
-            );
-          }
-        } catch { /* non-fatal */ }
-        finally { sessionActions().setCompacting(false); }
-      }
-    }
-
-    // Dual-path streaming: mutable buffer + store
-    const streamingMessageId = sessionActions().startStreamingMessage();
-    // Wire to store so Escape/Ctrl+C can actually abort the agent
-    const abortController = commandActions().createAbortController();
-
-    try {
-      const contextMessages = ctxManager.getMessages();
-      const modelName = modelRef.current || 'claude-sonnet-4-6';
-
-      const inputTokens = TokenCounter.countTokens(
-        contextMessages.map(m => ({ role: m.role as Message['role'], content: m.content })),
-        modelName
-      );
-
-      const { nanoid } = await import('nanoid');
-
-      const chatContext = {
-        sessionId: ctxManager.getCurrentSessionId() || getState().session.sessionId,
-        messages: contextMessages.map(m => ({
-          role: m.role as Message['role'],
-          content: m.content,
-        })),
-        confirmationHandler: confirmationHandlerRef.current,
-        permissionMode: getState().config.config?.defaultPermissionMode || 'default',
-      };
-
-      const result = await dispatchAgent!.chat(value, chatContext, {
-        signal: abortController.signal,
-        onStreamEvent: (event) => {
-          if (!abortController.signal.aborted) {
-            applyStreamEvent(event);
-          }
-        },
-        onToolCallStart: (toolCall) => {
-          if (abortController.signal.aborted) return;
-          sessionActions().flushStreamBuffer(streamingMessageId);
-          const name = toolCall.function?.name || 'tool';
-          const toolId = toolCall.id || `${name}-${Date.now()}`;
-          sessionActions().addContentBlock(streamingMessageId, {
-            type: 'tool_use',
-            id: toolId,
-            name,
-            input: '',
-            status: 'running',
-            startedAt: Date.now(),
-          });
-        },
-        onToolResult: (_toolCall: ToolCall, toolResult: ToolResult) => {
-          if (abortController.signal.aborted) return;
-          const toolId = _toolCall.id;
-          const isError = !toolResult.success;
-          finishToolCallInBuffer(toolId, isError);
-          const bufferedCalls = getBufferedToolCalls();
-          const bufferedCall = bufferedCalls.find(tc => tc.id === toolId);
-          if (bufferedCall?.arguments) {
-            sessionActions().setToolCallInput(streamingMessageId, toolId, bufferedCall.arguments);
-          }
-          sessionActions().updateToolCallStatus(streamingMessageId, toolId, isError ? 'error' : 'success', Date.now());
-          const DISPLAY_CONTENT_CAP = 3000; // diffs need more room than plain text results
-          const resultContent = toolResult.error
-            ? (toolResult.error.length > 200 ? toolResult.error.slice(0, 200) + '...' : toolResult.error)
-            : (toolResult.displayContent
-                ? (toolResult.displayContent.length > DISPLAY_CONTENT_CAP ? toolResult.displayContent.slice(0, DISPLAY_CONTENT_CAP) + '...' : toolResult.displayContent)
-                : '');
-          sessionActions().addToolResultBlock(streamingMessageId, toolId, resultContent, isError);
-        },
-      });
-
-      sessionActions().finishStreamingMessage(streamingMessageId);
-      await ctxManager.addMessage('assistant', result);
-
-      const outputTokens = TokenCounter.countTextTokens(result, modelName);
-      const totalTokens = inputTokens + outputTokens;
-      ctxManager.updateTokenCount(totalTokens);
-
-      const currentTokenUsage = getState().session.tokenUsage;
-      const prevModel = currentTokenUsage.modelBreakdown[modelName] ?? { inputTokens: 0, outputTokens: 0 };
-      sessionActions().updateTokenUsage({
-        inputTokens: currentTokenUsage.inputTokens + inputTokens,
-        outputTokens: currentTokenUsage.outputTokens + outputTokens,
-        modelBreakdown: {
-          ...currentTokenUsage.modelBreakdown,
-          [modelName]: {
-            inputTokens: prevModel.inputTokens + inputTokens,
-            outputTokens: prevModel.outputTokens + outputTokens,
-          },
-        },
-      });
-
-      if (debugRef.current) {
-        console.log('[DEBUG] Token usage - input:', inputTokens, 'output:', outputTokens);
-        console.log('[DEBUG] Total context tokens:', ctxManager.getTokenCount());
-      }
-
-      if (routedTier && routedModelId) {
-        const { recordRouterOutcome } = await import('../../agent/routerStats.js');
-        recordRouterOutcome(routedTier, routedModelId, true);
-      }
-    } catch (error) {
-      if (routedTier && routedModelId) {
-        const { recordRouterOutcome } = await import('../../agent/routerStats.js');
-        recordRouterOutcome(routedTier, routedModelId, false);
-      }
-      if ((error as Error)?.name !== 'AbortError') {
-        const errorContent = 'Error: ' + (error as Error).message;
-        sessionActions().forceAppendToMessage(streamingMessageId, errorContent);
-        sessionActions().finishStreamingMessage(streamingMessageId);
-        await ctxManager.addMessage('assistant', errorContent);
-      } else {
-        sessionActions().finishStreamingMessage(streamingMessageId);
-      }
-    } finally {
-      sessionActions().setCurrentCommand(null);
-      sessionActions().setThinking(false);
-    }
-  }, [onSelectorRequest]);
-
-  const processQueue = useCallback(async () => {
-    const nextCommand = commandActions().dequeueCommand();
-    if (nextCommand) {
-      if (debugRef.current) {
-        console.log('[DEBUG] Processing queued command:', nextCommand);
-      }
-      await processCommand(nextCommand);
-    }
-  }, [processCommand]);
-
-  const handleSubmit = useCallback(async (value: string) => {
-    if (!value.trim()) return;
-
-    const currentState = getState();
-    const currentIsThinking = currentState.session.isThinking;
-    const currentPendingCount = currentState.command.pendingCommands.length;
-
-    if (currentIsThinking) {
-      commandActions().enqueueCommand(value);
-      if (debugRef.current) {
-        console.log('[DEBUG] Command queued:', value, 'Queue size:', currentPendingCount + 1);
-      }
-      return;
-    }
-
-    // Acquire the lock synchronously, before processCommand's first await
-    // (dynamic imports, auto-router's Agent.create, etc.). Without this,
-    // isThinking stays false across that gap and a second Enter press in
-    // the same window slips past the check above instead of queueing,
-    // producing two concurrent in-flight commands.
-    sessionActions().setThinking(true);
-
-    await processCommand(value);
-  }, [processCommand]);
-
-  return { processCommand, handleSubmit, processQueue };
-}

package/src/ui/hooks/useConfirmation.ts

@@ -1,99 +0,0 @@
-/**
- * useConfirmation - 确认对话框状态管理
- * 
- * 
- * 
- */
-
-import { useState, useCallback, useMemo } from 'react';
-import { focusActions, FocusId } from '../focus/index.js';
-import type { ConfirmationHandler, ConfirmationDetails, ConfirmationResponse } from '../../tools/execution/types.js';
-
-// Re-export for useCommandProcessor
-export type { ConfirmationHandler, ConfirmationDetails, ConfirmationResponse };
-
-/**
- * 
- */
-interface ConfirmationState {
-  isVisible: boolean;
-  details: ConfirmationDetails | null;
-  resolver: ((response: ConfirmationResponse) => void) | null;
-}
-
-interface UseConfirmationResult {
-  /** 确认状态 */
-  confirmationState: ConfirmationState;
-  /** 确认处理器（供 Agent/Pipeline 使用） */
-  confirmationHandler: ConfirmationHandler;
-  /** 处理用户响应 */
-  handleResponse: (response: ConfirmationResponse) => void;
-  /** 显示确认对话框 */
-  showConfirmation: (details: ConfirmationDetails) => Promise<ConfirmationResponse>;
-}
-
-/**
- * 
- * 
- * 
- */
-export const useConfirmation = (): UseConfirmationResult => {
-  const [confirmationState, setConfirmationState] = useState<ConfirmationState>({
-    isVisible: false,
-    details: null,
-    resolver: null,
-  });
-
-  /**
-   * 
-   * 
-   */
-  const showConfirmation = useCallback(
-    (details: ConfirmationDetails): Promise<ConfirmationResponse> => {
-      return new Promise((resolve) => {
-        // 同步设置焦点 — 在 React 调度 render 之前就生
-        focusActions.setFocus(FocusId.CONFIRMATION_PROMPT);
-        setConfirmationState({
-          isVisible: true,
-          details,
-          resolver: resolve,
-        });
-      });
-    },
-    []
-  );
-
-  /**
-   * 
-   * 
-   */
-  const handleResponse = useCallback((response: ConfirmationResponse) => {
-    if (confirmationState.resolver) {
-      confirmationState.resolver(response);
-    }
-    // 同步恢复焦
-    focusActions.setFocus(FocusId.MAIN_INPUT);
-    setConfirmationState({
-      isVisible: false,
-      details: null,
-      resolver: null,
-    });
-  }, [confirmationState.resolver]);
-
-  /**
-   * 
-   */
-  const confirmationHandler: ConfirmationHandler = useMemo(
-    () => ({
-      requestConfirmation: showConfirmation,
-    }),
-    [showConfirmation]
-  );
-
-  return {
-    confirmationState,
-    confirmationHandler,
-    handleResponse,
-    showConfirmation,
-  };
-};

package/src/ui/hooks/useCtrlCHandler.ts

@@ -1,100 +0,0 @@
-/**
- * useCtrlCHandler - Ctrl+Z / Ctrl+C 处理
- * 
- * Ctrl+Z 主退出键 (Kitty 中 Ctrl+C 用于复制)
- * Ctrl+C 备用退出键
- * 
- * - 有任务运行时：请求中断
- * - 无任务时：退出应用
- */
-
-import { useCallback, useRef } from 'react';
-import { useApp, useInput } from 'ink';
-import { getState } from '../../store/index.js';
-
-interface CtrlCHandlerOptions {
-  /** 中断回调 */
-  onInterrupt?: () => void;
-  /** 
-   * 
-   * 
-   */
-  onBeforeExit?: () => boolean | void;
-  /** 强制退出前的确认时间（毫秒） */
-  forceExitDelay?: number;
-}
-
-interface CtrlCHandlerResult {
-  /** 处理退出信号 (Ctrl+Z / Ctrl+C) */
-  handleExit: () => void;
-  /** 重置强制退出状态 */
-  resetForceExit: () => void;
-}
-
-/**
- * 退出处理 Hook
- * 
- * Ctrl+Z = 主退出 (Kitty 中 Ctrl+C 用于复制)
- * Ctrl+C = 备用退出
- */
-export const useCtrlCHandler = (options: CtrlCHandlerOptions): CtrlCHandlerResult => {
-  const { onInterrupt, onBeforeExit, forceExitDelay = 2000 } = options;
-  const { exit } = useApp();
-  
-  const lastExitTime = useRef<number>(0);
-  const forceExitPending = useRef(false);
-
-  const doExit = useCallback(() => {
-    if (onBeforeExit) {
-      const handled = onBeforeExit();
-      if (handled === true) {
-        return;
-      }
-    }
-    exit();
-    setTimeout(() => process.exit(0), 50);
-  }, [onBeforeExit, exit]);
-
-  const handleExit = useCallback(() => {
-    const now = Date.now();
-    const timeSinceLastExit = now - lastExitTime.current;
-    
-    const hasRunningTask = getState().session.isThinking;
-    
-    if (hasRunningTask) {
-      if (forceExitPending.current && timeSinceLastExit < forceExitDelay) {
-        // 第二次退出信号：强制退出
-        doExit();
-        return;
-      }
-      
-      // 第一次退出信号：请求中断
-      forceExitPending.current = true;
-      lastExitTime.current = now;
-      
-      if (onInterrupt) {
-        onInterrupt();
-      }
-    } else {
-      // 没有任务，直接退出
-      doExit();
-    }
-  }, [onInterrupt, forceExitDelay, doExit]);
-
-  // Ctrl+Z = primary exit key (Ctrl+C reserved for terminal copy in Kitty & others)
-  useInput((input, key) => {
-    if (input === 'z' && key.ctrl) {
-      handleExit();
-    }
-  });
-
-  const resetForceExit = useCallback(() => {
-    forceExitPending.current = false;
-    lastExitTime.current = 0;
-  }, []);
-
-  return {
-    handleExit,
-    resetForceExit,
-  };
-};