50c 2.5.3 → 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/librarian.js

@@ -96,6 +96,210 @@ async function folderPlan(fileList, instruction) {
   });
 }
 
+// ═══════════════════════════════════════════════════════════════
+//                    BROWSER UTILITIES (LOCAL)
+// ═══════════════════════════════════════════════════════════════
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+function getChromeDataPath(profile = 'Default') {
+  const platform = process.platform;
+  const home = process.env.HOME || process.env.USERPROFILE;
+  
+  if (platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA, 'Google', 'Chrome', 'User Data', profile);
+  } else if (platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Google', 'Chrome', profile);
+  } else {
+    return path.join(home, '.config', 'google-chrome', profile);
+  }
+}
+
+function parseBookmarksFile(profile = 'Default') {
+  const bookmarksPath = path.join(getChromeDataPath(profile), 'Bookmarks');
+  if (!fs.existsSync(bookmarksPath)) {
+    throw new Error(`Chrome bookmarks not found at ${bookmarksPath}`);
+  }
+  
+  const data = JSON.parse(fs.readFileSync(bookmarksPath, 'utf8'));
+  const urls = [];
+  
+  function extractUrls(node, folder = '') {
+    if (node.url) {
+      urls.push({ url: node.url, title: node.name, folder });
+    }
+    if (node.children) {
+      const newFolder = node.name || folder;
+      node.children.forEach(child => extractUrls(child, newFolder));
+    }
+  }
+  
+  Object.values(data.roots).forEach(root => extractUrls(root));
+  return urls;
+}
+
+function checkUrl(url, timeout = 10000) {
+  return new Promise((resolve) => {
+    const protocol = url.startsWith('https') ? https : http;
+    const req = protocol.get(url, { 
+      timeout,
+      headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0' }
+    }, (res) => {
+      resolve({ url, status: res.statusCode, ok: res.statusCode >= 200 && res.statusCode < 400 });
+    });
+    req.on('error', (e) => resolve({ url, status: 0, ok: false, error: e.message }));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({ url, status: 0, ok: false, error: 'timeout' });
+    });
+  });
+}
+
+async function chromeBookmarksCheck(limit = 100, timeout = 10, profile = 'Default') {
+  const bookmarks = parseBookmarksFile(profile);
+  const toCheck = bookmarks.filter(b => 
+    b.url.startsWith('http') && !b.url.includes('localhost') && !b.url.includes('127.0.0.1')
+  ).slice(0, limit);
+  
+  const results = { ok: [], dead: [], errors: [], skipped: bookmarks.length - toCheck.length };
+  
+  // Check in batches of 10
+  for (let i = 0; i < toCheck.length; i += 10) {
+    const batch = toCheck.slice(i, i + 10);
+    const checks = await Promise.all(batch.map(b => checkUrl(b.url, timeout * 1000)));
+    
+    checks.forEach((result, idx) => {
+      const bookmark = batch[idx];
+      if (result.ok) {
+        results.ok.push({ ...bookmark, status: result.status });
+      } else if (result.status === 404) {
+        results.dead.push({ ...bookmark, status: 404 });
+      } else {
+        results.errors.push({ ...bookmark, status: result.status, error: result.error });
+      }
+    });
+  }
+  
+  return {
+    total: bookmarks.length,
+    checked: toCheck.length,
+    ok: results.ok.length,
+    dead: results.dead,
+    errors: results.errors.filter(e => e.status !== 403), // 403 = login required, not dead
+    login_required: results.errors.filter(e => e.status === 403),
+    skipped: results.skipped
+  };
+}
+
+function getExtensionsInfo(profile = 'Default') {
+  const extPath = path.join(getChromeDataPath(profile), 'Extensions');
+  if (!fs.existsSync(extPath)) {
+    return { error: 'Extensions folder not found' };
+  }
+  
+  const extensions = [];
+  const extDirs = fs.readdirSync(extPath);
+  
+  extDirs.forEach(extId => {
+    const extDir = path.join(extPath, extId);
+    if (fs.statSync(extDir).isDirectory()) {
+      const versions = fs.readdirSync(extDir).filter(v => !v.startsWith('.'));
+      if (versions.length > 0) {
+        const latestVersion = versions.sort().pop();
+        const manifestPath = path.join(extDir, latestVersion, 'manifest.json');
+        
+        if (fs.existsSync(manifestPath)) {
+          try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            extensions.push({
+              id: extId,
+              name: manifest.name || 'Unknown',
+              version: manifest.version,
+              description: manifest.description?.substring(0, 100),
+              permissions: manifest.permissions || [],
+              hostPermissions: manifest.host_permissions || manifest.optional_host_permissions || []
+            });
+          } catch (e) {
+            extensions.push({ id: extId, name: 'Unknown', error: 'Invalid manifest' });
+          }
+        }
+      }
+    }
+  });
+  
+  // Flag risky extensions
+  const risky = extensions.filter(ext => {
+    const perms = [...(ext.permissions || []), ...(ext.hostPermissions || [])];
+    return perms.some(p => 
+      p.includes('<all_urls>') || 
+      p.includes('*://*/*') || 
+      p === 'webRequest' || 
+      p === 'webRequestBlocking'
+    );
+  });
+  
+  return {
+    total: extensions.length,
+    extensions,
+    risky,
+    recommendations: risky.length > 0 ? 
+      `Found ${risky.length} extensions with broad permissions. Review: ${risky.map(e => e.name).join(', ')}` : 
+      'No obviously risky extensions found'
+  };
+}
+
+async function passwordsCheck(exportFile, checkBreaches = false) {
+  if (!fs.existsSync(exportFile)) {
+    return { error: `File not found: ${exportFile}` };
+  }
+  
+  const csv = fs.readFileSync(exportFile, 'utf8');
+  const lines = csv.split('\n').slice(1); // Skip header
+  
+  const passwords = lines.filter(l => l.trim()).map(line => {
+    const parts = line.split(',');
+    return {
+      name: parts[0],
+      url: parts[1],
+      username: parts[2],
+      password: parts[3]
+    };
+  });
+  
+  // Check for weak passwords
+  const weak = passwords.filter(p => {
+    const pwd = p.password || '';
+    return pwd.length < 8 || 
+           pwd === pwd.toLowerCase() || 
+           /^[0-9]+$/.test(pwd) ||
+           ['password', '123456', 'qwerty'].includes(pwd.toLowerCase());
+  });
+  
+  // Check for reused passwords
+  const pwdCounts = {};
+  passwords.forEach(p => {
+    const pwd = p.password;
+    pwdCounts[pwd] = (pwdCounts[pwd] || 0) + 1;
+  });
+  const reused = Object.entries(pwdCounts).filter(([_, count]) => count > 1);
+  
+  return {
+    total: passwords.length,
+    weak: weak.map(p => ({ name: p.name, url: p.url, reason: 'Weak password pattern' })),
+    reused: reused.map(([pwd, count]) => ({ 
+      count, 
+      sites: passwords.filter(p => p.password === pwd).map(p => p.name).slice(0, 3)
+    })),
+    recommendations: [
+      weak.length > 0 ? `${weak.length} weak passwords need updating` : null,
+      reused.length > 0 ? `${reused.length} passwords are reused across sites` : null
+    ].filter(Boolean)
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════
 //                    TOOL DEFINITIONS
 // ═══════════════════════════════════════════════════════════════
@@ -439,6 +643,76 @@ const LIBRARIAN_TOOLS = [
     },
     cost: 0.08,
     tier: 'pro'
+  },
+
+  // ═══════════════════════════════════════════════════════════════
+  //                    BROWSER MANAGEMENT
+  // ═══════════════════════════════════════════════════════════════
+  {
+    name: 'chrome_bookmarks_check',
+    description: 'Check Chrome bookmarks for dead links (404, timeouts). Local scan. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', default: 100, description: 'Max URLs to check' },
+        timeout: { type: 'number', default: 10, description: 'Timeout per URL (seconds)' },
+        profile: { type: 'string', default: 'Default', description: 'Chrome profile name' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'chrome_bookmarks_report',
+    description: 'Full bookmark health report with categorization. $0.05',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        include_recommendations: { type: 'boolean', default: true },
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0.05,
+    tier: 'pro'
+  },
+  {
+    name: 'chrome_extensions_audit',
+    description: 'Audit installed Chrome extensions for security/bloat. FREE.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0,
+    tier: 'pro'
+  },
+  {
+    name: 'browser_passwords_check',
+    description: 'Check for weak/reused passwords (via Puppeteer). $0.10',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        export_file: { type: 'string', description: 'Path to exported passwords CSV' },
+        check_breaches: { type: 'boolean', default: false, description: 'Check haveibeenpwned (requires API key)' }
+      },
+      required: ['export_file']
+    },
+    cost: 0.10,
+    tier: 'pro'
+  },
+  {
+    name: 'browser_history_analyze',
+    description: 'Analyze browsing patterns for productivity insights. $0.08',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        days: { type: 'number', default: 30, description: 'Days of history to analyze' },
+        profile: { type: 'string', default: 'Default' }
+      }
+    },
+    cost: 0.08,
+    tier: 'pro'
   }
 ];
 
