@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/builtin/workflows/src/tui/prompt-card-select.ts

@@ -0,0 +1,116 @@
+import {
+  SelectList,
+  truncateToWidth,
+  type SelectItem,
+  type SelectListTheme,
+} from "@earendil-works/pi-tui";
+import type { GraphTheme } from "./graph-theme.js";
+import { paint } from "./color-utils.js";
+import { Key, matchesKey } from "./text-helpers.js";
+import {
+  type KeybindingsLike,
+  TUI_ACTION,
+  matchesAction,
+} from "./keybindings-adapter.js";
+import type { PromptCardState } from "./prompt-card-state.js";
+
+export function createPromptSelectList(
+  state: PromptCardState,
+  theme?: GraphTheme,
+  maxVisible = 5,
+): SelectList {
+  const choices = state.prompt.choices ?? [];
+  const items: SelectItem[] = choices.map((choice, idx) => ({
+    value: String(idx),
+    label: choice,
+  }));
+  const list = new SelectList(
+    items,
+    Math.max(1, Math.min(maxVisible, choices.length || 1)),
+    createSelectListTheme(theme),
+    {
+      minPrimaryColumnWidth: 1,
+      maxPrimaryColumnWidth: 80,
+      truncatePrimary: ({ text, maxWidth, isSelected }) => {
+        const clipped = truncateToWidth(text, maxWidth, "");
+        if (!theme) return clipped;
+        return paint(clipped, isSelected ? theme.text : theme.dim, { bold: isSelected });
+      },
+    },
+  );
+  const selectedIndex = normalizeSelectIndex(state.selectedIndex, choices.length);
+  list.setSelectedIndex(selectedIndex);
+  list.onSelectionChange = (item) => {
+    state.selectedIndex = normalizeSelectIndex(Number(item.value), choices.length);
+  };
+  return list;
+}
+
+function createSelectListTheme(theme?: GraphTheme): SelectListTheme {
+  if (!theme) {
+    return {
+      selectedPrefix: (text) => text,
+      selectedText: (text) => text,
+      description: (text) => text,
+      scrollInfo: (text) => text,
+      noMatch: (text) => text,
+    };
+  }
+  return {
+    selectedPrefix: (text) => paint(text, theme.accent, { bold: true }),
+    selectedText: (text) => paint(text, theme.text, { bold: true }),
+    description: (text) => paint(text, theme.textMuted),
+    scrollInfo: (text) => paint(text, theme.dim),
+    noMatch: (text) => paint(text, theme.dim),
+  };
+}
+
+export function normalizeSelectIndex(index: number, length: number): number {
+  if (length <= 0) return 0;
+  const n = Number.isFinite(index) ? Math.trunc(index) : 0;
+  return ((n % length) + length) % length;
+}
+
+const SELECT_PAGE_STEP = 5;
+
+export function selectMovementDelta(
+  data: string,
+  keybindings: KeybindingsLike | undefined,
+  choiceCount: number,
+): number {
+  if (
+    matchesAction(keybindings, data, TUI_ACTION.selectUp) ||
+    matchesKey(data, Key.up) ||
+    matchesKey(data, Key.left)
+  ) {
+    return -1;
+  }
+  if (
+    matchesAction(keybindings, data, TUI_ACTION.selectDown) ||
+    matchesKey(data, Key.down) ||
+    matchesKey(data, Key.right)
+  ) {
+    return 1;
+  }
+  const pageStep = Math.max(1, Math.min(SELECT_PAGE_STEP, choiceCount));
+  if (
+    matchesAction(keybindings, data, TUI_ACTION.selectPageUp) ||
+    matchesKey(data, "pageUp")
+  ) {
+    return -pageStep;
+  }
+  if (
+    matchesAction(keybindings, data, TUI_ACTION.selectPageDown) ||
+    matchesKey(data, "pageDown")
+  ) {
+    return pageStep;
+  }
+  return 0;
+}
+
+export function matchesSelectSubmit(
+  data: string,
+  keybindings: KeybindingsLike | undefined,
+): boolean {
+  return matchesAction(keybindings, data, TUI_ACTION.selectConfirm) || matchesKey(data, Key.enter);
+}

package/dist/builtin/workflows/src/tui/prompt-card-state.ts

