Aadi

Thread Summary

AI chats

About

A catch up card for a long thread that streams its points, decisions and open questions, then folds to the top three.

Built with React and Tailwind. Copy the prompt and paste it into Claude Code, Cursor or Lovable: your agent adds Thread Summary to your project and fits it to your theme.

Code

How Thread Summary is used: the demo's code. The component's own source comes with a free account.

Usage.tsx

"use client"

import * as React from "react"
import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip"
import { ThreadSummary, ThreadSummaryPoint, ThreadSummaryStatus } from "@/components/ui/thread-summary"

interface GhostState {
  x: number
  y: number
  shown: boolean
  down: boolean
}

/**
 * A pointer that walks a demo through its clicks, so a preview shows what each control does.
 * `stage` is the positioned box the pointer moves in; targets are found inside it. Sizes come
 * from layout boxes, so a scaled FitFrame never throws the aim off.
 */
function useGhost(stage: React.RefObject<HTMLElement | null>) {
  const [ghost, setGhost] = React.useState<GhostState>({ x: 0, y: 0, shown: false, down: false })

  const find = React.useCallback(
    (target: string | HTMLElement) =>
      typeof target === "string"
        ? stage.current?.querySelector<HTMLElement>(target) ?? null
        : target,
    [stage],
  )

  const moveTo = React.useCallback(
    (target: string | HTMLElement, dx = 0.5, dy = 0.6) => {
      const root = stage.current
      const el = find(target)
      if (!root || !el) return null
      const rr = root.getBoundingClientRect()
      const scale = root.offsetWidth ? rr.width / root.offsetWidth : 1
      const er = el.getBoundingClientRect()
      const x = (er.left - rr.left + er.width * dx) / scale
      const y = (er.top - rr.top + er.height * dy) / scale
      // A hidden pointer fades in a short way off its first target instead of flying in from
      // wherever it was last.
      setGhost((g) => (g.shown ? { x, y, shown: true, down: false } : { x: x + 70, y: y + 46, shown: false, down: false }))
      window.requestAnimationFrame(() =>
        window.requestAnimationFrame(() => setGhost({ x, y, shown: true, down: false })),
      )
      return el
    },
    [stage, find],
  )

  const press = React.useCallback((down: boolean) => setGhost((g) => ({ ...g, down })), [])
  const hide = React.useCallback(() => setGhost((g) => ({ ...g, shown: false, down: false })), [])

  return { ghost, moveTo, press, hide, find }
}

const code = (text: string) => <code className="font-mono text-[0.9em]">{text}</code>

const summaryPoints: ThreadSummaryPoint[] = [
  {
    id: "s1",
    messageId: "m-4",
    text: (
      <>
        Sessions move from Redis to a {code("sessions")} table in Postgres, keyed by a hashed token.
      </>
    ),
  },
  {
    id: "s2",
    messageId: "m-18",
    text: "Reads stay under 2 ms at p95 with a partial index on unexpired rows.",
  },
  {
    id: "s3",
    messageId: "m-27",
    text: "Log out everywhere now deletes rows instead of scanning Redis keys.",
  },
  {
    id: "s4",
    messageId: "m-41",
    text: "A nightly job removes expired sessions in batches of 5,000.",
  },
  {
    id: "s5",
    messageId: "m-63",
    text: "Cutover runs dual writes for 7 days before Redis is switched off.",
  },
]

/** A trimmed thread, so the open summary fits the preview at a readable size. */
const POINTS = summaryPoints.slice(0, 3)

const summaryDecisions: ThreadSummaryPoint[] = [
  {
    id: "d1",
    messageId: "m-9",
    text: "Store only a SHA-256 of the token, never the token itself.",
  },
  {
    id: "d2",
    messageId: "m-22",
    text: "Keep the 30 day sliding expiry, refreshed at most once an hour.",
  },
  { id: "d3", messageId: "m-70", text: "No Redis fallback after cutover." },
]

const DECISIONS = summaryDecisions.slice(0, 2)

