@ainova-systems/intelligence 0.18.1 → 0.20.0

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")"
@@ -200,25 +200,30 @@ fetch_package() {
     printf '%s' "$sha"
 }
 
-# wire_package_sources <manifest> <@scope/name> <store-rel-dir>
+# wire_package_sources <manifest> <@scope/name> <store-rel-dir> <root>
 # The provides convention: whichever of rules/agents/skills the installed
-# package has becomes a sources entry — inserted FIRST in its section, so
-# project-owned entries come later and win on same-named artifacts.
+# package has becomes a sources entry — its store path, inserted FIRST in its
+# section, so project-owned entries come later and win on same-named artifacts.
+# A section that already names that directory, in any spelling, keeps the entry
+# where it stands: the person who wrote `@scope/name/<dir>` or `<alias>:<dir>`
+# chose both the spelling and the position. Call it once `packages:` declares
+# the package and its alias, which is what resolves those spellings.
 wire_package_sources() {
-    local manifest="$1" name="$2" rel="$3" root="$4"
+    local manifest="$1" rel="$3" root="$4"
     local section
     for section in rules agents skills; do
-        if [ -d "$root/$rel/$section" ]; then
-            sources_add_entry_first "$manifest" "$section" "$rel/$section"
-        fi
+        [ -d "$root/$rel/$section" ] || continue
+        package_source_listed "$manifest" "$section" "$rel/$section" && continue
+        sources_add_entry_first "$manifest" "$section" "$rel/$section"
     done
 }
 
-# unwire_package_sources <manifest> <store-rel-dir>
+# unwire_package_sources <manifest> <@scope/name> [section...]
+# Drop the package's sources entries in every spelling (sources_remove_package):
+# every one without sections, as `package remove` does; only the named
+# sections' own directories with them, as `update` does for the directories a
+# new version no longer has. Call it while `packages:` still declares the
+# package and its alias.
 unwire_package_sources() {
-    local manifest="$1" rel="$2"
-    local section
-    for section in rules agents skills; do
-        sources_remove_entry "$manifest" "$section" "$rel/$section"
-    done
+    sources_remove_package "$@"
 }