Auto-archive every Claude Code session into a `claude_sessions` folder

#!/usr/bin/env bash
# Auto-archive each Claude Code session as a new Fresh Jots note inside
# the claude_sessions folder, with a rolling 50-file local stash as a
# fallback for offline / API-down moments.
# Wired in ~/.claude/settings.json for PreCompact + SessionEnd events.
# Always exits 0 — failures log, never block the user.

set -uo pipefail

STASH_DIR="$HOME/.claude/freshjots-stash"
LOG_FILE="$STASH_DIR/.log"
FOLDER_ID_FILE="$STASH_DIR/.folder-id"
FOLDER_NAME="claude_sessions"
KEEP=50

mkdir -p "$STASH_DIR"
log() { printf '[%s] %s\n' "$(date -Iseconds)" "$*" >> "$LOG_FILE"; }

INPUT=$(cat)
SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty')
EVENT=$(printf '%s' "$INPUT" | jq -r '.hook_event_name // empty')
log "FIRED event='$EVENT' session='$SESSION_ID'"

[ -z "$SESSION_ID" ] && { log "ABORT: no session_id"; exit 0; }
[ -z "${FRESHJOTS_TOKEN:-}" ] && { log "ABORT: FRESHJOTS_TOKEN not set"; exit 0; }

# Locate the JSONL Claude Code is writing for this session.
TRANSCRIPT_JSONL=$(find "$HOME/.claude/projects" -maxdepth 2 \
    -name "${SESSION_ID}.jsonl" -type f 2>/dev/null | head -1)
if [ -z "$TRANSCRIPT_JSONL" ] || [ ! -s "$TRANSCRIPT_JSONL" ]; then
    log "ABORT: could not locate JSONL for session_id=$SESSION_ID"
    exit 0
fi

# Title: per-day counter, derived from how many stash files we already
# have for today. The counter is best-effort — it's not a global UUID,
# just enough to keep the day's titles sortable.
TODAY=$(date +%Y-%m-%d)
EXISTING=$(ls -1 "$STASH_DIR"/claude-code-"$TODAY"-session-*.txt 2>/dev/null | wc -l)
N=$((EXISTING + 1))
TITLE="claude-code-${TODAY}-session-${N}"
STASH_PATH="$STASH_DIR/${TITLE}.txt"

# Flatten JSONL → role-prefixed plain text.
jq -r '
  if .type == "user" then
    if (.message.content | type) == "string" then
      "USER:\n" + .message.content + "\n"
    elif (.message.content | type) == "array" then
      [.message.content[] |
        if .type == "tool_result" then
          "TOOL RESULT:\n" + (if (.content | type) == "string" then .content
                              elif (.content | type) == "array" then
                                ([.[] | if .type == "text" then .text else (. | tostring) end] | join("\n"))
                              else (. | tostring) end) + "\n"
        elif .type == "text" then "USER:\n" + .text + "\n"
        else empty end
      ] | join("\n")
    else empty end
  elif .type == "assistant" then
    [.message.content[] |
      if .type == "text" then "ASSISTANT:\n" + .text + "\n"
      elif .type == "tool_use" then "[Tool: " + .name + "]\n" + (.input | tojson) + "\n"
      else empty end
    ] | join("\n")
  else empty end
' "$TRANSCRIPT_JSONL" > "$STASH_PATH" 2>>"$LOG_FILE"

# If the structured render produced nothing usable, fall back to raw JSONL.
if [ "$(wc -c < "$STASH_PATH")" -lt 100 ]; then
    cp "$TRANSCRIPT_JSONL" "$STASH_PATH"
fi
printf '\n==================== TRANSCRIPT END · %s ====================\n' \
    "$(date -Iseconds)" >> "$STASH_PATH"
log "STASHED $STASH_PATH ($(wc -c < "$STASH_PATH" | tr -d ' ') bytes)"

# Find-or-create the claude_sessions folder. Cache the id so we don't
# round-trip the lookup on every session.
folder_id=""

if [ -s "$FOLDER_ID_FILE" ]; then
    cached=$(cat "$FOLDER_ID_FILE")
    status=$(curl -sS --max-time 15 -o /dev/null -w '%{http_code}' \
        -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
        "https://freshjots.com/api/v1/folders/$cached")
    [ "$status" = "200" ] && folder_id=$cached
fi

