web: add store-lite agents cache

brandonkachen · brandonkachen · commit ad2bbe4c5835 · 2025-12-16T15:02:25.000-08:00
diff --git a/web/src/app/api/healthz/route.ts b/web/src/app/api/healthz/route.ts
@@ -1,11 +1,11 @@
 import { NextResponse } from 'next/server'
-import { getCachedAgents } from '@/server/agents-data'
+import { getCachedAgentsLite } from '@/server/agents-data'
 
 export const GET = async () => {
   try {
     // Warm the cache by fetching agents data
     // This ensures SEO-critical data is available immediately
-    const agents = await getCachedAgents()
+    const agents = await getCachedAgentsLite()
 
     return NextResponse.json({
       status: 'ok',
diff --git a/web/src/app/sitemap.ts b/web/src/app/sitemap.ts
@@ -1,5 +1,5 @@
 import { env } from '@codebuff/common/env'
-import { getCachedAgents } from '@/server/agents-data'
+import { getCachedAgentsLite } from '@/server/agents-data'
 
 import type { MetadataRoute } from 'next'
 
@@ -28,7 +28,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 
   // Include agent detail pages and publisher pages derived from cached store data
   try {
-    const agents = await getCachedAgents()
+    const agents = await getCachedAgentsLite()
 
     const seenPublishers = new Set<string>()
     for (const agent of agents) {
diff --git a/web/src/app/store/page.tsx b/web/src/app/store/page.tsx
@@ -1,5 +1,5 @@
 import { Metadata } from 'next'
-import { getCachedAgents } from '@/server/agents-data'
+import { getCachedAgentsLite } from '@/server/agents-data'
 import AgentStoreClient from './store-client'
 
 interface PublisherProfileResponse {
@@ -15,7 +15,7 @@ export async function generateMetadata(): Promise<Metadata> {
     publisher?: { avatar_url?: string | null }
   }> = []
   try {
-    agents = await getCachedAgents()
+    agents = await getCachedAgentsLite()
   } catch (error) {
     console.error('[Store] Failed to fetch agents for metadata:', error)
     agents = []
@@ -61,7 +61,7 @@ export default async function StorePage({ searchParams }: StorePageProps) {
   // Fetch agents data on the server with ISR cache
   let agentsData: any[] = []
   try {
-    agentsData = await getCachedAgents()
+    agentsData = await getCachedAgentsLite()
   } catch (error) {
     console.error('[Store] Failed to fetch agents data:', error)
     agentsData = []
diff --git a/web/src/app/store/store-client.tsx b/web/src/app/store/store-client.tsx
@@ -3,6 +3,7 @@
 import { useMemo, useCallback, memo, useEffect, useRef, useState } from 'react'
 import { useQuery } from '@tanstack/react-query'
 import { useSession } from 'next-auth/react'
+import { useRouter } from 'next/navigation'
 import {
   Search,
   TrendingUp,
@@ -127,6 +128,7 @@ export default function AgentStoreClient({
   session: initialSession,
   searchParams,
 }: AgentStoreClientProps) {
+  const router = useRouter()
   // Use client-side session for authentication state, but don't block rendering
   const { data: clientSession, status: sessionStatus } = useSession()
   const session = clientSession || initialSession
@@ -151,6 +153,18 @@ export default function AgentStoreClient({
   // Local state for immediate input feedback
   const [localSearchQuery, setLocalSearchQuery] = useState(searchQuery)
 
+  const prefetchedRoutes = useRef<Set<string>>(new Set())
+  const prefetchRoute = useCallback(
+    (href: string) => {
+      if (prefetchedRoutes.current.has(href)) {
+        return
+      }
+      prefetchedRoutes.current.add(href)
+      router.prefetch(href)
+    },
+    [router],
+  )
+
   const observerRef = useRef<IntersectionObserver | null>(null)
   const loadMoreRef = useRef<HTMLDivElement>(null)
   const prevFilters = useRef({ searchQuery: '', sortBy: 'cost' })
@@ -388,9 +402,14 @@ export default function AgentStoreClient({
     agent: AgentData
     isEditorsChoice?: boolean
   }) {
+    const href = `/publishers/${agent.publisher.id}/agents/${agent.id}/${agent.version || '1.0.0'}`
     return (
       <Link
-        href={`/publishers/${agent.publisher.id}/agents/${agent.id}/${agent.version || '1.0.0'}`}
+        href={href}
+        prefetch={false}
+        onMouseEnter={() => prefetchRoute(href)}
+        onFocus={() => prefetchRoute(href)}
+        onTouchStart={() => prefetchRoute(href)}
         className="block group"
       >
         <Card
diff --git a/web/src/server/__tests__/agents-transform.test.ts b/web/src/server/__tests__/agents-transform.test.ts
@@ -1,5 +1,9 @@
 import { describe, it, expect } from '@jest/globals'
-import { buildAgentsData, type AgentRow } from '../agents-transform'
+import {
+  buildAgentsData,
+  buildAgentsDataLite,
+  type AgentRow,
+} from '../agents-transform'
 
 describe('buildAgentsData', () => {
   it('dedupes by latest and merges metrics + sorts by weekly_spent', () => {
@@ -255,3 +259,149 @@ describe('buildAgentsData', () => {
     })
   })
 })
+
+describe('buildAgentsDataLite', () => {
+  it('dedupes by latest, merges metrics, and omits version_stats', () => {
+    const agents: AgentRow[] = [
+      {
+        id: 'base',
+        version: '1.0.0',
+        data: { name: 'Base', description: 'desc', tags: ['x'] },
+        created_at: '2025-01-01T00:00:00.000Z',
+        publisher: {
+          id: 'codebuff',
+          name: 'Codebuff',
+          verified: true,
+          avatar_url: null,
+        },
+      },
+      // older duplicate by name should be ignored due to first-seen is latest ordering
+      {
+        id: 'base-old',
+        version: '0.9.0',
+        data: { name: 'Base', description: 'old' },
+        created_at: '2024-12-01T00:00:00.000Z',
+        publisher: {
+          id: 'codebuff',
+          name: 'Codebuff',
+          verified: true,
+          avatar_url: null,
+        },
+      },
+      {
+        id: 'reviewer',
+        version: '2.1.0',
+        data: { name: 'Reviewer' },
+        created_at: '2025-01-03T00:00:00.000Z',
+        publisher: {
+          id: 'codebuff',
+          name: 'Codebuff',
+          verified: true,
+          avatar_url: null,
+        },
+      },
+    ]
+
+    const usageMetrics = [
+      {
+        publisher_id: 'codebuff',
+        agent_name: 'Base',
+        total_invocations: 50,
+        total_dollars: 100,
+        avg_cost_per_run: 2,
+        unique_users: 4,
+        last_used: new Date('2025-01-05T00:00:00.000Z'),
+      },
+      {
+        publisher_id: 'codebuff',
+        agent_name: 'reviewer',
+        total_invocations: 5,
+        total_dollars: 5,
+        avg_cost_per_run: 1,
+        unique_users: 1,
+        last_used: new Date('2025-01-04T00:00:00.000Z'),
+      },
+    ]
+
+    const weeklyMetrics = [
+      {
+        publisher_id: 'codebuff',
+        agent_name: 'Base',
+        weekly_runs: 10,
+        weekly_dollars: 20,
+      },
+      {
+        publisher_id: 'codebuff',
+        agent_name: 'reviewer',
+        weekly_runs: 2,
+        weekly_dollars: 1,
+      },
+    ]
+
+    const out = buildAgentsDataLite({
+      agents,
+      usageMetrics: usageMetrics as any,
+      weeklyMetrics: weeklyMetrics as any,
+    })
+
+    // should have deduped to two agents
+    expect(out.length).toBe(2)
+
+    const base = out.find((a) => a.id === 'base')!
+    expect(base.name).toBe('Base')
+    expect(base.weekly_spent).toBe(20)
+    expect(base.weekly_runs).toBe(10)
+    expect(base.total_spent).toBe(100)
+    expect(base.usage_count).toBe(50)
+    expect(base.avg_cost_per_invocation).toBe(2)
+    expect(base.unique_users).toBe(4)
+    expect(base.version_stats).toBeUndefined()
+    expect(Object.prototype.hasOwnProperty.call(base, 'version_stats')).toBe(
+      false,
+    )
+
+    // sorted by weekly_spent desc
+    expect(out[0].weekly_spent! >= out[1].weekly_spent!).toBe(true)
+  })
+
+  it('handles missing metrics gracefully and omits version_stats', () => {
+    const agents = [
+      {
+        id: 'solo',
+        version: '0.1.0',
+        data: { description: 'no name provided' },
+        created_at: new Date('2025-02-01T00:00:00.000Z'),
+        publisher: {
+          id: 'codebuff',
+          name: 'Codebuff',
+          verified: true,
+          avatar_url: null,
+        },
+      },
+    ] as any
+
+    const out = buildAgentsDataLite({
+      agents,
+      usageMetrics: [],
+      weeklyMetrics: [],
+    })
+
+    expect(out).toHaveLength(1)
+    const a = out[0]
+    // falls back to id when name missing
+    expect(a.name).toBe('solo')
+    // defaults present
+    expect(a.weekly_spent).toBe(0)
+    expect(a.weekly_runs).toBe(0)
+    expect(a.total_spent).toBe(0)
+    expect(a.usage_count).toBe(0)
+    expect(a.avg_cost_per_invocation).toBe(0)
+    expect(a.unique_users).toBe(0)
+    expect(a.last_used).toBeUndefined()
+    expect(a.version_stats).toBeUndefined()
+    expect(Object.prototype.hasOwnProperty.call(a, 'version_stats')).toBe(false)
+    expect(a.tags).toEqual([])
+    // created_at normalized to string
+    expect(typeof a.created_at).toBe('string')
+  })
+})
diff --git a/web/src/server/agents-data.ts b/web/src/server/agents-data.ts
@@ -2,7 +2,7 @@ import db from '@codebuff/internal/db'
 import * as schema from '@codebuff/internal/db/schema'
 import { unstable_cache } from 'next/cache'
 import { sql, eq, and, gte } from 'drizzle-orm'
-import { buildAgentsData } from './agents-transform'
+import { buildAgentsData, buildAgentsDataLite } from './agents-transform'
 
 export interface AgentData {
   id: string
@@ -156,6 +156,82 @@ export const fetchAgentsWithMetrics = async (): Promise<AgentData[]> => {
   })
 }
 
+export const fetchAgentsWithMetricsLite = async (): Promise<AgentData[]> => {
+  const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+
+  const agentsPromise = db
+    .select({
+      id: schema.agentConfig.id,
+      version: schema.agentConfig.version,
+      data: schema.agentConfig.data,
+      created_at: schema.agentConfig.created_at,
+      publisher: {
+        id: schema.publisher.id,
+        name: schema.publisher.name,
+        verified: schema.publisher.verified,
+        avatar_url: schema.publisher.avatar_url,
+      },
+    })
+    .from(schema.agentConfig)
+    .innerJoin(
+      schema.publisher,
+      eq(schema.agentConfig.publisher_id, schema.publisher.id),
+    )
+    .orderBy(sql`${schema.agentConfig.created_at} DESC`)
+
+  const usageMetricsPromise = db
+    .select({
+      publisher_id: schema.agentRun.publisher_id,
+      agent_name: schema.agentRun.agent_name,
+      total_invocations: sql<number>`COUNT(*)`,
+      total_dollars: sql<number>`COALESCE(SUM(${schema.agentRun.total_credits}) / 100.0, 0)`,
+      avg_cost_per_run: sql<number>`COALESCE(AVG(${schema.agentRun.total_credits}) / 100.0, 0)`,
+      unique_users: sql<number>`COUNT(DISTINCT ${schema.agentRun.user_id})`,
+      last_used: sql<Date>`MAX(${schema.agentRun.created_at})`,
+    })
+    .from(schema.agentRun)
+    .where(
+      and(
+        eq(schema.agentRun.status, 'completed'),
+        sql`${schema.agentRun.agent_id} != 'test-agent'`,
+        sql`${schema.agentRun.publisher_id} IS NOT NULL`,
+        sql`${schema.agentRun.agent_name} IS NOT NULL`,
+      ),
+    )
+    .groupBy(schema.agentRun.publisher_id, schema.agentRun.agent_name)
+
+  const weeklyMetricsPromise = db
+    .select({
+      publisher_id: schema.agentRun.publisher_id,
+      agent_name: schema.agentRun.agent_name,
+      weekly_runs: sql<number>`COUNT(*)`,
+      weekly_dollars: sql<number>`COALESCE(SUM(${schema.agentRun.total_credits}) / 100.0, 0)`,
+    })
+    .from(schema.agentRun)
+    .where(
+      and(
+        eq(schema.agentRun.status, 'completed'),
+        gte(schema.agentRun.created_at, oneWeekAgo),
+        sql`${schema.agentRun.agent_id} != 'test-agent'`,
+        sql`${schema.agentRun.publisher_id} IS NOT NULL`,
+        sql`${schema.agentRun.agent_name} IS NOT NULL`,
+      ),
+    )
+    .groupBy(schema.agentRun.publisher_id, schema.agentRun.agent_name)
+
+  const [agents, usageMetrics, weeklyMetrics] = await Promise.all([
+    agentsPromise,
+    usageMetricsPromise,
+    weeklyMetricsPromise,
+  ])
+
+  return buildAgentsDataLite({
+    agents,
+    usageMetrics,
+    weeklyMetrics,
+  })
+}
+
 export const getCachedAgents = unstable_cache(
   fetchAgentsWithMetrics,
   ['agents-data'],
@@ -164,3 +240,12 @@ export const getCachedAgents = unstable_cache(
     tags: ['agents', 'api', 'store'],
   },
 )
+
+export const getCachedAgentsLite = unstable_cache(
+  fetchAgentsWithMetricsLite,
+  ['agents-data-lite'],
+  {
+    revalidate: 600, // 10 minutes
+    tags: ['agents', 'store'],
+  },
+)
diff --git a/web/src/server/agents-transform.ts b/web/src/server/agents-transform.ts
