@ainova-systems/intelligence 0.19.0 → 0.20.0

package/cli/lib/manifest.sh

@@ -156,10 +156,20 @@ target_set_enabled() {
     '
 }
 
+_QMAP_AWK="${BASH_SOURCE[0]%/*}/qmap.awk"
+
 # _qmap_read <mode> <file> <block> [key] [field] [expected-lock-version]
 # All scalar reads and strict lock records share one tokenizer. Environment
 # transport preserves literal backslashes that awk -v would interpret again.
 _qmap_read() {
+    if _qmap_memo_find "$@"; then
+        _qmap_memo_replay
+        return
+    fi
+    _qmap_read_file "$@"
+}
+
+_qmap_read_file() {
     local mode="$1" file="$2"
     if [ ! -f "$file" ] || [ ! -r "$file" ]; then
         case "$mode" in
@@ -169,7 +179,140 @@ _qmap_read() {
     fi
     QMAP_MODE="$mode" QMAP_FILE="$file" QMAP_BLOCK="${3:-}" \
         QMAP_KEY="${4:-}" QMAP_FIELD="${5:-}" QMAP_EXPECTED_VERSION="${6:-}" \
-        LC_ALL=C awk -f "${BASH_SOURCE[0]%/*}/qmap.awk" < "$file"
+        LC_ALL=C awk -f "$_QMAP_AWK" < "$file"
+}
+
+# _qmap_read_var <mode> <file> <block> [key] [field] [expected-lock-version]
+# — _qmap_read into IS_QMAP_OUT, as `$(_qmap_read ...)` would capture it, and
+# with its status. A preloaded answer costs no process: on Git Bash every
+# `$(...)` forks, which is what made a lifecycle preflight take half a second.
+# shellcheck disable=SC2034  # IS_QMAP_OUT is the return channel
+_qmap_read_var() {
+    if _qmap_memo_find "$@"; then
+        IS_QMAP_OUT="${QMAP_MEMO_OUTS[$IS_QMAP_MEMO_AT]}"
+        while [[ "$IS_QMAP_OUT" == *$'\n' ]]; do IS_QMAP_OUT="${IS_QMAP_OUT%$'\n'}"; done
+        if [ "${QMAP_MEMO_RCS[$IS_QMAP_MEMO_AT]}" -ne 0 ]; then
+            printf '%s' "${QMAP_MEMO_OUTS[$IS_QMAP_MEMO_AT]}" >&2
+            IS_QMAP_OUT=""
+        fi
+        return "${QMAP_MEMO_RCS[$IS_QMAP_MEMO_AT]}"
+    fi
+    IS_QMAP_OUT="$(_qmap_read_file "$@")"
+}
+
+# --- Reads answered once per process ------------------------------------
+# qmap_preload runs one awk over several requests and remembers each answer —
+# output or strict error, and status — under the exact request it answers.
+# Only a command that holds the project lock may preload, and anything that
+# writes a qmap document forgets every answer (qmap_memo_reset): a remembered
+# read must never outlive the bytes it was read from.
+QMAP_MEMO_KEYS=()
+QMAP_MEMO_RCS=()
+QMAP_MEMO_OUTS=()
+
+qmap_memo_reset() {
+    QMAP_MEMO_KEYS=()
+    QMAP_MEMO_RCS=()
+    QMAP_MEMO_OUTS=()
+    if declare -F manifest_view_reset >/dev/null; then manifest_view_reset; fi
+}
+
+# _qmap_memo_find <request...> — set IS_QMAP_MEMO_AT to the remembered answer.
+_qmap_memo_find() {
+    local request="${1:-}"$'\037'"${2:-}"$'\037'"${3:-}"$'\037'"${4:-}"$'\037'"${5:-}"$'\037'"${6:-}" i=0
+    while [ "$i" -lt "${#QMAP_MEMO_KEYS[@]}" ]; do
+        if [ "${QMAP_MEMO_KEYS[$i]}" = "$request" ]; then
+            IS_QMAP_MEMO_AT="$i"
+            return 0
+        fi
+        i=$((i + 1))
+    done
+    return 1
+}
+
+# Print a remembered answer exactly as the awk reader printed it.
+_qmap_memo_replay() {
+    if [ "${QMAP_MEMO_RCS[$IS_QMAP_MEMO_AT]}" -ne 0 ]; then
+        printf '%s' "${QMAP_MEMO_OUTS[$IS_QMAP_MEMO_AT]}" >&2
+        return "${QMAP_MEMO_RCS[$IS_QMAP_MEMO_AT]}"
+    fi
+    printf '%s' "${QMAP_MEMO_OUTS[$IS_QMAP_MEMO_AT]}"
+}
+
+# qmap_preload <request>... — each request is one string of _qmap_read's six
+# arguments, unit-separated. Requests for absent or empty documents are left
+# to the ordinary reader, which reports them exactly as before. A preload that
+# cannot run leaves nothing remembered; reads then take the ordinary path.
+# A caller that wants the awk pass to overlap other work uses the three steps
+# itself: qmap_preload_plan, qmap_preload_run (prints), qmap_preload_store.
+qmap_preload() {
+    local out
+    qmap_preload_plan "$@" || return 0
+    out="$(qmap_preload_run)" || return 0
+    qmap_preload_store "$out"
+}
+
+# qmap_preload_plan <request>... — QMAP_PLAN_REQUESTS, _FILES and _JOBS for the
+# requests one awk pass can answer; returns 1 when there are none.
+qmap_preload_plan() {
+    local request saved_ifs="$IFS"
+    local -a fields=()
+    QMAP_PLAN_REQUESTS=() QMAP_PLAN_FILES=() QMAP_PLAN_JOBS=""
+    for request in "$@"; do
+        IFS=$'\037'
+        set -f
+        # shellcheck disable=SC2206  # splitting on the unit separator is the point
+        fields=($request)
+        set +f
+        IFS="$saved_ifs"
+        case "${fields[1]:-}" in /*) ;; *) continue ;; esac
+        [ -f "${fields[1]}" ] && [ -r "${fields[1]}" ] && [ -s "${fields[1]}" ] || continue
+        QMAP_PLAN_FILES+=("${fields[1]}")
+        QMAP_PLAN_REQUESTS+=("$request")
+        QMAP_PLAN_JOBS="$QMAP_PLAN_JOBS${fields[0]:-}"$'\037'"${fields[2]:-}"$'\037'"${fields[3]:-}"$'\037'"${fields[4]:-}"$'\037'"${fields[5]:-}"$'\n'
+    done
+    [ "${#QMAP_PLAN_FILES[@]}" -gt 0 ]
+}
+
+# qmap_preload_run — the planned pass; a trailing `end` proves it completed.
+qmap_preload_run() {
+    QMAP_JOBS="${QMAP_PLAN_JOBS%$'\n'}" LC_ALL=C awk -f "$_QMAP_AWK" "${QMAP_PLAN_FILES[@]}" && echo end
+}
+
+# qmap_preload_store <output> — remember every planned answer, or nothing when
+# the output is not exactly one complete answer per request.
+qmap_preload_store() {
+    local header line status count raw i=0 saved_ifs="$IFS"
+    local -a lines=() rcs=() outs=()
+    IFS=$'\n'
+    set -f
+    # shellcheck disable=SC2206  # no line is empty: rows carry a ">" prefix
+    lines=($1)
+    set +f
+    IFS="$saved_ifs"
+    while [ "$i" -lt "${#lines[@]}" ]; do
+        header="${lines[i]}"
+        i=$((i + 1))
+        if [ "$header" = end ]; then
+            [ "$i" -eq "${#lines[@]}" ] && [ "${#rcs[@]}" -eq "${#QMAP_PLAN_REQUESTS[@]}" ] || return 0
+            QMAP_MEMO_KEYS+=("${QMAP_PLAN_REQUESTS[@]}")
+            QMAP_MEMO_RCS+=("${rcs[@]}")
+            QMAP_MEMO_OUTS+=("${outs[@]}")
+            return 0
+        fi
+        case "$header" in $'\036'[01]' '[0-9]*) ;; *) return 0 ;; esac
+        status="${header:1:1}" count="${header#* }"
+        raw=""
+        while [ "$count" -gt 0 ]; do
+            line="${lines[i]-}"
+            case "$line" in '>'*) ;; *) return 0 ;; esac
+            raw="$raw${line#>}"$'\n'
+            i=$((i + 1))
+            count=$((count - 1))
+        done
+        rcs+=("$status")
+        outs+=("$raw")
+    done
 }
 
 # qmap_validate_document <file> <block> — structural validation only.
@@ -191,6 +334,7 @@ qmap_value() { _qmap_read value "$1" "$2" "$3"; }
 _qmap_stage() {
     local file="$1"; shift
     local tmp="$file.cli.tmp" rc=0
+    qmap_memo_reset
     awk "$@" "$file" > "$tmp" || rc=$?
     [ "$rc" -eq 0 ] || { rm -f "$tmp"; die "internal: manifest edit refused (awk exit $rc) for $file"; }
     [ -s "$tmp" ] || { rm -f "$tmp"; die "internal: manifest edit produced an empty file for $file"; }
@@ -643,6 +787,8 @@ sources_remove_package() {
     shift 2
     [ -f "$file" ] || return 0
     tmp="$file.cli.tmp"
+    # A write to a qmap document forgets every remembered read, as _qmap_stage does.
+    qmap_memo_reset
     awk -v name="$name" -v only=" $* " "$IS_PKG_REF_AWK$IS_YAML_ITEM_AWK"'
         BEGIN { store = ".intelligence/packages/" name }
         FNR == 1 { pass++ }

package/cli/lib/qmap.awk

@@ -1,16 +1,58 @@
 # Shared tokenizer for the CLI-owned quoted-key map and scalar document shape.
 # Reader modes ignore unrelated YAML. Lock mode validates the whole document
 # before publishing rows, so a bad later entry never yields a partial result.
+#
+# One read per process: QMAP_MODE and friends describe it, the document
+# arrives on stdin, and a strict failure exits 1 with its reason on stderr.
+# Several reads per process: QMAP_JOBS holds one job per line (mode, block,
+# key, field and expected lock version, unit-separated) and each job names its
+# document as the matching file operand, so a command that needs the manifest,
+# the lock and the CLI's package descriptor parses them in a single awk start.
+# Every job then prints a header, "\036<status> <line count>", followed by that
+# many lines, each behind a ">" so none is empty: its rows, or its error. Empty
+# documents cannot be job operands (they yield no first line to start the job);
+# the caller reads those alone.
 BEGIN {
-    mode = ENVIRON["QMAP_MODE"]
-    block = ENVIRON["QMAP_BLOCK"]
-    wanted_key = ENVIRON["QMAP_KEY"]
-    wanted_field = ENVIRON["QMAP_FIELD"]
-    expected_version = ENVIRON["QMAP_EXPECTED_VERSION"]
-    source_file = ENVIRON["QMAP_FILE"]
-    strict = (mode == "lock" || mode == "validate")
     sep = sprintf("%c", 31)
     single_quote = sprintf("%c", 39)
+    multi = (ENVIRON["QMAP_JOBS"] != "")
+    if (multi) job_count = split(ENVIRON["QMAP_JOBS"], job_spec, "\n")
+    else configure(ENVIRON["QMAP_MODE"], ENVIRON["QMAP_BLOCK"], ENVIRON["QMAP_KEY"], ENVIRON["QMAP_FIELD"], ENVIRON["QMAP_EXPECTED_VERSION"], ENVIRON["QMAP_FILE"])
+}
+
+function configure(m, b, k, f, v, file) {
+    mode = m
+    block = b
+    wanted_key = k
+    wanted_field = f
+    expected_version = v
+    source_file = file
+    strict = (mode == "lock" || mode == "validate")
+    problem = ""; problem_line = 0
+    in_block = 0; package = ""
+    row_count = 0; found = 0; result = ""; block_seen = 0
+    split("", row_name); split("", row_line)
+    split("", package_seen); split("", field_seen); split("", field_value)
+    split("", top_seen); split("", top_value)
+    out_count = 0; failed = 0
+}
+
+# emit/fail keep the single-document output stream and exit status unchanged;
+# a job buffers both so its header can state them first.
+function emit(line) {
+    if (multi) out[++out_count] = line
+    else print line
+}
+
+function fail(message) {
+    if (multi) {
+        failed = 1
+        out_count = 0
+        out[++out_count] = message
+        return
+    }
+    print message > "/dev/stderr"
+    exit 1
 }
 
 function error_at(reason, line) {
@@ -104,6 +146,14 @@ function token(line,    text, colon, tail) {
     return 1
 }
 
+# A job starts at its document's first line and ends where the next begins.
+multi && FNR == 1 {
+    if (job) finish()
+    job++
+    split(job_spec[job], spec, sep)
+    configure(spec[1], spec[2], spec[3], spec[4], spec[5], FILENAME)
+}
+
 {
     sub(/\r$/, "")
     if ($0 ~ /^[ \t]*(#.*)?$/) next
@@ -114,7 +164,7 @@ function token(line,    text, colon, tail) {
                 if (kind == "field" && package != "") context = "package " package ", field " key ": "
                 else if (kind == "top") context = "field " key ": "
             }
-            error_at(context "malformed lock structure or unsupported scalar", NR)
+            error_at(context "malformed lock structure or unsupported scalar", FNR)
         }
         if ($0 ~ /^[^ #\t]/) { in_block = 0; package = "" }
         next
@@ -122,14 +172,14 @@ function token(line,    text, colon, tail) {
     if (kind == "top") {
         in_block = (key == block && empty)
         package = ""
-        if (strict && top_seen[key]++) error_at("duplicate top-level field " key, NR)
+        if (strict && top_seen[key]++) error_at("duplicate top-level field " key, FNR)
         if (!(key in top_value)) top_value[key] = value
         if (mode == "top" && key == wanted_key && !found) { result = value; found = 1 }
         if (strict) {
             if (key == block) {
                 block_seen = 1
-                if (!empty) error_at(block " must be a block map", NR)
-            } else if (empty) error_at("expected scalar for " key, NR)
+                if (!empty) error_at(block " must be a block map", FNR)
+            } else if (empty) error_at("expected scalar for " key, FNR)
         }
         next
     }
@@ -137,46 +187,55 @@ function token(line,    text, colon, tail) {
         package = key
         row_count++
         row_name[row_count] = key
-        row_line[row_count] = NR
+        row_line[row_count] = FNR
         if (strict) {
-            if (key == "") error_at("empty package key", NR)
-            if (package_seen[key]++) error_at("duplicate package " key, NR)
-            if (!empty) error_at("expected field map for " key, NR)
+            if (key == "") error_at("empty package key", FNR)
+            if (package_seen[key]++) error_at("duplicate package " key, FNR)
+            if (!empty) error_at("expected field map for " key, FNR)
         }
         if (mode == "value" && key == wanted_key && !found) { result = value; found = 1 }
         next
     }
     if (kind == "field" && in_block && package != "") {
         identity = package SUBSEP key
-        if (strict && field_seen[identity]++) error_at("duplicate field " package "." key, NR)
+        if (strict && field_seen[identity]++) error_at("duplicate field " package "." key, FNR)
         if (!(identity in field_value)) field_value[identity] = value
-        if (strict && empty) error_at("expected scalar for " package "." key, NR)
+        if (strict && empty) error_at("expected scalar for " package "." key, FNR)
         if (mode == "field" && package == wanted_key && key == wanted_field && !found) {
             result = value
             found = 1
         }
         next
     }
-    if (strict) error_at("malformed lock structure: expected top-level scalar or quoted package field", NR)
+    if (strict) error_at("malformed lock structure: expected top-level scalar or quoted package field", FNR)
 }
 
-END {
+# The end of one document: its rows or its error, through emit/fail.
+function finish(    i) {
+    finish_rows()
+    if (multi) {
+        printf "%c%d %d\n", 30, failed, out_count
+        for (i = 1; i <= out_count; i++) print ">" out[i]
+    }
+}
+
+function finish_rows(    version, count, fields, tops, i, f, name, row) {
     # Read the format header before interpreting a future body's shape. Errors
     # were retained during the single pass so header placement does not matter.
     if (mode == "lock" && top_value["lockfile_version"] != expected_version) {
         version = top_value["lockfile_version"]
-        print source_file " has unsupported or missing lockfile_version '" (version == "" ? "<missing>" : version) "' — expected " expected_version > "/dev/stderr"
-        exit 1
+        fail(source_file " has unsupported or missing lockfile_version '" (version == "" ? "<missing>" : version) "' — expected " expected_version)
+        return
     }
     if (strict && problem != "") {
-        print source_file ":" problem_line ": " problem > "/dev/stderr"
-        exit 1
+        fail(source_file ":" problem_line ": " problem)
+        return
     }
     if (strict && !block_seen) {
-        print source_file ": missing " block " block" > "/dev/stderr"
-        exit 1
+        fail(source_file ": missing " block " block")
+        return
     }
-    if (mode == "lock") print "V" sep top_value["lockfile_version"] sep top_value["engine_version"]
+    if (mode == "lock") emit("V" sep top_value["lockfile_version"] sep top_value["engine_version"])
     if (mode == "fieldrows") {
         # One row per package key, as `keys` lists them: the name, then each
         # field QMAP_FIELD names (space separated), as qmap_field decodes it.
@@ -185,22 +244,28 @@ END {
             name = row_name[i]
             row = name
             for (f = 1; f <= count; f++) row = row sep field_value[name SUBSEP fields[f]]
-            print row
+            emit(row)
         }
     } else if (mode == "rows" || mode == "lock" || mode == "keys") {
         for (i = 1; i <= row_count; i++) {
             name = row_name[i]
-            if (mode == "keys") print name
+            if (mode == "keys") emit(name)
             else {
                 row = name sep field_value[name SUBSEP "requested"] sep field_value[name SUBSEP "url"] sep field_value[name SUBSEP "path"] sep field_value[name SUBSEP "resolved"] sep field_value[name SUBSEP "sha"]
-                if (mode == "lock") print "R" sep row sep row_line[i]
-                else print row
+                if (mode == "lock") emit("R" sep row sep row_line[i])
+                else emit(row)
             }
         }
     } else if (mode == "tops") {
         # Several top-level scalars in one pass: QMAP_KEY lists them, space
         # separated; each present one prints as key<US>value.
         count = split(wanted_key, tops, " ")
-        for (i = 1; i <= count; i++) if (tops[i] in top_value) print tops[i] sep top_value[tops[i]]
-    } else if (found) print result
+        for (i = 1; i <= count; i++) if (tops[i] in top_value) emit(tops[i] sep top_value[tops[i]])
+    } else if (found) emit(result)
+}
+
+END {
+    if (multi) {
+        if (job) finish()
+    } else finish()
 }

package/cli/lib/registry.sh

@@ -61,7 +61,7 @@ resolve_package_source() {
             [ -n "$reg_url" ] || continue
             index="$(_fetch_index "${reg_url#git+}")"
             if [ -z "$index" ]; then
-                echo "  WARN: registry unreachable or missing index.yaml, skipped: $reg_url" >&2
+                echo "WARNING: registry unreachable or missing index.yaml, skipped: $reg_url" >&2
                 continue
             fi
             RES_URL="$(qmap_field "$index" "packages" "$name" "url")"