v1.1.0 Ecosystem Expansion — Competitive Research Implementation Plan¶

#!/usr/bin/env bash
# lib/24-litellm.sh — OpenAI-compatible local API gateway (LiteLLM proxy)
set -euo pipefail

_step_skip step_litellm && return 0

section "OpenAI-compatible API Gateway (LiteLLM)"

# LiteLLM — unified proxy for Ollama/vLLM/SGLang behind OpenAI-compatible /v1
if ! command -v litellm &>/dev/null; then
  info "Installing LiteLLM (OpenAI-compatible proxy for local LLMs)..."
  pipx install litellm 2>/dev/null && log "LiteLLM installed" || warn "LiteLLM install failed"
fi

# Generate config: auto-detect running backends
mkdir -p ~/.config/litellm

# Detect Ollama models and register them as proxies
OLLAMA_MODELS="qwen3:1.8b"
if command -v ollama &>/dev/null; then
  OLLAMA_MODELS=$(ollama list 2>/dev/null | awk 'NR>1{print $1}' | tr '\n' ',' | sed 's/,$//')
  [ -z "$OLLAMA_MODELS" ] && OLLAMA_MODELS="qwen3:1.8b"
fi

cat > ~/.config/litellm/config.yaml << YAML
general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
  database_url: os.environ/LITELLM_DATABASE_URL

model_list:
YAML

# Register Ollama models
for model in $(echo "$OLLAMA_MODELS" | tr ',' ' '); do
  cat >> ~/.config/litellm/config.yaml << YAML
  - model_name: ollama/${model}
    litellm_params:
      model: ollama/${model}
      api_base: http://localhost:11434
YAML
done

# Register vLLM if available
if command -v vllm &>/dev/null; then
  cat >> ~/.config/litellm/config.yaml << YAML
  - model_name: vllm-self-hosted
    litellm_params:
      model: openai/default
      api_base: http://localhost:8000/v1
YAML
fi

litellm_version: 1

# Register remote providers (from auth.json) as fallback models
# DeepSeek, OpenCode, xAI — handled by opencode.json provider config
# LiteLLM serves as the LOCAL-only gateway; remote providers stay in opencode.json

cat >> ~/.config/litellm/config.yaml << YAML

router_settings:
  routing_strategy: usage-based
  enable_pre_call_checks: true
  allowed_fails: 3
  num_retries: 2
  fallbacks:
    - ollama/qwen3:1.8b
YAML

log "LiteLLM config written: ~/.config/litellm/config.yaml"

# Install systemd user service for auto-start
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/litellm.service << 'SVC'
[Unit]
Description=LiteLLM — OpenAI-compatible Local API Gateway
After=network.target ollama.service
Wants=ollama.service

[Service]
Type=simple
Environment=LITELLM_MASTER_KEY=sk-local-dev-key-change-me
ExecStart=%h/.local/bin/litellm --config %h/.config/litellm/config.yaml --port 4000
Restart=on-failure
RestartSec=5

[Install]
WantedBy=default.target
SVC

systemctl --user daemon-reload
systemctl --user enable litellm.service
systemctl --user start litellm.service 2>/dev/null || true

log "LiteLLM API: http://localhost:4000/v1 (OpenAI-compatible)"
log "Test: curl http://localhost:4000/v1/models"

_step_done step_litellm

# Unit: bash -n src/lib/24-litellm.sh
# Integration: grep -q "LiteLLM" opencode.json (if we add it as MCP)
# Health: curl -s http://localhost:4000/health/liveliness
# E2E: curl -s http://localhost:4000/v1/models | python3 -c "import json,sys; d=json.load(sys.stdin); assert 'data' in d"

# Line 256: TOTAL_STEPS=24
# After line 307: _run_step step_litellm "LiteLLM API Gateway" "$SCRIPT_DIR/src/lib/24-litellm.sh"

# lib/16-llm.sh — revised hardware detection section

