@nextclaw/ui 0.13.13 → 0.14.0

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

@@ -0,0 +1,355 @@
+import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatInputManager } from '@/features/chat/managers/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';
+
+function resetChatInputManagerStoreState() {
+  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',
+    },
+  });
+}
+
+describe('ChatInputManager', () => {
+  beforeEach(resetChatInputManagerStoreState);
+
+  it('sends through the current thread session when selected session state is stale', async () => {
+    const chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).toHaveBeenCalledTimes(1);
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionKey: 'current-route-session',
+        message: 'hello from current thread',
+      }),
+    );
+    expect(sessionListManager.ensureDraftSession).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 chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'materialized-draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(sessionListManager.ensureDraftSession).toHaveBeenCalledWith('native');
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.not.objectContaining({
+        sessionKey: expect.any(String),
+      }),
+    );
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: 'hello from current thread',
+      }),
+    );
+  });
+
+  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 chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).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 chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).toHaveBeenCalledTimes(1);
+  });
+
+  it('includes the current thread project root in the run payload', async () => {
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'current-route-session',
+        sessionProjectRoot: '/tmp/project-alpha',
+      },
+    });
+    const chatRunManager = {
+      sendMessage: vi.fn().mockResolvedValue(undefined),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+
+    await manager.send();
+
+    expect(chatRunManager.sendMessage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectRoot: '/tmp/project-alpha',
+      }),
+    );
+  });
+
+  it('restores the composer when sending through the run manager fails', async () => {
+    const chatRunManager = {
+      sendMessage: vi.fn().mockRejectedValue(new Error('send failed')),
+      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[0];
+    const sessionListManager = {
+      ensureDraftSession: vi.fn(() => 'draft-session'),
+    } as unknown as ConstructorParameters<typeof ChatInputManager>[1];
+    const manager = new ChatInputManager(
+      chatRunManager,
+      sessionListManager,
+    );
+    const originalComposerNodes = useChatInputStore.getState().snapshot.composerNodes;
+
+    await expect(manager.send()).rejects.toThrow('send failed');
+
+    expect(useChatInputStore.getState().snapshot.draft).toBe('hello from current thread');
+    expect(useChatInputStore.getState().snapshot.composerNodes).toEqual(originalComposerNodes);
+  });
+
+  it('creates and consumes one-shot composer focus requests', () => {
+    const manager = new ChatInputManager(
+      {} as ConstructorParameters<typeof ChatInputManager>[0],
+      {} as ConstructorParameters<typeof ChatInputManager>[1],
+    );
+
+    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();
+  });
+});
+
+describe('ChatInputManager configuration sync', () => {
+  beforeEach(resetChatInputManagerStoreState);
+
+  it('syncs session model and thinking preferences inside the input manager', () => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        modelOptions: [
+          {
+            value: 'anthropic/claude-sonnet-4',
+            modelLabel: 'claude-sonnet-4',
+            providerLabel: 'Anthropic',
+            thinkingCapability: {
+              supported: ['off', 'medium'],
+              default: 'medium',
+            },
+          },
+          {
+            value: 'openai/gpt-5',
+            modelLabel: 'gpt-5',
+            providerLabel: 'OpenAI',
+            thinkingCapability: {
+              supported: ['off', 'high'],
+              default: 'high',
+            },
+          },
+        ],
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        sessionKey: 'session-1',
+      },
+    });
+    const manager = new ChatInputManager(
+      {} as ConstructorParameters<typeof ChatInputManager>[0],
+      {} as ConstructorParameters<typeof ChatInputManager>[1],
+    );
+
+    manager.syncSessionPreferences({
+      selectedSessionExists: true,
+      selectedSessionPreferredModel: 'openai/gpt-5',
+      selectedSessionPreferredThinking: 'high',
+      fallbackPreferredModel: 'anthropic/claude-sonnet-4',
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      selectedModel: 'openai/gpt-5',
+      selectedThinkingLevel: 'high',
+    });
+  });
+
+  it('resolves and clears pending project root overrides inside the input manager', () => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        pendingProjectRoot: '/tmp/project-alpha',
+        pendingProjectRootSessionKey: 'session-1',
+      },
+    });
+    const manager = new ChatInputManager(
+      {} as ConstructorParameters<typeof ChatInputManager>[0],
+      {} as ConstructorParameters<typeof ChatInputManager>[1],
+    );
+
+    expect(
+      manager.resolveProjectRootForSend({
+        sessionKey: 'session-1',
+        selectedSessionProjectRoot: '/tmp/server-project',
+      }),
+    ).toBe('/tmp/project-alpha');
+
+    manager.clearPendingProjectRootOverrideForSession({
+      sessionKey: 'session-1',
+      selectedSessionProjectRoot: '/tmp/project-alpha',
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null,
+    });
+  });
+});

package/src/features/chat/managers/__tests__/chat-query.manager.test.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatQueryManager } from '@/features/chat/managers/chat-query.manager';
+import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
+import type { ChatQuerySnapshot } from '@/features/chat/stores/ncp-chat-query.store';
+
+function createQuery<TData>(data: TData) {
+  return {
+    data,
+    error: null,
+    fetchStatus: 'idle',
+    isFetched: true,
+    isFetching: false,
+    isLoading: false,
+    isSuccess: true,
+    status: 'success',
+  };
+}
+
+describe('ChatQueryManager', () => {
+  beforeEach(() => {
+    useChatQueryStore.setState({ snapshot: {} });
+  });
+
+  it('skips store writes when only query wrapper identity changes', () => {
+    const manager = new ChatQueryManager();
+    const sessions = { sessions: [] };
+    manager.syncSnapshot({
+      sessionsQuery: createQuery(sessions) as unknown as ChatQuerySnapshot['sessionsQuery'],
+    });
+    const setSnapshot = vi.spyOn(useChatQueryStore.getState(), 'setSnapshot');
+
+    manager.syncSnapshot({
+      sessionsQuery: createQuery(sessions) as unknown as ChatQuerySnapshot['sessionsQuery'],
+    });
+
+    expect(setSnapshot).not.toHaveBeenCalled();
+    setSnapshot.mockRestore();
+  });
+});