@@ -0,0 +1,61 @@
+import type { PendingPrompt } from "../shared/store-types.js";
+
+export interface PromptCardState {
+  readonly prompt: PendingPrompt;
+  /** Raw text buffer for `input`/`editor` prompts. */
+  rawText: string;
+  /** Caret position within `rawText` (in characters, not visual cells). */
+  caret: number;
+  /** Selected index for `select` prompts (offset into `prompt.choices`). */
+  selectedIndex: number;
+  /** Boolean selection for `confirm` prompts (true = yes, false = no). */
+  confirmValue: boolean;
+  /** For multi-line editor prompts, Tab moves focus to a visible Submit action. */
+  editorSubmitFocused: boolean;
+}
+
+export function createPromptCardState(prompt: PendingPrompt): PromptCardState {
+  const initial = prompt.initial ?? "";
+  return {
+    prompt,
+    rawText: initial,
+    caret: initial.length,
+    selectedIndex: 0,
+    confirmValue: false,
+    editorSubmitFocused: false,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Key handling
+// ---------------------------------------------------------------------------
+
+/** Action returned by `handlePromptCardInput`. */
+export type PromptCardAction =
+  | { kind: "noop" }
+  /** User submitted — `response` already shaped to match the prompt's kind. */
+  | { kind: "submit"; response: unknown }
+  /**
+   * User dismissed without responding. Caller decides what to do — for HIL
+   * we forward a kind-appropriate default to `store.resolvePendingPrompt`
+   * so the workflow body resumes (rather than hanging).
+   */
+  | { kind: "cancel" };
+
+/**
+ * Compute the safe default response when the user dismisses the prompt.
+ * Used by the overlay to keep the workflow body unblocked even on cancel.
+ */
+export function defaultResponseFor(prompt: PendingPrompt): unknown {
+  switch (prompt.kind) {
+    case "input":
+    case "editor":
+      return prompt.initial ?? "";
+    case "confirm":
+      return false;
+    case "select":
+      return prompt.choices?.[0] ?? "";
+    case "custom":
+      return undefined;
+  }
+}

package/dist/builtin/workflows/src/tui/prompt-card-text.ts

@@ -0,0 +1,129 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { matchesKey } from "./text-helpers.js";
+import {
+  type KeybindingsLike,
+  deleteRange,
+  matchesAction,
+} from "./keybindings-adapter.js";
+import type { PromptCardState } from "./prompt-card-state.js";
+
+export interface GraphemePart {
+  text: string;
+  start: number;
+  end: number;
+  width: number;
+}
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export function graphemeParts(value: string): GraphemePart[] {
+  const parts: GraphemePart[] = [];
+  for (const segment of segmenter.segment(value)) {
+    const text = segment.segment;
+    parts.push({
+      text,
+      start: segment.index,
+      end: segment.index + text.length,
+      width: visibleWidth(text),
+    });
+  }
+  return parts;
+}
+
+export function previousGraphemeBoundary(value: string, caret: number): number {
+  const safeCaret = Math.max(0, Math.min(caret, value.length));
+  let prev = 0;
+  for (const part of graphemeParts(value)) {
+    if (part.start >= safeCaret) break;
+    prev = part.start;
+  }
+  return prev;
+}
+
+export function nextGraphemeBoundary(value: string, caret: number): number {
+  const safeCaret = Math.max(0, Math.min(caret, value.length));
+  for (const part of graphemeParts(value)) {
+    if (part.end > safeCaret) return part.end;
+  }
+  return value.length;
+}
+
+function clampGraphemeBoundary(value: string, caret: number): number {
+  const safeCaret = Math.max(0, Math.min(caret, value.length));
+  if (safeCaret === value.length) return safeCaret;
+  for (const part of graphemeParts(value)) {
+    if (part.start === safeCaret) return safeCaret;
+    if (part.start > safeCaret) break;
+  }
+  return previousGraphemeBoundary(value, safeCaret);
+}
+
+export function isPrintableText(data: string): boolean {
+  return data.length > 0 && !data.startsWith("\x1b") && !/[\x00-\x1f\x7f]/.test(data);
+}
+
+export function insertText(state: PromptCardState, text: string): void {
+  const caret = Math.max(0, Math.min(state.caret, state.rawText.length));
+  state.rawText = state.rawText.slice(0, caret) + text + state.rawText.slice(caret);
+  state.caret = caret + text.length;
+}
+
+export function matchesTextAction(
+  keybindings: KeybindingsLike | undefined,
+  data: string,
+  action: string,
+  fallback?: Parameters<typeof matchesKey>[1],
+): boolean {
+  return matchesAction(keybindings, data, action) || (fallback !== undefined && matchesKey(data, fallback));
+}
+
+export function matchesAnyKey(
+  data: string,
+  keys: readonly Parameters<typeof matchesKey>[1][],
+): boolean {
+  return keys.some((key) => matchesKey(data, key));
+}
+
+export function applyDeleteRange(state: PromptCardState, start: number, end: number, caret: number): void {
+  const result = deleteRange(state.rawText, start, end, caret);
+  state.rawText = result.text;
+  state.caret = result.caret;
+}
+
+function visualColumnAt(text: string, caret: number): number {
+  return visibleWidth(text.slice(0, clampGraphemeBoundary(text, caret)));
+}
+
+function offsetAtVisualColumn(text: string, targetCol: number): number {
+  let col = 0;
+  for (const part of graphemeParts(text)) {
+    const width = part.width;
+    if (col + width > targetCol) return part.start;
+    col += width;
+  }
+  return text.length;
+}
+
+export function caretLineUp(raw: string, caret: number): number | null {
+  const safe = clampGraphemeBoundary(raw, caret);
+  const lineStartOffset = raw.lastIndexOf("\n", safe - 1) + 1;
+  if (lineStartOffset === 0) return null;
+  const prevLineEnd = lineStartOffset - 1;
+  const prevLineStart = raw.lastIndexOf("\n", prevLineEnd - 1) + 1;
+  const col = visualColumnAt(raw.slice(lineStartOffset, safe), raw.slice(lineStartOffset, safe).length);
+  const prevLine = raw.slice(prevLineStart, prevLineEnd);
+  return prevLineStart + offsetAtVisualColumn(prevLine, col);
+}
+
+export function caretLineDown(raw: string, caret: number): number | null {
+  const safe = clampGraphemeBoundary(raw, caret);
+  const nextNl = raw.indexOf("\n", safe);
+  if (nextNl === -1) return null;
+  const lineStartOffset = raw.lastIndexOf("\n", safe - 1) + 1;
+  const col = visualColumnAt(raw.slice(lineStartOffset, safe), raw.slice(lineStartOffset, safe).length);
+  const nextLineStart = nextNl + 1;
+  const nextNlAfter = raw.indexOf("\n", nextLineStart);
+  const nextLineEnd = nextNlAfter === -1 ? raw.length : nextNlAfter;
+  const nextLine = raw.slice(nextLineStart, nextLineEnd);
+  return nextLineStart + offsetAtVisualColumn(nextLine, col);
+}