@ngocsangairvds/vsaf 5.4.4 → 5.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngocsangairvds/vsaf",
-  "version": "5.4.4",
+  "version": "5.4.5",
   "description": "logging step",
   "main": "packages/core/dist/index.js",
   "types": "packages/core/dist/index.d.ts",

package/workflows/sdlc/sdlc-build-headless.yaml

@@ -1,10 +1,10 @@
 name: sdlc-build-headless
-description: 'Sub-flow: headless Implement → Env Check → DevOps agent provisions env (Docker, dynamic) → Test Gate (verify only)'
+description: 'Sub-flow (Archon-style): Implement in a single loop that runs the tests IN-LOOP and finishes only when green. Toolchain provisioned once (Docker when the host lacks it). Acyclic — no on_fail back-edge.'
 provider: claude
 model: sonnet
 nodes:
   - id: impl-prereq
-    description: Implement 1/5 — enumerate test cases into a progress checklist
+    description: Implement 1/4 — enumerate test cases into a progress checklist
     model: sonnet
     workspace: false
     timeout: 600000
@@ -22,118 +22,88 @@ nodes:
 
       This checklist is the single source of truth for the implementation loop that follows.
 
-  - id: impl-loop
-    description: Implement 2/5 — TDD one test case per iteration until all are checked
+  - id: env-setup
+    description: Implement 2/4 — provision the test toolchain ONCE; expose it as run-tests.sh
     model: sonnet
+    permission_mode: bypassPermissions
     workspace: false
-    timeout: 2400000
+    timeout: 1800000
     depends_on:
       - impl-prereq
     prompt: |
-      Implement the feature by test-driven development, ONE test case per turn.
+      You are a DevOps engineer. Make this project's test suite RUNNABLE, then write ONE reusable
+      script the implementation loop will call every iteration. You may run shell commands
+      (including docker). Do NOT install anything on the host.
 
