start parsing things from the extension side

we have 2 commands (getContent and setupStep) respectively to get the full content of the tutorial and to ask the extension to set up the state in vscode for the current step.

we already support parsing the spoken form for the command to be said by the user during the getContent command and spawning the contents in vscode for the setupStep.

We need to parse the other spoken forms and to initialize better the vscode content with the hats, etc.

cursorless-talon/src/tutorial.py

@@ -3,92 +3,90 @@
 from pathlib import Path
 from typing import Callable
 
-import yaml
 from talon import actions, app
 
 from .get_action_spoken_form import lookup_action
 
-regex = re.compile(r"\{(\w+):([^}]+)\}")
-tutorial_dir = Path(
-    r"C:\work\tools\voicecoding\cursorless_fork\packages\cursorless-vscode-e2e\src\suite\fixtures\recorded\tutorial\unit-2-basic-coding"
-)
-
-
+# {literalStep:...}
+# "To see all available scopes, use the command {literalStep:cursorless help}, and look at the Scopes section."
 def process_literal_step(argument: str):
     return f"<cmd@{argument}/>"
 
-
+# {action:...}
+# "Say {action:setSelectionAfter} to place the cursor after a target: {step:postLook.yml}",
+# "Say {action:clearAndSetSelection} to delete a word and move your cursor to where it used to be: {step:clearTrap.yml}",
+# The {action:editNewLineAfter} action"  => "The "pour" action"
 def process_action(argument: str):
     _, spoken_form = lookup_action(argument)
     return f'<*"{spoken_form}"/>'
 
-
+# {scopeType:...}
+# "We can also use {scopeType:line} to refer to the line containing our cursor: {step:takeLine.yml}"
+# "Cursorless tries its best to keep your commands short. In the following command, we just say {scopeType:string} once, but cursorless infers that both targets are strings: {step:swapStringAirWithWhale.yml}"
 def process_scope_type(argument: str):
-    # TODO not sure what we are trying to achieve here
-    _, spoken_form = lookup_scope_type(argument)
-    return f'<*"{spoken_form}"/>'
-
-
-def process_cursorless_command_step(argument: str):
-    print(f"{argument=}")
-    step_fixture = yaml.safe_load((tutorial_dir / argument).read_text())
-    print(f"{step_fixture['command']=}")
-    result = actions.user.private_cursorless_run_rpc_command_get(
-        "cursorless.tutorial.create",
-        {
-            "version": 0,
-            "stepFixture": step_fixture,
-            "yamlFilename": argument,
-        },
-    )
-    print(f"{result=}")
-    return f"<cmd@{cursorless_command_to_spoken_form(step_fixture['command'])}/>"
-    # return f"<cmd@{result}/>"
-
-
-# TODO get this information from the extension
-def cursorless_command_to_spoken_form(command: dict[str, str]):
-    return command["spokenForm"]
-
-
+    #_, spoken_form = lookup_scope_type(argument)
+    #return f'<*"{spoken_form}"/>'
+    return f'<*"SCOPETYPE_{argument}"/>'
+
+# "When editing code, we often think in terms of statements, functions, etc. Let's clone a statement: {step:cloneStateInk.yml}",
+# 
+# this builds a dictionary which has keys and values (each one is a spoken form)
+# each value is built by calling the function with the argument being passed
+# eg interpolation_processor_map["step"]()
 interpolation_processor_map: dict[str, Callable[[str], str]] = {
+    # this will exist extension side
+    # nothing needed as  not a Cursorless command
     "literalStep": process_literal_step,
+    # import https://github.com/cursorless-dev/cursorless/blob/7341d0f707b1d0a0950a19894be3aebbb33582c8/packages/cursorless-engine/src/generateSpokenForm/defaultSpokenForms/actions.ts#L7C1-L7C1
+    # hardcoded list of default spoken form for an action (not yet the customized one)
     "action": process_action,
+    # scopeTypeType == "line", etc.
+# generator.processScopeType({type: scopeTypeType})
     "scopeType": process_scope_type,
-    "step": process_cursorless_command_step,
 }
 
