# Claude Code memory + skills <-> Obsidian vault
#
# Two things under ~/.claude have no other backup (not in Time Machine, and the
# dotfiles repo is public so work content can't go there):
#
#   memory   ~/.claude/projects/<slug>/memory/      -> vault AI/memories/<slug>/
#   skills   ~/.claude/<dir>/  (skills, commands)   -> vault AI/<dir>/
#
# `task memory:link` / `task skills:link` move the real directory into the vault
# and leave a symlink behind, so Obsidian Sync backs it up continuously.
# On a new machine: install Obsidian, let Sync pull the vault, then run both
# link tasks again to recreate the symlinks.
#
# Fallback if symlinks ever misbehave: `task <x>:unlink` puts real directories
# back, then `task <x>:mirror` does a manual one-way rsync.
#
# ~/.claude/commands currently symlinks into the public dotfiles repo, so
# skills:link leaves it alone (skills:status shows ELSEWHERE) and skills:mirror
# copies its contents into the vault as a point-in-time backup. To move it into
# the vault for good:
#     task skills:mirror && rm ~/.claude/commands && task skills:link

version: '3'
silent: true

vars:
  VAULT: '{{.HOME}}/Documents/vault/AI/memories'
  PROJECTS: '{{.HOME}}/.claude/projects'
  AI_VAULT: '{{.HOME}}/Documents/vault/AI'
  CLAUDE_HOME: '{{.HOME}}/.claude'
  CLAUDE_DIRS: 'skills commands'

