cat <<'HELPTEXT'

exit 0

local missing=()

for cmd in curl jq; do

command -v "$cmd" &>/dev/null || missing+=("$cmd")

done

if [[ ${#missing[@]} -gt 0 ]]; then

log_fail "Missing required tools: ${missing[*]}"

echo " Install with: sudo apt-get install -y ${missing[*]}"

exit 1

fi

local method="$1" endpoint="$2"

shift 2

local url="${BRAIN_API}${endpoint}"

local -a headers=(-H "Content-Type: application/json")

if [[ -n "${PI:-}" ]]; then

headers+=(-H "Authorization: Bearer ${PI}")

fi

local response http_code body

response=$(curl -s -w "\n%{http_code}" --max-time 15 \

"${headers[@]}" -X "$method" "$@" "$url" 2>/dev/null) || {

log_fail "Network error calling $method $url"

return 1

}

http_code=$(echo "$response" | tail -1)

body=$(echo "$response" | sed '$d')

if [[ "$http_code" -ge 200 && "$http_code" -lt 300 ]]; then

echo "$body"

return 0

else

log_fail "HTTP $http_code on $method $endpoint"

echo "$body" | jq . 2>/dev/null || echo "$body"

return 1

fi

if [[ -z "${PI:-}" ]]; then

log_fail "PI environment variable not set."

echo -e " Export your bearer token first: ${BOLD}export PI=your-token${NC}"

return 1

fi

sed -E \

-e 's/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/[REDACTED_EMAIL]/g' \

-e 's/(\+?1?[-. ]?\(?[0-9]{3}\)?[-. ]?[0-9]{3}[-. ]?[0-9]{4})/[REDACTED_PHONE]/g' \

-e 's/[0-9]{3}-[0-9]{2}-[0-9]{4}/[REDACTED_SSN]/g'

local current="$1" total="$2" width=40

local pct=0 filled=0 empty=0

if (( total > 0 )); then

pct=$(( current * 100 / total ))

filled=$(( current * width / total ))

fi

empty=$(( width - filled ))

local bar_full="" bar_empty=""

for (( i=0; i<filled; i++ )); do bar_full+="█"; done

for (( i=0; i<empty; i++ )); do bar_empty+="░"; done

printf "\r ${GREEN}[%s${DIM}%s${NC}${GREEN}]${NC} %3d%% (%d/%d)" \

"$bar_full" "$bar_empty" "$pct" "$current" "$total"

log_head "Discovery Scanner"

if [[ ! -d "$DISCOVERIES_DIR" ]]; then

log_fail "Discoveries directory not found: $DISCOVERIES_DIR"

return 1

fi

local total_files=0 total_entries=0

# Associative array for domain counts

declare -A domain_counts

echo -e " ${BOLD}Scanning:${NC} ${DIM}${DISCOVERIES_DIR}${NC}\n"

printf " ${BOLD}%-45s %8s %-30s${NC}\n" "FILE" "ENTRIES" "DOMAINS"

printf " %s\n" "$(printf '%.0s-' {1..85})"

for f in "$DISCOVERIES_DIR"/*.json; do

[[ -f "$f" ]] || continue

local fname count domains_str

fname=$(basename "$f")

# Count entries (works for arrays and single objects)

count=$(jq 'if type == "array" then length else 1 end' "$f" 2>/dev/null || echo 0)

# Extract unique domains

domains_str=$(jq -r '

# Track domain counts per file

while IFS=',' read -ra doms; do

for d in "${doms[@]}"; do

d=$(echo "$d" | xargs) # trim whitespace

[[ -n "$d" ]] && domain_counts["$d"]=$(( ${domain_counts["$d"]:-0} + 1 ))

done

done <<< "$domains_str"

printf " ${CYAN}%-45s${NC} ${GREEN}%8d${NC} %s\n" "$fname" "$count" "$domains_str"

total_files=$((total_files + 1))

total_entries=$((total_entries + count))

done

printf " %s\n" "$(printf '%.0s-' {1..85})"

echo -e "\n ${BOLD}Summary:${NC}"

echo -e " Files scanned: ${GREEN}${total_files}${NC}"

echo -e " Total entries: ${GREEN}${total_entries}${NC}"

echo -e " Unique domains: ${GREEN}${#domain_counts[@]}${NC}"

if [[ ${#domain_counts[@]} -gt 0 ]]; then

echo -e "\n ${BOLD}Domain Coverage:${NC}"

# Sort domains by count descending

for domain in $(

); do

local cnt=${domain_counts[$domain]}

printf " ${BLUE}%-30s${NC} %d file(s)\n" "$domain" "$cnt"

done

fi

log_head "Brain Gap Analysis"

require_token || return 1

log_info "Querying brain exploration data from /v1/explore..."

local explore_data

explore_data=$(api_call GET "/v1/explore") || {

log_fail "Could not reach /v1/explore"

return 1

}

echo -e "\n ${BOLD}Curiosity & Novelty Landscape:${NC}\n"

# Parse the explore response - handles various response shapes

# Extract domain/novelty/curiosity tuples and display as bar chart

echo "$explore_data" | jq -r '

' 2>/dev/null | sort -t$'\t' -k2 -rn | head -20 | while IFS=$'\t' read -r domain novelty curiosity; do

# Build a visual bar proportional to novelty score

local bar_len color

bar_len=$(printf '%.0f' "$(echo "$novelty * 30" | bc -l 2>/dev/null || echo 5)")

[[ "$bar_len" -gt 30 ]] && bar_len=30

[[ "$bar_len" -lt 1 ]] && bar_len=1

local bar=""

for (( i=0; i<bar_len; i++ )); do bar+="█"; done

# Color by novelty threshold

if (( $(echo "$novelty > 0.7" | bc -l 2>/dev/null || echo 0) )); then

color="$RED"

elif (( $(echo "$novelty > 0.4" | bc -l 2>/dev/null || echo 0) )); then

color="$YELLOW"

else

color="$GREEN"

fi

printf " ${BOLD}%-25s${NC} ${color}%-30s${NC} novelty=%-6s curiosity=%s\n" \

"$domain" "$bar" "$novelty" "$curiosity"

done

echo ""

echo -e " ${BOLD}Legend:${NC}"

echo -e " ${RED}█${NC} High novelty (>0.7) = domain needs more content"

echo -e " ${YELLOW}█${NC} Medium novelty (0.4-0.7) = partially covered"

echo -e " ${GREEN}█${NC} Low novelty (<0.4) = well covered"

log_head "Batch Upload to Brain"

require_token || return 1

if $DRY_RUN; then

echo -e " ${YELLOW}*** DRY-RUN MODE -- no data will be sent ***${NC}\n"

fi

if [[ ! -d "$DISCOVERIES_DIR" ]]; then

log_fail "Discoveries directory not found: $DISCOVERIES_DIR"

return 1

fi

# Collect all entries into a temp file (one JSON object per line)

local entries_file

entries_file=$(mktemp /tmp/ruv_upload.XXXXXX)

trap "rm -f '$entries_file'" RETURN

for f in "$DISCOVERIES_DIR"/*.json; do

[[ -f "$f" ]] || continue

jq -c 'if type == "array" then .[] else . end' "$f" 2>/dev/null >> "$entries_file"

done

local total

total=$(wc -l < "$entries_file")

if [[ "$total" -eq 0 ]]; then

log_warn "No discovery entries found in $DISCOVERIES_DIR"

return 0

fi

log_info "Found $total entries to upload"

echo ""

local success=0 fail=0 skipped=0 current=0

while IFS= read -r entry; do

current=$((current + 1))

progress_bar "$current" "$total"

# Extract fields

local title content tags domain

title=$(echo "$entry" | jq -r '.title // "untitled"')

content=$(echo "$entry" | jq -r '.content // ""')

tags=$(echo "$entry" | jq -c '.tags // []')

domain=$(echo "$entry" | jq -r '.domain // "general"')

# Skip entries missing content

if [[ -z "$content" || "$content" == "null" ]]; then

skipped=$((skipped + 1))

continue

fi

# Strip PII from title and content

title=$(echo "$title" | strip_pii)

content=$(echo "$content" | strip_pii)

# In dry-run mode, skip actual upload

if $DRY_RUN; then

skipped=$((skipped + 1))

continue

fi

# Step 1: Get challenge nonce

local nonce_resp nonce

nonce_resp=$(api_call GET "/v1/challenge" 2>/dev/null) || { fail=$((fail + 1)); continue; }

nonce=$(echo "$nonce_resp" | jq -r '.nonce // .challenge // empty' 2>/dev/null)

if [[ -z "$nonce" ]]; then

fail=$((fail + 1))

continue

fi

# Step 2: Build payload with nonce

local payload

payload=$(jq -n \

# Step 3: POST to /v1/memories

if api_call POST "/v1/memories" -d "$payload" &>/dev/null; then

success=$((success + 1))

else

fail=$((fail + 1))

fi

# Brief rate-limit pause

sleep 0.3

done < "$entries_file"

echo "" # clear progress bar line

echo ""

echo -e " ${BOLD}Upload Summary:${NC}"

echo -e " Total processed: $total"

echo -e " ${GREEN}Uploaded: $success${NC}"

[[ $fail -gt 0 ]] && echo -e " ${RED}Failed: $fail${NC}"

[[ $skipped -gt 0 ]] && echo -e " ${YELLOW}Skipped: $skipped${NC}"

$DRY_RUN && echo -e " ${DIM}(dry-run -- nothing was sent)${NC}"

log_head "Training & Optimization"

require_token || return 1

# Trigger training

log_info "Triggering training via POST /v1/train..."

local train_result

train_result=$(api_call POST "/v1/train" -d '{}') || {

log_warn "Training endpoint returned an error (may still have triggered)"

}

if [[ -n "${train_result:-}" ]]; then

echo -e "\n ${BOLD}Training Response:${NC}"

echo "$train_result" | jq -r '

' 2>/dev/null || echo " $train_result"

fi

# Fetch SONA stats

echo ""

log_info "Fetching SONA stats from GET /v1/sona/stats..."

local sona_stats

sona_stats=$(api_call GET "/v1/sona/stats") || {

log_warn "Could not retrieve SONA stats"

return 0

}

echo -e "\n ${BOLD}SONA Statistics:${NC}"

echo "$sona_stats" | jq -r '

' 2>/dev/null || echo " $sona_stats"

log_head "Cross-Domain Discovery"

require_token || return 1

# Query semantic drift

log_info "Querying semantic drift via GET /v1/drift..."

local drift_data

drift_data=$(api_call GET "/v1/drift" 2>/dev/null) || true

if [[ -n "${drift_data:-}" ]]; then

echo -e "\n ${BOLD}Semantic Drift:${NC}"

echo "$drift_data" | jq -r '

' 2>/dev/null || echo "$drift_data" | jq . 2>/dev/null || echo " $drift_data"

else

log_warn "Drift endpoint unavailable"

fi

echo ""

# Query domain partitions

log_info "Querying domain partitions via GET /v1/partition..."

local partition_data

partition_data=$(api_call GET "/v1/partition" 2>/dev/null) || true

if [[ -n "${partition_data:-}" ]]; then

echo -e "\n ${BOLD}Domain Partitions:${NC}"

echo "$partition_data" | jq -r '

' 2>/dev/null || echo "$partition_data" | jq . 2>/dev/null || echo " $partition_data"

else

log_warn "Partition endpoint unavailable"

fi

# Show cross-domain insight

if [[ -n "${drift_data:-}" && -n "${partition_data:-}" ]]; then

echo ""

echo -e " ${BOLD}Insight:${NC} Domains with high drift and small partition size"

echo -e " are the best candidates for cross-domain knowledge transfer."

fi

log_head "Interactive Explorer"

require_token || return 1

echo -e " Search the brain for memories. Type ${BOLD}q${NC} to return to menu.\n"

while true; do

echo -ne " ${CYAN}search>${NC} "

read -r query || break

[[ -z "$query" ]] && continue

[[ "$query" == "q" || "$query" == "quit" || "$query" == "exit" ]] && break

# URL-encode the query

local encoded_query

encoded_query=$(printf '%s' "$query" | jq -sRr @uri 2>/dev/null || echo "$query")

local results

results=$(api_call GET "/v1/memories/search?q=${encoded_query}") || {

log_fail "Search failed"

continue

}

# Count results (handle array or wrapper object)

local count

count=$(echo "$results" | jq '

echo -e " ${GREEN}Found $count result(s)${NC}\n"

# Display results

echo "$results" | jq -r '

' 2>/dev/null || echo "$results" | jq . 2>/dev/null || echo " $results"

done

echo -e "${BOLD}${MAGENTA}"

echo " ╔═══════════════════════════════════════════════════════════╗"

echo " ║ RuVector Training Orchestrator v1.0 ║"

echo " ║ Brain API: pi.ruv.io ║"

echo " ╚═══════════════════════════════════════════════════════════╝"

echo -ne "${NC}"

if $DRY_RUN; then

echo -e " ${YELLOW}[DRY-RUN MODE ACTIVE]${NC}"

fi

if [[ -n "${PI:-}" ]]; then

echo -e " ${GREEN}API token: configured${NC}"

else

echo -e " ${YELLOW}API token: not set (export PI=your-token)${NC}"

fi

echo ""

echo -e " ${BOLD}Select a mode:${NC}\n"

echo -e " ${CYAN}1${NC} Discovery Scanner ${DIM}Scan local JSON files for entries and domains${NC}"

echo -e " ${CYAN}2${NC} Brain Gap Analysis ${DIM}Query /v1/explore for novelty gaps${NC}"

echo -e " ${CYAN}3${NC} Batch Upload ${DIM}Upload entries via /v1/memories with nonce auth${NC}"

echo -e " ${CYAN}4${NC} Training & Optimization ${DIM}POST /v1/train + GET /v1/sona/stats${NC}"

echo -e " ${CYAN}5${NC} Cross-Domain Discovery ${DIM}GET /v1/drift + /v1/partition${NC}"

echo -e " ${CYAN}6${NC} Interactive Explorer ${DIM}Search brain with /v1/memories/search${NC}"

echo -e " ${CYAN}q${NC} Quit"

echo ""

echo -ne " ${BOLD}Choice [1-6/q]:${NC} "