#!/bin/sh
# sync-memory.sh -- additive union between the REPO memory store and the
# machine-local HARNESS PROFILE memory store.
#
# WHY: There are TWO memory stores on every machine:
#   REPO store    : <root>/.claude/memory/                 (git-tracked, synced via Gitea -- SOURCE OF TRUTH)
#   PROFILE store : $HOME/.claude/projects/<slug>/memory/  (machine-local, NOT in git;
#                                                            the harness auto-injects THIS into the prompt)
# They drift. This script keeps the auto-injected PROFILE store in step with the
# synced REPO store, while preserving any memories authored only on this machine.
#
# ADDITIVE UNION -- NO DELETES, NO DESTRUCTIVE OVERWRITES:
#   * file in REPO but not in PROFILE   -> copy REPO -> PROFILE
#   * file in PROFILE but not in REPO   -> copy PROFILE -> REPO  (capture local-only for git sync)
#   * file in BOTH, identical           -> nothing
#   * file in BOTH, content differs     -> DO NOT overwrite; log "CONFLICT (manual review)"
#   * never deletes from either side.
#
# Idempotent and safe to run repeatedly on every machine (Windows Git Bash,
# macOS, Linux). ASCII output only. No hardcoded drive paths.
#
# Flags:
#   --dry-run   show what WOULD be copied; copy nothing, create nothing.
#
# Exit: 0 normally (including when conflicts are present -- they are reported,
# not fatal). Non-zero only on a hard setup error (no repo, no memory dir).

set -u

DRY_RUN=0
for arg in "$@"; do
    case "$arg" in
        --dry-run) DRY_RUN=1 ;;
        -h|--help)
            echo "Usage: sync-memory.sh [--dry-run]"
            echo "  Additive union of the repo and harness-profile memory stores."
            echo "  --dry-run   print planned copies; change nothing."
            exit 0
            ;;
        *)
            echo "[ERROR] unknown argument: $arg" >&2
            echo "Usage: sync-memory.sh [--dry-run]" >&2
            exit 2
            ;;
    esac
done

# --- Resolve CLAUDETOOLS_ROOT (env -> identity.json -> git toplevel -> script dir) ---

# Absolute dir of this script, POSIX-portable (no readlink -f on macOS).
script_path="$0"
case "$script_path" in
    /*) : ;;
    *) script_path="$(pwd)/$script_path" ;;
esac
SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$script_path")" && pwd)"

ROOT=""
if [ -n "${CLAUDETOOLS_ROOT:-}" ] && [ -d "${CLAUDETOOLS_ROOT}" ]; then
    ROOT="$CLAUDETOOLS_ROOT"
fi

# Walk up from the script dir to find a dir containing .claude/ (covers the
# normal layout <root>/.claude/scripts/sync-memory.sh).
if [ -z "$ROOT" ]; then
    d="$SCRIPT_DIR"
    while [ "$d" != "/" ] && [ -n "$d" ]; do
        if [ -d "$d/.claude" ]; then
            ROOT="$d"
            break
        fi
        parent="$(dirname -- "$d")"
        [ "$parent" = "$d" ] && break
        d="$parent"
    done
fi

# identity.json may override with claudetools_root (authoritative per machine).
if [ -n "$ROOT" ] && [ -f "$ROOT/.claude/identity.json" ]; then
    ID_ROOT="$(
        PYBIN=""
        for c in py python3 python; do
            if command -v "$c" >/dev/null 2>&1; then PYBIN="$c"; break; fi
        done
        if [ -n "$PYBIN" ]; then
            "$PYBIN" - "$ROOT/.claude/identity.json" <<'PYEOF' 2>/dev/null
import json, os, sys
try:
    d = json.load(open(sys.argv[1]))
    r = d.get("claudetools_root")
    if r and os.path.isdir(r):
        print(r)
except Exception:
    pass
PYEOF
        fi
    )"
    if [ -n "$ID_ROOT" ] && [ -d "$ID_ROOT" ]; then
        ROOT="$ID_ROOT"
    fi
fi

# Last resort: git toplevel.
if [ -z "$ROOT" ]; then
    ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
fi

if [ -z "$ROOT" ] || [ ! -d "$ROOT/.claude" ]; then
    echo "[ERROR] could not resolve CLAUDETOOLS_ROOT (no .claude dir found)." >&2
    exit 1
fi

REPO_MEM="$ROOT/.claude/memory"
if [ ! -d "$REPO_MEM" ]; then
    echo "[ERROR] repo memory dir not found: $REPO_MEM" >&2
    exit 1
fi

# --- Derive the harness profile memory dir ---------------------------------
# Slug = absolute project path with every run of non-alphanumeric chars -> '-'.
# Must match memory_dream.py's derivation. Prefer CLAUDE_PROJECT_DIR if set.
HOME_DIR="${HOME:-$(cd ~ 2>/dev/null && pwd)}"
PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$ROOT}"

# Absolutize PROJECT_DIR.
case "$PROJECT_DIR" in
    /*) : ;;
    *) PROJECT_DIR="$(CDPATH= cd -- "$PROJECT_DIR" 2>/dev/null && pwd || echo "$PROJECT_DIR")" ;;
esac

# Compute the slug. Use Python when available (exact, matches the analyzer);
# otherwise fall back to sed/tr.
# Single-dash collapse: replace any non-alphanumeric run with a single '-'.
# Prefer Python (exact, matches the analyzer) when available, else sed.
SLUG_SINGLE=""
PYBIN=""
for c in py python3 python; do
    if command -v "$c" >/dev/null 2>&1; then PYBIN="$c"; break; fi
done
if [ -n "$PYBIN" ]; then
    SLUG_SINGLE="$(
        "$PYBIN" - "$PROJECT_DIR" <<'PYEOF' 2>/dev/null
import os, re, sys
print(re.sub(r"[^A-Za-z0-9]+", "-", os.path.abspath(sys.argv[1])))
PYEOF
    )"
fi
if [ -z "$SLUG_SINGLE" ]; then
    SLUG_SINGLE="$(printf '%s' "$PROJECT_DIR" | sed 's/[^A-Za-z0-9][^A-Za-z0-9]*/-/g')"
