@techierathore/techieflow 1.0.4 → 1.1.1

package/.tfcore/utils/tf-build.sh

@@ -6,7 +6,9 @@
 #   bash .tfcore/utils/tf-build.sh [build] [<target>] [-- <extra dotnet args>]
 #   bash .tfcore/utils/tf-build.sh test  [<target>] [-- <extra dotnet args>]
 #   bash .tfcore/utils/tf-build.sh run   <project>  [-- <extra dotnet args>]
+#   bash .tfcore/utils/tf-build.sh publish <project> -- -o <dir> [-c <config>]   # tf-verify-boot.sh's
 #   bash .tfcore/utils/tf-build.sh probe                 # print the platform and the rungs, run nothing
+#   bash .tfcore/utils/tf-build.sh --print [build|test]  # print the command this repository uses, run nothing
 #
 # <target> is a .sln, .slnx or .csproj relative to the current folder (default: the one
 # solution or project found here). Output goes to tests/.artifacts/build/<UTC time>.log.
@@ -27,14 +29,28 @@
 # A workload / SDK-missing error (NETSDK1178, Microsoft.iOS/Android/MacCatalyst.Sdk, Workload ID,
 # WindowsAppSDK, command not found) means the wrong rung: the next one is tried, nothing is logged
 # as a blocker. A CS#### error means the code is wrong: the rung stays and the script exits 1.
+# A locked output file (MSB3021, MSB3027, "being used by another process") is neither: the same
+# rung waits and tries again, then says NOT-RUN naming the lock; it never falls to the next rung
+# (TF-035). On WSL a build that changes side -- a WSL rung, then a Windows one, over the same obj/,
+# in this run or since the last -- first clears obj/**/scopedcss: a Blazor build names each scoped
+# stylesheet by a hash of the path, the two sides hash differently, and the incremental target
+# kept the old names, so every page's own styles stopped applying (TfLens, 2026-09-11).
+# One build, test or publish at a time per repository: a second one waits for the first
+# (tests/.artifacts/build/.lock names who holds it). Builders side by side each rebuilt the same
+# obj/ under the others: a running app lost its stylesheet or its process, and a publish carried a
+# dll older than its own source (TF-043). A lock whose process has gone is taken over.
 set -u
+# mapfile and the other bash-4 / GNU-only spellings go through the shim (a stock Mac has bash 3.2).
+source "$(dirname "${BASH_SOURCE[0]}")/tf-portable.sh"
 
-MODE="build"; TARGET=""; EXTRA=()
+MODE="build"; TARGET=""; EXTRA=(); PRINT=0
+[[ "${1:-}" == "--print" ]] && { PRINT=1; shift; }   # print the resolved command, run nothing (TfLens TF-049)
 case "${1:-}" in