detect_hardware() {
  # GPU detection
  HAS_GPU=false; HAS_NVIDIA_GPU=false; HAS_AMD_GPU=false; HAS_INTEL_GPU=false; HAS_NPU=false

  # NVIDIA GPU
  if lspci 2>/dev/null | grep -qiE 'nvidia|3D controller.*NVIDIA'; then
    HAS_NVIDIA_GPU=true; HAS_GPU=true
    log "NVIDIA GPU detected"
    # Check CUDA version
    nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null && log "NVIDIA driver: $(nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null)"
  fi

  # AMD GPU (ROCm)
  if lspci 2>/dev/null | grep -qiE 'amd/ati|Advanced Micro Devices' || \
     [ -d /opt/rocm ] || [ -d /opt/amdgpu ]; then
    HAS_AMD_GPU=true; HAS_GPU=true
    log "AMD GPU detected (ROCm compatible)"
    # Check ROCm version
    [ -f /opt/rocm/.info/version ] && log "ROCm: $(cat /opt/rocm/.info/version)"
  fi

  # Intel GPU (OneAPI/Arc)
  if lspci 2>/dev/null | grep -qiE 'Intel.*Graphics|Intel.*Arc'; then
    HAS_INTEL_GPU=true; HAS_GPU=true
    log "Intel GPU detected (OneAPI compatible)"
  fi

  # NPU (AMD Ryzen AI, Intel Meteor Lake)
  if lspci 2>/dev/null | grep -qiE 'IPU|Neural|NPU|Ryzen AI' || \
     [ -e /dev/accel/accel0 ] || [ -e /dev/dri/renderD128 ]; then
    HAS_NPU=true
    log "NPU detected (AMD Ryzen AI / Intel Meteor Lake)"
  fi

  # Apple Silicon (M1/M2/M3 — macOS only)
  if [ "$(uname -s)" = "Darwin" ] && sysctl -n machdep.cpu.brand_string 2>/dev/null | grep -qi 'Apple'; then
    HAS_GPU=true
    log "Apple Silicon detected (Metal/MPS acceleration)"
  fi

  # Determine optimal backend
  if $HAS_NVIDIA_GPU; then
    OPTIMAL_BACKEND="vllm"      # Best performance on NVIDIA
  elif $HAS_AMD_GPU; then
    OPTIMAL_BACKEND="ollama"    # ROCm via Ollama
  elif $HAS_INTEL_GPU; then
    OPTIMAL_BACKEND="ollama"    # OneAPI via Ollama
  elif $HAS_NPU; then
    OPTIMAL_BACKEND="llama.cpp" # CPU fallback, NPU not yet supported in Ollama
  else
    OPTIMAL_BACKEND="ollama"    # CPU-only works with Ollama
  fi

  export HAS_NVIDIA_GPU HAS_AMD_GPU HAS_INTEL_GPU HAS_NPU OPTIMAL_BACKEND

  # Write hardware profile for LiteLLM routing
  mkdir -p ~/.config/litellm
  python3 -c "
import json
with open('$HOME/.config/litellm/hardware.json', 'w') as f:
    json.dump({
        'nvidia_gpu': $HAS_NVIDIA_GPU,
        'amd_gpu': $HAS_AMD_GPU,
        'intel_gpu': $HAS_INTEL_GPU,
        'npu': $HAS_NPU,
        'optimal_backend': '$OPTIMAL_BACKEND',
        'is_wsl2': '${WSL_DISTRO_NAME:+true}',
        'arch': '$(uname -m)'
    }, f, indent=2)
  "

  log "Optimal backend: $OPTIMAL_BACKEND"
}

detect_hardware

# ── Backend-specific installs ─────────────────────────────────────────────

# Ollama — universal (NVIDIA CUDA, AMD ROCm, Intel OneAPI, CPU)
if ! command -v ollama &>/dev/null; then
  info "Installing Ollama..."
  command -v zstd &>/dev/null || sudo apt-get install -y zstd 2>/dev/null || true
  _curl "https://ollama.ai/install.sh" /tmp/ollama-install.sh 2>/dev/null && bash /tmp/ollama-install.sh 2>/dev/null && log "Ollama installed" || warn "Ollama install failed"
  rm -f /tmp/ollama-install.sh
  if command -v ollama &>/dev/null; then
    # Pull optimal model based on hardware
    if $HAS_GPU; then
      ollama pull qwen3:14b 2>/dev/null & log "Ollama: pulling qwen3:14b (GPU-optimized, background)";
    else
      ollama pull qwen3:1.8b 2>/dev/null & log "Ollama: pulling qwen3:1.8b (CPU-friendly, background)";
    fi
  fi
