setup

#!/usr/bin/env bash
# i18nstack setup — install i18n CLI tools + register skills/commands for Claude Code, Grok, and Codex
set -e

STACK_DIR="$(cd "$(dirname "$0")" && pwd)"
SKILLS_PARENT="$(dirname "$STACK_DIR")"
AGENT_HOME="$(dirname "$SKILLS_PARENT")"
AGENT_NAME="$(basename "$AGENT_HOME")"
AGENT_ID="${AGENT_NAME#.}"  # .claude -> claude, .grok -> grok

TOOLS=(i18n-convert i18n-pseudo i18n-validate)
HEADER_MARKER="<!-- grok-claude-sync:"
MARKER_FILE=".grok-claude-source.json"

# --- CLI tools ---------------------------------------------------------------

missing=()
for t in "${TOOLS[@]}"; do
  command -v "$t" >/dev/null 2>&1 || missing+=("$t")
done

if [ ${#missing[@]} -gt 0 ]; then
  pkgs=()
  for t in "${missing[@]}"; do pkgs+=("@i18n-agent/$t"); done
  if command -v npm >/dev/null 2>&1; then
    echo "Installing CLI tools via npm: ${missing[*]}"
    npm install -g "${pkgs[@]}" || true
  elif command -v brew >/dev/null 2>&1; then
    echo "Installing CLI tools via Homebrew: ${missing[*]}"
    brew tap i18n-agent/tap && brew install "${missing[@]}" || true
  else
    echo "⚠ Neither npm nor Homebrew found — skipping CLI install."
  fi
  still_missing=()
  for t in "${missing[@]}"; do
    command -v "$t" >/dev/null 2>&1 || still_missing+=("$t")
  done
  if [ ${#still_missing[@]} -gt 0 ]; then
    echo "⚠ Not installed: ${still_missing[*]}"
    echo "  Install manually:  npm install -g @i18n-agent/<tool>"
    echo "  or:                brew tap i18n-agent/tap && brew install <tool>"
  fi
fi

# --- agent registration helpers ----------------------------------------------

grok_compat_header() {
  local source="$1"
  local kind="$2"
  cat <<EOF
${HEADER_MARKER} ${source} -->

## Grok Compatibility

Installed by i18nstack \`setup\`. Source: \`${source}\`.

When following this ${kind} in Grok:

1. Tool mapping from Claude Code:
   - \`Read\` -> \`read_file\`
   - \`Edit\`, \`Write\`, \`MultiEdit\` -> \`search_replace\` (and write tools as needed)
   - \`Glob\`, \`Grep\`, \`LS\` -> \`list_dir\`, \`grep_search\`
   - \`Bash\` -> \`bash\`
   - \`TodoWrite\` -> \`todo_write\`
   - \`Task\`, \`Agent\`, named subagents -> \`task\` tool (use \`--subagents\` for parallel child sessions)
   - \`Skill(name)\` / \`\$name\` -> \`/name\` or read that skill's \`SKILL.md\`
   - \`WebFetch\`, \`WebSearch\` -> \`web_fetch\`, \`web_search\`
2. Placeholders: \`\$ARGUMENTS\` = all invocation args; \`\$1\` through \`\$9\` = positional args.
3. Ignore Claude-only \`allowed-tools\` frontmatter when it conflicts with session permissions.
4. Preserve safety instructions. Ask before destructive database, production, credential, deploy, or data-loss operations.

---

EOF
}

strip_grok_header() {
  local file="$1"
  python3 - "$file" <<'PY'
import sys
from pathlib import Path

text = Path(sys.argv[1]).read_text(encoding="utf-8", errors="replace")
marker = "<!-- grok-claude-sync:"
if text.startswith(marker):
    parts = text.split("---\n\n", 1)
    if len(parts) == 2 and parts[1].lstrip().startswith("## Grok Compatibility"):
        body = parts[1].split("\n---\n\n", 1)
        if len(body) == 2:
            text = body[1]
print(text, end="")
PY
}

write_marker() {
  local target="$1"
  local kind="$2"
  local source="$3"
  python3 - "$target" "$kind" "$source" <<'PY'
import json, sys
from datetime import datetime, timezone
from pathlib import Path

target, kind, source = sys.argv[1:4]
marker = {
    "generator": "i18nstack/setup",
    "kind": kind,
    "source": source,
    "updatedAt": datetime.now(timezone.utc).isoformat(),
}
path = Path(target) / ".grok-claude-source.json"
path.write_text(json.dumps(marker, indent=2, sort_keys=True) + "\n", encoding="utf-8")
PY
}

ensure_stack_entrypoint() {
  local source="$STACK_DIR/i18nstack/SKILL.md"
  local target="$STACK_DIR/SKILL.md"
  local relative_source="i18nstack/SKILL.md"

  if [ ! -f "$source" ]; then
    echo "⚠ i18nstack umbrella skill missing: $source"
    return 1
  fi

  # skills.sh discovery requires the umbrella skill to live in its own
  # directory in the repository. Direct agent installs, however, use the
  # repository root as the i18nstack package anchor and expect SKILL.md there.
  # Keep the root entrypoint generated and gitignored so both layouts work.
  if [ -L "$target" ] || [ ! -e "$target" ]; then
    ln -snf "$relative_source" "$target"
  elif ! cmp -s "$source" "$target"; then
    echo "⚠ $target exists and differs from $source — refusing to overwrite it"
    return 1
  fi
}

ensure_stack_anchor() {
  local agent_home="$1"
  local skills_dir="$agent_home/skills"
  local anchor="$skills_dir/i18nstack"

  mkdir -p "$skills_dir"
  if [ "$STACK_DIR" = "$anchor" ] || [ "$anchor" -ef "$STACK_DIR" ]; then
    return 0
  fi
  if [ -L "$anchor" ] || [ ! -e "$anchor" ]; then
    ln -snf "$STACK_DIR" "$anchor"
    return 0
  fi
  echo "⚠ $anchor exists and is not managed by i18nstack — skipping $agent_home registration"
  return 1
}

register_claude() {
  local agent_home="$1"
  local skills_dir="$agent_home/skills"
  local commands_dir="$agent_home/commands"
  local linked=() skipped=() linked_cmds=()

  ensure_stack_anchor "$agent_home" || return 0
  mkdir -p "$commands_dir"

  for skill_dir in "$STACK_DIR"/*/; do
    skill_name="$(basename "$skill_dir")"
    [[ "$skill_name" == "skills" || "$skill_name" == "i18nstack" ]] && continue
    [ -f "$skill_dir/SKILL.md" ] || continue
    target="$skills_dir/$skill_name"
    if [ -L "$target" ] || [ ! -e "$target" ]; then
      ln -snf "i18nstack/$skill_name" "$target"
      linked+=("$skill_name")
    else
      skipped+=("$skill_name")
    fi
  done

  for cmd_file in "$STACK_DIR"/commands/*.md; do
    [ -f "$cmd_file" ] || continue
    cmd_name="$(basename "$cmd_file")"
    target="$commands_dir/$cmd_name"
    if [ -L "$target" ] || [ ! -e "$target" ]; then
      ln -snf "../skills/i18nstack/commands/$cmd_name" "$target"
      linked_cmds+=("$cmd_name")
    else
      skipped+=("commands/$cmd_name")
    fi
  done

  echo "Claude Code ($agent_home):"
  echo "  linked skills: ${#linked[@]}"
  echo "  linked commands: ${#linked_cmds[@]}"
  if [ ${#skipped[@]} -gt 0 ]; then
    echo "  skipped (already exists): ${skipped[*]}"
  fi
}

register_grok() {
  local agent_home="$1"
  local skills_dir="$agent_home/skills"
  local commands_dir="$agent_home/commands"
  local linked=() skipped=() linked_cmds=()

  ensure_stack_anchor "$agent_home" || return 0
  mkdir -p "$commands_dir"

  for skill_dir in "$STACK_DIR"/*/; do
    skill_name="$(basename "$skill_dir")"
    [[ "$skill_name" == "skills" || "$skill_name" == "i18nstack" ]] && continue
    [ -f "$skill_dir/SKILL.md" ] || continue
    target="$skills_dir/$skill_name"
    if [ -L "$target" ] || [ ! -e "$target" ]; then
      ln -snf "i18nstack/$skill_name" "$target"
      write_marker "$target" "skill-symlink" "$skill_dir/SKILL.md"
      linked+=("$skill_name")
    else
      skipped+=("$skill_name")
    fi
  done

  for cmd_file in "$STACK_DIR"/commands/*.md; do
    [ -f "$cmd_file" ] || continue
    cmd_name="$(basename "$cmd_file")"
    target="$commands_dir/$cmd_name"
    if [ -L "$target" ] || [ ! -e "$target" ]; then
      {
        grok_compat_header "$cmd_file" "command"
        strip_grok_header "$cmd_file"
      } >"$target"
      linked_cmds+=("$cmd_name")
    else
      skipped+=("commands/$cmd_name")
    fi
  done

  echo "Grok ($agent_home):"
  echo "  linked skills: ${#linked[@]}"
  echo "  installed commands: ${#linked_cmds[@]}"
  if [ ${#skipped[@]} -gt 0 ]; then
    echo "  skipped (already exists): ${skipped[*]}"
  fi
}

register_codex() {
  local script="$STACK_DIR/scripts/register-codex.py"
  if [ ! -f "$script" ]; then
    echo "⚠ Codex registration script missing: $script"
    return 0
  fi
  python3 "$script" "$STACK_DIR"
}

# --- register with supported agents ------------------------------------------

ensure_stack_entrypoint

in_canonical_location=0
stack_name="$(basename "$STACK_DIR")"
parent_name="$(basename "$SKILLS_PARENT")"
agent_dir_name="$(basename "$(dirname "$SKILLS_PARENT")")"

if [ "$stack_name" = "i18nstack" ]; then
  if [ "$parent_name" = "skills" ] && { [ "$agent_dir_name" = ".claude" ] || [ "$agent_dir_name" = ".grok" ] || [ "$agent_dir_name" = ".agents" ]; }; then
    in_canonical_location=1
  elif [ "$parent_name" = ".codex" ] || [ "$SKILLS_PARENT" = "$HOME/.codex" ]; then
    in_canonical_location=1
  fi
fi

if [ "$in_canonical_location" -eq 1 ]; then
  echo ""
  if [ -d "$HOME/.claude" ] || [ "$AGENT_ID" = "claude" ]; then
    register_claude "$HOME/.claude"
  fi
  if [ -d "$HOME/.grok" ] || [ "$AGENT_ID" = "grok" ]; then
    register_grok "$HOME/.grok"
  fi
  if [ -d "$HOME/.codex" ] || [ -d "$HOME/.agents" ] || [ "$AGENT_ID" = "codex" ] || [ "$AGENT_ID" = "agents" ]; then
    register_codex
  fi
  echo ""
  echo "i18nstack ready."
else
  echo ""
  echo "i18nstack ready. (skipped skill registration — clone into a supported agent path first)"
  echo "  Claude: git clone --depth 1 https://github.com/i18n-agent/i18nstack.git ~/.claude/skills/i18nstack && ~/.claude/skills/i18nstack/setup"
  echo "  Grok:   git clone --depth 1 https://github.com/i18n-agent/i18nstack.git ~/.grok/skills/i18nstack && ~/.grok/skills/i18nstack/setup"
  echo "  Codex:  git clone --depth 1 https://github.com/i18n-agent/i18nstack.git ~/.codex/i18nstack && ~/.codex/i18nstack/setup"
fi

if [ -x "$STACK_DIR/scripts/sync-skills-catalog.sh" ]; then
  "$STACK_DIR/scripts/sync-skills-catalog.sh" >/dev/null
fi

for t in "${TOOLS[@]}"; do
  if command -v "$t" >/dev/null 2>&1; then
    echo "  $t: $("$t" --version 2>/dev/null | head -1)"
  fi
done