@ainova-systems/intelligence 0.11.0-rc.1 → 0.11.0-rc.3

package/cli/commands/registry.sh

@@ -35,6 +35,19 @@ case "$sub" in
         { [ -n "$scope" ] && [ -n "$url" ]; } || die "usage: intelligence registry add @scope <registry-repo-url>"
         case "$scope" in @*/*) die "bind a scope (@acme), not a package name" ;; @*) ;; *) die "scope must start with @" ;; esac
         require_v2
+        # Validate at bind time, not at the first `add`: a registry is a git
+        # repo holding index.yaml, and a URL pointing at anything else (a pack
+        # repo, a typo) is a mistake worth hearing about now. The binding is
+        # still written — the registry may simply not be reachable yet.
+        index="$(_fetch_index "${url#git+}")"
+        if [ -n "$index" ]; then
+            n="$(qmap_keys "$index" "packages" | grep -c . || true)"
+            echo "  index.yaml reachable — $n package(s) offered"
+        else
+            echo "  WARN: no index.yaml found at $url — 'intelligence add $scope/<name>' will fail until it has one." >&2
+            echo "        A registry is a git repo with index.yaml at its root (see the README of" >&2
+            echo "        https://github.com/ainova-systems/intelligence-registry for the format)." >&2
+        fi
         qmap_set_value "$IP_ROOT/intelligence.yaml" "registries" "$scope" "$url"
         echo "$scope -> $url"
         ;;

package/cli/commands/search.sh

@@ -0,0 +1,84 @@
+#!/bin/bash
+# intelligence search [term] — what the registries offer, and what this project
+# already has. The catalogue view `list` deliberately is not: `list` answers
+# "what does this project depend on", `search` answers "what could it".
+#
+# Sources, in resolution order (a name found earlier wins, exactly as `add`
+# resolves it): every scope bound in the manifest, then the bundled index.
+set -euo pipefail
+source "$CLI_DIR/lib/cli-common.sh"
+
+term="${1:-}"
+
+detect_project
+manifest=""
+[ "$IP_MODE" = "v2" ] && manifest="$IP_ROOT/intelligence.yaml"
+
+# State of one package name in this project: installed / declared / available.
+pkg_state() {
+    local name="$1"
+    [ -n "$manifest" ] || { printf 'available'; return 0; }
+    local declared=0 k
+    while IFS= read -r k; do
+        [ "$k" = "$name" ] && declared=1
+    done < <(qmap_keys "$manifest" "packages")
+    if [ "$declared" -eq 0 ]; then
+        printf 'available'
+    elif [ -d "$IP_ROOT/.intelligence/packages/$name" ]; then
+        printf 'installed %s' "$(qmap_field "$IP_ROOT/intelligence.lock" "packages" "$name" "resolved")"
+    else
+        printf 'declared (run install)'
+    fi
+}
+
+seen=" "
+rows=0
+emit_index() {
+    local index="$1" origin="$2" name desc state
+    [ -n "$index" ] && [ -f "$index" ] || return 0
+    while IFS= read -r name; do
+        [ -n "$name" ] || continue
+        case "$seen" in *" $name "*) continue ;; esac
+        if [ -n "$term" ]; then
+            desc="$(qmap_field "$index" "packages" "$name" "description")"
+            case "$name$desc" in
+                *"$term"*) ;;
+                *) continue ;;
+            esac
+        fi
+        seen="$seen$name "
+        desc="$(qmap_field "$index" "packages" "$name" "description")"
+        state="$(pkg_state "$name")"
+        printf '%-34s %-22s %s\n' "$name" "$state" "${desc:-$(qmap_field "$index" "packages" "$name" "url")}"
+        [ "$origin" = "bundled" ] || printf '%-34s %s\n' "" "  via $origin"
+        rows=$((rows + 1))
+    done < <(qmap_keys "$index" "packages")
+}
+
+if [ -n "$manifest" ]; then
+    while IFS= read -r scope; do
+        [ -n "$scope" ] || continue
+        url="$(qmap_value "$manifest" "registries" "$scope")"
+        [ -n "$url" ] || continue
+        index="$(_fetch_index "${url#git+}")"
+        if [ -z "$index" ]; then
+            echo "  WARN: registry for $scope is unreachable or has no index.yaml: $url" >&2
+            continue
+        fi
+        emit_index "$index" "$scope -> $url"
+    done < <(qmap_keys "$manifest" "registries")
+fi
+emit_index "$(default_index_file)" "bundled"
+
+if [ "$rows" -eq 0 ]; then
+    if [ -n "$term" ]; then
+        echo "Nothing matching '$term' in the configured registries."
+    else
+        echo "No registries hold any packages."
+    fi
+    echo "Any git repo with rules/, agents/ or skills/ is a package: intelligence add @org/repo"
+    exit 0
+fi
+
+echo ""
+echo "add one: intelligence add <name>   |   private registry: intelligence registry add @scope <repo-url>"

package/cli/intelligence

@@ -46,6 +46,7 @@ Usage: intelligence <command> [args]
   update [name]           Re-resolve version ranges and rewrite the lockfile
   upgrade                 Upgrade the project to this CLI's engine (restage + restamp)
   list                    Installed packages with requested/locked versions
+  search [term]           What the registries offer, and what this project has
   sync [target]           Render intelligence to every enabled tool (.claude, AGENTS.md, ...)
   registry <list|add|remove>  Bind a scope to a registry index
   migrate [--dry-run]     Convert a vendored (v1) setup to the CLI setup

package/cli/lib/cli-common.sh

@@ -102,7 +102,11 @@ stage_engine_content() {
     rm -rf "$store"
     mkdir -p "$store"
     local d s name skip
-    for d in rules agents docs; do
+    # `scripts` travels too: engine-shipped skills reference `<module>/scripts/…`
+    # (adapters, docs) and `<module>` resolves here, so the paths they hand an
+    # agent must exist. Running that sync.sh directly is harmless — outside CLI
+    # mode it fails closed rather than generating against the wrong layout.
+    for d in rules agents docs scripts; do
         [ -d "$IS_ENGINE_DIR/$d" ] && cp -R "$IS_ENGINE_DIR/$d" "$store/$d"
     done
     if [ -d "$IS_ENGINE_DIR/skills" ]; then

package/cli/lib/manifest.sh

@@ -134,10 +134,13 @@ qmap_set() {
             if (c > 0 && substr(line, 1, c - 1) == field) { print fieldline(); done = 1; next }
             print; next
         }
-        { print }
+        { last = $0; print }
         END {
             flush_key(); flush_block()
             if (!blockseen) {
+                # A block appended to a file that does not end blank would
+                # otherwise glue itself onto the previous section.
+                if (last != "") print ""
                 print block ":"
                 print keyline()
                 print fieldline()
@@ -159,10 +162,14 @@ qmap_set_value() {
             s = substr($0, 4); q = index(s, "\"")
             if (q > 0 && substr(s, 1, q - 1) == key) { print entry(); done = 1; next }
         }
-        { print }
+        { last = $0; print }
         END {
             if (inb && !done) { print entry(); done = 1 }
-            if (!blockseen) { print block ":"; print entry() }
+            if (!blockseen) {
+                if (last != "") print ""
+                print block ":"
+                print entry()
+            }
         }
     '
 }

package/cli/lib/semver.sh

@@ -39,9 +39,12 @@ semver_match() {
         ""|"*"|latest) return 0 ;;
     esac
     local op="" base="$range"
+    # Both strip patterns are quoted: an unquoted `~` in ${range#~} is a tilde
+    # EXPANSION (it becomes $HOME), so the prefix never strips and every
+    # `~x.y.z` range silently matches nothing.
     case "$range" in
-        "^"*) op="^"; base="${range#^}" ;;
-        "~"*) op="~"; base="${range#~}" ;;
+        "^"*) op="^"; base="${range#'^'}" ;;
+        "~"*) op="~"; base="${range#'~'}" ;;
     esac
     base="${base#v}"
     semver_is_stable "$base" || return 1

package/engine/INIT.md

@@ -2,6 +2,8 @@
 
 The sync engine is already installed in this directory's `scripts/` subfolder. Your job: analyze this codebase, ask the user targeted questions, and generate the project-specific configuration and content.
 
+> **The intelligence CLI is the recommended setup for new projects.** If `intelligence --version` works on this machine (or `npm i -g @ainova-systems/intelligence` is acceptable), prefer `intelligence init` + `intelligence add <package>` over this document — it automates what this bootstrap does by hand and adds versioned packages with a lockfile (see `docs/CLI.md`). This document remains the authoritative bootstrap for the **vendored** setup, which stays fully supported; a vendored project can convert later with `intelligence migrate`.
+
 **Execute phases sequentially. Do not skip or combine phases. Each phase has a gate — wait for it before proceeding.**
 
 ## Bootstrap: install the engine if it isn't here yet

package/engine/docs/ADAPTERS.md

@@ -110,9 +110,10 @@ The engine ships artifacts of its own — the `intelligence-authoring` rule and
 | Token | Expands to |
 |---|---|
 | `<umbrella>` | repo-relative umbrella dir (e.g. `Intelligence`) |
-| `<module>` | repo-relative engine module (e.g. `Intelligence/sync`) |
+| `<module>` | repo-relative engine module (e.g. `Intelligence/sync`; CLI setup: `.intelligence/engine`) |
+| `<sync-cmd>` | the sync invocation — vendored: `bash <module>/scripts/sync.sh`, CLI setup: `intelligence sync` (`IS_SYNC_CMD`) |
 
-Values are exported by `sync.sh` (`IS_UMBRELLA_REL`, `IS_MODULE_REL`), derived from the detected layout. Expansion covers frontmatter and body, so `paths: ["<umbrella>/**"]` reaches Claude's `paths:`, Cursor's `globs:` and Copilot's `applyTo:` carrying the project's real folder name. A file written without `finalize_output_file` ships a literal `<umbrella>` into an IDE — CI fails the build if any generated output still contains a token.
+Values are exported by `sync.sh` (`IS_UMBRELLA_REL`, `IS_MODULE_REL`; `IS_SYNC_CMD` comes from the CLI in CLI mode), derived from the detected layout. Expansion covers frontmatter and body, so `paths: ["<umbrella>/**"]` reaches Claude's `paths:`, Cursor's `globs:` and Copilot's `applyTo:` carrying the project's real folder name. A file written without `finalize_output_file` ships a literal `<umbrella>` into an IDE — CI fails the build if any generated output still contains a token.
 
 ### Cleanup Contract
 

package/engine/docs/CONVENTIONS.md

@@ -56,9 +56,10 @@ An artifact shipped *by the engine* cannot write the umbrella's name down — th
 | Token | Expands to | Example |
 |---|---|---|
 | `<umbrella>` | repo-relative umbrella dir | `Intelligence` |
-| `<module>` | repo-relative engine module | `Intelligence/sync` |
+| `<module>` | repo-relative engine module | `Intelligence/sync` (CLI setup: `.intelligence/engine`) |
+| `<sync-cmd>` | how a reader re-runs the sync | vendored: `bash Intelligence/sync/scripts/sync.sh`; CLI setup: `intelligence sync` |
 
-Expansion covers frontmatter and body alike, so `paths: ["<umbrella>/**"]` reaches Claude's `paths:`, Cursor's `globs:` and Copilot's `applyTo:` already carrying the project's real folder name. Project-authored artifacts may use the tokens too, but they have no reason to — they can simply name their own folders.
+Expansion covers frontmatter and body alike, so `paths: ["<umbrella>/**"]` reaches Claude's `paths:`, Cursor's `globs:` and Copilot's `applyTo:` already carrying the project's real folder name. Project-authored artifacts may use the tokens too, but they have no reason to — they can simply name their own folders. `<sync-cmd>` exists because "run a sync" is spelled differently per setup: engine content says the token, and `IS_SYNC_CMD` (set by the CLI) picks the spelling; unset, it reproduces the vendored command string exactly.
 
 A custom adapter belongs in the umbrella's `adapters/`, never in the module's `sync/scripts/adapters/` — the module is replaced wholesale on every update, so an adapter written there disappears at the next one. See `docs/ADAPTERS.md`.
 
@@ -401,6 +402,19 @@ Bash emits `IS_STATUS=<code> [IS_DETAIL=...]` on stdout and exits with the match
 
 **Module model.** The engine self-locates by its own path; it does not assume a folder name (`sync/` by convention). Each `<umbrella>/<module>/` is self-contained: its own `scripts/`(+`VERSION`), `skills/`, `INIT.md`, `docs/`. Modules update independently and never touch sibling modules or project content (`rules/`, `agents/`, non-meta `skills/`) nor `config.yaml` beyond the idempotent additive `sources.skills` line and the `sync_version` key.
 
+**CLI mode (0.11.0+).** The `intelligence` CLI drives the same engine from outside the repo (the npm install dir); the project arrives through an env contract honored only when `IS_CLI=1` — with every variable unset the engine behaves byte-identically to the vendored flow (CI's `legacy-golden` job asserts that):
+
+| Variable | CLI-mode value |
+|---|---|
+| `CONFIG_FILE` | `<root>/intelligence.yaml` (the root manifest) |
+| `REPO_ROOT` | project root |
+| `IS_UMBRELLA_REL` / `IS_MODULE_REL` | content dir (default `intelligence`) / `.intelligence/engine` |
+| `IS_SYNC_CMD` | `intelligence sync` (feeds the `<sync-cmd>` token) |
+| `IS_PROTECTED_DIRS` | colon-separated dirs `validate_output_path` must refuse — restores the source-tree protection a root manifest would otherwise disable |
+| `IS_SUPPRESS_CLI_NOTE` | silences the vendored-flow recommendation NOTE (stderr-only either way) |
+
+In CLI projects the `intelligence-sync` and `intelligence-update` meta-skills are not installed — `intelligence sync` / `intelligence update` replace them; the other meta-skills ship unchanged and reach outputs from `.intelligence/engine/skills`. `sync.sh` in CLI mode still never migrates: an outdated stamp exits `needs-update` and the CLI's own `upgrade` closes the gap. See `docs/CLI.md` for the full CLI surface.
+
 ## .gitignore Pattern
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ainova-systems/intelligence",
-  "version": "0.11.0-rc.1",
+  "version": "0.11.0-rc.3",
   "description": "Build, version and distribute AI agent intelligence across your organization — one CLI, versioned Intelligence Packages, and a sync engine for Claude Code, Cursor, Copilot, Codex, Pi and OpenCode.",
   "bin": {
     "intelligence": "bin/intelligence.js"

package/registry/index.yaml

@@ -6,10 +6,17 @@
 # @org/name -> https://github.com/org/name.git, content at the repo root.
 # Organizations override or extend this per scope with `intelligence registry
 # add @scope <registry-repo-url>`.
+#
+# This copy travels inside the CLI package. The same index lives at
+# https://github.com/ainova-systems/intelligence-registry and can be bound
+# explicitly (`intelligence registry add @ainova-systems <url>`) to read the
+# newest entries without waiting for a CLI release.
 packages:
   "@ainova-systems/core":
     url: "https://github.com/ainova-systems/intelligence-dev-packs.git"
     path: "packs/core"
+    description: "Engineering discipline for AI-first development: context engineering, artifact-derived status, review and diagnosis loops."
   "@ainova-systems/spec":
     url: "https://github.com/ainova-systems/intelligence-dev-packs.git"
     path: "packs/spec"
+    description: "Spec-driven delivery: specifications, decision records, sliced execution."