@bastani/atomic 0.5.12-4 → 0.5.12-5

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

@@ -43,11 +43,6 @@ 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 ──────────────────────────────────────
@@ -470,7 +465,7 @@ const Preview = memo(function Preview({
   wf: WorkflowWithMetadata;
 }) {
   const theme = usePickerTheme();
-  const args = normalizePickerInputs(wf.inputs);
+  const args = wf.inputs;
 
   return (
     <box
@@ -504,13 +499,16 @@ const Preview = memo(function Preview({
         </span>
       </text>
 
-      <box height={2} />
-
-      <SectionLabel label="ARGUMENTS" />
-      <box height={1} />
-      {args.map((f) => (
-        <ArgumentRow key={f.name} field={f} />
-      ))}
+      {args.length > 0 && (
+        <>
+          <box height={2} />
+          <SectionLabel label="ARGUMENTS" />
+          <box height={1} />
+          {args.map((f) => (
+            <ArgumentRow key={f.name} field={f} />
+          ))}
+        </>
+      )}
     </box>
   );
 });
@@ -643,7 +641,7 @@ function EnumContent({
   selected,
   focused,
 }: {
-  values: string[];
+  values: readonly string[];
   selected: string;
   focused: boolean;
 }) {
@@ -782,7 +780,7 @@ function InputPhase({
   onTextChangeRef: React.RefObject<((value: string) => void) | null>;
 }) {
   const theme = usePickerTheme();
-  const isStructured = !isFreeformPromptSchema(workflow.inputs);
+  const isStructured = workflow.inputs.length > 0;
   const scrollboxRef = useRef<ScrollBoxRenderable>(null);
   const [scrollTop, setScrollTop] = useState(0);
 
@@ -1241,9 +1239,8 @@ function usePickerKeyboard(state: PickerKeyboardState): void {
       key.stopPropagation();
       const wf = focusedWfRef.current;
       if (wf) {
-        const inputs = normalizePickerInputs(wf.inputs);
         const initial: Record<string, string> = {};
-        for (const f of inputs) {
+        for (const f of wf.inputs) {
           initial[f.name] =
             f.default ??
             (f.type === "enum" ? (f.values?.[0] ?? "") : "");
@@ -1357,10 +1354,7 @@ export function WorkflowPicker({
   const focusedWf = entries[clampedEntryIdx]?.workflow;
 
   const currentFields = useMemo<readonly WorkflowInput[]>(
-    () =>
-      focusedWf
-        ? normalizePickerInputs(focusedWf.inputs)
-        : DEFAULT_PROMPT_FIELDS,
+    () => focusedWf?.inputs ?? [],
     [focusedWf],
   );
   const currentField = currentFields[focusedFieldIdx];

package/src/sdk/define-workflow.test.ts

@@ -170,3 +170,61 @@ describe("WorkflowBuilder.compile()", () => {
     expect(() => builder.compile()).toThrow("has no run callback");
   });
 });
+
+describe("WorkflowBuilder.for()", () => {
+  test("returns the same builder instance (type-only narrowing)", () => {
+    const builder = defineWorkflow({ name: "test" });
+    const narrowed = builder.for<"copilot">();
+    // Same instance — .for() only changes the TypeScript type, not the value
+    expect(narrowed === (builder as unknown)).toBe(true);
+  });
+
+  test("chains with run and compile", () => {
+    const def = defineWorkflow({
+      name: "test",
+      inputs: [{ name: "greeting", type: "string" }],
+    })
+      .for<"copilot">()
+      .run(async () => {})
+      .compile();
+    expect(def.__brand).toBe("WorkflowDefinition");
+    expect(def.inputs[0]?.name).toBe("greeting");
+  });
+});
+
+describe("typed inputs (compile-time)", () => {
+  test("structured inputs restrict ctx.inputs keys", () => {
+    // This test validates that the type system correctly narrows
+    // ctx.inputs to only declared field names. The assertions below
+    // are runtime no-ops — the real check is that tsc compiles this
+    // file without errors (or produces errors only where expected).
+    defineWorkflow({
+      name: "typed-test",
+      inputs: [
+        { name: "greeting", type: "string", required: true },
+        { name: "style", type: "enum", values: ["formal", "casual"] },
+      ],
+    })
+      .for<"copilot">()
+      .run(async (ctx) => {
+        // Declared keys are valid
+        const _g: string | undefined = ctx.inputs.greeting;
+        const _s: string | undefined = ctx.inputs.style;
+        // Undeclared key — would be a compile error without @ts-expect-error
+        // @ts-expect-error — "prompt" is not a declared input
+        ctx.inputs.prompt;
+        expect(true).toBe(true);
+      })
+      .compile();
+  });
+
+  test("free-form workflows allow any key", () => {
+    defineWorkflow({ name: "freeform-test" })
+      .for<"copilot">()
+      .run(async (ctx) => {
+        const _p: string | undefined = ctx.inputs.prompt;
+        expect(true).toBe(true);
+      })
+      .compile();
+  });
+});

package/src/sdk/define-workflow.ts

@@ -2,7 +2,8 @@
  * Workflow Builder — defines a workflow with a single `.run()` entry point.
  *
  * Usage:
- *   defineWorkflow<"copilot">({ name: "my-workflow", description: "..." })
+ *   defineWorkflow({ name: "my-workflow", inputs: [...] })
+ *     .for<"copilot">()
  *     .run(async (ctx) => {
  *       await ctx.stage({ name: "research" }, {}, {}, async (s) => { ... });
  *       await ctx.stage({ name: "plan" }, {}, {}, async (s) => { ... });
@@ -58,16 +59,42 @@ function validateWorkflowInput(input: WorkflowInput, workflowName: string): void
  * Chainable workflow builder. Records the run callback,
  * then .compile() seals it into a WorkflowDefinition.
  */
-export class WorkflowBuilder<A extends AgentType = AgentType> {
+export class WorkflowBuilder<A extends AgentType = AgentType, N extends string = string> {
   /** @internal Brand for detection across package boundaries */
   readonly __brand = "WorkflowBuilder" as const;
   private readonly options: WorkflowOptions;
-  private runFn: ((ctx: WorkflowContext<A>) => Promise<void>) | null = null;
+  private runFn: ((ctx: WorkflowContext<A, N>) => Promise<void>) | null = null;
 
   constructor(options: WorkflowOptions) {
     this.options = options;
   }
 
+  /**
+   * Narrow the agent type for this workflow while preserving typed inputs.
+   *
+   * Use `.for<"copilot">()` **before** `.run()` instead of passing the
+   * agent as a type parameter to `defineWorkflow`. This allows TypeScript
+   * to infer input names from the `inputs` array AND narrow the agent
+   * type for `stage()` callbacks.
+   *
+   * @example
+   * ```typescript
+   * defineWorkflow({
+   *   name: "my-workflow",
+   *   inputs: [{ name: "greeting", type: "string" }],
+   * })
+   *   .for<"copilot">()
+   *   .run(async (ctx) => {
+   *     ctx.inputs.greeting; // ✓ typed
+   *     ctx.inputs.prompt;   // ✗ compile error
+   *   })
+   *   .compile();
+   * ```
+   */
+  for<B extends AgentType>(): WorkflowBuilder<B, N> {
+    return this as unknown as WorkflowBuilder<B, N>;
+  }
+
   /**
    * Set the workflow's entry point.
    *
@@ -76,7 +103,7 @@ export class WorkflowBuilder<A extends AgentType = AgentType> {
    * reading completed session outputs. Use native TypeScript control flow
    * (loops, conditionals, `Promise.all()`) for orchestration.
    */
-  run(fn: (ctx: WorkflowContext<A>) => Promise<void>): this {
+  run(fn: (ctx: WorkflowContext<A, N>) => Promise<void>): this {
     if (this.runFn) {
       throw new Error("run() can only be called once per workflow.");
     }
@@ -93,7 +120,7 @@ export class WorkflowBuilder<A extends AgentType = AgentType> {
    * After calling compile(), the returned object is consumed by the
    * Atomic CLI runtime.
    */
-  compile(): WorkflowDefinition<A> {
+  compile(): WorkflowDefinition<A, N> {
     if (!this.runFn) {
       throw new Error(
         `Workflow "${this.options.name}" has no run callback. ` +
@@ -133,45 +160,36 @@ export class WorkflowBuilder<A extends AgentType = AgentType> {
 /**
  * Entry point for defining a workflow.
  *
- * Pass a type parameter to narrow all context types to a specific agent:
+ * Write the `inputs` array inline so TypeScript infers literal field
+ * names and enforces them on `ctx.inputs`. Use `.for<Agent>()` to
+ * narrow the agent type while keeping typed inputs:
  *
  * @example
  * ```typescript
  * import { defineWorkflow } from "@bastani/atomic/workflows";
  *
- * export default defineWorkflow<"copilot">({
+ * export default defineWorkflow({
  *   name: "hello",
  *   description: "Two-session demo",
+ *   inputs: [
+ *     { name: "greeting", type: "string", required: true },
+ *   ],
  * })
+ *   .for<"copilot">()
  *   .run(async (ctx) => {
- *     const describe = await ctx.stage(
- *       { name: "describe" },
- *       {},
- *       {},
- *       async (s) => {
- *         // s.client: CopilotClient, s.session: CopilotSession
- *         await s.session.send({ prompt: s.inputs.prompt ?? "" });
- *         s.save(await s.session.getMessages());
- *       },
- *     );
- *     await ctx.stage(
- *       { name: "summarize" },
- *       {},
- *       {},
- *       async (s) => {
- *         const research = await s.transcript(describe);
- *         // ...
- *       },
- *     );
+ *     ctx.inputs.greeting; // ✓ string | undefined
+ *     ctx.inputs.prompt;   // ✗ compile error — not declared
  *   })
  *   .compile();
  * ```
  */
-export function defineWorkflow<A extends AgentType = AgentType>(
-  options: WorkflowOptions,
-): WorkflowBuilder<A> {
+export function defineWorkflow<
+  const I extends readonly WorkflowInput[] = readonly WorkflowInput[],
+>(
+  options: WorkflowOptions<I>,
+): WorkflowBuilder<AgentType, I[number]["name"]> {
   if (!options.name || options.name.trim() === "") {
     throw new Error("Workflow name is required.");
   }
-  return new WorkflowBuilder<A>(options);
+  return new WorkflowBuilder<AgentType, I[number]["name"]>(options);
 }