@edtools/cli 0.7.0 → 0.7.1

package/dist/chunk-OVFZRN7O.js

@@ -0,0 +1,850 @@
+import {
+  calculateReadTime,
+  calculateWordCount,
+  extractShortDescription,
+  generateTimestamp,
+  generateUUID
+} from "./chunk-INVECVSW.js";
+
+// src/types/adapter.ts
+var AdapterRegistry = class {
+  adapters;
+  constructor() {
+    this.adapters = /* @__PURE__ */ new Map();
+  }
+  register(adapter) {
+    this.adapters.set(adapter.name, adapter);
+  }
+  get(name) {
+    return this.adapters.get(name);
+  }
+  async detectAdapter(projectPath) {
+    for (const adapter of this.adapters.values()) {
+      if (await adapter.detect(projectPath)) {
+        return adapter;
+      }
+    }
+    return null;
+  }
+  list() {
+    return Array.from(this.adapters.keys());
+  }
+};
+
+// src/adapters/html/index.ts
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import ejs from "ejs";
+import { marked } from "marked";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var HTMLAdapter = class {
+  name = "html";
+  async detect(projectPath) {
+    try {
+      const files = await fs.readdir(projectPath);
+      const hasHtmlInRoot = files.some((f) => f.endsWith(".html"));
+      const hasIndexHtml = await fs.pathExists(path.join(projectPath, "index.html"));
+      const commonDirs = ["public", "dist", "build", "src"];
+      for (const dir of commonDirs) {
+        const dirPath = path.join(projectPath, dir);
+        if (await fs.pathExists(dirPath)) {
+          const dirFiles = await fs.readdir(dirPath);
+          const hasHtmlInDir = dirFiles.some((f) => f.endsWith(".html"));
+          if (hasHtmlInDir) {
+            return true;
+          }
+        }
+      }
+      return hasHtmlInRoot || hasIndexHtml;
+    } catch (error) {
+      return false;
+    }
+  }
+  async render(content, data) {
+    const possiblePaths = [
+      path.join(__dirname, "templates", "blog-post-enhanced.ejs"),
+      path.join(__dirname, "../../../src/adapters/html/templates/blog-post-enhanced.ejs"),
+      path.join(path.dirname(fileURLToPath(import.meta.url)), "templates/blog-post-enhanced.ejs"),
+      path.join(path.dirname(fileURLToPath(import.meta.url)), "../html/templates/blog-post-enhanced.ejs")
+    ];
+    let templatePath = null;
+    let templateDir = null;
+    for (const p of possiblePaths) {
+      if (await fs.pathExists(p)) {
+        templatePath = p;
+        templateDir = path.dirname(p);
+        break;
+      }
+    }
+    if (!templatePath || !templateDir) {
+      throw new Error(`Template not found. Tried paths:
+${possiblePaths.join("\n")}`);
+    }
+    const template = await fs.readFile(templatePath, "utf-8");
+    const blogConfig = data?.blogConfig || {
+      name: content.metadata.author || "Blog",
+      description: "",
+      language: "es",
+      websiteUrl: "",
+      navigation: [],
+      primaryColor: "#2563eb",
+      textColor: "#1f2937",
+      textLight: "#6b7280",
+      borderColor: "#e5e7eb",
+      bgLight: "#f9fafb",
+      allowAICrawlers: true
+    };
+    const templateData = {
+      metadata: content.metadata,
+      schemaOrg: JSON.stringify(content.schemaOrg, null, 2),
+      intro: await this.markdownToHTML(content.content.intro),
+      sections: await Promise.all(
+        content.content.sections.map(async (section) => ({
+          ...section,
+          content: await this.renderSectionContent(section)
+        }))
+      ),
+      conclusion: await this.markdownToHTML(content.content.conclusion),
+      cta: content.content.cta,
+      relatedPosts: content.relatedPosts || [],
+      seoScore: content.seo.score,
+      // New data
+      blogConfig,
+      tableOfContents: data?.tableOfContents || [],
+      prevPost: data?.prevPost,
+      nextPost: data?.nextPost
+    };
+    const html = ejs.render(template, templateData, {
+      filename: templatePath,
+      // Required for includes to resolve correctly
+      root: templateDir
+      // Root directory for include resolution
+    });
+    return html;
+  }
+  async write(output, outputPath) {
+    await fs.ensureDir(path.dirname(outputPath));
+    await fs.writeFile(outputPath, output, "utf-8");
+  }
+  getFileExtension() {
+    return ".html";
+  }
+  transformPath(basePath) {
+    if (!basePath.endsWith(".html")) {
+      return basePath + ".html";
+    }
+    return basePath;
+  }
+  /**
+   * Convert markdown to HTML
+   */
+  async markdownToHTML(markdown) {
+    return marked(markdown);
+  }
+  /**
+   * Render section content based on type
+   */
+  async renderSectionContent(section) {
+    switch (section.type) {
+      case "text":
+        return await this.markdownToHTML(section.content);
+      case "comparison":
+        return this.renderComparisonTable(section.data);
+      case "list":
+        return this.renderList(section.data);
+      case "code":
+        return this.renderCode(section.data);
+      default:
+        return await this.markdownToHTML(section.content);
+    }
+  }
+  /**
+   * Render comparison table
+   */
+  renderComparisonTable(data) {
+    if (!data || !data.headers || !data.rows) {
+      return "";
+    }
+    let html = '<table class="comparison-table">\n';
+    html += "  <thead>\n    <tr>\n";
+    data.headers.forEach((header) => {
+      html += `      <th>${header}</th>
+`;
+    });
+    html += "    </tr>\n  </thead>\n";
+    html += "  <tbody>\n";
+    data.rows.forEach((row) => {
+      html += "    <tr>\n";
+      row.forEach((cell) => {
+        html += `      <td>${cell}</td>
+`;
+      });
+      html += "    </tr>\n";
+    });
+    html += "  </tbody>\n";
+    html += "</table>";
+    return html;
+  }
+  /**
+   * Render list
+   */
+  renderList(data) {
+    if (!data || !data.items) {
+      return "";
+    }
+    const tag = data.ordered ? "ol" : "ul";
+    let html = `<${tag} class="content-list">
+`;
+    data.items.forEach((item) => {
+      html += "  <li>\n";
+      html += `    <strong>${item.title}</strong>
+`;
+      if (item.description) {
+        html += `    <p>${item.description}</p>
+`;
+      }
+      html += "  </li>\n";
+    });
+    html += `</${tag}>`;
+    return html;
+  }
+  /**
+   * Render code block
+   */
+  renderCode(data) {
+    if (!data || !data.code) {
+      return "";
+    }
+    let html = '<div class="code-block">\n';
+    if (data.caption) {
+      html += `  <div class="code-caption">${data.caption}</div>
+`;
+    }
+    html += `  <pre><code class="language-${data.language || "plaintext"}">${this.escapeHtml(data.code)}</code></pre>
+`;
+    html += "</div>";
+    return html;
+  }
+  /**
+   * Escape HTML entities
+   */
+  escapeHtml(text) {
+    const map = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#039;"
+    };
+    return text.replace(/[&<>"']/g, (m) => map[m]);
+  }
+};
+
+// src/core/generator.ts
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs2 from "fs-extra";
+import slugify from "slugify";
+var ContentGenerator = class {
+  anthropic = null;
+  openai = null;
+  provider;
+  adapters;
+  constructor(apiKey, provider = "anthropic") {
+    this.provider = provider;
+    if (provider === "anthropic") {
+      this.anthropic = new Anthropic({
+        apiKey: apiKey || process.env.ANTHROPIC_API_KEY || ""
+      });
+    } else if (provider === "openai") {
+      this.openai = new OpenAI({
+        apiKey: apiKey || process.env.OPENAI_API_KEY || ""
+      });
+    }
+    this.adapters = new AdapterRegistry();
+    this.adapters.register(new HTMLAdapter());
+  }
+  /**
+   * Main generate method
+   */
+  async generate(config) {
+    const results = {
+      success: true,
+      posts: [],
+      warnings: [],
+      errors: [],
+      dryRun: config.dryRun
+    };
+    const allPostsContent = [];
+    const { calculateAvgReadTime } = await import("./content-helpers-TXVEJMQK.js");
+    try {
+      const adapter = await this.adapters.detectAdapter(config.projectPath);
+      if (!adapter) {
+        throw new Error("No suitable adapter found for this project");
+      }
+      console.log(`\u2713 Using adapter: ${adapter.name}`);
+      const topics = config.topics || await this.generateTopics(config.productInfo, config.count || 3);
+      const blogConfig = config.blogConfig || {
+        name: `${config.productInfo.name} Blog`,
+        description: config.productInfo.description,
+        language: "en",
+        websiteUrl: config.productInfo.websiteUrl,
+        navigation: [
+          { label: "Home", url: config.productInfo.websiteUrl || "/" },
+          { label: "Blog", url: `${config.productInfo.websiteUrl}/blog/`, active: true }
+        ],
+        primaryColor: "#2563eb",
+        textColor: "#1f2937",
+        textLight: "#6b7280",
+        borderColor: "#e5e7eb",
+        bgLight: "#f9fafb",
+        allowAICrawlers: true
+      };
+      for (const topic of topics.slice(0, config.count || 3)) {
+        try {
+          console.log(`
+\u{1F4DD} Generating: ${topic}`);
+          const content = await this.generateContent(config.productInfo, topic);
+          const tableOfContents = this.generateTableOfContents(content);
+          const relatedPosts = await this.generateRelatedPosts(content, config.outputDir);
+          const navigation = await this.generateNavigationData(content, config.outputDir);
+          content.relatedPosts = relatedPosts;
+          const output = await adapter.render(content, {
+            blogConfig,
+            tableOfContents,
+            prevPost: navigation.prevPost,
+            nextPost: navigation.nextPost
+          });
+          const slug = content.metadata.slug;
+          const fileName = adapter.transformPath?.(slug) || `${slug}/index${adapter.getFileExtension()}`;
+          const outputPath = path2.join(config.outputDir, fileName);
+          if (!config.dryRun) {
+            await adapter.write(output, outputPath);
+          }
+          allPostsContent.push(content);
+          results.posts.push({
+            id: content.metadata.id,
+            title: content.metadata.title,
+            slug,
+            path: outputPath,
+            url: content.metadata.url,
+            seoScore: content.seo.score,
+            readTime: content.metadata.readTime,
+            wordCount: content.metadata.wordCount,
+            tags: content.metadata.tags,
+            keywords: content.metadata.keywords,
+            datePublished: content.metadata.datePublished,
+            seoIssues: content.seo.suggestions
+          });
+          if (!config.dryRun) {
+            console.log(`\u2713 Generated: ${outputPath}`);
+          } else {
+            console.log(`\u2713 Would generate: ${outputPath}`);
+          }
+          console.log(`  SEO Score: ${content.seo.score}/100`);
+        } catch (error) {
+          results.errors?.push(`Failed to generate "${topic}": ${error.message}`);
+          results.success = false;
+        }
+      }
+      if (results.posts.length > 0 && allPostsContent.length > 0) {
+        results.manifestPath = path2.join(config.outputDir, "index.json");
+        results.sitemapPath = path2.join(config.outputDir, "sitemap.xml");
+        if (!config.dryRun) {
+          await this.generateManifest(config.outputDir, config.productInfo, allPostsContent);
+          await this.generateBlogIndex(config.outputDir, config.productInfo, blogConfig);
+          await this.updateSitemap(config.outputDir, config.productInfo, allPostsContent);
+        }
+        const totalWords = allPostsContent.reduce((sum, post) => sum + post.metadata.wordCount, 0);
+        const avgSeoScore = results.posts.reduce((sum, p) => sum + p.seoScore, 0) / results.posts.length;
+        const wordCounts = allPostsContent.map((post) => post.metadata.wordCount);
+        const avgReadTime = calculateAvgReadTime(wordCounts);
+        results.stats = {
+          avgSeoScore: Math.round(avgSeoScore * 10) / 10,
+          totalWords,
+          avgReadTime
+        };
+      }
+    } catch (error) {
+      results.success = false;
+      results.errors?.push(error.message);
+    }
+    return results;
+  }
+  /**
+   * Generate blog post content using the selected AI provider
+   */
+  async generateContent(productInfo, topic) {
+    const prompt = this.buildPrompt(productInfo, topic);
+    let contentData;
+    if (this.provider === "anthropic") {
+      contentData = await this.generateWithAnthropic(prompt);
+    } else if (this.provider === "openai") {
+      contentData = await this.generateWithOpenAI(prompt);
+    } else {
+      throw new Error(`Unsupported provider: ${this.provider}`);
+    }
+    const id = generateUUID();
+    const slug = slugify(contentData.metadata.title, { lower: true, strict: true });
+    const datePublished = generateTimestamp();
+    const baseUrl = productInfo.websiteUrl.replace(/\/$/, "");
+    const url = `${baseUrl}/blog/${slug}.html`;
+    const fullContent = [
+      contentData.content.intro,
+      ...contentData.content.sections.map((s) => s.content),
+      contentData.content.conclusion
+    ].join(" ");
+    const wordCount = calculateWordCount(fullContent);
+    const readTime = calculateReadTime(wordCount);
+    const shortDescription = extractShortDescription(contentData.content.intro);
+    const tags = contentData.metadata.keywords.slice(0, 5);
+    const content = {
+      metadata: {
+        id,
+        ...contentData.metadata,
+        slug,
+        url,
+        datePublished,
+        author: productInfo.name,
+        readTime,
+        wordCount,
+        tags,
+        shortDescription,
+        fullDescription: contentData.content.intro
+      },
+      schemaOrg: this.generateSchemaOrg({
+        id,
+        ...contentData.metadata,
+        slug,
+        url,
+        datePublished,
+        author: productInfo.name,
+        readTime,
+        wordCount,
+        tags
+      }, productInfo),
+      content: contentData.content,
+      relatedPosts: [],
+      seo: await this.calculateSEOScore(contentData)
+    };
+    return content;
+  }
+  /**
+   * Generate content using Anthropic's Claude API
+   */
+  async generateWithAnthropic(prompt) {
+    if (!this.anthropic) {
+      throw new Error("Anthropic client not initialized");
+    }
+    const response = await this.anthropic.messages.create({
+      model: "claude-3-5-sonnet-20241022",
+      max_tokens: 4096,
+      temperature: 0.7,
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ]
+    });
+    const textContent = response.content[0].type === "text" ? response.content[0].text : "";
+    const jsonMatch = textContent.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("Failed to extract JSON from Claude response");
+    }
+    return JSON.parse(jsonMatch[0]);
+  }
+  /**
+   * Generate content using OpenAI's ChatGPT API
+   */
+  async generateWithOpenAI(prompt) {
+    if (!this.openai) {
+      throw new Error("OpenAI client not initialized");
+    }
+    const response = await this.openai.chat.completions.create({
+      model: "gpt-4-turbo-preview",
+      max_tokens: 4096,
+      temperature: 0.7,
+      messages: [
+        {
+          role: "user",
+          content: prompt
+        }
+      ],
+      response_format: { type: "json_object" }
+    });
+    const textContent = response.choices[0]?.message?.content || "";
+    if (!textContent) {
+      throw new Error("Failed to get response from OpenAI");
+    }
+    return JSON.parse(textContent);
+  }
+  /**
+   * Build prompt for Claude API
+   */
+  buildPrompt(productInfo, topic) {
+    return `You are an expert SEO content writer. Generate a comprehensive blog post about: "${topic}"
+
+Product context:
+- Name: ${productInfo.name}
+- Tagline: ${productInfo.tagline || ""}
+- Category: ${productInfo.category}
+- Features: ${productInfo.features.join(", ")}
+- Pricing: ${productInfo.pricingModel || "Not specified"}
+${productInfo.useCases ? `- Use cases: ${productInfo.useCases.join(", ")}` : ""}
+
+IMPORTANT INSTRUCTIONS:
+1. Write for users searching on Google and being recommended by AI assistants (Claude, ChatGPT)
+2. Focus on being helpful, not promotional
+3. Include comparisons with alternatives when relevant
+4. Use natural language, avoid keyword stuffing
+5. Make it comprehensive (1000-1500 words worth of content)
+6. Structure with clear sections (intro, 3-5 main sections, conclusion)
+7. Be factual - do NOT invent statistics or make false claims
+
+Output ONLY valid JSON in this exact format (no markdown, no code blocks):
+{
+  "metadata": {
+    "title": "SEO-optimized title (under 60 chars)",
+    "description": "Meta description (under 160 chars)",
+    "keywords": ["keyword1", "keyword2", "keyword3"],
+    "category": "${productInfo.category}"
+  },
+  "content": {
+    "intro": "Engaging introduction paragraph in markdown format",
+    "sections": [
+      {
+        "heading": "Section title",
+        "level": 2,
+        "content": "Section content in markdown format",
+        "type": "text"
+      }
+    ],
+    "conclusion": "Conclusion paragraph in markdown",
+    "cta": {
+      "text": "Try ${productInfo.name}",
+      "url": "${productInfo.websiteUrl || "/signup"}"
+    }
+  }
+}`;
+  }
+  /**
+   * Generate Schema.org structured data
+   */
+  generateSchemaOrg(metadata, productInfo) {
+    return {
+      "@context": "https://schema.org",
+      "@type": "BlogPosting",
+      headline: metadata.title,
+      description: metadata.description,
+      author: {
+        "@type": "Organization",
+        name: productInfo.name,
+        url: productInfo.websiteUrl
+      },
+      datePublished: metadata.datePublished,
+      publisher: {
+        "@type": "Organization",
+        name: productInfo.name
+      },
+      keywords: metadata.keywords.join(", "),
+      articleSection: metadata.category
+    };
+  }
+  /**
+   * Calculate SEO score
+   */
+  async calculateSEOScore(content) {
+    let score = 100;
+    const suggestions = [];
+    if (content.metadata.title.length > 60) {
+      score -= 10;
+      suggestions.push("Title is too long (should be under 60 chars)");
+    }
+    if (content.metadata.description.length > 160) {
+      score -= 10;
+      suggestions.push("Meta description is too long (should be under 160 chars)");
+    }
+    if (content.metadata.keywords.length < 3) {
+      score -= 5;
+      suggestions.push("Add more keywords (at least 3)");
+    }
+    if (content.content.sections.length < 3) {
+      score -= 10;
+      suggestions.push("Add more sections for better structure (at least 3)");
+    }
+    return {
+      score: Math.max(0, score),
+      suggestions
+    };
+  }
+  /**
+   * Generate topic suggestions
+   */
+  async generateTopics(productInfo, count) {
+    const prompt = `Generate ${count} SEO-friendly blog post topics for a product called "${productInfo.name}" in the ${productInfo.category} category.
+
+Product description: ${productInfo.description}
+Features: ${productInfo.features.join(", ")}
+
+Requirements:
+- Topics should be helpful for potential customers
+- Focus on solving problems or answering questions
+- Include comparisons, guides, and use cases
+- Optimize for search engines and AI recommendations
+
+Output ONLY a JSON array of topic strings, no markdown:
+["Topic 1", "Topic 2", "Topic 3"]`;
+    try {
+      if (this.provider === "anthropic" && this.anthropic) {
+        const response = await this.anthropic.messages.create({
+          model: "claude-3-5-sonnet-20241022",
+          max_tokens: 1024,
+          messages: [{ role: "user", content: prompt }]
+        });
+        const textContent = response.content[0].type === "text" ? response.content[0].text : "";
+        const jsonMatch = textContent.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+          return JSON.parse(jsonMatch[0]);
+        }
+      } else if (this.provider === "openai" && this.openai) {
+        const response = await this.openai.chat.completions.create({
+          model: "gpt-4-turbo-preview",
+          max_tokens: 1024,
+          messages: [{ role: "user", content: prompt }],
+          response_format: { type: "json_object" }
+        });
+        const textContent = response.choices[0]?.message?.content || "";
+        if (textContent) {
+          const data = JSON.parse(textContent);
+          const topicsArray = data.topics || data;
+          if (Array.isArray(topicsArray)) {
+            return topicsArray;
+          }
+          if (typeof topicsArray === "object") {
+            return Object.values(topicsArray).filter((v) => typeof v === "string");
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to generate topics with AI, using fallback");
+    }
+    return [
+      `Best ${productInfo.category} software ${(/* @__PURE__ */ new Date()).getFullYear()}`,
+      `How to choose ${productInfo.category} solution`,
+      `${productInfo.name} vs alternatives: Complete comparison`
+    ];
+  }
+  /**
+   * Generate blog manifest (index.json)
+   */
+  async generateManifest(outputDir, productInfo, posts) {
+    const { calculateAvgReadTime } = await import("./content-helpers-TXVEJMQK.js");
+    const manifestPosts = posts.map((post) => ({
+      id: post.metadata.id,
+      slug: post.metadata.slug,
+      url: post.metadata.url,
+      title: post.metadata.title,
+      shortDescription: post.metadata.shortDescription || post.metadata.description,
+      fullDescription: post.metadata.fullDescription || post.content.intro,
+      publishDate: post.metadata.datePublished,
+      readTime: post.metadata.readTime,
+      wordCount: post.metadata.wordCount,
+      tags: post.metadata.tags,
+      category: post.metadata.category,
+      seo: {
+        metaTitle: post.metadata.title,
+        metaDescription: post.metadata.description,
+        keywords: post.metadata.keywords,
+        seoScore: post.seo.score
+      }
+    }));
+    const totalWords = posts.reduce((sum, post) => sum + post.metadata.wordCount, 0);
+    const wordCounts = posts.map((post) => post.metadata.wordCount);
+    const avgReadTime = calculateAvgReadTime(wordCounts);
+    const manifest = {
+      version: "1.0.0",
+      generated: generateTimestamp(),
+      site: {
+        name: `${productInfo.name} Blog`,
+        url: productInfo.websiteUrl + "/blog",
+        description: productInfo.description || `Insights on ${productInfo.category}`
+      },
+      posts: manifestPosts,
+      stats: {
+        totalPosts: posts.length,
+        totalWords,
+        avgReadTime
+      }
+    };
+    const manifestPath = path2.join(outputDir, "index.json");
+    await fs2.writeJson(manifestPath, manifest, { spaces: 2 });
+    console.log(`\u2713 Generated blog manifest: ${manifestPath}`);
+  }
+  /**
+   * Generate blog index.html page
+   */
+  async generateBlogIndex(outputDir, productInfo, blogConfig) {
+    const ejs2 = await import("ejs");
+    const possiblePaths = [
+      path2.join(path2.dirname(fileURLToPath2(import.meta.url)), "../adapters/html/templates/blog-index.html.ejs"),
+      path2.join(path2.dirname(fileURLToPath2(import.meta.url)), "../../adapters/html/templates/blog-index.html.ejs"),
+      path2.join(path2.dirname(fileURLToPath2(import.meta.url)), "adapters/html/templates/blog-index.html.ejs")
+    ];
+    let templatePath = null;
+    for (const p of possiblePaths) {
+      if (await fs2.pathExists(p)) {
+        templatePath = p;
+        break;
+      }
+    }
+    if (!templatePath) {
+      console.warn(`Blog index template not found in any of the expected locations. Skipping blog index generation.`);
+      return;
+    }
+    const templateDir = path2.dirname(templatePath);
+    const template = await fs2.readFile(templatePath, "utf-8");
+    const html = ejs2.render(template, {
+      siteName: `${productInfo.name} Blog`,
+      siteDescription: productInfo.description || `Insights on ${productInfo.category}`,
+      siteUrl: productInfo.websiteUrl + "/blog",
+      blogConfig
+    }, {
+      filename: templatePath,
+      // Required for includes to resolve correctly
+      root: templateDir
+      // Root directory for include resolution
+    });
+    const indexPath = path2.join(outputDir, "index.html");
+    await fs2.writeFile(indexPath, html, "utf-8");
+    console.log(`\u2713 Generated blog index: ${indexPath}`);
+  }
+  /**
+   * Update sitemap.xml
+   */
+  async updateSitemap(blogDir, productInfo, posts) {
+    const sitemapPath = path2.join(blogDir, "sitemap.xml");
+    const urls = posts.map((post) => {
+      return `  <url>
+    <loc>${post.metadata.url}</loc>
+    <lastmod>${post.metadata.datePublished.split("T")[0]}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.8</priority>
+  </url>`;
+    }).join("\n");
+    const baseUrl = productInfo.websiteUrl.replace(/\/$/, "");
+    const blogIndexUrl = `  <url>
+    <loc>${baseUrl}/blog/</loc>
+    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
+    <changefreq>daily</changefreq>
+    <priority>1.0</priority>
+  </url>`;
+    const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${blogIndexUrl}
+${urls}
+</urlset>`;
+    await fs2.writeFile(sitemapPath, sitemap, "utf-8");
+    console.log(`\u2713 Generated sitemap: ${sitemapPath}`);
+  }
+  /**
+   * Generate table of contents from post sections
+   */
+  generateTableOfContents(content) {
+    const toc = [];
+    content.content.sections.forEach((section) => {
+      if (section.level >= 2 && section.level <= 4) {
+        const id = section.heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+        toc.push({
+          id,
+          text: section.heading,
+          level: section.level
+        });
+      }
+    });
+    return toc;
+  }
+  /**
+   * Find related posts based on tags and category similarity
+   */
+  async generateRelatedPosts(currentPost, outputDir, limit = 3) {
+    try {
+      const manifestPath = path2.join(outputDir, "index.json");
+      if (!await fs2.pathExists(manifestPath)) {
+        return [];
+      }
+      const manifest = await fs2.readJson(manifestPath);
+      const scoredPosts = manifest.posts.filter((post) => post.id !== currentPost.metadata.id).map((post) => {
+        let score = 0;
+        if (post.category === currentPost.metadata.category) {
+          score += 3;
+        }
+        const sharedTags = post.tags.filter(
+          (tag) => currentPost.metadata.tags.includes(tag)
+        );
+        score += sharedTags.length;
+        return {
+          post,
+          score
+        };
+      }).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+      return scoredPosts.map((item) => ({
+        title: item.post.title,
+        slug: item.post.slug,
+        url: item.post.url,
+        excerpt: item.post.shortDescription
+      }));
+    } catch (error) {
+      console.warn("Failed to generate related posts:", error);
+      return [];
+    }
+  }
+  /**
+   * Get previous and next posts for navigation
+   */
+  async generateNavigationData(currentPost, outputDir) {
+    try {
+      const manifestPath = path2.join(outputDir, "index.json");
+      if (!await fs2.pathExists(manifestPath)) {
+        return {};
+      }
+      const manifest = await fs2.readJson(manifestPath);
+      const sortedPosts = [...manifest.posts].sort(
+        (a, b) => new Date(b.publishDate).getTime() - new Date(a.publishDate).getTime()
+      );
+      const currentIndex = sortedPosts.findIndex(
+        (post) => post.id === currentPost.metadata.id
+      );
+      if (currentIndex === -1) {
+        return {};
+      }
+      const prevPost = sortedPosts[currentIndex + 1];
+      const nextPost = sortedPosts[currentIndex - 1];
+      return {
+        prevPost: prevPost ? {
+          title: prevPost.title,
+          url: prevPost.url,
+          slug: prevPost.slug
+        } : void 0,
+        nextPost: nextPost ? {
+          title: nextPost.title,
+          url: nextPost.url,
+          slug: nextPost.slug
+        } : void 0
+      };
+    } catch (error) {
+      console.warn("Failed to generate navigation data:", error);
+      return {};
+    }
+  }
+};
+
+export {
+  AdapterRegistry,
+  HTMLAdapter,
+  ContentGenerator
+};