mmt-mcp 1.42.2-pre

package/dist/examples/intermediate/06_imports/test_root_import.mmt

@@ -0,0 +1,14 @@
+type: test
+title: Import test with project root path
+description: |-
+  Imports a test using the +/ project root path and calls it.
+  The +/ prefix resolves from the directory containing multimeter.mmt.
+import:
+  api_test: +/tests/test_api.mmt
+steps:
+  - call: api_test
+    id: result
+    title: Run API test (+/ project root import)
+    inputs:
+      message: from project root import
+      name: root call

package/dist/examples/intermediate/06_imports/tests/test_api.mmt

@@ -0,0 +1,30 @@
+type: test
+title: Test calling imported APIs
+description: |-
+  Imports two APIs using relative paths and calls each one.
+  Shows same-directory and subfolder relative imports.
+import:
+  echo: ../apis/echo_api.mmt
+  greet: +/apis/greet_api.mmt
+inputs:
+  message: hello imports
+  name: multimeter
+steps:
+  - call: echo
+    id: echoResult
+    title: Call echo API (relative import from parent dir)
+    inputs:
+      message: i:message
+    expect:
+      status_code: 200
+      echoed_message: <<i:message>>
+    report: all
+  - call: greet
+    id: greetResult
+    title: Call greet API (relative import from parent dir)
+    inputs:
+      name: i:name
+    expect:
+      status_code: == 200
+      greeted_name: == <<i:name>>
+    report: all

package/dist/examples/intermediate/07_simple_suite/README.md

@@ -0,0 +1,56 @@
+# Simple Suite
+
+A minimal example of `type: suite` files that run multiple tests together, demonstrating both **parallel** and **sequential** execution modes.
+
+## Structure
+
+```
+07_simple_suite/
+├── api/
+│   ├── echo_api.mmt            # API that echoes a posted message
+│   └── status_api.mmt          # API that returns server status
+├── test/
+│   ├── echo_test.mmt           # Test that calls the echo API and checks the response
+│   ├── echo_test_fail.mmt      # Test that calls the echo API and expects a failure
+│   ├── status_test.mmt         # Test that calls the status API and checks the status code
+│   └── status_test_fail.mmt    # Test that calls the status API and expects a failure
+├── suite_parallel.mmt           # Suite that runs all tests in parallel
+├── suite_sequential.mmt         # Suite that runs all tests one after another
+└── README.md
+```
+
+## Files
+
+| File | Description |
+|---|---|
+| `api/echo_api.mmt` | Posts a message and extracts the echoed value |
+| `api/status_api.mmt` | Sends a GET request and extracts the status code |
+| `test/echo_test.mmt` | Calls the echo API with an input and verifies it is echoed back |
+| `test/echo_test_fail.mmt` | Calls the echo API and expects the assertion to fail |
+| `test/status_test.mmt` | Calls the status API and verifies a 200 response |
+| `test/status_test_fail.mmt` | Calls the status API and expects the assertion to fail |
+| `suite_parallel.mmt` | Suite that runs all four tests in parallel (default behavior) |
+| `suite_sequential.mmt` | Suite that runs all four tests sequentially using `then` separators |
+
+## Parallel vs Sequential
+
+- **Parallel** (`suite_parallel.mmt`): all items are listed directly under `items` and execute at the same time.
+- **Sequential** (`suite_sequential.mmt`): tests are separated by `- then` entries, so each test waits for the previous one to finish before starting.
+
+## How to use
+
+### In VS Code
+
+1. Open `suite_parallel.mmt` or `suite_sequential.mmt`.
+2. Click **Run** to execute the suite.
+3. The panel shows the result of each test.
+
+### With the CLI
+
+```sh
+# Run tests in parallel
+npx testlight run examples/intermediate/07_simple_suite/suite_parallel.mmt
+
+# Run tests sequentially
+npx testlight run examples/intermediate/07_simple_suite/suite_sequential.mmt
+```

