setup

#!/usr/bin/env bash
# nanostack setup — register skills with Claude Code / Codex / Kiro
# No build step required. No runtime dependencies.
#
# Install:
#   git clone https://github.com/garagon/nanostack.git ~/.claude/skills/nanostack
#   cd ~/.claude/skills/nanostack && ./setup
#
# Per-repo:
#   git clone https://github.com/garagon/nanostack.git .claude/skills/nanostack
#   cd .claude/skills/nanostack && ./setup
#
# Codex:
#   git clone https://github.com/garagon/nanostack.git ~/nanostack
#   cd ~/nanostack && ./setup --host codex
set -e

NANOSTACK_DIR="$(cd "$(dirname "$0")" && pwd)"
SOURCE_DIR="$(cd "$(dirname "$0")" && pwd -P)"
SKILLS_DIR="$(dirname "$NANOSTACK_DIR")"
SKILLS=(think nano review qa security ship guard conductor compound)

# Map skill name to directory (when they differ)
skill_dir() {
  case "$1" in
    nano) echo "plan" ;;
    *) echo "$1" ;;
  esac
}

# sed -i portability (BSD vs GNU)
if sed --version >/dev/null 2>&1; then
  sed_inplace() { sed -i "$@"; }
else
  sed_inplace() { sed -i '' "$@"; }
fi

# ─── Parse flags ──────────────────────────────────────────────
HOST="claude"
LOCAL_INSTALL=0
RENAMES=""
while [ $# -gt 0 ]; do
  case "$1" in
    --host)  [ -z "${2:-}" ] && echo "Missing value for --host" >&2 && exit 1; HOST="$2"; shift 2 ;;
    --host=*) HOST="${1#--host=}"; shift ;;
    --local) LOCAL_INSTALL=1; shift ;;
    --rename) [ -z "${2:-}" ] && echo "Missing value for --rename" >&2 && exit 1; RENAMES="$2"; shift 2 ;;
    --rename=*) RENAMES="${1#--rename=}"; shift ;;
    --list) LIST_SKILLS=1; shift ;;
    --help)
      cat <<'HELP'
Usage: ./setup [OPTIONS]

Options:
  --host <agent>    Target: claude (default), codex, cursor, opencode, gemini, auto
  --local           Install to .claude/skills/ in current working directory
  --rename <map>    Rename skills to avoid collisions (comma-separated old=new pairs)
  --rename reset    Restore all skills to their original names
  --list            Show installed skills and their current names
  --help            Show this help

Install methods:
  # Global (recommended)
  git clone https://github.com/garagon/nanostack.git ~/.claude/skills/nanostack
  cd ~/.claude/skills/nanostack && ./setup

  # Per-repo
  ./setup --local

  # Multi-agent
  ./setup --host auto

  # Rename skills that collide with other tools
  ./setup --rename "review=nano-review,security=nano-security"

  # See current skill names
  ./setup --list

  # Restore original names
  ./setup --rename reset
HELP
      exit 0
      ;;
    *) shift ;;
  esac
done

# Handle --list (show skills and exit)
if [ "${LIST_SKILLS:-0}" -eq 1 ]; then
  echo "Nanostack Skills"
  echo "================"
  # Load saved renames
  if [ -f "$HOME/.nanostack/setup.json" ]; then
    saved=$(jq -r '.renames // {} | to_entries[] | "\(.key)=\(.value)"' "$HOME/.nanostack/setup.json" 2>/dev/null | tr '\n' ' ')
  fi
  for skill in "${SKILLS[@]}"; do
    renamed=""
    for pair in $saved; do
      old="${pair%%=*}"
      new="${pair#*=}"
      if [ "$old" = "$skill" ]; then
        renamed="$new"
        break
      fi
    done
    if [ -n "$renamed" ]; then
      echo "  /$renamed (original: /$skill)"
    else
      echo "  /$skill"
    fi
  done
  echo ""
  echo "To rename: ./setup --rename \"review=nano-review\""
  echo "To reset:  ./setup --rename reset"
  exit 0
fi

# Handle --rename reset
if [ "$RENAMES" = "reset" ]; then
  RENAMES=""
  if [ -f "$HOME/.nanostack/setup.json" ]; then
    jq '.renames = {}' "$HOME/.nanostack/setup.json" > "$HOME/.nanostack/setup.json.tmp" && \
      mv "$HOME/.nanostack/setup.json.tmp" "$HOME/.nanostack/setup.json"
  fi
  echo "Renames cleared. Running setup with original names..."
  echo ""
