@eigenpal/cli 0.4.12 → 0.4.14

package/dist/skill/examples/hello-world/workflow.yaml

@@ -15,15 +15,12 @@ steps:
     with:
       inputs:
         text: '{{ input.text }}'
+      # Return-type annotation (`: { length: number; original: string }`)
+      # is mandatory and becomes this step's output schema.
       function: |
-        function script(text) {
+        function script(text: string): { length: number; original: string } {
           return { length: text.length, original: text };
         }
-      outputSchema:
-        type: object
-        properties:
-          length: { type: number }
-          original: { type: string }
 
 output:
   length: '{{ steps.echo.output.length }}'

package/dist/skill/reference/evaluators.md

@@ -109,12 +109,7 @@ one of the keys in `labels`; the harness then looks up the score.
   config:
     passThreshold: 1.0
     function: |
-      /**
-       * @param {Expected} expected the example's expected output
-       * @param {Actual} actual the workflow's actual output
-       * @returns {number} a score in [0, 1]; throws are caught and scored as 0
-       */
-      function scoreScript(expected, actual) {
+      function scoreScript(expected: Expected, actual: Actual): number {
         const a = actual.totalAmount ?? 0;
         const e = expected.totalAmount ?? 0;
         return Math.abs(a - e) <= 0.01 ? 1 : 0;
@@ -123,10 +118,11 @@ one of the keys in `labels`; the harness then looks up the score.
 
 Same WASM sandbox as `transform.script` (5s wall clock, 10 MB heap, no
 network). The YAML stores the **whole** `function scoreScript(expected,
-actual) { ... }` declaration verbatim — same text the dashboard editor
-shows. The JSDoc preamble is optional but recommended: it pulls the
-workflow's output schema into IntelliSense for `expected.…` /
-`actual.…` in the dashboard.
+actual): number { ... }` declaration verbatim, same text the dashboard
+editor shows. The `: number` return-type annotation is required and
+enforced at parse time. `Expected` / `Actual` are in-scope type aliases
+in the dashboard editor (both are the workflow's output shape); plain
+`unknown` works too if you don't want them.
 
 The signature shape is **locked**:
 
@@ -271,7 +267,7 @@ _Generated from `EvalConfigYamlSchema` in `@eigenpal/types/src/eval/evaluator-co
 
 | Field | Type | Required | Default | Description |
 | --- | --- | --- | --- | --- |
-| `function` | string | yes |  | Full JavaScript declaration of `function scoreScript(expected, actual) { ... }`. Receives `expected` (the example's expected output) and `actual` (the workflow's actual output), returns a number in [0, 1]. Throws are caught and scored as 0. |
+| `function` | string | yes |  | Full TypeScript declaration of `function scoreScript(expected, actual): number { ... }`. Receives `expected` (the example's expected output) and `actual` (the workflow's actual output), returns a number in [0, 1] (the `: number` annotation is required). The `: number` return-type annotation is required and enforced at parse time. Throws are caught and scored as 0. |
 | `timeoutMs` | integer | no | `5000` | Maximum wall-clock time the script can run before it's killed and the run is marked failed. |
 | `memoryLimitMb` | integer | no | `10` | Maximum memory the sandbox may allocate. Increase if the script processes large arrays or strings. |
 | `passThreshold` | number | no | `1` | Minimum script score this evaluator must reach for a run to pass. |

package/dist/skill/reference/step-types.md

@@ -65,15 +65,20 @@ the catalog tells you what fields it takes.
 
 `transform.script` advantages over Liquid:
 
-- Explicit `inputs:` declaration → the validator knows the data deps
-- `outputSchema:` enforces the return shape at runtime
-- Real JS — `Array.prototype.reduce`, `JSON.parse`, etc.
+- Explicit `inputs:` declaration; the validator knows the data deps
+- Typed return annotation drives downstream autocomplete + runtime validation
+- Real JS/TS (`Array.prototype.reduce`, `JSON.parse`, etc.)
 - Sandbox limits prevent infinite loops from blowing up an execution
 
-> Each entry in `inputs:` becomes a parameter of `function script(...)`
-> in declaration order. `inputs: { items, taxRate }` ⇒
-> `function script(items, taxRate) { … }`. The function must `return`
-> (or `throw`) a value.
+> The function is **TypeScript**. Each `inputs:` key becomes a parameter
+> in declaration order: `inputs: { items, taxRate }` ⇒
+> `function script(items: ..., taxRate: ...): R { ... }`. The return-type
+> annotation `R` is **required** and IS this step's output schema; there
+> is no separate `outputSchema:` field. Describe what your function
+> actually returns: downstream steps reference its fields via
+> `{{ steps.<this>.output.<field> }}`, so a too-loose annotation (e.g.
+> `unknown`) makes those references unresolvable. The function must
+> `return` (or `throw`) a value.
 
 ## Reference / output paths
 
@@ -318,21 +323,20 @@ Convert XLSX spreadsheet to JSON array of row objects for use in scripts or down
 
 #### `transform.script` — Script
 
-Execute a JavaScript function in a QuickJS sandbox. Input keys become the function's parameter list, in declaration order: `inputs: { items, taxRate }` ⇒ `function script(items, taxRate) { … }`. Must `return` (or `throw`) a value.
+Execute a TypeScript function in a QuickJS sandbox. Input keys become the function's parameter list, in declaration order, and the required `: R` return-type annotation IS this step's output schema: `inputs: { items, taxRate }` ⇒ `function script(items: …, taxRate: …): R { … }`.
 
 **Config** (in `step.with`):
 
 | Field | Type | Required | Default | Description |
 | --- | --- | --- | --- | --- |
-| `inputs` | record<string, string> | no |  | Named inputs mapped from template expressions. Keys become the function parameter list in declaration order: `inputs: { items, taxRate }` ⇒ `function script(items, taxRate) { … }`. |
-| `function` | string | no |  | JavaScript function declaration. Must be `function script(arg1, arg2, …) { … }` where the parameter list equals `Object.keys(inputs)` in declaration order. Must `return` (or `throw`) a value. |
-| `outputSchema` | record<string, unknown> | no |  | JSON Schema describing the expected return value. Used for validation and type hints. |
+| `inputs` | record<string, string> | no |  | Named inputs mapped from template expressions. Keys become the function parameter list in declaration order: `inputs: { items, taxRate }` ⇒ `function script(items: …, taxRate: …): R { … }`. |
+| `function` | string | yes |  | TypeScript function declaration. Must be `function script(args): R { … }` where the parameter list equals `Object.keys(inputs)` in order and `R` is a return type annotation. The annotation IS this step's output schema. |
 | `timeout` | number | no | `5000` | Max execution time in milliseconds (default: 5000) |
 | `memoryLimit` | number | no | `10485760` | Max memory in bytes (default: 10MB) |
 
 **Output:** `unknown`
 
-> Value returned from script (validated against outputSchema if provided)
+> Value returned from script. Validated at runtime against the JSON Schema derived from the function's return type annotation.
 
 #### `transform.text-chunker` — Text Chunker
 

package/dist/skill/reference/workflow-yaml.md

@@ -149,7 +149,9 @@ Use Liquid `{{ ... }}` for one-liners:
 | Simple math   | `{{ price \| times: quantity }}` |
 
 Anything more complex (array reduce/filter, multi-step calc, date
-arithmetic, regex) goes in `transform.script`:
+arithmetic, regex) goes in `transform.script`. The function is
+TypeScript; the return-type annotation IS this step's output schema
+(there is no separate `outputSchema:` field):
 
 ```yaml
 - name: total
@@ -159,19 +161,24 @@ arithmetic, regex) goes in `transform.script`:
       lineItems: '{{ steps.extract.output.lineItems }}'
       taxRate: '{{ input.taxRate }}'
     function: |
-      function script(lineItems, taxRate) {
+      function script(
+        lineItems: { price: number; qty: number }[],
+        taxRate: number,
+      ): { subtotal: number; tax: number; total: number } {
         const subtotal = lineItems.reduce((s, i) => s + i.price * i.qty, 0);
         const tax = subtotal * taxRate;
         return { subtotal, tax, total: subtotal + tax };
       }
-    outputSchema: # optional but recommended — runtime-validated
-      type: object
-      properties:
-        subtotal: { type: number }
-        tax: { type: number }
-        total: { type: number }
 ```
 
+The `): { subtotal: number; tax: number; total: number }` annotation is
+required and IS this step's output schema. Downstream steps autocomplete
+against it and reference its fields via `{{ steps.<this>.output.<field> }}`,
+and the worker validates the actual return value against it. Describe what
+the function really returns: a too-loose annotation like `unknown` produces
+an empty schema, which makes downstream `output.<field>` references
+unresolvable and trips "field not found" warnings.
+
 The script runs in a WASM sandbox: 5s wall clock, 10 MB heap, no network,
 no filesystem. Trips show up as `script_timeout` / `script_memory_limit`
 on the step execution.

package/dist/templates/blank/workflow.yaml

@@ -25,15 +25,13 @@ steps:
     with:
       inputs:
         text: '{{ input.text }}'
+      # The `: { length: number; original: string }` return-type annotation
+      # IS this step's output schema. Downstream steps autocomplete against
+      # it; the worker AJV-validates the return value against it at runtime.
       function: |
-        function script(text) {
+        function script(text: string): { length: number; original: string } {
           return { length: text.length, original: text };
         }
-      outputSchema:
-        type: object
-        properties:
-          length: { type: number }
-          original: { type: string }
 
 # `output` shapes the final return value. References any step's output.
 output:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eigenpal/cli",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   "keywords": [
     "eigenpal",