@girardmedia/bootspring 1.2.0 → 2.0.3

package/skills/patterns/README.md

@@ -1,163 +0,0 @@
-# Bootspring Skill Patterns
-
-Battle-tested code patterns for common development tasks.
-
-## Available Patterns
-
-### Authentication
-| Pattern | Description |
-|---------|-------------|
-| [auth/clerk](./auth/clerk.md) | Clerk authentication - server auth, middleware, user sync |
-
-### Database
-| Pattern | Description |
-|---------|-------------|
-| [database/prisma](./database/prisma.md) | Prisma ORM - client setup, queries, transactions, migrations |
-
-### API Development
-| Pattern | Description |
-|---------|-------------|
-| [api/route-handler](./api/route-handler.md) | Next.js route handlers - CRUD, error handling, rate limiting |
-| [api/server-action](./api/server-action.md) | Server actions - forms, optimistic updates, useActionState |
-
-### Payments
-| Pattern | Description |
-|---------|-------------|
-| [payments/stripe](./payments/stripe.md) | Stripe - checkout, subscriptions, webhooks, customer portal |
-
-### Security
-| Pattern | Description |
-|---------|-------------|
-| [security/validation](./security/validation.md) | Input validation - Zod schemas, sanitization, CSRF, rate limiting |
-
-### Testing
-| Pattern | Description |
-|---------|-------------|
-| [testing/vitest](./testing/vitest.md) | Vitest - setup, unit tests, component tests, mocking |
-
-## Usage
-
-### Via CLI
-```bash
-# List all patterns
-bootspring skill list
-
-# Include curated external skills catalog (skills/external)
-bootspring skill list --external
-
-# Search for patterns
-bootspring skill search "auth"
-bootspring skill search "vercel" --external
-
-# Show a specific pattern
-bootspring skill show auth/clerk
-
-# Show concise summary
-bootspring skill show auth/clerk --summary
-
-# Show only matching sections and cap output size
-bootspring skill show api/route-handler --sections "basic crud,error handling" --max-chars 1200
-
-# Show an external skill by id
-bootspring skill show external/vercel-automation
-```
-
-### Via MCP Tool
-```text
-bootspring_skill { action: "show", name: "auth/clerk" }
-bootspring_skill { action: "show", name: "auth/clerk", summary: true }
-bootspring_skill { action: "show", name: "api/route-handler", sections: "basic crud", maxChars: 1200 }
-bootspring_skill { action: "search", query: "database" }
-bootspring_skill { action: "list", includeExternal: true, limit: 20 }
-```
-
-### Direct Reference
-Patterns are markdown files with code blocks. Reference them in prompts:
-```text
-Using the pattern from bootspring/skills/patterns/api/server-action.md,
-implement a server action for updating user profile.
-```
-
-## Pattern Structure
-
-Each pattern includes:
-- **Setup code** - Configuration and initialization
-- **Common patterns** - Frequently used implementations
-- **Best practices** - Security and performance considerations
-- **When to use** - Guidance on appropriate use cases
-
-## Adding Custom Patterns
-
-Create a markdown file in the appropriate category:
-```text
-skills/patterns/
-├── auth/
-│   └── my-custom-auth.md
-├── database/
-├── api/
-└── ...
-```
-
-Pattern template:
-```markdown
-# Pattern Name
-
-Brief description.
-
-## Setup
-
-~~~typescript
-// Configuration code
-~~~
-
-## Common Patterns
-
-~~~typescript
-// Implementation examples
-~~~
-
-## When to Use
-
-- Use case 1
-- Use case 2
-```
-
-## External Catalog (Curated)
-
-If `skills/external/` exists, Bootspring indexes it as an optional external catalog:
-
-- `bootspring skill list --external`
-- `bootspring skill search <query> --external`
-- `bootspring skill show external/<skill-id>`
-
-This catalog is optional. If you want a leaner repo, you can remove `skills/external/` without affecting built-in patterns.
-
-### Entitlement Policy
-
-External skills are checked through `core/entitlements.js`:
-
-- `BOOTSPRING_SKILL_ACCESS_MODE=local` (default): external skills are accessible.
-- `BOOTSPRING_SKILL_ACCESS_MODE=server`: external skills require entitlement.
-- Entitlement in server mode is granted by either:
-  - `BOOTSPRING_SKILLS_ENTITLED=true`
-  - `BOOTSPRING_USER_TIER=pro|team|enterprise`
-
-### Remote Catalog Sync
-
-For lightweight npm installs, sync protected skills from your backend into local cache:
-
-```bash
-bootspring skill sync \
-  --manifest-url https://api.bootspring.com/skills/manifest.json \
-  --content-base-url https://api.bootspring.com/skills/content
-```
-
-Relevant environment variables:
-
-- `BOOTSPRING_SKILL_MANIFEST_URL`
-- `BOOTSPRING_SKILL_CONTENT_BASE_URL`
-- `BOOTSPRING_SKILL_TOKEN`
-- `BOOTSPRING_SKILL_CACHE_DIR`
-- `BOOTSPRING_SKILL_CATALOG_SOURCE=auto|cache|local`
-- `BOOTSPRING_SKILL_MANIFEST_PUBLIC_KEY`
-- `BOOTSPRING_SKILL_MANIFEST_REQUIRE_SIGNATURE=true|false`

