#!/bin/sh
# 0G Builder Hub installer.
#
#   curl -fsSL https://build.0g.ai/install | sh
#
# Puts the 0G agent skills in ./.0g-skills so your coding assistant can read
# them, and prints the one line to add to your assistant's instructions file.
#
# Nothing happens until you say yes, and it never rewrites CLAUDE.md,
# .cursorrules, copilot-instructions.md, or any settings file. Those belong to
# you. It writes ./.0g-skills, and one line in .gitignore if you agree to it.
#
# POSIX sh. No bashisms, no sudo, no eval of anything fetched.

set -eu

REPO="https://github.com/0gfoundation/0g-agent-skills"
DIR=".0g-skills"
RPC_TESTNET="https://evmrpc-testnet.0g.ai"
INDEXER_TESTNET="https://indexer-storage-testnet-turbo.0g.ai"
ATTESTOR_TESTNET="https://agenticid.0g.ai"
PC_INSTALL="curl -fsSL https://pc.0g.ai/install | bash -s claude --key -"
TAGLINE="Build on the trust layer for AI"

AGENT=""
OTHER_NAME=""
ASSUME_YES=0
PARTS=""
WANT_COMPUTE=0
WANT_STORAGE=0
WANT_CHAIN=0
WANT_INFT=0

# ---------------------------------------------------------------------------
# Presentation
#
# Colour and box-drawing only when a terminal is there to render them. stdout
# is the terminal even when this script arrives through a pipe, so -t 1 is the
# right test. NO_COLOR and TERM=dumb are honoured.
# ---------------------------------------------------------------------------
if [ -t 1 ] && [ -z "${NO_COLOR:-}" ] && [ "${TERM:-dumb}" != "dumb" ]; then
    C_RESET=$(printf '\033[0m')
    C_BOLD=$(printf '\033[1m')
    C_DIM=$(printf '\033[2m')
# Hero Purple, #B75FFF, the same accent the site uses. Truecolor when the
# terminal advertises it, the nearest xterm-256 purple when it does not, and
# plain magenta as the last resort.
    case "${COLORTERM:-}" in
        truecolor|24bit)
            C_ACCENT=$(printf '\033[38;2;183;95;255m')
            ;;
        *)
            case "${TERM:-}" in
                *256color*) C_ACCENT=$(printf '\033[38;5;141m') ;;
                *) C_ACCENT=$(printf '\033[35m') ;;
            esac
            ;;
    esac
    C_OK=$(printf '\033[32m')
    FANCY=1
else
    C_RESET=""; C_BOLD=""; C_DIM=""; C_ACCENT=""; C_OK=""
    FANCY=0
fi

COLS=$(tput cols 2>/dev/null || printf '80')
case "$COLS" in
    ''|*[!0-9]*) COLS=80 ;;
esac
[ "$COLS" -ge 40 ] || COLS=40
[ "$COLS" -le 100 ] || COLS=100

say() { printf '%s\n' "$1"; }

pad() {
    # pad <count>: spaces, without relying on printf field widths
    i=0
    while [ "$i" -lt "$1" ]; do
        printf ' '
        i=$((i + 1))
    done
}

centre() {
    # centre <visible-width> <text>: width is passed in because ${#text}
    # counts bytes, not columns, in most shells, and the logo is UTF-8.
    offset=$(((COLS - $1) / 2))
    [ "$offset" -ge 0 ] || offset=0
    pad "$offset"
    printf '%s\n' "$2"
}

rule() {
    width=$((COLS - 4))
    printf '%s  ' "$C_DIM"
    i=0
    while [ "$i" -lt "$width" ]; do
        if [ "$FANCY" -eq 1 ]; then printf '─'; else printf '-'; fi
        i=$((i + 1))
    done
    printf '%s\n' "$C_RESET"
}

header() {
    say ""
    if [ "$FANCY" -eq 1 ]; then
        # "0G", 19 columns wide on every line
        printf '%s' "$C_ACCENT"
        centre 19 ' ██████╗   ██████╗ '
        centre 19 '██╔═══██╗ ██╔════╝ '
        centre 19 '██║   ██║ ██║  ███╗'
        centre 19 '██║   ██║ ██║   ██║'
        centre 19 '╚██████╔╝ ╚██████╔╝'
        centre 19 ' ╚═════╝   ╚═════╝ '
        printf '%s' "$C_RESET"
        say ""
        printf '%s' "$C_BOLD"
        centre 31 "$TAGLINE"
        printf '%s' "$C_RESET"
    else
        say "  0G BUILDER HUB"
        say "  $TAGLINE"
    fi
    say ""
    rule
    say ""
}