fi

case "$HOST" in
  claude|codex|cursor|opencode|gemini|auto) ;;
  *) echo "Unknown --host: $HOST (expected claude, codex, cursor, opencode, gemini, or auto)" >&2; exit 1 ;;
esac

# --local override
if [ "$LOCAL_INSTALL" -eq 1 ]; then
  SKILLS_DIR="$(pwd)/.claude/skills"
  mkdir -p "$SKILLS_DIR"
  NANOSTACK_LOCAL="$SKILLS_DIR/nanostack"
  if [ ! -e "$NANOSTACK_LOCAL" ]; then
    ln -snf "$SOURCE_DIR" "$NANOSTACK_LOCAL"
    echo "Linked $NANOSTACK_LOCAL → $SOURCE_DIR"
  fi
  HOST="claude"
fi

# ─── Rename map ──────────────────────────────────────────────
# Parse --rename "review=ns-review,security=ns-sec" into a lookup.
# Renames persist in ~/.nanostack/setup.json so upgrade.sh reapplies them.
# Uses a flat string "old=new old2=new2" for bash 3 compatibility (macOS).
RENAME_PAIRS=""

if [ -z "$RENAMES" ]; then
  # Load saved renames from previous setup
  if [ -f "$HOME/.nanostack/setup.json" ]; then
    saved_renames=$(jq -r '.renames // {} | to_entries[] | "\(.key)=\(.value)"' "$HOME/.nanostack/setup.json" 2>/dev/null | tr '\n' ',')
    RENAMES="${saved_renames%,}"
  fi
fi

if [ -n "$RENAMES" ]; then
  RENAME_PAIRS=$(echo "$RENAMES" | tr ',' ' ')
fi

# Get the public name for a skill (after renames)
skill_public_name() {
  local skill="$1"
  for pair in $RENAME_PAIRS; do
    local old="${pair%%=*}"
    local new="${pair#*=}"
    if [ "$old" = "$skill" ]; then
      echo "$new"
      return
    fi
  done
  echo "$skill"
}

