@bastani/atomic 0.8.13-0 → 0.8.14-0

package/dist/builtin/workflows/src/tui/inline-form-editor.ts

@@ -2,7 +2,7 @@
  * Custom `EditorComponent` swapped in via `ctx.ui.setEditorComponent` while
  * an inline workflow form is active. Owns ALL keystrokes during fill-out:
  *
- *   tab / shift+tab     — move focus across form fields (NOT editor lines)
+ *   tab / shift+tab     — move focus across form fields and the final Submit action
  *   ↑/↓                 — move focus (or caret between logical lines in `text`)
  *   ←/→                 — caret nav (text) | choice cycle (select) | flip (bool)
  *   alt/ctrl+←/→        — word movement in text/string/number fields
@@ -16,13 +16,13 @@
  *   space               — boolean toggle
  *   enter               — newline (text) | otherwise next field
  *   printable ASCII     — insert at caret (text/string/number)
- *   ctrl+x          — submit form (if valid)
+ *   submit action       — ↑/↓ returns to questions; enter submits
  *   esc / ctrl+c        — cancel form
  *
  * Editor-mode keys (cursor movement, word jumps, deletions) route through
  * the Pi `KeybindingsManager` injected by the host at factory time, so any
  * user-configured keybinding overrides surfaces here as well. Form-level
- * keys (tab/shift+tab/ctrl+x/esc/ctrl+c) stay as raw byte checks because
+ * keys (tab/shift+tab/esc/ctrl+c) stay as raw byte checks because
  * they are workflow form contract, not Pi-configurable actions.
  *
  * On submit/cancel the editor calls back to the orchestrator which:
@@ -47,8 +47,10 @@ import type { GraphTheme } from "./graph-theme.js";
 import type { WorkflowInputEntry } from "../extension/render-result.js";
 import type { InlineFormState } from "./inline-form-store.js";
 import { getForm, touch } from "./inline-form-store.js";
