@nextclaw/ui 0.13.12 → 0.14.0

package/src/features/chat/managers/ncp-chat-input.manager.test.ts

@@ -1,232 +0,0 @@
-import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { NcpChatInputManager } from '@/features/chat/managers/ncp-chat-input.manager';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import { useSystemStatusStore } from '@/features/system-status';
-
-describe('NcpChatInputManager', () => {
-  beforeEach(() => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        draft: 'hello from current thread',
-        composerNodes: [createChatComposerTextNode('hello from current thread')],
-        attachments: [],
-        selectedSkills: [],
-        composerFocusRequest: null,
-        selectedSessionType: 'native',
-        selectedModel: 'gpt-5',
-        selectedThinkingLevel: null,
-        isProviderStateResolved: true,
-        modelOptions: [
-          {
-            value: 'gpt-5',
-            modelLabel: 'GPT-5',
-            providerLabel: 'OpenAI',
-            thinkingCapability: null,
-          },
-        ],
-      },
-    });
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'ready',
-        bootstrapStatus: {
-          phase: 'ready',
-          ncpAgent: {
-            state: 'ready',
-          },
-          extensionLoading: {
-            state: 'ready',
-            loadedExtensionCount: 1,
-            totalExtensionCount: 1,
-          },
-          channels: {
-            state: 'ready',
-            enabled: [],
-          },
-          remote: {
-            state: 'pending',
-          },
-        },
-      },
-    });
-    useChatSessionListStore.setState({
-      optimisticReadAtBySessionKey: {},
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'stale-selected-session',
-        selectedAgentId: 'main',
-      },
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: 'current-route-session',
-      },
-    });
-  });
-
-  it('sends through the current thread session when selected session state is stale', async () => {
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledTimes(1);
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        sessionKey: 'current-route-session',
-        message: 'hello from current thread',
-      }),
-    );
-    expect(sessionListManager.ensureDraftSession).not.toHaveBeenCalled();
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('sends without a session key while /chat is still in blank-draft mode', async () => {
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: null,
-      },
-    });
-    useChatSessionListStore.setState({
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: null,
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'materialized-draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(sessionListManager.ensureDraftSession).toHaveBeenCalledWith('native');
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.not.objectContaining({
-        sessionKey: expect.any(String),
-      }),
-    );
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: 'hello from current thread',
-      }),
-    );
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('does not send while the runtime is still blocked during startup', async () => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        isProviderStateResolved: false,
-        modelOptions: [],
-      },
-    });
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'cold-starting',
-        bootstrapStatus: {
-          ...useSystemStatusStore.getState().state.bootstrapStatus!,
-          phase: 'kernel-starting',
-          ncpAgent: {
-            state: 'pending',
-          },
-        },
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).not.toHaveBeenCalled();
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('still attempts to send when provider metadata is stale or the session type is marked unavailable', async () => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        isProviderStateResolved: true,
-        modelOptions: [],
-        sessionTypeUnavailable: true,
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledTimes(1);
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('creates and consumes one-shot composer focus requests', () => {
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      {} as ConstructorParameters<typeof NcpChatInputManager>[1],
-      {} as ConstructorParameters<typeof NcpChatInputManager>[2],
-    );
-
-    manager.requestComposerFocusAtEnd();
-
-    const request = useChatInputStore.getState().snapshot.composerFocusRequest;
-    expect(request).toEqual({ id: 1, placement: 'end' });
-
-    manager.consumeComposerFocusRequest(999);
-    expect(useChatInputStore.getState().snapshot.composerFocusRequest).toEqual(request);
-
-    manager.consumeComposerFocusRequest(request!.id);
-    expect(useChatInputStore.getState().snapshot.composerFocusRequest).toBeNull();
-  });
-});

package/src/features/chat/managers/ncp-chat-presenter.manager.ts