fi

# The Claude Code harness maps a Windows drive colon to '--' (so
# "D:\claudetools" -> "D--claudetools"), while the single-dash collapse above
# produces "D-claudetools". Reproduce the harness rule by doubling a leading
# "<drive>-" into "<drive>--".
SLUG_DOUBLE="$(printf '%s' "$SLUG_SINGLE" | sed 's/^\([A-Za-z]\)-/\1--/')"

# Resolve the profile dir. Try the EXACT candidate slugs in priority order
# (harness double-dash first, then single-dash collapse); use the first whose
# profile memory dir actually exists.
PROJ_ROOT="$HOME_DIR/.claude/projects"
SLUG=""
PROFILE_MEM=""
SKIP_PROFILE=0
for cand_slug in "$SLUG_DOUBLE" "$SLUG_SINGLE"; do
    [ -n "$cand_slug" ] || continue
    if [ -d "$PROJ_ROOT/$cand_slug/memory" ]; then
        SLUG="$cand_slug"
        PROFILE_MEM="$PROJ_ROOT/$cand_slug/memory"
        break
    elif [ -d "$PROJ_ROOT/$cand_slug" ]; then
        SLUG="$cand_slug"
        PROFILE_MEM="$PROJ_ROOT/$cand_slug/memory"
        break
    fi
done

