@girardmedia/bootspring 1.1.0

package/hooks/context-detector.js

@@ -0,0 +1,177 @@
+/**
+ * Bootspring Context Detector
+ * Detects task types and suggests relevant agents/skills
+ *
+ * @package bootspring
+ * @module hooks/context-detector
+ */
+
+/**
+ * Context trigger definitions
+ * Maps keywords to agents, skills, and categories
+ */
+const CONTEXT_TRIGGERS = {
+  database: {
+    keywords: ['database', 'schema', 'prisma', 'migration', 'query', 'sql', 'postgres', 'mongodb', 'drizzle', 'orm', 'table', 'column', 'foreign key', 'index'],
+    agents: ['database-expert'],
+    skills: ['database/prisma', 'database/drizzle'],
+    category: 'database'
+  },
+  authentication: {
+    keywords: ['auth', 'login', 'signup', 'sign up', 'sign in', 'session', 'clerk', 'jwt', 'token', 'password', 'oauth', 'nextauth', 'user authentication', 'protected route'],
+    agents: ['security-expert', 'backend-expert'],
+    skills: ['auth/clerk', 'auth/nextauth'],
+    category: 'authentication'
+  },
+  frontend: {
+    keywords: ['component', 'react', 'ui', 'tailwind', 'page', 'layout', 'client component', 'server component', 'css', 'styling', 'responsive', 'mobile', 'form', 'button', 'modal', 'dropdown'],
+    agents: ['frontend-expert', 'ui-ux-expert'],
+    skills: ['ui/components', 'ui/forms'],
+    category: 'frontend'
+  },
+  api: {
+    keywords: ['api', 'endpoint', 'route', 'rest', 'graphql', 'trpc', 'fetch', 'request', 'response', 'post', 'get', 'put', 'delete', 'server action', 'route handler'],
+    agents: ['api-expert', 'backend-expert'],
+    skills: ['api/route-handler', 'api/server-action'],
+    category: 'api'
+  },
+  payments: {
+    keywords: ['stripe', 'payment', 'subscription', 'checkout', 'billing', 'invoice', 'webhook', 'price', 'product', 'paddle', 'lemon squeezy'],
+    agents: ['backend-expert'],
+    skills: ['payments/stripe', 'payments/webhooks'],
+    category: 'payments'
+  },
+  testing: {
+    keywords: ['test', 'jest', 'vitest', 'playwright', 'coverage', 'unit test', 'integration test', 'e2e', 'mock', 'spy', 'assertion', 'expect'],
+    agents: ['testing-expert', 'code-review-expert'],
+    skills: ['testing/vitest', 'testing/playwright'],
+    category: 'testing'
+  },
+  performance: {
+    keywords: ['performance', 'optimize', 'cache', 'slow', 'speed', 'lighthouse', 'core web vitals', 'bundle size', 'lazy load', 'memory leak', 'profiling'],
+    agents: ['performance-expert'],
+    skills: ['performance/caching', 'performance/optimization'],
+    category: 'performance'
+  },
+  deployment: {
+    keywords: ['deploy', 'vercel', 'production', 'ci', 'cd', 'github actions', 'docker', 'kubernetes', 'hosting', 'environment', 'build', 'release'],
+    agents: ['devops-expert', 'vercel-expert'],
+    skills: ['deployment/vercel', 'deployment/docker'],
+    category: 'deployment'
+  },
+  security: {
+    keywords: ['security', 'vulnerability', 'owasp', 'xss', 'csrf', 'injection', 'sanitize', 'validate', 'rate limit', 'cors', 'helmet', 'encryption'],
+    agents: ['security-expert'],
+    skills: ['security/validation', 'security/rate-limiting'],
+    category: 'security'
+  },
+  ai: {
+    keywords: ['claude', 'openai', 'gpt', 'llm', 'ai', 'anthropic', 'gemini', 'embedding', 'vector', 'rag', 'prompt', 'completion', 'streaming'],
+    agents: ['backend-expert'],
+    skills: ['ai/streaming', 'ai/tool-use'],
+    category: 'ai'
+  },
+  architecture: {
+    keywords: ['architecture', 'design pattern', 'refactor', 'structure', 'module', 'clean code', 'solid', 'dependency injection', 'microservice', 'monolith'],
+    agents: ['architecture-expert', 'code-review-expert'],
+    skills: ['architecture/patterns'],
+    category: 'architecture'
+  },
+  accessibility: {
+    keywords: ['accessibility', 'a11y', 'aria', 'screen reader', 'keyboard navigation', 'wcag', 'contrast', 'focus', 'semantic'],
+    agents: ['ui-ux-expert', 'frontend-expert'],
+    skills: ['ui/accessibility'],
+    category: 'accessibility'
+  }
+};
+
+/**
+ * Detect context from a message/prompt
+ * @param {string} message - The user message or prompt
+ * @returns {object} Detection result with matches, agents, skills, and confidence
+ */
+function detectContext(message) {
+  const messageLower = message.toLowerCase();
+  const matches = [];
+  const suggestedAgents = new Set();
+  const suggestedSkills = new Set();
+  let totalKeywordMatches = 0;
+
+  // Check each trigger category
+  for (const [triggerName, trigger] of Object.entries(CONTEXT_TRIGGERS)) {
+    const matchedKeywords = [];
+
+    // Check for keyword matches
+    for (const keyword of trigger.keywords) {
+      if (messageLower.includes(keyword)) {
+        matchedKeywords.push(keyword);
+        totalKeywordMatches++;
+      }
+    }
+
+    // If we found matches, add this category
+    if (matchedKeywords.length > 0) {
+      matches.push({
+        category: trigger.category,
+        triggerName,
+        matchedKeywords,
+        keywordCount: matchedKeywords.length
+      });
+
+      // Add suggested agents and skills
+      trigger.agents.forEach(a => suggestedAgents.add(a));
+      trigger.skills.forEach(s => suggestedSkills.add(s));
+    }
+  }
+
+  // Sort matches by keyword count (most relevant first)
+  matches.sort((a, b) => b.keywordCount - a.keywordCount);
+
+  // Calculate confidence (0-1)
+  // More keyword matches = higher confidence
+  const confidence = Math.min(totalKeywordMatches / 5, 1);
+
+  return {
+    matches,
+    suggestedAgents: Array.from(suggestedAgents),
+    suggestedSkills: Array.from(suggestedSkills),
+    confidence,
+    primaryCategory: matches[0]?.category || null
+  };
+}
+
+/**
+ * Get agents for a specific category
+ * @param {string} category - Category name
+ * @returns {string[]} Array of agent names
+ */
+function getAgentsForCategory(category) {
+  const trigger = Object.values(CONTEXT_TRIGGERS).find(t => t.category === category);
+  return trigger?.agents || [];
+}
+
+/**
+ * Get skills for a specific category
+ * @param {string} category - Category name
+ * @returns {string[]} Array of skill names
+ */
+function getSkillsForCategory(category) {
+  const trigger = Object.values(CONTEXT_TRIGGERS).find(t => t.category === category);
+  return trigger?.skills || [];
+}
+
+/**
+ * Get all available categories
+ * @returns {string[]} Array of category names
+ */
+function getCategories() {
+  return Object.values(CONTEXT_TRIGGERS).map(t => t.category);
+}
+
+module.exports = {
+  CONTEXT_TRIGGERS,
+  detectContext,
+  getAgentsForCategory,
+  getSkillsForCategory,
+  getCategories
+};

