#!/usr/bin/env bash
# Adopt owner hand-edits from a checkout into origin/main automatically.
#
# The owner edits docs, plans, skills and config in live checkouts without git
# (see 0 DOCS/GIT_FATIGUE.md); agent sessions are hook-blocked from writing
# there, so unclaimed dirt of those kinds is the owner's by construction and is
# WANTED. Anything parked on a side branch is, to the owner, deleted — so this
# lands straight to trunk. Source code is agent territory and is never adopted.
#
#   adopt-owner-edits.sh <checkout-dir> [--dry-run]
#
# Exit: 0 adopted (or nothing to adopt), 1 adoption failed, 2 usage/state error.
set -euo pipefail

CHECKOUT="${1:-}"
DRY_RUN="${2:-}"
[ -d "$CHECKOUT" ] || { echo "adopt-owner-edits: not a directory: $CHECKOUT" >&2; exit 2; }
git -C "$CHECKOUT" rev-parse --git-dir >/dev/null 2>&1 \
  || { echo "adopt-owner-edits: not a git checkout: $CHECKOUT" >&2; exit 2; }

# Owner-kind test. Deny before allow: lockfiles and generated trees are never
# owner edits even when their extension matches.
is_owner_kind() {
  local p="$1"
  case "$p" in
    */node_modules/*|node_modules/*) return 1 ;;
    *.lock|*-lock.yaml|*-lock.json|*.lockb) return 1 ;;
    *package.json|*tsconfig*.json) return 1 ;;
  esac
  case "$p" in
    *.md) return 0 ;;
    docs/*) return 0 ;;
  esac
  case "$p" in
    *.json|*.yaml|*.yml|*.toml)
      case "$p" in
        .claude/*|modules/workstation/*) return 0 ;;
        */*) return 1 ;;
        *) return 0 ;; # repo-root config file
      esac
      ;;
  esac
  return 1
}

cd "$CHECKOUT"
git fetch --quiet origin main || { echo "adopt-owner-edits: fetch failed" >&2; exit 2; }

mapfile -t dirty < <(git status --porcelain --untracked-files=all | sed -E 's/^.{3}//' | sed -E 's/^"(.*)"$/\1/')
adopt=()
for p in "${dirty[@]}"; do
  [ -f "$p" ] || continue                      # deletions/renames stay manual
  is_owner_kind "$p" || continue
  # A file inside a top-level directory that origin/main does not know is a
  # scratch workspace (temp-user/, ask-gpt/ downloads), not an owner edit.
  if [[ "$p" == */* ]] && ! git cat-file -e "origin/main:${p%%/*}" 2>/dev/null; then
    continue
  fi
  if git cat-file -e "origin/main:$p" 2>/dev/null \
    && git show "origin/main:$p" | cmp -s - "$p"; then
    continue                                   # already landed — stale duplicate
  fi
  adopt+=("$p")
done

if [ "${#adopt[@]}" -eq 0 ]; then
  echo "adopt-owner-edits: nothing to adopt"
  exit 0
fi

printf 'adopt-owner-edits: adopting %d owner file(s):\n' "${#adopt[@]}"
printf '  %s\n' "${adopt[@]}"
[ "$DRY_RUN" = "--dry-run" ] && exit 0

WT="$(mktemp -d)"
cleanup() { git worktree remove --force "$WT" >/dev/null 2>&1 || true; rm -rf "$WT"; }
trap cleanup EXIT
git worktree add --quiet --detach "$WT" origin/main \
  || { echo "adopt-owner-edits: cannot stage adoption worktree" >&2; exit 1; }

for p in "${adopt[@]}"; do
  mkdir -p "$WT/$(dirname "$p")"
  cp -p "$p" "$WT/$p"
done
git -C "$WT" add -A -- "${adopt[@]}"
git -C "$WT" -c core.hooksPath=/dev/null commit --quiet -m "Adopt owner edits" \
  || { echo "adopt-owner-edits: nothing staged after copy — aborting" >&2; exit 1; }

# Direct trunk push, retried once across a concurrent-land race. /usr/bin/git by
# absolute path: the plain git shim reroutes push into the interactive queue,
# which has no owner here.
push_once() {
  git -C "$WT" fetch --quiet origin main \
    && git -C "$WT" rebase --quiet origin/main \
    && /usr/bin/git -C "$WT" -c core.hooksPath=/dev/null push --quiet origin HEAD:refs/heads/main
}
push_once || push_once || { echo "adopt-owner-edits: push failed" >&2; exit 1; }

echo "adopt-owner-edits: landed $(git -C "$WT" rev-parse --short HEAD) (${#adopt[@]} file(s))"