@bastani/atomic 0.5.12-2 → 0.5.12-4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/atomic",
-  "version": "0.5.12-2",
+  "version": "0.5.12-4",
   "description": "Configuration management CLI and SDK for coding agents",
   "type": "module",
   "license": "MIT",
@@ -71,7 +71,7 @@
     "typescript-language-server": "^5.1.3"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.105",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.107",
     "@clack/prompts": "^1.2.0",
     "@commander-js/extra-typings": "^14.0.0",
     "@github/copilot-sdk": "^0.2.2",

package/src/commands/cli/workflow.ts

@@ -391,7 +391,7 @@ async function runPickerMode(
 
 /**
  * Execute a workflow selected via the picker. The picker already stores
- * free-form prompts under the `prompt` key (via `DEFAULT_PROMPT_INPUT`),
+ * free-form prompts under the canonical `prompt` key,
  * so we can hand the inputs record straight through — no split between
  * "prompt" and "structured inputs" is needed.
  */

package/src/sdk/components/workflow-picker-panel.tsx

@@ -30,6 +30,7 @@ import {
   createCliRenderer,
   type CliRenderer,
   type KeyEvent,
+  type ScrollBoxRenderable,
   type TextareaRenderable,
 } from "@opentui/core";
 import {
@@ -42,6 +43,11 @@ import { useLatest } from "./hooks.ts";
 import { resolveTheme, type TerminalTheme } from "../runtime/theme.ts";
 import type { AgentType, WorkflowInput } from "../types.ts";
 import type { WorkflowWithMetadata } from "../runtime/discovery.ts";
+import {
+  DEFAULT_PROMPT_FIELDS,
+  isFreeformPromptSchema,
+  normalizePickerInputs,
+} from "../workflow-inputs.ts";
 import { ErrorBoundary } from "./error-boundary.tsx";
 
 // ─── Theme ──────────────────────────────────────
@@ -117,19 +123,6 @@ export interface WorkflowPickerResult {
   inputs: Record<string, string>;
 }
 
-/** Fallback field used when a workflow has no structured input schema. */
-const DEFAULT_PROMPT_INPUT: WorkflowInput = {
-  name: "prompt",
-  type: "text",
-  required: true,
-  description: "what do you want this workflow to do?",
-  placeholder: "describe your task…",
-};
-
-/** Stable single-element array for free-form workflows — avoids allocating
- *  a new `[DEFAULT_PROMPT_INPUT]` on every useMemo recomputation. */
-const DEFAULT_FIELDS: WorkflowInput[] = [DEFAULT_PROMPT_INPUT];
-
 // ─── Helpers ────────────────────────────────────
 
 const SOURCE_DISPLAY: Record<Source, string> = {
@@ -477,8 +470,7 @@ const Preview = memo(function Preview({
   wf: WorkflowWithMetadata;
 }) {
   const theme = usePickerTheme();
-  const args: readonly WorkflowInput[] =
-    wf.inputs.length > 0 ? wf.inputs : DEFAULT_FIELDS;
+  const args = normalizePickerInputs(wf.inputs);
 
   return (
     <box
@@ -690,12 +682,14 @@ function EnumContent({
 }
 
 const Field = memo(function Field({
+  id,
   field,
   value,
   focused,
   onFieldInput,
   onTextChangeRef,
 }: {
+  id?: string;
   field: WorkflowInput;
   value: string;
   focused: boolean;
@@ -719,7 +713,7 @@ const Field = memo(function Field({
   );
 
   return (
-    <box flexDirection="column">
+    <box id={id} flexDirection="column">
       <box
         border
         borderStyle="rounded"
@@ -788,7 +782,55 @@ function InputPhase({
   onTextChangeRef: React.RefObject<((value: string) => void) | null>;
 }) {
   const theme = usePickerTheme();
-  const isStructured = workflow.inputs.length > 0;
+  const isStructured = !isFreeformPromptSchema(workflow.inputs);
+  const scrollboxRef = useRef<ScrollBoxRenderable>(null);
+  const [scrollTop, setScrollTop] = useState(0);
+
+  // Auto-scroll to keep the focused field visible.
+  // Sync scrollTop immediately so the visibility check below
+  // marks the field as visible on the same render pass.
+  useEffect(() => {
+    const sb = scrollboxRef.current;
+    const field = fields[focusedFieldIdx];
+    if (!sb || !field) return;
+    sb.scrollChildIntoView(`field-${field.name}`);
+    setScrollTop(sb.scrollTop);
+  }, [focusedFieldIdx, fields]);
+
+  // Sync scrollTop on every OpenTUI render frame via renderBefore.
+  // This replaces a polling timer — it fires at the renderer's native
+  // frame rate so the focused field defocuses within one frame of
+  // scrolling out of view, preventing the terminal cursor from
+  // bleeding into the fixed header above.
+  const syncScrollFrame = useCallback(function (this: unknown) {
+    const sb = scrollboxRef.current;
+    if (!sb) return;
+    setScrollTop((prev) => {
+      const cur = sb.scrollTop;
+      return cur !== prev ? cur : prev;
+    });
+  }, []);
+
+  // The bordered content box (where the cursor lives) must be fully
+  // inside the viewport. If even one row is clipped the field loses
+  // focus so the cursor can never land in a clipped row.
+  const isFocusedFieldVisible = useMemo(() => {
+    const sb = scrollboxRef.current;
+    if (!sb) return true;
+    const vpH = sb.viewport.height;
+    if (vpH <= 0) return true;
+    let y = 0;
+    for (let i = 0; i < fields.length; i++) {
+      const f = fields[i]!;
+      const inputH = f.type === "text" ? TEXT_FIELD_LINES + 2 : 3;
+      if (i === focusedFieldIdx) {
+        return y >= scrollTop && y + inputH <= scrollTop + vpH;
+      }
+      // Caption row (1) + spacer row (1) below the bordered box.
+      y += inputH + 2;
+    }
+    return true;
+  }, [fields, focusedFieldIdx, scrollTop]);
 
   return (
     <box
@@ -839,7 +881,7 @@ function InputPhase({
       <box flexDirection="row" height={1}>
         <text>
           <span fg={theme.textDim}>
-            <strong>{isStructured ? "INPUTS" : "PROMPT"}</strong>
+            <strong>INPUTS</strong>
           </span>
         </text>
         <box flexGrow={1} />
@@ -851,20 +893,48 @@ function InputPhase({
       </box>
       <box height={1} />
 
-      {fields.map((f, i) => (
-        <Field
-          key={f.name}
-          field={f}
-          value={values[f.name] ?? ""}
-          focused={i === focusedFieldIdx}
-          onFieldInput={onFieldInput}
-          onTextChangeRef={
-            f.type === "text" && i === focusedFieldIdx
-              ? onTextChangeRef
-              : undefined
-          }
-        />
-      ))}
+      <scrollbox
+        ref={scrollboxRef}
+        scrollY
+        viewportCulling
+        flexGrow={1}
+        renderBefore={syncScrollFrame}
+        style={{
+          rootOptions: {
+            backgroundColor: "transparent",
+            border: false,
+          },
+          contentOptions: {
+            flexDirection: "column",
+          },
+          verticalScrollbarOptions: {
+            showArrows: false,
+            trackOptions: {
+              foregroundColor: theme.border,
+              backgroundColor: theme.backgroundElement,
+            },
+          },
+        }}
+      >
+        {fields.map((f, i) => {
+          const active = i === focusedFieldIdx && isFocusedFieldVisible;
+          return (
+            <Field
+              key={f.name}
+              id={`field-${f.name}`}
+              field={f}
+              value={values[f.name] ?? ""}
+              focused={active}
+              onFieldInput={onFieldInput}
+              onTextChangeRef={
+                f.type === "text" && active
+                  ? onTextChangeRef
+                  : undefined
+              }
+            />
+          );
+        })}
+      </scrollbox>
     </box>
   );
 }
@@ -1171,10 +1241,7 @@ function usePickerKeyboard(state: PickerKeyboardState): void {
       key.stopPropagation();
       const wf = focusedWfRef.current;
       if (wf) {
-        const inputs: readonly WorkflowInput[] =
-          wf.inputs.length > 0
-            ? wf.inputs
-            : DEFAULT_FIELDS;
+        const inputs = normalizePickerInputs(wf.inputs);
         const initial: Record<string, string> = {};
         for (const f of inputs) {
           initial[f.name] =
@@ -1290,9 +1357,10 @@ export function WorkflowPicker({
   const focusedWf = entries[clampedEntryIdx]?.workflow;
 
   const currentFields = useMemo<readonly WorkflowInput[]>(
-    () => focusedWf && focusedWf.inputs.length > 0
-      ? focusedWf.inputs
-      : DEFAULT_FIELDS,
+    () =>
+      focusedWf
+        ? normalizePickerInputs(focusedWf.inputs)
+        : DEFAULT_PROMPT_FIELDS,
     [focusedWf],
   );
   const currentField = currentFields[focusedFieldIdx];

package/src/sdk/runtime/discovery.ts

@@ -13,6 +13,7 @@ import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import ignore from "ignore";
 import type { AgentType, WorkflowInput } from "../types.ts";
+import { normalizePickerInputs } from "../workflow-inputs.ts";
 import { WorkflowLoader } from "./loader.ts";
 
 export interface DiscoveredWorkflow {
@@ -288,12 +289,12 @@ export async function findWorkflow(
 export interface WorkflowWithMetadata extends DiscoveredWorkflow {
   /** Workflow description, empty string when none was declared. */
   description: string;
-  /** Declared input schema, empty array for free-form workflows. */
+  /** Picker-ready input schema; free-form workflows materialize a prompt field. */
   inputs: readonly WorkflowInput[];
 }
 
 /**
- * Load metadata (description + inputs) for a batch of discovered workflows.
+ * Load metadata (description + picker-ready inputs) for a batch of discovered workflows.
  *
  * Workflows that fail to import are **skipped silently** so one broken
  * entry can never prevent the picker from rendering. Callers that need
@@ -311,7 +312,7 @@ export async function loadWorkflowsMetadata(
       return {
         ...wf,
         description: loaded.value.definition.description,
-        inputs: loaded.value.definition.inputs,
+        inputs: normalizePickerInputs(loaded.value.definition.inputs),
       };
     }),
   );
@@ -320,4 +321,3 @@ export async function loadWorkflowsMetadata(
   );
 }
 
-

package/src/sdk/workflow-inputs.ts

@@ -0,0 +1,54 @@
+import type { WorkflowInput } from "./types.ts";
+
+/** Canonical free-form prompt field used by the interactive picker. */
+export const DEFAULT_PROMPT_INPUT: Readonly<WorkflowInput> = Object.freeze({
+  name: "prompt",
+  type: "text",
+  required: true,
+  description: "what do you want this workflow to do?",
+  placeholder: "describe your task…",
+});
+
+/** Stable single-field schema for free-form workflows. */
+export const DEFAULT_PROMPT_FIELDS: readonly WorkflowInput[] = Object.freeze([
+  DEFAULT_PROMPT_INPUT,
+]);
+
+/**
+ * Materialize the picker-facing input schema.
+ *
+ * Runtime workflow definitions keep `inputs: []` for free-form workflows so
+ * the CLI can preserve positional-prompt semantics. The interactive picker,
+ * however, benefits from a single normalized shape where every workflow has at
+ * least one field to render.
+ */
+export function normalizePickerInputs(
+  inputs: readonly WorkflowInput[],
+): readonly WorkflowInput[] {
+  return inputs.length > 0 ? inputs : DEFAULT_PROMPT_FIELDS;
+}
+
+/**
+ * Whether a picker-facing schema represents the canonical free-form prompt.
+ *
+ * This accepts both the raw `[]` runtime shape and the normalized
+ * `[DEFAULT_PROMPT_INPUT]` picker shape so callers can treat both as the same
+ * conceptual "free-form prompt" mode.
+ */
+export function isFreeformPromptSchema(
+  inputs: readonly WorkflowInput[],
+): boolean {
+  if (inputs.length === 0) return true;
+  if (inputs.length !== 1) return false;
+
+  const field = inputs[0];
+  return (
+    field?.name === DEFAULT_PROMPT_INPUT.name &&
+    field.type === DEFAULT_PROMPT_INPUT.type &&
+    field.required === DEFAULT_PROMPT_INPUT.required &&
+    field.description === DEFAULT_PROMPT_INPUT.description &&
+    field.placeholder === DEFAULT_PROMPT_INPUT.placeholder &&
+    field.default === DEFAULT_PROMPT_INPUT.default &&
+    field.values === DEFAULT_PROMPT_INPUT.values
+  );
+}