Refactor chat into a composable workspace shell

apps/server/src/keybindings.test.ts

@@ -188,6 +188,21 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
         DEFAULT_KEYBINDINGS.map((binding) => [binding.command, binding.key] as const),
       );
 
+      assert.equal(defaultsByCommand.get("workspace.pane.splitRight"), "mod+d");
+      assert.equal(defaultsByCommand.get("workspace.pane.splitDown"), "mod+shift+d");
+      assert.equal(defaultsByCommand.get("workspace.pane.close"), "mod+w");
+      assert.equal(defaultsByCommand.get("workspace.focus.previous"), "mod+[");
+      assert.equal(defaultsByCommand.get("workspace.focus.next"), "mod+]");
+      assert.equal(defaultsByCommand.get("workspace.focus.left"), "mod+alt+arrowleft");
+      assert.equal(defaultsByCommand.get("workspace.focus.right"), "mod+alt+arrowright");
+      assert.equal(defaultsByCommand.get("workspace.focus.up"), "mod+alt+arrowup");
+      assert.equal(defaultsByCommand.get("workspace.focus.down"), "mod+alt+arrowdown");
+      assert.equal(defaultsByCommand.get("workspace.pane.toggleZoom"), "mod+shift+enter");
+      assert.equal(defaultsByCommand.get("workspace.pane.resizeLeft"), "mod+ctrl+arrowleft");
+      assert.equal(defaultsByCommand.get("workspace.pane.resizeRight"), "mod+ctrl+arrowright");
+      assert.equal(defaultsByCommand.get("workspace.pane.resizeUp"), "mod+ctrl+arrowup");
+      assert.equal(defaultsByCommand.get("workspace.pane.resizeDown"), "mod+ctrl+arrowdown");
+      assert.equal(defaultsByCommand.get("workspace.pane.equalize"), "mod+ctrl+=");
       assert.equal(defaultsByCommand.get("thread.previous"), "mod+shift+[");
       assert.equal(defaultsByCommand.get("thread.next"), "mod+shift+]");
       assert.equal(defaultsByCommand.get("thread.jump.1"), "mod+1");

apps/server/src/keybindings.ts

@@ -60,7 +60,22 @@ export const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule> = [
   { key: "mod+d", command: "terminal.split", when: "terminalFocus" },
   { key: "mod+n", command: "terminal.new", when: "terminalFocus" },
   { key: "mod+w", command: "terminal.close", when: "terminalFocus" },
-  { key: "mod+d", command: "diff.toggle", when: "!terminalFocus" },
+  { key: "mod+d", command: "workspace.pane.splitRight", when: "!terminalFocus" },
+  { key: "mod+shift+d", command: "workspace.pane.splitDown", when: "!terminalFocus" },
+  { key: "mod+w", command: "workspace.pane.close", when: "!terminalFocus" },
+  { key: "mod+[", command: "workspace.focus.previous" },
+  { key: "mod+]", command: "workspace.focus.next" },
+  { key: "mod+alt+arrowup", command: "workspace.focus.up" },
+  { key: "mod+alt+arrowdown", command: "workspace.focus.down" },
+  { key: "mod+alt+arrowleft", command: "workspace.focus.left" },
+  { key: "mod+alt+arrowright", command: "workspace.focus.right" },
+  { key: "mod+shift+enter", command: "workspace.pane.toggleZoom" },
+  { key: "mod+ctrl+arrowup", command: "workspace.pane.resizeUp" },
+  { key: "mod+ctrl+arrowdown", command: "workspace.pane.resizeDown" },
+  { key: "mod+ctrl+arrowleft", command: "workspace.pane.resizeLeft" },
+  { key: "mod+ctrl+arrowright", command: "workspace.pane.resizeRight" },
+  { key: "mod+ctrl+=", command: "workspace.pane.equalize" },
+  { key: "mod+alt+d", command: "diff.toggle", when: "!terminalFocus" },
   { key: "mod+k", command: "commandPalette.toggle", when: "!terminalFocus" },
   { key: "mod+n", command: "chat.new", when: "!terminalFocus" },
   { key: "mod+shift+o", command: "chat.new", when: "!terminalFocus" },

apps/web/src/clientPersistenceStorage.test.ts

@@ -77,4 +77,53 @@ describe("clientPersistenceStorage", () => {
       ],
     });
   });