-  build|test|run|probe) MODE="$1"; shift ;;
+  build|test|run|publish|probe) MODE="$1"; shift ;;
 esac
 while [[ $# -gt 0 ]]; do
   if [[ "$1" == "--" ]]; then shift; EXTRA=("$@"); break; fi
+  if [[ "$1" == "--print" ]]; then PRINT=1; shift; continue; fi
   TARGET="$1"; shift
 done
 
@@ -48,10 +64,11 @@ elif [[ "$U" == Linux* ]]; then
   fi
 elif [[ "$U" == windows || "$U" == MINGW* || "$U" == MSYS* || "$U" == CYGWIN* ]]; then PLATFORM="windows"
 fi
+PLATFORM="${TF_BUILD_PLATFORM:-$PLATFORM}"   # the self-tests only
 
 # ---- target ---------------------------------------------------------------------------
 if [[ -z "$TARGET" && "$MODE" != "probe" ]]; then
-  mapfile -t CANDS < <(ls -1 *.slnx *.sln 2>/dev/null; ls -1 *.csproj 2>/dev/null)
+  tf_read_lines CANDS < <(ls -1 *.slnx *.sln 2>/dev/null; ls -1 *.csproj 2>/dev/null)
   if [[ ${#CANDS[@]} -eq 1 ]]; then TARGET="${CANDS[0]}"
   elif [[ ${#CANDS[@]} -gt 1 ]]; then echo "NOT-RUN more than one solution or project here; name one: ${CANDS[*]}"; exit 2
   fi
@@ -63,14 +80,14 @@ projects=()
 if [[ -n "$TARGET" ]]; then
   case "$TARGET" in
     *.csproj) projects=("$TARGET") ;;
-    *.sln)  mapfile -t projects < <(grep -oE '"[^"]+\.csproj"' "$TARGET" 2>/dev/null | tr -d '"' | tr '\\' '/') ;;
-    *.slnx) mapfile -t projects < <(grep -oE 'Path="[^"]+\.csproj"' "$TARGET" 2>/dev/null | sed 's/Path="//; s/"$//' | tr '\\' '/') ;;
+    *.sln)  tf_read_lines projects < <(grep -oE '"[^"]+\.csproj"' "$TARGET" 2>/dev/null | tr -d '"' | tr '\\' '/') ;;
+    *.slnx) tf_read_lines projects < <(grep -oE 'Path="[^"]+\.csproj"' "$TARGET" 2>/dev/null | sed 's/Path="//; s/"$//' | tr '\\' '/') ;;
   esac
   base="$(dirname "$TARGET")"
-  for p in "${projects[@]}"; do
+  for p in ${projects[@]+"${projects[@]}"}; do   # the +form: an empty array under set -u (bash 3.2)
     f="$p"; [[ -f "$f" ]] || f="$base/$p"
     [[ -f "$f" ]] || continue
-    if grep -qiE '<UseMaui>\s*true|Microsoft\.NET\.Sdk\.Maui|net[0-9.]+-(android|ios|maccatalyst|windows10)' "$f"; then maui=1; fi
+    if grep -qiE '<UseMaui>[[:space:]]*true|Microsoft\.NET\.Sdk\.Maui|net[0-9.]+-(android|ios|maccatalyst|windows10)' "$f"; then maui=1; fi
   done
 fi
 
@@ -91,17 +108,121 @@ if [[ "$MODE" == "probe" ]]; then
 fi
 [[ -z "$TARGET" && "$MODE" != "run" ]] && { echo "NOT-RUN no .sln, .slnx or .csproj here; name the target"; exit 2; }
 
+# ---- test on a solution: one test project at a time (TechieRag TF-004) ----------------------------
+# `dotnet test <solution>` runs every test project at once. On a 7.8 GB WSL machine TechieRag's local-
+# model tests took the memory while TechieRag.Tests walked folders, and a test that passes alone failed
+# with "Cannot allocate memory", twice in one day. Each test project now runs on its own, through this
+# same script, and the verdicts are merged into one line naming one joined log: FAIL if any failed
+# (naming which), else NOT-RUN if any could not run, else PASS. TF_TEST_TOGETHER=1 runs them together.
+if [[ "$MODE" == "test" && "${TF_TEST_TOGETHER:-0}" != "1" && "$TARGET" == *.sln* ]]; then
+  tests=()
+  for p in ${projects[@]+"${projects[@]}"}; do
+    f="$p"; [[ -f "$f" ]] || f="$base/$p"
+    [[ -f "$f" ]] || continue
+    grep -qiE 'Microsoft\.NET\.Test\.Sdk|<IsTestProject>[[:space:]]*true|"(xunit|xunit\.v3|NUnit|MSTest(\.TestFramework)?|TUnit)"|Include="(xunit|xunit\.v3|NUnit|MSTest|TUnit)' "$f" && tests+=("$f")
+  done
+  if [[ ${#tests[@]} -gt 1 ]]; then
+    if [[ $PRINT -eq 1 ]]; then
+      for t in "${tests[@]}"; do echo "dotnet test $t ${EXTRA[*]:-}"; done; exit 0
+    fi
+    mkdir -p tests/.artifacts/build
+    JOINED="tests/.artifacts/build/$(date -u +%Y%m%dT%H%M%SZ)-test-split-$$.log"; : > "$JOINED"
+    fails=(); notrun=(); passed=0; lines=(); pass=()
+    [[ ${#EXTRA[@]} -gt 0 ]] && pass=(-- "${EXTRA[@]}")
+    for t in "${tests[@]}"; do
+      out="$(TF_TEST_TOGETHER=1 bash "${BASH_SOURCE[0]}" test "$t" ${pass[@]+"${pass[@]}"} 2>&1)"
+      v="$(grep -m1 -E '^(PASS|FAIL|NOT-RUN)' <<<"$out")"
+      lg="$(sed -n 's/.*log \(tests\/\.artifacts\/build\/[^ ;]*\).*/\1/p' <<<"$v" | head -1)"
+      { echo "### test project: $t"; [[ -n "$lg" && -f "$lg" ]] && cat "$lg" || echo "$out"; } >> "$JOINED"
+      lines+=("  $(basename "$t" .csproj): $v")
+      case "$v" in PASS*) passed=$((passed+1)) ;; FAIL*) fails+=("$(basename "$t" .csproj)") ;; *) notrun+=("$(basename "$t" .csproj)") ;; esac
+    done
+    if [[ ${#fails[@]} -gt 0 ]]; then
+      echo "FAIL  tests failed in ${fails[*]} (${#tests[@]} test projects, each run on its own; $passed passed); log $JOINED"; rc=1
+    elif [[ ${#notrun[@]} -gt 0 ]]; then
+      echo "NOT-RUN ${notrun[*]} could not run (${#tests[@]} test projects, each run on its own; $passed passed); log $JOINED"; rc=2
+    else
+      echo "PASS  test on $PLATFORM — ${#tests[@]} test projects, each run on its own, all passed; log $JOINED"; rc=0
+    fi
+    printf '%s\n' "${lines[@]}"
+    exit $rc
+  fi
+fi
+
 # ---- the dotnet verb -------------------------------------------------------------------
 verb="$MODE"
 args=("$verb")
 [[ -n "$TARGET" ]] && args+=("$TARGET")
 [[ "$MODE" == "run" ]] && args=("run" "--project" "$TARGET")
-args+=("${EXTRA[@]}")
+args+=(${EXTRA[@]+"${EXTRA[@]}"})
+[[ $PRINT -eq 1 ]] && { echo "dotnet ${args[*]}"; exit 0; }
 
 mkdir -p tests/.artifacts/build
-LOG="tests/.artifacts/build/$(date -u +%Y%m%dT%H%M%SZ)-$MODE.log"
+LOG="tests/.artifacts/build/$(date -u +%Y%m%dT%H%M%SZ)-$MODE-$$.log"   # two builds in one second never share a log
+
+# ---- one build or browser check at a time (TF-043, TF-048): tf-lock.sh. `run` does not take it.
+source "$(dirname "${BASH_SOURCE[0]}")/tf-lock.sh"
+LOCK="$TF_LOCK"
+[[ "$MODE" != "run" ]] && tf_take_lock "$MODE"
+LOCKED='error MSB302[17]|being used by another process|Access to the path .* is denied'
+# which side of a WSL machine a rung builds on, and the project folders whose obj/ it writes
+side_of() { case "$1" in winrun|cmd.exe|powershell.exe) echo windows ;; *) echo wsl ;; esac; }
+# the projects the target builds, and every project they reference: a web head's static assets come
+# from the library it references, whose obj/ the other side may have written (AppManager TF-004)
+tf_read_lines pdirs < <(python3 - "${base:-.}" ${projects[@]+"${projects[@]}"} <<'PY'
+import os, re, sys
+base, todo, seen = sys.argv[1], [], []
+for p in sys.argv[2:]:
+    todo.append(p if os.path.isfile(p) else os.path.join(base, p))
+while todo:
+    f = os.path.normpath(todo.pop())
+    if not os.path.isfile(f) or os.path.dirname(f) in seen:
+        continue
+    seen.append(os.path.dirname(f) or ".")
+    for ref in re.findall(r'<ProjectReference\s+Include="([^"]+)"', open(f, encoding="utf-8", errors="replace").read()):
+        todo.append(os.path.join(os.path.dirname(f), ref.replace("\\", "/")))
+print("\n".join(seen))
+PY
+)
+cross_side() { # side: clear what another side built with its own paths in it, then mark this side
+  local d cleared=0
+  for d in ${pdirs[@]+"${pdirs[@]}"}; do
+    [[ -d "$d/obj" ]] || continue
+    if [[ "$(cat "$d/obj/.tf-build-side" 2>/dev/null)" != "$1" ]]; then
+      # the scoped stylesheets (TF-035) and the static web asset lists: each side writes its own absolute
+      # paths into those, and a Windows-written one (461 C:\ paths in AppManagerUI's) stopped the WSL
+      # host at startup with "The path must be absolute (Parameter 'root')" (AppManager TF-004)
+      if [[ -n "$(find "$d/obj" -type d -name scopedcss -print -quit 2>/dev/null)" || -n "$(find "$d/obj" "$d/bin" -name '*staticwebassets*.json' -print -quit 2>/dev/null)" ]]; then
+        find "$d/obj" -type d -name scopedcss -prune -exec rm -rf {} + 2>/dev/null
+        find "$d/obj" "$d/bin" -name '*staticwebassets*.json' -delete 2>/dev/null; cleared=1
+      fi
+    fi
+    echo "$1" > "$d/obj/.tf-build-side"
+  done
+  [[ $cleared -eq 1 ]] && echo "note  the scoped stylesheets and static asset lists were built on the other side of this machine; cleared so the $1 build writes them itself"
+}
 WRONG_RUNG='NETSDK1178|Microsoft\.(iOS|Android|MacCatalyst|tvOS)\.Sdk|Workload ID|not recognized|WindowsAppSDK|command not found|No such file or directory|is not recognized as an internal or external command|The term .* is not recognized|workload.*not installed|Inadequate permissions'
 
+# A Mac Catalyst build after Platforms/MacCatalyst/Info.plist (or an .entitlements file) changed: the
+# incremental build refreshed the DLLs and kept the .app's old Info.plist, so a fix that lives there
+# looked as if it had failed (Lekhak TF-026: the scene manifest was in the source and not in the
+# bundle). When such a file is newer than the bundle, that target's bin/ and obj/ are cleared first.
+mac_tfm="$(printf '%s\n' ${EXTRA[@]+"${EXTRA[@]}"} | grep -oE '^net[0-9.]+-maccatalyst[0-9.]*$' | head -1)"
+if [[ -n "$mac_tfm" && "$MODE" == build && "$TARGET" == *.csproj ]]; then
+  pd="$(dirname "$TARGET")"
+  for cfgdir in "$pd"/bin/*/"$mac_tfm"; do
+    [[ -d "$cfgdir" ]] || continue
+    plist="$(ls -t "$cfgdir"/*.app/Contents/Info.plist "$cfgdir"/*/*.app/Contents/Info.plist 2>/dev/null | head -1)"
+    [[ -n "$plist" ]] || continue
+    newer="$(find "$pd/Platforms/MacCatalyst" -maxdepth 1 \( -name '*.plist' -o -name '*.entitlements' \) -newer "$plist" 2>/dev/null | head -1)"
+    if [[ -n "$newer" ]]; then
+      cfg="$(basename "$(dirname "$cfgdir")")"
+      rm -rf "$cfgdir" "$pd/obj/$cfg/$mac_tfm"
+      echo "note  $newer is newer than the built app ($plist); cleared bin/$cfg/$mac_tfm and obj/$cfg/$mac_tfm so the bundle is built again"
+    fi
+  done
+fi
+
 tried=()
 n=0
 for r in "${rungs[@]}"; do
@@ -114,9 +235,29 @@ for r in "${rungs[@]}"; do
     powershell.exe)  cmd=(powershell.exe -Command "dotnet ${args[*]}"); label="powershell.exe dotnet" ;;
   esac
   tried+=("$label")
-  { echo "### rung $n: ${cmd[*]}"; "${cmd[@]}" 2>&1; echo "### exit $?"; } >> "$LOG" 2>&1
-  rc="$(tail -1 "$LOG" | sed 's/### exit //')"
-  seg="$(awk -v n="### rung $n:" 'index($0,n)==1{p=1} p' "$LOG")"
+  [[ "$PLATFORM" == "wsl" ]] && cross_side "$(side_of "$r")"
+  for attempt in $(seq 0 "${TF_BUILD_LOCK_RETRIES:-2}"); do
+    from=1; [[ -f "$LOG" ]] && from=$(( $(wc -l < "$LOG") + 1 ))   # the redirection itself fails on a log not yet written (TF-037)
+    { echo "### rung $n: ${cmd[*]}"; "${cmd[@]}" 2>&1; echo "### exit $?"; } >> "$LOG" 2>&1
+    rc="$(tail -1 "$LOG" | sed 's/### exit //')"
+    seg="$(tail -n +"$from" "$LOG")"      # this attempt's lines only
+    [[ "$rc" != "0" ]] && grep -qE "$LOCKED" <<<"$seg" || break
+    [[ $attempt -lt ${TF_BUILD_LOCK_RETRIES:-2} ]] && sleep "${TF_BUILD_LOCK_WAIT:-15}"
+  done
+  # A Mac Catalyst SDK names the one Xcode it was made for and refuses a newer one ("requires Xcode
+  # 26.6. The current version of Xcode is 27.0"): not the code, not the rung, so it fell through to
+  # NOT-RUN, while tf-verify-boot.sh built the same head with the check off (Lekhak TF-032). The same
+  # rung runs once more with the check off, and a note line says so before the verdict.
+  if [[ "$rc" != "0" && "$PLATFORM" == macos ]] && grep -qE 'requires Xcode [0-9.]+[.] The current version of Xcode is' <<<"$seg" \
+     && [[ " ${cmd[*]} " != *ValidateXcodeVersion* ]]; then
+    xnote="$(grep -oE 'requires Xcode [0-9.]+[.] The current version of Xcode is [0-9.]+' <<<"$seg" | head -1 | sed 's/[.]$//')"
+    echo "note  the Mac Catalyst SDK $xnote; built again with -p:ValidateXcodeVersion=false (xcode-check=off)"
+    cmd+=(-p:ValidateXcodeVersion=false)
+    from=$(( $(wc -l < "$LOG") + 1 ))
+    { echo "### rung $n, Xcode check off: ${cmd[*]}"; "${cmd[@]}" 2>&1; echo "### exit $?"; } >> "$LOG" 2>&1
+    rc="$(tail -1 "$LOG" | sed 's/### exit //')"
+    seg="$(tail -n +"$from" "$LOG")"
+  fi
   if [[ "$rc" == "0" ]]; then
     warns="$(grep -cE 'warning [A-Z]+[0-9]+' <<<"$seg" || true)"
     echo "PASS  $MODE on $PLATFORM via $label (rung $n) — $warns warning line(s); log $LOG"
@@ -127,16 +268,23 @@ for r in "${rungs[@]}"; do
   # taken for a wrong rung and reported NOT-RUN "host issue" (MISS-TechieFlow-20260906-03).
   if grep -qE 'error (CS|RZ|BL|XC|XLS)[0-9]{3,5}|error MSB[0-9]{4}: .*(does not exist|could not be found)|error NU1' <<<"$seg" && ! grep -qE "$WRONG_RUNG" <<<"$seg"; then
     errs="$(grep -cE 'error (CS|RZ|BL|XC|XLS|MSB|NU)[0-9]+' <<<"$seg" || true)"
-    first="$(grep -E 'error (CS|RZ|BL|XC|XLS|MSB|NU)[0-9]+' <<<"$seg" | head -1 | sed 's/^\s*//' | cut -c1-160)"
+    first="$(grep -E 'error (CS|RZ|BL|XC|XLS|MSB|NU)[0-9]+' <<<"$seg" | head -1 | sed 's/^[[:space:]]*//' | cut -c1-160)"
     echo "FAIL  real errors on $PLATFORM via $label (rung $n): $errs error line(s), first: $first; log $LOG"
-    grep -E 'error (CS|RZ|BL|XC|XLS|MSB|NU)[0-9]+' <<<"$seg" | sed 's/^\s*//' | sort -u | head -10
+    grep -E 'error (CS|RZ|BL|XC|XLS|MSB|NU)[0-9]+' <<<"$seg" | sed 's/^[[:space:]]*//' | sort -u | head -10
     exit 1
   fi
-  if [[ "$MODE" == "test" ]] && grep -qE 'Failed!|Failed:\s+[1-9]|Tests? failed' <<<"$seg"; then
+  if [[ "$MODE" == "test" ]] && grep -qE 'Failed!|Failed:[[:space:]]+[1-9]|Tests? failed' <<<"$seg"; then
     echo "FAIL  tests failed on $PLATFORM via $label (rung $n); log $LOG"
     grep -E 'Failed |Failed!|Error Message|Total tests|Passed!' <<<"$seg" | head -12
     exit 1
   fi
+  # a locked output file: the rung is right and the code is fine; another rung over the same obj/
+  # is exactly what broke the stylesheets (TF-035), so stop here and name the lock
+  if grep -qE "$LOCKED" <<<"$seg"; then
+    first="$(grep -E "$LOCKED" <<<"$seg" | head -1 | sed 's/^[[:space:]]*//' | cut -c1-200)"
+    echo "NOT-RUN the build output is held by a running process (still after $((${TF_BUILD_LOCK_RETRIES:-2} + 1)) tries on $label): $first. Stop that app -- bash .tfcore/utils/tf-verify-boot.sh stop --port <its port> -- and build again. Not a code error; log $LOG"
+    exit 2
+  fi
   # anything else (workload, wrong rung, tool absent): try the next rung
 done
 echo "NOT-RUN no rung could $MODE on $PLATFORM; tried: ${tried[*]}. This is a host issue, never a project blocker; log $LOG"

package/.tfcore/utils/tf-checklist-edit.py

@@ -72,8 +72,26 @@ def set_cells(path, rid, status=None, pct=None, remark=None, append_remark=None)
     return prior
 
 
-def next_id(text, prefix):
-    ids = [int(m.group(1)) for m in re.finditer(rf"REQ-{prefix}-(\d{{3}})", text)]
+def siblings(path):
+    """every checklist of the same application: docs/<App>-Checklist.md and docs/<App>-P<N>-Checklist.md"""
+    d, f = os.path.split(path)
+    m = re.match(r"^(.+?)(?:-P\d+)?-Checklist\.md$", f)
+    if not m:
+        return []
+    app = re.escape(m.group(1))
+    try:
+        names = os.listdir(d or ".")
+    except OSError:
+        return []
+    return [os.path.join(d, n) for n in sorted(names) if n != f and re.match(rf"^{app}(?:-P\d+)?-Checklist\.md$", n)]
+
+
+def next_id(text, prefix, others=()):
+    """one past the highest id of that prefix in this checklist AND every other checklist of the app:
+    counting this one alone gave REQ-UI-055 twice, once in phase 1 and once in phase 3 (Chatur TF-011)"""
+    ids = []
+    for t in (text, *(read(o) for o in others)):
+        ids += [int(m.group(1)) for m in re.finditer(rf"REQ-{prefix}-(\d{{3,}})", t)]
     return f"REQ-{prefix}-{(max(ids) + 1 if ids else 1):03d}"
 
 
@@ -81,7 +99,7 @@ def add_row(path, prefix, title, acceptance, section=None, remark=None, status="
     """append a row to the Requirements Status table and a detail entry under `section`
     (a new section at the end when it does not exist); returns the new id"""
     text = read(path)
-    rid = next_id(text, prefix)
+    rid = next_id(text, prefix, siblings(path))
     nl = "\r\n" if "\r\n" in text else "\n"
     lines = text.split(nl)
     # the table: after the last REQ row