else
  log "Ollama already installed"
fi

# vLLM — NVIDIA GPU only, for high-performance inference
if $HAS_NVIDIA_GPU && ! command -v vllm &>/dev/null; then
  info "Installing vLLM (NVIDIA GPU inference server)..."
  pipx install vllm 2>/dev/null && log "vLLM installed" || warn "vLLM install failed (requires NVIDIA GPU + CUDA)"
fi

# llama.cpp — CPU-optimized, best for NPU/no-GPU scenarios
if ! $HAS_GPU && ! command -v llama.cpp &>/dev/null; then
  info "Installing llama.cpp (CPU-optimized inference)..."
  if command -v brew &>/dev/null; then
    brew install llama.cpp 2>/dev/null && log "llama.cpp installed (brew)" || warn "llama.cpp brew install failed"
  else
    # Build from source — lightweight
    git clone --depth 1 https://github.com/ggerganov/llama.cpp /tmp/llama.cpp-build 2>/dev/null && \
      make -C /tmp/llama.cpp-build -j$(nproc) llama-cli 2>/dev/null && \
      cp /tmp/llama.cpp-build/llama-cli ~/.local/bin/ && log "llama.cpp built" || warn "llama.cpp build failed"
    rm -rf /tmp/llama.cpp-build
  fi
fi

# Open WebUI — only install if GPU detected or user explicitly chose LLM
if $HAS_GPU || [ "${INTERACTIVE_DO_LLM:-}" = "true" ]; then
  if command -v docker &>/dev/null && ! docker ps --format '{{.Names}}' 2>/dev/null | grep -q 'open-webui'; then
    info "Installing Open WebUI (Docker)..."
    docker run -d --name open-webui --restart unless-stopped \
      -p 3300:8080 -v open-webui:/app/backend/data \
      --add-host=host.docker.internal:host-gateway \
      ghcr.io/open-webui/open-webui:main 2>/dev/null && log "Open WebUI: http://localhost:3300" || warn "Open WebUI failed"
  fi
fi

# Unit: bash -n src/lib/16-llm.sh
# Integration: source 16-llm.sh, verify $OPTIMAL_BACKEND is set
# Health: grep "Optimal backend" setup log

#!/usr/bin/env bash
# modes/ci.sh — Lightweight CI/CD headless mode
# Installs: OpenCode CLI + Bun + 3 essential MCPs only
# Use: bash setup.sh --ci
# Non-interactive, zero GUI dependencies

if [ "$MODE" != "ci" ]; then return 0; fi

section "CI/CD Headless Mode — Minimal AI Agent Setup"
log "CI mode: OpenCode CLI + Bun + essential MCPs only"
log "Skipping: ZSH, Docker, Chrome, GUI tools, LLM runtimes, RAG"

TOTAL_STEPS=5

# Only install what CI/CD needs
INTERACTIVE_DO_SYSTEM=false
INTERACTIVE_DO_OPENCODE=true
INTERACTIVE_DO_MCP=true
INTERACTIVE_DO_CHROMADB=false
INTERACTIVE_DO_LLM=false
INTERACTIVE_DO_RAG=false
INTERACTIVE_DO_ZSH=false

# ── Step 1: System essentials ────────────────────────────────────────────
_run_step step_system "System essentials" "$SCRIPT_DIR/src/lib/01-system.sh" || true

# ── Step 2: Node.js (OpenCode depends on Node) ───────────────────────────
INTERACTIVE_DO_NODE=true
_run_step step_node "Node.js" "$SCRIPT_DIR/src/lib/06-node.sh" || true

# ── Step 3: OpenCode CLI + Bun ───────────────────────────────────────────
_run_step step_opencode "OpenCode CLI" "$SCRIPT_DIR/src/lib/11-opencode.sh" || true

