@nextclaw/ui 0.13.13 → 0.14.1-beta.0

package/src/features/chat/features/workspace/utils/chat-workspace-panel-view-model.utils.ts

@@ -0,0 +1,183 @@
+import type { ResolvedChildSessionTab } from "@/features/chat/features/ncp/hooks/use-ncp-child-session-tabs-view";
+import { shouldShowUnreadSessionIndicator } from "@/features/chat/stores/chat-session-list.store";
+import type { ChatWorkspaceFileTab } from "@/features/chat/stores/chat-thread.store";
+import { t } from "@/shared/lib/i18n";
+
+export type WorkspaceSelection =
+  | {
+      kind: "child-session";
+      tab: ResolvedChildSessionTab;
+    }
+  | {
+      kind: "file";
+      file: ChatWorkspaceFileTab;
+    }
+  | {
+      kind: "cron";
+    };
+
+export type WorkspaceTabViewModel = {
+  key: string;
+  kind: "child-session" | "file" | "cron";
+  title: string;
+  tooltip: string;
+  active: boolean;
+  agentId?: string | null;
+  showUnreadDot?: boolean;
+  viewMode?: "preview" | "diff";
+  onSelect: () => void;
+  onClose?: () => void;
+};
+
+export function readWorkspaceFileTitle(file: ChatWorkspaceFileTab): string {
+  const fileName = file.path.split("/").filter(Boolean).pop();
+  return file.label?.trim() || fileName || file.path;
+}
+
+export function resolveWorkspaceSelection(params: {
+  activePanelKind?: "child-session" | "file" | "cron" | null;
+  activeChildSessionKey: string | null;
+  activeWorkspaceFileKey: string | null;
+  childSessionTabs: ResolvedChildSessionTab[];
+  workspaceFileTabs: readonly ChatWorkspaceFileTab[];
+  sessionCronJobCount: number;
+}): WorkspaceSelection | null {
+  const {
+    activePanelKind,
+    activeChildSessionKey,
+    activeWorkspaceFileKey,
+    childSessionTabs,
+    workspaceFileTabs,
+    sessionCronJobCount,
+  } = params;
+
+  if (activePanelKind === "cron" && sessionCronJobCount > 0) {
+    return { kind: "cron" };
+  }
+
+  if (activePanelKind !== "child-session" && activeWorkspaceFileKey) {
+    const activeFile = workspaceFileTabs.find(
+      (file) => file.key === activeWorkspaceFileKey,
+    );
+    if (activeFile) {
+      return {
+        kind: "file",
+        file: activeFile,
+      };
+    }
+  }
+
+  if (activePanelKind !== "file" && activeChildSessionKey) {
+    const activeChild = childSessionTabs.find(
+      (tab) => tab.sessionKey === activeChildSessionKey,
+    );
+    if (activeChild) {
+      return {
+        kind: "child-session",
+        tab: activeChild,
+      };
+    }
+  }
+
+  if (childSessionTabs[0]) {
+    return {
+      kind: "child-session",
+      tab: childSessionTabs[0],
+    };
+  }
+
+  if (workspaceFileTabs[0]) {
+    return {
+      kind: "file",
+      file: workspaceFileTabs[0],
+    };
+  }
+
+  if (sessionCronJobCount > 0) {
+    return { kind: "cron" };
+  }
+
+  return null;
+}
+
+export function buildWorkspaceTabsViewModel(params: {
+  resolvedChildTabs: ResolvedChildSessionTab[];
+  workspaceFileTabs: readonly ChatWorkspaceFileTab[];
+  sessionCronJobCount: number;
+  activeSelection: WorkspaceSelection | null;
+  optimisticReadAtBySessionKey: Record<string, string>;
+  onSelectSession: (sessionKey: string) => void;
+  onSelectFile: (fileKey: string) => void;
+  onCloseFile: (fileKey: string) => void;
+  onSelectCronJobs: () => void;
+}): WorkspaceTabViewModel[] {
+  const {
+    resolvedChildTabs,
+    workspaceFileTabs,
+    sessionCronJobCount,
+    activeSelection,
+    optimisticReadAtBySessionKey,
+    onSelectSession,
+    onSelectFile,
+    onCloseFile,
+    onSelectCronJobs,
+  } = params;
+
+  const childTabs = resolvedChildTabs.map((tab) => {
+    const optimisticReadAt = optimisticReadAtBySessionKey[tab.sessionKey];
+    const effectiveReadAt =
+      optimisticReadAt && tab.readAt
+        ? optimisticReadAt.localeCompare(tab.readAt) > 0
+          ? optimisticReadAt
+          : tab.readAt
+        : (optimisticReadAt ?? tab.readAt);
+
+    return {
+      key: `child:${tab.sessionKey}`,
+      kind: "child-session" as const,
+      title: tab.title,
+      tooltip: tab.title,
+      agentId: tab.agentId,
+      active:
+        activeSelection?.kind === "child-session" &&
+        activeSelection.tab.sessionKey === tab.sessionKey,
+      showUnreadDot: shouldShowUnreadSessionIndicator({
+        active:
+          activeSelection?.kind === "child-session" &&
+          activeSelection.tab.sessionKey === tab.sessionKey,
+        lastMessageAt: tab.lastMessageAt,
+        readAt: effectiveReadAt,
+        runStatus: tab.runStatus,
+      }),
+      onSelect: () => onSelectSession(tab.sessionKey),
+    };
+  });
+
+  const fileTabs = workspaceFileTabs.map((file) => ({
+    key: `file:${file.key}`,
+    kind: "file" as const,
+    title: readWorkspaceFileTitle(file),
+    tooltip: file.path,
+    viewMode: file.viewMode,
+    active:
+      activeSelection?.kind === "file" && activeSelection.file.key === file.key,
+    onSelect: () => onSelectFile(file.key),
+    onClose: () => onCloseFile(file.key),
+  }));
+
+  const cronTab =
+    sessionCronJobCount > 0
+      ? [
+          {
+            key: "cron:session",
+            kind: "cron" as const,
+            title: t("chatWorkspaceSessionCronJobs"),
+            tooltip: t("chatWorkspaceSessionCronJobs"),
+            active: activeSelection?.kind === "cron",
+            onSelect: onSelectCronJobs,
+          },
+        ]
+      : [];
+
+  return [...childTabs, ...fileTabs, ...cronTab];
+}