tasks:
  default:
    cmds:
      - task --list

  memory:link:
    desc: Move Claude memory dirs into the vault and symlink them back (idempotent; also restores on a new machine)
    cmds:
      - |
        set -eu
        mkdir -p "{{.VAULT}}"
        # 1. Migrate: real memory dirs -> vault, leave symlink behind
        for p in "{{.PROJECTS}}"/*/; do
          slug=$(basename "$p"); src="${p%/}/memory"; dst="{{.VAULT}}/$slug"
          [ -L "$src" ] && continue
          [ -d "$src" ] || continue
          mkdir -p "$dst"
          rsync -a "$src/" "$dst/"
          mv "$src" "$src.migrating"
          if [ -e "$src" ]; then rsync -a "$src/" "$dst/"; rm -rf "$src"; fi   # write landed mid-move
          ln -s "$dst" "$src"
          rsync -au "$src.migrating/" "$dst/"                                    # catch stragglers
          rm -rf "$src.migrating"
          echo "migrated  $slug"
        done
        # 2. Restore: vault dirs with no project symlink yet
        for d in "{{.VAULT}}"/*/; do
          slug=$(basename "$d"); src="{{.PROJECTS}}/$slug/memory"
          [ -e "$src" ] && continue
          mkdir -p "{{.PROJECTS}}/$slug"
          ln -s "${d%/}" "$src"
          echo "restored  $slug"
        done

  memory:status:
    desc: Show which memory dirs are symlinked into the vault, and any that are not
    cmds:
      - |
        for p in "{{.PROJECTS}}"/*/; do
          slug=$(basename "$p"); src="${p%/}/memory"
          [ -e "$src" ] || [ -L "$src" ] || continue
          n=$(find "$src/" -maxdepth 1 -name '*.md' 2>/dev/null | wc -l | tr -d ' ')
          if [ -L "$src" ]; then
            case "$(readlink "$src")" in
              "{{.VAULT}}"/*) [ -d "$src/" ] && printf 'ok        %4s  %s\n' "$n" "$slug" || printf 'BROKEN    %4s  %s\n' "$n" "$slug" ;;
              *) printf 'ELSEWHERE %4s  %s -> %s\n' "$n" "$slug" "$(readlink "$src")" ;;
            esac
          else
            printf 'UNLINKED  %4s  %s\n' "$n" "$slug"
          fi
        done
        for d in "{{.VAULT}}"/*/; do
          slug=$(basename "$d")
          [ -e "{{.PROJECTS}}/$slug/memory" ] || printf 'VAULT-ONLY      %s\n' "$slug"
        done

  memory:unlink:
    desc: Replace each symlink with a real directory copied from the vault (fallback path)
    cmds:
      - |
        set -eu
        for p in "{{.PROJECTS}}"/*/; do
          slug=$(basename "$p"); src="${p%/}/memory"
          [ -L "$src" ] || continue
          target=$(readlink "$src")
          rm "$src"; mkdir -p "$src"
          rsync -a "$target/" "$src/"
          echo "unlinked  $slug"
        done

  memory:mirror:
    desc: Manual one-way rsync of real (non-symlinked) memory dirs into the vault, mirroring deletions
    cmds:
      - |
        set -eu
        mkdir -p "{{.VAULT}}"
        for p in "{{.PROJECTS}}"/*/; do
          slug=$(basename "$p"); src="${p%/}/memory"; dst="{{.VAULT}}/$slug"
          [ -d "$src" ] || continue
          [ -L "$src" ] && continue
          [ -n "$(ls -A "$src")" ] || continue
          mkdir -p "$dst"
          rsync -a --delete "$src/" "$dst/"
          echo "mirrored  $slug"
        done

  skills:link:
    desc: Move ~/.claude/{skills,commands} into the vault (AI/<dir>) and symlink them back (idempotent; also restores on a new machine)
    cmds:
      - |
        set -eu
        mkdir -p "{{.AI_VAULT}}" "{{.CLAUDE_HOME}}"
        for name in {{.CLAUDE_DIRS}}; do
          src="{{.CLAUDE_HOME}}/$name"; dst="{{.AI_VAULT}}/$name"
          if [ -L "$src" ]; then
            [ "$(readlink "$src")" = "$dst" ] || echo "skipped   $name -> $(readlink "$src")  (symlink elsewhere; not touching it)"
            continue
          fi
          if [ -d "$src" ]; then
            # Migrate: real dir -> vault, leave symlink behind
            mkdir -p "$dst"
            rsync -a --exclude .DS_Store "$src/" "$dst/"
            mv "$src" "$src.migrating"
            if [ -e "$src" ]; then rsync -a --exclude .DS_Store "$src/" "$dst/"; rm -rf "$src"; fi   # write landed mid-move
            ln -s "$dst" "$src"
            rsync -au --exclude .DS_Store "$src.migrating/" "$dst/"                                    # catch stragglers
            rm -rf "$src.migrating"
            echo "migrated  $name"
          elif [ -d "$dst" ]; then
            # Restore: vault has it, ~/.claude does not
            ln -s "$dst" "$src"
            echo "restored  $name"
          fi
        done

  skills:status:
    desc: Show whether each ~/.claude dir (skills, commands) is symlinked into the vault
    cmds:
      - |
        for name in {{.CLAUDE_DIRS}}; do
          src="{{.CLAUDE_HOME}}/$name"; dst="{{.AI_VAULT}}/$name"
          n=$(find "$src/" -type f ! -name .DS_Store 2>/dev/null | wc -l | tr -d ' ')
          if [ -L "$src" ]; then
            if [ "$(readlink "$src")" = "$dst" ]; then
              [ -d "$src/" ] && printf 'ok        %4s  %s\n' "$n" "$name" || printf 'BROKEN    %4s  %s\n' "$n" "$name"
            else
              extra=""
              if [ -d "$dst" ]; then
                pending=$(rsync -ani --delete --exclude .DS_Store "$src/" "$dst/" | grep -vc '^\.' || true)
                [ "$pending" = 0 ] && extra="  [vault copy in sync]" || extra="  [vault copy STALE: $pending changes; run: task skills:mirror]"
              fi
              printf 'ELSEWHERE %4s  %s -> %s%s\n' "$n" "$name" "$(readlink "$src")" "$extra"
            fi
          elif [ -d "$src" ]; then
            printf 'UNLINKED  %4s  %s\n' "$n" "$name"
          elif [ -d "$dst" ]; then
            printf 'VAULT-ONLY      %s\n' "$name"
          fi
        done

  skills:unlink:
    desc: Replace each vault symlink under ~/.claude with a real directory copied from the vault (fallback path)
    cmds:
      - |
        set -eu
        for name in {{.CLAUDE_DIRS}}; do
          src="{{.CLAUDE_HOME}}/$name"; dst="{{.AI_VAULT}}/$name"
          [ -L "$src" ] || continue
          [ "$(readlink "$src")" = "$dst" ] || continue   # leave symlinks that point elsewhere (e.g. dotfiles) alone
          rm "$src"; mkdir -p "$src"
          rsync -a "$dst/" "$src/"
          echo "unlinked  $name"
        done

  skills:mirror:
    desc: Manual one-way rsync of non-vault ~/.claude dirs (real dirs, or symlinks into dotfiles) into the vault, mirroring deletions
    cmds:
      - |
        set -eu
        mkdir -p "{{.AI_VAULT}}"
        for name in {{.CLAUDE_DIRS}}; do
          src="{{.CLAUDE_HOME}}/$name"; dst="{{.AI_VAULT}}/$name"
          [ -d "$src/" ] || continue
          [ -L "$src" ] && [ "$(readlink "$src")" = "$dst" ] && continue   # already lives in the vault
          [ -n "$(ls -A "$src/")" ] || continue
          mkdir -p "$dst"
          rsync -a --delete --exclude .DS_Store "$src/" "$dst/"
          echo "mirrored  $name"
        done