From 311117dce9798343f5bd83b0055c56b9d2533e3f Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Fri, 5 Apr 2024 17:25:51 -0700
Subject: [PATCH 1/8] form editor, disabled download button, nested grid which
 may have room for improvement

---
 .../sequencing/SequenceEditor.svelte          |  82 ++++---
 src/components/sequencing/SequenceForm.svelte |   3 +-
 .../form/add-missing-args-button.svelte       |  11 +
 .../sequencing/form/arg-editor.svelte         |  88 ++++++++
 .../sequencing/form/arg-title.svelte          |  19 ++
 .../sequencing/form/enum-editor.svelte        |  37 ++++
 .../form/extra-argument-editor.svelte         |  12 ++
 .../sequencing/form/num-editor.svelte         |  61 ++++++
 .../sequencing/form/selected-command.svelte   | 202 ++++++++++++++++++
 .../sequencing/form/string-editor.svelte      |  38 ++++
 src/components/sequencing/form/utils.ts       |  95 ++++++++
 src/stores/sequencing.ts                      |   2 +
 .../sequencer-grammar-constants.ts            |   2 +
 .../new-sequence-editor/tree-utils.ts         |   8 +
 14 files changed, 628 insertions(+), 32 deletions(-)
 create mode 100644 src/components/sequencing/form/add-missing-args-button.svelte
 create mode 100644 src/components/sequencing/form/arg-editor.svelte
 create mode 100644 src/components/sequencing/form/arg-title.svelte
 create mode 100644 src/components/sequencing/form/enum-editor.svelte
 create mode 100644 src/components/sequencing/form/extra-argument-editor.svelte
 create mode 100644 src/components/sequencing/form/num-editor.svelte
 create mode 100644 src/components/sequencing/form/selected-command.svelte
 create mode 100644 src/components/sequencing/form/string-editor.svelte
 create mode 100644 src/components/sequencing/form/utils.ts

diff --git a/src/components/sequencing/SequenceEditor.svelte b/src/components/sequencing/SequenceEditor.svelte
index 575c097383..e6945266af 100644
--- a/src/components/sequencing/SequenceEditor.svelte
+++ b/src/components/sequencing/SequenceEditor.svelte
@@ -6,12 +6,13 @@
   import { lintGutter } from '@codemirror/lint';
   import { Compartment, EditorState } from '@codemirror/state';
   import type { ViewUpdate } from '@codemirror/view';
+  import type { SyntaxNode } from '@lezer/common';
   import type { CommandDictionary } from '@nasa-jpl/aerie-ampcs';
   import { EditorView, basicSetup } from 'codemirror';
   import { seq } from 'codemirror-lang-sequence';
   import { debounce } from 'lodash-es';
   import { createEventDispatcher, onMount } from 'svelte';
-  import { commandDictionaries, userSequencesRows } from '../../stores/sequencing';
+  import { commandDictionaries, userSequenceEditorColumns, userSequencesRows } from '../../stores/sequencing';
   import type { User } from '../../types/app';
   import effects from '../../utilities/effects';
   import { seqJsonLinter } from '../../utilities/new-sequence-editor/seq-json-linter';
@@ -23,6 +24,7 @@
   import CssGridGutter from '../ui/CssGridGutter.svelte';
   import Panel from '../ui/Panel.svelte';
   import SectionTitle from '../ui/SectionTitle.svelte';
+  import SelectedCommand from './form/selected-command.svelte';
 
   export let readOnly: boolean = false;
   export let sequenceCommandDictionaryId: number | null = null;
@@ -48,6 +50,7 @@
   let editorSeqJsonView: EditorView;
   let editorSequenceDiv: HTMLDivElement;
   let editorSequenceView: EditorView;
+  let selectedNode: SyntaxNode | null;
 
   $: {
     if (editorSequenceView) {
@@ -122,8 +125,15 @@
     editorSeqJsonView.dispatch({ changes: { from: 0, insert: seqJsonStr, to: editorSeqJsonView.state.doc.length } });
 
     dispatch('sequence', sequence);
+
+    const updatedSelectionNode = tree.resolveInner(viewUpdate.state.selection.asSingle().main.from, -1);
+    // minimize triggering selected command view
+    if (selectedNode !== updatedSelectionNode) {
+      selectedNode = updatedSelectionNode;
+    }
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   function downloadSeqJson() {
     const a = document.createElement('a');
     a.href = URL.createObjectURL(new Blob([sequenceDefinition], { type: 'application/json' }));
@@ -132,34 +142,44 @@
   }
 </script>
 
-<CssGrid bind:rows={$userSequencesRows} minHeight={'0'}>
-  <Panel>
-    <svelte:fragment slot="header">
-      <SectionTitle>{title}</SectionTitle>
-
-      <div class="right">
-        <slot />
-      </div>
-    </svelte:fragment>
-
-    <svelte:fragment slot="body">
-      <div bind:this={editorSequenceDiv} />
-    </svelte:fragment>
-  </Panel>
-
-  <CssGridGutter track={1} type="row" />
-
-  <Panel>
-    <svelte:fragment slot="header">
-      <SectionTitle>Seq JSON (Read-only)</SectionTitle>
-
-      <div class="right">
-        <button class="st-button secondary ellipsis" on:click={downloadSeqJson}>Download</button>
-      </div>
-    </svelte:fragment>
-
-    <svelte:fragment slot="body">
-      <div bind:this={editorSeqJsonDiv} />
-    </svelte:fragment>
-  </Panel>
+<CssGrid bind:columns={$userSequenceEditorColumns} minHeight={'0'}>
+  <CssGrid bind:rows={$userSequencesRows} minHeight={'0'}>
+    <Panel>
+      <svelte:fragment slot="header">
+        <SectionTitle>{title}</SectionTitle>
+
+        <div class="right">
+          <slot />
+        </div>
+      </svelte:fragment>
+
+      <svelte:fragment slot="body">
+        <div bind:this={editorSequenceDiv} />
+      </svelte:fragment>
+    </Panel>
+
+    <CssGridGutter track={1} type="row" />
+
+    <Panel>
+      <svelte:fragment slot="header">
+        <SectionTitle>Seq JSON (Read-only)</SectionTitle>
+
+        <!-- <div class="right">
+          <button class="st-button secondary ellipsis" on:click={downloadSeqJson}>Download</button>
+        </div> -->
+      </svelte:fragment>
+
+      <svelte:fragment slot="body">
+        <div bind:this={editorSeqJsonDiv} />
+      </svelte:fragment>
+    </Panel>
+  </CssGrid>
+
+  <CssGridGutter track={1} type="column" />
+
+  {#if !!commandDictionary && !!selectedNode}
+    <SelectedCommand node={selectedNode} {commandDictionary} {editorSequenceView} />
+  {:else}
+    <div>Selected Command</div>
+  {/if}
 </CssGrid>
diff --git a/src/components/sequencing/SequenceForm.svelte b/src/components/sequencing/SequenceForm.svelte
index d172a46292..446c836a38 100644
--- a/src/components/sequencing/SequenceForm.svelte
+++ b/src/components/sequencing/SequenceForm.svelte
@@ -80,6 +80,7 @@
     loadAdaptation(adaptation);
   });
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async function getUserSequenceFromSeqJson() {
     const file: File = seqJsonFiles[0];
     const text = await file.text();
@@ -256,7 +257,7 @@
           }}
         />
       </fieldset>
-<!--
+      <!--
       <fieldset>
         <label for="seqJsonFile">Create Sequence from Seq JSON (optional)</label>
         <input
