@nextclaw/ui 0.13.11 → 0.13.13

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

@@ -11,11 +11,30 @@ import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import type {
   ChatThreadSnapshot,
+  ChatWorkspaceNavigationEntry,
   ChatWorkspaceFileTab,
 } from '@/features/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import { viewportLayoutManager } from '@/app/managers/viewport-layout.manager';
 import { t } from '@/shared/lib/i18n';
+import {
+  filterNavigationHistoryEntries,
+  pushNavigationHistoryEntry,
+  stepNavigationHistory,
+} from '@/shared/lib/navigation-history';
+
+function areWorkspaceNavigationEntriesEqual(
+  current: ChatWorkspaceNavigationEntry,
+  next: ChatWorkspaceNavigationEntry,
+): boolean {
+  if (current.kind !== next.kind) {
+    return false;
+  }
+  if (current.kind === 'cron') {
+    return true;
+  }
+  return next.kind !== 'cron' && current.key === next.key;
+}
 
 export class NcpChatThreadManager {
   constructor(
@@ -67,6 +86,8 @@ export class NcpChatThreadManager {
       activeChildSessionKey: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -134,6 +155,57 @@ export class NcpChatThreadManager {
     }
   };
 
+  private createWorkspaceSelectionPatch = (
+    entry: ChatWorkspaceNavigationEntry,
+    snapshot: ChatThreadSnapshot,
+  ): Partial<ChatThreadSnapshot> | null => {
+    if (entry.kind === 'cron') {
+      return {
+        activeWorkspacePanelKind: 'cron',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: null,
+      };
+    }
+    if (entry.kind === 'file') {
+      if (!snapshot.workspaceFileTabs.some((tab) => tab.key === entry.key)) {
+        return null;
+      }
+      return {
+        activeWorkspacePanelKind: 'file',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: entry.key,
+      };
+    }
+    if (!entry.key) {
+      return null;
+    }
+    return {
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: entry.key,
+      activeWorkspaceFileKey: null,
+    };
+  };
+
+  private setWorkspaceSelection = (
+    patch: Partial<ChatThreadSnapshot>,
+    entry: ChatWorkspaceNavigationEntry,
+  ) => {
+    const { snapshot } = useChatThreadStore.getState();
+    const history = pushNavigationHistoryEntry(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      entry,
+      areWorkspaceNavigationEntriesEqual,
+    );
+    useChatThreadStore.getState().setSnapshot({
+      ...patch,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
+    });
+  };
+
   deleteSession = () => {
     void this.deleteCurrentSession();
   };
@@ -155,12 +227,20 @@ export class NcpChatThreadManager {
       return;
     }
     const activeChildSessionKey = params.activeChildSessionKey?.trim() || null;
-    useChatThreadStore.getState().setSnapshot({
+    const patch: Partial<ChatThreadSnapshot> = {
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'child-session',
       activeChildSessionKey,
       activeWorkspaceFileKey: null,
-    });
+    };
+    if (activeChildSessionKey) {
+      this.setWorkspaceSelection(patch, {
+        kind: 'child-session',
+        key: activeChildSessionKey,
+      });
+    } else {
+      useChatThreadStore.getState().setSnapshot(patch);
+    }
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
@@ -170,12 +250,15 @@ export class NcpChatThreadManager {
     if (!nextTab) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'file',
       workspaceFileTabs: this.upsertWorkspaceFileTab(nextTab),
       activeWorkspaceFileKey: nextTab.key,
       activeChildSessionKey: null,
+    }, {
+      kind: 'file',
+      key: nextTab.key,
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
@@ -202,6 +285,8 @@ export class NcpChatThreadManager {
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
     this.uiManager.goToSession(action.sessionId);
   };
@@ -215,10 +300,13 @@ export class NcpChatThreadManager {
     if (!childSessionTabs.some((tab) => tab.sessionKey === normalizedSessionKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeChildSessionKey: normalizedSessionKey,
       activeWorkspaceFileKey: null,
       activeWorkspacePanelKind: 'child-session',
+    }, {
+      kind: 'child-session',
+      key: normalizedSessionKey,
     });
   };
 
@@ -231,10 +319,13 @@ export class NcpChatThreadManager {
     if (!workspaceFileTabs.some((tab) => tab.key === normalizedFileKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeWorkspaceFileKey: normalizedFileKey,
       activeChildSessionKey: null,
       activeWorkspacePanelKind: 'file',
+    }, {
+      kind: 'file',
+      key: normalizedFileKey,
     });
   };
 
@@ -248,11 +339,31 @@ export class NcpChatThreadManager {
     const nextTabs = workspaceFileTabs.filter(
       (tab) => tab.key !== normalizedFileKey,
     );
+    const history = filterNavigationHistoryEntries(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      (entry) => entry.kind !== 'file' || entry.key !== normalizedFileKey,
+    );
     const nextPatch: Partial<ChatThreadSnapshot> = {
       workspaceFileTabs: nextTabs,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
     };
     if (activeWorkspaceFileKey === normalizedFileKey) {
-      nextPatch.activeWorkspaceFileKey = null;
+      const nextSnapshot = {
+        ...snapshot,
+        workspaceFileTabs: nextTabs,
+      };
+      const restoreEntry = history.entries[history.index];
+      const restorePatch = restoreEntry
+        ? this.createWorkspaceSelectionPatch(restoreEntry, nextSnapshot)
+        : null;
+      Object.assign(nextPatch, restorePatch ?? {
+        activeWorkspacePanelKind: null,
+        activeWorkspaceFileKey: null,
+      });
     }
     useChatThreadStore.getState().setSnapshot(nextPatch);
   };
@@ -263,6 +374,8 @@ export class NcpChatThreadManager {
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -271,15 +384,48 @@ export class NcpChatThreadManager {
     if (!parentSessionKey) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'cron',
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+    }, {
+      kind: 'cron',
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
+  goBackWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('back');
+  };
+
+  goForwardWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('forward');
+  };
+
+  private restoreWorkspaceNavigationStep = (direction: 'back' | 'forward') => {
+    const { snapshot } = useChatThreadStore.getState();
+    const step = stepNavigationHistory(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      direction,
+    );
+    if (!step) {
+      return;
+    }
+    const selectionPatch = this.createWorkspaceSelectionPatch(step.entry, snapshot);
+    if (!selectionPatch) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({
+      ...selectionPatch,
+      workspaceNavigationHistory: [...step.history.entries],
+      workspaceNavigationHistoryIndex: step.history.index,
+    });
+  };
+
   closeChildSessionDetail = () => {
     this.closeWorkspacePanel();
   };

package/src/features/chat/pages/ncp-chat-page.tsx

@@ -195,6 +195,8 @@ function useNcpChatPageState(presenter: NcpChatPresenter) {
   const effectiveSessionProjectRoot = hasSessionProjectRootOverride
     ? pendingProjectRoot
     : (selectedSession?.projectRoot ?? null);
+  const effectiveSessionWorkingDir =
+    selectedSession?.workingDir ?? effectiveSessionProjectRoot;
   const effectiveSessionProjectName = hasSessionProjectRootOverride
     ? getSessionProjectName(effectiveSessionProjectRoot)
     : (selectedSession?.projectName ??
@@ -224,6 +226,7 @@ function useNcpChatPageState(presenter: NcpChatPresenter) {
     ...baseState,
     availableAgents,
     effectiveSessionProjectRoot,
+    effectiveSessionWorkingDir,
     effectiveSessionProjectName,
     isSending: agent.isSending || currentSessionRunning,
     isAwaitingAssistantOutput: currentSessionRunning,
@@ -438,6 +441,7 @@ export function NcpChatPage({ view }: ChatPageProps) {
     availableAgents: state.availableAgents,
     currentSessionDisplayName: state.currentSessionDisplayName,
     effectiveSessionProjectRoot: state.effectiveSessionProjectRoot,
+    effectiveSessionWorkingDir: state.effectiveSessionWorkingDir,
     effectiveSessionProjectName: state.effectiveSessionProjectName,
     selectedSession: state.selectedSession,
     threadRef: state.threadRef,

package/src/features/chat/stores/chat-thread.store.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+const chatThreadWorkspaceStorageKey = 'nextclaw.chat.workspace-panel.state';
+
+function createLocalStoragePersistStorage() {
+  return {
+    getItem: (name: string) => JSON.parse(window.localStorage.getItem(name) ?? 'null'),
+    setItem: (name: string, value: unknown) => window.localStorage.setItem(name, JSON.stringify(value)),
+    removeItem: (name: string) => window.localStorage.removeItem(name)
+  };
+}
+
+function resetChatThreadStore() {
+  useChatThreadStore.setState({
+    snapshot: {
+      ...useChatThreadStore.getState().snapshot,
+      sessionKey: null,
+      messages: [],
+      isSending: false,
+      workspacePanelParentKey: null,
+      activeWorkspacePanelKind: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
+    },
+  });
+}
+
+describe('chat thread workspace panel persistence', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    useChatThreadStore.persist.setOptions({
+      storage: createLocalStoragePersistStorage(),
+    });
+    resetChatThreadStore();
+    window.localStorage.clear();
+  });
+
+  it('persists only the workspace panel continuity state', () => {
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-1',
+      isSending: true,
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      workspaceFileTabs: [
+        {
+          key: 'session-1::preview::README.md',
+          parentSessionKey: 'session-1',
+          path: 'README.md',
+          label: 'README.md',
+          viewMode: 'preview',
+          rawText: '# Hello',
+          fullLines: [],
+        },
+      ],
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 1,
+    });
+
+    const persisted = JSON.parse(
+      window.localStorage.getItem(chatThreadWorkspaceStorageKey) ?? '{}',
+    );
+
+    expect(persisted.state.snapshot).toMatchObject({
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 1,
+    });
+    expect(persisted.state.snapshot.sessionKey).toBeUndefined();
+    expect(persisted.state.snapshot.isSending).toBeUndefined();
+    expect(persisted.state.snapshot.workspaceFileTabs[0].rawText).toBe('# Hello');
+    expect(persisted.state.snapshot.workspaceFileTabs[0].fullLines).toBeUndefined();
+  });
+
+  it('hydrates the workspace panel state and repairs stale active file keys', async () => {
+    window.localStorage.setItem(
+      chatThreadWorkspaceStorageKey,
+      JSON.stringify({
+        state: {
+          snapshot: {
+            workspacePanelParentKey: 'session-1',
+            activeWorkspacePanelKind: 'file',
+            activeWorkspaceFileKey: 'missing-file',
+            activeChildSessionKey: 'child-session-1',
+            workspaceNavigationHistory: [
+              { kind: 'file', key: 'missing-file' },
+              { kind: 'file', key: 'session-1::preview::README.md' },
+            ],
+            workspaceNavigationHistoryIndex: 1,
+            workspaceFileTabs: [
+              {
+                key: 'session-1::preview::README.md',
+                parentSessionKey: 'session-1',
+                path: 'README.md',
+                label: 'README.md',
+                viewMode: 'preview',
+                rawText: '# Hello',
+              },
+              {
+                key: 'invalid',
+                parentSessionKey: 'session-1',
+                path: '',
+                viewMode: 'preview',
+              },
+            ],
+          },
+        },
+        version: 2,
+      }),
+    );
+
+    await useChatThreadStore.persist.rehydrate();
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      activeChildSessionKey: 'child-session-1',
+      workspaceNavigationHistory: [
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 0,
+      workspaceFileTabs: [
+        {
+          key: 'session-1::preview::README.md',
+          parentSessionKey: 'session-1',
+          path: 'README.md',
+          label: 'README.md',
+          viewMode: 'preview',
+          rawText: '# Hello',
+        },
+      ],
+    });
+  });
+});