Add Emacs/readline editing mode

apps/desktop/src/settings/DesktopClientSettings.test.ts

@@ -19,6 +19,7 @@ const clientSettings: ClientSettings = {
   dismissedProviderUpdateNotificationKeys: [],
   diffIgnoreWhitespace: true,
   favorites: [],
+  keyboardEditingMode: "emacs",
   providerModelPreferences: {},
   sidebarAutoSettleAfterDays: 3,
   sidebarProjectGroupingMode: "repository_path",

apps/server/src/keybindings.test.ts

@@ -88,6 +88,7 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
 
       assert.deepEqual(compiled, {
         command: "terminal.split",
+        source: "user",
         shortcut: {
           key: "d",
           metaKey: false,
@@ -187,6 +188,19 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
     }).pipe(Effect.provide(makeKeybindingsLayer())),
   );
 
+  it.effect("marks startup-written defaults as defaults in runtime snapshots", () =>
+    Effect.gen(function* () {
+      const snapshot = yield* Effect.gen(function* () {
+        const keybindings = yield* Keybindings.Keybindings;
+        yield* keybindings.syncDefaultKeybindingsOnStartup;
+        return yield* keybindings.loadConfigState;
+      });
+
+      assert.equal(snapshot.keybindings.length, Keybindings.DEFAULT_KEYBINDINGS.length);
+      assert.isTrue(snapshot.keybindings.every((binding) => binding.source === "default"));
+    }).pipe(Effect.provide(makeKeybindingsLayer())),
+  );
+
   it.effect("ships configurable thread navigation defaults", () =>
     Effect.sync(() => {
       const defaultsByCommand = new Map(
@@ -219,7 +233,7 @@ it.layer(NodeServices.layer)("keybindings", (it) => {
 
       assert.deepEqual(
         configState.keybindings,
-        Keybindings.compileResolvedKeybindingsConfig(Keybindings.DEFAULT_KEYBINDINGS),
+        Keybindings.compileResolvedKeybindingsConfig(Keybindings.DEFAULT_KEYBINDINGS, "default"),
       );
       assert.deepEqual(configState.issues, [
         {

apps/server/src/keybindings.ts

@@ -109,6 +109,22 @@ function isSameKeybindingRule(left: KeybindingRule, right: KeybindingRule): bool
   );
 }
 
+function compileRuntimeKeybindingsConfig(
+  config: ReadonlyArray<KeybindingRule>,
+): ResolvedKeybindingsConfig {
+  const compiled: ResolvedKeybindingRule[] = [];
+  for (const rule of config) {
+    const source = DEFAULT_KEYBINDINGS.some((defaultRule) =>
+      isSameKeybindingRule(rule, defaultRule),
+    )
+      ? "default"
+      : "user";
+    const resolved = compileResolvedKeybindingRule(rule, source);
+    if (resolved) compiled.push(resolved);
+  }
+  return compiled.slice(-MAX_KEYBINDINGS_COUNT);
+}
+
 function keybindingShortcutContext(rule: KeybindingRule): string | null {
   const parsed = parseKeybindingShortcut(rule.key);
   if (!parsed) return null;
@@ -448,7 +464,7 @@ const make = Effect.gen(function* () {
 
   const loadConfigStateFromDisk = loadRuntimeCustomKeybindingsConfig().pipe(
     Effect.map(({ keybindings, issues }) => ({
-      keybindings: mergeWithDefaultKeybindings(compileResolvedKeybindingsConfig(keybindings)),
+      keybindings: mergeWithDefaultKeybindings(compileRuntimeKeybindingsConfig(keybindings)),
       issues,
     })),
   );
@@ -664,7 +680,7 @@ const make = Effect.gen(function* () {
           }
           yield* writeConfigAtomically(cappedConfig);
           const nextResolved = mergeWithDefaultKeybindings(
-            compileResolvedKeybindingsConfig(cappedConfig),
+            compileRuntimeKeybindingsConfig(cappedConfig),
           );
           yield* Cache.set(resolvedConfigCache, resolvedConfigCacheKey, {
             keybindings: nextResolved,
@@ -685,7 +701,7 @@ const make = Effect.gen(function* () {
           const nextConfig = customConfig.filter((entry) => !isSameKeybindingRule(entry, target));
           yield* writeConfigAtomically(nextConfig);
           const nextResolved = mergeWithDefaultKeybindings(
-            compileResolvedKeybindingsConfig(nextConfig),
+            compileRuntimeKeybindingsConfig(nextConfig),
           );
           yield* Cache.set(resolvedConfigCache, resolvedConfigCacheKey, {
             keybindings: nextResolved,

apps/web/src/AppRoot.test.tsx

@@ -3,22 +3,28 @@ import { RouterProvider } from "@tanstack/react-router";
 import { describe, expect, it } from "vite-plus/test";
 
 import { ElectronBrowserHost } from "./browser/ElectronBrowserHost";
+import { EmacsReadlineBindings } from "./components/EmacsReadlineBindings";
 import { PreviewAutomationHosts } from "./components/preview/PreviewAutomationHosts";
 import { AppAtomRegistryProvider } from "./rpc/atomRegistry";
 import type { AppRouter } from "./router";
 import { AppRoot } from "./AppRoot";
 
 describe("AppRoot", () => {
   it("shares the application atom registry with routed UI and renderer-wide desktop hosts", () => {
-    const root = AppRoot({ router: {} as AppRouter });
+    const router = {} as AppRouter;
+    const root = AppRoot({ router });
 
     expect(root.type).toBe(AppAtomRegistryProvider);
     const children = Children.toArray(
       (root as ReactElement<{ readonly children: ReactNode }>).props.children,
     );
-    expect(children).toHaveLength(3);
-    expect(isValidElement(children[0]) && children[0].type).toBe(RouterProvider);
-    expect(isValidElement(children[1]) && children[1].type).toBe(PreviewAutomationHosts);
-    expect(isValidElement(children[2]) && children[2].type).toBe(ElectronBrowserHost);
+    expect(children).toHaveLength(4);
+    expect(isValidElement(children[0]) && children[0].type).toBe(EmacsReadlineBindings);
+    expect(
+      isValidElement<{ readonly router: AppRouter }>(children[0]) && children[0].props.router,
+    ).toBe(router);
+    expect(isValidElement(children[1]) && children[1].type).toBe(RouterProvider);
+    expect(isValidElement(children[2]) && children[2].type).toBe(PreviewAutomationHosts);
+    expect(isValidElement(children[3]) && children[3].type).toBe(ElectronBrowserHost);
   });
 });

apps/web/src/AppRoot.tsx

@@ -1,6 +1,7 @@
 import { RouterProvider } from "@tanstack/react-router";
 
 import { ElectronBrowserHost } from "./browser/ElectronBrowserHost";
+import { EmacsReadlineBindings } from "./components/EmacsReadlineBindings";
 import { PreviewAutomationHosts } from "./components/preview/PreviewAutomationHosts";
 import { AppAtomRegistryProvider } from "./rpc/atomRegistry";
 import type { AppRouter } from "./router";
@@ -13,6 +14,7 @@ import type { AppRouter } from "./router";
 export function AppRoot({ router }: { readonly router: AppRouter }) {
   return (
     <AppAtomRegistryProvider>
+      <EmacsReadlineBindings router={router} />
       <RouterProvider router={router} />
       <PreviewAutomationHosts />
       <ElectronBrowserHost />

apps/web/src/components/ComposerPromptEditor.test.ts

@@ -4,13 +4,74 @@ import {
   $createTextNode,
   $getRoot,
   $getSelection,
+  $isElementNode,
   $isRangeSelection,
   COMMAND_PRIORITY_EDITOR,
   createEditor,
   PASTE_COMMAND,
 } from "lexical";
 
 import { registerComposerInlineTokenPaste } from "./composerInlineTokenPaste";
+import { $replaceComposerReadlineSelection } from "../composerEmacsReadline";
+
+describe("$replaceComposerReadlineSelection", () => {
+  it.each([
+    {
+      boundary: "at EOF",
+      serializedToken: "[file.ts](src/file.ts)",
+      suffix: "",
+      tokenType: "mention",
+    },
+    {
+      boundary: "before punctuation",
+      serializedToken: "[file.ts](src/file.ts)",
+      suffix: ".",
+      tokenType: "mention",
+    },
+    {
+      boundary: "at EOF",
+      serializedToken: "$review",
+      suffix: "",
+      tokenType: "skill",
+    },
+    {
+      boundary: "before punctuation",
+      serializedToken: "$review",
+      suffix: ".",
+      tokenType: "skill",
+    },
+  ])(
+    "preserves an existing $tokenType chip $boundary during a readline mutation",
+    ({ serializedToken, suffix }) => {
+      const editor = createEditor();
+      let tokenKey = "";
+
+      editor.update(
+        () => {
+          const paragraph = $createParagraphNode();
+          const prefix = $createTextNode("before");
+          const token = $createTextNode(serializedToken).setMode("token");
+          tokenKey = token.getKey();
+          paragraph.append(prefix, token);
+          if (suffix.length > 0) paragraph.append($createTextNode(suffix));
+          $getRoot().append(paragraph);
+
+          $replaceComposerReadlineSelection(prefix.select(0, 1), [$createTextNode("B")]);
+        },
+        { discrete: true },
+      );
+
+      editor.getEditorState().read(() => {
+        const paragraph = $getRoot().getFirstChild();
+        expect($isElementNode(paragraph)).toBe(true);
+        if (!$isElementNode(paragraph)) return;
+        const token = paragraph.getChildren().find((node) => node.getKey() === tokenKey);
+        expect(token?.getTextContent()).toBe(serializedToken);
+        expect($getRoot().getTextContent()).toBe(`Before${serializedToken}${suffix}`);
+      });
+    },
+  );
+});
 
 class TestClipboardEvent extends Event {
   readonly clipboardData: DataTransfer;