Summary

• support block syntax and ordered deps in HCL loader
• introduce native HCL runtime with shell and task built-ins
• add integration and runtime tests for HCL features

Testing

• go test ./...

Prompt

🗂️ Story Card – “Native-HCL Runtime, Blocks-only Vars/Env, Array Deps, Built-ins, E2E Test”

Hand this directly to Codex. It contains requirements, expectations, and acceptance tests only — no code skeletons, no file-layout mandates (except for the single test-data directory).

📌 Goal

Deliver full HCL Taskfile support such that:

1. Block syntax only for variables and environment:

   vars { … }
   env  { … }

   Both root-level and inside each task block.

2. Dependencies are expressed as an ordered list (array) – not a map:

   deps = [
     task("build"),                 # simple reference
     task("lint", {MODE = "fast"})  # with param vars
   ]

   – The list order is respected during execution.
   – Each entry is either a bare task reference or task(name, vars) expression.

3. All interpolation uses native HCL expressions:

   echo "${upper(vars.FOO)} - ${env.PATH}"

   – Variable access is always vars.X or env.Y.

4. Runtime HCL evaluation provides built-in functions:

   Function	Purpose & Expected Behaviour
   sh(cmd)	Run /bin/sh -c cmd, return trimmed stdout
   bash(cmd)	Run /bin/bash -c cmd
   zsh(cmd)	Run /bin/zsh -c cmd
   task(name, vars?)	Execute another task synchronously, optionally overriding its vars; returns that task’s combined stdout

5. **Go-template ({{ }}) syntax is invalid inside HCL files.

🛠️ Functional Requirements & Expectations

🧪 Required Tests

Location: create internal/testdata/HCLE2ETest/ (or analogous) that is committed with the repo.

1. Taskfile.hcl in HCLE2ETest – must demonstrate:

   • Root vars { ORIGINAL = "foo" }

   • Root env { PATH_COPY = env("PATH") }

   • Task build:

     vars { VERSION = sh("echo 1.2.3") }
     cmds = ["echo BUILD:$${vars.VERSION}", "echo ONE-DONE"]

   • Task lint with var override via task():

     cmds = ["echo LINT MODE $${vars.MODE}", "echo TWO-DONE"]

   • Task all:

     deps = [
       task("build"),
       task("lint", {MODE = "fast"})
     ]
     cmds = [
       "echo FINAL $${vars.ORIGINAL}",
       "echo PATH=$${env.PATH_COPY}"
     ]

2. Integration test (TestHCLE2E):

   • Run task -t testdata/HCLE2ETest/Taskfile.hcl all.

   • Assertions (order matters):

     1. Contains BUILD:1.2.3
     2. Contains ONE-DONE before TWO-DONE
     3. Contains LINT MODE fast
     4. Contains FINAL foo
     5. Contains PATH= plus a non-empty value

3. Unit tests (examples, not code):

   • TestBlockSyntaxEnforced: file using vars = {} returns parse error.
   • TestShFunctionSuccess / TestShFunctionFail.
   • TestTaskFunctionStdoutCapture.
   • TestInvalidReference: ${FOO} raises evaluation error.
   • TestTemplateSyntaxRejected: {{ .FOO }} in HCL raises parse error.

📎 General Guidance for Codex

• Focus on satisfying behaviour & tests; internal file structure is up to you.
• Preserve existing YAML behaviour.
• Return informative diagnostics on parse/eval errors.
• Ensure go test ./... passes and prints the HCLE2ETest markers in correct order.

No further implementation details or file names are prescribed beyond the test-data directory above.

https://chatgpt.com/codex/tasks/task_e_68921dd450d08330945d7ec60c6a40aa