const summaryQuestions: ThreadSummaryPoint[] = [
  {
    id: "q1",
    messageId: "m-75",
    text: "Do mobile clients need a path for sessions older than 30 days?",
  },
  { id: "q2", messageId: "m-80", text: "Who gets paged when the cleanup job fails?" },
]

const QUESTIONS = summaryQuestions.slice(0, 1)

const ORDER = [
  ...POINTS.map((p) => ["summary", p] as const),
  ...DECISIONS.map((p) => ["decisions", p] as const),
  ...QUESTIONS.map((p) => ["questions", p] as const),
]

const POINT_MS = 520

const reducedMotion = () =>
  typeof window !== "undefined" && window.matchMedia("(prefers-reduced-motion: reduce)").matches

const STOP = Symbol("stop")

/**
 * Runs `script` in a loop with a `wait(ms)` that stops cleanly on unmount or once `active` turns
 * false. Reduced motion never starts it.
 */
function useLoop(
  script: (wait: (ms: number) => Promise<void>) => Promise<void>,
  active = true,
) {
  const ref = React.useRef(script)
  ref.current = script
  React.useEffect(() => {
    if (!active || reducedMotion()) return
    let alive = true
    const timers = new Set<number>()
    const wait = (ms: number) =>
      new Promise<void>((resolve, reject) => {
        const id = window.setTimeout(() => {
          timers.delete(id)
          if (alive) resolve()
          else reject(STOP)
        }, ms)
        timers.add(id)
      })
    ;(async () => {
      try {
        while (alive) await ref.current(wait)
      } catch (error) {
        if (error !== STOP) throw error
      }
    })()
    return () => {
      alive = false
      for (const id of timers) window.clearTimeout(id)
    }
  }, [active])
}

/** Moves to a target, presses and clicks it. Returns the element, or null if it is gone. */
async function tap(
  g: ReturnType<typeof useGhost>,
  target: string | HTMLElement,
  wait: (ms: number) => Promise<void>,
  travel = 700,
) {
  if (!g.moveTo(target)) return null
  await wait(travel)
  g.press(true)
  await wait(130)
  const el = g.find(target)
  el?.click()
  g.press(false)
  return el
}

const FIT_CSS = "html,body{overflow:hidden}[data-fit-small] [data-fit-hide]{display:none!important}"

/**
 * 21st shows a demo in a small frame: about 674 by 421 on a component page, 358 by 224 on a
 * phone and 245 by 139 on a profile card. A demo taller than its frame gets scrollbars, which
 * render white on dark pages. FitFrame fills the frame exactly instead.
 *
 * - "scale": the content shrinks until it fits, centered. For visuals such as orbs.
 * - "crop": the content stays at full size from the top and fades out at the bottom. For text
 *   that streams in, where a changing scale would make the page breathe.
 *
 * `minWidth` lays out a wide demo (a table, a two column panel) at that width and scales it down
 * to the frame, instead of letting it collapse to a narrow layout. The frame centers it, so it
 * shrinks evenly on both sides.
 *
 * Anything marked `data-fit-hide` (state buttons, the chatcn.dev line) drops out in frames
 * shorter than `hideBelow`, so a profile card shows the visual alone.
 */
