@rankcli/agent-runtime 0.0.1

package/src/audit/checks/asset-minification.ts

@@ -0,0 +1,270 @@
+/**
+ * Asset Minification Check
+ *
+ * Checks if CSS and JavaScript files are properly minified.
+ * Unminified files contain unnecessary whitespace, comments, and long variable names
+ * that increase file size and slow down page load times.
+ *
+ * Detection methods:
+ * - Whitespace ratio (minified files have very low whitespace)
+ * - Average line length (minified files have very long lines)
+ * - Comment presence (minified files have no comments)
+ */
+
+import { httpGet } from '../../utils/http.js';
+import * as cheerio from 'cheerio';
+import type { AuditIssue } from '../types.js';
+
+export interface MinificationData {
+  cssFiles: AssetMinificationInfo[];
+  jsFiles: AssetMinificationInfo[];
+  totalCssFiles: number;
+  totalJsFiles: number;
+  unminifiedCss: number;
+  unminifiedJs: number;
+  potentialSavings: {
+    css: number; // estimated bytes
+    js: number;
+  };
+}
+
+interface AssetMinificationInfo {
+  url: string;
+  size: number;
+  isMinified: boolean;
+  indicators: {
+    avgLineLength: number;
+    whitespaceRatio: number;
+    hasComments: boolean;
+  };
+}
+
+/**
+ * Detect if content is minified
+ */
+function isMinified(content: string, type: 'css' | 'js'): { isMinified: boolean; indicators: AssetMinificationInfo['indicators'] } {
+  const lines = content.split('\n');
+  const totalLines = lines.length;
+  const avgLineLength = totalLines > 0 ? content.length / totalLines : 0;
+
+  // Count whitespace characters (spaces, tabs, newlines)
+  const whitespaceCount = (content.match(/\s/g) || []).length;
+  const whitespaceRatio = content.length > 0 ? whitespaceCount / content.length : 0;
+
+  // Check for comments
+  let hasComments = false;
+  if (type === 'css') {
+    // CSS comments: /* ... */
+    hasComments = /\/\*[\s\S]*?\*\//.test(content);
+  } else {
+    // JS comments: // ... or /* ... */
+    hasComments = /\/\/[^\n]*|\/\*[\s\S]*?\*\//.test(content);
+  }
+
+  // Minification indicators:
+  // - Average line length > 500 chars (minified = long lines)
+  // - Whitespace ratio < 10% (minified = little whitespace)
+  // - No comments
+  const isMinifiedByLineLength = avgLineLength > 500;
+  const isMinifiedByWhitespace = whitespaceRatio < 0.1;
+  const isMinifiedByComments = !hasComments;
+
+  // Consider minified if at least 2 of 3 indicators pass
+  // OR if single-line file with reasonable length (common for small minified files)
+  const score = (isMinifiedByLineLength ? 1 : 0) + (isMinifiedByWhitespace ? 1 : 0) + (isMinifiedByComments ? 1 : 0);
+  const isSingleLineMinified = totalLines <= 2 && avgLineLength > 100;
+
+  return {
+    isMinified: score >= 2 || isSingleLineMinified,
+    indicators: {
+      avgLineLength: Math.round(avgLineLength),
+      whitespaceRatio: Math.round(whitespaceRatio * 100) / 100,
+      hasComments,
+    },
+  };
+}
+
+/**
+ * Extract asset URLs from HTML
+ */
+function extractAssetUrls(html: string, baseUrl: string): { css: string[]; js: string[] } {
+  const $ = cheerio.load(html);
+  const base = new URL(baseUrl);
+  const css: string[] = [];
+  const js: string[] = [];
+
+  // Extract CSS files
+  $('link[rel="stylesheet"][href]').each((_, el) => {
+    const href = $(el).attr('href');
+    if (href && !href.startsWith('data:')) {
+      try {
+        const fullUrl = new URL(href, base).href;
+        // Only check first-party CSS
+        if (new URL(fullUrl).hostname === base.hostname) {
+          css.push(fullUrl);
+        }
+      } catch {
+        // Invalid URL
+      }
+    }
+  });
+
+  // Extract JS files
+  $('script[src]').each((_, el) => {
+    const src = $(el).attr('src');
+    if (src && !src.startsWith('data:')) {
+      try {
+        const fullUrl = new URL(src, base).href;
+        // Only check first-party JS
+        if (new URL(fullUrl).hostname === base.hostname) {
+          js.push(fullUrl);
+        }
+      } catch {
+        // Invalid URL
+      }
+    }
+  });
+
+  return { css, js };
+}
+
+/**
+ * Analyze asset minification
+ */
+export async function analyzeAssetMinification(
+  html: string,
+  url: string
+): Promise<{ issues: AuditIssue[]; data: MinificationData }> {
+  const issues: AuditIssue[] = [];
+  const assetUrls = extractAssetUrls(html, url);
+
+  const cssFiles: AssetMinificationInfo[] = [];
+  const jsFiles: AssetMinificationInfo[] = [];
+
+  // Check CSS files (limit to 3, parallel with short timeout)
+  const cssToCheck = assetUrls.css.slice(0, 3);
+  const cssPromises = cssToCheck.map(async (cssUrl) => {
+    try {
+      const response = await httpGet<string>(cssUrl, {
+        timeout: 3000, // Reduced timeout
+        validateStatus: () => true,
+      });
+
+      if (response.status === 200 && typeof response.data === 'string') {
+        const content = response.data;
+        const { isMinified: minified, indicators } = isMinified(content, 'css');
+
+        cssFiles.push({
+          url: cssUrl,
+          size: content.length,
+          isMinified: minified,
+          indicators,
+        });
+      }
+    } catch {
+      // Skip failed requests
+    }
+  });
+
+  // Check JS files (limit to 3, parallel with short timeout)
+  const jsToCheck = assetUrls.js.slice(0, 3);
+  const jsPromises = jsToCheck.map(async (jsUrl) => {
+    try {
+      const response = await httpGet<string>(jsUrl, {
+        timeout: 3000, // Reduced timeout
+        validateStatus: () => true,
+      });
+
+      if (response.status === 200 && typeof response.data === 'string') {
+        const content = response.data;
+        const { isMinified: minified, indicators } = isMinified(content, 'js');
+
+        jsFiles.push({
+          url: jsUrl,
+          size: content.length,
+          isMinified: minified,
+          indicators,
+        });
+      }
+    } catch {
+      // Skip failed requests
+    }
+  });
+
+  // Run all checks in parallel with overall timeout
+  await Promise.race([
+    Promise.all([...cssPromises, ...jsPromises]),
+    new Promise<void>((resolve) => setTimeout(resolve, 8000)), // 8s overall timeout
+  ]);
+
+  // Count unminified files
+  const unminifiedCss = cssFiles.filter((f) => !f.isMinified);
+  const unminifiedJs = jsFiles.filter((f) => !f.isMinified);
+
+  // Estimate potential savings (minification typically saves 30-50%)
+  const cssSavings = unminifiedCss.reduce((sum, f) => sum + Math.round(f.size * 0.4), 0);
+  const jsSavings = unminifiedJs.reduce((sum, f) => sum + Math.round(f.size * 0.4), 0);
+
+  // Generate issues
+  if (unminifiedCss.length > 0) {
+    issues.push({
+      code: 'CSS_NOT_MINIFIED',
+      severity: 'warning',
+      category: 'performance',
+      title: 'CSS files not minified',
+      description: `${unminifiedCss.length} CSS file(s) appear to not be minified. Minification removes whitespace and comments to reduce file size.`,
+      impact: `Unminified CSS increases page load time. Potential savings: ~${Math.round(cssSavings / 1024)}KB.`,
+      howToFix:
+        'Use a CSS minifier like cssnano, clean-css, or build tools (Vite, Webpack) to minify CSS files. Most bundlers do this automatically in production builds.',
+      affectedUrls: unminifiedCss.map((f) => f.url),
+      details: {
+        files: unminifiedCss.map((f) => ({
+          url: f.url,
+          size: `${Math.round(f.size / 1024)}KB`,
+          avgLineLength: f.indicators.avgLineLength,
+          whitespaceRatio: `${Math.round(f.indicators.whitespaceRatio * 100)}%`,
+          hasComments: f.indicators.hasComments,
+        })),
+      },
+    });
+  }
+
+  if (unminifiedJs.length > 0) {
+    issues.push({
+      code: 'JS_NOT_MINIFIED',
+      severity: 'warning',
+      category: 'performance',
+      title: 'JavaScript files not minified',
+      description: `${unminifiedJs.length} JavaScript file(s) appear to not be minified. Minification removes whitespace, comments, and shortens variable names.`,
+      impact: `Unminified JavaScript increases page load time and parsing time. Potential savings: ~${Math.round(jsSavings / 1024)}KB.`,
+      howToFix:
+        'Use a JS minifier like Terser, UglifyJS, or build tools (Vite, Webpack, esbuild) to minify JavaScript. Most bundlers do this automatically in production builds.',
+      affectedUrls: unminifiedJs.map((f) => f.url),
+      details: {
+        files: unminifiedJs.map((f) => ({
+          url: f.url,
+          size: `${Math.round(f.size / 1024)}KB`,
+          avgLineLength: f.indicators.avgLineLength,
+          whitespaceRatio: `${Math.round(f.indicators.whitespaceRatio * 100)}%`,
+          hasComments: f.indicators.hasComments,
+        })),
+      },
+    });
+  }
+
+  return {
+    issues,
+    data: {
+      cssFiles,
+      jsFiles,
+      totalCssFiles: assetUrls.css.length,
+      totalJsFiles: assetUrls.js.length,
+      unminifiedCss: unminifiedCss.length,
+      unminifiedJs: unminifiedJs.length,
+      potentialSavings: {
+        css: cssSavings,
+        js: jsSavings,
+      },
+    },
+  };
+}

