50c 2.6.0 → 2.7.0

package/lib/index.js

@@ -22,12 +22,14 @@ const whm = require('./packs/whm');
 const cf = require('./packs/cf');
 const wp = require('./packs/wp');
 const ux = require('./packs/ux');
+const promptEngine = require('./packs/prompt_engine');
 
 // Tool name mappings by pack
 const TOOL_PACKS = {
   beacon: ['hints', 'hints_plus', 'roast', 'quick_vibe', 'one_liner', 'name_it', 'price_it', 'compute', 'ide_conversation', 'learning_stats'],
   labs: ['genius', 'mind_opener', 'idea_fold', 'agent_autopsy', 'prompt_fortress', 'context_health', 'context_compress', 'context_extract', 'context_reposition'],
-  labs_plus: ['bcalc', 'genius_plus', 'bcalc_why', 'discovery_collision', 'cvi_loop', 'cvi_verify', 'chaos_fingerprint', 'resonance', 'prime_residue', 'echo_sequence', 'conversation_diagnostic', 'handoff']
+  labs_plus: ['bcalc', 'genius_plus', 'bcalc_why', 'discovery_collision', 'cvi_loop', 'cvi_verify', 'chaos_fingerprint', 'resonance', 'prime_residue', 'echo_sequence', 'conversation_diagnostic', 'handoff'],
+  prompt_engine: ['prompt_extract', 'prompt_phases', 'prompt_refine', 'prompt_expand', 'prompt_categorize']
 };
 
 // Get all available tools based on enabled packs