-
-def process_tutorial_step(raw: str):
-    print(f"{raw=}")
-    current_index = 0
-    content = ""
-    for match in regex.finditer(raw):
-        content += raw[current_index : match.start()]
-        content += interpolation_processor_map[match.group(1)](match.group(2))
-        current_index = match.end()
-    content += raw[current_index : len(raw)]
-    print(f"{content=}")
-
-    return {
-        "content": content,
-        "restore_callback": print,
-        "modes": ["command"],
-        "app": "Code",
-        "context_hint": "Please open VSCode and enter command mode",
-    }
-
-
-def get_basic_coding_walkthrough():
-    with open(tutorial_dir / "script.json") as f:
-        script = json.load(f)
-
-    return [
-        actions.user.hud_create_walkthrough_step(**process_tutorial_step(step))
-        for step in script
-    ]
-
-
+# TODO all the above will be deleted
+
+def step_callback(x):
+    print(f"step_callback8: {x}")
+    yamlFilename = tutorial_content['yamlFilenames'][x]
+    if yamlFilename:
+        response = actions.user.private_cursorless_run_rpc_command_get(
+                "cursorless.tutorial.setupStep",
+                {
+                    "version": 0,
+                    "tutorialName": "unit-2-basic-coding",
+                    "yamlFilename": yamlFilename
+                },
+            )
+
+tutorial_content = None
+def get_basic_coding_walkthrough(): 
+    global tutorial_content
+    print("get_basic_coding_walkthrough start")
+    tutorial_content = actions.user.private_cursorless_run_rpc_command_get(
+        "cursorless.tutorial.getContent",
+        {
+            "version": 0,
+            "tutorialName": "unit-2-basic-coding"
+        },
+    )
+    print(f"{tutorial_content=}")
+    walkthrough_steps = []
+    for content in tutorial_content['content']:
+        walkthrough_steps.append(actions.user.hud_create_walkthrough_step(
+            content=content,
+            restore_callback=step_callback,
+            modes=["command"],
+            app="Visual Studio Code", # Windows
+            # app="Code", # OS X?
+            context_hint="Please open VSCode and enter command mode"
+        ))
+    print("get_basic_coding_walkthrough end")
+    return walkthrough_steps
+
+# this is adding the menu to the hud
+# by adding a list of HudWalkThroughStep
 def on_ready():
     actions.user.hud_add_lazy_walkthrough(
         "Cursorless basic coding", get_basic_coding_walkthrough

packages/common/src/cursorlessCommandIds.ts

@@ -47,7 +47,8 @@ export const cursorlessCommandIds = [
   "cursorless.toggleDecorations",
   "cursorless.showScopeVisualizer",
   "cursorless.hideScopeVisualizer",
-  "cursorless.tutorial.create",
+  "cursorless.tutorial.getContent",
+  "cursorless.tutorial.setupStep",
 ] as const satisfies readonly `cursorless.${string}`[];
 
 export type CursorlessCommandId = (typeof cursorlessCommandIds)[number];
@@ -77,6 +78,12 @@ export const cursorlessCommandDescriptions: Record<
   ["cursorless.hideScopeVisualizer"]: new VisibleCommand(
     "Hide the scope visualizer",
   ),
+  ["cursorless.tutorial.getContent"]: new VisibleCommand(
+    "Get the tutorial content based on Talon HUD",
+  ),
+  ["cursorless.tutorial.setupStep"]: new VisibleCommand(
+    "Setup the current step for the tutorial based on Talon HUD",
+  ),
 
   ["cursorless.command"]: new HiddenCommand("The core cursorless command"),
   ["cursorless.showQuickPick"]: new HiddenCommand(
@@ -121,7 +128,4 @@ export const cursorlessCommandDescriptions: Record<
   ["cursorless.keyboard.modal.modeToggle"]: new HiddenCommand(
     "Toggle the cursorless modal mode",
   ),
-  ["cursorless.tutorial.create"]: new VisibleCommand(
-    "Create the tutorial based on Talon HUD",
-  ),
 };

packages/cursorless-engine/src/core/Tutorial.ts

@@ -9,28 +9,59 @@ import path from "path";
 import * as yaml from "js-yaml";
 import { promises as fsp } from "node:fs";
 
-import { TestCaseFixture } from "@cursorless/common";
+import { SpokenForm, SpokenFormSuccess, TestCaseFixture } from "@cursorless/common";
 import { Dictionary } from "lodash";
 import { ide } from "../singletons/ide.singleton";
 import { HatTokenMapImpl } from "./HatTokenMapImpl";
 import { CustomSpokenFormGeneratorImpl } from "../generateSpokenForm/CustomSpokenFormGeneratorImpl";
+import { canonicalizeAndValidateCommand } from "./commandVersionUpgrades/canonicalizeAndValidateCommand";
 
-const tutorialDirectory =
-  "C:\\work\\tools\\voicecoding\\cursorless_fork\\packages\\cursorless-vscode-e2e\\src\\suite\\fixtures\\recorded\\tutorial\\unit-2-basic-coding";
+const fs = require('node:fs');
+
+// TODO use a relative path but I'm not sure where these source files are at running time
+// and CWD is C:\Users\User\AppData\Local\Programs\Microsoft VS Code\
+const tutorialRootDir =
+  "C:\\work\\tools\\voicecoding\\cursorless_fork\\packages\\cursorless-vscode-e2e\\src\\suite\\fixtures\\recorded\\tutorial\\";
+
+interface TutorialGetContentArg {
+  /**
+   * The version of the tutorial command.
+   */
+  version: 0;
+
+  /**
+   * The name of the current tutorial
+   */
+  tutorialName: string;
+}
+
+interface TutorialGetContentResponse {
+  /**
+   * The version of the tutorial command.
+   */
+  version: 0;
+
+  /**
+   * The text content of the different steps of the current tutorial
+   */
+  content: Array<string>;
 
-/**
- * The argument expected by the tutorial command.
- */
-interface TutorialCommandArg {
+  /**
+   * The yaml files of the different steps of the current tutorial (if any)
+   */
+  yamlFilenames: Array<string>;
+}
+
+interface TutorialSetupStepArg {
   /**
    * The version of the tutorial command.
    */
   version: 0;
 
   /**
-   * A representation of the yaml file
+   * The name of the current tutorial
    */
-  stepFixture: Dictionary<string>;
+  tutorialName: string;
 
   /**
    * The yaml file for the current step
@@ -39,33 +70,115 @@ interface TutorialCommandArg {
 }
 
 export class Tutorial {
+  private customSpokenFormGenerator: CustomSpokenFormGeneratorImpl;
+
   constructor(
     hatTokenMap: HatTokenMapImpl,
     customSpokenFormGenerator: CustomSpokenFormGeneratorImpl,
   ) {
-    this.create = this.create.bind(this);
+    this.getContent = this.getContent.bind(this);
+    this.setupStep = this.setupStep.bind(this);
+
+    this.customSpokenFormGenerator = customSpokenFormGenerator;
   }
 
-  async create({ version, stepFixture, yamlFilename }: TutorialCommandArg) {
+  async getContent({ version, tutorialName }: TutorialGetContentArg) {
+    console.log("getContent(){ version, tutorialName, yamlFilename }: TutorialSetupStepArg", tutorialName);
     if (version !== 0) {
       throw new Error(`Unsupported tutorial api version: ${version}`);
     }
 
-    // const fixture = stepFixture as TestCaseFixture;
-    this.createEnvironment(yamlFilename);
-    // TODO need to answer to the talon side only what is necessary
-    return stepFixture;
+    const tutorialDir = path.join(tutorialRootDir, tutorialName);
+    if (!fs.existsSync(tutorialDir)) {
+        throw new Error(`Invalid tutorial name: ${tutorialName}`);
+    } 
+
+    const scriptFile = path.join(tutorialDir, "script.json");
+    if (!fs.existsSync(scriptFile)) {
+        throw new Error(`Can't file script file: ${scriptFile} in tutorial name: ${tutorialName}`);
+    }
+    const buffer = await fsp.readFile(scriptFile);
+    const contentList = JSON.parse(buffer.toString());
+    console.log(contentList);
+
+    // this is trying to catch occurrences of things like "{step:cloneStateInk.yml}"
+    const re = /\{(\w+):([^}]+)\}/g;
+
+    var m;
+    var response : TutorialGetContentResponse = {
+      version: 0,
+      content: [],
+      yamlFilenames: [],
+    };
+    // we need to replace the {...} with the right content
+    for (var content of contentList) {
+      var yamlFilename = ""; 
+      do {
+        m = re.exec(content);
+        if (m) {
+          const name = m[1];
+          const arg = m[2];
+          console.log(name, arg);
+          if (name === "step")
+          {
+            const tutorialDir = path.join(tutorialRootDir, tutorialName);
+            if (!fs.existsSync(tutorialDir)) {
+                throw new Error(`Invalid tutorial name: ${tutorialName}`);
+            } 
+
+            const yamlFile = path.join(tutorialDir, arg)
+            if (!fs.existsSync(yamlFile)) {
+                throw new Error(`Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`);
+            }
+            yamlFilename = arg;
+
+            const buffer = await fsp.readFile(yamlFile);
+            const fixture = yaml.load(buffer.toString()) as TestCaseFixture;
+
+            // command to be said for moving to the next step
+            const spoken_form = this.customSpokenFormGenerator.commandToSpokenForm(
+              canonicalizeAndValidateCommand(fixture.command)
+            ) as SpokenFormSuccess;
+            console.log("\t", spoken_form.spokenForms[0]);
+            content = content.replace(m[0], `<cmd@${spoken_form.spokenForms[0]}/>`)
+          }
+        }
+      } while (m);
+      response.yamlFilenames.push(yamlFilename);
+      response.content.push(content);
+    }
+
+    // return to the talon side
+    return response;
   }
 
-  async createEnvironment(yamlFilename: string) {
-    const buffer = await fsp.readFile(
-      path.join(tutorialDirectory, yamlFilename),
-    );
-    const fixture = yaml.load(buffer.toString()) as TestCaseFixture;
+  async setupStep({ version, tutorialName, yamlFilename }: TutorialSetupStepArg) {
+    console.log("setupStep()", tutorialName, yamlFilename);
+    if (version !== 0) {
+      throw new Error(`Unsupported tutorial api version: ${version}`);
+    }
 
+    const tutorialDir = path.join(tutorialRootDir, tutorialName);
+    if (!fs.existsSync(tutorialDir)) {
+        throw new Error(`Invalid tutorial name: ${tutorialName}`);
+    }
+
+    // TODO check for directory traversal?
+    const yamlFile = path.join(tutorialDir, yamlFilename);
+    if (!fs.existsSync(yamlFile)) {
+        throw new Error(`Can't file yaml file: ${yamlFile} in tutorial name: ${tutorialName}`);
+    }
+    const buffer = await fsp.readFile(yamlFile);
+    const fixture = yaml.load(buffer.toString()) as TestCaseFixture;
+
     const editor = ide().openUntitledTextDocument({
       content: fixture.initialState.documentContents,
       language: fixture.languageId,
     });
+
+    // TODO set up the right hats
+
+    // return to the talon side
+    return true;
   }
 }