# ── Step 4: Essential MCPs only (filesystem, github, context7) ───────────
# Override MCP install to only install CI-essential ones
_info_ci() { info "[CI] $1"; }

CI_MCPS=(
  "@modelcontextprotocol/server-filesystem"
  "@upstash/context7-mcp"
)

if command -v bun &>/dev/null; then
  for pkg in "${CI_MCPS[@]}"; do
    _info_ci "Installing $pkg..."
    bun add -g "$pkg" 2>/dev/null && log "MCP: $pkg" || warn "MCP: $pkg failed (non-fatal)"
  done
fi

# ── Step 5: Minimal opencode.json (CI-optimized) ────────────────────────
_info_ci "Generating minimal opencode.json for CI/CD..."

python3 -c "
import json, os
config = {
    'model': os.environ.get('OPENCODE_MODEL', 'deepseek/deepseek-v4-pro'),
    'small_model': 'deepseek/deepseek-v4-flash',
    'provider': {'deepseek': {}},
    'mcp': {},
    'plugin': [],
}
# Only add filesystem and context7 MCPs if available
bun_bin = os.path.expanduser('~/.bun/bin')
if os.path.exists(f'{bun_bin}/mcp-server-filesystem'):
    config['mcp']['filesystem'] = {
        'type': 'local',
        'command': [f'{bun_bin}/mcp-server-filesystem'],
        'enabled': True
    }
if os.path.exists(f'{bun_bin}/c7-mcp-server'):
    config['mcp']['context7'] = {
        'type': 'local',
        'command': [f'{bun_bin}/c7-mcp-server'],
        'enabled': True
    }
# Write config
out_dir = os.path.expanduser('~/.config/opencode')
os.makedirs(out_dir, exist_ok=True)
with open(f'{out_dir}/opencode.json', 'w') as f:
    json.dump(config, f, indent=2)
log('CI opencode.json generated')
" 2>/dev/null || warn "CI opencode.json generation failed"

log "CI/CD headless setup complete"
log "Run: opencode --non-interactive 'check repo for issues'"
echo ""
echo -e "  ${GREEN}╔══════════════════════════════════════╗${NC}"
echo -e "  ${GREEN}║   CI/CD Headless Mode — Ready       ║${NC}"
echo -e "  ${GREEN}║   opencode --non-interactive ...     ║${NC}"
echo -e "  ${GREEN}╚══════════════════════════════════════╝${NC}"
exit 0

# Add --ci flag
--ci) MODE="ci"; shift;;

# Add to CLI help
--ci                Headless CI/CD mode: OpenCode CLI + essential MCPs only

# Add to early-exit modes (after line 118)
if [ "$MODE" = "ci" ]; then source "$SCRIPT_DIR/src/modes/ci.sh"; fi

# Unit: bash -n src/modes/ci.sh
# Integration: MODE=ci bash setup.sh --dry-run --ci 2>&1 | grep -q "CI/CD Headless"
# E2E: verify only 5 components installed vs 23 in full mode

# ── Multimodal: Speech Recognition (whisper.cpp) ─────────────────────────
# Section to add to 16-llm.sh after llama.cpp install

if ! command -v whisper-cli &>/dev/null; then
  info "Installing whisper.cpp (speech-to-text)..."
  git clone --depth 1 https://github.com/ggerganov/whisper.cpp /tmp/whisper.cpp-build 2>/dev/null && \
    (cd /tmp/whisper.cpp-build && bash ./models/download-ggml-model.sh base 2>/dev/null && \
     make -j$(nproc) 2>/dev/null && cp main ~/.local/bin/whisper-cli) && \
    log "whisper.cpp installed (base model)" || warn "whisper.cpp build failed"
  rm -rf /tmp/whisper.cpp-build
else
  log "whisper.cpp already installed"
fi