field() {
    # field <label> <value>: aligned two-column detail line
    printf '  %s%-12s%s %s\n' "$C_DIM" "$1" "$C_RESET" "$2"
}

ok() {
    if [ "$FANCY" -eq 1 ]; then
        printf '  %s✓%s  %s%s%s\n' "$C_OK" "$C_RESET" "$C_BOLD" "$1" "$C_RESET"
    else
        printf '  [ok]  %s\n' "$1"
    fi
    [ $# -lt 2 ] || printf '      %s%s%s\n' "$C_DIM" "$2" "$C_RESET"
}

step() {
    # step <number> <heading>
    printf '\n  %s%s%s  %s%s%s\n' "$C_ACCENT" "$1" "$C_RESET" "$C_BOLD" "$2" "$C_RESET"
}

cmd() { printf '     %s%s%s\n' "$C_ACCENT" "$1" "$C_RESET"; }

note() { printf '     %s%s%s\n' "$C_DIM" "$1" "$C_RESET"; }

die() {
    printf '\n  %sx%s  %s\n\n' "${C_OK:+$(printf '\033[31m')}" "$C_RESET" "$1" >&2
    exit 1
}

usage() {
    cat <<'EOF'
0G Builder Hub installer

  curl -fsSL https://build.0g.ai/install | sh
  curl -fsSL https://build.0g.ai/install | sh -s -- --agent claude --yes

Options
  --agent NAME   Which assistant to set up for. claude, cursor and copilot
                 have setup guides; any other name (windsurf, zed, aider,
                 codex, cline, ...) gets tool-neutral instructions.
                 Detected from the project when omitted.
  --parts LIST   Which parts of 0G you are building on, comma separated:
                 compute, storage, chain, agentic-id, or all. Decides which
                 SDKs and env vars get printed. Asked for when omitted.
  --yes          Skip the confirmation. Required when there is no terminal
                 to ask on, such as in CI.
  --help         This text.

It clones the skills into ./.0g-skills and, if you agree, adds one line to
.gitignore. It never writes CLAUDE.md, .cursorrules,
.github/copilot-instructions.md or any settings file.
EOF
}

while [ $# -gt 0 ]; do
    case "$1" in
        --agent)
            [ $# -ge 2 ] || die "--agent needs a value, for example: claude, cursor, copilot, zed."
            AGENT="$2"
            shift 2
            ;;
        --agent=*)
            AGENT="${1#--agent=}"
            shift
            ;;
        --parts)
            [ $# -ge 2 ] || die "--parts needs a value, for example: compute,storage or all."
            PARTS="$2"
            shift 2
            ;;
        --parts=*)
            PARTS="${1#--parts=}"
            shift
            ;;
        --yes|-y)
            ASSUME_YES=1
            shift
            ;;
        --help|-h)
            usage
            exit 0
            ;;
        *)
            die "unknown option: $1. Try --help."
            ;;
    esac
done

# claude, cursor and copilot have setup guides in the skills repo. Any other
# value is fine: the skills are markdown any assistant can read, so those get
# the tool-neutral instructions instead of an error.
case "$AGENT" in
    ""|claude|cursor|copilot|other) ;;
    *) OTHER_NAME="$AGENT"; AGENT="other" ;;
esac

# ---------------------------------------------------------------------------
# Refuse the cases where "install into the current directory" is a mistake
# ---------------------------------------------------------------------------
command -v git >/dev/null 2>&1 || die "git is needed and was not found on PATH."

HERE="$(pwd)"
header

if [ "$HERE" = "$HOME" ]; then
    die "you are in your home directory, and this installs into the current one.
     Move into a project first:

       cd path/to/your/project

     Or start a new one:

       mkdir my-0g-app && cd my-0g-app"
fi
if [ "$HERE" = "/" ]; then
    die "refusing to install into /."
fi

# ---------------------------------------------------------------------------
# Which assistant
# ---------------------------------------------------------------------------
detect_agent() {
    if [ -d ".claude" ] || [ -f "CLAUDE.md" ]; then
        printf 'claude'
    elif [ -d ".cursor" ] || [ -f ".cursorrules" ]; then
        printf 'cursor'
    elif [ -f ".github/copilot-instructions.md" ]; then
        printf 'copilot'
    elif [ -f "AGENTS.md" ]; then
        printf 'other'
    else
        printf ''
    fi
}

