@girardmedia/bootspring 1.2.0 → 2.0.3

package/core/utils.js

@@ -372,33 +372,44 @@ function isMCPContext() {
 }
 
 /**
- * Print MCP requirement message and return false if not in MCP context
- * Features protected by this are only accessible through AI assistant integration,
- * ensuring prompts and internal content are never exposed to stdout.
- * @param {string} feature - Feature name requiring MCP
+ * Print MCP recommendation message and return false if not in MCP context.
+ * This is a soft gate - callers should provide degraded functionality.
+ * @param {string} feature - Feature name that benefits from MCP
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.silent - Don't print any message
+ * @param {boolean} options.brief - Print brief message instead of full
  * @returns {boolean} True if in MCP context, false otherwise
  */
-function requireMCP(feature) {
+function requireMCP(feature, options = {}) {
   if (isMCPContext()) {
     return true;
   }
 
+  if (options.silent) {
+    return false;
+  }
+
+  if (options.brief) {
+    console.log(`${COLORS.dim}Note: ${feature} has enhanced features when used with MCP integration.${COLORS.reset}`);
+    console.log(`${COLORS.dim}Run "bootspring mcp" for setup instructions.${COLORS.reset}\n`);
+    return false;
+  }
+
   console.log(`
-${COLORS.yellow}${COLORS.bold}MCP Integration Required${COLORS.reset}
+${COLORS.yellow}${COLORS.bold}Limited Mode - MCP Integration Recommended${COLORS.reset}
+
+${feature} works in CLI mode but has enhanced features through MCP integration.
+MCP enables real-time AI-assisted workflows and deeper integration.
 
-${feature} is only available through MCP (Model Context Protocol) integration.
-This ensures AI-powered features work seamlessly with your assistant.
+${COLORS.bold}Current Mode:${COLORS.reset} CLI (limited functionality)
+${COLORS.bold}Enhanced Mode:${COLORS.reset} MCP (full AI integration)
 
-${COLORS.bold}Setup:${COLORS.reset}
+${COLORS.bold}To enable full features:${COLORS.reset}
   1. Start the MCP server:
      ${COLORS.cyan}bootspring mcp start${COLORS.reset}
 
   2. Add Bootspring to your AI client's MCP configuration
 
-  3. Use natural language with your AI assistant:
-     ${COLORS.dim}"Help me implement authentication"${COLORS.reset}
-     ${COLORS.dim}"Review this code for security issues"${COLORS.reset}
-
 ${COLORS.bold}Documentation:${COLORS.reset}
   https://bootspring.com/docs/mcp-setup
 
@@ -408,6 +419,18 @@ ${COLORS.dim}Run "bootspring mcp" for server options${COLORS.reset}
   return false;
 }
 
+/**
+ * Print a warning about MCP-only features (non-blocking)
+ * Use this when a command works without MCP but has reduced functionality
+ * @param {string} feature - Feature with limited functionality
+ */
+function warnMCPLimited(feature) {
+  if (isMCPContext()) return;
+
+  console.log(`${COLORS.dim}Note: ${feature} - some features require MCP integration.${COLORS.reset}`);
+  console.log(`${COLORS.dim}Run "bootspring mcp" for setup instructions.${COLORS.reset}\n`);
+}
+
 module.exports = {
   COLORS,
   print,
@@ -427,5 +450,6 @@ module.exports = {
   isCI,
   getPackageJson,
   isMCPContext,
-  requireMCP
+  requireMCP,
+  warnMCPLimited
 };

package/generators/questionnaire.js

@@ -12,7 +12,7 @@ const readline = require('readline');
 const utils = require('../core/utils');
 
 /**
- * Questionnaire configuration - 16 sections
+ * Questionnaire configuration - 17 sections
  */
 const QUESTIONNAIRE_CONFIG = {
   sections: [
@@ -29,28 +29,31 @@ const QUESTIONNAIRE_CONFIG = {
     'deployment',     // 11. DevOps & Deployment
     'security',       // 12. Security Requirements
     'features',       // 13. Features & Functionality
-    'workflow',       // 14. Team & Workflow
-    'instructions',   // 15. Custom Instructions
-    'advanced'        // 16. Advanced Options
+    'content',        // 14. Content & Documentation
+    'workflow',       // 15. Team & Workflow
+    'instructions',   // 16. Custom Instructions
+    'advanced'        // 17. Advanced Options
   ],
   presets: {
     // Quick setup - just the essentials (4 sections)
     minimal: ['pre-build', 'identity', 'technical', 'features'],
-    // Standard setup - core config (8 sections)
-    standard: ['pre-build', 'identity', 'business', 'technical', 'frontend', 'auth', 'workflow', 'instructions'],
-    // Full setup - all sections (16 sections)
+    // Standard setup - core config (9 sections)
+    standard: ['pre-build', 'identity', 'business', 'technical', 'frontend', 'auth', 'content', 'workflow', 'instructions'],
+    // Full setup - all sections (17 sections)
     full: [
       'pre-build', 'identity', 'business', 'technical', 'frontend', 'backend',
       'auth', 'payments', 'ai', 'testing', 'deployment', 'security',
-      'features', 'workflow', 'instructions', 'advanced'
+      'features', 'content', 'workflow', 'instructions', 'advanced'
     ],
-    // Startup preset - business-focused (10 sections)
+    // Startup preset - business-focused (11 sections)
     startup: [
       'pre-build', 'identity', 'business', 'technical', 'frontend',
-      'auth', 'payments', 'features', 'workflow', 'instructions'
+      'auth', 'payments', 'features', 'content', 'workflow', 'instructions'
     ],
-    // API preset - backend-focused (8 sections)
-    api: ['pre-build', 'identity', 'technical', 'backend', 'auth', 'testing', 'deployment', 'security']
+    // API preset - backend-focused (9 sections)
+    api: ['pre-build', 'identity', 'technical', 'backend', 'auth', 'testing', 'deployment', 'security', 'content'],
+    // Content preset - content and marketing focused (8 sections)
+    content: ['pre-build', 'identity', 'business', 'technical', 'frontend', 'content', 'workflow', 'instructions']
   }
 };
 

package/generators/sections/ai.js

@@ -28,21 +28,21 @@ async function run(rl, previousAnswers, helpers) {
     return answers;
   }
 
-  // AI Provider
+  // AI Providers (multi-select)
   const providerOptions = [
     { label: 'Anthropic (Claude)', value: 'anthropic', description: 'Claude models (Recommended)' },
     { label: 'OpenAI', value: 'openai', description: 'GPT models' },
-    { label: 'Vercel AI SDK', value: 'vercel-ai', description: 'Multi-provider SDK' },
     { label: 'Google AI', value: 'google', description: 'Gemini models' },
-    { label: 'Local (Ollama)', value: 'ollama', description: 'Self-hosted models' },
-    { label: 'Multiple providers', value: 'multi', description: 'Mix and match' }
+    { label: 'Cohere', value: 'cohere', description: 'Enterprise NLP' },
+    { label: 'Hugging Face', value: 'huggingface', description: 'Open source models' },
+    { label: 'Local (Ollama)', value: 'ollama', description: 'Self-hosted models' }
   ];
 
-  answers.aiProvider = await askChoice(
+  answers.aiProviders = await askMultiSelect(
     rl,
-    'Primary AI provider:',
+    'AI providers to integrate (select one or more):',
     providerOptions,
-    0
+    ['anthropic']
   );
 
   // AI Features

package/generators/sections/content.js

@@ -0,0 +1,300 @@
+/**
+ * Content Section
+ *
+ * Content strategy, documentation, and publishing planning.
+ *
+ * @package bootspring
+ * @module generators/sections/content
+ */
+
+const title = 'Content & Documentation';
+const description = 'Content strategy and documentation planning';
+
+/**
+ * Run the content section
+ */
+async function run(rl, previousAnswers, helpers) {
+  const { askChoice, askMultiSelect, askText } = helpers;
+  const answers = {};
+
+  // Content Strategy
+  const strategyOptions = [
+    { label: 'Developer-focused', value: 'developer', description: 'Technical docs, tutorials, API refs' },
+    { label: 'Marketing-focused', value: 'marketing', description: 'Landing pages, blog, case studies' },
+    { label: 'Mixed (Dev + Marketing)', value: 'mixed', description: 'Both technical and marketing' },
+    { label: 'Internal only', value: 'internal', description: 'Internal docs and wikis' },
+    { label: 'Minimal', value: 'minimal', description: 'Just README and basics' }
+  ];
+
+  answers.contentStrategy = await askChoice(
+    rl,
+    'Content strategy:',
+    strategyOptions,
+    2
+  );
+
+  // Documentation Types
+  const docTypeOptions = [
+    { label: 'Getting Started guide', value: 'getting-started' },
+    { label: 'API Reference', value: 'api-reference' },
+    { label: 'Tutorials/Guides', value: 'tutorials' },
+    { label: 'Architecture docs', value: 'architecture' },
+    { label: 'Contributing guide', value: 'contributing' },
+    { label: 'Changelog', value: 'changelog' },
+    { label: 'FAQ', value: 'faq' },
+    { label: 'Troubleshooting', value: 'troubleshooting' }
+  ];
+
+  const defaultDocs = {
+    developer: ['getting-started', 'api-reference', 'tutorials', 'contributing', 'changelog'],
+    marketing: ['getting-started', 'faq'],
+    mixed: ['getting-started', 'api-reference', 'tutorials', 'faq', 'changelog'],
+    internal: ['architecture', 'contributing', 'troubleshooting'],
+    minimal: ['getting-started']
+  };
+
+  answers.documentationTypes = await askMultiSelect(
+    rl,
+    'Documentation to generate:',
+    docTypeOptions,
+    defaultDocs[answers.contentStrategy] || defaultDocs.minimal
+  );
+
+  // Blog/Content Publishing
+  const publishingOptions = [
+    { label: 'Yes, blog with regular posts', value: 'blog', description: 'Regular content publishing' },
+    { label: 'Yes, announcements only', value: 'announcements', description: 'Release notes, updates' },
+    { label: 'Yes, technical blog', value: 'technical', description: 'Tutorials, deep dives' },
+    { label: 'No blog planned', value: 'none', description: 'No content publishing' }
+  ];
+
+  answers.contentPublishing = await askChoice(
+    rl,
+    'Content publishing:',
+    publishingOptions,
+    answers.contentStrategy === 'marketing' ? 0 :
+      answers.contentStrategy === 'developer' ? 2 : 3
+  );
+
+  // Content Formats
+  if (answers.contentPublishing !== 'none') {
+    const formatOptions = [
+      { label: 'Blog posts', value: 'blog-posts' },
+      { label: 'Tutorials', value: 'tutorials' },
+      { label: 'Case studies', value: 'case-studies' },
+      { label: 'Video content', value: 'video' },
+      { label: 'Newsletter', value: 'newsletter' },
+      { label: 'Social media', value: 'social' },
+      { label: 'Podcasts', value: 'podcasts' },
+      { label: 'Webinars', value: 'webinars' }
+    ];
+
+    const defaultFormats = {
+      blog: ['blog-posts', 'social', 'newsletter'],
+      announcements: ['blog-posts'],
+      technical: ['tutorials', 'blog-posts', 'video']
+    };
+
+    answers.contentFormats = await askMultiSelect(
+      rl,
+      'Content formats:',
+      formatOptions,
+      defaultFormats[answers.contentPublishing] || []
+    );
+  }
+
+  // SEO Priority
+  const seoOptions = [
+    { label: 'High priority', value: 'high', description: 'Full SEO optimization' },
+    { label: 'Medium priority', value: 'medium', description: 'Basic SEO practices' },
+    { label: 'Low priority', value: 'low', description: 'Minimal SEO focus' },
+    { label: 'Not applicable', value: 'none', description: 'Internal/private content' }
+  ];
+
+  answers.seoPriority = await askChoice(
+    rl,
+    'SEO priority:',
+    seoOptions,
+    answers.contentStrategy === 'marketing' ? 0 : 1
+  );
+
+  // Documentation Platform
+  const platformOptions = [
+    { label: 'Built into app (MDX/Next.js)', value: 'builtin', description: 'Self-hosted docs' },
+    { label: 'Docusaurus', value: 'docusaurus', description: 'React-based docs' },
+    { label: 'GitBook', value: 'gitbook', description: 'Hosted docs platform' },
+    { label: 'ReadMe', value: 'readme', description: 'API docs platform' },
+    { label: 'Notion', value: 'notion', description: 'Wiki-style docs' },
+    { label: 'GitHub Wiki', value: 'github-wiki', description: 'Simple wiki' },
+    { label: 'Custom', value: 'custom', description: 'Build from scratch' }
+  ];
+
+  answers.docsPlatform = await askChoice(
+    rl,
+    'Documentation platform:',
+    platformOptions,
+    0
+  );
+
+  // Writing Style
+  const styleOptions = [
+    { label: 'Technical & precise', value: 'technical', description: 'Developer-focused, detailed' },
+    { label: 'Friendly & approachable', value: 'friendly', description: 'Casual, welcoming' },
+    { label: 'Professional & formal', value: 'professional', description: 'Enterprise, formal' },
+    { label: 'Minimal & concise', value: 'minimal', description: 'Brief, to the point' }
+  ];
+
+  answers.writingStyle = await askChoice(
+    rl,
+    'Writing style:',
+    styleOptions,
+    answers.contentStrategy === 'marketing' ? 1 :
+      answers.contentStrategy === 'internal' ? 2 : 0
+  );
+
+  // Content Templates
+  const templateOptions = [
+    { label: 'README template', value: 'readme' },
+    { label: 'Blog post template', value: 'blog' },
+    { label: 'API endpoint docs', value: 'api-docs' },
+    { label: 'Release notes template', value: 'release-notes' },
+    { label: 'Tutorial template', value: 'tutorial' },
+    { label: 'Landing page copy', value: 'landing' },
+    { label: 'Email templates', value: 'email' },
+    { label: 'Social media templates', value: 'social' }
+  ];
+
+  answers.contentTemplates = await askMultiSelect(
+    rl,
+    'Content templates to generate:',
+    templateOptions,
+    ['readme', 'blog', 'release-notes']
+  );
+
+  // Localization
+  const localizationOptions = [
+    { label: 'English only', value: 'en', description: 'Single language' },
+    { label: 'English + top languages', value: 'multi-top', description: 'EN, ES, FR, DE, ZH' },
+    { label: 'Full i18n', value: 'full', description: 'All major languages' },
+    { label: 'Community translations', value: 'community', description: 'Crowdsourced' }
+  ];
+
+  answers.localization = await askChoice(
+    rl,
+    'Content localization:',
+    localizationOptions,
+    0
+  );
+
+  // Content calendar
+  if (answers.contentPublishing !== 'none') {
+    const calendarOptions = [
+      { label: 'Weekly publishing', value: 'weekly', description: '1+ posts per week' },
+      { label: 'Bi-weekly publishing', value: 'biweekly', description: '2 posts per month' },
+      { label: 'Monthly publishing', value: 'monthly', description: '1 post per month' },
+      { label: 'Release-driven', value: 'release', description: 'Publish with releases' },
+      { label: 'Ad-hoc', value: 'adhoc', description: 'No schedule' }
+    ];
+
+    answers.contentCadence = await askChoice(
+      rl,
+      'Content cadence:',
+      calendarOptions,
+      3
+    );
+  }
+
+  return answers;
+}
+
+/**
+ * Generate content-related CLAUDE.md sections
+ */
+function generateSection(answers) {
+  const sections = [];
+
+  if (answers.contentStrategy && answers.contentStrategy !== 'minimal') {
+    sections.push(`## Content Strategy
+
+- **Strategy**: ${answers.contentStrategy}
+- **Writing Style**: ${answers.writingStyle || 'technical'}
+- **SEO Priority**: ${answers.seoPriority || 'medium'}
+- **Documentation Platform**: ${answers.docsPlatform || 'builtin'}
+- **Localization**: ${answers.localization || 'en'}
+`);
+  }
+
+  if (answers.documentationTypes && answers.documentationTypes.length > 0) {
+    sections.push(`### Documentation Types
+
+${answers.documentationTypes.map(d => `- ${formatDocType(d)}`).join('\n')}
+`);
+  }
+
+  if (answers.contentFormats && answers.contentFormats.length > 0) {
+    sections.push(`### Content Formats
+
+${answers.contentFormats.map(f => `- ${formatContentFormat(f)}`).join('\n')}
+
+**Cadence**: ${answers.contentCadence || 'ad-hoc'}
+`);
+  }
+
+  if (answers.contentTemplates && answers.contentTemplates.length > 0) {
+    sections.push(`### Content Templates
+
+${answers.contentTemplates.map(t => `- ${formatTemplate(t)}`).join('\n')}
+`);
+  }
+
+  return sections.join('\n');
+}
+
+function formatDocType(type) {
+  const labels = {
+    'getting-started': 'Getting Started Guide',
+    'api-reference': 'API Reference',
+    'tutorials': 'Tutorials & Guides',
+    'architecture': 'Architecture Documentation',
+    'contributing': 'Contributing Guide',
+    'changelog': 'Changelog',
+    'faq': 'FAQ',
+    'troubleshooting': 'Troubleshooting Guide'
+  };
+  return labels[type] || type;
+}
+
+function formatContentFormat(format) {
+  const labels = {
+    'blog-posts': 'Blog Posts',
+    'tutorials': 'Tutorial Articles',
+    'case-studies': 'Case Studies',
+    'video': 'Video Content',
+    'newsletter': 'Email Newsletter',
+    'social': 'Social Media',
+    'podcasts': 'Podcast Episodes',
+    'webinars': 'Webinars'
+  };
+  return labels[format] || format;
+}
+
+function formatTemplate(template) {
+  const labels = {
+    'readme': 'README Template',
+    'blog': 'Blog Post Template',
+    'api-docs': 'API Documentation Template',
+    'release-notes': 'Release Notes Template',
+    'tutorial': 'Tutorial Template',
+    'landing': 'Landing Page Copy Template',
+    'email': 'Email Templates',
+    'social': 'Social Media Templates'
+  };
+  return labels[template] || template;
+}
+
+module.exports = {
+  title,
+  description,
+  run,
+  generateSection
+};

package/generators/sections/index.js

@@ -31,6 +31,9 @@ module.exports = {
   'workflow': require('./workflow'),
   'instructions': require('./instructions'),
 
+  // Content & Documentation section
+  'content': require('./content'),
+
   // Legacy sections
   'plugins': require('./plugins'),
   'advanced': require('./advanced')

package/generators/sections/plugins.js

@@ -14,7 +14,7 @@ const description = 'Select the features you need';
  * Run the plugins section
  */
 async function run(rl, previousAnswers, helpers) {
-  const { askYesNo, askChoice } = helpers;
+  const { askYesNo, askChoice, askMultiSelect } = helpers;
 
   const answers = {};
 
@@ -87,16 +87,17 @@ async function run(rl, previousAnswers, helpers) {
   );
 
   if (answers.enableAI) {
-    answers.aiProvider = await askChoice(
+    answers.aiProviders = await askMultiSelect(
       rl,
-      'AI provider:',
+      'AI providers (select one or more):',
       [
         { label: 'Anthropic (Claude)', value: 'anthropic', description: 'Claude API' },
         { label: 'OpenAI', value: 'openai', description: 'GPT models' },
-        { label: 'Vercel AI SDK', value: 'vercel-ai', description: 'Multi-provider' },
-        { label: 'Multiple', value: 'multiple', description: 'Use multiple providers' }
+        { label: 'Google AI', value: 'google', description: 'Gemini models' },
+        { label: 'Cohere', value: 'cohere', description: 'Enterprise NLP' },
+        { label: 'Hugging Face', value: 'huggingface', description: 'Open source models' }
       ],
-      0
+      ['anthropic']
     );
 
     answers.aiFeatures = [];