package/hooks/index.js

@@ -0,0 +1,35 @@
+/**
+ * Bootspring Hook System
+ * Automatic context injection for AI assistants
+ *
+ * @package bootspring
+ * @module hooks
+ */
+
+const contextDetector = require('./context-detector');
+const promptEnhancer = require('./prompt-enhancer');
+
+module.exports = {
+  // Main exports
+  contextDetector,
+  promptEnhancer,
+
+  // Convenience functions
+  detectContext: contextDetector.detectContext,
+  enhancePrompt: promptEnhancer.enhance,
+
+  // Hook registration for Claude Code
+  hooks: {
+    UserPromptSubmit: async (prompt, projectContext) => {
+      // Detect context from the prompt
+      const detection = contextDetector.detectContext(prompt);
+
+      // If relevant context detected, enhance the response
+      if (detection.matches.length > 0) {
+        return promptEnhancer.enhance(prompt, detection, projectContext);
+      }
+
+      return null;
+    }
+  }
+};

package/hooks/prompt-enhancer.js

@@ -0,0 +1,289 @@
+/**
+ * Bootspring Prompt Enhancer
+ * Enhances prompts with relevant context based on detection
+ *
+ * @package bootspring
+ * @module hooks/prompt-enhancer
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Agent context templates
+ */
+const AGENT_CONTEXTS = {
+  'database-expert': `
+You have access to the Database Expert agent. Consider:
+- Database schema design and normalization
+- Query optimization and indexing
+- Migration strategies
+- ORM best practices (Prisma/Drizzle)
+`,
+  'security-expert': `
+You have access to the Security Expert agent. Consider:
+- OWASP Top 10 vulnerabilities
+- Input validation and sanitization
+- Authentication and authorization patterns
+- Secure session management
+`,
+  'frontend-expert': `
+You have access to the Frontend Expert agent. Consider:
+- React component patterns (Server vs Client)
+- Tailwind CSS best practices
+- State management approaches
+- Responsive design
+`,
+  'backend-expert': `
+You have access to the Backend Expert agent. Consider:
+- API design patterns
+- Server Actions vs Route Handlers
+- Error handling strategies
+- Data validation with Zod
+`,
+  'api-expert': `
+You have access to the API Expert agent. Consider:
+- RESTful design principles
+- GraphQL vs REST trade-offs
+- API versioning
+- Rate limiting and caching
+`,
+  'testing-expert': `
+You have access to the Testing Expert agent. Consider:
+- Test pyramid (unit, integration, e2e)
+- Mocking strategies
+- Coverage goals
+- Test organization
+`,
+  'performance-expert': `
+You have access to the Performance Expert agent. Consider:
+- Core Web Vitals optimization
+- Bundle size reduction
+- Caching strategies
+- Lazy loading
+`,
+  'devops-expert': `
+You have access to the DevOps Expert agent. Consider:
+- CI/CD pipeline design
+- Environment management
+- Deployment strategies
+- Monitoring and logging
+`,
+  'ui-ux-expert': `
+You have access to the UI/UX Expert agent. Consider:
+- User experience patterns
+- Accessibility (a11y) requirements
+- Design system consistency
+- Mobile-first approach
+`,
+  'architecture-expert': `
+You have access to the Architecture Expert agent. Consider:
+- System design patterns
+- Code organization
+- Dependency management
+- Scalability concerns
+`,
+  'code-review-expert': `
+You have access to the Code Review Expert agent. Consider:
+- Code quality standards
+- Best practices
+- Potential improvements
+- Technical debt
+`,
+  'vercel-expert': `
+You have access to the Vercel Expert agent. Consider:
+- Vercel deployment configuration
+- Edge functions
+- ISR and SSR strategies
+- Environment variables
+`
+};
+
+/**
+ * Skill snippet templates (simplified - would load from files in production)
+ */
+const SKILL_SNIPPETS = {
+  'auth/clerk': 'Use Clerk middleware for auth. Server: auth() from @clerk/nextjs/server. Client: useAuth() hook.',
+  'auth/nextauth': 'Configure NextAuth in app/api/auth/[...nextauth]/route.ts. Use getServerSession() server-side.',
+  'database/prisma': 'Use Prisma Client for queries. Run migrations with prisma migrate dev. Use transactions for multi-step operations.',
+  'database/drizzle': 'Define schema in drizzle/schema.ts. Use drizzle-kit for migrations. Type-safe queries with db.select().',
+  'api/route-handler': 'Export GET, POST, PUT, DELETE functions. Use NextRequest/NextResponse. Validate with Zod.',
+  'api/server-action': 'Mark with "use server". Return typed responses. Handle errors gracefully. Use revalidatePath/revalidateTag.',
+  'payments/stripe': 'Use Stripe.js for client-side. stripe.checkout.sessions.create() for checkout. Verify webhook signatures.',
+  'testing/vitest': 'Configure in vitest.config.ts. Use describe/it/expect. Mock with vi.mock(). Test utilities with @testing-library/react.',
+  'testing/playwright': 'Configure in playwright.config.ts. Use page.goto(), page.click(). Assert with expect(locator).',
+  'security/validation': 'Validate all inputs with Zod schemas. Sanitize HTML. Use parameterized queries.',
+  'security/rate-limiting': 'Implement with upstash/ratelimit or custom middleware. Apply to sensitive endpoints.',
+  'ai/streaming': 'Use Vercel AI SDK. stream: true option. Handle with useChat() hook or StreamingTextResponse.',
+  'ai/tool-use': 'Define tools with Zod schemas. Parse tool calls from response. Execute and return results.'
+};
+
+/**
+ * Enhance a prompt with relevant context
+ * @param {string} originalPrompt - The original user prompt
+ * @param {object} detection - Detection result from context-detector
+ * @param {object} projectContext - Optional project context
+ * @returns {object|null} Enhanced context or null if no enhancement needed
+ */
+function enhance(originalPrompt, detection, projectContext = {}) {
+  if (!detection || detection.matches.length === 0) {
+    return null;
+  }
+
+  const sections = [];
+
+  // Add agent contexts
+  if (detection.suggestedAgents.length > 0) {
+    sections.push('## Relevant Expertise\n');
+    for (const agentName of detection.suggestedAgents.slice(0, 3)) {
+      const context = AGENT_CONTEXTS[agentName];
+      if (context) {
+        sections.push(context);
+      }
+    }
+  }
+
+  // Add skill hints
+  if (detection.suggestedSkills.length > 0) {
+    sections.push('\n## Recommended Patterns\n');
+    for (const skillName of detection.suggestedSkills.slice(0, 3)) {
+      const snippet = SKILL_SNIPPETS[skillName];
+      if (snippet) {
+        sections.push(`- **${skillName}**: ${snippet}`);
+      }
+    }
+  }
+
+  // Add project context if available
+  if (projectContext.stack) {
+    sections.push('\n## Project Stack\n');
+    sections.push(`- Framework: ${projectContext.stack.framework || 'unknown'}`);
+    sections.push(`- Language: ${projectContext.stack.language || 'unknown'}`);
+    sections.push(`- Database: ${projectContext.stack.database || 'unknown'}`);
+  }
+
+  // Add category-specific tips
+  if (detection.primaryCategory) {
+    const tips = getCategoryTips(detection.primaryCategory);
+    if (tips) {
+      sections.push(`\n## ${detection.primaryCategory.charAt(0).toUpperCase() + detection.primaryCategory.slice(1)} Tips\n`);
+      sections.push(tips);
+    }
+  }
+
+  if (sections.length === 0) {
+    return null;
+  }
+
+  return {
+    enhancedContext: sections.join('\n'),
+    agents: detection.suggestedAgents,
+    skills: detection.suggestedSkills,
+    confidence: detection.confidence,
+    category: detection.primaryCategory
+  };
+}
+
+/**
+ * Get category-specific tips
+ * @param {string} category - Category name
+ * @returns {string|null} Tips string or null
+ */
+function getCategoryTips(category) {
+  const tips = {
+    database: `
+- Always use migrations for schema changes
+- Index frequently queried columns
+- Use transactions for related operations
+- Consider soft deletes for important data
+`,
+    authentication: `
+- Never store passwords in plain text
+- Use secure session management
+- Implement proper logout (invalidate tokens)
+- Consider rate limiting login attempts
+`,
+    frontend: `
+- Use Server Components by default
+- Add 'use client' only when needed
+- Keep components focused and small
+- Use Tailwind for consistent styling
+`,
+    api: `
+- Validate all inputs with Zod
+- Return consistent error formats
+- Use proper HTTP status codes
+- Document your endpoints
+`,
+    payments: `
+- Always verify webhook signatures
+- Store Stripe IDs in your database
+- Handle subscription lifecycle events
+- Test with Stripe CLI locally
+`,
+    testing: `
+- Write tests before complex refactors
+- Mock external services
+- Aim for 80%+ coverage on critical paths
+- Use fixtures for test data
+`,
+    security: `
+- Validate and sanitize all inputs
+- Use HTTPS everywhere
+- Implement CSRF protection
+- Review OWASP Top 10 regularly
+`,
+    performance: `
+- Profile before optimizing
+- Lazy load non-critical resources
+- Use appropriate caching strategies
+- Monitor Core Web Vitals
+`,
+    deployment: `
+- Use environment variables for config
+- Set up staging environments
+- Implement health checks
+- Have a rollback strategy
+`
+  };
+
+  return tips[category] || null;
+}
+
+/**
+ * Format enhanced context for display
+ * @param {object} enhancement - Enhancement result
+ * @returns {string} Formatted string
+ */
+function format(enhancement) {
+  if (!enhancement) return '';
+
+  const lines = [];
+
+  lines.push('---');
+  lines.push('**Bootspring Context Enhancement**');
+  lines.push(`Category: ${enhancement.category || 'general'}`);
+  lines.push(`Confidence: ${Math.round(enhancement.confidence * 100)}%`);
+
+  if (enhancement.agents.length > 0) {
+    lines.push(`Agents: ${enhancement.agents.join(', ')}`);
+  }
+
+  if (enhancement.skills.length > 0) {
+    lines.push(`Skills: ${enhancement.skills.join(', ')}`);
+  }
+
+  lines.push('---');
+  lines.push(enhancement.enhancedContext);
+  lines.push('---');
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  enhance,
+  format,
+  getCategoryTips,
+  AGENT_CONTEXTS,
+  SKILL_SNIPPETS
+};