function FitFrame({
  children,
  mode = "scale",
  hideBelow = 360,
  minWidth,
}: {
  children: React.ReactNode
  mode?: "scale" | "crop"
  hideBelow?: number
  minWidth?: string
}) {
  const content = React.useRef<HTMLDivElement>(null)
  const [cropped, setCropped] = React.useState(false)

  React.useLayoutEffect(() => {
    const el = content.current
    if (!el) return
    const measure = () => {
      const vw = window.innerWidth
      const vh = window.innerHeight
      el.toggleAttribute("data-fit-small", vh < hideBelow)
      // Layout sizes ignore the transform, so measuring never feeds back.
      const w = Math.max(el.offsetWidth, el.scrollWidth)
      const h = Math.max(el.offsetHeight, el.scrollHeight)
      const scale = mode === "scale" ? Math.min(1, vw / w, vh / h) : 1
      el.style.transform = scale < 1 ? `scale(${scale})` : ""
      setCropped(mode === "crop" && h > vh + 1)
    }
    measure()
    const observer = new ResizeObserver(measure)
    observer.observe(el)
    // Content that changes inside a fixed width box (a headline that cycles words) never resizes
    // the box itself, so changes below it measure again on the next frame.
    let frame = 0
    const mutations = new MutationObserver(() => {
      cancelAnimationFrame(frame)
      frame = requestAnimationFrame(measure)
    })
    mutations.observe(el, { subtree: true, childList: true, characterData: true })
    window.addEventListener("resize", measure)
    return () => {
      observer.disconnect()
      mutations.disconnect()
      cancelAnimationFrame(frame)
      window.removeEventListener("resize", measure)
    }
  }, [mode, hideBelow])

  const fade = "linear-gradient(to bottom, #000 calc(100% - 40px), transparent)"
  return (
    <div
      className="flex w-full justify-center overflow-hidden"
      style={{
        height: "100dvh",
        alignItems: mode === "crop" ? "flex-start" : "center",
        maskImage: cropped ? fade : undefined,
        WebkitMaskImage: cropped ? fade : undefined,
      }}
    >
      <style>{FIT_CSS}</style>
      <div
        ref={content}
        className="w-full shrink-0"
        style={{ transformOrigin: mode === "crop" ? "top center" : "center", minWidth }}
      >
        {children}
      </div>
    </div>
  )
}

/**
 * Wrap the app once. After the first tooltip opens, the next ones open instantly, the way
 * native toolbars behave.
 */
function TooltipProvider({
  delay = 500,
  ...props
}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
  return <TooltipPrimitive.Provider delay={delay} closeDelay={0} {...props} />
}

/** The pointer itself. Put it last inside the stage, which must be `relative`. */
function Ghost({ ghost }: { ghost: GhostState }) {
  return (
    <div
      aria-hidden
      className="pointer-events-none absolute top-0 left-0 z-20"
      style={{
        transform: `translate(${ghost.x}px, ${ghost.y}px)`,
        opacity: ghost.shown ? 1 : 0,
        // Hidden, it jumps; shown, it glides.
        transition: ghost.shown
          ? "transform 620ms cubic-bezier(0.4, 0, 0.2, 1), opacity 220ms ease-out"
          : "opacity 220ms ease-out",
      }}
    >
      <svg
        width="18"
        height="20"
        viewBox="0 0 18 20"
        className="drop-shadow-[0_1px_2px_rgb(0_0_0/0.25)]"
        style={{
          transform: ghost.down ? "scale(0.86)" : "scale(1)",
          transformOrigin: "2px 2px",
          transition: "transform 120ms ease-out",
        }}
      >
        <path
          d="M2 1.5 L2 16 L5.9 12.4 L8.6 18.3 L11.2 17.1 L8.6 11.3 L13.9 11.1 Z"
          className="fill-[oklch(0.2_0_0)] stroke-white dark:fill-white dark:stroke-[oklch(0.2_0_0)]"
          strokeWidth="1.3"
          strokeLinejoin="round"
        />
      </svg>
    </div>
  )
}

/** The line under each 21st demo that points back to the kit. */
function MoreOn({ slug, children }: { slug: string; children: React.ReactNode }) {
  return (
    <p data-fit-hide className="text-[0.75rem]/[1rem] text-(color:--chatcn-fg-faint) text-center text-balance">
      {children}{" "}
      <a
        href={`https://chatcn.dev/docs/components/${slug}`}
        target="_blank"
        rel="noopener"
        className="text-(color:--chatcn-fg-subtle) hover:text-(color:--chatcn-fg) underline underline-offset-2"
      >
        chatcn.dev
      </a>
    </p>
  )
}

/**
 * A long thread about moving sessions to Postgres. The summary reads the messages, writes its
 * points, decisions and open questions in place with a caret on the newest. The pointer folds it to the top three points and regenerates. Loops. Click anything
 * to stop the tour and open, fold or regenerate it yourself.
 */