package/dist/examples/intermediate/07_simple_suite/api/echo_api.mmt

@@ -0,0 +1,12 @@
+type: api
+title: Echo API
+description: Posts a message and echoes it back
+inputs:
+  message: hello world
+outputs:
+  echoed_message: body.body.message
+url: https://test.mmt.dev/echo
+method: post
+format: json
+body:
+  message: i:message

package/dist/examples/intermediate/07_simple_suite/api/status_api.mmt

@@ -0,0 +1,8 @@
+type: api
+title: Status API
+description: Returns server status information
+outputs:
+  status_code: status
+  server_name: body.server
+url: https://test.mmt.dev/echo
+method: get

package/dist/examples/intermediate/07_simple_suite/suite_parallel.mmt

@@ -0,0 +1,11 @@
+type: suite
+title: Simple Suite
+description: Runs the echo and status tests together
+tags:
+  - example
+  - smoke
+items:
+  - test/echo_test.mmt
+  - test/status_test.mmt
+  - test/echo_test_fail.mmt
+  - test/status_test_fail.mmt

package/dist/examples/intermediate/07_simple_suite/suite_sequential.mmt

@@ -0,0 +1,14 @@
+type: suite
+title: Simple Suite
+description: Runs the echo and status tests together
+tags:
+  - example
+  - smoke
+items:
+  - test/echo_test.mmt
+  - then
+  - test/status_test.mmt
+  - then
+  - test/echo_test_fail.mmt
+  - then
+  - test/status_test_fail.mmt

package/dist/examples/intermediate/07_simple_suite/test/echo_test.mmt

@@ -0,0 +1,16 @@
+type: test
+title: Test echo API
+description: Calls the echo API and verifies the echoed message
+import:
+  echo: ../api/echo_api.mmt
+inputs:
+  message: hello from suite
+steps:
+  - call: echo
+    id: result
+    inputs:
+      message: i:message
+    expect:
+      echoed_message: <<i:message>>
+    report: all
+  - delay: 2s

package/dist/examples/intermediate/07_simple_suite/test/echo_test_fail.mmt

@@ -0,0 +1,15 @@
+type: test
+title: Test echo API (fail case)
+description: Calls the echo API and expects a wrong message — should fail
+import:
+  echo: ../api/echo_api.mmt
+inputs:
+  message: hello from suite
+steps:
+  - call: echo
+    id: result
+    inputs:
+      message: i:message
+    expect:
+      echoed_message: this will not match
+    report: all

package/dist/examples/intermediate/07_simple_suite/test/status_test.mmt

@@ -0,0 +1,11 @@
+type: test
+title: Test status API
+description: Calls the status API and verifies a successful response
+import:
+  status: ../api/status_api.mmt
+steps:
+  - call: status
+    id: result
+    expect:
+      status_code: 200
+    report: all

package/dist/examples/intermediate/07_simple_suite/test/status_test_fail.mmt

@@ -0,0 +1,11 @@
+type: test
+title: Test status API (fail case)
+description: Calls the status API and expects a wrong status code — should fail
+import:
+  status: ../api/status_api.mmt
+steps:
+  - call: status
+    id: result
+    expect:
+      status_code: 404
+    report: all

package/dist/examples/intermediate/08_chained_api_calls/README.md