package/src/audit/checks/bing-optimization.ts

@@ -0,0 +1,206 @@
+/**
+ * Bing Optimization Checks
+ *
+ * ChatGPT Search uses Bing's index, making Bing optimization crucial for AI search visibility.
+ * These checks verify Bing-specific optimizations that improve AI search presence.
+ */
+
+import * as cheerio from 'cheerio';
+import { httpGet } from '../../utils/http.js';
+import type { AuditIssue } from '../types.js';
+
+export interface BingOptimizationData {
+  hasBingSiteAuth: boolean;
+  hasBingMetaTag: boolean;
+  hasBingIndexNowKey: boolean;
+  bingPlacesDetected: boolean;
+  bingSitemapAccessible: boolean;
+  issues: string[];
+}
+
+export async function analyzeBingOptimization(
+  html: string,
+  url: string
+): Promise<{ issues: AuditIssue[]; data: BingOptimizationData }> {
+  const issues: AuditIssue[] = [];
+  const $ = cheerio.load(html);
+  const parsedUrl = new URL(url);
+  const baseUrl = `${parsedUrl.protocol}//${parsedUrl.hostname}`;
+  const detectedIssues: string[] = [];
+
+  // Check for Bing site verification meta tag
+  const bingMetaTag = $('meta[name="msvalidate.01"]').attr('content');
+  const hasBingMetaTag = !!bingMetaTag && bingMetaTag.length > 0;
+
+  // Check for BingSiteAuth.xml
+  let hasBingSiteAuth = false;
+  try {
+    const authResponse = await httpGet(`${baseUrl}/BingSiteAuth.xml`, { timeout: 5000 });
+    hasBingSiteAuth = authResponse.status === 200 &&
+      authResponse.data.includes('<?xml') &&
+      authResponse.data.toLowerCase().includes('users');
+  } catch {
+    // File doesn't exist or not accessible
+  }
+
+  // Check for IndexNow key file (used by Bing)
+  let hasBingIndexNowKey = false;
+  try {
+    // Common IndexNow key file patterns
+    const keyPatterns = [
+      `${baseUrl}/indexnow.txt`,
+      `${baseUrl}/.well-known/indexnow`,
+    ];
+
+    for (const keyUrl of keyPatterns) {
+      try {
+        const keyResponse = await httpGet(keyUrl, { timeout: 5000 });
+        if (keyResponse.status === 200 && keyResponse.data.length >= 8) {
+          hasBingIndexNowKey = true;
+          break;
+        }
+      } catch {
+        // Continue checking other patterns
+      }
+    }
+  } catch {
+    // IndexNow key not found
+  }
+
+  // Check for Bing Places indicators in structured data
+  const scripts = $('script[type="application/ld+json"]');
+  let bingPlacesDetected = false;
+
+  scripts.each((_, el) => {
+    try {
+      const jsonText = $(el).html();
+      if (jsonText) {
+        const data = JSON.parse(jsonText);
+        const schemas = Array.isArray(data) ? data : [data];
+
+        for (const schema of schemas) {
+          // Check for LocalBusiness or Organization with address
+          if (schema['@type'] === 'LocalBusiness' ||
+              (schema['@type'] === 'Organization' && schema.address)) {
+            bingPlacesDetected = true;
+          }
+
+          // Check sameAs for Bing Places URL
+          if (schema.sameAs) {
+            const sameAsUrls = Array.isArray(schema.sameAs) ? schema.sameAs : [schema.sameAs];
+            if (sameAsUrls.some((u: string) => u.includes('bing.com/maps'))) {
+              bingPlacesDetected = true;
+            }
+          }
+        }
+      }
+    } catch {
+      // Invalid JSON
+    }
+  });
+
+  // Check if sitemap is accessible (important for Bing indexing)
+  let bingSitemapAccessible = false;
+  try {
+    const sitemapResponse = await httpGet(`${baseUrl}/sitemap.xml`, { timeout: 5000 });
+    bingSitemapAccessible = sitemapResponse.status === 200 &&
+      sitemapResponse.data.includes('<?xml');
+  } catch {
+    // Sitemap not accessible
+  }
+
+  // Generate issues
+
+  // No Bing verification
+  if (!hasBingMetaTag && !hasBingSiteAuth) {
+    detectedIssues.push('No Bing site verification');
+    issues.push({
+      code: 'BING_NOT_VERIFIED',
+      severity: 'warning',
+      category: 'ai-readiness',
+      title: 'Site not verified with Bing Webmaster Tools',
+      description: 'ChatGPT Search uses Bing\'s index. Verifying your site with Bing Webmaster Tools ensures proper indexing and access to Bing-specific SEO tools.',
+      impact: 'May reduce visibility in ChatGPT Search results and miss Bing-specific optimization opportunities.',
+      howToFix: 'Add Bing verification: 1) Go to Bing Webmaster Tools, 2) Add your site, 3) Choose verification method (meta tag or XML file), 4) Add the verification code to your site.',
+      affectedUrls: [url],
+      details: {
+        hasBingMetaTag,
+        hasBingSiteAuth,
+        verificationMethods: [
+          'Add <meta name="msvalidate.01" content="YOUR_CODE"> to <head>',
+          'Upload BingSiteAuth.xml to root directory',
+        ],
+      },
+    });
+  }
+
+  // No IndexNow for Bing
+  if (!hasBingIndexNowKey) {
+    detectedIssues.push('No IndexNow key for Bing');
+    issues.push({
+      code: 'BING_NO_INDEXNOW',
+      severity: 'notice',
+      category: 'ai-readiness',
+      title: 'IndexNow not configured for Bing instant indexing',
+      description: 'IndexNow enables instant content indexing by Bing (and subsequently ChatGPT Search). Without it, new content may take longer to appear in AI search results.',
+      impact: 'Content updates may be delayed in Bing\'s index and ChatGPT Search results.',
+      howToFix: 'Implement IndexNow: 1) Generate an API key, 2) Host the key file at /indexnow.txt or /.well-known/indexnow, 3) Notify Bing of URL changes via the IndexNow API.',
+      affectedUrls: [url],
+      details: {
+        indexNowEndpoint: 'https://www.bing.com/indexnow',
+        documentation: 'https://www.indexnow.org/documentation',
+      },
+    });
+  }
+
+  // No sitemap for Bing
+  if (!bingSitemapAccessible) {
+    detectedIssues.push('Sitemap not accessible');
+    issues.push({
+      code: 'BING_SITEMAP_MISSING',
+      severity: 'warning',
+      category: 'ai-readiness',
+      title: 'XML sitemap not accessible for Bing crawling',
+      description: 'A sitemap helps Bing discover and index all your pages. Without it, some content may not be indexed and thus not appear in ChatGPT Search.',
+      impact: 'Bing may miss important pages, reducing your AI search coverage.',
+      howToFix: 'Create and submit an XML sitemap: 1) Generate sitemap.xml with all important URLs, 2) Submit it in Bing Webmaster Tools, 3) Reference it in robots.txt.',
+      affectedUrls: [url],
+    });
+  }
+
+  // Local business without Bing Places
+  const hasLocalBusinessSchema = bingPlacesDetected;
+  const hasAddressOnPage = $('address').length > 0 ||
+    html.toLowerCase().includes('street') ||
+    /\d{5}(-\d{4})?/.test(html); // ZIP code pattern
+
+  if (hasAddressOnPage && !hasLocalBusinessSchema) {
+    detectedIssues.push('Local business may not be on Bing Places');
+    issues.push({
+      code: 'BING_PLACES_MISSING',
+      severity: 'notice',
+      category: 'ai-readiness',
+      title: 'Local business not optimized for Bing Places',
+      description: 'Your site appears to have a physical location but may not be listed on Bing Places. Bing Places listings appear in Bing Maps and can be referenced by AI assistants.',
+      impact: 'Missing local search visibility in Bing and potential AI assistant recommendations for local queries.',
+      howToFix: 'Claim your Bing Places listing: 1) Go to bingplaces.com, 2) Claim or add your business, 3) Verify ownership, 4) Add complete business information.',
+      affectedUrls: [url],
+      details: {
+        bingPlacesUrl: 'https://www.bingplaces.com/',
+        recommendation: 'Also add sameAs link to your Bing Places listing in Organization schema',
+      },
+    });
+  }
+
+  return {
+    issues,
+    data: {
+      hasBingSiteAuth,
+      hasBingMetaTag,
+      hasBingIndexNowKey,
+      bingPlacesDetected,
+      bingSitemapAccessible,
+      issues: detectedIssues,
+    },
+  };
+}