318 lines
12 KiB
Bash
Executable File
318 lines
12 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# RuVector Intelligence Statusline
|
|
# Multi-line display showcasing self-learning capabilities
|
|
|
|
INPUT=$(cat)
|
|
MODEL=$(echo "$INPUT" | jq -r '.model.display_name // "Claude"')
|
|
CWD=$(echo "$INPUT" | jq -r '.workspace.current_dir // .cwd')
|
|
DIR=$(basename "$CWD")
|
|
|
|
# Get git branch
|
|
BRANCH=$(cd "$CWD" 2>/dev/null && git branch --show-current 2>/dev/null)
|
|
|
|
# Colors
|
|
RESET="\033[0m"
|
|
BOLD="\033[1m"
|
|
CYAN="\033[36m"
|
|
YELLOW="\033[33m"
|
|
GREEN="\033[32m"
|
|
MAGENTA="\033[35m"
|
|
BLUE="\033[34m"
|
|
RED="\033[31m"
|
|
DIM="\033[2m"
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# LINE 1: Model, Directory, Git
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
printf "${BOLD}${MODEL}${RESET} in ${CYAN}${DIR}${RESET}"
|
|
[ -n "$BRANCH" ] && printf " on ${YELLOW}⎇ ${BRANCH}${RESET}"
|
|
echo
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# LINE 2: RuVector Intelligence Stats
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# Check multiple locations for intelligence file
|
|
INTEL_FILE=""
|
|
for INTEL_PATH in "$CWD/.ruvector/intelligence.json" \
|
|
"$CWD/npm/packages/ruvector/.ruvector/intelligence.json" \
|
|
"$HOME/.ruvector/intelligence.json"; do
|
|
if [ -f "$INTEL_PATH" ]; then
|
|
INTEL_FILE="$INTEL_PATH"
|
|
break
|
|
fi
|
|
done
|
|
|
|
if [ -n "$INTEL_FILE" ]; then
|
|
# Extract learning metrics
|
|
INTEL=$(cat "$INTEL_FILE" 2>/dev/null)
|
|
|
|
# Detect schema version (v2 has .learning.qTables, v1 has .patterns)
|
|
HAS_LEARNING=$(echo "$INTEL" | jq -r 'has("learning")' 2>/dev/null)
|
|
|
|
if [ "$HAS_LEARNING" = "true" ]; then
|
|
# v2 Schema: Multi-algorithm learning engine
|
|
PATTERN_COUNT=$(echo "$INTEL" | jq -r '[.learning.qTables // {} | to_entries[].value | to_entries | length] | add // 0' 2>/dev/null)
|
|
ACTIVE_ALGOS=$(echo "$INTEL" | jq -r '[.learning.stats // {} | to_entries[] | select(.value.updates > 0)] | length' 2>/dev/null)
|
|
TOTAL_ALGOS=$(echo "$INTEL" | jq -r '[.learning.stats // {} | keys] | length' 2>/dev/null)
|
|
BEST_ALGO=$(echo "$INTEL" | jq -r '
|
|
.learning.stats // {} | to_entries
|
|
| map(select(.value.updates > 0))
|
|
| sort_by(-.value.convergenceScore)
|
|
| .[0].key // "none"
|
|
' 2>/dev/null)
|
|
BEST_SCORE=$(echo "$INTEL" | jq -r ".learning.stats.\"$BEST_ALGO\".convergenceScore // 0" 2>/dev/null | awk '{printf "%.0f", $1 * 100}')
|
|
TOTAL_UPDATES=$(echo "$INTEL" | jq -r '[.learning.stats // {} | to_entries[].value.updates] | add // 0' 2>/dev/null)
|
|
MEMORY_COUNT=$(echo "$INTEL" | jq -r '.memory.entries | length // 0' 2>/dev/null)
|
|
TRAJ_COUNT=$(echo "$INTEL" | jq -r '.learning.trajectories | length // 0' 2>/dev/null)
|
|
ROUTING_ALGO=$(echo "$INTEL" | jq -r '.learning.configs."agent-routing".algorithm // "double-q"' 2>/dev/null)
|
|
LEARNING_RATE=$(echo "$INTEL" | jq -r '.learning.configs."agent-routing".learningRate // 0.1' 2>/dev/null)
|
|
EPSILON=$(echo "$INTEL" | jq -r '.learning.configs."agent-routing".epsilon // 0.1' 2>/dev/null)
|
|
TOP_AGENTS=$(echo "$INTEL" | jq -r '
|
|
.learning.qTables // {} | to_entries |
|
|
map(.value | to_entries | sort_by(-.value) | .[0] | select(.value > 0)) |
|
|
map(.key) | unique | .[0:3] | join(", ")
|
|
' 2>/dev/null)
|
|
SCHEMA="v2"
|
|
else
|
|
# v1 Schema: Simple patterns/memories
|
|
PATTERN_COUNT=$(echo "$INTEL" | jq -r '.patterns | length // 0' 2>/dev/null)
|
|
MEMORY_COUNT=$(echo "$INTEL" | jq -r '.memories | length // 0' 2>/dev/null)
|
|
TRAJ_COUNT=$(echo "$INTEL" | jq -r '.trajectories | length // 0' 2>/dev/null)
|
|
ACTIVE_ALGOS=0
|
|
TOTAL_ALGOS=0
|
|
BEST_ALGO="none"
|
|
BEST_SCORE=0
|
|
TOTAL_UPDATES=0
|
|
ROUTING_ALGO="q-learning"
|
|
LEARNING_RATE="0.1"
|
|
EPSILON="0.1"
|
|
TOP_AGENTS=""
|
|
SCHEMA="v1"
|
|
fi
|
|
|
|
# Common fields (both schemas)
|
|
ERROR_COUNT=$(echo "$INTEL" | jq -r '.errors | length // 0' 2>/dev/null)
|
|
SESSION_COUNT=$(echo "$INTEL" | jq -r '.stats.session_count // 0' 2>/dev/null)
|
|
FILE_SEQ_COUNT=$(echo "$INTEL" | jq -r '.file_sequences | length // 0' 2>/dev/null)
|
|
AGENT_COUNT=$(echo "$INTEL" | jq -r '.agents | keys | length // 0' 2>/dev/null)
|
|
|
|
# Build Line 2
|
|
printf "${MAGENTA}🧠 RuVector${RESET}"
|
|
|
|
# Patterns learned
|
|
if [ "$PATTERN_COUNT" != "null" ] && [ "$PATTERN_COUNT" -gt 0 ]; then
|
|
printf " ${GREEN}◆${RESET} ${PATTERN_COUNT} patterns"
|
|
else
|
|
printf " ${DIM}◇ learning${RESET}"
|
|
fi
|
|
|
|
# Active algorithms
|
|
if [ "$ACTIVE_ALGOS" != "null" ] && [ "$ACTIVE_ALGOS" -gt 0 ]; then
|
|
printf " ${CYAN}⚙${RESET} ${ACTIVE_ALGOS}/${TOTAL_ALGOS} algos"
|
|
fi
|
|
|
|
# Best algorithm with convergence
|
|
if [ "$BEST_ALGO" != "none" ] && [ "$BEST_ALGO" != "null" ]; then
|
|
# Shorten algorithm name
|
|
case "$BEST_ALGO" in
|
|
"double-q") SHORT_ALGO="DQ" ;;
|
|
"q-learning") SHORT_ALGO="QL" ;;
|
|
"actor-critic") SHORT_ALGO="AC" ;;
|
|
"decision-transformer") SHORT_ALGO="DT" ;;
|
|
"monte-carlo") SHORT_ALGO="MC" ;;
|
|
"td-lambda") SHORT_ALGO="TD" ;;
|
|
*) SHORT_ALGO="${BEST_ALGO:0:3}" ;;
|
|
esac
|
|
|
|
# Color based on convergence
|
|
if [ "$BEST_SCORE" -ge 80 ]; then
|
|
SCORE_COLOR="$GREEN"
|
|
elif [ "$BEST_SCORE" -ge 50 ]; then
|
|
SCORE_COLOR="$YELLOW"
|
|
else
|
|
SCORE_COLOR="$RED"
|
|
fi
|
|
printf " ${SCORE_COLOR}★${SHORT_ALGO}:${BEST_SCORE}%%${RESET}"
|
|
fi
|
|
|
|
# Memory entries
|
|
if [ "$MEMORY_COUNT" != "null" ] && [ "$MEMORY_COUNT" -gt 0 ]; then
|
|
printf " ${BLUE}⬡${RESET} ${MEMORY_COUNT} mem"
|
|
fi
|
|
|
|
# Trajectories
|
|
if [ "$TRAJ_COUNT" != "null" ] && [ "$TRAJ_COUNT" -gt 0 ]; then
|
|
printf " ${YELLOW}↝${RESET}${TRAJ_COUNT}"
|
|
fi
|
|
|
|
# Error fixes available
|
|
if [ "$ERROR_COUNT" != "null" ] && [ "$ERROR_COUNT" -gt 0 ]; then
|
|
printf " ${RED}🔧${RESET}${ERROR_COUNT}"
|
|
fi
|
|
|
|
# Sessions
|
|
if [ "$SESSION_COUNT" != "null" ] && [ "$SESSION_COUNT" -gt 0 ]; then
|
|
printf " ${DIM}#${SESSION_COUNT}${RESET}"
|
|
fi
|
|
|
|
echo
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# LINE 3: Agent Routing & Session Performance
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
|
|
# Compression stats (v2 only)
|
|
COMPRESSION=$(echo "$INTEL" | jq -r '.tensorCompress.compressionRatio // 0' 2>/dev/null | awk '{printf "%.0f", $1 * 100}')
|
|
|
|
printf "${BLUE}🎯 Routing${RESET}"
|
|
|
|
# Show routing algorithm
|
|
case "$ROUTING_ALGO" in
|
|
"double-q") ALGO_ICON="⚡DQ" ;;
|
|
"sarsa") ALGO_ICON="🔄SA" ;;
|
|
"actor-critic") ALGO_ICON="🎭AC" ;;
|
|
*) ALGO_ICON="$ROUTING_ALGO" ;;
|
|
esac
|
|
printf " ${CYAN}${ALGO_ICON}${RESET}"
|
|
|
|
# Learning rate
|
|
LR_PCT=$(echo "$LEARNING_RATE" | awk '{printf "%.0f", $1 * 100}')
|
|
printf " lr:${LR_PCT}%%"
|
|
|
|
# Exploration rate
|
|
EPS_PCT=$(echo "$EPSILON" | awk '{printf "%.0f", $1 * 100}')
|
|
printf " ε:${EPS_PCT}%%"
|
|
|
|
# Top learned agents
|
|
if [ -n "$TOP_AGENTS" ] && [ "$TOP_AGENTS" != "null" ] && [ "$TOP_AGENTS" != "" ]; then
|
|
printf " ${GREEN}→${RESET} ${TOP_AGENTS}"
|
|
fi
|
|
|
|
# Session info
|
|
if [ "$TOTAL_UPDATES" != "null" ] && [ "$TOTAL_UPDATES" -gt 0 ]; then
|
|
printf " ${DIM}│${RESET} ${YELLOW}↻${RESET}${TOTAL_UPDATES}"
|
|
fi
|
|
|
|
# Compression ratio
|
|
if [ "$COMPRESSION" != "null" ] && [ "$COMPRESSION" -gt 0 ]; then
|
|
printf " ${MAGENTA}◊${RESET}${COMPRESSION}%%"
|
|
fi
|
|
|
|
# File sequences learned
|
|
if [ "$FILE_SEQ_COUNT" != "null" ] && [ "$FILE_SEQ_COUNT" -gt 0 ]; then
|
|
printf " ${CYAN}📂${RESET}${FILE_SEQ_COUNT}"
|
|
fi
|
|
|
|
# Agents learned
|
|
if [ "$AGENT_COUNT" != "null" ] && [ "$AGENT_COUNT" -gt 0 ]; then
|
|
printf " ${GREEN}🤖${RESET}${AGENT_COUNT}"
|
|
fi
|
|
|
|
echo
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# LINE 4: Four Attention Mechanisms
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# Show attention status based on what's been learned
|
|
|
|
# Get top Q-value pattern for confidence indicator
|
|
TOP_Q=$(echo "$INTEL" | jq -r '
|
|
.patterns // {} | to_entries |
|
|
sort_by(-.value.q_value) | .[0].value.q_value // 0
|
|
' 2>/dev/null | awk '{printf "%.0f", $1 * 100}')
|
|
|
|
# Calculate attention indicators
|
|
if [ "$TOP_Q" -ge 80 ]; then
|
|
NEURAL_STATUS="${GREEN}●${RESET}"
|
|
elif [ "$TOP_Q" -ge 50 ]; then
|
|
NEURAL_STATUS="${YELLOW}◐${RESET}"
|
|
else
|
|
NEURAL_STATUS="${DIM}○${RESET}"
|
|
fi
|
|
|
|
if [ "$TRAJ_COUNT" -ge 100 ]; then
|
|
DAG_STATUS="${GREEN}●${RESET}"
|
|
elif [ "$TRAJ_COUNT" -ge 10 ]; then
|
|
DAG_STATUS="${YELLOW}◐${RESET}"
|
|
else
|
|
DAG_STATUS="${DIM}○${RESET}"
|
|
fi
|
|
|
|
if [ "$AGENT_COUNT" -gt 0 ]; then
|
|
GRAPH_STATUS="${GREEN}●${RESET}"
|
|
elif [ "$FILE_SEQ_COUNT" -gt 0 ]; then
|
|
GRAPH_STATUS="${YELLOW}◐${RESET}"
|
|
else
|
|
GRAPH_STATUS="${DIM}○${RESET}"
|
|
fi
|
|
|
|
if [ "$SESSION_COUNT" -ge 5 ]; then
|
|
SSM_STATUS="${GREEN}●${RESET}"
|
|
elif [ "$SESSION_COUNT" -ge 1 ]; then
|
|
SSM_STATUS="${YELLOW}◐${RESET}"
|
|
else
|
|
SSM_STATUS="${DIM}○${RESET}"
|
|
fi
|
|
|
|
printf "${DIM}⚡ Attention:${RESET}"
|
|
printf " ${NEURAL_STATUS}${CYAN}Neural${RESET}"
|
|
printf " ${DAG_STATUS}${YELLOW}DAG${RESET}"
|
|
printf " ${GRAPH_STATUS}${MAGENTA}Graph${RESET}"
|
|
printf " ${SSM_STATUS}${BLUE}SSM${RESET}"
|
|
echo
|
|
|
|
else
|
|
# No intelligence file - show initialization hint
|
|
printf "${DIM}🧠 RuVector: run 'npx ruvector hooks session-start' to initialize${RESET}\n"
|
|
fi
|
|
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
# LINE 4: Claude Flow Integration (only if meaningful data exists)
|
|
# ═══════════════════════════════════════════════════════════════════════════════
|
|
FLOW_DIR="$CWD/.claude-flow"
|
|
FLOW_OUTPUT=""
|
|
|
|
if [ -d "$FLOW_DIR" ]; then
|
|
# Swarm config
|
|
if [ -f "$FLOW_DIR/swarm-config.json" ]; then
|
|
STRATEGY=$(jq -r '.defaultStrategy // empty' "$FLOW_DIR/swarm-config.json" 2>/dev/null)
|
|
AGENT_COUNT=$(jq -r '.agentProfiles | length' "$FLOW_DIR/swarm-config.json" 2>/dev/null)
|
|
|
|
if [ -n "$STRATEGY" ]; then
|
|
case "$STRATEGY" in
|
|
"balanced") TOPO="mesh" ;;
|
|
"conservative") TOPO="hier" ;;
|
|
"aggressive") TOPO="ring" ;;
|
|
*) TOPO="$STRATEGY" ;;
|
|
esac
|
|
FLOW_OUTPUT="${FLOW_OUTPUT} ${MAGENTA}${TOPO}${RESET}"
|
|
fi
|
|
|
|
if [ -n "$AGENT_COUNT" ] && [ "$AGENT_COUNT" != "null" ] && [ "$AGENT_COUNT" -gt 0 ]; then
|
|
FLOW_OUTPUT="${FLOW_OUTPUT} ${CYAN}🤖${AGENT_COUNT}${RESET}"
|
|
fi
|
|
fi
|
|
|
|
# Active tasks
|
|
if [ -d "$FLOW_DIR/tasks" ]; then
|
|
TASK_COUNT=$(find "$FLOW_DIR/tasks" -name "*.json" -type f 2>/dev/null | wc -l)
|
|
if [ "$TASK_COUNT" -gt 0 ]; then
|
|
FLOW_OUTPUT="${FLOW_OUTPUT} ${YELLOW}📋${TASK_COUNT}${RESET}"
|
|
fi
|
|
fi
|
|
|
|
# Session state
|
|
if [ -f "$FLOW_DIR/session-state.json" ]; then
|
|
ACTIVE=$(jq -r '.active // false' "$FLOW_DIR/session-state.json" 2>/dev/null)
|
|
if [ "$ACTIVE" = "true" ]; then
|
|
FLOW_OUTPUT="${FLOW_OUTPUT} ${GREEN}●${RESET}"
|
|
fi
|
|
fi
|
|
|
|
# Only print if we have content
|
|
if [ -n "$FLOW_OUTPUT" ]; then
|
|
printf "${DIM}⚡ Flow:${RESET}${FLOW_OUTPUT}\n"
|
|
fi
|
|
fi
|