if [ -z "$folder_id" ]; then
    folder_id=$(curl -sS --max-time 15 \
        -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
        "https://freshjots.com/api/v1/folders" \
      | jq -r --arg n "$FOLDER_NAME" \
            '.folders[]? | select(.name == $n) | .id' | head -1)
fi

if [ -z "$folder_id" ]; then
    folder_id=$(curl -sS --max-time 15 \
        -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
        -H "Content-Type: application/json" \
        -X POST -d "{\"folder\":{\"name\":\"$FOLDER_NAME\"}}" \
        "https://freshjots.com/api/v1/folders" \
      | jq -r '.id // empty')
fi

if [ -n "$folder_id" ]; then
    echo "$folder_id" > "$FOLDER_ID_FILE"
else
    log "WARN: could not resolve/create folder '$FOLDER_NAME'; posting at root"
fi

# Build the JSON payload and POST.
PAYLOAD=$(mktemp)
RESPONSE=$(mktemp)
trap 'rm -f "$PAYLOAD" "$RESPONSE"' EXIT

if [ -n "$folder_id" ]; then
    jq -Rs --arg title "$TITLE" --argjson fid "$folder_id" \
        '{note: {title: $title, plain_body: ., format: "plain", folder_id: $fid}}' \
        < "$STASH_PATH" > "$PAYLOAD"
else
    jq -Rs --arg title "$TITLE" \
        '{note: {title: $title, plain_body: ., format: "plain"}}' \
        < "$STASH_PATH" > "$PAYLOAD"
fi

STATUS=$(curl -sS -o "$RESPONSE" -w '%{http_code}' --max-time 30 \
    -X POST https://freshjots.com/api/v1/notes \
    -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
    -H "Content-Type: application/json" \
    --data-binary "@$PAYLOAD" 2>>"$LOG_FILE")

case "$STATUS" in
    201) log "SUCCESS: created note #$(jq -r '.id // "?"' < "$RESPONSE") '$TITLE' folder_id=$folder_id" ;;
    *)   log "FAILURE: status=$STATUS body=$(head -c 256 "$RESPONSE" 2>/dev/null); LOCAL STASH at $STASH_PATH" ;;
esac

# Rotate the stash: keep the 50 most-recently-modified .txt files.
( cd "$STASH_DIR" && ls -1t *.txt 2>/dev/null | tail -n +$((KEEP + 1)) | while IFS= read -r f; do rm -f -- "$f"; done )

exit 0

chmod +x ~/.claude/hooks/freshjots-claude-sessions.sh
bash -n ~/.claude/hooks/freshjots-claude-sessions.sh && echo "syntax OK"

{
  "hooks": {
    "PreCompact": [
      {
        "matcher": "",
        "hooks": [
          { "type": "command", "command": "bash /home/USERNAME/.claude/hooks/freshjots-claude-sessions.sh" }
        ]
      }
    ],
    "SessionEnd": [
      {
        "matcher": "clear|other|prompt_input_exit",
        "hooks": [
          { "type": "command", "command": "bash /home/USERNAME/.claude/hooks/freshjots-claude-sessions.sh" }
        ]
      }
    ]
  }
}

jq . ~/.claude/settings.json > /dev/null && echo "JSON valid"

# 1. Verify the cached id, if we have one.
curl -sS -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
    "https://freshjots.com/api/v1/folders/$cached"
# 200 → reuse the cached id. 404 → fall through.

# 2. List folders and scan for the name.
curl -sS -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
    "https://freshjots.com/api/v1/folders"
# .folders[] | select(.name == "claude_sessions") | .id

# 3. Create the folder if it's not there.
curl -sS -X POST \
    -H "Authorization: Bearer $FRESHJOTS_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"folder":{"name":"claude_sessions"}}' \
    "https://freshjots.com/api/v1/folders"
# 201 → use the new id. Persist it.

( cd "$STASH_DIR" && ls -1t *.txt 2>/dev/null | tail -n +51 | while IFS= read -r f; do rm -f -- "$f"; done )

tail -f ~/.claude/freshjots-stash/.log

[2026-05-14T14:22:05+02:00] FIRED event='SessionEnd' session='abc-123'
[2026-05-14T14:22:05+02:00] STASHED /home/you/.claude/freshjots-stash/claude-code-2026-05-14-session-1.txt (8432 bytes)
[2026-05-14T14:22:06+02:00] SUCCESS: created note #142 'claude-code-2026-05-14-session-1' folder_id=37