-      Source of truth: `$ARTIFACTS_DIR/impl-progress.md`.
-      Steps for THIS turn:
-      1. Read `$ARTIFACTS_DIR/impl-progress.md`. Find the FIRST unchecked `- [ ]` case.
-      2. If every case is already checked `- [x]`, output exactly `<promise>IMPL_COMPLETE</promise>`
-         and stop.
-      3. Otherwise, for that one case: write/adjust its test (RED), implement the minimal code
-         to make it pass (GREEN), keep the change scoped to this case. If a prior test is now
-         failing, fix it first.
-      4. Tick that line to `- [x]` in `$ARTIFACTS_DIR/impl-progress.md` and append a one-line
-         note of what you did.
-      5. Report the case id you completed. Do NOT emit the completion signal unless ALL cases
-         are checked.
-
-      Work on the real project files. Match the project's existing structure, language, and
-      test framework. Do only the current case — the loop will call you again for the next.
-    loop:
-      until: IMPL_COMPLETE
-      interactive: false
-      max_iterations: 40
-
-  - id: env-check
-    description: Implement 3/5 — scan the build/test toolchain and report EVERY missing item
-    workspace: false
-    depends_on:
-      - impl-loop
-    bash: |
-      echo "[vsaf] env-check: scanning build/test toolchain…"
-      MISS=$ARTIFACTS_DIR/env-missing.txt; : > "$MISS"
-      note() { echo "$1" >> "$MISS"; echo "   ✗ $1"; }
-      if [ -f pom.xml ] || [ -f mvnw ]; then
-        echo "project: Maven"
-        jv=$(grep -oE '<(java.version|maven.compiler.(target|release))>[0-9]+' pom.xml 2>/dev/null | grep -oE '[0-9]+' | head -1); jv="${jv:-17}"
-        echo "required-jdk: $jv"
-        if command -v java >/dev/null 2>&1; then
-          cur=$(java -version 2>&1 | head -1 | sed -E 's/.*version "([0-9]+).*/\1/')
-          [ "$cur" -ge "$jv" ] 2>/dev/null || note "JDK>=${jv} (host has ${cur})"
-        else note "JDK ${jv}"; fi
-        { [ -f mvnw ] && [ -f .mvn/wrapper/maven-wrapper.jar ]; } || command -v mvn >/dev/null 2>&1 || note "Maven (mvnw wrapper jar or system mvn)"
-      elif [ -f build.gradle ] || [ -f build.gradle.kts ] || [ -f gradlew ]; then
-        echo "project: Gradle"
-        command -v java >/dev/null 2>&1 || note "JDK"
-        [ -f gradlew ] || command -v gradle >/dev/null 2>&1 || note "Gradle"
-      elif [ -f package.json ]; then
-        echo "project: Node"; command -v node >/dev/null 2>&1 || note "Node.js + npm"
-      elif [ -f requirements.txt ] || [ -f pyproject.toml ]; then
-        echo "project: Python"; command -v python3 >/dev/null 2>&1 || note "Python 3"
-      else
-        echo "project: unknown (no pom/gradle/package.json/requirements)"
-      fi
-      command -v docker >/dev/null 2>&1 && echo "docker: available" || echo "docker: MISSING"
-      if [ -s "$MISS" ]; then echo "[vsaf] ── Missing environment ──"; cat "$MISS"; else echo "[vsaf] toolchain complete on host"; fi
+      1. Detect the project + required toolchain:
+         - Maven: `pom.xml`/`mvnw` (read the required JDK from `<java.version>` or
+           `<maven.compiler.target|release>`, default 17). Gradle: `build.gradle*`/`gradlew`.
+           Node: `package.json`. Python: `requirements.txt`/`pyproject.toml`.
+      2. Check what is missing on the HOST (e.g. `java -version`, `mvn -v`).
+      3. Decide dynamically:
+         - If the toolchain is present on the host: `run-tests.sh` runs the tests directly
+           (Maven `./mvnw test` or `mvn test`; Gradle `./gradlew test`; Node `npm test`;
+           Python `pytest`).
+         - If a tool is MISSING: build a Docker image with the correct toolchain
+           (e.g. `maven:3.9-eclipse-temurin-<jdk>`, `gradle:8-jdk17`, `node:20`, `python:3.11`):
+           write `.vsaf/docker/Dockerfile`, run `docker build -t vsaf-build .vsaf/docker`, and make
+           `run-tests.sh` run the tests INSIDE the container with the project bind-mounted so the
+           code stays on the host, e.g.:
+             `docker run --rm -v "$PWD":/work -w /work -v "$HOME/.m2":/root/.m2 vsaf-build <test cmd>`
+         - If Docker itself is not installed AND the host lacks the toolchain, make `run-tests.sh`
+           print a clear message and `exit 1` (do NOT try to install Docker).
+      4. Write the chosen command to `$ARTIFACTS_DIR/run-tests.sh` — a POSIX sh script that runs the
+         FULL test suite from the project root and exits with the test runner's exit code. Make it
+         self-contained and re-runnable, then `chmod +x` it.
+      5. Verify once: `sh $ARTIFACTS_DIR/run-tests.sh`. It is FINE if tests fail now (the code isn't
+         written yet) — you are only proving the toolchain runs. Report one line: host or docker,
+         and that run-tests.sh is ready.
 
-  - id: env-devops
-    description: Implement 4/5 — DevOps agent provisions the environment (Docker, dynamic) and runs the tests
+  - id: impl-loop
+    description: Implement 3/4 — TDD one case per turn; run tests IN-LOOP; finish only when GREEN
     model: sonnet
     permission_mode: bypassPermissions
     workspace: false
     timeout: 2400000
     depends_on:
-      - env-check
+      - env-setup
     prompt: |
-      You are a DevOps engineer. Your job: make this project's tests runnable and RUN them,
-      then record the result. You may run shell commands (including docker).
-
-      Toolchain scan (from env-check):
-      $env-check.output
+      Implement the feature by test-driven development. Source of truth:
+      `$ARTIFACTS_DIR/impl-progress.md`. Run the tests with `sh $ARTIFACTS_DIR/run-tests.sh`
+      (already provisioned by env-setup — it uses Docker automatically if the host lacks the
+      toolchain).
 