@@ -471,6 +745,26 @@ async function handleTool(name, args) {
         return await folderDedup(args.files, args);
       case 'folder_plan':
         return await folderPlan(args.files, args.instruction);
+      
+      // Browser tools (local execution)
+      case 'chrome_bookmarks_check':
+        return await chromeBookmarksCheck(args.limit || 100, args.timeout || 10, args.profile || 'Default');
+      case 'chrome_bookmarks_report':
+        const checkResult = await chromeBookmarksCheck(500, 8, args.profile || 'Default');
+        return apiRequest('POST', '/tools/librarian/bookmarks_report', { 
+          check_result: checkResult, 
+          include_recommendations: args.include_recommendations !== false 
+        });
+      case 'chrome_extensions_audit':
+        return getExtensionsInfo(args.profile || 'Default');
+      case 'browser_passwords_check':
+        return await passwordsCheck(args.export_file, args.check_breaches);
+      case 'browser_history_analyze':
+        return apiRequest('POST', '/tools/librarian/history_analyze', { 
+          days: args.days || 30, 
+          profile: args.profile || 'Default' 
+        });
+      
       default:
         return { error: `Unknown librarian tool: ${name}` };
     }
@@ -492,5 +786,9 @@ module.exports = {
   folderAnalyze,
   folderOrganize,
   folderDedup,
-  folderPlan
+  folderPlan,
+  // Browser tools
+  chromeBookmarksCheck,
+  getExtensionsInfo,
+  passwordsCheck
 };

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.5.3",
-  "description": "AI toolkit with Dewey index. 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",