interactive() {
    # -r /dev/tty passes even with no controlling terminal, so actually try to
    # open it. A subshell keeps the probe free of side effects.
    [ "$ASSUME_YES" -eq 0 ] || return 1
    ( : < /dev/tty ) 2>/dev/null
}

ask() {
    # ask <prompt> <default>; answers come from the terminal, not from the
    # pipe feeding this script to sh.
    if interactive; then
        printf '  %s%s%s' "$C_BOLD" "$1" "$C_RESET" > /dev/tty
        reply=""
        read -r reply < /dev/tty || reply=""
        [ -n "$reply" ] || reply="$2"
        printf '%s' "$reply"
    else
        printf '%s' "$2"
    fi
}

agent_label() {
    case "$1" in
        claude) printf 'Claude Code' ;;
        cursor) printf 'Cursor' ;;
        copilot) printf 'GitHub Copilot' ;;
        other) [ -n "$OTHER_NAME" ] && printf '%s' "$OTHER_NAME" || printf 'any assistant' ;;
    esac
}

DETECTED=""
if [ -z "$AGENT" ]; then
    AGENT="$(detect_agent)"
    if [ -n "$AGENT" ]; then
        DETECTED="detected"
    elif interactive; then
        printf '  %sWhich assistant are you using?%s\n\n' "$C_BOLD" "$C_RESET"
        printf '    %s1%s  Claude Code\n' "$C_ACCENT" "$C_RESET"
        printf '    %s2%s  Cursor\n' "$C_ACCENT" "$C_RESET"
        printf '    %s3%s  GitHub Copilot\n' "$C_ACCENT" "$C_RESET"
        printf '    %s4%s  Something else  %s(Windsurf, Zed, Aider, Codex, Cline, ...)%s\n\n' \
            "$C_ACCENT" "$C_RESET" "$C_DIM" "$C_RESET"
        choice="$(ask "Select one option: " "1")"
        case "$choice" in
            1|claude) AGENT="claude" ;;
            2|cursor) AGENT="cursor" ;;
            3|copilot) AGENT="copilot" ;;
            4|other) AGENT="other" ;;
            *) OTHER_NAME="$choice"; AGENT="other" ;;
        esac
        say ""
    else
        # Nobody to ask, and guessing a tool would print confident
        # instructions for the wrong file. The neutral ones are right
        # whatever they use.
        AGENT="other"
    fi
fi

# ---------------------------------------------------------------------------
# Which parts of 0G. This does not change what gets cloned (the skills
# cross-reference each other, so they all come down). It decides which SDKs,
# env vars and example prompts are printed, which is the part a builder has to
# get right.
# ---------------------------------------------------------------------------
set_parts() {
    raw="$(printf '%s' "$1" | tr 'A-Z,' 'a-z ')"
    for tok in $raw; do
        case "$tok" in
            all|a) WANT_COMPUTE=1; WANT_STORAGE=1; WANT_CHAIN=1; WANT_INFT=1 ;;
            1|compute) WANT_COMPUTE=1 ;;
            2|storage) WANT_STORAGE=1 ;;
            3|chain) WANT_CHAIN=1 ;;
            4|agentic-id|agentic|inft|id) WANT_INFT=1 ;;
            *) ;;
        esac
    done
    if [ $((WANT_COMPUTE + WANT_STORAGE + WANT_CHAIN + WANT_INFT)) -eq 0 ]; then
        WANT_COMPUTE=1; WANT_STORAGE=1; WANT_CHAIN=1; WANT_INFT=1
    fi
}

if [ -n "$PARTS" ]; then
    set_parts "$PARTS"
elif interactive; then
    printf '  %sWhich parts of 0G are you building on?%s\n\n' "$C_BOLD" "$C_RESET"
    printf '    %s1%s  Compute      %sAI inference, images, speech, embeddings%s\n' \
        "$C_ACCENT" "$C_RESET" "$C_DIM" "$C_RESET"
    printf '    %s2%s  Storage      %sUpload, download and verify files%s\n' \
        "$C_ACCENT" "$C_RESET" "$C_DIM" "$C_RESET"
    printf '    %s3%s  Chain        %sContracts, transactions, tokens%s\n' \
        "$C_ACCENT" "$C_RESET" "$C_DIM" "$C_RESET"
    printf '    %s4%s  Agentic ID   %sOnchain identity for agents%s\n\n' \
        "$C_ACCENT" "$C_RESET" "$C_DIM" "$C_RESET"
    printf '  %sSeveral are fine: 1 3, or press Enter for all%s\n\n' "$C_DIM" "$C_RESET"
    set_parts "$(ask "Select one or more: " "all")"
    say ""