@@ -53,6 +55,7 @@ async function getTools() {
   if (config.packs.cf) tools.push(...cf.CF_TOOLS);
   if (config.packs.wp) tools.push(...wp.WP_TOOLS);
   if (config.packs.ux) tools.push(...ux.UX_TOOLS);
+  if (config.packs.prompt_engine) tools.push(...promptEngine.PROMPT_ENGINE_TOOLS);
   
   // ENTERPRISE tier
   if (config.packs.labs_plus) tools.push(...labsPlus.LABS_PLUS_TOOLS);
@@ -101,6 +104,14 @@ async function handleTool(name, args = {}) {
     return labs.handleTool(name, args);
   }
   
+  // Prompt Engine tools (PRO)
+  if (TOOL_PACKS.prompt_engine.includes(name)) {
+    if (!config.packs.prompt_engine) {
+      return { error: 'Requires Pro tier ($99/mo). Enable prompt_engine pack or upgrade at sales.50c.ai/50c-pro/' };
+    }
+    return promptEngine.handleTool(name, args);
+  }
+  
   // Labs+ tools (ENTERPRISE)
   if (TOOL_PACKS.labs_plus.includes(name)) {
     if (!config.packs.labs_plus) {
@@ -171,5 +182,6 @@ module.exports = {
   packs,
   beacon,
   labs,
-  labsPlus
+  labsPlus,
+  promptEngine
 };

package/lib/packs/prompt_engine.js

@@ -0,0 +1,365 @@
+/**
+ * 50c Prompt Engine Pack - PRO Tier
+ * Harvested from CrazyBuild: extractConceptDetails + 4-phase prompt generation
+ * Available at: 50c.ai/prompt-engine
+ */
+
+const { apiRequest } = require('../config');
+
+// Feature patterns for concept extraction
+const FEATURE_PATTERNS = [
+  // Healthcare/Medical
+  /(?:patient\s+portal|medical\s+records|EHR|EMR|HIPAA|health\s+records|appointment\s+booking|telemedicine|virtual\s+consultation|prescription|diagnosis)/gi,
+  // Standard features
+  /(?:booking|appointment|scheduling|calendar|reservation)/gi,
+  /(?:payment|checkout|purchase|shopping\s+cart|billing|invoice)/gi,
+  /(?:user\s+account|profile|authentication|login|registration|sign\s+up)/gi,
+  /(?:search|filter|find|browse|lookup)/gi,
+  /(?:dashboard|analytics|reporting|metrics|insights)/gi,
+  /(?:messaging|chat|communication|contact|notifications)/gi,
+  /(?:upload|file|image|media|document|attachment)/gi,
+  /(?:review|rating|feedback|testimonial|comment)/gi,
+  /(?:blog|news|article|post|content)/gi,
+  /(?:gallery|portfolio|showcase|catalog)/gi,
+  // Business/professional
+  /(?:CRM|customer\s+management|lead\s+tracking|sales\s+pipeline)/gi,
+  /(?:inventory|stock|warehouse|catalog\s+management)/gi,
+  /(?:workflow|automation|process|task\s+management)/gi,
+  /(?:collaboration|team|sharing|permissions)/gi,
+  /(?:export|import|integration|API)/gi
+];
+
+// Capability patterns
+const CAPABILITY_PATTERNS = [
+  /(?:allows?\s+(?:users?|patients?|customers?|clients?)\s+to\s+)([^.]{10,80})/gi,
+  /(?:enables?\s+(?:users?|patients?|customers?|clients?)\s+to\s+)([^.]{10,80})/gi,
+  /(?:provides?\s+)([^.]{10,80})/gi,
+  /(?:includes?\s+)([^.]{10,80})/gi,
+  /(?:features?\s+)([^.]{10,80})/gi,
+  /(?:supports?\s+)([^.]{10,80})/gi,
+  /(?:manages?\s+)([^.]{10,80})/gi
+];
+
+// Domain-specific terms
+const TERM_PATTERNS = [
+  /\b[A-Z]{2,}(?:\s+[A-Z]{2,})*\b/g,
+  /\b(?:HIPAA|GDPR|SOC2|PCI|ISO|WCAG)\b/gi,
+  /\b(?:telemedicine|telehealth|virtual\s+care|remote\s+consultation)\b/gi,
+  /\b(?:e-commerce|marketplace|B2B|B2C|SaaS)\b/gi,
+  /\b(?:real-time|live|instant|automated|AI-powered|ML-based)\b/gi
+];
+
+// Audience patterns
+const AUDIENCE_PATTERNS = [
+  /(?:for|targeting|serving|helping)\s+([a-z\s]+?)(?:\.|,|\s+who|\s+seeking)/i,
+  /(?:designed\s+for|built\s+for|created\s+for)\s+([a-z\s]+?)(?:\.|,|\s+who|\s+to)/i,
+  /(?:patients?|doctors?|physicians?|nurses?|healthcare\s+professionals?|clinicians?|medical\s+staff)/gi,
+  /(?:customers?|clients?|users?|members?|subscribers?|students?|teachers?)/gi
+];
+
+// App type categories
+const APP_CATEGORIES = {
+  'saas': { keywords: ['subscription', 'platform', 'dashboard', 'analytics', 'team'], niche: 'B2B Software' },
+  'ecommerce': { keywords: ['shop', 'cart', 'payment', 'product', 'checkout'], niche: 'Online Retail' },
+  'marketplace': { keywords: ['vendor', 'seller', 'buyer', 'listing', 'auction'], niche: 'Two-Sided Platform' },
+  'healthcare': { keywords: ['patient', 'medical', 'health', 'clinic', 'doctor'], niche: 'HealthTech' },
+  'fintech': { keywords: ['payment', 'banking', 'investment', 'finance', 'trading'], niche: 'Financial Services' },
+  'edtech': { keywords: ['course', 'learning', 'student', 'teacher', 'education'], niche: 'Education' },
+  'social': { keywords: ['profile', 'feed', 'follow', 'share', 'community'], niche: 'Social Network' },
+  'productivity': { keywords: ['task', 'project', 'todo', 'workflow', 'calendar'], niche: 'Business Tools' },
+  'content': { keywords: ['blog', 'article', 'post', 'media', 'cms'], niche: 'Content Management' },
+  'booking': { keywords: ['appointment', 'reservation', 'schedule', 'booking', 'availability'], niche: 'Scheduling' }
+};
+
+/**
+ * Extract concept details from natural language description
+ * Core pattern harvested from CrazyBuild
+ */
+function extractConceptDetails(concept, projectTitle = '') {
+  // Extract business name
+  const businessMatch = concept.match(/([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+(?:website|business|company|into|from|platform|app|system)/);
+  const businessName = businessMatch?.[1] || projectTitle || 'App';
+
+  // Extract features
+  const features = [];
+  FEATURE_PATTERNS.forEach(pattern => {
+    const matches = concept.match(pattern);
+    if (matches) {
+      matches.forEach(match => {
+        const normalized = match.toLowerCase().trim();
+        if (!features.includes(normalized)) features.push(normalized);
+      });
+    }
+  });
+
+  // Extract capabilities
+  const capabilities = [];
+  CAPABILITY_PATTERNS.forEach(pattern => {
+    const matches = concept.matchAll(pattern);
+    for (const match of matches) {
+      const cap = match[1].trim();
+      if (cap.length >= 10 && cap.length <= 80 && !cap.includes('\n')) {
+        capabilities.push(cap);
+      }
+    }
+  });
+
+  // Extract domain terms
+  const terms = [];
+  TERM_PATTERNS.forEach(pattern => {
+    const matches = concept.match(pattern);
+    if (matches) {
+      matches.forEach(match => {
+        const normalized = match.toUpperCase().trim();
+        if (!terms.includes(normalized)) terms.push(normalized);
+      });
+    }
+  });
+
+  // Extract target audience
+  let audience = 'users';
+  for (const pattern of AUDIENCE_PATTERNS) {
+    const match = concept.match(pattern);
+    if (match && match[1] && match[1].trim().length > 3) {
+      audience = match[1].trim();
+      break;
+    }
+  }
+
+  // Detect app type
+  const conceptLower = concept.toLowerCase();
+  let appType = 'general';
+  let appNiche = 'Web Application';
+  let maxScore = 0;
+
+  for (const [type, config] of Object.entries(APP_CATEGORIES)) {
+    const score = config.keywords.filter(kw => conceptLower.includes(kw)).length;
+    if (score > maxScore) {
+      maxScore = score;
+      appType = type;
+      appNiche = config.niche;
+    }
+  }
+
+  return {
+    businessName,
+    features: features.slice(0, 12),
+    capabilities: capabilities.slice(0, 10),
+    terms: terms.slice(0, 8),
+    audience,
+    appType,
+    appNiche,
+    confidence: Math.min(maxScore / 3, 1)
+  };
+}
+
+/**
+ * Generate 4-phase prompt structure
+ * Phase 1: Foundation & Setup
+ * Phase 2: Core Features
+ * Phase 3: User Experience
+ * Phase 4: Launch & Scale
+ */
+function generatePhases(concept, details) {
+  const { businessName, features, capabilities, audience, appType, appNiche } = details;
+  
+  return [
+    {
+      phase: 1,
+      title: 'Foundation & Setup',
+      focus: 'Architecture, authentication, database schema',
+      content: `Build the foundation for ${businessName}:
+- Set up project structure (React + Hono + Cloudflare Workers)
+- Design database schema for ${appNiche}
+- Implement authentication system
+- Create base API routes
+- Set up deployment pipeline
+
+Target: ${audience}
+App Type: ${appType}
+Key Features: ${features.slice(0, 4).join(', ')}`,
+      suggestedTools: ['GenXis Auth', 'GenXis CRUD', 'Database Schema Generator']
+    },
+    {
+      phase: 2,
+      title: 'Core Features',
+      focus: 'Primary functionality and business logic',
+      content: `Implement core features:
+${features.map((f, i) => `${i + 1}. ${f}`).join('\n')}
+
+Capabilities:
+${capabilities.slice(0, 5).map((c, i) => `- ${c}`).join('\n')}
+
+Database operations, API endpoints, and business logic for each feature.`,
+      suggestedTools: ['GenXis CRUD Builder', 'GenXis Search', 'GenXis File Upload']
+    },
+    {
+      phase: 3,
+      title: 'User Experience',
+      focus: 'UI/UX, responsive design, accessibility',
+      content: `Design the user experience for ${audience}:
+- Responsive layout (mobile-first)
+- Component library setup
+- Form validation and error handling
+- Loading states and optimistic updates
+- Accessibility (WCAG 2.1 AA)
+
+Style: Modern, clean, ${appType === 'healthcare' ? 'trustworthy' : 'professional'}
+Theme: Dark mode with light mode toggle`,
+      suggestedTools: ['GenXis UI Kit', 'GenXis Analytics', 'GenXis Performance']
+    },
+    {
+      phase: 4,
+      title: 'Launch & Scale',
+      focus: 'Deployment, monitoring, optimization',
+      content: `Prepare for production:
+- Performance optimization
+- Security hardening
+- Error monitoring (Sentry)
+- Analytics integration
+- SEO optimization
+- Documentation
+
+Compliance: ${details.terms.filter(t => ['HIPAA', 'GDPR', 'SOC2', 'PCI'].includes(t)).join(', ') || 'Standard web security'}`,
+      suggestedTools: ['GenXis Security', 'GenXis Analytics', 'GenXis Email']
+    }
+  ];
+}
+
+// API calls
+async function promptExtract(concept, title = '') {
+  const details = extractConceptDetails(concept, title);
+  return { success: true, ...details };
+}
+
+async function promptPhases(concept, title = '') {
+  const details = extractConceptDetails(concept, title);
+  const phases = generatePhases(concept, details);
+  return { success: true, details, phases };
+}
+
+async function promptRefine(concept, feedback) {
+  return apiRequest('POST', '/tools/prompt_refine', { concept, feedback });
+}
+
+async function promptExpand(idea) {
+  return apiRequest('POST', '/tools/prompt_expand', { idea });
+}
+
+async function promptCategorize(concept) {
+  const details = extractConceptDetails(concept);
+  return {
+    success: true,
+    appType: details.appType,
+    appNiche: details.appNiche,
+    confidence: details.confidence,
+    suggestedCategory: APP_CATEGORIES[details.appType]?.niche || 'General'
+  };
+}
+
+// Tool definitions
+const PROMPT_ENGINE_TOOLS = [
+  {
+    name: 'prompt_extract',
+    description: 'Extract features, capabilities, audience from natural language. $0.02',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'Natural language app description' },
+        title: { type: 'string', description: 'Optional project title' }
+      },
+      required: ['concept']
+    },
+    cost: 0.02,
+    tier: 'pro'
+  },
+  {
+    name: 'prompt_phases',
+    description: 'Generate 4-phase development prompts from concept. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'Natural language app description' },
+        title: { type: 'string', description: 'Optional project title' }
+      },
+      required: ['concept']
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'prompt_refine',
+    description: 'Refine prompts with conversational feedback. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'Current concept/prompt' },
+        feedback: { type: 'string', description: 'User feedback to incorporate' }
+      },
+      required: ['concept', 'feedback']
+    },
+    cost: 0.08,
+    tier: 'pro'
+  },
+  {
+    name: 'prompt_expand',
+    description: 'Expand short idea into detailed concept. $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        idea: { type: 'string', description: 'Short idea (1-2 sentences)' }
+      },
+      required: ['idea']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'prompt_categorize',
+    description: 'Auto-detect app type and niche. $0.01',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concept: { type: 'string', description: 'App concept to categorize' }
+      },
+      required: ['concept']
+    },
+    cost: 0.01,
+    tier: 'pro'
+  }
+];
+
+// Handle tool calls
+async function handleTool(name, args) {
+  try {
+    switch (name) {
+      case 'prompt_extract':
+        return await promptExtract(args.concept, args.title);
+      case 'prompt_phases':
+        return await promptPhases(args.concept, args.title);
+      case 'prompt_refine':
+        return await promptRefine(args.concept, args.feedback);
+      case 'prompt_expand':
+        return await promptExpand(args.idea);
+      case 'prompt_categorize':
+        return await promptCategorize(args.concept);
+      default:
+        return { error: `Unknown prompt_engine tool: ${name}` };
+    }
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  promptExtract,
+  promptPhases,
+  promptRefine,
+  promptExpand,
+  promptCategorize,
+  extractConceptDetails,
+  generatePhases,
+  PROMPT_ENGINE_TOOLS,
+  handleTool,
+  APP_CATEGORIES
+};

package/lib/packs.js

@@ -73,6 +73,13 @@ const PACKS = {
     tier: 'pro',
     highlights: ['ux_list_blocks', 'ux_ab_compare', 'ux_a11y_check']
   },
+  prompt_engine: {
+    name: 'prompt_engine',
+    description: 'Prompt engineering - extract, phases, refine, expand',
+    tools: 5,
+    tier: 'pro',
+    highlights: ['prompt_extract', 'prompt_phases', 'prompt_expand', 'prompt_categorize']
+  },
   librarian: {
     name: 'librarian',
     description: 'Digital asset manager - domains, bookmarks, CSV, folders, writing style',
@@ -184,6 +191,12 @@ const TOOL_TIERS = {
   ux_a11y_check: 'pro',
   ux_color_palette: 'pro',
   ux_contrast_check: 'pro',
+  // Prompt Engine tools
+  prompt_extract: 'pro',
+  prompt_phases: 'pro',
+  prompt_refine: 'pro',
+  prompt_expand: 'pro',
+  prompt_categorize: 'pro',
   // Librarian tools
   bookmarks_prune: 'pro',
   bookmarks_organize: 'pro',
@@ -395,7 +408,7 @@ const PACK_TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        pack: { type: 'string', description: 'Pack name', enum: ['beacon', 'labs', 'labs_plus', 'whm', 'cf', 'wp', 'ux', 'librarian'] }
+        pack: { type: 'string', description: 'Pack name', enum: ['beacon', 'labs', 'labs_plus', 'whm', 'cf', 'wp', 'ux', 'prompt_engine', 'librarian'] }
       },
       required: ['pack']
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "50c",
-  "version": "2.6.0",
-  "description": "AI toolkit with browser tools. One install, 100+ tools.",
+  "version": "2.7.0",
+  "description": "AI toolkit with prompt engine. One install, 105+ tools.",
   "main": "lib/index.js",
   "bin": {
     "50c": "./bin/50c.js"
@@ -12,6 +12,7 @@
     "llm",
     "tools",
     "genius",
+    "prompt-engine",
     "agent-autopsy",
     "prompt-fortress",
     "bcalc",