package/src/features/chat/managers/__tests__/chat-run.manager.test.ts

@@ -0,0 +1,202 @@
+import type { NcpMessage } from '@nextclaw/ncp';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+function createChatRunManager() {
+  const uiManager = {
+    isAtChatRoot: vi.fn(() => true),
+    goToSession: vi.fn(),
+  };
+  return {
+    manager: new ChatRunManager(
+      uiManager as unknown as ConstructorParameters<typeof ChatRunManager>[0],
+    ),
+    uiManager,
+  };
+}
+
+describe('ChatRunManager', () => {
+  beforeEach(() => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        canStopGeneration: false,
+        sendError: null,
+        isSending: false,
+      },
+    });
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        isHistoryLoading: false,
+        messages: [],
+        isSending: false,
+        isAwaitingAssistantOutput: false,
+        contextWindow: null,
+      },
+    });
+  });
+
+  it('sends an envelope through the active runtime and materializes a root session', async () => {
+    const { manager, uiManager } = createChatRunManager();
+    const sendEnvelope = vi.fn(async () => ({
+      sessionId: 'materialized-session',
+      userMessageId: 'user-message-1',
+      assistantMessageId: null,
+      runId: 'run-1',
+    }));
+    manager.setActiveRuntime({
+      sessionKey: null,
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      agentId: 'engineer',
+      sessionType: 'codex',
+      projectRoot: '/tmp/project-alpha',
+      requestedSkills: ['project:/tmp/project-alpha/.agents/skills/review'],
+    });
+
+    expect(sendEnvelope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          agentId: 'engineer',
+          session_type: 'codex',
+          projectRoot: '/tmp/project-alpha',
+          requested_skill_refs: ['project:/tmp/project-alpha/.agents/skills/review'],
+        }),
+      }),
+    );
+    expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', { replace: true });
+  });
+
+  it('does not send through a runtime for another session', async () => {
+    const { manager } = createChatRunManager();
+    const sendEnvelope = vi.fn();
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope,
+      abortCurrentRun: vi.fn(),
+      resumeCurrentSessionRun: vi.fn(),
+    });
+
+    await manager.sendMessage({
+      message: 'hello',
+      sessionKey: 'session-2',
+      agentId: 'main',
+    });
+
+    expect(sendEnvelope).not.toHaveBeenCalled();
+  });
+
+  it('routes stop and resume commands through the active runtime', async () => {
+    const { manager } = createChatRunManager();
+    const abortCurrentRun = vi.fn(async () => undefined);
+    const resumeCurrentSessionRun = vi.fn(async () => undefined);
+    manager.setActiveRuntime({
+      sessionKey: 'session-1',
+      sendEnvelope: vi.fn(),
+      abortCurrentRun,
+      resumeCurrentSessionRun,
+    });
+
+    await manager.stopCurrentRun();
+    await manager.resumeRun({ sessionKey: 'session-1' });
+    await manager.resumeRun({ sessionKey: 'session-2' });
+
+    expect(abortCurrentRun).toHaveBeenCalledTimes(1);
+    expect(resumeCurrentSessionRun).toHaveBeenCalledTimes(1);
+  });
+
+  it('syncs the run snapshot into chat input and thread state', () => {
+    const { manager } = createChatRunManager();
+    const message: NcpMessage = {
+      id: 'message-1',
+      sessionId: 'session-1',
+      role: 'assistant',
+      status: 'final',
+      parts: [{ type: 'text', text: 'done' }],
+      timestamp: '2026-06-10T00:00:00.000Z',
+    };
+
+    manager.applyRunSnapshot({
+      routeSessionKey: 'session-1',
+      isHydrating: true,
+      isSending: false,
+      isRunning: true,
+      visibleMessages: [message],
+      contextWindow: {
+        usedContextTokens: 10,
+        totalContextTokens: 100,
+        availableContextTokens: 90,
+        prunedUsedContextTokens: 10,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 10,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+      sendErrorMessage: 'failed',
+      materializedSessionKey: null,
+    });
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      isHistoryLoading: true,
+      messages: [message],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+    });
+  });
+
+  it('clears run-owned input and thread state', () => {
+    const { manager } = createChatRunManager();
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: true,
+      sendError: 'failed',
+      isSending: true,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      isHistoryLoading: true,
+      messages: [
+        {
+          id: 'message-1',
+          sessionId: 'session-1',
+          role: 'assistant',
+          status: 'final',
+          parts: [{ type: 'text', text: 'done' }],
+          timestamp: '2026-06-10T00:00:00.000Z',
+        },
+      ],
+      isSending: true,
+      isAwaitingAssistantOutput: true,
+    });
+
+    manager.clearRunState();
+
+    expect(useChatInputStore.getState().snapshot).toMatchObject({
+      canStopGeneration: false,
+      sendError: null,
+      isSending: false,
+    });
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      contextWindow: null,
+    });
+  });
+});