else
    set_parts "all"
fi

PKGS=""
[ "$WANT_STORAGE" -eq 1 ] && PKGS="$PKGS @0gfoundation/0g-storage-ts-sdk"
[ "$WANT_COMPUTE" -eq 1 ] && PKGS="$PKGS @0gfoundation/0g-compute-ts-sdk"
[ "$WANT_INFT" -eq 1 ] && PKGS="$PKGS @0gfoundation/0g-agenticid-sdk viem"
# Storage, Compute and Chain are ethers v6, pinned exactly because the storage
# SDK declares an exact peer dependency. Agentic ID is viem, so a project that
# only wants Agentic ID does not need ethers at all.
if [ $((WANT_STORAGE + WANT_COMPUTE + WANT_CHAIN)) -gt 0 ]; then
    PKGS="$PKGS ethers@6.13.1"
fi
SDKS="npm install$PKGS dotenv"

parts_label() {
    label=""
    [ "$WANT_COMPUTE" -eq 1 ] && label="$label, Compute"
    [ "$WANT_STORAGE" -eq 1 ] && label="$label, Storage"
    [ "$WANT_CHAIN" -eq 1 ] && label="$label, Chain"
    [ "$WANT_INFT" -eq 1 ] && label="$label, Agentic ID"
    printf '%s' "${label#, }"
}

# ---------------------------------------------------------------------------
# Say what will happen, then ask. Nothing above this point touched the disk.
# ---------------------------------------------------------------------------
IN_GIT=0
git rev-parse --is-inside-work-tree >/dev/null 2>&1 && IN_GIT=1

GITIGNORE_NEEDED=0
if [ "$IN_GIT" -eq 1 ]; then
    if [ -f .gitignore ] && grep -qxF "$DIR/" .gitignore; then
        GITIGNORE_NEEDED=0
    else
        GITIGNORE_NEEDED=1
    fi
fi

UPDATING=0
[ -d "$DIR/.git" ] && UPDATING=1

field "Project" "$HERE"
field "Building on" "$(parts_label)"
if [ -n "$DETECTED" ]; then
    field "Assistant" "$(agent_label "$AGENT")  ${C_DIM}(detected)${C_RESET}"
else
    field "Assistant" "$(agent_label "$AGENT")"
fi
say ""

printf '  %sThis will%s\n\n' "$C_BOLD" "$C_RESET"
if [ "$UPDATING" -eq 1 ]; then
    printf '    %s•%s update the skills already in %s./%s%s\n' "$C_ACCENT" "$C_RESET" "$C_ACCENT" "$DIR" "$C_RESET"
else
    printf '    %s•%s clone the 0G agent skills into %s./%s%s\n' "$C_ACCENT" "$C_RESET" "$C_ACCENT" "$DIR" "$C_RESET"
fi
[ "$GITIGNORE_NEEDED" -eq 1 ] && printf '    %s•%s add %s"%s/"%s to .gitignore\n' \
    "$C_ACCENT" "$C_RESET" "$C_ACCENT" "$DIR" "$C_RESET"
printf '    %s•%s print the SDKs, env vars and the line for you to add\n\n' "$C_ACCENT" "$C_RESET"
printf '  %sNothing else changes. Your instructions files and settings are left alone.%s\n\n' \
    "$C_DIM" "$C_RESET"

if interactive; then
    proceed="$(ask "Proceed? [Y/n]: " "Y")"
    case "$proceed" in
        [Nn]*) say ""; note "Nothing was installed."; say ""; exit 0 ;;
    esac
    say ""
elif [ "$ASSUME_YES" -eq 0 ]; then
    die "no terminal to confirm on. Re-run with --yes if you mean it:

       curl -fsSL https://build.0g.ai/install | sh -s -- --yes"
fi

# ---------------------------------------------------------------------------
# The skills themselves
# ---------------------------------------------------------------------------
if [ -e "$DIR" ]; then
    if [ -d "$DIR/.git" ]; then
        git -C "$DIR" pull --ff-only --quiet || die "could not update $DIR: it has local changes, or it has diverged.
     Move it aside and run this again."
        ok "Skills updated" "./$DIR"
    else
        die "$DIR exists and is not a git clone, so nothing was changed.
     Move it aside and run this again."
    fi
