@girardmedia/bootspring 1.2.0 → 2.0.3

package/mcp/tools/content-tool.js

@@ -0,0 +1,571 @@
+/**
+ * MCP Content Generation Tool
+ *
+ * Provides AI-assisted content generation via MCP:
+ * - Generate business and legal documents
+ * - Get AI enhancement prompts
+ * - Validate generated content
+ * - Track generation statistics
+ *
+ * @package bootspring
+ * @module mcp/tools/content-tool
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_content',
+    description: 'Generate business and legal documents with AI assistance. Creates privacy policies, terms of service, READMEs, changelogs, API docs, business plans, and more using project context.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'generate', 'preview', 'enhance', 'validate', 'stats', 'batch'],
+          description: 'Action to perform: list (show templates), generate (create document), preview (show without saving), enhance (get AI prompts), validate (check content), stats (generation statistics), batch (generate multiple)'
+        },
+        template: {
+          type: 'string',
+          description: 'Template key (e.g., privacy-policy, terms-of-service, readme, changelog, api-documentation, business-plan)'
+        },
+        category: {
+          type: 'string',
+          enum: ['legal', 'documentation', 'business', 'fundraising', 'security'],
+          description: 'Filter templates by category (for list action) or generate all in category (for batch action)'
+        },
+        section: {
+          type: 'string',
+          description: 'Specific section to enhance (for enhance action)'
+        },
+        outputDir: {
+          type: 'string',
+          description: 'Output directory for generated files (default: docs/)'
+        },
+        filename: {
+          type: 'string',
+          description: 'Custom filename for generated document'
+        },
+        options: {
+          type: 'object',
+          description: 'Customization options (domain, jurisdiction, address, etc.)',
+          properties: {
+            domain: { type: 'string' },
+            jurisdiction: { type: 'string' },
+            address: { type: 'string' },
+            country: { type: 'string' }
+          }
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ contentGen, config, format }) {
+  return async (args) => {
+    const { action, template, category, section, outputDir, filename, options } = args;
+    const cfg = config.load();
+    const projectRoot = cfg._projectRoot;
+
+    try {
+      switch (action) {
+        case 'list':
+          return handleList(contentGen, category, format);
+
+        case 'generate':
+          return handleGenerate(contentGen, template, { outputDir, filename, ...options }, format);
+
+        case 'preview':
+          return handlePreview(contentGen, template, options, format);
+
+        case 'enhance':
+          return handleEnhance(contentGen, template, section, format);
+
+        case 'validate':
+          return handleValidate(contentGen, template, projectRoot, format);
+
+        case 'stats':
+          return handleStats(contentGen, format);
+
+        case 'batch':
+          return handleBatch(contentGen, category, { outputDir, ...options }, format);
+
+        default:
+          return format.error(`Unknown action: ${action}`, [
+            'Valid actions: list, generate, preview, enhance, validate, stats, batch'
+          ]);
+      }
+    } catch (error) {
+      return format.error(`Content generation failed: ${error.message}`);
+    }
+  };
+}
+
+/**
+ * List available templates
+ */
+function handleList(contentGen, category, _format) {
+  const templates = contentGen.listTemplates({ category });
+  const categories = contentGen.getCategories();
+
+  if (templates.length === 0) {
+    return {
+      content: [{
+        type: 'text',
+        text: `## Document Templates
+
+No templates found${category ? ` in category "${category}"` : ''}.
+
+**Available Categories:** ${categories.join(', ')}
+
+Use: \`bootspring_content\` action: "list" category: "legal"`
+      }]
+    };
+  }
+
+  // Group by category
+  const grouped = {};
+  for (const t of templates) {
+    if (!grouped[t.category]) {
+      grouped[t.category] = [];
+    }
+    grouped[t.category].push(t);
+  }
+
+  const sections = ['## Document Templates\n'];
+
+  for (const [cat, tmpls] of Object.entries(grouped)) {
+    sections.push(`### ${cat.charAt(0).toUpperCase() + cat.slice(1)}\n`);
+
+    for (const t of tmpls) {
+      const compliance = t.compliance.length > 0 ? ` [${t.compliance.join(', ')}]` : '';
+      const hasFile = t.hasTemplateFile ? ' (template file)' : '';
+      sections.push(`- **${t.key}** - ${t.description}${compliance}${hasFile}`);
+    }
+    sections.push('');
+  }
+
+  sections.push(`**Total:** ${templates.length} templates across ${Object.keys(grouped).length} categories`);
+  sections.push('');
+  sections.push('**Commands:**');
+  sections.push('- Generate: `bootspring_content` action: "generate" template: "privacy-policy"');
+  sections.push('- Preview: `bootspring_content` action: "preview" template: "readme"');
+  sections.push('- AI Help: `bootspring_content` action: "enhance" template: "business-plan"');
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Generate a document
+ */
+function handleGenerate(contentGen, template, options, format) {
+  if (!template) {
+    return format.error('Template required', [
+      'Use template parameter to specify which document to generate',
+      'Run action: "list" to see available templates'
+    ]);
+  }
+
+  const templateInfo = contentGen.getTemplate(template);
+  if (!templateInfo) {
+    const available = contentGen.listTemplates().map(t => t.key).join(', ');
+    return format.error(`Unknown template: ${template}`, [
+      `Available templates: ${available}`
+    ]);
+  }
+
+  const result = contentGen.generateDocument(template, {
+    save: true,
+    outputDir: options.outputDir,
+    filename: options.filename,
+    context: options
+  });
+
+  if (!result.success) {
+    return format.error(`Generation failed: ${result.error}`);
+  }
+
+  const validationSummary = result.validation.valid
+    ? 'Content validation passed'
+    : `Validation found ${result.validation.issues.length} issue(s)`;
+
+  const issues = result.validation.issues
+    .filter(i => i.severity === 'error' || i.severity === 'warning')
+    .map(i => `  - [${i.severity}] ${i.message}`)
+    .join('\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Document Generated
+
+**Template:** ${templateInfo.name}
+**Category:** ${templateInfo.category}
+**File:** ${result.outputPath}
+**Sections:** ${result.sections}
+
+### Validation
+
+${validationSummary}
+${issues ? `\n${issues}\n` : ''}
+**Score:** ${result.validation.score}/100
+
+### Next Steps
+
+1. Review the generated document at \`${result.outputPath}\`
+2. Use \`bootspring_content\` action: "enhance" template: "${template}" to get AI improvement prompts
+3. Customize placeholders marked with \`[...]\`
+
+${templateInfo.compliance?.length > 0 ? `\n**Compliance Notes:** This template includes ${templateInfo.compliance.join(', ')} provisions. Please review with legal counsel.` : ''}`
+    }]
+  };
+}
+
+/**
+ * Preview document without saving
+ */
+function handlePreview(contentGen, template, options, format) {
+  if (!template) {
+    return format.error('Template required', [
+      'Use template parameter to specify which document to preview'
+    ]);
+  }
+
+  const templateInfo = contentGen.getTemplate(template);
+  if (!templateInfo) {
+    return format.error(`Unknown template: ${template}`, [
+      'Run action: "list" to see available templates'
+    ]);
+  }
+
+  const result = contentGen.generateDocument(template, {
+    save: false,
+    context: options
+  });
+
+  if (!result.success) {
+    return format.error(`Preview failed: ${result.error}`);
+  }
+
+  // Truncate long content for preview
+  const maxLength = 4000;
+  const truncated = result.content.length > maxLength;
+  const previewContent = truncated
+    ? result.content.slice(0, maxLength) + '\n\n... [Truncated for preview]'
+    : result.content;
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Preview: ${templateInfo.name}
+
+**Sections:** ${result.sections}
+**Length:** ${result.content.length} characters
+**Validation Score:** ${result.validation.score}/100
+
+---
+
+${previewContent}
+
+---
+
+${truncated ? '\n*Content truncated. Generate to see full document.*\n' : ''}
+**Commands:**
+- Save: \`bootspring_content\` action: "generate" template: "${template}"
+- AI Help: \`bootspring_content\` action: "enhance" template: "${template}"`
+    }]
+  };
+}
+
+/**
+ * Get AI enhancement prompts
+ */
+function handleEnhance(contentGen, template, section, format) {
+  if (!template) {
+    return format.error('Template required', [
+      'Use template parameter to specify which document to enhance'
+    ]);
+  }
+
+  const templateInfo = contentGen.getTemplate(template);
+  if (!templateInfo) {
+    return format.error(`Unknown template: ${template}`, [
+      'Run action: "list" to see available templates'
+    ]);
+  }
+
+  if (section) {
+    // Get specific section prompt
+    const result = contentGen.getEnhancementPrompt(template, section);
+
+    if (!result.success) {
+      return format.error(result.error);
+    }
+
+    return {
+      content: [{
+        type: 'text',
+        text: `## AI Enhancement Prompt
+
+**Template:** ${templateInfo.name}
+**Section:** ${section}
+**Generic:** ${result.generic ? 'Yes (no specific prompt defined)' : 'No'}
+
+### Prompt for AI
+
+\`\`\`
+${result.prompt}
+\`\`\`
+
+### Project Context Used
+
+| Key | Value |
+|-----|-------|
+| Project Name | ${result.context.projectName} |
+| Framework | ${result.context.framework} |
+| Language | ${result.context.language} |
+| Database | ${result.context.database || 'N/A'} |
+| Hosting | ${result.context.hosting || 'N/A'} |
+
+**Tip:** Copy this prompt and use it with your AI assistant to generate enhanced content for this section.`
+      }]
+    };
+  }
+
+  // Get all section prompts
+  const result = contentGen.getAllEnhancementPrompts(template);
+
+  if (!result.success) {
+    return format.error(result.error);
+  }
+
+  const sections = result.prompts.map(p => {
+    const status = p.generic ? '(generic)' : '(custom)';
+    return `- **${p.title}** ${status}`;
+  }).join('\n');
+
+  // Get the full document prompt
+  const fullPrompt = contentGen.getEnhancementPrompt(template);
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## AI Enhancement Prompts
+
+**Template:** ${result.templateName}
+**Total Sections:** ${result.prompts.length}
+
+### Available Section Prompts
+
+${sections}
+
+### Full Document Prompt
+
+Use this prompt to generate the entire document with AI:
+
+\`\`\`
+${fullPrompt.prompt.slice(0, 2000)}${fullPrompt.prompt.length > 2000 ? '...' : ''}
+\`\`\`
+
+### Commands
+
+- Get specific section: \`bootspring_content\` action: "enhance" template: "${template}" section: "executive-summary"
+- Preview generated: \`bootspring_content\` action: "preview" template: "${template}"
+
+**Tip:** Use these prompts with Claude or other AI assistants to create customized, high-quality content.`
+    }]
+  };
+}
+
+/**
+ * Validate content
+ */
+function handleValidate(contentGen, template, projectRoot, format) {
+  const fs = require('fs');
+  const path = require('path');
+
+  if (!template) {
+    return format.error('Template required for validation', [
+      'Specify which template type to validate against'
+    ]);
+  }
+
+  const templateInfo = contentGen.getTemplate(template);
+  if (!templateInfo) {
+    return format.error(`Unknown template: ${template}`);
+  }
+
+  // Try to find existing document
+  const possiblePaths = [
+    path.join(projectRoot, 'docs', `${template}.md`),
+    path.join(projectRoot, `${template.toUpperCase()}.md`),
+    path.join(projectRoot, `${template}.md`)
+  ];
+
+  let content = null;
+  let foundPath = null;
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      content = fs.readFileSync(p, 'utf8');
+      foundPath = p;
+      break;
+    }
+  }
+
+  if (!content) {
+    return format.warning(`No existing ${template} document found`, [
+      `Expected locations: ${possiblePaths.join(', ')}`,
+      `Generate one: bootspring_content action: "generate" template: "${template}"`
+    ]);
+  }
+
+  const validation = contentGen.validateContent(content, template);
+
+  const issuesList = validation.issues
+    .map(i => `- [${i.severity.toUpperCase()}] ${i.message}`)
+    .join('\n');
+
+  const statusIcon = validation.valid ? '  ' : '  ';
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Content Validation
+
+${statusIcon} **Status:** ${validation.valid ? 'Valid' : 'Issues Found'}
+**File:** ${foundPath}
+**Template:** ${templateInfo.name}
+**Score:** ${validation.score}/100
+
+### Issues (${validation.issues.length})
+
+${issuesList || 'No issues found.'}
+
+### Recommendations
+
+${validation.valid
+    ? '- Document passes basic validation\n- Consider using AI enhancement for improvements\n- Have legal counsel review before publishing'
+    : '- Address the issues listed above\n- Use `bootspring_content action: "enhance"` for improvement prompts\n- Regenerate if needed'
+}`
+    }]
+  };
+}
+
+/**
+ * Show generation statistics
+ */
+function handleStats(contentGen, _format) {
+  const stats = contentGen.getStatistics();
+
+  const categoryStats = Object.entries(stats.byCategory)
+    .map(([cat, count]) => `| ${cat} | ${count} |`)
+    .join('\n');
+
+  const templateStats = Object.entries(stats.byTemplate)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([tmpl, count]) => `| ${tmpl} | ${count} |`)
+    .join('\n');
+
+  const recentDocs = stats.recentDocuments
+    .slice(-5)
+    .reverse()
+    .map(d => `- ${d.template} (${d.generatedAt.split('T')[0]})`)
+    .join('\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Content Generation Statistics
+
+**Total Documents Generated:** ${stats.totalGenerated}
+**Last Generation:** ${stats.lastGeneration || 'Never'}
+
+### By Category
+
+| Category | Count |
+|----------|-------|
+${categoryStats || '| - | - |'}
+
+### Top Templates
+
+| Template | Count |
+|----------|-------|
+${templateStats || '| - | - |'}
+
+### Recent Documents
+
+${recentDocs || 'No documents generated yet.'}
+
+### Commands
+
+- Generate: \`bootspring_content\` action: "generate" template: "privacy-policy"
+- List templates: \`bootspring_content\` action: "list"
+- Batch generate: \`bootspring_content\` action: "batch" category: "legal"`
+    }]
+  };
+}
+
+/**
+ * Batch generate documents by category
+ */
+function handleBatch(contentGen, category, options, format) {
+  if (!category) {
+    return format.error('Category required for batch generation', [
+      'Specify which category of documents to generate',
+      'Available: legal, documentation, business, fundraising, security'
+    ]);
+  }
+
+  const templates = contentGen.listTemplates({ category });
+
+  if (templates.length === 0) {
+    return format.error(`No templates found in category: ${category}`, [
+      'Available categories: legal, documentation, business, fundraising, security'
+    ]);
+  }
+
+  const result = contentGen.generateByCategory(category, {
+    outputDir: options.outputDir,
+    context: options
+  });
+
+  const resultsList = result.results
+    .map(r => {
+      const icon = r.success ? '  ' : '  ';
+      return `${icon} ${r.template}: ${r.success ? r.outputPath : r.error}`;
+    })
+    .join('\n');
+
+  return {
+    content: [{
+      type: 'text',
+      text: `## Batch Generation Complete
+
+**Category:** ${category}
+**Generated:** ${result.generated}/${templates.length}
+**Failed:** ${result.failed}
+
+### Results
+
+${resultsList}
+
+### Next Steps
+
+1. Review generated documents in your output directory
+2. Use \`bootspring_content\` action: "enhance" for AI improvement prompts
+3. Customize placeholders and project-specific details
+4. Have appropriate experts review (legal for legal docs, etc.)`
+    }]
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};