@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/ui/containers/AppContainer/hooks/useTodoContinuationFlow.ts

@@ -1,160 +0,0 @@
-/**
- * @license
- * Copyright 2025 Vybestack LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-/**
- * @hook useTodoContinuationFlow
- * @description Task-list continuation detection and prompts
- * @inputs uiRuntime, streamingState, history, pendingHistoryItems, setDebugMessage, todoContinuationRef, hadToolCallsRef
- * @outputs todoContinuationRef
- * @sideEffects Effect watching streaming state
- * @cleanup N/A
- * @strictMode Safe - effect deps are stable
- * @subscriptionStrategy Resubscribe
- */
-
-import { useEffect, useMemo, useRef } from 'react';
-import {
-  StreamingState,
-  type HistoryItem,
-  type HistoryItemWithoutId,
-} from '../../../types.js';
-
-import {
-  useTodoContinuation,
-  type TodoContinuationHook,
-} from '../../../hooks/useTodoContinuation.js';
-import type { UiRuntime } from '../../../cliUiRuntime.js';
-import type { Agent } from '@vybestack/llxprt-code-agents';
-
-export type { TodoContinuationHook };
-
-interface UseTodoContinuationFlowOptions {
-  uiRuntime: UiRuntime;
-  agent: Agent;
-  streamingState: StreamingState;
-  history: HistoryItem[];
-  pendingHistoryItems: HistoryItemWithoutId[];
-  setDebugMessage: (message: string) => void;
-  todoContinuationRef?: React.MutableRefObject<Pick<
-    TodoContinuationHook,
-    'handleTodoPause' | 'clearPause'
-  > | null>;
-  hadToolCallsRef?: React.MutableRefObject<boolean>;
-}
-
-export interface UseTodoContinuationFlowResult {
-  todoContinuationRef: React.MutableRefObject<Pick<
-    TodoContinuationHook,
-    'handleTodoPause' | 'clearPause'
-  > | null>;
-  hadToolCallsRef: React.MutableRefObject<boolean>;
-}
-
-export function useTodoContinuationFlow({
-  uiRuntime,
-  agent,
-  streamingState,
-  history,
-  pendingHistoryItems,
-  setDebugMessage,
-  todoContinuationRef: externalTodoContinuationRef,
-  hadToolCallsRef: externalHadToolCallsRef,
-}: UseTodoContinuationFlowOptions): UseTodoContinuationFlowResult {
-  const internalTodoContinuationRef = useRef<Pick<
-    TodoContinuationHook,
-    'handleTodoPause' | 'clearPause'
-  > | null>(null);
-  const todoContinuationRef =
-    externalTodoContinuationRef ?? internalTodoContinuationRef;
-
-  /**
-   * @plan PLAN-20260129-TODOPERSIST.P12
-   * Wire up task-list continuation detection to trigger continuation prompts
-   * when streams complete without tool calls and active tasks exist.
-   */
-  const continuationRuntime = useMemo(
-    () => ({
-      getEphemeralSettings: () => uiRuntime.app.getEphemeralSettings(),
-      getApprovalMode: () => uiRuntime.approval.getApprovalMode(),
-    }),
-    [uiRuntime.app, uiRuntime.approval],
-  );
-  const todoContinuation = useTodoContinuation(
-    agent,
-    continuationRuntime,
-    streamingState === StreamingState.Responding ||
-      streamingState === StreamingState.WaitingForConfirmation,
-    setDebugMessage,
-  );
-
-  todoContinuationRef.current = todoContinuation;
-
-  // Track previous streaming state to detect turn completion
-  const prevStreamingStateRef = useRef<StreamingState>(streamingState);
-
-  /**
-   * @plan PLAN-20260129-TODOPERSIST.P12
-   * Track whether tool calls were made during the turn for continuation decision.
-   * Tool calls signal the AI made progress, so we don't need continuation.
-   */
-  const internalHadToolCallsRef = useRef<boolean>(false);
-  const hadToolCallsRef = externalHadToolCallsRef ?? internalHadToolCallsRef;
-
-  /**
-   * @plan PLAN-20260129-TODOPERSIST.P12
-   * Track tool calls by detecting tool_group items in history and pending items.
-   * Reset hadToolCallsRef when a new turn starts (streamingState transitions TO Responding)
-   * so that tool calls from previous turns don't suppress continuation prompts.
-   */
-  useEffect(() => {
-    // Detect transition into Responding (new turn start) and reset the flag.
-    const wasIdle = prevStreamingStateRef.current === StreamingState.Idle;
-    const isNowResponding = streamingState === StreamingState.Responding;
-    if (wasIdle && isNowResponding) {
-      hadToolCallsRef.current = false;
-    }
-
-    const hasToolCalls =
-      history.some((item) => item.type === 'tool_group') ||
-      pendingHistoryItems.some((item) => item.type === 'tool_group');
-
-    if (
-      hasToolCalls &&
-      (streamingState === StreamingState.Responding ||
-        streamingState === StreamingState.WaitingForConfirmation)
-    ) {
-      hadToolCallsRef.current = true;
-    }
-  }, [history, pendingHistoryItems, streamingState, hadToolCallsRef]);
-
-  // Detect turn completion (streaming goes idle) for continuation logic
-  useEffect(() => {
-    const wasActive =
-      prevStreamingStateRef.current === StreamingState.Responding ||
-      prevStreamingStateRef.current === StreamingState.WaitingForConfirmation;
-    const isNowIdle = streamingState === StreamingState.Idle;
-    prevStreamingStateRef.current = streamingState;
-
-    if (!wasActive || !isNowIdle) {
-      return;
-    }
-
-    /**
-     * @plan PLAN-20260129-TODOPERSIST.P12
-     * Notify continuation logic that stream completed.
-     * Pass hadToolCalls to determine if continuation is needed.
-     */
-    todoContinuation.handleStreamCompleted(hadToolCallsRef.current);
-
-    // Reset for next turn
-    hadToolCallsRef.current = false;
-  }, [streamingState, todoContinuation, hadToolCallsRef]);
-
-  return {
-    todoContinuationRef,
-    hadToolCallsRef,
-  };
-}