package/skills/patterns/ai/agents.md

@@ -1,281 +0,0 @@
-# AI Agents Patterns
-
-Patterns for building AI agents.
-
-## Basic Agent Loop
-
-```typescript
-// lib/agents/base.ts
-import Anthropic from '@anthropic-ai/sdk'
-
-const client = new Anthropic()
-
-interface Tool {
-  name: string
-  description: string
-  input_schema: object
-  execute: (input: any) => Promise<string>
-}
-
-export async function runAgent(
-  systemPrompt: string,
-  userMessage: string,
-  tools: Tool[],
-  maxIterations = 10
-) {
-  const messages: Anthropic.MessageParam[] = [
-    { role: 'user', content: userMessage }
-  ]
-
-  const anthropicTools = tools.map(t => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.input_schema
-  }))
-
-  for (let i = 0; i < maxIterations; i++) {
-    const response = await client.messages.create({
-      model: 'claude-sonnet-4-20250514',
-      max_tokens: 4096,
-      system: systemPrompt,
-      tools: anthropicTools,
-      messages
-    })
-
-    // Check if we're done
-    if (response.stop_reason === 'end_turn') {
-      const textBlock = response.content.find(b => b.type === 'text')
-      return textBlock?.text ?? ''
-    }
-
-    // Process tool uses
-    const toolUses = response.content.filter(b => b.type === 'tool_use')
-
-    if (toolUses.length === 0) {
-      const textBlock = response.content.find(b => b.type === 'text')
-      return textBlock?.text ?? ''
-    }
-
-    // Add assistant message
-    messages.push({ role: 'assistant', content: response.content })
-
-    // Execute tools and add results
-    const toolResults = await Promise.all(
-      toolUses.map(async (toolUse) => {
-        const tool = tools.find(t => t.name === toolUse.name)
-        if (!tool) {
-          return {
-            type: 'tool_result' as const,
-            tool_use_id: toolUse.id,
-            content: `Error: Tool ${toolUse.name} not found`
-          }
-        }
-
-        try {
-          const result = await tool.execute(toolUse.input)
-          return {
-            type: 'tool_result' as const,
-            tool_use_id: toolUse.id,
-            content: result
-          }
-        } catch (error) {
-          return {
-            type: 'tool_result' as const,
-            tool_use_id: toolUse.id,
-            content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
-          }
-        }
-      })
-    )
-
-    messages.push({ role: 'user', content: toolResults })
-  }
-
-  throw new Error('Max iterations reached')
-}
-```
-
-## Research Agent
-
-```typescript
-// lib/agents/research.ts
-import { runAgent } from './base'
-
-const webSearchTool = {
-  name: 'web_search',
-  description: 'Search the web for information',
-  input_schema: {
-    type: 'object',
-    properties: {
-      query: { type: 'string', description: 'The search query' }
-    },
-    required: ['query']
-  },
-  execute: async (input: { query: string }) => {
-    const response = await fetch(
-      `https://api.search.com/search?q=${encodeURIComponent(input.query)}`
-    )
-    const data = await response.json()
-    return JSON.stringify(data.results.slice(0, 5))
-  }
-}
-
-const readUrlTool = {
-  name: 'read_url',
-  description: 'Read the contents of a URL',
-  input_schema: {
-    type: 'object',
-    properties: {
-      url: { type: 'string', description: 'The URL to read' }
-    },
-    required: ['url']
-  },
-  execute: async (input: { url: string }) => {
-    const response = await fetch(input.url)
-    const html = await response.text()
-    // Extract text from HTML
-    return extractText(html).slice(0, 5000)
-  }
-}
-
-export async function researchTopic(topic: string) {
-  const systemPrompt = `You are a research assistant. Your job is to research topics thoroughly using web search and URL reading tools. Provide comprehensive, well-sourced information.`
-
-  return runAgent(
-    systemPrompt,
-    `Research the following topic and provide a detailed summary: ${topic}`,
-    [webSearchTool, readUrlTool]
-  )
-}
-```
-
-## Task Execution Agent
-
-```typescript
-// lib/agents/task.ts
-import { runAgent } from './base'
-import { prisma } from '@/lib/db'
-
-const createTaskTool = {
-  name: 'create_task',
-  description: 'Create a new task in the system',
-  input_schema: {
-    type: 'object',
-    properties: {
-      title: { type: 'string' },
-      description: { type: 'string' },
-      priority: { type: 'string', enum: ['low', 'medium', 'high'] },
-      dueDate: { type: 'string', description: 'ISO date string' }
-    },
-    required: ['title']
-  },
-  execute: async (input: any) => {
-    const task = await prisma.task.create({
-      data: {
-        title: input.title,
-        description: input.description,
-        priority: input.priority ?? 'medium',
-        dueDate: input.dueDate ? new Date(input.dueDate) : null
-      }
-    })
-    return `Created task: ${task.id}`
-  }
-}
-
-const listTasksTool = {
-  name: 'list_tasks',
-  description: 'List all tasks',
-  input_schema: {
-    type: 'object',
-    properties: {
-      status: { type: 'string', enum: ['pending', 'completed', 'all'] }
-    }
-  },
-  execute: async (input: any) => {
-    const where = input.status === 'all' ? {} : { status: input.status }
-    const tasks = await prisma.task.findMany({ where })
-    return JSON.stringify(tasks)
-  }
-}
-
-export async function processTaskRequest(userRequest: string) {
-  const systemPrompt = `You are a task management assistant. Help users create, list, and manage their tasks using the available tools.`
-
-  return runAgent(
-    systemPrompt,
-    userRequest,
-    [createTaskTool, listTasksTool]
-  )
-}
-```
-
-## Streaming Agent
-
-```typescript
-// lib/agents/streaming.ts
-import Anthropic from '@anthropic-ai/sdk'
-
-export async function* streamingAgent(
-  systemPrompt: string,
-  userMessage: string,
-  tools: Tool[]
-) {
-  const client = new Anthropic()
-  const messages: Anthropic.MessageParam[] = [
-    { role: 'user', content: userMessage }
-  ]
-
-  while (true) {
-    let currentToolUse: any = null
-    let currentToolInput = ''
-
-    const stream = client.messages.stream({
-      model: 'claude-sonnet-4-20250514',
-      max_tokens: 4096,
-      system: systemPrompt,
-      tools: tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema
-      })),
-      messages
-    })
-
-    for await (const event of stream) {
-      if (event.type === 'content_block_start' && event.content_block.type === 'text') {
-        yield { type: 'text_start' }
-      }
-
-      if (event.type === 'content_block_delta') {
-        if (event.delta.type === 'text_delta') {
-          yield { type: 'text', content: event.delta.text }
-        }
-        if (event.delta.type === 'input_json_delta') {
-          currentToolInput += event.delta.partial_json
-        }
-      }
-
-      if (event.type === 'content_block_start' && event.content_block.type === 'tool_use') {
-        currentToolUse = event.content_block
-        yield { type: 'tool_start', name: currentToolUse.name }
-      }
-    }
-
-    const finalMessage = await stream.finalMessage()
-
-    if (finalMessage.stop_reason === 'end_turn') {
-      break
-    }
-
-    // Handle tool execution
-    // ... similar to non-streaming version
-  }
-}
-```
-
-## When to Use
-
-- Autonomous tasks
-- Research assistants
-- Multi-step workflows
-- Tool orchestration

package/skills/patterns/ai/claude.md

@@ -1,138 +0,0 @@
-# Claude API Integration Patterns
-
-Patterns for integrating Anthropic Claude in Next.js.
-
-## Client Setup
-
-```typescript
-// lib/anthropic.ts
-import Anthropic from '@anthropic-ai/sdk'
-
-export const anthropic = new Anthropic({
-  apiKey: process.env.ANTHROPIC_API_KEY
-})
-```
-
-## Basic Message
-
-```typescript
-// lib/anthropic.ts
-export async function chat(prompt: string) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages: [{ role: 'user', content: prompt }]
-  })
-
-  return response.content[0].type === 'text'
-    ? response.content[0].text
-    : null
-}
-```
-
-## With System Prompt
-
-```typescript
-// lib/anthropic.ts
-export async function chatWithSystem(
-  system: string,
-  prompt: string
-) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    system,
-    messages: [{ role: 'user', content: prompt }]
-  })
-
-  return response.content[0].type === 'text'
-    ? response.content[0].text
-    : null
-}
-```
-
-## Multi-Turn Conversation
-
-```typescript
-// lib/anthropic.ts
-type Message = {
-  role: 'user' | 'assistant'
-  content: string
-}
-
-export async function conversation(messages: Message[]) {
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages
-  })
-
-  return response.content[0].type === 'text'
-    ? response.content[0].text
-    : null
-}
-```
-
-## API Route Handler
-
-```typescript
-// app/api/chat/route.ts
-import { anthropic } from '@/lib/anthropic'
-
-export async function POST(req: Request) {
-  const { messages, system } = await req.json()
-
-  const response = await anthropic.messages.create({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    system,
-    messages
-  })
-
-  const text = response.content[0].type === 'text'
-    ? response.content[0].text
-    : ''
-
-  return Response.json({ response: text })
-}
-```
-
-## Error Handling
-
-```typescript
-// lib/anthropic.ts
-import Anthropic from '@anthropic-ai/sdk'
-
-export async function safeChatcompletion(prompt: string) {
-  try {
-    const response = await anthropic.messages.create({
-      model: 'claude-sonnet-4-20250514',
-      max_tokens: 1024,
-      messages: [{ role: 'user', content: prompt }]
-    })
-
-    return {
-      success: true,
-      text: response.content[0].type === 'text'
-        ? response.content[0].text
-        : null
-    }
-  } catch (error) {
-    if (error instanceof Anthropic.APIError) {
-      return {
-        success: false,
-        error: error.message,
-        status: error.status
-      }
-    }
-    throw error
-  }
-}
-```
-
-## When to Use
-
-- Chatbots and assistants
-- Content generation
-- Data extraction
-- Code generation