diff --git a/src/components/sequencing/form/add-missing-args-button.svelte b/src/components/sequencing/form/add-missing-args-button.svelte
new file mode 100644
index 0000000000..9b1c181f07
--- /dev/null
+++ b/src/components/sequencing/form/add-missing-args-button.svelte
@@ -0,0 +1,11 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  export let setInEditor: () => void;
+</script>
+
+<div>
+  <button on:click={setInEditor}>
+    Add Missing Arguments
+  </button>
+</div>
diff --git a/src/components/sequencing/form/arg-editor.svelte b/src/components/sequencing/form/arg-editor.svelte
new file mode 100644
index 0000000000..a0ba94fd39
--- /dev/null
+++ b/src/components/sequencing/form/arg-editor.svelte
@@ -0,0 +1,88 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import type { SyntaxNode } from '@lezer/common';
+  import type { CommandDictionary, FswCommandArgument } from '@nasa-jpl/aerie-ampcs';
+  import EnumEditor from './enum-editor.svelte';
+  import ExtraArgumentEditor from './extra-argument-editor.svelte';
+  import StringEditor from './string-editor.svelte';
+  import NumEditor from './num-editor.svelte';
+  import { isNumberArg, type ArgTextDef, isFswCommandArgumentRepeat, isFswCommandArgumentVarString, getMissingArgDefs } from './utils';
+  import AddMissingArgsButton from './add-missing-args-button.svelte';
+  import ArgTitle from './arg-title.svelte';
+
+  export let argInfo: ArgTextDef;
+  export let commandDictionary: CommandDictionary;
+  export let setInEditor: (token: SyntaxNode, val: string) => void;
+  export let addDefaultArgs: (commandNode: SyntaxNode, argDefs: FswCommandArgument[]) => void;
+</script>
+
+{#if !argInfo.argDef}
+  {#if argInfo.text}
+    <div title="Unknown Argument">Unknown Argument</div>
+    <ExtraArgumentEditor
+      initVal={argInfo.text}
+      setInEditor={() => {
+        if (argInfo.node) {
+          setInEditor(argInfo.node, '');
+        }
+      }}
+    />
+  {/if}
+{:else}
+  <ArgTitle argDef={argInfo.argDef} />
+  {#if argInfo.argDef.arg_type === 'enum' && argInfo.node?.name === 'String'}
+    <EnumEditor
+      {commandDictionary}
+      argDef={argInfo.argDef}
+      initVal={argInfo.text ?? ''}
+      setInEditor={(val) => {
+        if (argInfo.node) {
+          setInEditor(argInfo.node, val);
+        }
+      }}
+    />
+  {:else if isNumberArg(argInfo.argDef) && argInfo.node?.name === 'Number'}
+    <NumEditor
+      argDef={argInfo.argDef}
+      initVal={argInfo.text ?? (argInfo.argDef.default_value ?? 0).toString()}
+      setInEditor={(val) => {
+        if (argInfo.node) {
+          setInEditor(argInfo.node, val);
+        }
+      }}
+    />
+  {:else if isFswCommandArgumentVarString(argInfo.argDef)}
+    <StringEditor
+      argDef={argInfo.argDef}
+      initVal={argInfo.text ?? ''}
+      setInEditor={(val) => {
+        if (argInfo.node) {
+          setInEditor(argInfo.node, val);
+        }
+      }}
+    />
+  {:else if isFswCommandArgumentRepeat(argInfo.argDef) && !!argInfo.children}
+    {#each argInfo.children as childArgInfo }
+      {#if childArgInfo.node}
+        <svelte:self
+          argInfo={childArgInfo}
+          {commandDictionary}
+          {setInEditor}
+          {addDefaultArgs}
+        />
+      {/if}
+    {/each}
+    {#if argInfo.children.find(childArgInfo => !childArgInfo.node)}
+      <AddMissingArgsButton
+        setInEditor={() => {
+          if (argInfo.node && argInfo.children) {
+            addDefaultArgs(argInfo.node, getMissingArgDefs(argInfo.children));
+          }
+        }}
+      />
+    {/if}
+  {:else}
+    <div>Unexpected value for definition</div>
+  {/if}
+{/if}
diff --git a/src/components/sequencing/form/arg-title.svelte b/src/components/sequencing/form/arg-title.svelte
new file mode 100644
index 0000000000..2291a948ec
--- /dev/null
+++ b/src/components/sequencing/form/arg-title.svelte
@@ -0,0 +1,19 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import type { FswCommandArgument } from '@nasa-jpl/aerie-ampcs';
+
+  export let argDef: FswCommandArgument;
+
+  function getArgTitle(argDef: FswCommandArgument) {
+    if ("units" in argDef) {
+      return `${argDef.name} - (${argDef.units})`;
+    }
+    return argDef.name;
+  }
+</script>
+
+<details>
+  <summary>{getArgTitle(argDef)}</summary>
+  {argDef.description}
+</details>
diff --git a/src/components/sequencing/form/enum-editor.svelte b/src/components/sequencing/form/enum-editor.svelte
new file mode 100644
index 0000000000..c1db09fc0c
--- /dev/null
+++ b/src/components/sequencing/form/enum-editor.svelte
@@ -0,0 +1,37 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import type { CommandDictionary, FswCommandArgumentEnum } from '@nasa-jpl/aerie-ampcs';
+  import { quoteEscape, unquoteUnescape } from './utils';
+
+  export let argDef: FswCommandArgumentEnum;
+  export let commandDictionary: CommandDictionary;
+  export let initVal: string;
+  export let setInEditor: (val: string) => void;
+
+  $: value = unquoteUnescape(initVal);
+  $: enumValues = commandDictionary.enumMap[argDef.enum_name]?.values ?? [];
+  $: isValueInEnum = !!enumValues.find(ev => ev.symbol === value);
+  $: { setInEditor(quoteEscape(value)); }
+</script>
+
+<div>
+  <select
+    class="st-select"
+    required
+    bind:value
+  >
+    {#if !isValueInEnum}
+      <option>{value}</option>
+    {/if}
+    {#each enumValues as ev }
+      <option>{ev.symbol}</option>
+    {/each}
+  </select>
+</div>
+
+<style>
+  select {
+    width: 90%;
+  }
+</style>
diff --git a/src/components/sequencing/form/extra-argument-editor.svelte b/src/components/sequencing/form/extra-argument-editor.svelte
new file mode 100644
index 0000000000..4e31d8a183
--- /dev/null
+++ b/src/components/sequencing/form/extra-argument-editor.svelte
@@ -0,0 +1,12 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  export let initVal: string;
+
+  export let setInEditor: () => void;
+</script>
+
+<div>
+  <button on:click={setInEditor}>Remove</button>
+  <span>{initVal}</span>
+</div>
diff --git a/src/components/sequencing/form/num-editor.svelte b/src/components/sequencing/form/num-editor.svelte
new file mode 100644
index 0000000000..c6bb0c2c6c
--- /dev/null
+++ b/src/components/sequencing/form/num-editor.svelte
@@ -0,0 +1,61 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  // This uses JS number to represents arguments which shoul
+
+  // ("+" | "-")? (@digit ("_" | @digit)* ("." ("_" | @digit)*)? | "." @digit ("_" | @digit)*)
+  // (("e" | "E") ("+" | "-")? ("_" | @digit)+)? |
+  // @digit ("_" | @digit)* "n" |
+
+  import { isFswCommandArgumentInteger, isFswCommandArgumentUnsigned, type NumberArg } from './utils';
+
+  // const PAT_INT = "^[-+]?\\d+$";
+  // const PAT_FLOAT = "^[-+]?\\d+\.?\\d*$";
+
+  export let argDef: NumberArg;
+  export let initVal: string;
+  export let setInEditor: (val: string) => void;
+
+  // $: pattern = isFswCommandArgumentUnsigned(argDef) ? PAT_INT : PAT_FLOAT;
+
+  $: max = argDef.range?.max ?? Infinity;
+  $: min =
+    argDef.range?.min ?? (isFswCommandArgumentUnsigned(argDef) || isFswCommandArgumentInteger(argDef) ? 0 : -Infinity);
+  $: value = initVal;
+  $: {
+    const valFloat = Number(value);
+    //  && valFloat > min && valFloat < max
+    if (value && !isNaN(valFloat)) {
+      setInEditor(value);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  function customValidate(e: Event & { currentTarget: EventTarget & HTMLInputElement }) {
+    // const val = (e.target as HTMLInputElement).value;
+    const numVal = Number(value);
+    if (numVal < min) {
+      (e.target as HTMLInputElement).setCustomValidity('value is too low');
+    } else if (numVal > max) {
+      (e.target as HTMLInputElement).setCustomValidity('value is too low');
+    } else {
+      (e.target as HTMLInputElement).setCustomValidity('');
+    }
+  }
+</script>
+
+<div>
+  <input class="st-input" type="string" bind:value required />
+  <!-- {pattern} -->
+  <!-- on:input={customValidate} -->
+</div>
+
+<style>
+  input {
+    width: 90%;
+  }
+
+  input:invalid {
+    color: red;
+  }
+</style>
diff --git a/src/components/sequencing/form/selected-command.svelte b/src/components/sequencing/form/selected-command.svelte
new file mode 100644
index 0000000000..e3f5dacc1e
--- /dev/null
+++ b/src/components/sequencing/form/selected-command.svelte
@@ -0,0 +1,202 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import type { EditorState } from '@codemirror/state';
+  import type { SyntaxNode } from '@lezer/common';
+  import type { CommandDictionary, FswCommandArgument, FswCommandArgumentRepeat } from '@nasa-jpl/aerie-ampcs';
+  import type { EditorView } from 'codemirror';
+  import { debounce } from 'lodash-es';
+  import { fswCommandArgDefault } from '../../../utilities/new-sequence-editor/command-dictionary';
+  import {
+    TOKEN_COMMAND,
+    TOKEN_ERROR,
+    TOKEN_REPEAT_ARG,
+  } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
+  import { getAncestorNode } from '../../../utilities/new-sequence-editor/tree-utils';
+  import AddMissingArgsButton from './add-missing-args-button.svelte';
+  import ArgEditor from './arg-editor.svelte';
+  import { getMissingArgDefs, isFswCommandArgumentRepeat, type ArgTextDef } from './utils';
+
+  export let editorSequenceView: EditorView;
+  export let commandDictionary: CommandDictionary;
+  export let node: SyntaxNode | null;
+
+  $: commandNode = getAncestorNode(node, TOKEN_COMMAND);
+  $: commandDef = getCommandDef(commandDictionary, editorSequenceView.state, commandNode);
+  $: argInfoArray = getArgumentInfo(commandNode?.getChild('Args') ?? null, commandDef?.arguments);
+  $: editorArgInfoArray = argInfoArray.filter(argInfo => !!argInfo.node);
+  $: missingArgDefArray = getMissingArgDefs(argInfoArray);
+  $: timeTagNode = getTimeTagInfo(node);
+
+  function getTimeTagInfo(commandNode: SyntaxNode | null) {
+    const node = commandNode?.getChild('TimeTag');
+    return (
+      node && {
+        node,
+        text: editorSequenceView.state.sliceDoc(node.from, node.to) ?? '',
+      }
+    );
+  }
+
+  function getArgumentInfo(
+    args: SyntaxNode | null,
+    argumentDefs: FswCommandArgument[] | undefined,
+    parentArgDef?: FswCommandArgumentRepeat,
+  ) {
+    const argArray: ArgTextDef[] = [];
+    let node = args?.firstChild;
+
+    // loop through nodes in editor and pair with definitions
+    while (node) {
+      // TODO - Consider early out on grammar error as higher chance of argument mismatch
+      // skip error tokens in grammar and try to give best guess at what argument we're on
+      if (node.name !== TOKEN_ERROR) {
+        const argDef =
+          argumentDefs &&
+          argumentDefs[
+            parentArgDef?.repeat?.arguments.length !== undefined
+              ? argArray.length % parentArgDef?.repeat?.arguments.length
+              : argArray.length
+          ];
+        let children: ArgTextDef[] | undefined = undefined;
+        if (!!argDef && isFswCommandArgumentRepeat(argDef)) {
+          children = getArgumentInfo(node, argDef.repeat?.arguments, argDef);
+        }
+        argArray.push({
+          argDef,
+          children,
+          node,
+          parentArgDef,
+          text: editorSequenceView.state.sliceDoc(node.from, node.to),
+        });
+      }
+      node = node.nextSibling;
+    }
+
+    // add entries for defined arguments missing from editor
+    if (argumentDefs) {
+      if (!parentArgDef) {
+        argArray.push(...argumentDefs.slice(argArray.length).map(argDef => ({ argDef })));
+      } else {
+        const repeatArgs = parentArgDef?.repeat?.arguments;
+        if (repeatArgs) {
+          if (argArray.length % repeatArgs.length !== 0) {
+            argArray.push(...argumentDefs.slice(argArray.length % repeatArgs.length).map(argDef => ({ argDef })));
+          }
+        }
+      }
+    }
+
+    return argArray;
+  }
+
+  function getCommandDef(
+    commandDictionary: CommandDictionary | null,
+    state: EditorState | undefined,
+    commandNode: SyntaxNode | null,
+  ) {
+    if (!commandDictionary || !state || !node) {
+      return null;
+    }
+
+    const stemNode = commandNode?.getChild('Stem');
+
+    if (stemNode) {
+      const stemName = state.sliceDoc(stemNode.from, stemNode.to);
+      return commandDictionary.fswCommandMap[stemName];
+    }
+
+    return null;
+  }
+
+  function setInEditor(token: SyntaxNode, val: string) {
+    if (editorSequenceView) {
+      const currentVal = editorSequenceView.state.sliceDoc(token.node.from, token.node.to);
+      if (currentVal !== val) {
+        const transaction = editorSequenceView.state.update({
+          changes: { from: token.node.from, insert: val, to: token.node.to },
+          userEvent: 'formView',
+        });
+        editorSequenceView.dispatch(transaction);
+      }
+    }
+  }
+
+  function addDefaultArgs(commandNode: SyntaxNode, argDefs: FswCommandArgument[]) {
+    let insertPosition: undefined | number = undefined;
+    if (editorSequenceView) {
+      const str = ' ' + argDefs.map(argDef => fswCommandArgDefault(argDef, commandDictionary.enumMap)).join(' ');
+      const argsNode = commandNode.getChild('Args');
+      const stemNode = commandNode.getChild('Stem');
+      if (stemNode) {
+        insertPosition = argsNode?.to ?? stemNode.to;
+        if (insertPosition !== undefined) {
+          const stemAndMaybeArgs = editorSequenceView.state.sliceDoc(stemNode.from, insertPosition);
+          const numEndingSpaces = stemAndMaybeArgs.length - stemAndMaybeArgs.trimEnd().length;
+          let transaction = editorSequenceView.state.update({
+            changes: {
+              from: insertPosition - numEndingSpaces,
+              insert: str,
+              to: insertPosition,
+            },
+          });
+          editorSequenceView.dispatch(transaction);
+        }
+      } else if (commandNode.name === TOKEN_REPEAT_ARG) {
+        insertPosition = commandNode.to - 1;
+        if (insertPosition !== undefined) {
+          let transaction = editorSequenceView.state.update({
+            changes: { from: insertPosition, insert: str, to: insertPosition },
+          });
+          editorSequenceView.dispatch(transaction);
+        }
+      }
+    }
+  }
+
+  // When the type in the argument value is compatible with the argument definition,
+  // provide a more restrictive editor to keep argument valid. Otherwise fall back on a string editor.
+
+  // TODO
+  // display repeat args
+  // button to add repeat set
+  // add descriptive text
+  // better handling of unclosed strings
+
+  // {'integer_arg', 'float_arg', 'unsigned_arg', 'enum_arg', 'var_string_arg', 'repeat_arg'}
+  // {'unsigned_arg', 'enum_arg', 'var_string_arg', 'float_arg'}
+</script>
+
+<div class="select-command-detail">
+  {#if !!commandNode}
+    <div>Selected Command</div>
+    {#if !!commandDef}
+      {#if !!timeTagNode}
+        <div>Time Tag: {timeTagNode.text.trim()}</div>
+      {/if}
+      <div>{commandDef.stem}</div>
+      <hr />
+      <div class="select-command-argument-detail">
+        {#each editorArgInfoArray as argInfo}
+          <ArgEditor {argInfo} {commandDictionary} setInEditor={debounce(setInEditor, 250)} {addDefaultArgs} />
+        {/each}
+        {#if missingArgDefArray.length}
+          <AddMissingArgsButton
+            setInEditor={() => {
+              if (commandNode) {
+                addDefaultArgs(commandNode, missingArgDefArray);
+              }
+            }}
+          />
+        {/if}
+      </div>
+    {/if}
+  {/if}
+</div>
+
+<style>
+  .select-command-detail {
+    padding: 10px;
+    width: 100%;
+  }
+</style>
diff --git a/src/components/sequencing/form/string-editor.svelte b/src/components/sequencing/form/string-editor.svelte
new file mode 100644
index 0000000000..7a8485cf0b
--- /dev/null
+++ b/src/components/sequencing/form/string-editor.svelte
@@ -0,0 +1,38 @@
+<svelte:options immutable={true} />
+
+<script lang="ts">
+  import type { FswCommandArgumentVarString } from '@nasa-jpl/aerie-ampcs';
+  import { isQuoted, quoteEscape, unquoteUnescape } from './utils';
+
+  export let argDef: FswCommandArgumentVarString;
+  export let initVal: string;
+  export let setInEditor: (val: string) => void;
+
+  $: initHadQuotes = isQuoted(initVal);
+  $: value = unquoteUnescape(initVal);
+
+  $: {
+    if (initHadQuotes) {
+      // normal case
+      setInEditor(quoteEscape(value));
+    } else {
+      // can happen with unmatched quotes
+      setInEditor(value);
+    }
+  }
+</script>
+
+<div>
+  <input
+    class="st-input"
+    spellcheck="false"
+    bind:value
+    title={argDef.description}
+  />
+</div>
+
+<style>
+  input {
+    width: 90%;
+  }
+</style>
diff --git a/src/components/sequencing/form/utils.ts b/src/components/sequencing/form/utils.ts
new file mode 100644
index 0000000000..49caf590dd
--- /dev/null
+++ b/src/components/sequencing/form/utils.ts
@@ -0,0 +1,95 @@
+
+import type {
+  FswCommandArgument,
+  FswCommandArgumentEnum,
+  FswCommandArgumentFixedString,
+  FswCommandArgumentFloat,
+  FswCommandArgumentInteger,
+  FswCommandArgumentNumeric,
+  FswCommandArgumentRepeat,
+  FswCommandArgumentUnsigned,
+  FswCommandArgumentVarString,
+} from '@nasa-jpl/aerie-ampcs';
+import type { SyntaxNode } from '@lezer/common';
+
+export function isFswCommandArgumentEnum(arg: FswCommandArgument): arg is FswCommandArgumentEnum {
+  return arg.arg_type === 'enum';
+}
+
+export function isFswCommandArgumentInteger(arg: FswCommandArgument): arg is FswCommandArgumentInteger {
+  return arg.arg_type === 'integer';
+}
+
+export function isFswCommandArgumentFloat(arg: FswCommandArgument): arg is FswCommandArgumentFloat {
+  return arg.arg_type === 'float';
+}
+
+export function isFswCommandArgumentNumeric(arg: FswCommandArgument): arg is FswCommandArgumentNumeric {
+  return arg.arg_type === 'numeric';
+}
+
+export function isFswCommandArgumentUnsigned(arg: FswCommandArgument): arg is FswCommandArgumentUnsigned {
+  return arg.arg_type === 'unsigned';
+}
+
+export function isFswCommandArgumentRepeat(arg: FswCommandArgument): arg is FswCommandArgumentRepeat {
+  return arg.arg_type === 'repeat';
+}
+
+export function isFswCommandArgumentVarString(arg: FswCommandArgument): arg is FswCommandArgumentVarString {
+  return arg.arg_type === 'var_string';
+}
+
+export function isFswCommandArgumentFixedString(arg: FswCommandArgument): arg is FswCommandArgumentFixedString {
+  return arg.arg_type === 'fixed_string';
+}
+
+export function isNumberArg(arg: FswCommandArgument): arg is NumberArg {
+  return (
+    isFswCommandArgumentFloat(arg) ||
+    isFswCommandArgumentInteger(arg) ||
+    isFswCommandArgumentNumeric(arg) ||
+    isFswCommandArgumentUnsigned(arg)
+  );
+}
+
+export function isStringArg(arg: FswCommandArgument): arg is StringArg {
+  return isFswCommandArgumentVarString(arg) || isFswCommandArgumentFixedString(arg);
+}
+
+export type StringArg = FswCommandArgumentVarString | FswCommandArgumentFixedString;
+
+export type NumberArg =
+  | FswCommandArgumentFloat
+  | FswCommandArgumentInteger
+  | FswCommandArgumentNumeric
+  | FswCommandArgumentUnsigned;
+
+export type ArgTextDef = {
+  node?: SyntaxNode;
+  text?: string;
+  argDef?: FswCommandArgument;
+  children?: ArgTextDef[];
+  parentArgDef?: FswCommandArgumentRepeat;
+};
+
+export function getMissingArgDefs(argInfoArray: ArgTextDef[]) {
+  return argInfoArray
+    .filter((argInfo): argInfo is { argDef: FswCommandArgument } => !argInfo.node && !!argInfo.argDef)
+    .map(argInfo => argInfo.argDef);
+}
+
+export function isQuoted(s: string) {
+  return s.startsWith('"') && s.endsWith('"');
+}
+
+export function unquoteUnescape(s: string) {
+  if (isQuoted(s)) {
+    return s.slice(1, -1).replaceAll('\\"', '"');
+  }
+  return s;
+}
+
+export function quoteEscape(s: string) {
+  return `"${s.replaceAll('"', '\\"')}"`;
+}
diff --git a/src/stores/sequencing.ts b/src/stores/sequencing.ts
index 7e87fb7897..9b962131e6 100644
--- a/src/stores/sequencing.ts
+++ b/src/stores/sequencing.ts
@@ -16,3 +16,5 @@ export const userSequencesColumns: Writable<string> = writable('1.5fr 3px 1fr');
 export const userSequenceFormColumns: Writable<string> = writable('1fr 3px 2fr');
 
 export const userSequencesRows: Writable<string> = writable('1fr 3px 1fr');
+
+export const userSequenceEditorColumns: Writable<string> = writable('3fr 3px 1fr');
diff --git a/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts b/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
index b420079c30..77eff640d7 100644
--- a/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
+++ b/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
@@ -1 +1,3 @@
+export const TOKEN_COMMAND = 'Command';
 export const TOKEN_REPEAT_ARG = 'RepeatArg';
+export const TOKEN_ERROR = '⚠';
diff --git a/src/utilities/new-sequence-editor/tree-utils.ts b/src/utilities/new-sequence-editor/tree-utils.ts
index 2fab3c398c..0e9864763f 100644
--- a/src/utilities/new-sequence-editor/tree-utils.ts
+++ b/src/utilities/new-sequence-editor/tree-utils.ts
@@ -45,3 +45,11 @@ export function getFromAndTo(nodes: (SyntaxNode | null)[]): { from: number; to:
     { from: Number.MAX_VALUE, to: Number.MIN_VALUE },
   );
 }
+
+export function getAncestorNode(node: SyntaxNode | null, name: string) {
+  let commandNode: SyntaxNode | null = node;
+  while (commandNode && commandNode.name !== name) {
+    commandNode = commandNode.parent;
+  }
+  return commandNode;
+}

From b78223b1e4b7c4df98025e4a6be2b2698e666352 Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sat, 6 Apr 2024 10:46:56 -0700
Subject: [PATCH 2/8] filter codemirror edit dispatching

---
 .../sequencing/form/selected-command.svelte   | 33 ++++++++++++-------
 .../sequencing/form/string-editor.svelte      | 20 +++++------
 2 files changed, 30 insertions(+), 23 deletions(-)

diff --git a/src/components/sequencing/form/selected-command.svelte b/src/components/sequencing/form/selected-command.svelte
index e3f5dacc1e..f5e685a836 100644
--- a/src/components/sequencing/form/selected-command.svelte
+++ b/src/components/sequencing/form/selected-command.svelte
@@ -21,6 +21,8 @@
   export let commandDictionary: CommandDictionary;
   export let node: SyntaxNode | null;
 
+  const ID_COMMAND_DETAIL_PANE = 'ID_COMMAND_DETAIL_PANE';
+
   $: commandNode = getAncestorNode(node, TOKEN_COMMAND);
   $: commandDef = getCommandDef(commandDictionary, editorSequenceView.state, commandNode);
   $: argInfoArray = getArgumentInfo(commandNode?.getChild('Args') ?? null, commandDef?.arguments);
@@ -110,18 +112,30 @@
   }
 
   function setInEditor(token: SyntaxNode, val: string) {
-    if (editorSequenceView) {
+    // checking that we are not in the code mirror editor
+    // this breaks cycle of form edits triggering document updates and vice versa
+    if (editorSequenceView && hasAncestorWithId(document.activeElement, ID_COMMAND_DETAIL_PANE)) {
       const currentVal = editorSequenceView.state.sliceDoc(token.node.from, token.node.to);
       if (currentVal !== val) {
-        const transaction = editorSequenceView.state.update({
-          changes: { from: token.node.from, insert: val, to: token.node.to },
-          userEvent: 'formView',
-        });
-        editorSequenceView.dispatch(transaction);
+        editorSequenceView.dispatch(
+          editorSequenceView.state.update({
+            changes: { from: token.node.from, insert: val, to: token.node.to },
+            userEvent: 'formView',
+          }),
+        );
       }
     }
   }
 
+  function hasAncestorWithId(element: Element | null, id: string) {
+    if (element === null) {
+      return false;
+    } else if (element.id === id) {
+      return true;
+    }
+    return hasAncestorWithId(element.parentElement, id);
+  }
+
   function addDefaultArgs(commandNode: SyntaxNode, argDefs: FswCommandArgument[]) {
     let insertPosition: undefined | number = undefined;
     if (editorSequenceView) {
@@ -158,16 +172,13 @@
   // provide a more restrictive editor to keep argument valid. Otherwise fall back on a string editor.
 
   // TODO
-  // display repeat args
-  // button to add repeat set
-  // add descriptive text
   // better handling of unclosed strings
 
   // {'integer_arg', 'float_arg', 'unsigned_arg', 'enum_arg', 'var_string_arg', 'repeat_arg'}
   // {'unsigned_arg', 'enum_arg', 'var_string_arg', 'float_arg'}
 </script>
 
-<div class="select-command-detail">
+<div class="select-command-detail" id={ID_COMMAND_DETAIL_PANE}>
   {#if !!commandNode}
     <div>Selected Command</div>
     {#if !!commandDef}
@@ -178,7 +189,7 @@
       <hr />
       <div class="select-command-argument-detail">
         {#each editorArgInfoArray as argInfo}
-          <ArgEditor {argInfo} {commandDictionary} setInEditor={debounce(setInEditor, 250)} {addDefaultArgs} />
+          <ArgEditor {argInfo} {commandDictionary} setInEditor={debounce(setInEditor, 2500)} {addDefaultArgs} />
         {/each}
         {#if missingArgDefArray.length}
           <AddMissingArgsButton
diff --git a/src/components/sequencing/form/string-editor.svelte b/src/components/sequencing/form/string-editor.svelte
index 7a8485cf0b..aebc9481f5 100644
--- a/src/components/sequencing/form/string-editor.svelte
+++ b/src/components/sequencing/form/string-editor.svelte
@@ -12,23 +12,19 @@
   $: value = unquoteUnescape(initVal);
 
   $: {
-    if (initHadQuotes) {
-      // normal case
-      setInEditor(quoteEscape(value));
-    } else {
-      // can happen with unmatched quotes
-      setInEditor(value);
+    if (value !== unquoteUnescape(initVal)) {
+      // normal case is string tokens contain quotes
+      if (initHadQuotes) {
+        setInEditor(quoteEscape(value));
+      } else {
+        setInEditor(value);
+      }
     }
   }
 </script>
 
 <div>
-  <input
-    class="st-input"
-    spellcheck="false"
-    bind:value
-    title={argDef.description}
-  />
+  <input class="st-input" spellcheck="false" bind:value title={argDef.description} />
 </div>
 
 <style>

From 4feb5fa78becbd806f227967b7f18c6c174fc054 Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sat, 6 Apr 2024 15:11:32 -0700
Subject: [PATCH 3/8] remove redundant quotes on metadata and model values

---
 .../new-sequence-editor/from-seq-json.ts      | 36 ++++++++++++++++++-
 .../new-sequence-editor/to-seq-json.ts        | 35 ++++++++++++------
 2 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/src/utilities/new-sequence-editor/from-seq-json.ts b/src/utilities/new-sequence-editor/from-seq-json.ts
index 18f2e0bc4c..1b854feead 100644
--- a/src/utilities/new-sequence-editor/from-seq-json.ts
+++ b/src/utilities/new-sequence-editor/from-seq-json.ts
@@ -2,6 +2,8 @@ import type {
   Args,
   BooleanArgument,
   HexArgument,
+  Metadata,
+  Model,
   NumberArgument,
   SeqJson,
   StringArgument,
@@ -9,6 +11,7 @@ import type {
   Time,
 } from '@nasa-jpl/seq-json-schema/types';
 import { isArray } from 'lodash-es';
+import { quoteEscape } from '../../components/sequencing/form/utils';
 import { logError } from './logger';
 
 /**
@@ -102,6 +105,35 @@ export function seqJsonArgsToSequence(args: Args): string {
   return argsStr;
 }
 
+export function seqJsonModelsToSequence(models: Model[]) {
+  // MODEL directives are one per line, the last new line is to start the next token
+  return (
+    models
+      .map(model => {
+        let formattedValue: Model['value'] = model.value;
+        if (typeof model.value === 'string') {
+          formattedValue = quoteEscape(model.value);
+        } else if (typeof model.value === 'boolean') {
+          formattedValue = model.value.toString().toUpperCase();
+        }
+        return `@MODEL ${quoteEscape(model.variable)} ${formattedValue} ${quoteEscape(model.offset)}`;
+      })
+      .join('\n') + '\n'
+  );
+}
+
+export function seqJsonMetadataToSequence(metadata: Metadata) {
+  // METADATA directives are one per line, the last new line is to start the next token
+  return (
+    Object.entries(metadata)
+      .map(
+        ([key, value]: [key: string, value: unknown]) =>
+          `@METADATA ${quoteEscape(key)} ${quoteEscape(value as string)}`,
+      )
+      .join('\n') + '\n'
+  );
+}
+
 /**
  * Transforms a sequence JSON to a sequence string.
  */
@@ -118,7 +150,9 @@ export function seqJsonToSequence(seqJson: SeqJson | null): string {
         if (step.type === 'command') {
           const time = seqJsonTimeToSequence(step.time);
           const args = seqJsonArgsToSequence(step.args);
-          sequence.push(`${time} ${step.stem}${args}\n`);
+          const metadata = step.metadata ? seqJsonMetadataToSequence(step.metadata) : '';
+          const models = step.models ? seqJsonModelsToSequence(step.models) : '';
+          sequence.push(`${time} ${step.stem}${args}\n${models}${metadata}`);
         }
       }
     }
diff --git a/src/utilities/new-sequence-editor/to-seq-json.ts b/src/utilities/new-sequence-editor/to-seq-json.ts
index 9eff829530..f06a376822 100644
--- a/src/utilities/new-sequence-editor/to-seq-json.ts
+++ b/src/utilities/new-sequence-editor/to-seq-json.ts
@@ -40,7 +40,7 @@ export function sequenceToSeqJson(node: Tree, text: string, commandDictionary: C
   variableList = [];
 
   seqJson.id = parseId(baseNode, text);
-  seqJson.metadata = { ...parseLGO(baseNode), ...parseMetatdata(baseNode, text) } ?? {};
+  seqJson.metadata = { ...parseLGO(baseNode), ...parseMetadata(baseNode, text) } ?? {};
   seqJson.locals = parseVariables(baseNode, text, 'LocalDeclaration') ?? undefined;
   seqJson.parameters = parseVariables(baseNode, text, 'ParameterDeclaration') ?? undefined;
   seqJson.steps =
@@ -369,10 +369,25 @@ function parseModel(node: SyntaxNode, text: string): Model[] | undefined {
     const variable = variableNode
       ? (removeQuotes(text.slice(variableNode.from, variableNode.to)) as string)
       : 'UNKNOWN';
-    const value = valueNode ? removeQuotes(text.slice(valueNode.from, valueNode.to)) : 0;
+
+    // Value can be string, number or boolean
+    let value: Model['value'] = 0;
+    if (valueNode) {
+      const valueChild = valueNode.firstChild;
+      if (valueChild) {
+        const valueText = text.slice(valueChild.from, valueChild.to);
+        if (valueChild.name === 'String') {
+          value = removeQuotes(valueText);
+        } else if (valueChild.name === 'Boolean') {
+          value = !/^FALSE$/i.test(valueText);
+        } else if (valueChild.name === 'Number') {
+          value = Number(valueText);
+        }
+      }
+    }
     const offset = offsetNode ? (removeQuotes(text.slice(offsetNode.from, offsetNode.to)) as string) : 'UNKNOWN';
 
-    models.push({ offset, value, variable});
+    models.push({ offset, value, variable });
   }
 
   return models;
@@ -389,7 +404,7 @@ function parseDescription(node: SyntaxNode, text: string): string | undefined {
 
 function removeQuotes(text: string | number | boolean): string | number | boolean {
   if (typeof text === 'string') {
-    return text.replace(/^"|"$/g, '');
+    return text.replace(/^"|"$/g, '').replaceAll('\\"', '"');
   }
   return text;
 }
@@ -408,7 +423,7 @@ export function parseCommand(
   const args = argsNode ? parseArgs(argsNode, text, commandDictionary, stem) : [];
 
   const description = parseDescription(commandNode, text);
-  const metadata: Metadata | undefined = parseMetatdata(commandNode, text);
+  const metadata: Metadata | undefined = parseMetadata(commandNode, text);
   const models: Model[] | undefined = parseModel(commandNode, text);
 
   return {
@@ -434,7 +449,7 @@ export function parseImmediateCommand(
   const args = argsNode ? parseArgs(argsNode, text, commandDictionary, stem) : [];
 
   const description = parseDescription(commandNode, text);
-  const metadata: Metadata | undefined = parseMetatdata(commandNode, text);
+  const metadata: Metadata | undefined = parseMetadata(commandNode, text);
 
   return {
     args,
@@ -448,7 +463,7 @@ export function parseHardwareCommand(commandNode: SyntaxNode, text: string): Har
   const stemNode = commandNode.getChild('Stem');
   const stem = stemNode ? text.slice(stemNode.from, stemNode.to) : 'UNKNOWN';
   const description = parseDescription(commandNode, text);
-  const metadata: Metadata | undefined = parseMetatdata(commandNode, text);
+  const metadata: Metadata | undefined = parseMetadata(commandNode, text);
 
   return {
     stem,
@@ -472,7 +487,7 @@ export function parseId(node: SyntaxNode, text: string): string {
   return id;
 }
 
-export function parseMetatdata(node: SyntaxNode, text: string): Metadata | undefined {
+function parseMetadata(node: SyntaxNode, text: string): Metadata | undefined {
   const metadataNode = node.getChild('Metadata');
   if (!metadataNode) {
     return undefined;
@@ -492,8 +507,8 @@ export function parseMetatdata(node: SyntaxNode, text: string): Metadata | undef
       return; // Skip this entry if either the key or value is missing
     }
 
-    const keyText = text.slice(keyNode.from, keyNode.to);
-    const valueText = text.slice(valueNode.from, valueNode.to);
+    const keyText = removeQuotes(text.slice(keyNode.from, keyNode.to)) as string;
+    const valueText = removeQuotes(text.slice(valueNode.from, valueNode.to));
 
     obj[keyText] = valueText;
   });

From 92cb940122f54378d6bb7ff23fe9e6f7bc2e49ea Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sat, 6 Apr 2024 15:41:41 -0700
Subject: [PATCH 4/8] leave whitespace when addining missing args, fix for
 missing time tag, warning cleanup

---
 src/components/sequencing/form/selected-command.svelte | 9 +++------
 src/utilities/new-sequence-editor/to-seq-json.ts       | 2 +-
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/components/sequencing/form/selected-command.svelte b/src/components/sequencing/form/selected-command.svelte
index f5e685a836..80f10d8453 100644
--- a/src/components/sequencing/form/selected-command.svelte
+++ b/src/components/sequencing/form/selected-command.svelte
@@ -28,7 +28,7 @@
   $: argInfoArray = getArgumentInfo(commandNode?.getChild('Args') ?? null, commandDef?.arguments);
   $: editorArgInfoArray = argInfoArray.filter(argInfo => !!argInfo.node);
   $: missingArgDefArray = getMissingArgDefs(argInfoArray);
-  $: timeTagNode = getTimeTagInfo(node);
+  $: timeTagNode = getTimeTagInfo(commandNode);
 
   function getTimeTagInfo(commandNode: SyntaxNode | null) {
     const node = commandNode?.getChild('TimeTag');
@@ -145,13 +145,10 @@
       if (stemNode) {
         insertPosition = argsNode?.to ?? stemNode.to;
         if (insertPosition !== undefined) {
-          const stemAndMaybeArgs = editorSequenceView.state.sliceDoc(stemNode.from, insertPosition);
-          const numEndingSpaces = stemAndMaybeArgs.length - stemAndMaybeArgs.trimEnd().length;
           let transaction = editorSequenceView.state.update({
             changes: {
-              from: insertPosition - numEndingSpaces,
+              from: insertPosition,
               insert: str,
-              to: insertPosition,
             },
           });
           editorSequenceView.dispatch(transaction);
@@ -160,7 +157,7 @@
         insertPosition = commandNode.to - 1;
         if (insertPosition !== undefined) {
           let transaction = editorSequenceView.state.update({
-            changes: { from: insertPosition, insert: str, to: insertPosition },
+            changes: { from: insertPosition, insert: str },
           });
           editorSequenceView.dispatch(transaction);
         }
diff --git a/src/utilities/new-sequence-editor/to-seq-json.ts b/src/utilities/new-sequence-editor/to-seq-json.ts
index f06a376822..ff79febe32 100644
--- a/src/utilities/new-sequence-editor/to-seq-json.ts
+++ b/src/utilities/new-sequence-editor/to-seq-json.ts
@@ -40,7 +40,7 @@ export function sequenceToSeqJson(node: Tree, text: string, commandDictionary: C
   variableList = [];
 
   seqJson.id = parseId(baseNode, text);
-  seqJson.metadata = { ...parseLGO(baseNode), ...parseMetadata(baseNode, text) } ?? {};
+  seqJson.metadata = { ...parseLGO(baseNode), ...parseMetadata(baseNode, text) };
   seqJson.locals = parseVariables(baseNode, text, 'LocalDeclaration') ?? undefined;
   seqJson.parameters = parseVariables(baseNode, text, 'ParameterDeclaration') ?? undefined;
   seqJson.steps =

From c2af379ed91d1f53aed57b577a58198fabc8cae4 Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sat, 6 Apr 2024 17:42:51 -0700
Subject: [PATCH 5/8] demonstration of quick fix actions on arg counts (#1214)

---
 .../sequencing/form/selected-command.svelte   | 48 ++++------------
 src/components/sequencing/form/utils.ts       | 40 +++++++++++--
 .../new-sequence-editor/sequence-linter.ts    | 57 ++++++++++++++-----
 3 files changed, 89 insertions(+), 56 deletions(-)

diff --git a/src/components/sequencing/form/selected-command.svelte b/src/components/sequencing/form/selected-command.svelte
index 80f10d8453..0a82a9ac58 100644
--- a/src/components/sequencing/form/selected-command.svelte
+++ b/src/components/sequencing/form/selected-command.svelte
@@ -6,16 +6,11 @@
   import type { CommandDictionary, FswCommandArgument, FswCommandArgumentRepeat } from '@nasa-jpl/aerie-ampcs';
   import type { EditorView } from 'codemirror';
   import { debounce } from 'lodash-es';
-  import { fswCommandArgDefault } from '../../../utilities/new-sequence-editor/command-dictionary';
-  import {
-    TOKEN_COMMAND,
-    TOKEN_ERROR,
-    TOKEN_REPEAT_ARG,
-  } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
+  import { TOKEN_COMMAND, TOKEN_ERROR } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
   import { getAncestorNode } from '../../../utilities/new-sequence-editor/tree-utils';
   import AddMissingArgsButton from './add-missing-args-button.svelte';
   import ArgEditor from './arg-editor.svelte';
-  import { getMissingArgDefs, isFswCommandArgumentRepeat, type ArgTextDef } from './utils';
+  import { addDefaultArgs, getMissingArgDefs, isFswCommandArgumentRepeat, type ArgTextDef } from './utils';
 
   export let editorSequenceView: EditorView;
   export let commandDictionary: CommandDictionary;
@@ -136,35 +131,6 @@
     return hasAncestorWithId(element.parentElement, id);
   }
 
-  function addDefaultArgs(commandNode: SyntaxNode, argDefs: FswCommandArgument[]) {
-    let insertPosition: undefined | number = undefined;
-    if (editorSequenceView) {
-      const str = ' ' + argDefs.map(argDef => fswCommandArgDefault(argDef, commandDictionary.enumMap)).join(' ');
-      const argsNode = commandNode.getChild('Args');
-      const stemNode = commandNode.getChild('Stem');
-      if (stemNode) {
-        insertPosition = argsNode?.to ?? stemNode.to;
-        if (insertPosition !== undefined) {
-          let transaction = editorSequenceView.state.update({
-            changes: {
-              from: insertPosition,
-              insert: str,
-            },
-          });
-          editorSequenceView.dispatch(transaction);
-        }
-      } else if (commandNode.name === TOKEN_REPEAT_ARG) {
-        insertPosition = commandNode.to - 1;
-        if (insertPosition !== undefined) {
-          let transaction = editorSequenceView.state.update({
-            changes: { from: insertPosition, insert: str },
-          });
-          editorSequenceView.dispatch(transaction);
-        }
-      }
-    }
-  }
-
   // When the type in the argument value is compatible with the argument definition,
   // provide a more restrictive editor to keep argument valid. Otherwise fall back on a string editor.
 
@@ -186,13 +152,19 @@
       <hr />
       <div class="select-command-argument-detail">
         {#each editorArgInfoArray as argInfo}
-          <ArgEditor {argInfo} {commandDictionary} setInEditor={debounce(setInEditor, 2500)} {addDefaultArgs} />
+          <ArgEditor
+            {argInfo}
+            {commandDictionary}
+            setInEditor={debounce(setInEditor, 2500)}
+            addDefaultArgs={(commandNode, missingArgDefArray) =>
+              addDefaultArgs(commandDictionary, editorSequenceView, commandNode, missingArgDefArray)}
+          />
         {/each}
         {#if missingArgDefArray.length}
           <AddMissingArgsButton
             setInEditor={() => {
               if (commandNode) {
-                addDefaultArgs(commandNode, missingArgDefArray);
+                addDefaultArgs(commandDictionary, editorSequenceView, commandNode, missingArgDefArray);
               }
             }}
           />
diff --git a/src/components/sequencing/form/utils.ts b/src/components/sequencing/form/utils.ts
index 49caf590dd..debda51e19 100644
--- a/src/components/sequencing/form/utils.ts
+++ b/src/components/sequencing/form/utils.ts
@@ -1,5 +1,6 @@
-
+import type { SyntaxNode } from '@lezer/common';
 import type {
+  CommandDictionary,
   FswCommandArgument,
   FswCommandArgumentEnum,
   FswCommandArgumentFixedString,
@@ -10,7 +11,9 @@ import type {
   FswCommandArgumentUnsigned,
   FswCommandArgumentVarString,
 } from '@nasa-jpl/aerie-ampcs';
-import type { SyntaxNode } from '@lezer/common';
+import type { EditorView } from 'codemirror';
+import { fswCommandArgDefault } from '../../../utilities/new-sequence-editor/command-dictionary';
+import { TOKEN_REPEAT_ARG } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
 
 export function isFswCommandArgumentEnum(arg: FswCommandArgument): arg is FswCommandArgumentEnum {
   return arg.arg_type === 'enum';
@@ -66,13 +69,42 @@ export type NumberArg =
   | FswCommandArgumentUnsigned;
 
 export type ArgTextDef = {
-  node?: SyntaxNode;
-  text?: string;
   argDef?: FswCommandArgument;
   children?: ArgTextDef[];
+  node?: SyntaxNode;
   parentArgDef?: FswCommandArgumentRepeat;
+  text?: string;
 };
 
+export function addDefaultArgs(
+  commandDictionary: CommandDictionary,
+  view: EditorView,
+  commandNode: SyntaxNode,
+  argDefs: FswCommandArgument[],
+) {
+  let insertPosition: undefined | number = undefined;
+  const str = ' ' + argDefs.map(argDef => fswCommandArgDefault(argDef, commandDictionary.enumMap)).join(' ');
+  const argsNode = commandNode.getChild('Args');
+  const stemNode = commandNode.getChild('Stem');
+  if (stemNode) {
+    insertPosition = argsNode?.to ?? stemNode.to;
+    if (insertPosition !== undefined) {
+      const transaction = view.state.update({
+        changes: { from: insertPosition, insert: str },
+      });
+      view.dispatch(transaction);
+    }
+  } else if (commandNode.name === TOKEN_REPEAT_ARG) {
+    insertPosition = commandNode.to - 1;
+    if (insertPosition !== undefined) {
+      const transaction = view.state.update({
+        changes: { from: insertPosition, insert: str },
+      });
+      view.dispatch(transaction);
+    }
+  }
+}
+
 export function getMissingArgDefs(argInfoArray: ArgTextDef[]) {
   return argInfoArray
     .filter((argInfo): argInfo is { argDef: FswCommandArgument } => !argInfo.node && !!argInfo.argDef)
diff --git a/src/utilities/new-sequence-editor/sequence-linter.ts b/src/utilities/new-sequence-editor/sequence-linter.ts
index 909cd4e023..5dd2f38064 100644
--- a/src/utilities/new-sequence-editor/sequence-linter.ts
+++ b/src/utilities/new-sequence-editor/sequence-linter.ts
@@ -3,6 +3,8 @@ import { linter, type Diagnostic } from '@codemirror/lint';
 import type { Extension } from '@codemirror/state';
 import type { SyntaxNode } from '@lezer/common';
 import type { CommandDictionary, EnumMap, FswCommand, FswCommandArgument, HwCommand } from '@nasa-jpl/aerie-ampcs';
+import { addDefaultArgs } from '../../components/sequencing/form/utils';
+
 import { TOKEN_REPEAT_ARG } from './sequencer-grammar-constants';
 import {
   ABSOLUTE_TIME,
@@ -89,17 +91,17 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     ) {
       if (lgo) {
         diagnostics.push({
-            from,
-            message: `Directive 'LOAD_AND_GO' cannot be used with 'Immediate Commands' or 'Hardware Commands'.`,
-            severity: 'error',
-            to,
-        });
-      }
-      diagnostics.push({
           from,
-          message: 'Cannot mix different command types in one Sequence.',
+          message: `Directive 'LOAD_AND_GO' cannot be used with 'Immediate Commands' or 'Hardware Commands'.`,
           severity: 'error',
           to,
+        });
+      }
+      diagnostics.push({
+        from,
+        message: 'Cannot mix different command types in one Sequence.',
+        severity: 'error',
+        to,
       });
     }
     return diagnostics;
@@ -436,11 +438,11 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
 
     const stemText = text.slice(stem.from, stem.to);
 
-    const dictionaryCommand : FswCommand | HwCommand | null = fswCommandMap[stemText]
+    const dictionaryCommand: FswCommand | HwCommand | null = fswCommandMap[stemText]
       ? fswCommandMap[stemText]
       : hwCommandMap[stemText]
-      ? hwCommandMap[stemText]
-      : null;
+        ? hwCommandMap[stemText]
+        : null;
 
     if (!dictionaryCommand) {
       return {
@@ -511,12 +513,39 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         return diagnostics;
       }
 
-      if (argNode.length !== dictArgs.length) {
+      if (argNode.length > dictArgs.length) {
+        const extraArgs = argNode.slice(dictArgs.length);
+        const { from, to } = getFromAndTo(extraArgs);
+        diagnostics.push({
+          actions: [
+            {
+              apply(view, from, to) {
+                view.dispatch({ changes: { from, to } });
+              },
+              name: `Remove ${extraArgs.length} extra argument${extraArgs.length > 1 ? 's' : ''}`,
+            },
+          ],
+          from,
+          message: `Extra arguments, definition has ${dictArgs.length}, but ${argNode.length} are present`,
+          severity: 'error',
+          to,
+        });
+        return diagnostics;
+      } else if (argNode.length < dictArgs.length) {
         const { from, to } = getFromAndTo(argNode);
         diagnostics.push({
-          actions: [],
+          actions: [
+            {
+              apply(view, _from, _to) {
+                if (commandDictionary) {
+                  addDefaultArgs(commandDictionary, view, command, dictArgs.slice(argNode.length));
+                }
+              },
+              name: 'Add default missing arguments',
+            },
+          ],
           from,
-          message: `Should only have ${dictArgs.length} arguments`,
+          message: `Missing arguments, definition has ${argNode.length}, but ${dictArgs.length} are present`,
           severity: 'error',
           to,
         });

From 8d26a37ac29b1180cd0715ee246a1da757e653bb Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sat, 6 Apr 2024 23:08:41 -0700
Subject: [PATCH 6/8] made grammar more flexible with directive ordering and
 misspelling, added some suggested fixes

---
 codemirror-lang-sequence/package.json         |  2 +-
 codemirror-lang-sequence/src/index.ts         |  1 +
 codemirror-lang-sequence/src/sequence.grammar | 16 +++--
 .../test/cases/parse_tree.txt                 | 16 +++++
 codemirror-lang-sequence/test/token.js        |  7 ++-
 package-lock.json                             |  2 +-
 package.json                                  |  1 +
 .../new-sequence-editor/sequence-linter.ts    | 61 +++++++++++++++++--
 8 files changed, 90 insertions(+), 16 deletions(-)

diff --git a/codemirror-lang-sequence/package.json b/codemirror-lang-sequence/package.json
index a8ed18267a..9a49d3a3ea 100644
--- a/codemirror-lang-sequence/package.json
+++ b/codemirror-lang-sequence/package.json
@@ -15,7 +15,7 @@
     "build": "npm run clean && rollup -c",
     "clean": "rm -rf dist",
     "postinstall": "npm run build",
-    "test": "npm run build && mocha test/test.js"
+    "test": "npm run build && mocha test/*.js"
   },
   "dependencies": {
     "@codemirror/autocomplete": "^6.15.0",
diff --git a/codemirror-lang-sequence/src/index.ts b/codemirror-lang-sequence/src/index.ts
index 9a7c2f6c0d..55b63d1ac6 100644
--- a/codemirror-lang-sequence/src/index.ts
+++ b/codemirror-lang-sequence/src/index.ts
@@ -26,6 +26,7 @@ export const SeqLanguage = LRLanguage.define({
       }),
       styleTags({
         Boolean: t.bool,
+        GenericDirective: t.namespace,
         Global: t.namespace,
         HardwareCommands: t.namespace,
         IdDeclaration: t.namespace,
diff --git a/codemirror-lang-sequence/src/sequence.grammar b/codemirror-lang-sequence/src/sequence.grammar
index 98937e21ff..18bfef15ef 100644
--- a/codemirror-lang-sequence/src/sequence.grammar
+++ b/codemirror-lang-sequence/src/sequence.grammar
@@ -1,11 +1,9 @@
 @top Sequence {
   (newLine | whiteSpace)?
-  commentLine* ~maybeComments
-  IdDeclaration?
-  commentLine* ~maybeComments
-  ParameterDeclaration?
-  commentLine* ~maybeComments
-  LocalDeclaration?
+  (
+    commentLine* ~maybeComments
+    (IdDeclaration | ParameterDeclaration | LocalDeclaration | GenericDirective)
+  )*
   commentLine* ~maybeComments
   Metadata?
   Commands?
@@ -22,6 +20,10 @@
   stemStart @cut
 }
 
+GenericDirective {
+  genericDirective (whiteSpace String)* newLine
+}
+
 IdDeclaration {
   idDirective whiteSpace String newLine
 }
@@ -148,6 +150,7 @@ Stem { !stemStart identifier }
   parameterDirective { "@INPUT_PARAMS" }
   metadataDirective { "@METADATA" }
   modelDirective { "@MODEL" }
+  genericDirective { "@"identifier }
 
   @precedence {
     newLine, whiteSpace
@@ -164,6 +167,7 @@ Stem { !stemStart identifier }
     localsDirective,
     parameterDirective,
     LoadAndGoDirective,
+    genericDirective,
     identifier
   }
 }
diff --git a/codemirror-lang-sequence/test/cases/parse_tree.txt b/codemirror-lang-sequence/test/cases/parse_tree.txt
index 7e0f0f336b..5e71462d9c 100644
--- a/codemirror-lang-sequence/test/cases/parse_tree.txt
+++ b/codemirror-lang-sequence/test/cases/parse_tree.txt
@@ -23,6 +23,22 @@ Sequence(
   )
 )
 
+# Generic directive
+
+@WRONG_LOAD_AND_GO
+
+C CMD_1
+
+==>
+
+Sequence(
+  GenericDirective,
+  Commands(
+    Command(TimeTag(TimeComplete),Stem,Args)
+  )
+)
+
+
 # Command with two string args
 
 FSW_CMD "hello" "world"
diff --git a/codemirror-lang-sequence/test/token.js b/codemirror-lang-sequence/test/token.js
index d505696cf1..970b5bb053 100644
--- a/codemirror-lang-sequence/test/token.js
+++ b/codemirror-lang-sequence/test/token.js
@@ -35,7 +35,7 @@ describe('error positions', () => {
       testname: 'bad number arg',
     },
     {
-      first_error: 20,
+      first_error: 24,
       input: `COM 12345
   COM "dsa"
   @UNKNOWN DIRECTIVE`,
@@ -58,7 +58,9 @@ describe('error positions', () => {
 describe('seqfiles', () => {
   const seqDir = path.dirname(fileURLToPath(import.meta.url)) + '/sequences';
   for (const file of readdirSync(seqDir)) {
-    if (!/\.txt$/.test(file)) {continue};
+    if (!/\.txt$/.test(file)) {
+      continue;
+    }
 
     const name = /^[^.]*/.exec(file)[0];
     it(name, () => {
@@ -91,7 +93,6 @@ CMD0
       return {
         from,
         to: from + nodeText.length,
-
       };
     };
     const expectedCommentLocations = {
diff --git a/package-lock.json b/package-lock.json
index 17851bc76e..44f0099abf 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -30,6 +30,7 @@
         "d3-selection": "^3.0.0",
         "d3-shape": "^3.2.0",
         "d3-time": "^3.1.0",
+        "fastest-levenshtein": "^1.0.16",
         "graphql-ws": "^5.14.0",
         "json-source-map": "^0.6.1",
         "jszip": "^3.10.1",
@@ -4133,7 +4134,6 @@
       "version": "1.0.16",
       "resolved": "https://registry.npmjs.org/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz",
       "integrity": "sha512-eRnCtTTtGZFpQCwhJiUOuxPQWRXVKYDn0b2PeHfXL6/Zi53SLAzAHfVhVWK2AryC/WH05kGfxhFIPvTF0SXQzg==",
-      "dev": true,
       "engines": {
         "node": ">= 4.9.1"
       }
diff --git a/package.json b/package.json
index 290f3e66bf..01e12f257c 100644
--- a/package.json
+++ b/package.json
@@ -58,6 +58,7 @@
     "d3-selection": "^3.0.0",
     "d3-shape": "^3.2.0",
     "d3-time": "^3.1.0",
+    "fastest-levenshtein": "^1.0.16",
     "graphql-ws": "^5.14.0",
     "json-source-map": "^0.6.1",
     "jszip": "^3.10.1",
diff --git a/src/utilities/new-sequence-editor/sequence-linter.ts b/src/utilities/new-sequence-editor/sequence-linter.ts
index 5dd2f38064..21ee94fd4d 100644
--- a/src/utilities/new-sequence-editor/sequence-linter.ts
+++ b/src/utilities/new-sequence-editor/sequence-linter.ts
@@ -3,6 +3,7 @@ import { linter, type Diagnostic } from '@codemirror/lint';
 import type { Extension } from '@codemirror/state';
 import type { SyntaxNode } from '@lezer/common';
 import type { CommandDictionary, EnumMap, FswCommand, FswCommandArgument, HwCommand } from '@nasa-jpl/aerie-ampcs';
+import { closest } from 'fastest-levenshtein';
 import { addDefaultArgs } from '../../components/sequencing/form/utils';
 
 import { TOKEN_REPEAT_ARG } from './sequencer-grammar-constants';
@@ -19,6 +20,17 @@ import { getChildrenNode, getDeepestNode, getFromAndTo } from './tree-utils';
 
 const ERROR = '⚠';
 
+const KNOWN_DIRECTIVES = [
+  'LOAD_AND_GO',
+  'ID',
+  'IMMEDIATE',
+  'HARDWARE',
+  'LOCALS',
+  'INPUT_PARAMS',
+  'MODEL',
+  'METADATA',
+].map(name => `@${name}`);
+
 export function getAllEnumSymbols(enumMap: EnumMap, enumName: string) {
   const enumSymbols = enumMap[enumName].values.map(({ symbol }) => symbol);
   const enumSymbolsDisplayStr = enumSymbols.join('  |  ');
@@ -40,6 +52,8 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     // Validate command type mixing
     diagnostics.push(...validateCommandTypeMixing(treeNode));
 
+    diagnostics.push(...validateCustomDirectives(treeNode, view.state.doc.toString()));
+
     diagnostics.push(
       ...commandLinter(treeNode.getChild('Commands')?.getChildren('Command') || [], view.state.doc.toString()),
     );
@@ -107,6 +121,30 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     return diagnostics;
   }
 
+  function validateCustomDirectives(node: SyntaxNode, text: string): Diagnostic[] {
+    const diagnostics: Diagnostic[] = [];
+    node.getChildren('GenericDirective').forEach(directiveNode => {
+      const { from, to } = getFromAndTo([directiveNode]);
+      const custom = text.slice(from, to).trim();
+      const guess = closest(custom, KNOWN_DIRECTIVES);
+      diagnostics.push({
+        actions: [
+          {
+            apply(view, from, to) {
+              view.dispatch({ changes: { from, insert: guess + '\n', to } });
+            },
+            name: `Change to ${guess}`,
+          },
+        ],
+        from,
+        message: `Unknown Directive ${custom}, did you mean ${guess}`,
+        severity: 'error',
+        to,
+      });
+    });
+    return diagnostics;
+  }
+
   /**
    * Function to generate diagnostics based on Commands section in the parse tree.
    *
@@ -434,7 +472,7 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     if (commandDictionary === null) {
       return null;
     }
-    const { fswCommandMap, hwCommandMap } = commandDictionary;
+    const { fswCommandMap, fswCommands, hwCommandMap, hwCommands } = commandDictionary;
 
     const stemText = text.slice(stem.from, stem.to);
 
@@ -445,10 +483,14 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         : null;
 
     if (!dictionaryCommand) {
+      const guess = closest(stemText.toUpperCase(), [
+        ...fswCommands.map(cmd => cmd.stem),
+        ...hwCommands.map(cmd => cmd.stem),
+      ]);
       return {
         actions: [],
         from: stem.from,
-        message: 'Command not found',
+        message: `Command '${stemText}' not found, '${guess}' is closest match in dictionary`,
         severity: 'error',
         to: stem.to,
       };
@@ -633,9 +675,18 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
               commandDictionary?.enumMap,
               dictArg.enum_name,
             );
-            if (!symbols.includes(argText.replace(/^"|"$/g, ''))) {
+            const unquotedArgText = argText.replace(/^"|"$/g, '');
+            if (!symbols.includes(unquotedArgText)) {
+              const guess = closest(unquotedArgText.toUpperCase(), symbols);
               diagnostics.push({
-                actions: [],
+                actions: [
+                  {
+                    apply(view, from, to) {
+                      view.dispatch({ changes: { from, insert: `"${guess}"`, to } });
+                    },
+                    name: `Change to ${guess}`,
+                  },
+                ],
                 from: argNode.from,
                 message: `Enum should be "${availableSymbols}"`,
                 severity: 'error',
@@ -649,7 +700,7 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
               actions: [],
               from: argNode.from,
               message: `Enum should be a "string"`,
-              severity: 'warning',
+              severity: 'error',
               to: argNode.to,
             });
           }

From 4ab35ab2772e805cae327106dfb56e3b1ba30545 Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sun, 7 Apr 2024 12:18:30 -0700
Subject: [PATCH 7/8] cleaned up some diagnostic actions

---
 codemirror-lang-sequence/src/sequence.grammar |  7 +-
 .../test/cases/errors.txt                     |  8 ++
 .../sequencing/CommandTooltip.svelte          |  2 +-
 .../new-sequence-editor/sequence-linter.ts    | 83 +++++++++----------
 4 files changed, 51 insertions(+), 49 deletions(-)

diff --git a/codemirror-lang-sequence/src/sequence.grammar b/codemirror-lang-sequence/src/sequence.grammar
index 18bfef15ef..7471a3210a 100644
--- a/codemirror-lang-sequence/src/sequence.grammar
+++ b/codemirror-lang-sequence/src/sequence.grammar
@@ -12,9 +12,8 @@
 }
 
 // Potential Improvements
-// flexibility - allow indentation of directives
 // maintainability - use @specialize on directives
-// extensibility - add generic Directive { "@"identifier }
+// expressiveness - add activate, load and ground syntax
 
 @precedence {
   stemStart @cut
@@ -152,9 +151,7 @@ Stem { !stemStart identifier }
   modelDirective { "@MODEL" }
   genericDirective { "@"identifier }
 
-  @precedence {
-    newLine, whiteSpace
-  }
+  @precedence { newLine, whiteSpace }
 
   @precedence{ TimeAbsolute, TimeRelative, TimeEpoch, TimeComplete, identifier }
 
diff --git a/codemirror-lang-sequence/test/cases/errors.txt b/codemirror-lang-sequence/test/cases/errors.txt
index 6b7e78d245..a09b086e94 100644
--- a/codemirror-lang-sequence/test/cases/errors.txt
+++ b/codemirror-lang-sequence/test/cases/errors.txt
@@ -39,3 +39,11 @@ Sequence(Commands(
   Command(Stem,Args(RepeatArg(⚠))),
   Command(Stem,Args(RepeatArg(⚠,Enum)))
 ))
+
+# locals with wrong value types
+
+@LOCALS "string_not_enum"
+
+==>
+
+Sequence(LocalDeclaration(⚠(String)))
diff --git a/src/components/sequencing/CommandTooltip.svelte b/src/components/sequencing/CommandTooltip.svelte
index be18db8d64..02e3283391 100644
--- a/src/components/sequencing/CommandTooltip.svelte
+++ b/src/components/sequencing/CommandTooltip.svelte
@@ -5,7 +5,7 @@
 
   export let command: FswCommand | HwCommand;
 
-  let commandExample: string;
+  $: commandExample = command.stem;
 
   $: if (command.type === 'hw_command') {
     commandExample = command.stem;
diff --git a/src/utilities/new-sequence-editor/sequence-linter.ts b/src/utilities/new-sequence-editor/sequence-linter.ts
index 21ee94fd4d..03acef7919 100644
--- a/src/utilities/new-sequence-editor/sequence-linter.ts
+++ b/src/utilities/new-sequence-editor/sequence-linter.ts
@@ -6,7 +6,8 @@ import type { CommandDictionary, EnumMap, FswCommand, FswCommandArgument, HwComm
 import { closest } from 'fastest-levenshtein';
 import { addDefaultArgs } from '../../components/sequencing/form/utils';
 
-import { TOKEN_REPEAT_ARG } from './sequencer-grammar-constants';
+import type { EditorView } from 'codemirror';
+import { TOKEN_COMMAND, TOKEN_ERROR, TOKEN_REPEAT_ARG } from './sequencer-grammar-constants';
 import {
   ABSOLUTE_TIME,
   EPOCH_SIMPLE,
@@ -18,8 +19,6 @@ import {
 } from './time-utils';
 import { getChildrenNode, getDeepestNode, getFromAndTo } from './tree-utils';
 
-const ERROR = '⚠';
-
 const KNOWN_DIRECTIVES = [
   'LOAD_AND_GO',
   'ID',
@@ -52,24 +51,18 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     // Validate command type mixing
     diagnostics.push(...validateCommandTypeMixing(treeNode));
 
-    diagnostics.push(...validateCustomDirectives(treeNode, view.state.doc.toString()));
+    const docText = view.state.doc.toString();
 
-    diagnostics.push(
-      ...commandLinter(treeNode.getChild('Commands')?.getChildren('Command') || [], view.state.doc.toString()),
-    );
+    diagnostics.push(...validateCustomDirectives(treeNode, docText));
+
+    diagnostics.push(...commandLinter(treeNode.getChild('Commands')?.getChildren(TOKEN_COMMAND) || [], docText));
 
     diagnostics.push(
-      ...immediateCommandLinter(
-        treeNode.getChild('ImmediateCommands')?.getChildren('Command') || [],
-        view.state.doc.toString(),
-      ),
+      ...immediateCommandLinter(treeNode.getChild('ImmediateCommands')?.getChildren(TOKEN_COMMAND) || [], docText),
     );
 
     diagnostics.push(
-      ...hardwareCommandLinter(
-        treeNode.getChild('HardwareCommands')?.getChildren('Command') || [],
-        view.state.doc.toString(),
-      ),
+      ...hardwareCommandLinter(treeNode.getChild('HardwareCommands')?.getChildren(TOKEN_COMMAND) || [], docText),
     );
 
     return diagnostics;
@@ -89,7 +82,7 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     const lgo = commands?.getChild('LoadAndGoDirective') ?? null;
 
     // Check if each command type exists and has at least one child node.
-    const hasCommands = commands !== null && (commands?.getChildren('Command').length > 0 || lgo !== null);
+    const hasCommands = commands !== null && (commands?.getChildren(TOKEN_COMMAND).length > 0 || lgo !== null);
     const hasImmediateCommands = immediateCommands !== null;
     const hasHardwareCommands = hardwareCommands !== null;
 
@@ -124,14 +117,17 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
   function validateCustomDirectives(node: SyntaxNode, text: string): Diagnostic[] {
     const diagnostics: Diagnostic[] = [];
     node.getChildren('GenericDirective').forEach(directiveNode => {
-      const { from, to } = getFromAndTo([directiveNode]);
+      const child = directiveNode.firstChild;
+      // use first token as directive, preserve remainder of line
+      const { from, to } = { ...getFromAndTo([directiveNode]), ...(child ? { to: child.from } : {}) };
       const custom = text.slice(from, to).trim();
       const guess = closest(custom, KNOWN_DIRECTIVES);
+      const insert = guess + (child ? ' ' : '\n');
       diagnostics.push({
         actions: [
           {
             apply(view, from, to) {
-              view.dispatch({ changes: { from, insert: guess + '\n', to } });
+              view.dispatch({ changes: { from, insert, to } });
             },
             name: `Change to ${guess}`,
           },
@@ -145,6 +141,15 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     return diagnostics;
   }
 
+  function insertAction(name: string, insert: string) {
+    return {
+      apply(view: EditorView, from: number, _to: number) {
+        view.dispatch({ changes: { from, insert } });
+      },
+      name,
+    };
+  }
+
   /**
    * Function to generate diagnostics based on Commands section in the parse tree.
    *
@@ -169,7 +174,10 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       // If the TimeTag node is missing, create a diagnostic
       if (!timeTagNode) {
         diagnostics.push({
-          actions: [],
+          actions: [
+            insertAction(`Insert 'C' (command complete)`, 'C '),
+            insertAction(`Insert 'R1' (relative 1)`, 'R '),
+          ],
           from: command.from,
           message: "Missing 'Time Tag' for command",
           severity: 'error',
@@ -338,7 +346,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       const modelsNode = command.getChild('Models');
       if (modelsNode) {
         diagnostics.push({
-          actions: [],
           from: modelsNode.from,
           message: "Immediate commands can't have models",
           severity: 'error',
@@ -488,7 +495,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         ...hwCommands.map(cmd => cmd.stem),
       ]);
       return {
-        actions: [],
         from: stem.from,
         message: `Command '${stemText}' not found, '${guess}' is closest match in dictionary`,
         severity: 'error',
@@ -501,7 +507,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       case 'immediate':
         if (!fswCommandMap[stemText]) {
           return {
-            actions: [],
             from: stem.from,
             message: 'Command must be a fsw command',
             severity: 'error',
@@ -512,7 +517,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       case 'hardware':
         if (!hwCommandMap[stemText]) {
           return {
-            actions: [],
             from: stem.from,
             message: 'Command must be a hardware command',
             severity: 'error',
@@ -575,6 +579,7 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         return diagnostics;
       } else if (argNode.length < dictArgs.length) {
         const { from, to } = getFromAndTo(argNode);
+        const pluralS = dictArgs.length > argNode.length + 1 ? 's' : '';
         diagnostics.push({
           actions: [
             {
@@ -583,11 +588,11 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
                   addDefaultArgs(commandDictionary, view, command, dictArgs.slice(argNode.length));
                 }
               },
-              name: 'Add default missing arguments',
+              name: `Add default missing argument${pluralS}`,
             },
           ],
           from,
-          message: `Missing arguments, definition has ${argNode.length}, but ${dictArgs.length} are present`,
+          message: `Missing argument${pluralS}, definition has ${argNode.length}, but ${dictArgs.length} are present`,
           severity: 'error',
           to,
         });
@@ -697,7 +702,14 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
           }
           if (argType === 'Enum') {
             diagnostics.push({
-              actions: [],
+              actions: [
+                {
+                  apply(view, from, to) {
+                    view.dispatch({ changes: { from, insert: `"${argText}"`, to } });
+                  },
+                  name: `Add quotes around ${argText}`,
+                },
+              ],
               from: argNode.from,
               message: `Enum should be a "string"`,
               severity: 'error',
@@ -720,7 +732,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
           if (nodeTextAsNumber < min || nodeTextAsNumber > max) {
             const message = `Number out of range. Make sure this number is between ${min} and ${max} inclusive.`;
             diagnostics.push({
-              actions: [],
               from: argNode.from,
               message,
               severity: 'error',
@@ -729,7 +740,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
           }
         } else {
           diagnostics.push({
-            actions: [],
             from: argNode.from,
             message: `Incorrect type - expected 'Number' but got ${argType}`,
             severity: 'error',
@@ -741,7 +751,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       case 'var_string':
         if (argType !== 'String') {
           diagnostics.push({
-            actions: [],
             from: argNode.from,
             message: `Incorrect type - expected 'String' but got ${argType}`,
             severity: 'error',
@@ -752,7 +761,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       case 'repeat':
         if (argType !== TOKEN_REPEAT_ARG) {
           diagnostics.push({
-            actions: [],
             from: argNode.from,
             message: `Incorrect type - expected '${TOKEN_REPEAT_ARG}' but got ${argType}`,
             severity: 'error',
@@ -905,7 +913,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
               case 'Enum':
               case 'Boolean':
                 diagnostics.push({
-                  actions: [],
                   from: metadataNode.from,
                   message: `Incorrect type - expected 'String' but got ${deepestNodeName}`,
                   severity: 'error',
@@ -914,7 +921,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
                 break;
               default:
                 diagnostics.push({
-                  actions: [],
                   from: entry.from,
                   message: `Missing ${templateName}`,
                   severity: 'error',
@@ -930,11 +936,7 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
   }
 
   function validateModel(commandNode: SyntaxNode): Diagnostic[] {
-    const modelConstainerNode = commandNode.getChild('Models');
-    if (!modelConstainerNode) {
-      return [];
-    }
-    const models = modelConstainerNode.getChildren('Model');
+    const models = commandNode.getChild('Models')?.getChildren('Model');
     if (!models) {
       return [];
     }
@@ -945,7 +947,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
       const modelChildren = getChildrenNode(model);
       if (modelChildren.length > 3) {
         diagnostics.push({
-          actions: [],
           from: model.from,
           message: `Should only have 'Variable', 'value', and 'Offset'`,
           severity: 'error',
@@ -958,7 +959,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
           const modelNode = modelChildren[i];
           if (!modelNode) {
             diagnostics.push({
-              actions: [],
               from: model.from,
               message: `Missing ${templateName}`,
               severity: 'error',
@@ -968,9 +968,8 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
 
           if (modelNode.name !== templateName) {
             const deepestNodeName = getDeepestNode(modelNode).name;
-            if (deepestNodeName === ERROR) {
+            if (deepestNodeName === TOKEN_ERROR) {
               diagnostics.push({
-                actions: [],
                 from: model.from,
                 message: `Missing ${templateName}`,
                 severity: 'error',
@@ -981,7 +980,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
               if (templateName === 'Variable' || templateName === 'Offset') {
                 if (deepestNodeName !== 'String') {
                   diagnostics.push({
-                    actions: [],
                     from: modelNode.from,
                     message: `Incorrect type - expected 'String' but got ${deepestNodeName}`,
                     severity: 'error',
@@ -993,7 +991,6 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
                 // Value
                 if (deepestNodeName !== 'Number' && deepestNodeName !== 'String' && deepestNodeName !== 'Boolean') {
                   diagnostics.push({
-                    actions: [],
                     from: modelNode.from,
                     message: `Incorrect type - expected 'Number', 'String', or 'Boolean' but got ${deepestNodeName}`,
                     severity: 'error',

From 21e87ad4d67647de332b4988e20897f91bd634c8 Mon Sep 17 00:00:00 2001
From: Chet Joswig <cjoswig@yahoo.com>
Date: Sun, 7 Apr 2024 20:02:37 -0700
Subject: [PATCH 8/8] lint @LOCALS and @INPUT_PARAMETERS

---
 .../new-sequence-editor/sequence-linter.ts    | 101 ++++++++++++++++--
 1 file changed, 91 insertions(+), 10 deletions(-)

diff --git a/src/utilities/new-sequence-editor/sequence-linter.ts b/src/utilities/new-sequence-editor/sequence-linter.ts
index 03acef7919..87441e2100 100644
--- a/src/utilities/new-sequence-editor/sequence-linter.ts
+++ b/src/utilities/new-sequence-editor/sequence-linter.ts
@@ -3,7 +3,7 @@ import { linter, type Diagnostic } from '@codemirror/lint';
 import type { Extension } from '@codemirror/state';
 import type { SyntaxNode } from '@lezer/common';
 import type { CommandDictionary, EnumMap, FswCommand, FswCommandArgument, HwCommand } from '@nasa-jpl/aerie-ampcs';
-import { closest } from 'fastest-levenshtein';
+import { closest, distance } from 'fastest-levenshtein';
 import { addDefaultArgs } from '../../components/sequencing/form/utils';
 
 import type { EditorView } from 'codemirror';
@@ -36,6 +36,12 @@ export function getAllEnumSymbols(enumMap: EnumMap, enumName: string) {
   return { enumSymbols, enumSymbolsDisplayStr };
 }
 
+function closestStrings(value: string, potentialMatches: string[], n: number) {
+  const distances = potentialMatches.map(s => ({ distance: distance(s, value), s }));
+  distances.sort((a, b) => a.distance - b.distance);
+  return distances.slice(0, n).map(pair => pair.s);
+}
+
 /**
  * Linter function that returns a Code Mirror extension function.
  * Can be optionally called with a command dictionary so it's available during linting.
@@ -48,6 +54,10 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     // Validate top level metadata
     diagnostics.push(...validateMetadata(treeNode));
 
+    diagnostics.push(...validateLocals(treeNode.getChildren('LocalDeclaration')));
+
+    diagnostics.push(...validateParameters(treeNode.getChildren('ParameterDeclaration')));
+
     // Validate command type mixing
     diagnostics.push(...validateCommandTypeMixing(treeNode));
 
@@ -114,6 +124,66 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
     return diagnostics;
   }
 
+  function validateLocals(locals: SyntaxNode[]) {
+    const diagnostics: Diagnostic[] = [];
+    diagnostics.push(
+      ...locals.slice(1).map(
+        local =>
+          ({
+            ...getFromAndTo([local]),
+            message: 'There is a maximum of @LOCALS directive per sequence',
+            severity: 'error',
+          }) as Diagnostic,
+      ),
+    );
+    locals.forEach(local => {
+      let child = local.firstChild;
+      while (child) {
+        if (child.name !== 'Enum') {
+          diagnostics.push({
+            from: child.from,
+            message: `@LOCALS values are required to be Enums`,
+            severity: 'error',
+            to: child.to,
+          });
+        }
+        child = child.nextSibling;
+      }
+    });
+    // TODO - hook to check mission specific nomenclature
+    return diagnostics;
+  }
+
+  function validateParameters(inputParams: SyntaxNode[]) {
+    const diagnostics: Diagnostic[] = [];
+    diagnostics.push(
+      ...inputParams.slice(1).map(
+        inputParam =>
+          ({
+            ...getFromAndTo([inputParam]),
+            message: 'There is a maximum of @INPUT_PARAMS directive per sequence',
+            severity: 'error',
+          }) as Diagnostic,
+      ),
+    );
+    inputParams.forEach(inputParam => {
+      let child = inputParam.firstChild;
+      while (child) {
+        if (child.name !== 'Enum') {
+          diagnostics.push({
+            from: child.from,
+            message: `@INPUT_PARAMS values are required to be Enums`,
+            severity: 'error',
+            to: child.to,
+          });
+        }
+        child = child.nextSibling;
+      }
+    });
+    // TODO - hook to check mission specific nomenclature
+    return diagnostics;
+  }
+
   function validateCustomDirectives(node: SyntaxNode, text: string): Diagnostic[] {
     const diagnostics: Diagnostic[] = [];
     node.getChildren('GenericDirective').forEach(directiveNode => {
@@ -490,13 +560,16 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         : null;
 
     if (!dictionaryCommand) {
-      const guess = closest(stemText.toUpperCase(), [
-        ...fswCommands.map(cmd => cmd.stem),
-        ...hwCommands.map(cmd => cmd.stem),
-      ]);
+      const ALL_STEMS = [...fswCommands.map(cmd => cmd.stem), ...hwCommands.map(cmd => cmd.stem)];
       return {
+        actions: closestStrings(stemText.toUpperCase(), ALL_STEMS, 3).map(guess => ({
+          apply(view, from, to) {
+            view.dispatch({ changes: { from, insert: guess, to } });
+          },
+          name: `Change to ${guess}`,
+        })),
         from: stem.from,
-        message: `Command '${stemText}' not found, '${guess}' is closest match in dictionary`,
+        message: `Command '${stemText}' not found`,
         severity: 'error',
         to: stem.to,
       };
@@ -599,17 +672,25 @@ export function sequenceLinter(commandDictionary: CommandDictionary | null = nul
         return diagnostics;
       }
     } else if (argNode && argNode.length > 0) {
+      const { from, to } = getFromAndTo(argNode);
       diagnostics.push({
-        actions: [],
-        from: command.from,
+        actions: [
+          {
+            apply(view, from, to) {
+              view.dispatch({ changes: { from, to } });
+            },
+            name: `Remove argument${argNode.length > 1 ? 's' : ''}`,
+          },
+        ],
+        from: from,
         message: 'The command should not have arguments',
         severity: 'error',
-        to: command.to,
+        to: to,
       });
       return diagnostics;
     }
 
-    // don't check any further as there is no arguments in the command dictionary
+    // don't check any further as there are no arguments in the command dictionary
     if (dictArgs.length === 0) {
       return diagnostics;
     }