gsc-cli 2.0.2 → 2.2.0

data/lib/gsc/network_tracer.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'set'
+
+module GSC
+  class NetworkTracer
+    attr_reader :start_url, :max_hops
+
+    def initialize(start_url, max_hops: 10)
+      @start_url = start_url.to_s.strip
+      @start_url = "http://#{@start_url}" unless @start_url =~ %r{^https?://}
+      @max_hops = max_hops
+    end
+
+    def trace
+      current_url = @start_url
+      hops = []
+      visited = Set.new
+
+      @max_hops.times do |hop_idx|
+        break if visited.include?(current_url)
+        visited << current_url
+
+        uri = URI.parse(current_url) rescue nil
+        break unless uri && uri.host
+
+        start_t = Time.now
+        res = nil
+
+        begin
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: (uri.scheme == 'https'), open_timeout: 5, read_timeout: 10) do |http|
+            req = Net::HTTP::Get.new(uri.request_uri)
+            req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) gsc-cli/2.1'
+            res = http.request(req)
+          end
+        rescue StandardError => e
+          hops << {
+            hop: hop_idx + 1,
+            url: current_url,
+            error: e.message
+          }
+          break
+        end
+
+        duration_ms = ((Time.now - start_t) * 1000).round(1)
+        status_code = res.code.to_i
+        location = res['location']
+
+        hop_info = {
+          hop: hop_idx + 1,
+          url: current_url,
+          status_code: status_code,
+          duration_ms: duration_ms,
+          x_robots_tag: res['x-robots-tag'],
+          canonical_header: res['link'] =~ /rel="canonical"/i ? res['link'] : nil,
+          hsts: res['strict-transport-security'],
+          content_type: res['content-type'],
+          server: res['server']
+        }
+
+        hops << hop_info
+
+        if [301, 302, 303, 307, 308].include?(status_code) && location
+          next_url = begin
+                       URI.join(current_url, location.strip).to_s
+                     rescue StandardError
+                       nil
+                     end
+          break unless next_url
+          current_url = next_url
+        else
+          break
+        end
+      end
+
+      total_time = hops.sum { |h| h[:duration_ms] || 0 }.round(1)
+      final_hop = hops.last || {}
+      is_redirect_chain = hops.length > 2
+
+      {
+        start_url: @start_url,
+        final_url: final_hop[:url],
+        total_hops: hops.length,
+        total_duration_ms: total_time,
+        is_redirect_chain: is_redirect_chain,
+        hops: hops
+      }
+    end
+  end
+end