# ONLY if no exact candidate exists, fall back to a case-insensitive tail-scan
# of $HOME/.claude/projects/*/memory for a dir whose slug ends with the repo's
# basename. If MORE THAN ONE dir matches, do NOT guess -- skip the profile side
# entirely to avoid cross-project contamination.
if [ -z "$PROFILE_MEM" ]; then
    # Default to the harness (double-dash) slug for messaging / dir creation.
    SLUG="$SLUG_DOUBLE"
    PROFILE_MEM="$PROJ_ROOT/$SLUG/memory"
    if [ -d "$PROJ_ROOT" ]; then
        BASE="$(basename -- "$ROOT")"
        BASE_SLUG="$(printf '%s' "$BASE" | sed 's/[^A-Za-z0-9][^A-Za-z0-9]*/-/g' | tr 'A-Z' 'a-z')"
        MATCH_COUNT=0
        MATCH_LIST=""
        MATCH_DIR=""
        for cand in "$PROJ_ROOT"/*/memory; do
            [ -d "$cand" ] || continue
            cand_parent="$(basename -- "$(dirname -- "$cand")")"
            cand_lc="$(printf '%s' "$cand_parent" | tr 'A-Z' 'a-z')"
            case "$cand_lc" in
                *"$BASE_SLUG")
                    MATCH_COUNT=$((MATCH_COUNT + 1))
                    MATCH_DIR="$cand"
                    if [ -z "$MATCH_LIST" ]; then
                        MATCH_LIST="$cand_parent"
                    else
                        MATCH_LIST="$MATCH_LIST, $cand_parent"
                    fi
                    ;;
            esac
        done
        if [ "$MATCH_COUNT" -gt 1 ]; then
            echo "[WARNING] multiple profile dirs matched ($MATCH_LIST); skipping profile sync to avoid cross-project contamination"
            SKIP_PROFILE=1
        elif [ "$MATCH_COUNT" -eq 1 ]; then
            PROFILE_MEM="$MATCH_DIR"
            SLUG="$(basename -- "$(dirname -- "$MATCH_DIR")")"
        fi
    fi
fi

echo "[INFO] sync-memory.sh"
if [ "$DRY_RUN" -eq 1 ]; then
    echo "[INFO] MODE: DRY-RUN (no files will be copied or created)"
else
    echo "[INFO] MODE: APPLY (additive union)"
fi
echo "[INFO] repo store    : $REPO_MEM"
if [ "$SKIP_PROFILE" -eq 1 ]; then
    echo "[INFO] profile store : (skipped -- ambiguous match)"
    echo "[INFO] profile slug  : (skipped -- ambiguous match)"
    echo "[INFO] ----- summary -----"
    echo "[INFO] profile sync SKIPPED: multiple candidate profile dirs matched; refusing to guess."
    echo "[INFO] additive-only: no file was deleted or overwritten on either side."
    exit 0
fi
echo "[INFO] profile store : $PROFILE_MEM"
echo "[INFO] profile slug  : $SLUG"

# Create the profile dir (apply mode only).
if [ ! -d "$PROFILE_MEM" ]; then
    if [ "$DRY_RUN" -eq 1 ]; then
        echo "[INFO] would create profile dir: $PROFILE_MEM"
    else
        mkdir -p "$PROFILE_MEM" || {
            echo "[ERROR] could not create profile dir: $PROFILE_MEM" >&2
            exit 1
        }
        echo "[OK] created profile dir: $PROFILE_MEM"
    fi
fi

# --- Build the union of *.md basenames (excluding MEMORY.md) ----------------
# MEMORY.md (the human index) is intentionally NOT synced -- the repo index is
# authoritative and the profile index is regenerated by the harness; copying it
# either way would create a guaranteed perpetual "conflict".

list_md() {
    # $1 = dir ; prints basenames of *.md except MEMORY.md, one per line
    dir="$1"
    [ -d "$dir" ] || return 0
    for f in "$dir"/*.md; do
        [ -e "$f" ] || continue
        b="$(basename -- "$f")"
        case "$b" in
            MEMORY.md|memory.md) continue ;;
        esac
        printf '%s\n' "$b"
    done
}

# Collect names into a deduped, sorted list using a temp file (portable).
NAMES_TMP="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/sync-memory-names.$$")"
trap 'rm -f "$NAMES_TMP"' EXIT INT TERM
{
    list_md "$REPO_MEM"
    [ -d "$PROFILE_MEM" ] && list_md "$PROFILE_MEM"
} | sort -u > "$NAMES_TMP"

copied_r2p=0
copied_p2r=0
conflicts=0
identical=0

# Copy helper honoring dry-run.
do_copy() {
    src="$1"; dst="$2"; label="$3"
    if [ "$DRY_RUN" -eq 1 ]; then
        echo "[DRY-RUN] would copy $label : $(basename -- "$src")"
    else
        # Belt-and-suspenders no-clobber: even though the caller only invokes
        # do_copy when the destination is absent, re-check here to close any
        # TOCTOU window and protect against future refactors. ADDITIVE-ONLY:
        # never overwrite an existing destination.
        if [ -e "$dst" ]; then
            echo "[SKIP] dst appeared, not overwriting: $(basename -- "$dst")"
            return 0
        fi
        # cp -p preserves mtime; portable across BSD/GNU.
        if cp -p "$src" "$dst" 2>/dev/null || cp "$src" "$dst"; then
            echo "[OK] copied $label : $(basename -- "$src")"
        else
            echo "[ERROR] failed to copy $label : $(basename -- "$src")" >&2
            return 1
        fi
    fi
}

while IFS= read -r name; do
    [ -n "$name" ] || continue
    r="$REPO_MEM/$name"
    p="$PROFILE_MEM/$name"
    if [ -f "$r" ] && [ ! -f "$p" ]; then
        do_copy "$r" "$p" "REPO->PROFILE" && copied_r2p=$((copied_r2p + 1))
    elif [ ! -f "$r" ] && [ -f "$p" ]; then
        do_copy "$p" "$r" "PROFILE->REPO" && copied_p2r=$((copied_p2r + 1))
    elif [ -f "$r" ] && [ -f "$p" ]; then
        if cmp -s "$r" "$p"; then
            identical=$((identical + 1))
        else
            echo "[CONFLICT] $name : repo and profile differ -- left untouched (manual review)"
            conflicts=$((conflicts + 1))
        fi
    fi
done < "$NAMES_TMP"

echo "[INFO] ----- summary -----"
echo "[INFO] copied REPO   -> PROFILE : $copied_r2p"
echo "[INFO] copied PROFILE -> REPO   : $copied_p2r"
echo "[INFO] identical (no action)    : $identical"
echo "[INFO] conflicts (manual review): $conflicts"
if [ "$DRY_RUN" -eq 1 ]; then
    echo "[INFO] DRY-RUN: nothing was changed."
fi
echo "[INFO] additive-only: no file was deleted or overwritten on either side."

exit 0