@girardmedia/bootspring 2.0.21 → 2.0.22

package/src/cli/content.ts

@@ -0,0 +1,273 @@
+/**
+ * Bootspring Content Command
+ * Generate and manage content (blogs, docs, release notes, etc.)
+ *
+ * @package bootspring
+ * @command content
+ */
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Type interfaces for JS modules
+interface Colors {
+  reset: string;
+  bold: string;
+  dim: string;
+  cyan: string;
+  green: string;
+  yellow: string;
+  red: string;
+}
+
+interface PrintModule {
+  error(msg: string): void;
+  dim(msg: string): void;
+}
+
+interface UtilsModule {
+  COLORS: Colors;
+  print: PrintModule;
+  parseArgs(args: string[]): ParsedArgs;
+  createSpinner(text: string): Spinner;
+  fileExists(path: string): boolean;
+  writeFile(path: string, content: string): void;
+}
+
+interface ParsedArgs {
+  _: string[];
+  title?: string | undefined;
+  t?: string | undefined;
+  description?: string | undefined;
+  d?: string | undefined;
+  author?: string | undefined;
+  a?: string | undefined;
+  version?: string | undefined;
+  v?: string | undefined;
+  tags?: string | undefined;
+  name?: string | undefined;
+  n?: string | undefined;
+  date?: string | undefined;
+  output?: string | undefined;
+  o?: string | undefined;
+}
+
+interface Spinner {
+  start(): Spinner;
+  stop(): void;
+  succeed(text: string): void;
+  fail(text: string): void;
+}
+
+interface ContentType {
+  name: string;
+  extension: string;
+  directory: string;
+}
+
+interface ContentOptions {
+  title: string;
+  description: string;
+  author: string;
+  version: string;
+  tags: string[];
+  name: string;
+  date: string;
+}
+
+interface ContentTemplateModule {
+  CONTENT_TYPES: Record<string, ContentType>;
+  getContentType(type: string): ContentType | null;
+  generate(type: string, options: ContentOptions): string;
+  listContentTypes(): Record<string, ContentType>;
+}
+
+const utils = require('../core/utils') as UtilsModule;
+const contentTemplate = require('../generators/templates/content.template') as ContentTemplateModule;
+
+/**
+ * Generate content file
+ */
+function generateContent(type: string, args: string[]): void {
+  const contentType = contentTemplate.getContentType(type);
+
+  if (!contentType) {
+    utils.print.error(`Unknown content type: ${type}`);
+    utils.print.dim('Available types: ' + Object.keys(contentTemplate.CONTENT_TYPES).join(', '));
+    return;
+  }
+
+  const parsedArgs = utils.parseArgs(args);
+
+  // Build options from args
+  const options: ContentOptions = {
+    title: parsedArgs.title || parsedArgs.t || '',
+    description: parsedArgs.description || parsedArgs.d || '',
+    author: parsedArgs.author || parsedArgs.a || 'Team',
+    version: parsedArgs.version || parsedArgs.v || '1.0.0',
+    tags: parsedArgs.tags ? parsedArgs.tags.split(',').map(t => t.trim()) : [],
+    name: parsedArgs.name || parsedArgs.n || '',
+    date: parsedArgs.date || new Date().toISOString().split('T')[0] || ''
+  };
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Content${utils.COLORS.reset}
+${utils.COLORS.dim}Generating ${contentType.name}...${utils.COLORS.reset}
+`);
+
+  const spinner = utils.createSpinner(`Creating ${contentType.name}`).start();
+
+  try {
+    const content = contentTemplate.generate(type, options);
+
+    // Determine output path
+    const filename = options.title
+      ? options.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '')
+      : type;
+
+    const outputDir = parsedArgs.output || parsedArgs.o || contentType.directory;
+    const outputPath = path.join(process.cwd(), outputDir, `${filename}${contentType.extension}`);
+
+    // Create directory if needed
+    const dir = path.dirname(outputPath);
+    if (!utils.fileExists(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    utils.writeFile(outputPath, content);
+    spinner.succeed(`Created ${contentType.name}`);
+
+    console.log(`
+${utils.COLORS.bold}File created:${utils.COLORS.reset} ${outputPath}
+
+${utils.COLORS.dim}Next steps:${utils.COLORS.reset}
+  1. Edit the generated file with your content
+  2. Run ${utils.COLORS.cyan}bootspring agent invoke content-expert${utils.COLORS.reset} for writing help
+  3. Publish when ready
+`);
+
+  } catch (error) {
+    spinner.fail(`Failed to create ${contentType.name}: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * List available content types
+ */
+function listTypes(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Content Types${utils.COLORS.reset}
+${utils.COLORS.dim}Generate any content type with a single command${utils.COLORS.reset}
+`);
+
+  const types = contentTemplate.listContentTypes();
+
+  for (const [id, type] of Object.entries(types)) {
+    console.log(`  ${utils.COLORS.cyan}${id}${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}${type.name} (${type.extension})${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}Directory: ${type.directory}${utils.COLORS.reset}`);
+    console.log();
+  }
+
+  utils.print.dim(`${Object.keys(types).length} content types available`);
+  utils.print.dim('Use "bootspring content new <type> --title \'Title\'" to generate');
+}
+
+/**
+ * Show content help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Content${utils.COLORS.reset}
+${utils.COLORS.dim}Generate and manage content for your project${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring content <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}new${utils.COLORS.reset} <type>          Generate new content from template
+  ${utils.COLORS.cyan}types${utils.COLORS.reset}              List available content types
+  ${utils.COLORS.cyan}help${utils.COLORS.reset}               Show this help
+
+${utils.COLORS.bold}Content Types:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}blog-post${utils.COLORS.reset}          Blog article template
+  ${utils.COLORS.cyan}release-notes${utils.COLORS.reset}      Version release notes
+  ${utils.COLORS.cyan}documentation${utils.COLORS.reset}      Documentation page (MDX)
+  ${utils.COLORS.cyan}changelog${utils.COLORS.reset}          Changelog entry
+  ${utils.COLORS.cyan}readme${utils.COLORS.reset}             README file
+  ${utils.COLORS.cyan}api-doc${utils.COLORS.reset}            API endpoint documentation
+  ${utils.COLORS.cyan}tutorial${utils.COLORS.reset}           Step-by-step tutorial
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}--title, -t${utils.COLORS.reset}        Content title
+  ${utils.COLORS.cyan}--description, -d${utils.COLORS.reset}  Brief description
+  ${utils.COLORS.cyan}--author, -a${utils.COLORS.reset}       Author name
+  ${utils.COLORS.cyan}--tags${utils.COLORS.reset}             Comma-separated tags
+  ${utils.COLORS.cyan}--version, -v${utils.COLORS.reset}      Version number (for releases)
+  ${utils.COLORS.cyan}--output, -o${utils.COLORS.reset}       Output directory
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  ${utils.COLORS.dim}# Create a blog post${utils.COLORS.reset}
+  bootspring content new blog-post --title "Getting Started with Bootspring"
+
+  ${utils.COLORS.dim}# Generate release notes${utils.COLORS.reset}
+  bootspring content new release-notes --version 1.2.0
+
+  ${utils.COLORS.dim}# Create API documentation${utils.COLORS.reset}
+  bootspring content new api-doc --title "Create User"
+
+  ${utils.COLORS.dim}# Generate a tutorial${utils.COLORS.reset}
+  bootspring content new tutorial --title "Building Your First App"
+
+${utils.COLORS.bold}Workflow:${utils.COLORS.reset}
+  1. Generate content: ${utils.COLORS.cyan}bootspring content new blog-post --title "My Post"${utils.COLORS.reset}
+  2. Get writing help: ${utils.COLORS.cyan}bootspring agent invoke content-expert${utils.COLORS.reset}
+  3. Publish when ready
+`);
+}
+
+/**
+ * Run content command
+ */
+export async function run(args: string[]): Promise<void> {
+  const subcommand = args[0] || 'help';
+  const subargs = args.slice(1);
+
+  switch (subcommand) {
+    case 'new':
+    case 'create':
+    case 'generate':
+    case 'gen':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a content type');
+        utils.print.dim('Usage: bootspring content new <type> [options]');
+        utils.print.dim('Run "bootspring content types" to see available types');
+        return;
+      }
+      generateContent(subargs[0], subargs.slice(1));
+      break;
+
+    case 'types':
+    case 'list':
+    case 'ls':
+      listTypes();
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Check if it's a content type shortcut
+      if (contentTemplate.getContentType(subcommand)) {
+        generateContent(subcommand, subargs);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}
+
+export { generateContent, listTypes };