@rankcli/agent-runtime 0.0.9 → 0.0.11

package/dist/chunk-K6VSXDD6.mjs

@@ -0,0 +1,293 @@
+// src/analyzers/internal-linking-analyzer.ts
+import * as cheerio from "cheerio";
+var GENERIC_ANCHOR_TEXTS = [
+  "click here",
+  "read more",
+  "learn more",
+  "here",
+  "link",
+  "this",
+  "more",
+  "continue",
+  "see more",
+  "view more",
+  "details",
+  "go",
+  "continue reading",
+  ">>",
+  "\u2192",
+  "next",
+  "previous"
+];
+function isInternalUrl(href, baseUrl) {
+  if (!href || href.startsWith("#") || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+    return false;
+  }
+  if (href.startsWith("/") && !href.startsWith("//")) {
+    return true;
+  }
+  try {
+    const base = new URL(baseUrl);
+    const link = new URL(href, baseUrl);
+    return link.hostname === base.hostname;
+  } catch {
+    return false;
+  }
+}
+function isNavigationLink($el, $) {
+  const parent = $el.parents('nav, header, footer, [role="navigation"], .nav, .navigation, .menu, .sidebar').first();
+  return parent.length > 0;
+}
+function analyzeAnchorText(text) {
+  const normalized = text.toLowerCase().trim();
+  return {
+    isEmpty: normalized.length === 0,
+    isGeneric: GENERIC_ANCHOR_TEXTS.some((g) => normalized === g || normalized.includes(g)),
+    isTooLong: normalized.length > 100
+  };
+}
+function analyzeInternalLinking(html, url) {
+  const $ = cheerio.load(html);
+  const issues = [];
+  const recommendations = [];
+  let score = 100;
+  const linkDetails = [];
+  const anchorTextCounts = {};
+  let totalLinks = 0;
+  let internalLinks = 0;
+  let externalLinks = 0;
+  let navigationLinks = 0;
+  let contentLinks = 0;
+  let linksWithGenericText = 0;
+  let linksWithKeywords = 0;
+  let emptyAnchorLinks = 0;
+  let tooLongAnchorLinks = 0;
+  let imageLinks = 0;
+  const internalTargets = /* @__PURE__ */ new Set();
+  $("a[href]").each((_, el) => {
+    const $link = $(el);
+    const href = $link.attr("href") || "";
+    const text = $link.text().trim();
+    const rel = $link.attr("rel");
+    const title = $link.attr("title");
+    const hasImage = $link.find("img").length > 0;
+    if (href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("javascript:")) {
+      return;
+    }
+    totalLinks++;
+    const linkIssues = [];
+    const isInternal = isInternalUrl(href, url);
+    const isNav = isNavigationLink($link, $);
+    if (isInternal) {
+      internalLinks++;
+      try {
+        const targetUrl = new URL(href, url).pathname;
+        internalTargets.add(targetUrl);
+      } catch {
+      }
+    } else if (href.startsWith("http")) {
+      externalLinks++;
+    }
+    if (isNav) {
+      navigationLinks++;
+    } else {
+      contentLinks++;
+    }
+    const anchorAnalysis = analyzeAnchorText(text);
+    if (hasImage && !text) {
+      imageLinks++;
+      const imgAlt = $link.find("img").attr("alt");
+      if (!imgAlt) {
+        linkIssues.push("Image link without alt text");
+      }
+    } else if (anchorAnalysis.isEmpty) {
+      emptyAnchorLinks++;
+      linkIssues.push("Empty anchor text");
+    } else if (anchorAnalysis.isGeneric) {
+      linksWithGenericText++;
+      linkIssues.push("Generic anchor text");
+    } else {
+      linksWithKeywords++;
+    }
+    if (anchorAnalysis.isTooLong) {
+      tooLongAnchorLinks++;
+      linkIssues.push("Anchor text too long");
+    }
+    if (text) {
+      const normalizedText = text.toLowerCase().substring(0, 50);
+      anchorTextCounts[normalizedText] = (anchorTextCounts[normalizedText] || 0) + 1;
+    }
+    if (isInternal && rel?.includes("nofollow")) {
+      linkIssues.push("nofollow on internal link");
+    }
+    if (isInternal && (rel?.includes("sponsored") || rel?.includes("ugc"))) {
+      linkIssues.push("sponsored/ugc on internal link");
+    }
+    linkDetails.push({
+      href: href.substring(0, 200),
+      text: text.substring(0, 100),
+      isInternal,
+      isNavigation: isNav,
+      rel,
+      title,
+      issues: linkIssues
+    });
+  });
+  const anchorPatterns = Object.entries(anchorTextCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([text, count]) => ({ text, count }));
+  const uniqueInternalTargets = internalTargets.size;
+  const orphanRisk = internalLinks < 3 && contentLinks < 2;
+  if (internalLinks === 0) {
+    issues.push({
+      code: "LINK_NO_INTERNAL",
+      severity: "critical",
+      category: "content",
+      title: "No internal links found",
+      description: "This page has no internal links to other pages on your site.",
+      impact: "Poor link equity distribution, crawlability issues",
+      howToFix: "Add relevant internal links to other pages on your site.",
+      affectedUrls: [url]
+    });
+    score -= 25;
+  } else if (contentLinks === 0 && internalLinks < 5) {
+    issues.push({
+      code: "LINK_LOW_INTERNAL",
+      severity: "warning",
+      category: "content",
+      title: "Very few internal links in content",
+      description: `Only ${internalLinks} internal links found, all in navigation.`,
+      impact: "Limited topic relevance signals",
+      howToFix: "Add contextual internal links within your content.",
+      affectedUrls: [url]
+    });
+    score -= 15;
+  }
+  if (linksWithGenericText > 3) {
+    const percentage = Math.round(linksWithGenericText / totalLinks * 100);
+    issues.push({
+      code: "LINK_GENERIC_ANCHOR",
+      severity: "warning",
+      category: "content",
+      title: `${linksWithGenericText} links with generic anchor text`,
+      description: `${percentage}% of links use non-descriptive text like "click here" or "read more".`,
+      impact: "Missed keyword relevance signals",
+      howToFix: "Replace generic anchors with descriptive, keyword-rich text.",
+      affectedUrls: [url]
+    });
+    score -= Math.min(linksWithGenericText * 2, 15);
+  }
+  if (emptyAnchorLinks > 0) {
+    issues.push({
+      code: "LINK_EMPTY_ANCHOR",
+      severity: "warning",
+      category: "content",
+      title: `${emptyAnchorLinks} links with empty anchor text`,
+      description: "Links without text or alt text are inaccessible and provide no SEO value.",
+      impact: "Accessibility issues, wasted link equity",
+      howToFix: "Add descriptive text or ensure image links have alt text.",
+      affectedUrls: [url]
+    });
+    score -= Math.min(emptyAnchorLinks * 3, 15);
+  }
+  if (orphanRisk) {
+    issues.push({
+      code: "LINK_ORPHAN_RISK",
+      severity: "info",
+      category: "content",
+      title: "Page may be an orphan",
+      description: "This page has very few internal links, which may indicate it's poorly connected in your site structure.",
+      impact: "Difficult for users and crawlers to find",
+      howToFix: "Link to this page from related content and relevant hub pages.",
+      affectedUrls: [url]
+    });
+    score -= 10;
+  }
+  const nofollowInternalLinks = linkDetails.filter((l) => l.isInternal && l.rel?.includes("nofollow"));
+  if (nofollowInternalLinks.length > 0) {
+    issues.push({
+      code: "LINK_NOFOLLOW_INTERNAL",
+      severity: "warning",
+      category: "technical",
+      title: `${nofollowInternalLinks.length} internal links with nofollow`,
+      description: "Internal links should not have nofollow - it wastes PageRank.",
+      impact: "Reduced internal link equity flow",
+      howToFix: "Remove nofollow from internal links.",
+      affectedUrls: [url]
+    });
+    score -= nofollowInternalLinks.length * 3;
+  }
+  if (externalLinks > internalLinks && externalLinks > 10) {
+    issues.push({
+      code: "LINK_EXTERNAL_HEAVY",
+      severity: "info",
+      category: "content",
+      title: "More external links than internal",
+      description: `${externalLinks} external vs ${internalLinks} internal links.`,
+      impact: "May leak PageRank to external sites",
+      howToFix: "Consider adding more internal links or using nofollow/sponsored for some external links.",
+      affectedUrls: [url]
+    });
+  }
+  if (contentLinks < 3 && internalLinks > 0) {
+    recommendations.push("Add 2-3 contextual internal links within your content");
+  }
+  if (linksWithKeywords / Math.max(totalLinks, 1) > 0.7) {
+    recommendations.push("\u2713 Good use of descriptive anchor text");
+  }
+  if (uniqueInternalTargets > 5) {
+    recommendations.push("\u2713 Good diversity of internal link targets");
+  }
+  if (internalLinks > 10) {
+    recommendations.push("Consider creating a hub/pillar page to consolidate topic authority");
+  }
+  return {
+    score: Math.max(0, Math.min(100, score)),
+    totalLinks,
+    internalLinks,
+    externalLinks,
+    navigationLinks,
+    contentLinks,
+    uniqueInternalTargets,
+    linksWithKeywords,
+    linksWithGenericText,
+    orphanRisk,
+    linkDetails,
+    anchorTextAnalysis: {
+      total: totalLinks,
+      descriptive: linksWithKeywords,
+      generic: linksWithGenericText,
+      empty: emptyAnchorLinks,
+      tooLong: tooLongAnchorLinks,
+      imageLinks,
+      patterns: anchorPatterns
+    },
+    issues,
+    recommendations
+  };
+}
+function suggestInternalLinks(content, availablePages) {
+  const suggestions = [];
+  const contentLower = content.toLowerCase();
+  for (const page of availablePages) {
+    for (const keyword of page.keywords) {
+      if (contentLower.includes(keyword.toLowerCase())) {
+        const alreadyLinked = content.includes(`href="${page.url}"`) || content.includes(`href='${page.url}'`);
+        if (!alreadyLinked) {
+          const position = contentLower.indexOf(keyword.toLowerCase());
+          const relevance = keyword.length * 2 + (1e3 - Math.min(position, 1e3)) / 100;
+          suggestions.push({
+            keyword,
+            suggestedUrl: page.url,
+            suggestedTitle: page.title,
+            relevance
+          });
+        }
+      }
+    }
+  }
+  return suggestions.sort((a, b) => b.relevance - a.relevance).filter((s, i, arr) => arr.findIndex((x) => x.suggestedUrl === s.suggestedUrl) === i).slice(0, 10);
+}
+
+export {
+  analyzeInternalLinking,
+  suggestInternalLinks
+};