package/src/features/chat/index.ts

@@ -1,6 +1,17 @@
-export * from "./components/chat-sidebar-list-mode-switch"; export * from "./components/chat-sidebar-project-groups"; export * from "./components/chat-sidebar-session-item"; export * from "./components/chat-welcome"; export * from "./components/providers/chat-presenter.provider";
-export * from "./components/conversation/chat-conversation-panel"; export * from "./components/layout/chat-sidebar";
-export * from "./components/chat-session-type-option-item"; export * from "./components/chat-session-workspace-file-preview"; export * from "./components/chat-session-workspace-panel"; export * from "./components/chat-session-workspace-panel-nav";
-export * from "./hooks/use-chat-session-type-state"; export * from "./hooks/use-ncp-chat-session-types"; export * from "./hooks/use-ncp-session-list-view";
-export * from "./managers/chat-recent-models.manager"; export * from "./managers/chat-recent-skills.manager"; export * from "./managers/chat-session-preference-sync.manager"; export * from "./managers/ncp-chat-input.manager"; export * from "./managers/ncp-chat-presenter.manager"; export * from "./managers/ncp-chat-thread.manager"; export * from "./stores/chat-input.store"; export * from "./stores/chat-session-list.store"; export * from "./stores/chat-thread.store";
-export * from "./types/chat-input.types"; export * from "./utils/chat-composer-state.utils"; export * from "./utils/chat-inline-token.utils"; export * from "./utils/chat-session-display.utils"; export * from "./utils/chat-session-preference-governance.utils"; export * from "./utils/chat-session-route.utils"; export * from "./utils/ncp-session-adapter.utils";
+export { ChatConversationPanel } from "./components/conversation/chat-conversation-panel";
+export { ChatSidebar } from "./components/layout/chat-sidebar";
+export { ChatPresenterProvider } from "./components/providers/chat-presenter.provider";
+export { usePresenter } from "./components/providers/chat-presenter.provider";
+export { ChatPresenter } from "./presenters/chat.presenter";
+export { ChatDraftIntentManager } from "./managers/chat-draft-intent.manager";
+export { useChatInputStore } from "./stores/chat-input.store";
+export { useChatSessionListStore } from "./stores/chat-session-list.store";
+export { useChatThreadStore } from "./stores/chat-thread.store";
+export { useNcpChatSessionTypes } from "./features/session-type/hooks/use-ncp-chat-session-types";
+export {
+  buildSessionTypeOptions,
+  normalizeSessionType,
+  resolveAgentRuntimeSessionType,
+  resolveSessionTypeLabel,
+  type ChatSessionTypeOption,
+} from "./features/session-type/utils/chat-session-type.utils";

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

@@ -0,0 +1,383 @@
+import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
+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('sends the runtime-default sentinel so the backend can ignore stale session model metadata', async () => {
+    useChatInputStore.setState({
+      snapshot: {
+        ...useChatInputStore.getState().snapshot,
+        selectedSessionType: 'codex',
+        selectedModel: RUNTIME_DEFAULT_MODEL_VALUE,
+      },
+    });
+    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({
+        sessionType: 'codex',
+        model: RUNTIME_DEFAULT_MODEL_VALUE,
+      }),
+    );
+  });
+
+  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();
+  });
+});