@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/ai/structured-output.md

@@ -1,162 +0,0 @@
-# Structured Output Patterns
-
-Patterns for getting structured data from AI responses.
-
-## JSON Output with Zod
-
-```typescript
-// lib/ai/structured.ts
-import { anthropic } from '@/lib/anthropic'
-import { z } from 'zod'
-
-const ProductSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  price: z.number(),
-  category: z.string()
-})
-
-export async function extractProduct(text: string) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages: [
-      {
-        role: 'user',
-        content: `Extract product information from this text and return as JSON:
-
-${text}
-
-Return JSON with: name, description, price, category`
-      }
-    ]
-  })
-
-  const content = response.content[0]
-  if (content.type !== 'text') throw new Error('Unexpected response')
-
-  // Parse JSON from response
-  const jsonMatch = content.text.match(/\{[\s\S]*\}/)
-  if (!jsonMatch) throw new Error('No JSON found')
-
-  const parsed = JSON.parse(jsonMatch[0])
-  return ProductSchema.parse(parsed)
-}
-```
-
-## AI SDK Structured Output
-
-```typescript
-// lib/ai/structured.ts
-import { generateObject } from 'ai'
-import { anthropic } from '@ai-sdk/anthropic'
-import { z } from 'zod'
-
-const RecipeSchema = z.object({
-  name: z.string(),
-  ingredients: z.array(z.object({
-    item: z.string(),
-    amount: z.string()
-  })),
-  instructions: z.array(z.string()),
-  prepTime: z.number(),
-  cookTime: z.number()
-})
-
-export async function generateRecipe(dish: string) {
-  const { object } = await generateObject({
-    model: anthropic('claude-sonnet-4-20250514'),
-    schema: RecipeSchema,
-    prompt: `Generate a recipe for ${dish}`
-  })
-
-  return object
-}
-```
-
-## Classification
-
-```typescript
-// lib/ai/classify.ts
-import { anthropic } from '@/lib/anthropic'
-
-const CATEGORIES = ['bug', 'feature', 'question', 'docs'] as const
-
-export async function classifyIssue(
-  title: string,
-  body: string
-): Promise<typeof CATEGORIES[number]> {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 50,
-    messages: [
-      {
-        role: 'user',
-        content: `Classify this GitHub issue into one of: ${CATEGORIES.join(', ')}
-
-Title: ${title}
-Body: ${body}
-
-Respond with ONLY the category name.`
-      }
-    ]
-  })
-
-  const text = response.content[0].type === 'text'
-    ? response.content[0].text.trim().toLowerCase()
-    : ''
-
-  if (CATEGORIES.includes(text as any)) {
-    return text as typeof CATEGORIES[number]
-  }
-
-  return 'question' // default
-}
-```
-
-## Entity Extraction
-
-```typescript
-// lib/ai/extract.ts
-import { anthropic } from '@/lib/anthropic'
-import { z } from 'zod'
-
-const EntitiesSchema = z.object({
-  people: z.array(z.string()),
-  organizations: z.array(z.string()),
-  locations: z.array(z.string()),
-  dates: z.array(z.string())
-})
-
-export async function extractEntities(text: string) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages: [
-      {
-        role: 'user',
-        content: `Extract named entities from this text:
-
-${text}
-
-Return JSON with arrays for: people, organizations, locations, dates`
-      }
-    ]
-  })
-
-  const content = response.content[0]
-  if (content.type !== 'text') throw new Error('Unexpected response')
-
-  const jsonMatch = content.text.match(/\{[\s\S]*\}/)
-  if (!jsonMatch) throw new Error('No JSON found')
-
-  return EntitiesSchema.parse(JSON.parse(jsonMatch[0]))
-}
-```
-
-## When to Use
-
-- Data extraction from text
-- Content classification
-- Form auto-fill
-- API response generation

package/skills/patterns/ai/tools.md