# Install a renamed skill: copy SKILL.md with updated name in frontmatter
install_renamed_skill() {
  local skill="$1"
  local public_name="$2"
  local target_dir="$3"
  local dir
  dir=$(skill_dir "$skill")

  mkdir -p "$target_dir/$public_name"

  # Copy SKILL.md with updated name field
  sed "s/^name: .*/name: $public_name/" "$SOURCE_DIR/$dir/SKILL.md" > "$target_dir/$public_name/SKILL.md"

  # Symlink everything else (references, templates, bin, etc.)
  for item in "$SOURCE_DIR/$dir"/*; do
    local basename
    basename=$(basename "$item")
    [ "$basename" = "SKILL.md" ] && continue
    ln -snf "$item" "$target_dir/$public_name/$basename" 2>/dev/null || true
  done
}

# ─── Auto-detect agents ──────────────────────────────────────
INSTALL_CLAUDE=0
INSTALL_CODEX=0
INSTALL_CURSOR=0
INSTALL_OPENCODE=0
INSTALL_GEMINI=0

if [ "$HOST" = "auto" ]; then
  command -v claude >/dev/null 2>&1 && INSTALL_CLAUDE=1
  command -v codex >/dev/null 2>&1 && INSTALL_CODEX=1
  command -v cursor >/dev/null 2>&1 && INSTALL_CURSOR=1
  command -v opencode >/dev/null 2>&1 && INSTALL_OPENCODE=1
  command -v gemini >/dev/null 2>&1 && INSTALL_GEMINI=1
  # Default to claude if nothing detected
  TOTAL=$((INSTALL_CLAUDE + INSTALL_CODEX + INSTALL_CURSOR + INSTALL_OPENCODE + INSTALL_GEMINI))
  [ "$TOTAL" -eq 0 ] && INSTALL_CLAUDE=1
elif [ "$HOST" = "claude" ]; then
  INSTALL_CLAUDE=1
elif [ "$HOST" = "codex" ]; then
  INSTALL_CODEX=1
elif [ "$HOST" = "cursor" ]; then
  INSTALL_CURSOR=1
elif [ "$HOST" = "opencode" ]; then
  INSTALL_OPENCODE=1
elif [ "$HOST" = "gemini" ]; then
  INSTALL_GEMINI=1
fi

# ─── Claude Code ──────────────────────────────────────────────
# Creates symlinks from ~/.claude/skills/<skill> → nanostack/<skill>
# so Claude Code discovers each skill as a top-level slash command.
install_claude() {
  local skills_dir="$1"
  local linked=()
  local renamed=()

  # Check we're inside a skills directory
  local basename
  basename="$(basename "$skills_dir")"
  if [ "$basename" != "skills" ]; then
    echo "  (skipped skill symlinks — not inside a skills/ directory)"
    echo "  Recommended: git clone into ~/.claude/skills/nanostack"
    return
  fi

  for skill in "${SKILLS[@]}"; do
    local public_name
    public_name=$(skill_public_name "$skill")
    local dir
    dir=$(skill_dir "$skill")

    # Clean up: remove old symlink with the original name if we're renaming
    if [ "$public_name" != "$skill" ]; then
      [ -L "$skills_dir/$skill" ] && rm -f "$skills_dir/$skill"
    fi

    local target="$skills_dir/$public_name"

    # Always remove stale symlink/dir at target to recreate cleanly
    [ -L "$target" ] && rm -f "$target"
    [ -d "$target" ] && [ ! -L "$target" ] && rm -rf "$target"

    if [ "$public_name" != "$skill" ]; then
      # Renamed: copy SKILL.md with new name, symlink the rest
      install_renamed_skill "$skill" "$public_name" "$skills_dir"
      renamed+=("/$skill > /$public_name")
    else
      # Normal: symlink the directory
      ln -snf "nanostack/$dir" "$target"
      linked+=("$skill")
    fi
  done

  if [ ${#linked[@]} -gt 0 ]; then
    echo "  Linked skills: ${linked[*]}"
  fi
  if [ ${#renamed[@]} -gt 0 ]; then
    echo "  Renamed skills: ${renamed[*]}"
  fi
}

# ─── OpenAI Codex ─────────────────────────────────────────────
# Creates nanostack-<skill> directories with symlinks in ~/.codex/skills/
install_codex() {
  local codex_skills="${HOME}/.codex/skills"
  mkdir -p "$codex_skills"

  # Create runtime root with symlinks to source
  local codex_root="$codex_skills/nanostack"
  mkdir -p "$codex_root"
  ln -snf "$SOURCE_DIR/SKILL.md" "$codex_root/SKILL.md"
  ln -snf "$SOURCE_DIR/AGENTS.md" "$codex_root/AGENTS.md"

  local linked=()
  for skill in "${SKILLS[@]}"; do
    local target="$codex_skills/nanostack-${skill}"
    if [ -L "$target" ] || [ ! -e "$target" ]; then
      ln -snf "$SOURCE_DIR/$skill" "$target"
      linked+=("nanostack-${skill}")
    fi
  done

  if [ ${#linked[@]} -gt 0 ]; then
    echo "  Linked skills: ${linked[*]}"
  fi
}

# ─── Cursor ───────────────────────────────────────────────────
# Creates .cursor/rules/ with skill references
install_cursor() {
  local cursor_rules=".cursor/rules"
  mkdir -p "$cursor_rules"

  # Create a rule that loads nanostack skills
  cat > "$cursor_rules/nanostack.md" << CURSORRULE
---
description: "Nanostack engineering workflow skills"
alwaysApply: true
---

You have access to nanostack skills. Read SKILL.md files in ~/.claude/skills/nanostack/ for instructions.

Available: /think, /nano, /review, /qa, /security, /ship, /guard, /conductor
Workflow: /think → /nano → build → /review → /qa → /security → /ship
CURSORRULE

  echo "  Created $cursor_rules/nanostack.md"
}

# ─── OpenCode ─────────────────────────────────────────────────
# Symlinks into ~/.agents/skills/ (OpenCode scans this natively)
install_opencode() {
  local agents_skills="${HOME}/.agents/skills"
  mkdir -p "$agents_skills"

  local agents_root="$agents_skills/nanostack"
  if [ -L "$agents_root" ] || [ ! -e "$agents_root" ]; then
    ln -snf "$SOURCE_DIR" "$agents_root"
    echo "  Linked $agents_root → $SOURCE_DIR"
  fi
}

# ─── Gemini CLI ───────────────────────────────────────────────
# Installs as Gemini extension
install_gemini() {
  echo "  Gemini CLI: run 'gemini extensions install $SOURCE_DIR' to install"
  echo "  Or for development: 'gemini extensions link $SOURCE_DIR'"
}

# ─── Config ──────────────────────────────────────────────────
# Persist installation metadata to ~/.nanostack/setup.json
write_setup_config() {
  local config_dir="$HOME/.nanostack"
  mkdir -p "$config_dir"

  local agents="[]"
  [ "$INSTALL_CLAUDE" -eq 1 ] && agents=$(echo "$agents" | jq '. + ["claude"]')
  [ "$INSTALL_CODEX" -eq 1 ] && agents=$(echo "$agents" | jq '. + ["codex"]')
  [ "$INSTALL_CURSOR" -eq 1 ] && agents=$(echo "$agents" | jq '. + ["cursor"]')
  [ "$INSTALL_OPENCODE" -eq 1 ] && agents=$(echo "$agents" | jq '. + ["opencode"]')
  [ "$INSTALL_GEMINI" -eq 1 ] && agents=$(echo "$agents" | jq '. + ["gemini"]')

  # Build renames JSON object
  local renames_json="{}"
  for pair in $RENAME_PAIRS; do
    local old="${pair%%=*}"
    local new="${pair#*=}"
    renames_json=$(echo "$renames_json" | jq --arg k "$old" --arg v "$new" '. + {($k): $v}')
  done

  jq -n \
    --arg src "$SOURCE_DIR" \
    --arg ver "$(git -C "$SOURCE_DIR" describe --tags 2>/dev/null || git -C "$SOURCE_DIR" rev-parse --short HEAD 2>/dev/null || echo 'unknown')" \
    --argjson agents "$agents" \
    --argjson local "$LOCAL_INSTALL" \
    --argjson renames "$renames_json" \
    --arg date "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" \
    '{
      schema_version: "1",
      source: $src,
      version: $ver,
      agents: $agents,
      local_install: ($local == 1),
      renames: $renames,
      installed_at: $date
    }' > "$config_dir/setup.json"
}

# ─── Execute ──────────────────────────────────────────────────
echo "Nanostack Setup"
echo "================"
echo ""

if [ "$INSTALL_CLAUDE" -eq 1 ]; then
  install_claude "$SKILLS_DIR"
  if [ "$LOCAL_INSTALL" -eq 1 ]; then
    echo "nanostack ready (claude, project-local)."
  else
    echo "nanostack ready (claude)."
  fi
  echo "  skills: $SKILLS_DIR"
fi

if [ "$INSTALL_CODEX" -eq 1 ]; then
  install_codex
  echo "nanostack ready (codex)."
  echo "  skills: ${HOME}/.codex/skills"
fi

if [ "$INSTALL_CURSOR" -eq 1 ]; then
  install_cursor
  echo "nanostack ready (cursor)."
fi

if [ "$INSTALL_OPENCODE" -eq 1 ]; then
  install_opencode
  echo "nanostack ready (opencode)."
  echo "  skills: ${HOME}/.agents/skills/nanostack"
fi

if [ "$INSTALL_GEMINI" -eq 1 ]; then
  install_gemini
  echo "nanostack ready (gemini)."
fi

# Save installation config
write_setup_config
echo ""
echo "  config: ~/.nanostack/setup.json"

echo ""
echo "Available skills:"
for skill in "${SKILLS[@]}"; do
  pname=$(skill_public_name "$skill")
  if [ "$pname" != "$skill" ]; then
    echo "  /$pname (renamed from /$skill)"
  else
    echo "  /$skill"
  fi
done
echo ""
# Build workflow line with renames applied
w_think=$(skill_public_name "think")
w_nano=$(skill_public_name "nano")
w_review=$(skill_public_name "review")
w_qa=$(skill_public_name "qa")
w_security=$(skill_public_name "security")
w_ship=$(skill_public_name "ship")
w_guard=$(skill_public_name "guard")
echo "Workflow: /$w_think → /$w_nano → build → /$w_review → /$w_qa → /$w_security → /$w_ship"
echo "Safety:   /$w_guard (activate on-demand)"
echo ""
echo "Per-project setup (run once in each project):"
echo "  ~/.claude/skills/nanostack/bin/init-project.sh"
echo ""
echo "Update:    ~/.claude/skills/nanostack/bin/upgrade.sh"