@@ -0,0 +1,58 @@
+# Chained API Calls
+
+Shows how to **chain API calls** — the output of one call feeds into the next. Demonstrates test `outputs`, `set`, `setenv`, and inline `expect`.
+
+## Structure
+
+```
+08_chained_api_calls/
+├── api/
+│   ├── login.mmt              # POST login, outputs token + user_id
+│   └── get_profile.mmt        # POST profile lookup using token
+├── chained_test.mmt            # Test that chains login → profile
+└── README.md
+```
+
+## Files
+
+| File | Description |
+|---|---|
+| `api/login.mmt` | Sends credentials, extracts `token` and `user_id` from the response |
+| `api/get_profile.mmt` | Uses a token and user_id to fetch a profile |
+| `chained_test.mmt` | Calls login, saves `session_token` and `user_id` into test outputs, promotes `auth_token` with `setenv`, then calls get_profile |
+
+## Key concepts
+
+- **Step output chaining** — `${auth.token}` and `${auth.user_id}` read values from the `login` call result.
+- **Test outputs** — the test declares top-level `outputs` (`session_token`, `user_id`) and fills them with `set` keys `o:session_token` / `o:user_id` so later steps can read `o:…` (same as `${outputs.…}`).
+- **`setenv`** — promotes `${auth.token}` into the environment as `auth_token` so downstream APIs or tests can use `e:auth_token` or `<<e:auth_token>>`.
+- **Inline `expect`** — validates outputs directly on a `call` step without a separate `assert`/`check`. In this example it checks that `token` and `name` are not null.
+
+## Flow summary
+
+1. `login` is called with `username` and `password` inputs.
+2. The call verifies `token: != null` with inline `expect`.
+3. `set` writes `o:session_token` / `o:user_id` from `${auth.token}` / `${auth.user_id}`.
+4. `setenv` promotes the token as `auth_token`.
+5. `getProfile` is called with `o:session_token` and `o:user_id`.
+6. The second call verifies `name: != null` with inline `expect`.
+
+## How to use
+
+### In VS Code
+
+1. Open `chained_test.mmt` and click **Run**.
+2. The Log panel shows both API calls, the inline expect results, and the populated test outputs.
+
+### With the CLI
+
+```sh
+npx testlight run examples/intermediate/08_chained_api_calls/chained_test.mmt
+```
+
+Override credentials:
+
+```sh
+npx testlight run examples/intermediate/08_chained_api_calls/chained_test.mmt \
+  -e username=bob@example.com -e password=hunter2
+```

package/dist/examples/intermediate/08_chained_api_calls/api/get_profile.mmt

@@ -0,0 +1,15 @@
+type: api
+title: Get User Profile
+description: Fetches a user profile using a session token
+inputs:
+  token: placeholder
+  user_id: "1"
+outputs:
+  name: body.body.user_id
+  email: body.body.token
+url: https://test.mmt.dev/echo
+method: post
+format: json
+body:
+  token: i:token
+  user_id: i:user_id

package/dist/examples/intermediate/08_chained_api_calls/api/login.mmt

@@ -0,0 +1,17 @@
+type: api
+title: Login
+description: Authenticates a user and returns a session token
+inputs:
+  username: alice@example.com
+  password: secret123
+outputs:
+  token: body.body.token
+  user_id: body.body.user_id
+url: https://test.mmt.dev/echo
+method: post
+format: json
+body:
+  username: i:username
+  password: i:password
+  token: r:uuid
+  user_id: 1

package/dist/examples/intermediate/08_chained_api_calls/chained_test.mmt

@@ -0,0 +1,31 @@
+type: test
+title: Chained API Calls
+description: Login, capture the token, then fetch the user profile using the token
+import:
+  login: ./api/login.mmt
+  getProfile: ./api/get_profile.mmt
+inputs:
+  username: alice@example.com
+  password: secret123
+outputs:
+  session_token: ""
+  user_id: ""
+steps:
+  - call: login
+    id: auth
+    inputs:
+      username: i:username
+      password: i:password
+    expect:
+      token: != null
+  - set:
+      o:session_token: ${auth.token}
+      o:user_id: ${auth.user_id}
+  - setenv:
+      auth_token: ${auth.token}
+  - call: getProfile
+    inputs:
+      token: o:session_token
+      user_id: o:user_id
+    expect:
+      name: != null

package/dist/examples/intermediate/09_csv_data_driven_test/README.md