@@ -1,154 +0,0 @@
-# AI Tool Use / Function Calling Patterns
-
-Patterns for AI tool use with Claude.
-
-## Tool Definition
-
-```typescript
-// lib/ai/tools.ts
-import { anthropic } from '@/lib/anthropic'
-
-const tools = [
-  {
-    name: 'get_weather',
-    description: 'Get the current weather for a location',
-    input_schema: {
-      type: 'object',
-      properties: {
-        location: {
-          type: 'string',
-          description: 'City and state, e.g., San Francisco, CA'
-        }
-      },
-      required: ['location']
-    }
-  },
-  {
-    name: 'search_database',
-    description: 'Search the product database',
-    input_schema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string' },
-        limit: { type: 'number', default: 10 }
-      },
-      required: ['query']
-    }
-  }
-]
-```
-
-## Tool Execution
-
-```typescript
-// lib/ai/tools.ts
-async function executeTool(name: string, input: any) {
-  switch (name) {
-    case 'get_weather':
-      // Call weather API
-      return { temperature: 72, condition: 'sunny' }
-
-    case 'search_database':
-      // Search database
-      return await searchProducts(input.query, input.limit)
-
-    default:
-      throw new Error(`Unknown tool: ${name}`)
-  }
-}
-```
-
-## Chat with Tools
-
-```typescript
-// lib/ai/tools.ts
-export async function chatWithTools(prompt: string) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    tools,
-    messages: [{ role: 'user', content: prompt }]
-  })
-
-  // Handle tool use
-  for (const block of response.content) {
-    if (block.type === 'tool_use') {
-      const result = await executeTool(block.name, block.input)
-
-      // Continue conversation with tool result
-      return anthropic.messages.create({
-        model: 'claude-sonnet-4-20250514',
-        max_tokens: 1024,
-        messages: [
-          { role: 'user', content: prompt },
-          { role: 'assistant', content: response.content },
-          {
-            role: 'user',
-            content: [
-              {
-                type: 'tool_result',
-                tool_use_id: block.id,
-                content: JSON.stringify(result)
-              }
-            ]
-          }
-        ]
-      })
-    }
-  }
-
-  return response
-}
-```
-
-## Multi-Tool Loop
-
-```typescript
-// lib/ai/tools.ts
-export async function chatWithToolLoop(prompt: string, maxIterations = 5) {
-  let messages: any[] = [{ role: 'user', content: prompt }]
-  let iteration = 0
-
-  while (iteration < maxIterations) {
-    const response = await anthropic.messages.create({
-      model: 'claude-sonnet-4-20250514',
-      max_tokens: 1024,
-      tools,
-      messages
-    })
-
-    // Check if we're done
-    if (response.stop_reason === 'end_turn') {
-      return response
-    }
-
-    // Process tool uses
-    const toolResults = []
-    for (const block of response.content) {
-      if (block.type === 'tool_use') {
-        const result = await executeTool(block.name, block.input)
-        toolResults.push({
-          type: 'tool_result',
-          tool_use_id: block.id,
-          content: JSON.stringify(result)
-        })
-      }
-    }
-
-    // Add to conversation
-    messages.push({ role: 'assistant', content: response.content })
-    messages.push({ role: 'user', content: toolResults })
-
-    iteration++
-  }
-
-  throw new Error('Max iterations reached')
-}
-```
-
-## When to Use
-
-- AI agents with capabilities
-- Database queries via AI
-- External API integration
-- Multi-step reasoning tasks

package/skills/patterns/analytics/tracking.md