-      The full list of MISSING tools is in `$ARTIFACTS_DIR/env-missing.txt` (empty = nothing missing).
-
-      Decide dynamically:
-      - If `env-missing.txt` is EMPTY: just run the project's test suite on the host
-        (Maven: `./mvnw test` if the wrapper works else `mvn test`; Gradle: `./gradlew test`;
-        Node: `npm test`; Python: `pytest`). Fix a mis-set JAVA_HOME if that is all that's wrong.
-      - If tools are MISSING: do NOT install anything on the host. Instead build a Docker
-        environment with the correct toolchain and run the tests INSIDE the container with the
-        project bind-mounted so the code stays on the host, e.g.:
-          write `.vsaf/docker/Dockerfile` (FROM an image with the needed toolchain, e.g.
-          `maven:3.9-eclipse-temurin-<jdk>`, `gradle:8-jdk17`, `node:20`, `python:3.11`),
-          `docker build -t vsaf-build .vsaf/docker`, then
-          `docker run --rm -v "$PWD":/work -w /work [-v "$HOME/.m2":/root/.m2] vsaf-build <test cmd>`.
-        If Docker itself is not installed, do NOT try to install it — stop and clearly report
-        that Docker Desktop/engine must be installed.
+      Steps for THIS turn:
+      1. Read `$ARTIFACTS_DIR/impl-progress.md`. Find the FIRST unchecked `- [ ]` case.
+      2. If every case is checked `- [x]` AND the full suite is green (step 4), output exactly
+         `<promise>IMPL_COMPLETE</promise>` and stop.
+      3. For that one case: write/adjust its test (RED), implement the minimal code to make it pass
+         (GREEN). Keep the change scoped to this case.
+      4. Run `sh $ARTIFACTS_DIR/run-tests.sh 2>&1 | tee $ARTIFACTS_DIR/test-output.log`. If ANY test
+         fails (this case OR a regression in a previously-passing test), FIX it now and re-run until
+         this case passes and nothing else is broken. Never move on with a failing suite.
+      5. Tick the line to `- [x]` in `$ARTIFACTS_DIR/impl-progress.md` and append a one-line note.
 
-      When done, you MUST write the test command's numeric exit code to
-      `$ARTIFACTS_DIR/test-exit` and its full output to `$ARTIFACTS_DIR/test-output.log`.
-      Report one line: how you ran the tests (host or docker) and the exit code.
+      Work on the real project files. Match the project's existing structure, language, and test
+      framework. Do only the current case — the loop calls you again for the next. CRITICAL: NEVER
+      emit `<promise>IMPL_COMPLETE</promise>` while any test is failing; the signal means the whole
+      suite is green.
+    loop:
+      until: IMPL_COMPLETE
+      interactive: false
+      max_iterations: 40
 
   - id: test-gate
-    description: Implement 5/5 — verify the test result produced by env-devops
+    description: Implement 4/4 — final deterministic verify (runs the provisioned suite once)
     workspace: false
     depends_on:
-      - env-devops
+      - impl-loop
     bash: |
-      TEXIT=$ARTIFACTS_DIR/test-exit; TLOG=$ARTIFACTS_DIR/test-output.log
-      if [ -f "$TEXIT" ]; then
-        code=$(cat "$TEXIT" 2>/dev/null | tr -cd '0-9'); code="${code:-1}"
-        echo "[vsaf] test-gate: verifying result (exit=$code)"
-        tail -30 "$TLOG" 2>/dev/null || true
-        exit "$code"
-      fi
-      echo "[vsaf] test-gate: no prepared test result (env-devops did not record test-exit)"; exit 1
-    loop:
-      on_fail: impl-loop
-      max_retries: 3
-      inject_error: true
+      RT=$ARTIFACTS_DIR/run-tests.sh
+      LOG=$ARTIFACTS_DIR/test-output.log
+      if [ ! -f "$RT" ]; then echo "[vsaf] test-gate: run-tests.sh missing (env-setup did not run)"; exit 1; fi
+      echo "[vsaf] test-gate: final verification via run-tests.sh"
+      sh "$RT" > "$LOG" 2>&1; code=$?
+      tail -40 "$LOG" 2>/dev/null || true
+      echo "[vsaf] test-gate exit=$code"
+      exit "$code"