@@ -0,0 +1,80 @@
+# CSV Data-Driven Test
+
+Run the same API call for every row in a CSV file and check the results. This is useful for parameterized testing — define your test data in a spreadsheet-friendly format and let the test loop through it.
+
+## Files
+
+| File | Description |
+|---|---|
+| `echo_api.mmt` | API definition — POSTs a message to the echo endpoint and extracts the response |
+| `messages.csv` | CSV data file with `message` and `expected_method` columns |
+| `echo_csv_test.mmt` | Test — imports the CSV, loops over each row, calls the API, and checks the outputs |
+
+## How to use
+
+### In VS Code
+
+1. Open `echo_csv_test.mmt`.
+2. Click **Run** to execute the test.
+3. The Log panel shows a check result for every row in the CSV.
+
+### With the CLI
+
+```sh
+npx testlight run examples/intermediate/09_csv_data_driven_test/echo_csv_test.mmt
+```
+
+## How it works
+
+### 1. Define your test data in a CSV
+
+```csv
+message,expected_method
+hello world,POST
+goodbye,POST
+test 123,POST
+```
+
+- The first row is the header — each column becomes a field name on the row object.
+- Unquoted numbers are auto-coerced (`"42"` → `42`); `true`/`false` become booleans.
+- Quoted values stay as strings (e.g. `"00123"` stays `"00123"`).
+
+### 2. Import the CSV and bind it with `data`
+
+```yaml
+import:
+  messages: messages.csv
+steps:
+  - for: message of messages
+```
+
+The `data` step binds the imported CSV alias into scope so it can be used in loops and expressions.
+
+### 3. Loop with `for`
+
+```yaml
+  - for: const row of messages
+    steps:
+      - call: echo
+        inputs:
+          message: ${row.message}
+        check:
+          - echoed_message == ${row.message}
+```
+
+The `for` expression is standard JavaScript — `const row of messages` iterates over each CSV row. Inside the loop, wrap runtime variables in `${...}` — both in inputs (`message: ${row.column_name}`) and in checks (`output == ${row.column_name}`). This is because values are evaluated as JavaScript template literals, and `${...}` triggers interpolation.
+
+## Key concepts
+
+- **`import`** — imports both `.mmt` files and `.csv` files by alias.
+- **`data`** — binds an imported CSV into the runtime scope for iteration.
+- **`for`** — iterates using any valid JS expression. `const row of messages` loops over CSV rows.
+- **`check`** — inline checks that compare API outputs against values from the current CSV row.
+
+## Next steps
+
+- See [Data-driven tests](../../../docs/features/data-driven-tests.md) for the full CSV data-driven guide.
+- See [Simple Test](../../basic/02_simple_test/) for a basic test without CSV.
+- See [API Inputs & Outputs](../01_api_inputs_outputs/) for more input/output patterns.
+- See [Test docs — for/repeat](../../../docs/files/test/steps/control-flow.md#for-repeat) for the full `for`/`repeat` reference.
+- See [Test docs — data](../../../docs/files/test/steps/variables.md#data) for more on the `data` step.

package/dist/examples/intermediate/09_csv_data_driven_test/echo_api.mmt

@@ -0,0 +1,14 @@
+type: api
+title: Echo API
+description: Posts a message and echoes it back
+inputs:
+  message: hello world
+outputs:
+  echoed_message: body.body.message
+  request_method: body.method
+  status: status
+url: https://test.mmt.dev/echo
+method: post
+format: json
+body:
+  message: i:message

package/dist/examples/intermediate/09_csv_data_driven_test/echo_csv_test.mmt

@@ -0,0 +1,18 @@
+type: test
+title: Data driven echo test
+description: Loops over rows from a CSV file and calls the echo API for each message
+import:
+  echo: echo_api.mmt
+  messages: messages.csv
+steps:
+  - for: row of messages
+    steps:
+      - call: echo
+        id: result
+        title: ${row.message}
+        inputs:
+          message: ${row.message}
+        expect:
+          status: 200
+          echoed_message: ${row.message}
+          request_method: ${row.expected_method}

package/dist/examples/intermediate/10_environment_presets/README.md

@@ -0,0 +1,58 @@
+# Environment Presets
+
+Shows how to use **environment files** and **presets** to manage configuration across environments.
+
+## Structure
+
+```
+10_environment_presets/
+├── multimeter.mmt               # Project root marker + env variables + presets
+├── api/
+│   └── echo_env.mmt             # API using <<e:api_url>> and e:mode tokens
+├── test/
+│   └── preset_test.mmt          # Test using the selected preset
+└── README.md
+```
+
+## Files
+
+| File | Description |
+|---|---|
+| `multimeter.mmt` | Defines `api_url`, `mode`, and `timeout` variables with named choices, plus `runner.dev` and `runner.staging` presets |
+| `api/echo_env.mmt` | Uses `<<e:api_url>>` in the URL and `e:mode` in the body |
+| `test/preset_test.mmt` | Imports the API and runs it with the selected preset |
+
+## Key concepts
+
+- **`type: env`** — defines variables with named choices (key-value map) or allowed values (array).
+- **Presets** — named groups that select specific variable choices. `runner.dev` picks `api_url: local` and `mode: dev`.
+- **`<<e:var>>`** — inline string substitution (always a string).
+- **`e:var`** — entire-value substitution (preserves type: number, boolean, string).
+
+## How to use
+
+### In VS Code
+
+1. Open the folder in VS Code. The `multimeter.mmt` file is auto-loaded as the workspace environment.
+2. Use the **Environment** panel to pick a preset (e.g., `runner.dev`).
+3. Open `test/preset_test.mmt` and click **Run**.
+
+### With the CLI
+
+```sh
+# Use the dev preset
+npx testlight run examples/intermediate/10_environment_presets/test/preset_test.mmt \
+  --env-file examples/intermediate/10_environment_presets/multimeter.mmt \
+  --preset runner.dev
+
+# Use the staging preset
+npx testlight run examples/intermediate/10_environment_presets/test/preset_test.mmt \
+  --env-file examples/intermediate/10_environment_presets/multimeter.mmt \
+  --preset runner.staging
+
+# Override a variable explicitly
+npx testlight run examples/intermediate/10_environment_presets/test/preset_test.mmt \
+  --env-file examples/intermediate/10_environment_presets/multimeter.mmt \
+  --preset runner.dev \
+  -e mode=release
+```

package/dist/examples/intermediate/10_environment_presets/api/echo_env.mmt

@@ -0,0 +1,14 @@
+type: api
+title: Echo with Environment
+description: Calls the echo API using environment variables for the base URL
+inputs:
+  message: hello from env
+outputs:
+  echoed_message: body.body.message
+  echoed_mode: body.body.mode
+url: <<e:api_url>>/echo
+method: post
+format: json
+body:
+  message: i:message
+  mode: e:mode

package/dist/examples/intermediate/10_environment_presets/multimeter.mmt

@@ -0,0 +1,22 @@
+type: env
+variables:
+  api_url:
+    local: "https://test.mmt.dev"
+    staging: "https://test.mmt.dev"
+  mode:
+    dev: debug
+    prod: release
+  timeout:
+    - 5000
+    - 10000
+    - 30000
+presets:
+  runner:
+    dev:
+      api_url: local
+      mode: dev
+      timeout: 5000
+    staging:
+      api_url: staging
+      mode: prod
+      timeout: 10000

package/dist/examples/intermediate/10_environment_presets/test/preset_test.mmt

@@ -0,0 +1,14 @@
+type: test
+title: Environment Preset Test
+description: Tests that environment variables from presets are applied correctly
+import:
+  echoApi: ../api/echo_env.mmt
+inputs:
+  message: testing presets
+steps:
+  - call: echoApi
+    id: result
+    inputs:
+      message: i:message
+    expect:
+      echoed_message: <<i:message>>

package/dist/examples/intermediate/11_control_flow/README.md

@@ -0,0 +1,48 @@
+# Control Flow
+
+Demonstrates **if/else** branching, **repeat** (count and time-based), **delay**, and **for** loops in test flows.
+
+## Structure
+
+```
+11_control_flow/
+├── api/
+│   └── echo.mmt                 # Simple echo API
+├── if_else_test.mmt             # if/else conditional branching
+├── repeat_delay_test.mmt        # repeat (count + time) and delay
+├── for_loop_test.mmt            # for loop with index
+└── README.md
+```
+
+## Files
+
+| File | Description |
+|---|---|
+| `api/echo.mmt` | Echo API used by all tests |
+| `if_else_test.mmt` | Calls the API, branches on status code with `if`/`else` |
+| `repeat_delay_test.mmt` | Repeats a call 3 times, then repeats for 3 seconds, with `delay` pauses |
+| `for_loop_test.mmt` | Loops 3 times with a counter using `for: let i = 0; i < 3; i++` |
+
+## Key concepts
+
+- **`if` / `else`** — run nested steps conditionally. Uses the same expression syntax as `assert`/`check`.
+- **`repeat: N`** — run nested steps N times (count-based).
+- **`repeat: 3s`** — run nested steps for a duration. Supported units: `ns`, `ms`, `s`, `m`, `h`; combined values like `1h5m` and `5m3s` are also valid. Use `inf` for indefinite.
+- **`delay: 500`** — pause in milliseconds. Also supports unit/combo values like `- delay: 2s`, `- delay: 1h5m`, or `- delay: 5m3s`.
+- **`for`** — JavaScript-style loop header. Supports `for-of`, `for-in`, and classic `for` syntax.
+- `${variable}` — template literals resolve variables inside strings.
+
+## How to use
+
+### In VS Code
+
+1. Open any test file and click **Run**.
+2. Watch the Log panel — `print` statements show progress through branches, loops, and repeats.
+
+### With the CLI
+
+```sh
+npx testlight run examples/intermediate/11_control_flow/if_else_test.mmt
+npx testlight run examples/intermediate/11_control_flow/repeat_delay_test.mmt
+npx testlight run examples/intermediate/11_control_flow/for_loop_test.mmt
+```

package/dist/examples/intermediate/11_control_flow/api/echo.mmt

@@ -0,0 +1,13 @@
+type: api
+title: Echo API
+description: Simple echo API for control flow examples
+inputs:
+  message: hello
+outputs:
+  status_code: status
+  echoed: body.body.message
+url: https://test.mmt.dev/echo
+method: post
+format: json
+body:
+  message: i:message

package/dist/examples/intermediate/11_control_flow/for_loop_test.mmt

@@ -0,0 +1,15 @@
+type: test
+title: Control Flow — for loop
+description: Demonstrates for loops with index iteration and variable scoping
+import:
+  echo: ./api/echo.mmt
+steps:
+  - print: Iterating with a counter...
+  - for: let i = 0; i < 3; i++
+    steps:
+      - call: echo
+        id: iter
+        inputs:
+          message: iteration ${i}
+      - check: ${iter.status_code} == 200
+  - print: Loop completed

package/dist/examples/intermediate/11_control_flow/if_else_test.mmt

@@ -0,0 +1,19 @@
+type: test
+title: Control Flow — if/else
+description: Demonstrates conditional branching with if/else
+import:
+  echo: ./api/echo.mmt
+inputs:
+  message: hello
+steps:
+  - call: echo
+    id: result
+    inputs:
+      message: i:message
+  - if: ${result.status_code} == 200
+    steps:
+      - print: "Success — echoed: ${result.echoed}"
+      - check: ${result.echoed} == <<i:message>>
+    else:
+      - print: "Echo failed with status ${result.status_code}"
+      - assert: ${result.status_code} == 200