# ── Multimodal: Image Generation (stable-diffusion.cpp) ──────────────────
# CPU-only by default; GPU-accelerated if NVIDIA detected
if ! command -v sd &>/dev/null && ! $HAS_NVIDIA_GPU; then
  info "Installing stable-diffusion.cpp (CPU image generation)..."
  git clone --depth 1 https://github.com/leejet/stable-diffusion.cpp /tmp/sd.cpp-build 2>/dev/null && \
    (cd /tmp/sd.cpp-build && mkdir -p build && cd build && \
     cmake .. -DSD_SYSTEM_GGML=OFF 2>/dev/null && \
     cmake --build . --config Release -j$(nproc) 2>/dev/null && \
     cp bin/sd ~/.local/bin/) && log "stable-diffusion.cpp installed" || warn "sd.cpp build failed"
  rm -rf /tmp/sd.cpp-build
fi

# ── Multimodal: Pull vision model for Ollama ─────────────────────────────
if command -v ollama &>/dev/null; then
  # Pull a vision-capable model (llava or bakllava)
  if ! ollama list 2>/dev/null | grep -q 'llava'; then
    info "Pulling vision model (llava:7b)..."
    ollama pull llava:7b 2>/dev/null & log "Ollama: pulling llava:7b (vision, background)"
  fi
fi

# Unit: bash -n src/lib/16-llm.sh
# Health: check whisper-cli --version, sd --help
# E2E: echo "test" | whisper-cli -m ~/.local/share/whisper/models/ggml-base.bin -f - 2>&1 | grep -q "test"

# lib/25-providers.sh — Multi-provider registry

_step_skip step_providers && return 0

section "Multi-Provider Configuration"

# Provider registry: (short_name api_key_env cli_flag description free_tier)
declare -A PROVIDER_REGISTRY
PROVIDER_REGISTRY=(
  [deepseek]="DEEPSEEK_API_KEY|--deepseek-key|DeepSeek V4 Pro (direct)|yes"
  [opencode]="OPENCODE_API_KEY|-k|OpenCode Go proxy|yes"
  [xai]="XAI_API_KEY|--xai-key|xAI Grok 3|no"
  [mimo]="MIMO_API_KEY|--mimo-key|Xiaomi MiMo|yes"
  [moonshot]="MOONSHOT_API_KEY|--moonshot-key|Moonshot Kimi K2.6|no"
  [minimax]="MINIMAX_API_KEY|--minimax-key|MiniMax M3|no"
  [openai]="OPENAI_API_KEY|--openai-key|OpenAI GPT-5|no"
  [anthropic]="ANTHROPIC_API_KEY|--anthropic-key|Anthropic Claude 4|no"
  [google]="GOOGLE_API_KEY|--google-key|Google Gemini 2.5|yes"
  [mistral]="MISTRAL_API_KEY|--mistral-key|Mistral Large 3|no"
  [groq]="GROQ_API_KEY|--groq-key|Groq Cloud (fast inference)|yes"
  [together]="TOGETHER_API_KEY|--together-key|Together AI|yes"
  [cohere]="COHERE_API_KEY|--cohere-key|Cohere Command R+|yes"
  [fireworks]="FIREWORKS_API_KEY|--fireworks-key|Fireworks AI|no"
  [cerebras]="CEREBRAS_API_KEY|--cerebras-key|Cerebras (fast inference)|no"
  [perplexity]="PERPLEXITY_API_KEY|--perplexity-key|Perplexity (online search)|no"
)

# Detect available providers from env vars + auth.json
AVAILABLE_PROVIDERS=""