@@ -1,28 +0,0 @@
-import { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
-import { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
-import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
-import { NcpChatInputManager } from '@/features/chat/managers/ncp-chat-input.manager';
-import { NcpChatThreadManager } from '@/features/chat/managers/ncp-chat-thread.manager';
-
-export class NcpChatPresenter {
-  chatUiManager = new ChatUiManager();
-  chatStreamActionsManager = new ChatStreamActionsManager();
-  chatSessionListManager = new ChatSessionListManager(this.chatUiManager, this.chatStreamActionsManager);
-  chatInputManager = new NcpChatInputManager(
-    this.chatUiManager,
-    this.chatStreamActionsManager,
-    this.chatSessionListManager
-  );
-  chatThreadManager = new NcpChatThreadManager(
-    this.chatUiManager,
-    this.chatSessionListManager,
-    this.chatStreamActionsManager
-  );
-
-  startAgentCreationDraft = (prompt: string) => {
-    this.chatSessionListManager.createSession();
-    this.chatSessionListManager.setSelectedAgentId('main');
-    this.chatInputManager.setDraft(prompt);
-    this.chatInputManager.requestComposerFocusAtEnd();
-  };
-}

package/src/features/chat/managers/ncp-chat-thread.manager.test.ts

@@ -1,241 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { appQueryClient } from '@/app-query-client';
-import { NcpChatThreadManager } from '@/features/chat/managers/ncp-chat-thread.manager';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import type * as SharedApi from '@/shared/lib/api';
-
-const { deleteNcpSessionMock, deleteSummaryMock } = vi.hoisted(() => ({
-  deleteNcpSessionMock: vi.fn(async () => ({ deleted: true, sessionId: 'parent-session-1' })),
-  deleteSummaryMock: vi.fn(),
-}));
-
-vi.mock('@/shared/lib/api', async (importOriginal) => {
-  const actual = await importOriginal<typeof SharedApi>();
-  return {
-    ...actual,
-    deleteNcpSession: deleteNcpSessionMock,
-    deleteNcpSessionSummaryInQueryClient: deleteSummaryMock,
-  };
-});
-
-describe('NcpChatThreadManager', () => {
-  beforeEach(() => {
-    useChatSessionListStore.setState({
-      optimisticReadAtBySessionKey: {},
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'parent-session-1',
-      },
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: 'parent-session-1',
-        workspacePanelParentKey: null,
-        childSessionTabs: [
-          {
-            sessionKey: 'child-session-1',
-            parentSessionKey: 'parent-session-1',
-            label: 'Child Session 1',
-            agentId: 'reviewer',
-          },
-        ],
-        activeChildSessionKey: null,
-      },
-    });
-  });
-
-  it('opens the child-session panel for the requested parent session and keeps focus on the chosen child', () => {
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
-    );
-
-    manager.openChildSessionPanel({
-      parentSessionKey: 'parent-session-1',
-      activeChildSessionKey: 'child-session-1',
-    });
-
-    expect(useChatThreadStore.getState().snapshot.workspacePanelParentKey).toBe('parent-session-1');
-    expect(useChatThreadStore.getState().snapshot.activeChildSessionKey).toBe('child-session-1');
-    expect(uiManager.goToSession).not.toHaveBeenCalled();
-  });
-
-  it('routes to the parent session before opening the child-session panel when needed', () => {
-    useChatSessionListStore.setState({
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'another-session',
-      },
-    });
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
-    );
-
-    manager.openChildSessionPanel({
-      parentSessionKey: 'parent-session-1',
-      activeChildSessionKey: 'child-session-1',
-    });
-
-    expect(uiManager.goToSession).toHaveBeenCalledWith('parent-session-1');
-  });
-
-  it('opens the session cron panel without changing route when already selected', () => {
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
-    );
-
-    manager.openSessionCronPanel('parent-session-1');
-
-    expect(useChatThreadStore.getState().snapshot).toMatchObject({
-      workspacePanelParentKey: 'parent-session-1',
-      activeWorkspacePanelKind: 'cron',
-      activeChildSessionKey: null,
-      activeWorkspaceFileKey: null,
-    });
-    expect(uiManager.goToSession).not.toHaveBeenCalled();
-  });
-
-  it('routes to the session before opening its cron panel when needed', () => {
-    useChatSessionListStore.setState({
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'another-session',
-      },
-    });
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
-    );
-
-    manager.openSessionCronPanel('parent-session-1');
-
-    expect(uiManager.goToSession).toHaveBeenCalledWith('parent-session-1');
-  });
-
-  it('keeps preview and diff for the same file as separate workspace tabs', () => {
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[1],
-      {} as ConstructorParameters<typeof NcpChatThreadManager>[2],
-    );
-
-    manager.openFilePreview({
-      path: 'README.md',
-      label: 'README.md',
-      viewMode: 'preview',
-    });
-    manager.openFilePreview({
-      path: 'README.md',
-      label: 'README.md',
-      viewMode: 'diff',
-      beforeText: 'old\n',
-      afterText: 'new\n',
-    });
-
-    expect(useChatThreadStore.getState().snapshot.workspaceFileTabs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          key: 'parent-session-1::preview::README.md',
-          path: 'README.md',
-          viewMode: 'preview',
-        }),
-        expect.objectContaining({
-          key: 'parent-session-1::diff::README.md',
-          path: 'README.md',
-          viewMode: 'diff',
-        }),
-      ]),
-    );
-  });
-
-  it('clears the selected thread state after deleting the current session', async () => {
-    const removeQueries = vi.spyOn(appQueryClient, 'removeQueries').mockImplementation(async () => undefined);
-    const uiManager = {
-      goToSession: vi.fn(),
-      goToChatRoot: vi.fn(),
-      goToProviders: vi.fn(),
-      confirm: vi.fn(async () => true),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[0];
-    const sessionListManager = {
-      setSelectedSessionKey: vi.fn((value: string | null) => {
-        useChatSessionListStore.getState().setSnapshot({
-          selectedSessionKey: value,
-        });
-      }),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[1];
-    const streamActionsManager = {
-      resetStreamState: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatThreadManager>[2];
-    const manager = new NcpChatThreadManager(
-      uiManager,
-      sessionListManager,
-      streamActionsManager,
-    );
-
-    await (manager as unknown as { deleteCurrentSession: () => Promise<void> }).deleteCurrentSession();
-
-    expect(sessionListManager.setSelectedSessionKey).toHaveBeenCalledWith(null);
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatThreadStore.getState().snapshot).toMatchObject({
-      sessionKey: null,
-      canDeleteSession: false,
-      messages: [],
-      workspacePanelParentKey: null,
-      childSessionTabs: [],
-      activeChildSessionKey: null,
-      workspaceFileTabs: [],
-      activeWorkspaceFileKey: null,
-    });
-    expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
-    expect(deleteSummaryMock).toHaveBeenCalledWith(appQueryClient, 'parent-session-1');
-    expect(removeQueries).toHaveBeenCalledWith({
-      queryKey: ['ncp-session-messages', 'parent-session-1'],
-    });
-    expect(uiManager.goToChatRoot).toHaveBeenCalledWith({ replace: true });
-
-    removeQueries.mockRestore();
-  });
-});