@@ -1,220 +0,0 @@
-# Analytics Tracking Patterns
-
-Patterns for implementing analytics.
-
-## Google Analytics 4
-
-```tsx
-// components/GoogleAnalytics.tsx
-import Script from 'next/script'
-
-const GA_ID = process.env.NEXT_PUBLIC_GA_ID
-
-export function GoogleAnalytics() {
-  if (!GA_ID) return null
-
-  return (
-    <>
-      <Script
-        src={`https://www.googletagmanager.com/gtag/js?id=${GA_ID}`}
-        strategy="afterInteractive"
-      />
-      <Script id="google-analytics" strategy="afterInteractive">
-        {`
-          window.dataLayer = window.dataLayer || [];
-          function gtag(){dataLayer.push(arguments);}
-          gtag('js', new Date());
-          gtag('config', '${GA_ID}');
-        `}
-      </Script>
-    </>
-  )
-}
-
-// lib/analytics.ts
-export function trackEvent(action: string, category: string, label?: string, value?: number) {
-  if (typeof window !== 'undefined' && window.gtag) {
-    window.gtag('event', action, {
-      event_category: category,
-      event_label: label,
-      value
-    })
-  }
-}
-
-// Usage
-trackEvent('click', 'button', 'signup')
-trackEvent('purchase', 'ecommerce', 'product_123', 99)
-```
-
-## Page View Tracking
-
-```tsx
-// components/PageViewTracker.tsx
-'use client'
-
-import { useEffect } from 'react'
-import { usePathname, useSearchParams } from 'next/navigation'
-
-export function PageViewTracker() {
-  const pathname = usePathname()
-  const searchParams = useSearchParams()
-
-  useEffect(() => {
-    const url = pathname + searchParams.toString()
-
-    // Google Analytics
-    window.gtag?.('config', process.env.NEXT_PUBLIC_GA_ID!, {
-      page_path: url
-    })
-
-    // Custom analytics
-    fetch('/api/analytics/pageview', {
-      method: 'POST',
-      body: JSON.stringify({ path: url })
-    })
-  }, [pathname, searchParams])
-
-  return null
-}
-```
-
-## Custom Analytics Service
-
-```typescript
-// lib/analytics-service.ts
-interface AnalyticsEvent {
-  name: string
-  properties?: Record<string, any>
-  userId?: string
-  timestamp?: Date
-}
-
-class Analytics {
-  private queue: AnalyticsEvent[] = []
-  private flushInterval: NodeJS.Timeout | null = null
-
-  constructor() {
-    if (typeof window !== 'undefined') {
-      this.flushInterval = setInterval(() => this.flush(), 5000)
-    }
-  }
-
-  track(name: string, properties?: Record<string, any>) {
-    this.queue.push({
-      name,
-      properties,
-      userId: this.getUserId(),
-      timestamp: new Date()
-    })
-
-    if (this.queue.length >= 10) {
-      this.flush()
-    }
-  }
-
-  identify(userId: string, traits?: Record<string, any>) {
-    localStorage.setItem('analytics_user_id', userId)
-    this.track('identify', { userId, ...traits })
-  }
-
-  private getUserId(): string | undefined {
-    if (typeof window === 'undefined') return undefined
-    return localStorage.getItem('analytics_user_id') ?? undefined
-  }
-
-  async flush() {
-    if (this.queue.length === 0) return
-
-    const events = [...this.queue]
-    this.queue = []
-
-    try {
-      await fetch('/api/analytics/events', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ events })
-      })
-    } catch (error) {
-      // Re-queue on failure
-      this.queue.unshift(...events)
-    }
-  }
-}
-
-export const analytics = new Analytics()
-
-// Usage
-analytics.track('button_clicked', { buttonId: 'signup' })
-analytics.identify('user_123', { plan: 'pro' })
-```
-
-## Event Tracking Hook
-
-```tsx
-// hooks/useTrackEvent.ts
-'use client'
-
-import { useCallback } from 'react'
-import { analytics } from '@/lib/analytics-service'
-
-export function useTrackEvent() {
-  return useCallback((name: string, properties?: Record<string, any>) => {
-    analytics.track(name, properties)
-  }, [])
-}
-
-// Usage in component
-function SignupButton() {
-  const trackEvent = useTrackEvent()
-
-  const handleClick = () => {
-    trackEvent('signup_clicked', { source: 'header' })
-    // ... signup logic
-  }
-
-  return <button onClick={handleClick}>Sign Up</button>
-}
-```
-
-## A/B Testing
-
-```tsx
-// lib/ab-testing.ts
-import { cookies } from 'next/headers'
-
-export function getVariant(experimentId: string, variants: string[]): string {
-  const cookieStore = cookies()
-  const cookieKey = `ab_${experimentId}`
-
-  let variant = cookieStore.get(cookieKey)?.value
-
-  if (!variant || !variants.includes(variant)) {
-    // Assign random variant
-    variant = variants[Math.floor(Math.random() * variants.length)]
-    // Cookie will be set via response
-  }
-
-  return variant
-}
-
-// Usage in page
-export default function LandingPage() {
-  const variant = getVariant('hero_test', ['control', 'variation_a', 'variation_b'])
-
-  return (
-    <div>
-      {variant === 'control' && <HeroControl />}
-      {variant === 'variation_a' && <HeroVariationA />}
-      {variant === 'variation_b' && <HeroVariationB />}
-    </div>
-  )
-}
-```
-
-## When to Use
-
-- User behavior tracking
-- Conversion tracking
-- A/B testing
-- Performance monitoring