package/src/ui/hooks/useTodoContinuation.ts

@@ -1,299 +0,0 @@
-/**
- * @license
- * Copyright 2025 Vybestack LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState, useRef, useCallback, useEffect } from 'react';
-import type { Todo } from '@vybestack/llxprt-code-core';
-import { ApprovalMode } from '@vybestack/llxprt-code-core';
-import type { Agent } from '@vybestack/llxprt-code-agents';
-import { useTodoContext } from '../contexts/TodoContext.js';
-
-export interface TodoContinuationRuntime {
-  getEphemeralSettings(): Record<string, unknown>;
-  getApprovalMode(): ApprovalMode;
-}
-
-export interface ContinuationState {
-  isActive: boolean;
-  taskDescription?: string;
-  attemptCount: number;
-  lastPromptTime?: Date;
-}
-
-export interface ContinuationOptions {
-  taskDescription: string;
-  isYoloMode: boolean;
-}
-
-interface ContinuationConditions {
-  streamCompleted: boolean;
-  noToolCallsMade: boolean;
-  hasActiveTodos: boolean;
-  continuationEnabled: boolean;
-  notAlreadyContinuing: boolean;
-  todoPaused: boolean;
-}
-
-export interface TodoContinuationHook {
-  handleStreamCompleted: (hadToolCalls: boolean) => void;
-  continuationState: ContinuationState;
-  handleTodoPause: (reason: string) => {
-    type: 'pause';
-    reason: string;
-    message: string;
-  };
-  clearPause: () => void;
-}
-
-function evaluateConditions(
-  hadToolCalls: boolean,
-  todoPaused: boolean,
-  config: TodoContinuationRuntime,
-  todos: Todo[],
-  isActive: boolean,
-): ContinuationConditions {
-  const ephemeralSettings = config.getEphemeralSettings();
-  const isEnabled = ephemeralSettings['todo-continuation'] === true;
-  const hasActiveTodos = todos.some(
-    (todo) => todo.status === 'pending' || todo.status === 'in_progress',
-  );
-  const hadBlockingToolCalls = hadToolCalls && (todoPaused || !hasActiveTodos);
-
-  return {
-    streamCompleted: true,
-    noToolCallsMade: !hadBlockingToolCalls,
-    hasActiveTodos,
-    continuationEnabled: isEnabled,
-    notAlreadyContinuing: !isActive,
-    todoPaused,
-  };
-}
-
-function shouldTrigger(
-  conditions: ContinuationConditions,
-  isResponding: boolean,
-): boolean {
-  if (isResponding) {
-    return false;
-  }
-
-  const baseConditionsMet =
-    conditions.streamCompleted &&
-    conditions.noToolCallsMade &&
-    conditions.hasActiveTodos;
-  const continuationReady =
-    conditions.continuationEnabled && conditions.notAlreadyContinuing;
-  return baseConditionsMet && continuationReady && !conditions.todoPaused;
-}
-
-function findMostRelevantTodo(todos: Todo[]): Todo | null {
-  const inProgressTodos = todos.filter((todo) => todo.status === 'in_progress');
-
-  if (inProgressTodos.length > 0) {
-    return inProgressTodos[0];
-  }
-
-  const pendingTodos = todos.filter((todo) => todo.status === 'pending');
-
-  if (pendingTodos.length > 0) {
-    return pendingTodos[0];
-  }
-
-  return null;
-}
-
-function generatePrompt(todo: Todo, config: TodoContinuationRuntime): string {
-  const isYoloMode = config.getApprovalMode() === ApprovalMode.YOLO;
-
-  if (isYoloMode) {
-    return `Continue to proceed with the active task without waiting for confirmation: "${todo.content}"`;
-  }
-
-  return `Please continue working on the following task: "${todo.content}"`;
-}
-
-function sendContinuationPrompt(
-  agent: Agent,
-  taskDescription: string,
-  continuationPrompt: string,
-  onDebugMessage: (message: string) => void,
-  setContinuationState: React.Dispatch<React.SetStateAction<ContinuationState>>,
-  continuationInProgressRef: React.MutableRefObject<boolean>,
-  abortControllerRef: React.MutableRefObject<AbortController | undefined>,
-): void {
-  if (continuationInProgressRef.current) {
-    return;
-  }
-
-  continuationInProgressRef.current = true;
-
-  setContinuationState((prev) => ({
-    isActive: true,
-    taskDescription,
-    attemptCount: prev.attemptCount + 1,
-    lastPromptTime: new Date(),
-  }));
-
-  const abortController = new AbortController();
-  abortControllerRef.current = abortController;
-  const promptId = `todo-continuation-${Date.now().toString(16)}`;
-
-  void (async () => {
-    try {
-      const stream = agent.stream(continuationPrompt, {
-        signal: abortController.signal,
-        promptId,
-      });
-      for await (const _event of stream) {
-        // Continuation prompts are submitted for side effects; the main stream
-        // UI owns rendering for user-initiated turns.
-      }
-    } catch (error: unknown) {
-      if (!abortController.signal.aborted) {
-        onDebugMessage(
-          `[TodoContinuation] Error sending continuation prompt: ${error instanceof Error ? error.message : String(error)}`,
-        );
-        setContinuationState((prev) => ({
-          isActive: false,
-          attemptCount: prev.attemptCount,
-          lastPromptTime: prev.lastPromptTime,
-          taskDescription: prev.taskDescription,
-        }));
-      }
-    } finally {
-      continuationInProgressRef.current = false;
-      if (abortControllerRef.current === abortController) {
-        abortControllerRef.current = undefined;
-      }
-    }
-  })();
-}
-
-function processContinuation(
-  hadToolCalls: boolean,
-  todoContext: { todos: Todo[]; paused: boolean },
-  config: TodoContinuationRuntime,
-  isResponding: boolean,
-  continuationState: ContinuationState,
-  continuationInProgressRef: React.MutableRefObject<boolean>,
-  abortControllerRef: React.MutableRefObject<AbortController | undefined>,
-  agent: Agent,
-  onDebugMessage: (message: string) => void,
-  setContinuationState: React.Dispatch<React.SetStateAction<ContinuationState>>,
-): void {
-  if (hadToolCalls) {
-    setContinuationState((prev) => ({ ...prev, isActive: false }));
-  }
-
-  const conditions = evaluateConditions(
-    hadToolCalls,
-    todoContext.paused,
-    config,
-    todoContext.todos,
-    continuationState.isActive,
-  );
-
-  if (!shouldTrigger(conditions, isResponding)) {
-    return;
-  }
-
-  const activeTodo = findMostRelevantTodo(todoContext.todos);
-
-  if (!activeTodo?.content || activeTodo.content.trim() === '') {
-    return;
-  }
-
-  if (continuationState.isActive || continuationInProgressRef.current) {
-    return;
-  }
-
-  const continuationPrompt = generatePrompt(activeTodo, config);
-  sendContinuationPrompt(
-    agent,
-    activeTodo.content,
-    continuationPrompt,
-    onDebugMessage,
-    setContinuationState,
-    continuationInProgressRef,
-    abortControllerRef,
-  );
-}
-
-/**
- * React hook for task continuation - monitors stream completion and triggers continuation
- * prompts when active tasks exist but no tool calls were made.
- * [REQ-001] Task Continuation Detection, [REQ-002] Continuation Prompting
- */
-export const useTodoContinuation = (
-  agent: Agent,
-  config: TodoContinuationRuntime,
-  isResponding: boolean,
-  onDebugMessage: (message: string) => void,
-): TodoContinuationHook => {
-  const [continuationState, setContinuationState] = useState<ContinuationState>(
-    { isActive: false, attemptCount: 0 },
-  );
-
-  const continuationInProgressRef = useRef<boolean>(false);
-  const todoContext = useTodoContext();
-  const abortControllerRef = useRef<AbortController | undefined>(undefined);
-  const continuationTimeoutRef = useRef<NodeJS.Timeout | undefined>(undefined);
-
-  const handleStreamCompleted = useCallback(
-    (hadToolCalls: boolean): void => {
-      processContinuation(
-        hadToolCalls,
-        todoContext,
-        config,
-        isResponding,
-        continuationState,
-        continuationInProgressRef,
-        abortControllerRef,
-        agent,
-        onDebugMessage,
-        setContinuationState,
-      );
-    },
-    [
-      config,
-      todoContext,
-      continuationState,
-      isResponding,
-      agent,
-      onDebugMessage,
-    ],
-  );
-
-  const handleTodoPause = useCallback(
-    (reason: string): { type: 'pause'; reason: string; message: string } => {
-      todoContext.setPaused(true);
-      return {
-        type: 'pause' as const,
-        reason,
-        message: `Task paused: ${reason}`,
-      };
-    },
-    [todoContext],
-  );
-
-  const clearPause = useCallback(() => {
-    todoContext.setPaused(false);
-  }, [todoContext]);
-
-  useEffect(
-    () => () => {
-      abortControllerRef.current?.abort();
-      clearTimeout(continuationTimeoutRef.current);
-    },
-    [],
-  );
-
-  return {
-    handleStreamCompleted,
-    continuationState,
-    handleTodoPause,
-    clearPause,
-  };
-};