Support custom spoken forms for actions (#2334)

## Checklist

- [x] I have added
[tests](https://www.cursorless.org/docs/contributing/test-case-recorder/)
- [-] I have updated the
[docs](https://github.com/cursorless-dev/cursorless/tree/main/docs) and
[cheatsheet](https://github.com/cursorless-dev/cursorless/tree/main/cursorless-talon/src/cheatsheet)
- [x] I have not broken the cheatsheet
- [x] I have run Talon-side tests

Author: pokey

cursorless-talon/src/spoken_forms.py

@@ -4,6 +4,7 @@
 
 from talon import app, fs
 
+from .actions.actions import ACTION_LIST_NAMES
 from .csv_overrides import (
     SPOKEN_FORM_HEADER,
     ListToSpokenForms,
@@ -70,6 +71,12 @@ def ret(filename: str, *args: P.args, **kwargs: P.kwargs) -> R:
     "scope_type": "simpleScopeTypeType",
     "glyph_scope_type": "complexScopeTypeType",
     "custom_regex_scope_type": "customRegex",
+    **{
+        action_list_name: "action"
+        for action_list_name in ACTION_LIST_NAMES
+        if action_list_name != "custom_action"
+    },
+    "custom_action": "customAction",
 }
 
 

data/fixtures/recorded/actions/parseTreeFile.yml

@@ -10,6 +10,9 @@ command:
         - type: containingScope
           scopeType: {type: document}
   usePrePhraseSnapshot: true
+spokenFormError: >-
+  action with id private.showParseTree; this is a private spoken form currently
+  only for internal experimentation
 initialState:
   documentContents: const value = 2;
   selections:

packages/cursorless-engine/src/customCommandGrammar/lexer.ts

@@ -5,7 +5,6 @@ import {
   simpleScopeTypeTypes,
   surroundingPairNames,
 } from "@cursorless/common";
-import { actions } from "../generateSpokenForm/defaultSpokenForms/actions";
 import { marks } from "../generateSpokenForm/defaultSpokenForms/marks";
 import { defaultSpokenFormMap } from "../spokenForms/defaultSpokenFormMap";
 import { connectives } from "../generateSpokenForm/defaultSpokenForms/connectives";
@@ -21,8 +20,8 @@ const tokens: Record<string, Token> = {};
 // FIXME: Remove the duplication below?
 
 for (const simpleActionName of simpleActionNames) {
-  const spokenForm = actions[simpleActionName];
-  if (spokenForm != null) {
+  const { spokenForms } = defaultSpokenFormMap.action[simpleActionName];
+  for (const spokenForm of spokenForms) {
     tokens[spokenForm] = {
       type: "simpleActionName",
       value: simpleActionName,
@@ -36,8 +35,8 @@ const bringMoveActionNames: BringMoveActionDescriptor["name"][] = [
 ];
 
 for (const bringMoveActionName of bringMoveActionNames) {
-  const spokenForm = actions[bringMoveActionName];
-  if (spokenForm != null) {
+  const { spokenForms } = defaultSpokenFormMap.action[bringMoveActionName];
+  for (const spokenForm of spokenForms) {
     tokens[spokenForm] = {
       type: "bringMove",
       value: bringMoveActionName,

packages/cursorless-engine/src/generateSpokenForm/CustomSpokenFormGeneratorImpl.test.ts

@@ -1,10 +1,10 @@
 import assert from "node:assert";
 import { CustomSpokenFormGeneratorImpl } from "./CustomSpokenFormGeneratorImpl";
-import { asyncSafety } from "@cursorless/common";
+import { LATEST_VERSION, asyncSafety } from "@cursorless/common";
 
 suite("CustomSpokenFormGeneratorImpl", async function () {
   test(
-    "glyph",
+    "basic",
     asyncSafety(async () => {
       const generator = new CustomSpokenFormGeneratorImpl({
         async getSpokenFormEntries() {
@@ -14,22 +14,47 @@ suite("CustomSpokenFormGeneratorImpl", async function () {
               id: "glyph",
               spokenForms: ["foo"],
             },
+            {
+              type: "action",
+              id: "setSelection",
+              spokenForms: ["bar"],
+            },
           ];
         },
         onDidChange: () => ({ dispose() {} }),
       });
 
       await generator.customSpokenFormsInitialized;
 
-      const spokenForm = generator.scopeTypeToSpokenForm({
-        type: "glyph",
-        character: "a",
-      });
-
-      assert.deepStrictEqual(spokenForm, {
-        type: "success",
-        spokenForms: ["foo air"],
-      });
+      assert.deepStrictEqual(
+        generator.scopeTypeToSpokenForm({
+          type: "glyph",
+          character: "a",
+        }),
+        {
+          type: "success",
+          spokenForms: ["foo air"],
+        },
+      );
+      assert.deepStrictEqual(
+        generator.commandToSpokenForm({
+          version: LATEST_VERSION,
+          action: {
+            name: "setSelection",
+            target: {
+              type: "primitive",
+              mark: {
+                type: "cursor",
+              },
+            },
+          },
+          usePrePhraseSnapshot: false,
+        }),
+        {
+          type: "success",
+          spokenForms: ["bar this"],
+        },
+      );
     }),
   );
 });

packages/cursorless-engine/src/generateSpokenForm/CustomSpokenFormGeneratorImpl.ts

@@ -1,4 +1,5 @@
 import {
+  ActionType,
   CommandComplete,
   Disposable,
   Listener,
@@ -54,6 +55,10 @@ export class CustomSpokenFormGeneratorImpl
     return this.spokenFormGenerator.processScopeType(scopeType);
   }
 
+  actionIdToSpokenForm(actionId: ActionType) {
+    return this.customSpokenForms.spokenFormMap.action[actionId];
+  }
+
   getCustomRegexScopeTypes() {
     return this.customSpokenForms.getCustomRegexScopeTypes();
   }

packages/cursorless-engine/src/generateSpokenForm/defaultSpokenForms/actions.ts

@@ -8,7 +8,6 @@ import {
   camelCaseToAllDown,
 } from "@cursorless/common";
 import { NoSpokenFormError } from "./NoSpokenFormError";
-import { actions } from "./defaultSpokenForms/actions";
 import { connectives } from "./defaultSpokenForms/connectives";
 import { surroundingPairDelimitersToSpokenForm } from "./defaultSpokenForms/modifiers";
 import {
@@ -111,25 +110,28 @@ export class SpokenFormGenerator {
       case "replaceWithTarget":
       case "moveToTarget":
         return [
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleTarget(action.source),
           this.handleDestination(action.destination),
         ];
 
       case "swapTargets":
         return [
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleTarget(action.target1),
           connectives.swapConnective,
           this.handleTarget(action.target2),
         ];
 
       case "callAsFunction":
         if (action.argument.type === "implicit") {
-          return [actions[action.name], this.handleTarget(action.callee)];
+          return [
+            this.spokenFormMap.action[action.name],
+            this.handleTarget(action.callee),
+          ];
         }
         return [
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleTarget(action.callee),
           "on",
           this.handleTarget(action.argument),
@@ -143,19 +145,19 @@ export class SpokenFormGenerator {
             action.left,
             action.right,
           ),
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleTarget(action.target),
         ];
 
       case "pasteFromClipboard":
         return [
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleDestination(action.destination),
         ];
 
       case "insertSnippet":
         return [
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           insertionSnippetToSpokenForm(action.snippetDescription),
           this.handleDestination(action.destination),
         ];
@@ -164,24 +166,33 @@ export class SpokenFormGenerator {
         if (action.snippetName != null) {
           throw new NoSpokenFormError(`${action.name}.snippetName`);
         }
-        return [actions[action.name], this.handleTarget(action.target)];
+        return [
+          this.spokenFormMap.action[action.name],
+          this.handleTarget(action.target),
+        ];
 
       case "wrapWithSnippet":
         return [
           wrapperSnippetToSpokenForm(action.snippetDescription),
-          actions[action.name],
+          this.spokenFormMap.action[action.name],
           this.handleTarget(action.target),
         ];
 
       case "highlight": {
         if (action.highlightId != null) {
           throw new NoSpokenFormError(`${action.name}.highlightId`);
         }
-        return [actions[action.name], this.handleTarget(action.target)];
+        return [
+          this.spokenFormMap.action[action.name],
+          this.handleTarget(action.target),
+        ];
       }
 
       default: {
-        return [actions[action.name], this.handleTarget(action.target)];
+        return [
+          this.spokenFormMap.action[action.name],
+          this.handleTarget(action.target),
+        ];
       }
     }
   }

packages/cursorless-engine/src/generateSpokenForm/generateSpokenForm.ts

@@ -22,6 +22,8 @@ export const SUPPORTED_ENTRY_TYPES = [
   "complexScopeTypeType",
   "customRegex",
   "pairedDelimiter",
+  "action",
+  "customAction",
 ] as const;
 
 type SupportedEntryType = (typeof SUPPORTED_ENTRY_TYPES)[number];

packages/cursorless-engine/src/scopeProviders/TalonSpokenForms.ts

@@ -1,4 +1,5 @@
 import {
+  ActionType,
   ModifierType,
   SimpleScopeTypeType,
   SurroundingPairName,
@@ -33,6 +34,14 @@ export interface SpokenFormMapKeyTypes {
    */
   modifierExtra: ModifierExtra;
   customRegex: string;
+
+  action: ActionType;
+
+  /**
+   * These actions correspond to id's of app commands. Eg in VSCode, you can have
+   * custom actions corresponding to id's of VSCode commands.
+   */
+  customAction: string;
 }
 
 /**