package/dist/chunk-M27NQCWW.mjs

@@ -0,0 +1,303 @@
+// src/analyzers/mobile-seo-analyzer.ts
+import * as cheerio from "cheerio";
+function analyzeViewport($) {
+  const viewport = $('meta[name="viewport"]');
+  const issues = [];
+  if (viewport.length === 0) {
+    return {
+      hasViewport: false,
+      isResponsive: false,
+      issues: ["No viewport meta tag"]
+    };
+  }
+  const content = viewport.attr("content") || "";
+  const hasWidth = content.includes("width=");
+  const hasDeviceWidth = content.includes("width=device-width");
+  const hasInitialScale = content.includes("initial-scale=");
+  const hasMaximumScale = content.includes("maximum-scale=1");
+  const hasUserScalable = content.includes("user-scalable=no") || content.includes("user-scalable=0");
+  let isResponsive = hasDeviceWidth;
+  if (!hasDeviceWidth) {
+    if (content.includes("width=") && !content.includes("width=device-width")) {
+      issues.push("Fixed viewport width instead of device-width");
+      isResponsive = false;
+    }
+  }
+  if (hasUserScalable || hasMaximumScale) {
+    issues.push("Viewport disables zooming - accessibility issue");
+  }
+  if (!hasInitialScale) {
+    issues.push("Missing initial-scale=1");
+  }
+  return {
+    hasViewport: true,
+    isResponsive,
+    viewportContent: content,
+    issues
+  };
+}
+function analyzeTouchTargets($) {
+  const issues = [];
+  let smallTargets = 0;
+  let properTargets = 0;
+  const interactiveElements = $('a, button, input, select, textarea, [role="button"], [onclick]');
+  interactiveElements.each((_, el) => {
+    const $el = $(el);
+    const style = $el.attr("style") || "";
+    const className = $el.attr("class") || "";
+    const hasSmallClass = /\b(xs|tiny|small|mini)\b/i.test(className);
+    const hasSmallInlineStyle = /(?:width|height)\s*:\s*(?:\d{1,2}(?:px|rem|em)|1\d{2}px)/i.test(style);
+    const hasPadding = /padding/i.test(style) || /\bp-\d|\bpy-\d|\bpx-\d/i.test(className);
+    if (hasSmallClass || hasSmallInlineStyle) {
+      smallTargets++;
+    } else if (hasPadding) {
+      properTargets++;
+    } else {
+      properTargets++;
+    }
+  });
+  if (smallTargets > 5) {
+    issues.push(`${smallTargets} potentially small touch targets`);
+  }
+  return {
+    smallTargets,
+    properTargets,
+    issues
+  };
+}
+function analyzeFontSizes($, html) {
+  const issues = [];
+  let smallFontIndicators = 0;
+  const hasResponsiveFonts = html.includes("@media") && html.includes("font-size") || html.includes("clamp(") || html.includes("vw") || /text-(?:xs|sm|base|lg|xl)/i.test(html);
+  $('[style*="font-size"]').each((_, el) => {
+    const style = $(el).attr("style") || "";
+    const match = style.match(/font-size\s*:\s*(\d+)(px|pt)?/i);
+    if (match) {
+      const size = parseInt(match[1]);
+      const unit = match[2]?.toLowerCase() || "px";
+      if (unit === "px" && size < 12 || unit === "pt" && size < 9) {
+        smallFontIndicators++;
+      }
+    }
+  });
+  const smallFontPatterns = /font-size\s*:\s*(?:[0-9]|1[01])px/gi;
+  const matches = html.match(smallFontPatterns);
+  if (matches) {
+    smallFontIndicators += matches.length;
+  }
+  if (smallFontIndicators > 3) {
+    issues.push(`${smallFontIndicators} instances of small font sizes (<12px)`);
+  }
+  return {
+    hasResponsiveFonts,
+    smallFontIndicators,
+    issues
+  };
+}
+function analyzeContentWidth($, html) {
+  const issues = [];
+  let fixedWidthElements = 0;
+  const hasOverflowHidden = html.includes("overflow-x: hidden") || html.includes("overflow-x:hidden");
+  $('[style*="width"]').each((_, el) => {
+    const style = $(el).attr("style") || "";
+    const widthMatch = style.match(/width\s*:\s*(\d+)(px)?/i);
+    if (widthMatch) {
+      const width = parseInt(widthMatch[1]);
+      if (width > 500 && !style.includes("max-width")) {
+        fixedWidthElements++;
+      }
+    }
+  });
+  const tables = $("table");
+  const responsiveTables = $("table").filter((_, el) => {
+    const parent = $(el).parent();
+    const parentClass = parent.attr("class") || "";
+    const parentStyle = parent.attr("style") || "";
+    return parentClass.includes("overflow") || parentStyle.includes("overflow") || parentClass.includes("responsive");
+  });
+  if (tables.length > responsiveTables.length) {
+    issues.push(`${tables.length - responsiveTables.length} tables without responsive wrapper`);
+    fixedWidthElements += tables.length - responsiveTables.length;
+  }
+  const iframes = $('iframe:not([style*="max-width"])');
+  if (iframes.length > 0) {
+    issues.push(`${iframes.length} iframes may cause horizontal scroll`);
+    fixedWidthElements += iframes.length;
+  }
+  return {
+    hasHorizontalScroll: !hasOverflowHidden && fixedWidthElements > 0,
+    fixedWidthElements,
+    issues
+  };
+}
+function analyzeMobileSpecific($) {
+  const issues = [];
+  const hasAppleTouchIcon = $('link[rel="apple-touch-icon"], link[rel="apple-touch-icon-precomposed"]').length > 0;
+  if (!hasAppleTouchIcon) {
+    issues.push("Missing apple-touch-icon");
+  }
+  const hasThemeColor = $('meta[name="theme-color"]').length > 0;
+  if (!hasThemeColor) {
+    issues.push("Missing theme-color meta tag");
+  }
+  const hasManifest = $('link[rel="manifest"]').length > 0;
+  if (!hasManifest) {
+    issues.push("Missing web app manifest");
+  }
+  const responsiveImages = $("img[srcset], picture source[srcset]").length;
+  const totalImages = $("img").length;
+  const hasMobileOptimizedImages = responsiveImages > 0 || totalImages === 0;
+  if (totalImages > 0 && responsiveImages === 0) {
+    issues.push("No responsive images (srcset)");
+  }
+  const popupIndicators = $('[class*="popup"], [class*="modal"], [class*="overlay"], [id*="popup"], [id*="modal"]');
+  const hasPopupTriggers = $("[data-popup], [data-modal], .popup-trigger, .modal-trigger").length > 0;
+  const avoidsMobilePopups = popupIndicators.filter((_, el) => {
+    const style = $(el).attr("style") || "";
+    return style.includes("display: block") || style.includes("display:block");
+  }).length === 0;
+  return {
+    hasAppleTouchIcon,
+    hasThemeColor,
+    hasManifest,
+    hasMobileOptimizedImages,
+    avoidsMobilePopups,
+    issues
+  };
+}
+function analyzeMobileSEO(html, url) {
+  const $ = cheerio.load(html);
+  const issues = [];
+  const recommendations = [];
+  let score = 100;
+  const viewport = analyzeViewport($);
+  const touchTargets = analyzeTouchTargets($);
+  const fontSizes = analyzeFontSizes($, html);
+  const contentWidth = analyzeContentWidth($, html);
+  const mobileSpecific = analyzeMobileSpecific($);
+  if (!viewport.hasViewport) {
+    issues.push({
+      code: "MOBILE_NO_VIEWPORT",
+      severity: "critical",
+      category: "technical",
+      title: "Missing viewport meta tag",
+      description: "The page lacks a viewport meta tag, critical for mobile rendering.",
+      impact: "Page will not render properly on mobile devices",
+      howToFix: 'Add <meta name="viewport" content="width=device-width, initial-scale=1">',
+      affectedUrls: [url]
+    });
+    score -= 30;
+  } else if (!viewport.isResponsive) {
+    issues.push({
+      code: "MOBILE_FIXED_VIEWPORT",
+      severity: "warning",
+      category: "technical",
+      title: "Non-responsive viewport",
+      description: viewport.issues.join(". "),
+      impact: "Page may not scale properly on all devices",
+      howToFix: "Use width=device-width instead of fixed width",
+      affectedUrls: [url]
+    });
+    score -= 15;
+  }
+  if (viewport.issues.includes("Viewport disables zooming - accessibility issue")) {
+    issues.push({
+      code: "MOBILE_ZOOM_DISABLED",
+      severity: "warning",
+      category: "technical",
+      title: "Pinch-to-zoom disabled",
+      description: "The viewport prevents users from zooming, which is an accessibility violation.",
+      impact: "Fails WCAG accessibility guidelines",
+      howToFix: "Remove maximum-scale=1 and user-scalable=no from viewport",
+      affectedUrls: [url]
+    });
+    score -= 10;
+  }
+  if (touchTargets.smallTargets > 5) {
+    issues.push({
+      code: "MOBILE_SMALL_TOUCH_TARGETS",
+      severity: "warning",
+      category: "technical",
+      title: `${touchTargets.smallTargets} small touch targets`,
+      description: "Interactive elements may be too small to tap easily on mobile.",
+      impact: "Poor mobile usability, user frustration",
+      howToFix: "Ensure touch targets are at least 48x48px with adequate spacing",
+      affectedUrls: [url]
+    });
+    score -= Math.min(touchTargets.smallTargets * 2, 15);
+  }
+  if (fontSizes.smallFontIndicators > 3) {
+    issues.push({
+      code: "MOBILE_SMALL_FONTS",
+      severity: "warning",
+      category: "technical",
+      title: "Small font sizes detected",
+      description: `${fontSizes.smallFontIndicators} instances of fonts smaller than 12px.`,
+      impact: "Text difficult to read on mobile without zooming",
+      howToFix: "Use minimum 16px for body text, 12px absolute minimum",
+      affectedUrls: [url]
+    });
+    score -= 10;
+  }
+  if (contentWidth.fixedWidthElements > 2) {
+    issues.push({
+      code: "MOBILE_HORIZONTAL_SCROLL",
+      severity: "warning",
+      category: "technical",
+      title: "Content wider than screen",
+      description: `${contentWidth.fixedWidthElements} elements may cause horizontal scrolling.`,
+      impact: "Horizontal scrolling is frustrating on mobile",
+      howToFix: "Use max-width: 100% and avoid fixed widths >320px",
+      affectedUrls: [url]
+    });
+    score -= Math.min(contentWidth.fixedWidthElements * 3, 15);
+  }
+  if (!mobileSpecific.hasManifest) {
+    issues.push({
+      code: "MOBILE_NO_MANIFEST",
+      severity: "info",
+      category: "technical",
+      title: "Missing web app manifest",
+      description: "No manifest.json linked for PWA capabilities.",
+      impact: "Cannot be installed as PWA",
+      howToFix: 'Add <link rel="manifest" href="/manifest.json">',
+      affectedUrls: [url]
+    });
+    score -= 5;
+  }
+  if (!mobileSpecific.hasThemeColor) {
+    recommendations.push("Add theme-color meta tag for mobile browser UI customization");
+    score -= 2;
+  }
+  if (!mobileSpecific.hasAppleTouchIcon) {
+    recommendations.push("Add apple-touch-icon for iOS home screen");
+    score -= 2;
+  }
+  if (!mobileSpecific.hasMobileOptimizedImages) {
+    recommendations.push("Use srcset for responsive images");
+    score -= 5;
+  }
+  if (viewport.hasViewport && viewport.isResponsive && viewport.issues.length === 0) {
+    recommendations.push("\u2713 Proper responsive viewport configuration");
+  }
+  if (fontSizes.hasResponsiveFonts) {
+    recommendations.push("\u2713 Responsive font sizing detected");
+  }
+  if (mobileSpecific.hasManifest && mobileSpecific.hasAppleTouchIcon && mobileSpecific.hasThemeColor) {
+    recommendations.push("\u2713 Good PWA/mobile app configuration");
+  }
+  return {
+    score: Math.max(0, Math.min(100, score)),
+    viewport,
+    touchTargets,
+    fontSizes,
+    contentWidth,
+    mobileSpecific,
+    issues,
+    recommendations
+  };
+}
+
+export {
+  analyzeMobileSEO
+};

package/dist/{chunk-YNZYHEYM.mjs → chunk-PJLNXOLN.mjs}

@@ -1,15 +1,3 @@
-var __defProp = Object.defineProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/utils/http.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_USER_AGENT = "RankCLI/1.0 (+https://rankcli.dev)";
@@ -757,8 +745,6 @@ function generateRecommendations(issues) {
 }
 
 export {
-  __require,
-  __export,
   httpGet,
   httpHead,
   httpPost,