data/lib/gsc/open_page_rank.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module GSC
+  class OpenPageRank
+    API_URL = 'https://openpagerank.com/api/v1.0/getPageRank'
+
+    attr_reader :api_key
+
+    def initialize(api_key = nil)
+      @api_key = api_key || ENV['OPENPAGERANK_API_KEY'] || GSC::Config.get('opr_api_key')
+    end
+
+    def configured?
+      !@api_key.nil? && !@api_key.strip.empty?
+    end
+
+    def check_domains(domains)
+      domains = Array(domains).map { |d| clean_domain(d) }.reject(&:empty?).uniq
+      return { error: 'No valid domains provided' } if domains.empty?
+      return { error: 'OpenPageRank API key not configured. Set via `gsc config set opr_api_key <key>` or OPENPAGERANK_API_KEY env (Get free 300k calls/mo at openpagerank.com)' } unless configured?
+
+      # Construct query params: domains[0]=a.com&domains[1]=b.com
+      params = domains.map.with_index { |d, idx| "domains%5B#{idx}%5D=#{URI.encode_www_form_component(d)}" }.join('&')
+      uri = URI("#{API_URL}?#{params}")
+
+      req = Net::HTTP::Get.new(uri)
+      req['API-OPR'] = @api_key
+      req['User-Agent'] = 'gsc-cli/2.1'
+
+      res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: 5, read_timeout: 15) do |http|
+        http.request(req)
+      end
+
+      if res.code == '200'
+        data = JSON.parse(res.body)
+        records = (data['response'] || []).map do |r|
+          {
+            domain: r['domain'],
+            page_rank_decimal: r['page_rank_decimal'] || 0.0,
+            page_rank_integer: r['page_rank_integer'] || 0,
+            rank: r['rank'],
+            status_code: r['status_code']
+          }
+        end
+        {
+          status: 'success',
+          status_code: data['status_code'],
+          records: records
+        }
+      else
+        {
+          status: 'error',
+          code: res.code.to_i,
+          message: res.body
+        }
+      end
+    rescue StandardError => e
+      { status: 'error', message: e.message }
+    end
+
+    def clean_domain(input)
+      d = input.to_s.strip.downcase
+      d = d.sub(%r{^https?://}, '').sub(%r{/.*$}, '').sub(/^www\./, '')
+      d
+    end
+  end
+end

data/lib/gsc/page_analyzer.rb

@@ -76,9 +76,28 @@ module GSC
       canonical_url = extract_link_attr(doc, 'canonical', 'href')
       robots_meta = extract_meta_content(doc, 'name', 'robots')
 
-      # 2. Detailed Headings Structure
-      headings = extract_headings(doc)
-      h1_list = headings.select { |h| h[:tag] == 'h1' }
+      # 2. Detailed Headings Structure & Hierarchy Depth
+      heading_audit = if defined?(HeadingValidator)
+                        HeadingValidator.analyze(doc, target_keywords: title_raw)
+                      else
+                        h_list = extract_headings(doc)
+                        h1_found = h_list.select { |h| h[:tag] == 'h1' }
+                        {
+                          score: h1_found.size == 1 ? 100 : 70,
+                          grade: h1_found.size == 1 ? 'A' : 'C',
+                          depth: h_list.map { |h| h[:tag][1].to_i }.max || 0,
+                          count: h_list.size,
+                          counts: h_list.group_by { |h| h[:tag] }.transform_values(&:size),
+                          h1_count: h1_found.size,
+                          empty_count: 0,
+                          headings: h_list,
+                          violations: [],
+                          ascii_tree: '',
+                          color_tree: ''
+                        }
+                      end
+      headings = heading_audit[:headings]
+      h1_list = headings.select { |h| h[:tag] == 'h1' && !h[:empty] }
 
       # 3. Images & Missing Alt Tags
       images_data = extract_images(doc)
@@ -123,8 +142,19 @@ module GSC
       issues << { level: :warn, type: :title, message: "Title > 568px width (~#{title_pixel_est}px, risks SERP truncation)" } if title_pixel_est > 568.0
       issues << { level: :warn, type: :meta, message: "Missing meta description" } if meta_desc.nil? || meta_desc.empty?
       issues << { level: :warn, type: :meta, message: "Meta description > 155 chars (#{meta_desc.length}c)" } if meta_desc && meta_desc.length > 155
-      issues << { level: :error, type: :headings, message: "Missing <h1> tag (0 found)" } if h1_list.empty?
-      issues << { level: :warn, type: :headings, message: "Multiple <h1> tags (#{h1_list.size} found)" } if h1_list.size > 1
+      if heading_audit[:violations] && !heading_audit[:violations].empty?
+        heading_audit[:violations].each do |v|
+          lvl = case v[:severity]
+                when :critical then :error
+                when :warning then :warn
+                else :info
+                end
+          issues << { level: lvl, type: :headings, message: v[:message] }
+        end
+      else
+        issues << { level: :error, type: :headings, message: "Missing <h1> tag (0 found)" } if h1_list.empty?
+        issues << { level: :warn, type: :headings, message: "Multiple <h1> tags (#{h1_list.size} found)" } if h1_list.size > 1
+      end
       issues << { level: :warn, type: :images, message: "#{images_data[:missing_alt_count]} images missing alt tags" } if images_data[:missing_alt_count] > 0
       issues << { level: :critical, type: :indexability, message: "Robots noindex tag detected (Blocking Googlebot)" } if noindex
 
@@ -155,13 +185,23 @@ module GSC
           self_referencing: canonical_url ? (canonical_url.chomp('/') == @url.chomp('/')) : false
         },
         headings: {
-          count: headings.size,
-          h1_count: h1_list.size,
+          count: heading_audit[:count],
+          h1_count: heading_audit[:h1_count],
+          score: heading_audit[:score],
+          grade: heading_audit[:grade],
+          depth: heading_audit[:depth],
+          counts: heading_audit[:counts],
+          empty_count: heading_audit[:empty_count],
+          violations: heading_audit[:violations],
+          ascii_tree: heading_audit[:ascii_tree],
+          color_tree: heading_audit[:color_tree],
+          keyword_analysis: heading_audit[:keyword_analysis],
           list: headings
         },
         images: images_data,
         links: links_data,
         schema: schemas,
+        structured_data: { schemas: schemas },
         social: { og: og_data, twitter: twitter_data },
         stats: { word_count: word_count, reading_time_mins: reading_time_mins },
         issues: issues

data/lib/gsc/page_comparator.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module GSC
+  class PageComparator
+    attr_reader :url1, :url2, :data1, :data2
+
+    def initialize(url1, url2)
+      @url1 = url1
+      @url2 = url2
+    end
+
+    def compare
+      pa1 = GSC::PageAnalyzer.new(@url1)
+      pa2 = GSC::PageAnalyzer.new(@url2)
+
+      @data1 = pa1.fetch_and_analyze
+      @data2 = pa2.fetch_and_analyze
+
+      diffs = {
+        meta: compare_meta,
+        headings: compare_headings,
+        images: compare_images,
+        links: compare_links,
+        performance: compare_perf,
+        structured_data: compare_schema
+      }
+
+      {
+        page1: { url: @url1, status: @data1[:http_status] },
+        page2: { url: @url2, status: @data2[:http_status] },
+        comparison: diffs
+      }
+    end
+
+    private
+
+    def compare_meta
+      t1 = @data1.dig(:title, :text) || ''
+      t2 = @data2.dig(:title, :text) || ''
+      m1 = @data1.dig(:meta_description, :text) || ''
+      m2 = @data2.dig(:meta_description, :text) || ''
+
+      {
+        title: {
+          page1: { text: t1, length: t1.length, optimal: t1.length.between?(30, 60) },
+          page2: { text: t2, length: t2.length, optimal: t2.length.between?(30, 60) }
+        },
+        meta_description: {
+          page1: { text: m1, length: m1.length, optimal: m1.length.between?(70, 155) },
+          page2: { text: m2, length: m2.length, optimal: m2.length.between?(70, 155) }
+        }
+      }
+    end
+
+    def compare_headings
+      h1_1 = @data1.dig(:headings, :h1) || []
+      h1_2 = @data2.dig(:headings, :h1) || []
+      h2_1 = @data1.dig(:headings, :h2) || []
+      h2_2 = @data2.dig(:headings, :h2) || []
+
+      {
+        h1_count: { page1: h1_1.length, page2: h1_2.length },
+        h1_text: { page1: h1_1.first, page2: h1_2.first },
+        h2_count: { page1: h2_1.length, page2: h2_2.length }
+      }
+    end
+
+    def compare_images
+      img1 = @data1[:images] || {}
+      img2 = @data2[:images] || {}
+
+      {
+        total_images: { page1: img1[:total] || 0, page2: img2[:total] || 0 },
+        missing_alt: { page1: img1[:missing_alt] || 0, page2: img2[:missing_alt] || 0 }
+      }
+    end
+
+    def compare_links
+      l1 = @data1[:links] || {}
+      l2 = @data2[:links] || {}
+
+      {
+        internal: { page1: l1[:internal_count] || 0, page2: l2[:internal_count] || 0 },
+        external: { page1: l1[:external_count] || 0, page2: l2[:external_count] || 0 }
+      }
+    end
+
+    def compare_perf
+      {
+        response_time_ms: { page1: @data1[:response_time_ms], page2: @data2[:response_time_ms] }
+      }
+    end
+
+    def compare_schema
+      s1 = @data1.dig(:structured_data, :schemas) || []
+      s2 = @data2.dig(:structured_data, :schemas) || []
+
+      types1 = s1.map { |s| s['@type'] }.compact
+      types2 = s2.map { |s| s['@type'] }.compact
+
+      {
+        schema_count: { page1: s1.length, page2: s2.length },
+        schema_types: { page1: types1, page2: types2 }
+      }
+    end
+  end
+end

data/lib/gsc/page_speed.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module GSC
+  class PageSpeed
+    API_URL = 'https://www.googleapis.com/pagespeedonline/v5/runPagespeed'
+
+    attr_reader :url, :strategy, :api_key
+
+    def initialize(url, strategy: 'mobile', api_key: nil)
+      @url = url.to_s.strip
+      @strategy = strategy.to_s.downcase == 'desktop' ? 'desktop' : 'mobile'
+      @api_key = api_key || ENV['PAGESPEED_API_KEY'] || GSC::Config.get('pagespeed_api_key')
+    end
+
+    def run
+      query_params = [
+        "url=#{URI.encode_www_form_component(@url)}",
+        "strategy=#{@strategy}",
+        "category=performance",
+        "category=seo"
+      ]
+      query_params << "key=#{URI.encode_www_form_component(@api_key)}" if @api_key && !@api_key.empty?
+
+      uri = URI("#{API_URL}?#{query_params.join('&')}")
+      req = Net::HTTP::Get.new(uri)
+      req['User-Agent'] = 'gsc-cli/2.1'
+
+      res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 30) do |http|
+        http.request(req)
+      end
+
+      if res.code == '200'
+        parse_response(JSON.parse(res.body))
+      else
+        {
+          error: true,
+          status_code: res.code.to_i,
+          message: res.body
+        }
+      end
+    rescue StandardError => e
+      { error: true, message: e.message }
+    end
+
+    private
+
+    def parse_response(data)
+      lhr = data['lighthouseResult'] || {}
+      categories = lhr['categories'] || {}
+      perf_score = ((categories.dig('performance', 'score') || 0) * 100).round
+      seo_score = ((categories.dig('seo', 'score') || 0) * 100).round
+
+      audits = lhr['audits'] || {}
+
+      # Core Web Vitals
+      fcp = audits.dig('first-contentful-paint', 'displayValue')
+      lcp = audits.dig('largest-contentful-paint', 'displayValue')
+      cls = audits.dig('cumulative-layout-shift', 'displayValue')
+      tbt = audits.dig('total-blocking-time', 'displayValue')
+      si  = audits.dig('speed-index', 'displayValue')
+
+      # CrUX Field Data (if available)
+      crux_metrics = {}
+      crux = data.dig('loadingExperience', 'metrics') || {}
+      crux.each do |k, v|
+        crux_metrics[k] = {
+          percentile: v['percentile'],
+          category: v['category']
+        }
+      end
+
+      # Opportunities
+      opportunities = []
+      audits.each do |k, v|
+        next unless v['details'] && v['details']['type'] == 'opportunity'
+        next unless v['numericValue'] && v['numericValue'] > 100
+
+        opportunities << {
+          id: k,
+          title: v['title'],
+          savings_ms: v['numericValue'] ? v['numericValue'].round : 0,
+          display: v['displayValue']
+        }
+      end
+      opportunities.sort_by! { |o| -o[:savings_ms] }
+
+      {
+        url: @url,
+        strategy: @strategy,
+        fetch_time: lhr['fetchTime'],
+        performance_score: perf_score,
+        seo_score: seo_score,
+        metrics: {
+          fcp: fcp,
+          lcp: lcp,
+          cls: cls,
+          tbt: tbt,
+          speed_index: si
+        },
+        field_data: crux_metrics,
+        opportunities: opportunities.first(5)
+      }
+    end
+  end
+end