@girardmedia/bootspring 1.2.0 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "1.2.0",
+  "version": "2.0.3",
   "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
   "keywords": [
     "ai",
@@ -44,6 +44,10 @@
     "./api": {
       "types": "./core/api-client.d.ts",
       "default": "./core/api-client.js"
+    },
+    "./marketplace": {
+      "types": "./marketplace/index.d.ts",
+      "default": "./marketplace/index.js"
     }
   },
   "files": [
@@ -51,15 +55,12 @@
     "core/",
     "cli/",
     "mcp/",
-    "templates/",
     "intelligence/",
     "quality/",
-    "skills/index.js",
-    "skills/patterns/",
-    "agents/",
     "generators/",
     "hooks/",
-    "plugins/"
+    "plugins/",
+    "marketplace/"
   ],
   "scripts": {
     "start": "node bin/bootspring.js",
@@ -74,6 +75,8 @@
     "build:mcp-contract": "node scripts/export-mcp-contract.js",
     "verify:mcp-contract": "node scripts/export-mcp-contract.js --check",
     "verify:package": "node scripts/check-package-boundaries.js",
+    "db:sync": "node shared/db/sync.js",
+    "db:sync:check": "node shared/db/sync.js --check",
     "prepublishOnly": "npm test && npm run lint --if-present && npm run verify:package && npm run verify:mcp-contract"
   },
   "devDependencies": {
@@ -90,5 +93,11 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "overrides": {
+    "table": {
+      "ajv": "^8.12.0"
+    },
+    "minimatch": "^10.2.1"
   }
 }

package/agents/README.md

@@ -1,93 +0,0 @@
-# Bootspring Agents
-
-Specialized AI agents for different development domains. Each agent provides focused expertise, context, and patterns for its area.
-
-## Available Agents
-
-| Agent | Domain | Use When |
-|-------|--------|----------|
-| [database-expert](./database-expert/) | Database & ORM | Schema design, queries, migrations |
-| [security-expert](./security-expert/) | Security & Auth | Auth flows, vulnerabilities, OWASP |
-| [frontend-expert](./frontend-expert/) | UI & React | Components, state, styling |
-| [backend-expert](./backend-expert/) | Server Logic | API routes, server actions, business logic |
-| [api-expert](./api-expert/) | API Design | REST, GraphQL, route handlers |
-| [testing-expert](./testing-expert/) | Testing | Unit, integration, E2E tests |
-| [performance-expert](./performance-expert/) | Performance | Optimization, caching, profiling |
-| [devops-expert](./devops-expert/) | DevOps & CI/CD | Deployment, pipelines, infrastructure |
-| [ui-ux-expert](./ui-ux-expert/) | Design & UX | User experience, accessibility, design |
-| [architecture-expert](./architecture-expert/) | Architecture | System design, patterns, scaling |
-| [code-review-expert](./code-review-expert/) | Code Quality | Reviews, best practices, refactoring |
-| [vercel-expert](./vercel-expert/) | Vercel Platform | Deployment, edge, serverless |
-
-## Using Agents
-
-### Via CLI
-```bash
-# List all agents
-bootspring agent list
-
-# Show agent details
-bootspring agent show database-expert
-
-# Invoke agent for current context
-bootspring agent invoke security-expert
-```
-
-### Via MCP
-When using Claude Code, agents are automatically suggested based on your task context. You can also explicitly request an agent:
-
-```
-@bootspring agent database-expert
-```
-
-### Agent Selection
-
-Bootspring automatically detects which agents are relevant based on keywords in your request:
-
-- **database-expert**: database, schema, prisma, drizzle, migration, query, model
-- **security-expert**: auth, login, security, password, jwt, csrf, xss, owasp
-- **frontend-expert**: component, react, ui, tailwind, state, client, hook
-- **backend-expert**: api, server, action, business, logic, service
-- **testing-expert**: test, spec, jest, vitest, playwright, coverage
-- **performance-expert**: performance, optimize, cache, slow, fast, bundle
-- **devops-expert**: deploy, ci, cd, docker, kubernetes, pipeline
-- **architecture-expert**: architecture, design, pattern, scale, structure
-
-## Agent Context Files
-
-Each agent directory contains:
-
-```
-agents/{name}/
-├── context.md       # Full agent context and expertise
-├── patterns.md      # Common patterns this agent uses
-└── checklist.md     # Review checklist for this domain
-```
-
-## Creating Custom Agents
-
-Add a new directory under `agents/` with at minimum a `context.md` file:
-
-```markdown
-# Custom Agent Name
-
-## Role
-Brief description of what this agent does.
-
-## Expertise
-- Area 1
-- Area 2
-
-## Context
-Detailed knowledge and patterns...
-```
-
-Then register it in your `bootspring.config.js`:
-
-```javascript
-module.exports = {
-  agents: {
-    custom: ['my-custom-agent']
-  }
-};
-```

package/agents/ai-integration-expert/context.md

