@f-o-t/content-analysis 1.0.0

package/dist/index.js

@@ -0,0 +1,891 @@
+// src/utils.ts
+function countSyllables(word) {
+  const w = word.toLowerCase();
+  if (w.length <= 3)
+    return 1;
+  const vowelGroups = w.match(/[aeiouy]+/g) || [];
+  let count = vowelGroups.length;
+  if (w.endsWith("e"))
+    count--;
+  return Math.max(1, count);
+}
+function calculateFleschKincaid(text) {
+  const cleanText = text.replace(/[^\w\s.!?]/g, "");
+  const sentences = cleanText.split(/[.!?]+/).filter(Boolean);
+  const words = cleanText.split(/\s+/).filter(Boolean);
+  if (words.length === 0 || sentences.length === 0) {
+    return { readingEase: 0, gradeLevel: 0 };
+  }
+  const totalSyllables = words.reduce((sum, word) => sum + countSyllables(word), 0);
+  const avgWordsPerSentence = words.length / sentences.length;
+  const avgSyllablesPerWord = totalSyllables / words.length;
+  const readingEase = 206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord;
+  const gradeLevel = 0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59;
+  return {
+    readingEase: Math.max(0, Math.min(100, Math.round(readingEase * 10) / 10)),
+    gradeLevel: Math.max(0, Math.round(gradeLevel * 10) / 10)
+  };
+}
+function getReadabilityLevel(score) {
+  if (score >= 90)
+    return "Very Easy (5th grade)";
+  if (score >= 80)
+    return "Easy (6th grade)";
+  if (score >= 70)
+    return "Fairly Easy (7th grade)";
+  if (score >= 60)
+    return "Standard (8th-9th grade)";
+  if (score >= 50)
+    return "Fairly Difficult (10th-12th grade)";
+  if (score >= 30)
+    return "Difficult (College)";
+  return "Very Difficult (College Graduate)";
+}
+function findOccurrences(regex, text) {
+  const matches = [];
+  const flags = regex.flags.includes("g") ? regex.flags : `${regex.flags}g`;
+  const globalRegex = new RegExp(regex.source, flags);
+  let match;
+  while ((match = globalRegex.exec(text)) !== null) {
+    const start = Math.max(0, match.index - 20);
+    const end = Math.min(text.length, match.index + match[0].length + 20);
+    const context = text.slice(start, end);
+    matches.push(`...${context}...`);
+  }
+  return matches;
+}
+function extractWords(content) {
+  return content.split(/\s+/).filter(Boolean);
+}
+function extractParagraphs(content) {
+  return content.split(/\n\n+/).filter(Boolean);
+}
+function extractHeadings(content) {
+  const headingMatches = [...content.matchAll(/^(#{1,6})\s+(.+)$/gm)];
+  const headings = [];
+  for (const match of headingMatches) {
+    const hashMarks = match[1];
+    const headingText = match[2];
+    if (hashMarks && headingText) {
+      headings.push({
+        level: hashMarks.length,
+        text: headingText,
+        index: match.index ?? 0
+      });
+    }
+  }
+  return headings;
+}
+function clampScore(score) {
+  return Math.max(0, Math.min(100, score));
+}
+function hasQuickAnswerPattern(text) {
+  return /\*\*quick\s*answer\*\*|>.*quick.*answer|tl;?dr|em\s+resumo|resumindo/i.test(text) || /^.*?\*\*[^*]+\*\*\s+(?:é|is|are|was|were|significa)\s/im.test(text) || /^\|.*\|.*\|$/m.test(text);
+}
+function hasConclusionSection(content) {
+  return /##\s*(?:conclus|conclusion|resumo|takeaway|key\s*takeaway|final|wrapping\s*up)/i.test(content);
+}
+
+// src/bad-patterns.ts
+function analyzeBadPatterns(content, title) {
+  const patterns = [];
+  const wordCountPattern = /\b\d+\+?\s*(?:palavras?|words?)\b|~\s*\d+\s*(?:palavras?|words?)|word\s*count|contagem\s*de\s*palavras/gi;
+  const wordCountMatches = findOccurrences(wordCountPattern, content);
+  if (wordCountMatches.length > 0) {
+    patterns.push({
+      pattern: "word_count_mention",
+      severity: "warning",
+      locations: wordCountMatches,
+      suggestion: "Remove word count mentions. Readers don't care about article length."
+    });
+  }
+  if (title) {
+    wordCountPattern.lastIndex = 0;
+    const titleWordCountMatch = wordCountPattern.exec(title);
+    if (titleWordCountMatch) {
+      patterns.push({
+        pattern: "word_count_in_title",
+        severity: "warning",
+        locations: [`Title: "${title}"`],
+        suggestion: "Remove word count claims from title. Focus on value, not length."
+      });
+    }
+  }
+  const metaCommentaryPatterns = [
+    /\b(?:neste\s+artigo|in\s+this\s+(?:article|post|guide))\b/gi,
+    /\b(?:como\s+mencionado|as\s+(?:mentioned|discussed|noted)\s+(?:above|earlier|before))\b/gi,
+    /\b(?:vamos\s+explorar|let'?s\s+explore|we\s+will\s+(?:discuss|explore|cover))\b/gi,
+    /\b(?:conforme\s+vimos|as\s+we\s+(?:saw|discussed|covered))\b/gi
+  ];
+  for (const pattern of metaCommentaryPatterns) {
+    const matches = findOccurrences(pattern, content);
+    if (matches.length > 0) {
+      patterns.push({
+        pattern: "meta_commentary",
+        severity: "warning",
+        locations: matches,
+        suggestion: "Remove meta-commentary. Just deliver the information directly."
+      });
+    }
+  }
+  const engagementPatterns = [
+    /\b(?:não\s+esqueça\s+de|don'?t\s+forget\s+to)\s+(?:curtir|like|subscribe|seguir|compartilhar|share)/gi,
+    /\b(?:deixe\s+(?:um\s+)?comentário|leave\s+a\s+comment|comment\s+below)/gi,
+    /\b(?:inscreva-se|subscribe|sign\s+up)\s+(?:para|to|for)\s+(?:nossa|my|our|the)\s+(?:newsletter|canal|channel)/gi,
+    /\b(?:compartilhe\s+com|share\s+(?:this|with))\s+(?:seus\s+amigos|your\s+friends)/gi,
+    /\bsmash\s+(?:that\s+)?(?:like|subscribe)\s+button\b/gi
+  ];
+  for (const pattern of engagementPatterns) {
+    const matches = findOccurrences(pattern, content);
+    if (matches.length > 0) {
+      patterns.push({
+        pattern: "engagement_begging",
+        severity: "warning",
+        locations: matches,
+        suggestion: "Remove engagement begging. Let quality content earn engagement naturally."
+      });
+    }
+  }
+  const firstH2Index = content.search(/^##\s+/m);
+  if (firstH2Index > 0) {
+    const introText = content.slice(0, firstH2Index);
+    const introWords = extractWords(introText).length;
+    if (introWords > 150) {
+      patterns.push({
+        pattern: "endless_introduction",
+        severity: "warning",
+        locations: [`Introduction: ~${introWords} words before first H2`],
+        suggestion: "Shorten introduction to under 150 words. Get to the point faster."
+      });
+    }
+  }
+  const vaguePatterns = [
+    /\b(?:configure\s+(?:appropriately|properly|correctly))\b/gi,
+    /\b(?:set\s+up\s+(?:as\s+needed|accordingly))\b/gi,
+    /\b(?:adjust\s+(?:as\s+necessary|accordingly|as\s+needed))\b/gi,
+    /\b(?:use\s+(?:the\s+right|appropriate|suitable)\s+(?:settings|options|values))\b/gi
+  ];
+  for (const pattern of vaguePatterns) {
+    const matches = findOccurrences(pattern, content);
+    if (matches.length > 0) {
+      patterns.push({
+        pattern: "vague_instructions",
+        severity: "warning",
+        locations: matches,
+        suggestion: "Be specific. Instead of 'configure appropriately', say exactly what to configure and how."
+      });
+    }
+  }
+  const clickbaitPatterns = [
+    /\b(?:you\s+won'?t\s+believe|você\s+não\s+vai\s+acreditar)\b/gi,
+    /\b(?:this\s+one\s+(?:trick|tip|secret))\b/gi,
+    /\b(?:AMAZING|INCREDIBLE|MIND-?BLOWING)\b/g,
+    /!!+|\?!+|!{3,}/g
+  ];
+  for (const pattern of clickbaitPatterns) {
+    const matches = findOccurrences(pattern, content);
+    if (matches.length > 0) {
+      patterns.push({
+        pattern: "clickbait_markers",
+        severity: "warning",
+        locations: matches,
+        suggestion: "Remove clickbait language. Use accurate, professional language instead."
+      });
+    }
+  }
+  const fillerPatterns = [
+    /\b(?:it\s+goes\s+without\s+saying|vai\s+sem\s+dizer)\b/gi,
+    /\b(?:without\s+further\s+ado|sem\s+mais\s+delongas)\b/gi,
+    /\b(?:at\s+the\s+end\s+of\s+the\s+day|no\s+final\s+das\s+contas)\b/gi,
+    /\b(?:in\s+today'?s\s+(?:digital\s+)?(?:landscape|world|age))\b/gi,
+    /\b(?:(?:as\s+)?a\s+matter\s+of\s+fact)\b/gi,
+    /\b(?:needless\s+to\s+say|escusado\s+será\s+dizer)\b/gi,
+    /\b(?:in\s+(?:conclusion|summary)|em\s+(?:conclusão|resumo))(?:\s*[,:])\b/gi
+  ];
+  for (const pattern of fillerPatterns) {
+    const matches = findOccurrences(pattern, content);
+    if (matches.length > 0) {
+      patterns.push({
+        pattern: "filler_phrases",
+        severity: "warning",
+        locations: matches,
+        suggestion: "Remove filler phrases. They add no value and waste reader's time."
+      });
+    }
+  }
+  const overFormattingPattern = /(\*{1,2}[^*]+\*{1,2}\s*){3,}|(_{1,2}[^_]+_{1,2}\s*){3,}/g;
+  const overFormattingMatches = findOccurrences(overFormattingPattern, content);
+  if (overFormattingMatches.length > 0) {
+    patterns.push({
+      pattern: "over_formatting",
+      severity: "warning",
+      locations: overFormattingMatches,
+      suggestion: "Reduce consecutive formatting. Use bold/italic sparingly for emphasis."
+    });
+  }
+  const paragraphs = extractParagraphs(content);
+  const longParagraphs = [];
+  for (const paragraph of paragraphs) {
+    if (paragraph.startsWith("```") || paragraph.startsWith("#"))
+      continue;
+    const wordCount = extractWords(paragraph).length;
+    if (wordCount > 100) {
+      const preview = paragraph.slice(0, 50) + "..." + paragraph.slice(-30);
+      longParagraphs.push(`~${wordCount} words: "${preview}"`);
+    }
+  }
+  if (longParagraphs.length > 0) {
+    patterns.push({
+      pattern: "wall_of_text",
+      severity: "warning",
+      locations: longParagraphs,
+      suggestion: "Break up long paragraphs. Keep paragraphs under 100 words for better readability."
+    });
+  }
+  const wordsLower = content.toLowerCase();
+  const totalWords = extractWords(content).length;
+  const phraseCount = {};
+  const tokens = wordsLower.match(/\b[a-záàâãéèêíïóôõöúç]{3,}\b/g) || [];
+  for (let i = 0;i < tokens.length - 1; i++) {
+    const bigram = `${tokens[i]} ${tokens[i + 1]}`;
+    phraseCount[bigram] = (phraseCount[bigram] || 0) + 1;
+  }
+  const stuffedPhrases = [];
+  for (const [phrase, count] of Object.entries(phraseCount)) {
+    const density = count / totalWords * 100;
+    if (density > 3 && count > 5) {
+      stuffedPhrases.push(`"${phrase}" appears ${count} times (${density.toFixed(1)}% density)`);
+    }
+  }
+  if (stuffedPhrases.length > 0) {
+    patterns.push({
+      pattern: "keyword_stuffing",
+      severity: "warning",
+      locations: stuffedPhrases,
+      suggestion: "Reduce keyword repetition. Use synonyms and natural language variation."
+    });
+  }
+  return {
+    hasIssues: patterns.length > 0,
+    issueCount: patterns.length,
+    patterns
+  };
+}
+// src/keywords.ts
+function analyzeKeywords(input) {
+  const { content, title, targetKeywords } = input;
+  const analysis = [];
+  const recommendations = [];
+  const words = extractWords(content);
+  const totalWordCount = words.length;
+  const uniqueWords = new Set(words.map((w) => w.toLowerCase()));
+  const contentLower = content.toLowerCase();
+  const titleLower = title?.toLowerCase() || "";
+  const headings = content.match(/^#{2,6}\s+(.+)$/gm) || [];
+  const headingsText = headings.join(" ").toLowerCase();
+  const first100Words = words.slice(0, 100).join(" ").toLowerCase();
+  const last100Words = words.slice(-100).join(" ").toLowerCase();
+  let totalDensity = 0;
+  for (const keyword of targetKeywords) {
+    const keywordLower = keyword.toLowerCase();
+    const regex = new RegExp(keywordLower, "gi");
+    const matches = contentLower.match(regex) || [];
+    const count = matches.length;
+    const density = totalWordCount > 0 ? count / totalWordCount * 100 : 0;
+    totalDensity += density;
+    const locations = [];
+    if (titleLower.includes(keywordLower)) {
+      locations.push({ type: "title" });
+    }
+    if (headingsText.includes(keywordLower)) {
+      locations.push({ type: "heading" });
+    }
+    if (first100Words.includes(keywordLower)) {
+      locations.push({ type: "first100words" });
+    }
+    if (last100Words.includes(keywordLower)) {
+      locations.push({ type: "last100words" });
+    }
+    let status;
+    let suggestion;
+    if (count === 0) {
+      status = "missing";
+      suggestion = `Add "${keyword}" naturally to your content`;
+    } else if (density < 0.5) {
+      status = "low";
+      suggestion = `Consider using "${keyword}" a few more times`;
+    } else if (density > 3) {
+      status = "high";
+      suggestion = `Reduce usage of "${keyword}" - it may appear spammy`;
+    } else {
+      status = "optimal";
+    }
+    analysis.push({
+      keyword,
+      count,
+      density: Math.round(density * 100) / 100,
+      locations,
+      status,
+      suggestion
+    });
+  }
+  let overallScore = 100;
+  for (const item of analysis) {
+    if (item.status === "missing")
+      overallScore -= 15;
+    else if (item.status === "low")
+      overallScore -= 10;
+    else if (item.status === "high")
+      overallScore -= 5;
+  }
+  overallScore = Math.max(0, Math.min(100, overallScore));
+  const missingKeywords = analysis.filter((a) => a.status === "missing");
+  const lowKeywords = analysis.filter((a) => a.status === "low");
+  const highKeywords = analysis.filter((a) => a.status === "high");
+  if (missingKeywords.length > 0) {
+    recommendations.push(`Add missing keywords: ${missingKeywords.map((k) => k.keyword).join(", ")}`);
+  }
+  if (lowKeywords.length > 0) {
+    recommendations.push(`Increase usage of: ${lowKeywords.map((k) => k.keyword).join(", ")}`);
+  }
+  if (highKeywords.length > 0) {
+    recommendations.push(`Reduce overused keywords: ${highKeywords.map((k) => k.keyword).join(", ")}`);
+  }
+  const phraseCount = {};
+  const tokens = contentLower.match(/\b[a-záàâãéèêíïóôõöúç]{3,}\b/g) || [];
+  for (const token of tokens) {
+    phraseCount[token] = (phraseCount[token] || 0) + 1;
+  }
+  const topKeywords = Object.entries(phraseCount).filter(([word]) => word.length > 4 && !["that", "this", "with", "from", "have", "been"].includes(word)).sort(([, a], [, b]) => b - a).slice(0, 10).map(([keyword, count]) => ({
+    keyword,
+    count,
+    density: Math.round(count / totalWordCount * 1e4) / 100
+  }));
+  const metrics = {
+    totalWordCount,
+    uniqueWordCount: uniqueWords.size,
+    avgKeywordDensity: targetKeywords.length > 0 ? Math.round(totalDensity / targetKeywords.length * 100) / 100 : 0
+  };
+  return {
+    analysis,
+    overallScore,
+    topKeywords,
+    recommendations,
+    metrics
+  };
+}
+// src/readability.ts
+var TARGET_SCORES = {
+  general: {
+    min: 60,
+    max: 70,
+    description: "Easy to read for general audience"
+  },
+  technical: {
+    min: 40,
+    max: 60,
+    description: "Technical but accessible"
+  },
+  academic: {
+    min: 30,
+    max: 50,
+    description: "Academic/professional level"
+  },
+  casual: {
+    min: 70,
+    max: 80,
+    description: "Very easy, conversational"
+  }
+};
+function analyzeReadability(content, targetAudience = "general") {
+  const { readingEase, gradeLevel } = calculateFleschKincaid(content);
+  const readabilityLevel = getReadabilityLevel(readingEase);
+  const targetScore = TARGET_SCORES[targetAudience];
+  const isOnTarget = readingEase >= targetScore.min && readingEase <= targetScore.max;
+  const cleanText = content.replace(/[^\w\s.!?]/g, "");
+  const sentences = cleanText.split(/[.!?]+/).filter(Boolean);
+  const words = cleanText.split(/\s+/).filter(Boolean);
+  const complexWords = words.filter((w) => countSyllables(w) >= 3);
+  const totalSyllables = words.reduce((sum, word) => sum + countSyllables(word), 0);
+  const suggestions = [];
+  if (readingEase < targetScore.min) {
+    suggestions.push("Simplify your language - use shorter words and sentences");
+    const avgWordsPerSentence = words.length / sentences.length;
+    if (avgWordsPerSentence > 20) {
+      suggestions.push(`Average sentence length is ${Math.round(avgWordsPerSentence)} words. Try to keep it under 20.`);
+    }
+    if (complexWords.length / words.length > 0.2) {
+      suggestions.push("Too many complex words (3+ syllables). Replace with simpler alternatives.");
+    }
+    suggestions.push("Break long sentences into shorter ones");
+    suggestions.push("Use active voice instead of passive voice");
+  } else if (readingEase > targetScore.max && targetAudience !== "casual") {
+    suggestions.push("Content may be too simple for your target audience");
+    suggestions.push("Consider adding more technical depth or detail");
+  }
+  if (sentences.some((s) => s.split(/\s+/).length > 40)) {
+    suggestions.push("Some sentences are very long. Consider breaking them up.");
+  }
+  const metrics = {
+    sentenceCount: sentences.length,
+    wordCount: words.length,
+    avgWordsPerSentence: sentences.length > 0 ? Math.round(words.length / sentences.length * 10) / 10 : 0,
+    avgSyllablesPerWord: words.length > 0 ? Math.round(totalSyllables / words.length * 100) / 100 : 0,
+    complexWordCount: complexWords.length,
+    complexWordPercentage: words.length > 0 ? Math.round(complexWords.length / words.length * 1000) / 10 : 0
+  };
+  return {
+    fleschKincaidReadingEase: readingEase,
+    fleschKincaidGradeLevel: gradeLevel,
+    readabilityLevel,
+    targetScore,
+    isOnTarget,
+    suggestions,
+    metrics
+  };
+}
+// src/seo.ts
+function analyzeSeo(input) {
+  const { content, title, metaDescription, targetKeywords } = input;
+  const issues = [];
+  const recommendations = [];
+  const words = extractWords(content);
+  const wordCount = words.length;
+  const paragraphs = extractParagraphs(content);
+  const headings = content.match(/^#{1,6}\s.+$/gm) || [];
+  const h2Headings = content.match(/^##\s.+$/gm) || [];
+  const links = content.match(/\[.+?\]\(.+?\)/g) || [];
+  const images = content.match(/!\[.+?\]\(.+?\)/g) || [];
+  const firstH2Index = content.search(/^##\s/m);
+  const firstParagraphText = firstH2Index > 0 ? content.slice(0, firstH2Index) : words.slice(0, 100).join(" ");
+  let score = 100;
+  if (!title) {
+    issues.push({
+      type: "title",
+      severity: "error",
+      message: "Missing title",
+      suggestion: "Add a descriptive title (50-60 characters)"
+    });
+    score -= 15;
+  } else if (title.length < 30) {
+    issues.push({
+      type: "title",
+      severity: "warning",
+      message: "Title is too short",
+      suggestion: "Expand title to 50-60 characters for better SEO"
+    });
+    score -= 8;
+  } else if (title.length > 60) {
+    issues.push({
+      type: "title",
+      severity: "warning",
+      message: "Title is too long",
+      suggestion: "Shorten to under 60 characters to avoid truncation in search results"
+    });
+    score -= 5;
+  }
+  if (title && targetKeywords && targetKeywords.length > 0) {
+    const titleLower = title.toLowerCase();
+    const hasKeywordInTitle = targetKeywords.some((kw) => titleLower.includes(kw.toLowerCase()));
+    if (!hasKeywordInTitle) {
+      issues.push({
+        type: "title",
+        severity: "warning",
+        message: "Primary keyword not found in title",
+        suggestion: "Include your primary keyword naturally in the title"
+      });
+      score -= 5;
+    }
+  }
+  if (!metaDescription) {
+    issues.push({
+      type: "meta_description",
+      severity: "warning",
+      message: "Missing meta description",
+      suggestion: "Add a meta description (150-160 characters)"
+    });
+    score -= 10;
+  } else if (metaDescription.length < 120) {
+    issues.push({
+      type: "meta_description",
+      severity: "info",
+      message: "Meta description could be longer",
+      suggestion: "Expand to 150-160 characters"
+    });
+    score -= 3;
+  } else if (metaDescription.length > 160) {
+    issues.push({
+      type: "meta_description",
+      severity: "warning",
+      message: "Meta description is too long",
+      suggestion: "Shorten to under 160 characters"
+    });
+    score -= 5;
+  }
+  if (headings.length === 0) {
+    issues.push({
+      type: "headings",
+      severity: "error",
+      message: "No headings found",
+      suggestion: "Add H2 and H3 headings to structure your content"
+    });
+    score -= 15;
+  } else if (h2Headings.length < 3 && wordCount > 500) {
+    issues.push({
+      type: "headings",
+      severity: "warning",
+      message: "Too few H2 headings for content length",
+      suggestion: "Add more H2 subheadings (one every 200-300 words)"
+    });
+    score -= 5;
+  }
+  const h1Headings = content.match(/^#\s.+$/gm) || [];
+  if (h1Headings.length > 0) {
+    issues.push({
+      type: "headings",
+      severity: "error",
+      message: "H1 heading found in content body",
+      suggestion: "Remove H1 from content. The title is in frontmatter. Start with H2."
+    });
+    score -= 10;
+  }
+  if (targetKeywords && targetKeywords.length > 0 && h2Headings.length > 0) {
+    const h2Text = h2Headings.join(" ").toLowerCase();
+    const hasKeywordInH2 = targetKeywords.some((kw) => h2Text.includes(kw.toLowerCase()));
+    if (!hasKeywordInH2) {
+      issues.push({
+        type: "heading_keywords",
+        severity: "info",
+        message: "Target keywords not found in any H2 headings",
+        suggestion: "Include keywords naturally in at least one H2 heading"
+      });
+      score -= 3;
+    }
+  }
+  if (wordCount < 300) {
+    issues.push({
+      type: "content_length",
+      severity: "error",
+      message: "Content is too short",
+      suggestion: "Aim for at least 600-1000 words for blog posts"
+    });
+    score -= 10;
+  } else if (wordCount < 600) {
+    issues.push({
+      type: "content_length",
+      severity: "warning",
+      message: "Content could be longer",
+      suggestion: "Consider expanding to 1000+ words for better ranking"
+    });
+    score -= 5;
+  }
+  if (links.length === 0 && wordCount > 500) {
+    issues.push({
+      type: "links",
+      severity: "warning",
+      message: "No links found",
+      suggestion: "Add internal and external links to improve SEO"
+    });
+    score -= 10;
+  } else if (links.length < 3 && wordCount > 1000) {
+    issues.push({
+      type: "links",
+      severity: "info",
+      message: "Few links for content length",
+      suggestion: "Add more internal links to related content and external links to authoritative sources"
+    });
+    score -= 3;
+  }
+  if (images.length === 0 && wordCount > 300) {
+    issues.push({
+      type: "images",
+      severity: "info",
+      message: "No images found",
+      suggestion: "Add images with descriptive alt text"
+    });
+    score -= 3;
+  }
+  const hasQuickAnswer = hasQuickAnswerPattern(firstParagraphText);
+  if (!hasQuickAnswer && wordCount > 300) {
+    issues.push({
+      type: "quick_answer",
+      severity: "warning",
+      message: "No quick answer detected in first 100 words",
+      suggestion: "Add a TL;DR, definition lead, or comparison table early to answer the reader's question immediately"
+    });
+    score -= 10;
+  }
+  let keywordInFirstParagraph = false;
+  if (targetKeywords && targetKeywords.length > 0) {
+    const firstParaLower = firstParagraphText.toLowerCase();
+    keywordInFirstParagraph = targetKeywords.some((kw) => firstParaLower.includes(kw.toLowerCase()));
+    if (!keywordInFirstParagraph) {
+      issues.push({
+        type: "first_paragraph",
+        severity: "warning",
+        message: "Primary keyword not found in first paragraph",
+        suggestion: "Include your primary keyword in the first 100 words for better SEO"
+      });
+      score -= 5;
+    }
+  }
+  const keywordDensity = {};
+  if (targetKeywords && targetKeywords.length > 0) {
+    const contentLower = content.toLowerCase();
+    for (const keyword of targetKeywords) {
+      const regex = new RegExp(keyword.toLowerCase(), "gi");
+      const matches = contentLower.match(regex) || [];
+      keywordDensity[keyword] = Number((matches.length / wordCount * 100).toFixed(2));
+      if (keywordDensity[keyword] === 0) {
+        issues.push({
+          type: "keyword_density",
+          severity: "warning",
+          message: `Target keyword "${keyword}" not found`,
+          suggestion: `Include "${keyword}" naturally in your content`
+        });
+        score -= 5;
+      } else if (keywordDensity[keyword] > 3) {
+        issues.push({
+          type: "keyword_density",
+          severity: "warning",
+          message: `Keyword "${keyword}" may be overused (${keywordDensity[keyword]}%)`,
+          suggestion: "Reduce keyword density to 1-2%"
+        });
+        score -= 3;
+      }
+    }
+  }
+  const hasConclusion = hasConclusionSection(content);
+  if (!hasConclusion && wordCount > 500) {
+    issues.push({
+      type: "structure",
+      severity: "info",
+      message: "No conclusion section detected",
+      suggestion: "Add a conclusion with key takeaways and a call-to-action"
+    });
+    score -= 5;
+  }
+  if (issues.some((i) => i.type === "content_length")) {
+    recommendations.push("Expand your content with more detailed explanations and examples");
+  }
+  if (issues.some((i) => i.type === "headings")) {
+    recommendations.push("Structure your content with clear H2 and H3 headings");
+  }
+  if (issues.some((i) => i.type === "links")) {
+    recommendations.push("Add relevant internal links to other blog posts and external links to authoritative sources");
+  }
+  if (issues.some((i) => i.type === "quick_answer")) {
+    recommendations.push("Start with a quick answer - readers want the answer immediately, not after scrolling");
+  }
+  if (issues.some((i) => i.type === "first_paragraph")) {
+    recommendations.push("Include your primary keyword in the first paragraph for better search visibility");
+  }
+  const metrics = {
+    wordCount,
+    headingCount: headings.length,
+    paragraphCount: paragraphs.length,
+    linkCount: links.length,
+    imageCount: images.length,
+    hasQuickAnswer,
+    keywordInFirstParagraph,
+    keywordDensity: Object.keys(keywordDensity).length > 0 ? keywordDensity : undefined
+  };
+  return {
+    score: clampScore(score),
+    issues,
+    recommendations,
+    metrics
+  };
+}
+// src/structure.ts
+function analyzeStructure(content, contentType) {
+  const issues = [];
+  let score = 100;
+  const words = extractWords(content);
+  const wordCount = words.length;
+  const paragraphs = extractParagraphs(content);
+  const headings = extractHeadings(content);
+  const hasH1InContent = headings.some((h) => h.level === 1);
+  if (hasH1InContent) {
+    issues.push({
+      type: "heading_h1",
+      severity: "error",
+      message: "H1 heading found in content body",
+      suggestion: "Remove H1 (# heading) from content. The title is in frontmatter. Start content with H2 (##)."
+    });
+    score -= 15;
+  }
+  let headingHierarchyValid = true;
+  for (let i = 1;i < headings.length; i++) {
+    const prevHeading = headings[i - 1];
+    const currentHeading = headings[i];
+    if (!prevHeading || !currentHeading)
+      continue;
+    const prevLevel = prevHeading.level;
+    const currentLevel = currentHeading.level;
+    if (currentLevel > prevLevel + 1) {
+      headingHierarchyValid = false;
+      issues.push({
+        type: "heading_hierarchy",
+        severity: "warning",
+        message: `Heading level skipped: H${prevLevel} to H${currentLevel} ("${currentHeading.text}")`,
+        suggestion: `Don't skip heading levels. Use H${prevLevel + 1} instead of H${currentLevel}.`
+      });
+      score -= 5;
+    }
+  }
+  const first100Words = words.slice(0, 100).join(" ");
+  const hasQuickAnswer = hasQuickAnswerPattern(first100Words);
+  if (!hasQuickAnswer && wordCount > 300) {
+    issues.push({
+      type: "quick_answer",
+      severity: "warning",
+      message: "No quick answer detected in first 100 words",
+      suggestion: "Add a TL;DR box, definition lead, or comparison table early to answer the reader's question immediately."
+    });
+    score -= 10;
+  }
+  let totalSentences = 0;
+  let longParagraphs = 0;
+  for (const paragraph of paragraphs) {
+    if (paragraph.startsWith("#") || paragraph.startsWith("```"))
+      continue;
+    const sentences = paragraph.split(/[.!?]+/).filter(Boolean);
+    totalSentences += sentences.length;
+    if (sentences.length > 4) {
+      longParagraphs++;
+    }
+  }
+  const avgParagraphLength = paragraphs.length > 0 ? totalSentences / paragraphs.length : 0;
+  if (longParagraphs > 0) {
+    issues.push({
+      type: "paragraph_length",
+      severity: "info",
+      message: `${longParagraphs} paragraph(s) exceed 4 sentences`,
+      suggestion: "Break up long paragraphs. Aim for 2-4 sentences per paragraph for better readability."
+    });
+    score -= Math.min(longParagraphs * 2, 10);
+  }
+  const h2Headings = headings.filter((h) => h.level === 2);
+  const expectedH2Count = Math.floor(wordCount / 250);
+  if (h2Headings.length < expectedH2Count && wordCount > 500) {
+    issues.push({
+      type: "heading_frequency",
+      severity: "warning",
+      message: `Only ${h2Headings.length} H2 headings for ${wordCount} words (recommended: ${expectedH2Count})`,
+      suggestion: "Add more H2 headings to break up content. Aim for one H2 every 200-300 words."
+    });
+    score -= 5;
+  }
+  const hasTableOfContents = /##\s*(?:table of contents|sumário|índice|contents)/i.test(content) || /\[.*\]\(#.*\)/.test(content.slice(0, 500));
+  if (wordCount > 1500 && !hasTableOfContents) {
+    issues.push({
+      type: "table_of_contents",
+      severity: "info",
+      message: "No table of contents detected for long-form content",
+      suggestion: "Add a table of contents near the beginning for posts over 1500 words."
+    });
+    score -= 3;
+  }
+  const hasTables = /^\|.*\|.*\|$/m.test(content);
+  const hasConclusion = hasConclusionSection(content);
+  if (!hasConclusion && wordCount > 500) {
+    issues.push({
+      type: "conclusion",
+      severity: "info",
+      message: "No conclusion section detected",
+      suggestion: "Add a conclusion with key takeaways and a call-to-action."
+    });
+    score -= 5;
+  }
+  if (contentType === "how-to") {
+    const hasNumberedSteps = /^\d+\.\s+/m.test(content) || /step\s*\d+|passo\s*\d+/i.test(content);
+    if (!hasNumberedSteps) {
+      issues.push({
+        type: "how_to_structure",
+        severity: "warning",
+        message: "How-to content should have numbered steps",
+        suggestion: "Use numbered lists (1. 2. 3.) for step-by-step instructions."
+      });
+      score -= 5;
+    }
+  }
+  if (contentType === "comparison") {
+    if (!hasTables) {
+      issues.push({
+        type: "comparison_structure",
+        severity: "warning",
+        message: "Comparison content should include a comparison table",
+        suggestion: "Add a table comparing key metrics between the options."
+      });
+      score -= 5;
+    }
+  }
+  if (contentType === "listicle") {
+    const listItemCount = (content.match(/^[-*]\s+/gm) || []).length;
+    if (listItemCount < 3) {
+      issues.push({
+        type: "listicle_structure",
+        severity: "warning",
+        message: "Listicle should have multiple list items",
+        suggestion: "Add more items to your list for a comprehensive listicle."
+      });
+      score -= 5;
+    }
+  }
+  const structure = {
+    hasQuickAnswer,
+    headingHierarchyValid,
+    avgParagraphLength: Math.round(avgParagraphLength * 10) / 10,
+    hasTableOfContents,
+    hasTables,
+    hasConclusion,
+    headingCount: headings.length,
+    wordCount
+  };
+  return {
+    score: clampScore(score),
+    issues,
+    structure
+  };
+}
+// src/index.ts
+function analyzeContent(input) {
+  const { content, title, description, targetKeywords } = input;
+  const seo = analyzeSeo({
+    content,
+    title,
+    metaDescription: description,
+    targetKeywords
+  });
+  const readability = analyzeReadability(content, "general");
+  const structure = analyzeStructure(content);
+  const badPatterns = analyzeBadPatterns(content, title);
+  const keywords = targetKeywords && targetKeywords.length > 0 ? analyzeKeywords({ content, title, targetKeywords }) : null;
+  return {
+    seo,
+    readability,
+    structure,
+    badPatterns,
+    keywords,
+    analyzedAt: new Date().toISOString()
+  };
+}
+export {
+  hasQuickAnswerPattern,
+  hasConclusionSection,
+  getReadabilityLevel,
+  findOccurrences,
+  extractWords,
+  extractParagraphs,
+  extractHeadings,
+  countSyllables,
+  clampScore,
+  calculateFleschKincaid,
+  analyzeStructure,
+  analyzeSeo,
+  analyzeReadability,
+  analyzeKeywords,
+  analyzeContent,
+  analyzeBadPatterns
+};