+
+  it("reads and writes workspace documents as JSON blobs", async () => {
+    const testWindow = getTestWindow();
+    const {
+      WORKSPACE_DOCUMENT_STORAGE_KEY,
+      readBrowserWorkspaceDocument,
+      writeBrowserWorkspaceDocument,
+    } = await import("./clientPersistenceStorage");
+    const workspaceDocument = {
+      version: 1 as const,
+      layoutEngine: "split" as const,
+      rootNodeId: "node-1",
+      nodesById: {
+        "node-1": {
+          id: "node-1",
+          kind: "window" as const,
+          windowId: "window-1",
+        },
+      },
+      windowsById: {
+        "window-1": {
+          id: "window-1",
+          surfaceId: "surface-1",
+        },
+      },
+      surfacesById: {
+        "surface-1": {
+          id: "surface-1",
+          kind: "thread" as const,
+          input: {
+            scope: "server" as const,
+            threadRef: {
+              environmentId: testEnvironmentId,
+              threadId: "thread-1",
+            },
+          },
+        },
+      },
+      focusedWindowId: "window-1",
+      mobileActiveWindowId: "window-1",
+    };
+
+    writeBrowserWorkspaceDocument(workspaceDocument);
+
+    expect(readBrowserWorkspaceDocument<typeof workspaceDocument>()).toEqual(workspaceDocument);
+    expect(JSON.parse(testWindow.localStorage.getItem(WORKSPACE_DOCUMENT_STORAGE_KEY)!)).toEqual(
+      workspaceDocument,
+    );
+  });
 });

apps/web/src/clientPersistenceStorage.ts

@@ -11,6 +11,7 @@ import { getLocalStorageItem, setLocalStorageItem } from "./hooks/useLocalStorag
 
 export const CLIENT_SETTINGS_STORAGE_KEY = "t3code:client-settings:v1";
 export const SAVED_ENVIRONMENT_REGISTRY_STORAGE_KEY = "t3code:saved-environment-registry:v1";
+export const WORKSPACE_DOCUMENT_STORAGE_KEY = "t3code:workspace-document:v1";
 
 const BrowserSavedEnvironmentRecordSchema = Schema.Struct({
   environmentId: EnvironmentId,
@@ -34,6 +35,34 @@ function hasWindow(): boolean {
   return typeof window !== "undefined";
 }
 
+function readBrowserJsonDocument<T>(storageKey: string): T | null {
+  if (!hasWindow()) {
+    return null;
+  }
+
+  try {
+    const raw = window.localStorage.getItem(storageKey);
+    if (!raw) {
+      return null;
+    }
+    return JSON.parse(raw) as T;
+  } catch {
+    return null;
+  }
+}
+
+function writeBrowserJsonDocument<T>(storageKey: string, document: T): void {
+  if (!hasWindow()) {
+    return;
+  }
+
+  try {
+    window.localStorage.setItem(storageKey, JSON.stringify(document));
+  } catch {
+    // Ignore quota/storage errors to avoid breaking the app.
+  }
+}
+
 function toPersistedSavedEnvironmentRecord(
   record: PersistedSavedEnvironmentRecord,
 ): PersistedSavedEnvironmentRecord {
@@ -192,3 +221,11 @@ export function removeBrowserSavedEnvironmentSecret(environmentId: EnvironmentId
     }),
   });
 }
+
+export function readBrowserWorkspaceDocument<T>(): T | null {
+  return readBrowserJsonDocument<T>(WORKSPACE_DOCUMENT_STORAGE_KEY);
+}
+
+export function writeBrowserWorkspaceDocument<T>(document: T): void {
+  writeBrowserJsonDocument(WORKSPACE_DOCUMENT_STORAGE_KEY, document);
+}

apps/web/src/commandPaletteStore.ts

@@ -1,13 +1,27 @@
 import { create } from "zustand";
 
+export interface CommandPaletteWorkspaceTarget {
+  disposition: "split-right" | "split-down";
+}
+
 interface CommandPaletteStore {
   open: boolean;
+  workspaceTarget: CommandPaletteWorkspaceTarget | null;
   setOpen: (open: boolean) => void;
   toggleOpen: () => void;
+  openWorkspaceTarget: (target: CommandPaletteWorkspaceTarget) => void;
+  clearWorkspaceTarget: () => void;
 }
 
 export const useCommandPaletteStore = create<CommandPaletteStore>((set) => ({
   open: false,
-  setOpen: (open) => set({ open }),
-  toggleOpen: () => set((state) => ({ open: !state.open })),
+  workspaceTarget: null,
+  setOpen: (open) => set({ open, ...(open ? {} : { workspaceTarget: null }) }),
+  toggleOpen: () =>
+    set((state) => ({
+      open: !state.open,
+      ...(!state.open ? {} : { workspaceTarget: null }),
+    })),
+  openWorkspaceTarget: (target) => set({ open: true, workspaceTarget: target }),
+  clearWorkspaceTarget: () => set({ workspaceTarget: null }),
 }));