@@ -1,386 +0,0 @@
-# AI Integration Expert Agent
-
-## Role
-Specialized in AI/LLM integration, Anthropic Claude SDK, AI SDK, streaming responses, and building AI-powered features.
-
-## Core Expertise
-
-### Anthropic Claude Integration
-
-```typescript
-// lib/anthropic.ts
-import Anthropic from '@anthropic-ai/sdk';
-
-export const anthropic = new Anthropic({
-  apiKey: process.env.ANTHROPIC_API_KEY,
-});
-
-// Basic message
-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
-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;
-}
-```
-
-### Streaming Responses
-
-```typescript
-// app/api/chat/route.ts
-import { anthropic } from '@/lib/anthropic';
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const stream = await anthropic.messages.stream({
-    model: 'claude-sonnet-4-20250514',
-    max_tokens: 1024,
-    messages,
-  });
-
-  // Return as streaming response
-  return new Response(stream.toReadableStream(), {
-    headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
-    },
-  });
-}
-```
-
-```tsx
-// components/chat.tsx
-'use client';
-
-import { useState } from 'react';
-
-export function Chat() {
-  const [messages, setMessages] = useState<Message[]>([]);
-  const [input, setInput] = useState('');
-  const [isLoading, setIsLoading] = useState(false);
-
-  async function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-    if (!input.trim()) return;
-
-    const userMessage = { role: 'user', content: input };
-    setMessages((prev) => [...prev, userMessage]);
-    setInput('');
-    setIsLoading(true);
-
-    const response = await fetch('/api/chat', {
-      method: 'POST',
-      body: JSON.stringify({
-        messages: [...messages, userMessage],
-      }),
-    });
-
-    const reader = response.body?.getReader();
-    const decoder = new TextDecoder();
-    let assistantMessage = '';
-
-    while (reader) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      assistantMessage += decoder.decode(value);
-      setMessages((prev) => [
-        ...prev.slice(0, -1),
-        { role: 'assistant', content: assistantMessage },
-      ]);
-    }
-
-    setIsLoading(false);
-  }
-
-  return (
-    <div className="flex flex-col h-full">
-      <div className="flex-1 overflow-y-auto p-4 space-y-4">
-        {messages.map((m, i) => (
-          <div
-            key={i}
-            className={`p-4 rounded-lg ${
-              m.role === 'user' ? 'bg-blue-100 ml-12' : 'bg-gray-100 mr-12'
-            }`}
-          >
-            {m.content}
-          </div>
-        ))}
-      </div>
-      <form onSubmit={handleSubmit} className="p-4 border-t">
-        <input
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          placeholder="Type a message..."
-          className="w-full p-2 border rounded"
-          disabled={isLoading}
-        />
-      </form>
-    </div>
-  );
-}
-```
-
-### Vercel AI SDK
-
-```typescript
-// app/api/chat/route.ts (using AI SDK)
-import { anthropic } from '@ai-sdk/anthropic';
-import { streamText } from 'ai';
-
-export async function POST(req: Request) {
-  const { messages } = await req.json();
-
-  const result = streamText({
-    model: anthropic('claude-sonnet-4-20250514'),
-    messages,
-  });
-
-  return result.toDataStreamResponse();
-}
-```
-
-```tsx
-// components/chat.tsx (using AI SDK React)
-'use client';
-
-import { useChat } from 'ai/react';
-
-export function Chat() {
-  const { messages, input, handleInputChange, handleSubmit, isLoading } =
-    useChat();
-
-  return (
-    <div className="flex flex-col h-full">
-      <div className="flex-1 overflow-y-auto p-4 space-y-4">
-        {messages.map((m) => (
-          <div
-            key={m.id}
-            className={`p-4 rounded-lg ${
-              m.role === 'user' ? 'bg-blue-100 ml-12' : 'bg-gray-100 mr-12'
-            }`}
-          >
-            {m.content}
-          </div>
-        ))}
-      </div>
-      <form onSubmit={handleSubmit} className="p-4 border-t">
-        <input
-          value={input}
-          onChange={handleInputChange}
-          placeholder="Type a message..."
-          className="w-full p-2 border rounded"
-          disabled={isLoading}
-        />
-      </form>
-    </div>
-  );
-}
-```
-
-### Structured Output
-
-```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);
-}
-```
-
-### Tool Use / Function Calling
-
-```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'],
-    },
-  },
-];
-
-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;
-}
-
-async function executeTool(name: string, input: any) {
-  switch (name) {
-    case 'get_weather':
-      return { temperature: 72, condition: 'sunny' };
-    case 'search_database':
-      return await searchProducts(input.query, input.limit);
-    default:
-      throw new Error(`Unknown tool: ${name}`);
-  }
-}
-```
-
-### Rate Limiting
-
-```typescript
-// lib/ratelimit.ts
-import { Ratelimit } from '@upstash/ratelimit';
-import { Redis } from '@upstash/redis';
-
-const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_URL!,
-  token: process.env.UPSTASH_REDIS_TOKEN!,
-});
-
-export const aiRateLimit = new Ratelimit({
-  redis,
-  limiter: Ratelimit.slidingWindow(10, '1 m'), // 10 requests per minute
-  analytics: true,
-});
-
-// Usage in API route
-export async function POST(req: Request) {
-  const userId = await getUserId(req);
-
-  const { success, limit, reset, remaining } = await aiRateLimit.limit(userId);
-
-  if (!success) {
-    return Response.json(
-      { error: 'Rate limit exceeded' },
-      {
-        status: 429,
-        headers: {
-          'X-RateLimit-Limit': limit.toString(),
-          'X-RateLimit-Remaining': remaining.toString(),
-          'X-RateLimit-Reset': reset.toString(),
-        },
-      }
-    );
-  }
-
-  // Continue with AI request...
-}
-```
-
-## AI Integration Checklist
-
-- [ ] API keys configured
-- [ ] Client library set up
-- [ ] Streaming implemented
-- [ ] Error handling in place
-- [ ] Rate limiting configured
-- [ ] Cost tracking enabled
-- [ ] Prompt templates created
-- [ ] Testing with mock responses
-
-## Trigger Keywords
-AI, LLM, Claude, Anthropic, OpenAI, GPT, streaming, chat, completion, embedding, RAG, tool use, function calling