package/src/features/chat/types/chat-stream.types.ts

@@ -1,32 +0,0 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
-import type { NcpMessagePart } from '@nextclaw/ncp';
-import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
-import type { ThinkingLevel } from '@/shared/lib/api';
-
-export type SendMessageParams = {
-  message: string;
-  sessionKey?: string;
-  agentId: string;
-  sessionType?: string;
-  model?: string;
-  thinkingLevel?: ThinkingLevel;
-  requestedSkills?: string[];
-  attachments?: NcpDraftAttachment[];
-  parts?: NcpMessagePart[];
-  stopSupported?: boolean;
-  stopReason?: string;
-  restoreDraftOnError?: boolean;
-  composerNodes?: ChatComposerNode[];
-};
-
-export type ResumeRunParams = {
-  sessionKey: string;
-};
-
-export type ChatStreamActions = {
-  sendMessage: (payload: SendMessageParams) => Promise<void>;
-  stopCurrentRun: () => Promise<void>;
-  resumeRun: (run: ResumeRunParams) => Promise<void>;
-  resetStreamState: () => void;
-  applyHistoryMessages: (messages: unknown[], options?: { isLoading?: boolean }) => void;
-};

package/src/features/chat/utils/chat-session-preference-governance.utils.test.tsx

@@ -1,114 +0,0 @@
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { useState } from 'react';
-import { describe, expect, it } from 'vitest';
-import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { useSyncSelectedModel } from '@/features/chat/utils/chat-session-preference-governance.utils';
-
-const modelOptions: ChatModelOption[] = [
-  {
-    value: 'minimax/MiniMax-M2.7',
-    modelLabel: 'MiniMax-M2.7',
-    providerLabel: 'MiniMax',
-    thinkingCapability: null
-  },
-  {
-    value: 'deepseek/deepseek-v4-flash',
-    modelLabel: 'deepseek-v4-flash',
-    providerLabel: 'DeepSeek',
-    thinkingCapability: null
-  },
-  {
-    value: 'openai/gpt-5',
-    modelLabel: 'gpt-5',
-    providerLabel: 'OpenAI',
-    thinkingCapability: null
-  }
-];
-
-type HookProps = {
-  fallbackPreferredModel?: string;
-  defaultModel: string;
-};
-
-describe('useSyncSelectedModel', () => {
-  it('replaces an auto-selected global default with the later-arriving recent same-runtime model for a fresh draft session', async () => {
-    const initialProps: HookProps = {
-      fallbackPreferredModel: undefined,
-      defaultModel: 'minimax/MiniMax-M2.7'
-    };
-    const { result, rerender } = renderHook(
-      (props: HookProps) => {
-        const [selectedModel, setSelectedModel] = useState('');
-        useSyncSelectedModel({
-          modelOptions,
-          selectedSessionKey: 'draft-session',
-          selectedSessionExists: false,
-          fallbackPreferredModel: props.fallbackPreferredModel,
-          defaultModel: props.defaultModel,
-          setSelectedModel
-        });
-        return selectedModel;
-      },
-      {
-        initialProps
-      }
-    );
-
-    await waitFor(() => {
-      expect(result.current).toBe('minimax/MiniMax-M2.7');
-    });
-
-    rerender({
-      fallbackPreferredModel: 'deepseek/deepseek-v4-flash',
-      defaultModel: 'minimax/MiniMax-M2.7'
-    });
-
-    await waitFor(() => {
-      expect(result.current).toBe('deepseek/deepseek-v4-flash');
-    });
-  });
-
-  it('does not override a manual model selection when recent same-runtime model data arrives later', async () => {
-    const initialProps: HookProps = {
-      fallbackPreferredModel: undefined,
-      defaultModel: 'minimax/MiniMax-M2.7'
-    };
-    const { result, rerender } = renderHook(
-      (props: HookProps) => {
-        const [selectedModel, setSelectedModel] = useState('');
-        useSyncSelectedModel({
-          modelOptions,
-          selectedSessionKey: 'draft-session',
-          selectedSessionExists: false,
-          fallbackPreferredModel: props.fallbackPreferredModel,
-          defaultModel: props.defaultModel,
-          setSelectedModel
-        });
-        return {
-          selectedModel,
-          setSelectedModel
-        };
-      },
-      {
-        initialProps
-      }
-    );
-
-    await waitFor(() => {
-      expect(result.current.selectedModel).toBe('minimax/MiniMax-M2.7');
-    });
-
-    act(() => {
-      result.current.setSelectedModel('openai/gpt-5');
-    });
-
-    rerender({
-      fallbackPreferredModel: 'deepseek/deepseek-v4-flash',
-      defaultModel: 'minimax/MiniMax-M2.7'
-    });
-
-    await waitFor(() => {
-      expect(result.current.selectedModel).toBe('openai/gpt-5');
-    });
-  });
-});