for provider in "${!PROVIDER_REGISTRY[@]}"; do
  IFS='|' read -r env_var _cli_flag _desc _free <<< "${PROVIDER_REGISTRY[$provider]}"
  key_val="${!env_var:-}"

  # Check auth.json as fallback
  if [ -z "$key_val" ] && [ -f "$HOME/.local/share/opencode/auth.json" ]; then
    key_val=$(python3 -c "
import json, os
try:
  with open('$HOME/.local/share/opencode/auth.json') as f:
    auth = json.load(f)
  print(auth.get('$provider', {}).get('key', ''))
except: pass
" 2>/dev/null)
  fi

  if [ -n "$key_val" ]; then
    AVAILABLE_PROVIDERS="$AVAILABLE_PROVIDERS $provider"
    log "Provider: $provider (API key found)"
  fi
done

[ -z "$AVAILABLE_PROVIDERS" ] && warn "No provider API keys found — some features disabled"
export AVAILABLE_PROVIDERS

_step_done step_providers

# Unit: bash -n src/lib/25-providers.sh src/lib/11-opencode.sh
# Integration: source 25-providers.sh, check $AVAILABLE_PROVIDERS count
# E2E: python3 -c "import json; c=json.load(open('...opencode.json')); assert len(c['provider']) >= 6"

# scripts/opencode-tui.sh — Terminal UI for OpenCode
# Uses dialog/whiptail for interactive prompt construction
cat > ~/.local/bin/oc-tui << 'TUI'
#!/usr/bin/env bash
# oc-tui — Terminal UI wrapper for OpenCode
set -euo pipefail

# Check for dialog or whiptail
if command -v dialog &>/dev/null; then
  DIALOG="dialog"
elif command -v whiptail &>/dev/null; then
  DIALOG="whiptail"
else
  echo "Install dialog or whiptail for TUI mode: sudo apt install dialog"
  exit 1
fi

# Select model
MODEL=$($DIALOG --title "OpenCode TUI" --menu "Select model:" 15 60 8 \
  "deepseek/deepseek-v4-pro"   "DeepSeek V4 Pro (recommended)" \
  "deepseek/deepseek-v4-flash" "DeepSeek V4 Flash (fast)" \
  "openai/gpt-5"               "OpenAI GPT-5" \
  "anthropic/claude-sonnet"    "Anthropic Claude Sonnet 4" \
  3>&1 1>&2 2>&3) || exit 0

# Get prompt
PROMPT=$($DIALOG --title "OpenCode TUI" --inputbox "Enter your prompt:" 10 60 3>&1 1>&2 2>&3) || exit 0

# Execute
opencode --model "$MODEL" "$PROMPT"
TUI
chmod +x ~/.local/bin/oc-tui
log "oc-tui installed (~/.local/bin/oc-tui)"

# Unit: bash -n scripts/opencode-tui.sh scripts/opencode-json.sh scripts/opencode-rpc.sh
# Integration: python3 -c "from opencode_sdk import OpenCode; oc = OpenCode(); assert oc.model"

# Enable Open WebUI admin features for model management
# Configure model download presets based on hardware detection
# Add model download queue for background pulls
# Expose Open WebUI on all interfaces (0.0.0.0) for LAN access

# Manual: open http://localhost:3300/admin/models in browser
# Health: curl -s http://localhost:3300/api/models | python3 -c "import json,sys; print(len(json.load(sys.stdin)['data']))"

# ── ONNX Runtime ─────────────────────────────────────────────────────────
if ! python3 -c "import onnxruntime" 2>/dev/null; then
  info "Installing ONNX Runtime (cross-platform inference)..."
  pipx install onnxruntime 2>/dev/null && log "ONNX Runtime installed" || \
  pip install --user onnxruntime 2>/dev/null && log "ONNX Runtime installed (pip)" || \
  warn "ONNX Runtime install failed"
fi

# Pull a small ONNX model as proof-of-concept
MODEL_CACHE="$HOME/.cache/opencode-setup/models"
mkdir -p "$MODEL_CACHE"
if [ ! -f "$MODEL_CACHE/all-MiniLM-L6-v2.onnx" ]; then
  info "Downloading ONNX embedding model (MiniLM-L6)..."
  _curl "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx" \
    "$MODEL_CACHE/all-MiniLM-L6-v2.onnx" 2>/dev/null && log "ONNX model cached" || warn "ONNX model download failed"
fi

# Unit: python3 -c "import onnxruntime; print(onnxruntime.__version__)"
# Health: check onnxruntime via python import

# scripts/build-embedded.sh
# Uses bun build --compile to create a single binary
# Includes: OpenCode CLI + essential MCPs + bun runtime
# Output: ~200MB standalone binary, no dependencies

# Build: bash scripts/build-embedded.sh
# Test: ./opencode-embedded --version
# Test: ./opencode-embedded --non-interactive "echo hello"