+import { computeInvalid } from "./inputs-picker.js";
 import {
   type KeybindingsLike,
+  TUI_ACTION,
   deleteRange,
   isKeybindingsLike,
   lineEnd,
@@ -57,14 +59,14 @@ import {
   wordLeft,
   wordRight,
 } from "./keybindings-adapter.js";
-import { decodePrintableKey, matchesKey, visibleWidth } from "./text-helpers.js";
+import { decodePrintableKey, Key, matchesKey, visibleWidth } from "./text-helpers.js";
 
 export type FormEditorOutcome = "submit" | "cancel";
 
 export interface InlineFormEditorOpts {
   formId: string;
   theme: GraphTheme;
-  /** Called when Ctrl+X passes validation or cancel fires. */
+  /** Called when the Submit row passes validation or cancel fires. */
   onExit: (outcome: FormEditorOutcome) => void;
   /**
    * Pi's `KeybindingsManager` injected as the third arg of the editor
@@ -433,27 +435,23 @@ export class InlineFormEditor implements PiEditorComponent {
     // editor actions, so they stay as raw byte checks:
     //   esc        (\x1b)        — cancel form
     //   ctrl+c     (\x03)        — cancel form
-    //   ctrl+x                — submit form
-    //   tab        (\t)          — focus next field
-    //   shift+tab  (\x1b[Z)      — focus previous field
-    if (matchesKey(data, "ctrl+c") || matchesKey(data, "escape")) {
+    //   tab        (\t)          — focus next field / final Submit action
+    //   shift+tab  (\x1b[Z)      — focus previous field / final Submit action
+    if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.escape)) {
       this.opts.onExit("cancel");
       return true;
     }
-    if (matchesKey(data, "ctrl+x")) {
-      if (this.allValid(state)) this.opts.onExit("submit");
-      else this.focusFirstInvalid(state);
-      return true;
-    }
-    if (matchesKey(data, "tab")) {
+    if (matchesKey(data, Key.tab)) {
       this.moveFocus(state, +1);
       return true;
     }
-    if (matchesKey(data, "shift+tab")) {
+    if (matchesKey(data, Key.shift("tab"))) {
       this.moveFocus(state, -1);
       return true;
     }
 
+    if (state.focusedIdx === state.fields.length) return this.handleSubmit(data, state);
+
     const field = state.fields[state.focusedIdx];
     if (!field) return false;
 
@@ -462,6 +460,31 @@ export class InlineFormEditor implements PiEditorComponent {
     return this.handleText(data, field, state);
   }
 
+  private handleSubmit(data: string, state: InlineFormState): boolean {
+    if (matchesAction(this.kb, data, TUI_ACTION.selectUp) || matchesAction(this.kb, data, TUI_ACTION.editorCursorUp)) {
+      this.moveFocus(state, -1);
+      return true;
+    }
+    if (matchesAction(this.kb, data, TUI_ACTION.selectDown) || matchesAction(this.kb, data, TUI_ACTION.editorCursorDown)) {
+      this.moveFocus(state, +1);
+      return true;
+    }
+    if (
+      matchesKey(data, Key.enter) ||
+      matchesAction(this.kb, data, TUI_ACTION.selectConfirm) ||
+      matchesAction(this.kb, data, TUI_ACTION.inputSubmit)
+    ) {
+      return this.submitOrFocusInvalid(state);
+    }
+    return false;
+  }
+
+  private submitOrFocusInvalid(state: InlineFormState): boolean {
+    if (this.allValid(state)) this.opts.onExit("submit");
+    else this.focusFirstInvalid(state);
+    return true;
+  }
+
   private handleSelect(
     data: string,
     field: WorkflowInputEntry,
@@ -471,22 +494,19 @@ export class InlineFormEditor implements PiEditorComponent {
     if (choices.length === 0) return false;
     const cur = state.rawText[field.name] ?? choices[0]!;
     const i = Math.max(0, choices.indexOf(cur));
-    if (matchesAction(this.kb, data, "tui.editor.cursorLeft")) {
+    if (matchesAction(this.kb, data, TUI_ACTION.selectUp) || matchesAction(this.kb, data, TUI_ACTION.editorCursorLeft)) {
       state.rawText[field.name] = choices[(i - 1 + choices.length) % choices.length]!;
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorRight") || matchesKey(data, "space")) {
+    if (
+      matchesAction(this.kb, data, TUI_ACTION.selectDown) ||
+      matchesAction(this.kb, data, TUI_ACTION.editorCursorRight) ||
+      matchesKey(data, Key.space)
+    ) {
       state.rawText[field.name] = choices[(i + 1) % choices.length]!;
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorUp")) {
-      this.moveFocus(state, -1);
-      return true;
-    }
-    if (
-      matchesAction(this.kb, data, "tui.editor.cursorDown") ||
-      matchesAction(this.kb, data, "tui.input.submit")
-    ) {
+    if (matchesAction(this.kb, data, TUI_ACTION.selectConfirm) || matchesAction(this.kb, data, TUI_ACTION.inputSubmit)) {
       this.moveFocus(state, +1);
       return true;
     }
@@ -499,21 +519,16 @@ export class InlineFormEditor implements PiEditorComponent {
     state: InlineFormState,
   ): boolean {
     if (
-      matchesKey(data, "space") ||
-      matchesAction(this.kb, data, "tui.editor.cursorLeft") ||
-      matchesAction(this.kb, data, "tui.editor.cursorRight")
+      matchesKey(data, Key.space) ||
+      matchesAction(this.kb, data, TUI_ACTION.selectUp) ||
+      matchesAction(this.kb, data, TUI_ACTION.selectDown) ||
+      matchesAction(this.kb, data, TUI_ACTION.editorCursorLeft) ||
+      matchesAction(this.kb, data, TUI_ACTION.editorCursorRight)
     ) {
       state.rawText[field.name] = state.rawText[field.name] === "true" ? "false" : "true";
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorUp")) {
-      this.moveFocus(state, -1);
-      return true;
-    }
-    if (
-      matchesAction(this.kb, data, "tui.editor.cursorDown") ||
-      matchesAction(this.kb, data, "tui.input.submit")
-    ) {
+    if (matchesAction(this.kb, data, TUI_ACTION.selectConfirm) || matchesAction(this.kb, data, TUI_ACTION.inputSubmit)) {
       this.moveFocus(state, +1);
       return true;
     }
@@ -531,7 +546,7 @@ export class InlineFormEditor implements PiEditorComponent {
 
     // Vertical navigation — text fields walk between logical lines first,
     // single-line scalars advance focus immediately.
-    if (matchesAction(this.kb, data, "tui.editor.cursorUp")) {
+    if (matchesAction(this.kb, data, TUI_ACTION.editorCursorUp)) {
       if (field.type === "text") {
         const newCaret = caretLineUp(cur, caret);
         if (newCaret !== null) {
@@ -542,7 +557,7 @@ export class InlineFormEditor implements PiEditorComponent {
       this.moveFocus(state, -1);
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorDown")) {
+    if (matchesAction(this.kb, data, TUI_ACTION.editorCursorDown)) {
       if (field.type === "text") {
         const newCaret = caretLineDown(cur, caret);
         if (newCaret !== null) {
@@ -579,11 +594,11 @@ export class InlineFormEditor implements PiEditorComponent {
     }
 
     // Character cursor movement.
-    if (matchesAction(this.kb, data, "tui.editor.cursorLeft")) {
+    if (matchesAction(this.kb, data, TUI_ACTION.editorCursorLeft)) {
       state.caret = previousGraphemeOffset(cur, caret);
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorRight")) {
+    if (matchesAction(this.kb, data, TUI_ACTION.editorCursorRight)) {
       state.caret = nextGraphemeOffset(cur, caret);
       return true;
     }
@@ -642,7 +657,7 @@ export class InlineFormEditor implements PiEditorComponent {
     // explicitly equivalent to plain Enter in our form contract; both
     // insert a newline in text fields and advance focus elsewhere.
     if (
-      matchesAction(this.kb, data, "tui.input.submit") ||
+      matchesAction(this.kb, data, TUI_ACTION.inputSubmit) ||
       matchesAction(this.kb, data, "tui.input.newLine")
     ) {
       if (field.type === "text") {
@@ -669,48 +684,28 @@ export class InlineFormEditor implements PiEditorComponent {
   }
 
   private moveFocus(state: InlineFormState, delta: number): void {
-    const n = state.fields.length;
-    if (n === 0) return;
+    const n = state.fields.length + 1;
+    if (n <= 1) return;
     state.focusedIdx = (state.focusedIdx + delta + n) % n;
+    if (state.focusedIdx === state.fields.length) {
+      state.caret = 0;
+      state.submitChoiceIdx = 0;
+      return;
+    }
     const next = state.fields[state.focusedIdx]!;
     state.caret = (state.rawText[next.name] ?? "").length;
   }
 
   private focusFirstInvalid(state: InlineFormState): void {
-    const idx = state.fields.findIndex((f) => {
-      const v = state.rawText[f.name] ?? "";
-      if (f.required && v.trim() === "") return true;
-      if ((f.type === "number" || f.type === "integer") && v !== "" && !Number.isFinite(Number(v))) {
-        return true;
-      }
-      return f.type === "select" && Boolean(f.choices) && v !== "" && !f.choices!.includes(v);
-    });
-    if (idx < 0) return;
+    const [idx] = computeInvalid(state.fields, state.rawText);
+    if (idx === undefined) return;
+    state.submitChoiceIdx = 0;
     state.focusedIdx = idx;
     state.caret = (state.rawText[state.fields[idx]!.name] ?? "").length;
   }
 
   private allValid(state: InlineFormState): boolean {
-    for (const f of state.fields) {
-      const v = state.rawText[f.name] ?? "";
-      if (f.required && v.trim() === "") return false;
-      if (
-        (f.type === "number" || f.type === "integer") &&
-        v !== "" &&
-        !Number.isFinite(Number(v))
-      ) {
-        return false;
-      }
-      if (
-        f.type === "select" &&
-        f.choices &&
-        v !== "" &&
-        !f.choices.includes(v)
-      ) {
-        return false;
-      }
-    }
-    return true;
+    return computeInvalid(state.fields, state.rawText).length === 0;
   }
 }
 

package/dist/builtin/workflows/src/tui/inline-form-overlay.ts

@@ -57,7 +57,6 @@ export type InlineFormResult =
 
 export interface OpenInlineFormOpts {
   workflowName: string;
-  description?: string;
   fields: readonly WorkflowInputEntry[];
   prefilled?: Record<string, unknown>;
   theme: GraphTheme;
@@ -107,7 +106,7 @@ export function registerInlineFormRenderer(pi: ExtensionAPI, theme: GraphTheme):
     const state = getForm(formId);
     if (!state) {
       // Process restart / map evicted — tombstone the entry.
-      return `▎ ${message.content ?? "workflow form"}  ·  (snapshot lost)`;
+      return `  ${message.content ?? "workflow form"}  ·  (snapshot lost)`;
     }
     return {
       // The card is fully reactive: read fresh state on every render call,
@@ -199,10 +198,10 @@ export async function openInlineInputsForm(
   const state = createForm({
     formId,
     workflowName: opts.workflowName,
-    description: opts.description,
     fields: opts.fields,
     rawText,
     focusedIdx,
+    submitChoiceIdx: 0,
     caret: (rawText[opts.fields[focusedIdx]!.name] ?? "").length,
     status: "editing",
   });

package/dist/builtin/workflows/src/tui/inline-form-store.ts

@@ -32,11 +32,12 @@ export type FormStatus = "editing" | "submitted" | "cancelled";
 export interface InlineFormState {
   formId: string;
   workflowName: string;
-  description?: string;
   fields: readonly WorkflowInputEntry[];
   /** Raw string per field; mirrors `inputs-picker.ts` semantics. */
   rawText: Record<string, string>;
   focusedIdx: number;
+  /** Reserved for older form snapshots; Submit is now a single final action. */
+  submitChoiceIdx: number;
   caret: number;
   status: FormStatus;
   /** Tick counter; bumped on every mutation so renderers can hash-dedupe. */

package/dist/builtin/workflows/src/tui/inputs-overlay.ts

@@ -55,7 +55,6 @@ export type InputsPickerResult =
 
 export interface OpenInputsPickerOpts {
   workflowName: string;
-  description?: string;
   fields: WorkflowInputEntry[];
   /** Prefilled values (e.g. from `key=value` slash args). The form
    *  seeds these into the form so the user doesn't re-type what they typed. */
@@ -78,7 +77,7 @@ export function openInputsPicker(
   opts: OpenInputsPickerOpts,
 ): Promise<InputsPickerResult> {
   return new Promise<InputsPickerResult>((resolve) => {
-    const { workflowName, description, fields, prefilled, theme } = opts;
+    const { workflowName, fields, prefilled, theme } = opts;
     const custom = ui.custom;
     if (typeof custom !== "function") {
       resolve({ kind: "cancel" });
@@ -124,7 +123,6 @@ export function openInputsPicker(
             width,
             theme,
             workflowName,
-            description,
             fields,
             state,
             cursorOn,