export default function ThreadSummaryPreview() {
  const stage = React.useRef<HTMLDivElement>(null)
  const g = useGhost(stage)
  const [touring, setTouring] = React.useState(true)
  const [count, setCount] = React.useState(ORDER.length + 1)
  const [status, setStatus] = React.useState<ThreadSummaryStatus>("done")
  const [open, setOpen] = React.useState(true)
  const [regen, setRegen] = React.useState(0)

  // After the tour, Regenerate writes the summary again on its own timers.
  React.useEffect(() => {
    if (regen === 0) return
    const timers: number[] = []
    setOpen(true)
    setCount(0)
    setStatus("loading")
    timers.push(window.setTimeout(() => setStatus("streaming"), 1300))
    for (let n = 1; n <= ORDER.length + 1; n += 1) {
      timers.push(window.setTimeout(() => setCount(n), 1300 + n * POINT_MS))
    }
    timers.push(window.setTimeout(() => setStatus("done"), 1300 + (ORDER.length + 2) * POINT_MS))
    return () => {
      for (const id of timers) window.clearTimeout(id)
    }
  }, [regen])

  /** Reads, then writes each point in turn. */
  const write = async (wait: (ms: number) => Promise<void>) => {
    setOpen(true)
    setCount(0)
    setStatus("loading")
    await wait(1300)
    setStatus("streaming")
    for (let n = 1; n <= ORDER.length + 1; n += 1) {
      setCount(n)
      await wait(POINT_MS)
    }
    setStatus("done")
  }

  useLoop(async (wait) => {
    await write(wait)
    await wait(2200)
    await tap(g, '[data-slot="thread-summary"] > button', wait)
    await wait(2000)
    await tap(g, '[data-slot="thread-summary"] button[aria-label="Regenerate summary"]', wait)
    ;(document.activeElement as HTMLElement | null)?.blur()
    g.hide()
  }, touring)

  const shown = ORDER.slice(0, count)
  const pick = (k: string) => shown.filter(([s]) => s === k).map(([, p]) => p)

  return (
    <FitFrame minWidth="36rem">
      <div className="flex w-full flex-col items-center justify-center gap-3 p-5">
        <TooltipProvider>
          <div
            ref={stage}
            className="relative flex h-[22rem] w-full max-w-xl items-start justify-center"
            onPointerDown={() => {
              if (!touring) return
              setTouring(false)
              g.hide()
            }}
          >
            <ThreadSummary
              title="Catch up"
              meta="86 messages since yesterday"
              status={status}
              loadingText="Reading 86 messages"
              open={open}
              onOpenChange={setOpen}
              summary={pick("summary")}
              decisions={pick("decisions")}
              questions={pick("questions")}
              onJump={() => {}}
              onRegenerate={() => {
                if (!touring) setRegen((r) => r + 1)
              }}
            />
            <Ghost ghost={g.ghost} />
          </div>
        </TooltipProvider>
        <MoreOn slug="thread-summary">Catch up on a long thread: points, decisions and open questions. On</MoreOn>
      </div>
    </FitFrame>
  )
}

Dependencies

More by Aadi

View all
  • Audio Visualizer

    Audio Visualizer

    29
  • Stat Card

    Stat Card

    24
  • Dither Orb

    Dither Orb

    23
  • Voice Orb

    Voice Orb

    17
  • Waveform

    Waveform

    13
  • Message Feedback

    Message Feedback

    12
  • Agent Lanes

    Agent Lanes

    11
  • Voice Controls

    Voice Controls

    10

More in AI chats

View all
  • AI Actions

    AI Actions

    349
  • Aquarium Prompt

    Aquarium Prompt

    95
  • Generation Stats

    Generation Stats

  • Chat Bubble

    Chat Bubble

    202
  • Commit

    Commit

    36
  • Color Picker

    Color Picker

    190
  • Environment Variables

    Environment Variables

    27
  • Message With Header And Delivery Status

    Message With Header And Delivery Status

    57

Explore more

Part of chatcn — browse the full library on 21st.dev.