else
    git clone --depth 1 --quiet "$REPO" "$DIR" || die "clone failed. Check your network and try again."
    COUNT="$(find "$DIR/skills" -name SKILL.md 2>/dev/null | wc -l | tr -d ' ')"
    if [ -n "$COUNT" ] && [ "$COUNT" -gt 0 ] 2>/dev/null; then
        ok "Skills installed" "$COUNT skills in ./$DIR"
    else
        ok "Skills installed" "./$DIR"
    fi
fi

# ---------------------------------------------------------------------------
# .gitignore, only with consent, only if missing
# ---------------------------------------------------------------------------
if [ "$GITIGNORE_NEEDED" -eq 1 ]; then
    if [ -f .gitignore ] && [ -n "$(tail -c 1 .gitignore 2>/dev/null)" ]; then
        printf '\n' >> .gitignore
    fi
    printf '%s\n' "$DIR/" >> .gitignore
    ok ".gitignore updated" "\"$DIR/\" added"
fi

# ---------------------------------------------------------------------------
# The one line to add. Never write it for them: these files have no include
# mechanism, so appending is a way to lose someone's work.
# ---------------------------------------------------------------------------
case "$AGENT" in
    claude)
        TARGET="CLAUDE.md"
        GUIDE=""
        ;;
    cursor)
        TARGET=".cursor/rules/0g.mdc"
        GUIDE="$DIR/setups/cursor/README.md"
        ;;
    copilot)
        TARGET=".github/copilot-instructions.md"
        GUIDE="$DIR/setups/copilot/README.md"
        ;;
    other)
        TARGET="your assistant's instructions file"
        GUIDE=""
        ;;
esac
LINE="For anything 0G, read and follow ./$DIR/CLAUDE.md."

say ""
rule
printf '\n  %sThree things left, all yours to do%s\n' "$C_BOLD" "$C_RESET"

step "1" "Add this line to $TARGET"
cmd "$LINE"
[ -z "$GUIDE" ] || note "Setup guide: $GUIDE"
if [ "$AGENT" = "other" ]; then
    if [ -n "$OTHER_NAME" ]; then
        note "No setup guide for $OTHER_NAME yet, but the skills are not"
        note "tool-specific: they are markdown any assistant can read."
    else
        note "The skills are markdown that any assistant can read."
    fi
    note "Whichever file yours reads for instructions is the right place:"
    note "  AGENTS.md                        a growing number of tools"
    note "  CLAUDE.md                        Claude Code"
    note "  .cursor/rules/ or .cursorrules   Cursor"
    note "  .github/copilot-instructions.md  GitHub Copilot"
fi

step "2" "Install the SDKs you need"
cmd "$SDKS"

step "3" "Put these in .env"
cmd "PRIVATE_KEY=your_test_wallet_key"
if [ $((WANT_STORAGE + WANT_COMPUTE + WANT_CHAIN)) -gt 0 ]; then
    cmd "RPC_URL=$RPC_TESTNET"
fi
[ "$WANT_STORAGE" -eq 0 ] || cmd "STORAGE_INDEXER=$INDEXER_TESTNET"
[ "$WANT_INFT" -eq 0 ] || cmd "ATTESTOR_URL=$ATTESTOR_TESTNET"
note "Testnet, chain 16602. Never commit this file."
[ "$WANT_INFT" -eq 0 ] || note "Agentic ID uses viem, and the attestor URL is what picks the network."
[ "$WANT_COMPUTE" -eq 0 ] || note "Compute also needs a funded ledger: see funding below."

say ""
rule
say ""
printf '  %sTry asking your assistant%s\n' "$C_BOLD" "$C_RESET"
[ "$WANT_COMPUTE" -eq 0 ] || cmd "\"build a streaming chatbot on 0G Compute\""
[ "$WANT_STORAGE" -eq 0 ] || cmd "\"upload a file to 0G Storage and verify it\""
[ "$WANT_CHAIN" -eq 0 ] || cmd "\"deploy a Solidity contract to 0G Chain\""
[ "$WANT_INFT" -eq 0 ] || cmd "\"mint an agent on 0G AgenticID and check its reputation\""
say ""
printf '  %sSkills and docs%s   %s\n' "$C_DIM" "$C_RESET" "$REPO"
printf '  %sTestnet funds%s     %s\n' "$C_DIM" "$C_RESET" "https://build.0g.ai/funding"
say ""
printf '  %sOptional: run Claude Code itself on 0G models%s\n' "$C_DIM" "$C_RESET"
printf '  %s%s%s\n' "$C_ACCENT" "$PC_INSTALL" "$C_RESET"
say ""