gsc-cli 2.0.2 → 2.1.0

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

data/lib/gsc/robots_checker.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module GSC
+  class RobotsChecker
+    attr_reader :base_url, :robots_content
+
+    def initialize(target_url)
+      @target_url = target_url.to_s.strip
+      @target_url = "https://#{@target_url}" unless @target_url =~ %r{^https?://}
+      @uri = URI.parse(@target_url)
+      @robots_url = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}/robots.txt"
+    end
+
+    def fetch_robots_txt
+      res = Net::HTTP.get_response(URI.parse(@robots_url))
+      return '' unless res.code == '200'
+
+      res.body.force_encoding('UTF-8')
+    rescue StandardError
+      ''
+    end
+
+    def check(path_to_test = nil, user_agent = 'googlebot')
+      @robots_content ||= fetch_robots_txt
+      path = path_to_test || @uri.path
+      path = '/' if path.empty?
+
+      ua = user_agent.to_s.downcase
+      rules = parse_rules(ua)
+
+      allowed = true
+      matched_rule = nil
+
+      rules.each do |rule|
+        pattern = rule[:path]
+        regex = Regexp.new('^' + Regexp.escape(pattern).gsub('\*', '.*'))
+        if path =~ regex
+          allowed = (rule[:type] == :allow)
+          matched_rule = rule
+        end
+      end
+
+      {
+        robots_url: @robots_url,
+        user_agent: user_agent,
+        tested_path: path,
+        allowed: allowed,
+        matched_rule: matched_rule,
+        has_robots_txt: !@robots_content.empty?
+      }
+    end
+
+    private
+
+    def parse_rules(target_ua)
+      rules = []
+      current_ua = nil
+      applies = false
+
+      @robots_content.each_line do |line|
+        line = line.strip.sub(/#.*$/, '')
+        next if line.empty?
+
+        if line =~ /^User-agent:\s*(.+)$/i
+          current_ua = $1.strip.downcase
+          applies = (current_ua == '*' || current_ua == target_ua)
+        elsif applies && line =~ /^Disallow:\s*(.*)$/i
+          val = $1.strip
+          rules << { type: :disallow, path: val } unless val.empty?
+        elsif applies && line =~ /^Allow:\s*(.*)$/i
+          val = $1.strip
+          rules << { type: :allow, path: val } unless val.empty?
+        end
+      end
+
+      rules
+    end
+  end
+end

data/lib/gsc/schema_validator.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'json'
+
+module GSC
+  class SchemaValidator
+    attr_reader :url, :schemas, :validation_results
+
+    def initialize(url)
+      @url = url.to_s.strip
+    end
+
+    def audit
+      pa = GSC::PageAnalyzer.new(@url)
+      data = pa.fetch_and_analyze
+      @schemas = data.dig(:structured_data, :schemas) || []
+
+      results = []
+      @schemas.each_with_index do |schema, idx|
+        results << validate_single_schema(schema, idx)
+      end
+
+      {
+        url: @url,
+        total_schemas: @schemas.length,
+        schemas: results
+      }
+    end
+
+    def validate_single_schema(schema, idx)
+      type = schema['@type'] || 'Unknown'
+      errors = []
+      warnings = []
+
+      case type
+      when 'SoftwareApplication', 'WebApplication'
+        errors << 'Missing "name"' unless schema['name']
+        warnings << 'Missing "operatingSystem"' unless schema['operatingSystem']
+        warnings << 'Missing "applicationCategory"' unless schema['applicationCategory']
+        warnings << 'Missing "offers"' unless schema['offers']
+        warnings << 'Missing "aggregateRating"' unless schema['aggregateRating']
+
+      when 'FAQPage'
+        main_entity = schema['mainEntity']
+        if !main_entity || !main_entity.is_a?(Array) || main_entity.empty?
+          errors << 'FAQPage must contain a non-empty "mainEntity" array'
+        else
+          main_entity.each_with_index do |q, q_idx|
+            errors << "Question ##{q_idx + 1} missing name" unless q['name']
+            errors << "Question ##{q_idx + 1} missing acceptedAnswer" unless q['acceptedAnswer']
+          end
+        end
+
+      when 'Product'
+        errors << 'Missing "name"' unless schema['name']
+        warnings << 'Missing "image"' unless schema['image']
+        warnings << 'Missing "offers"' unless schema['offers']
+
+      when 'Article', 'BlogPosting'
+        errors << 'Missing "headline"' unless schema['headline']
+        errors << 'Missing "author"' unless schema['author']
+        warnings << 'Missing "datePublished"' unless schema['datePublished']
+        warnings << 'Missing "image"' unless schema['image']
+
+      when 'Organization', 'LocalBusiness'
+        errors << 'Missing "name"' unless schema['name']
+        errors << 'Missing "url"' unless schema['url']
+        warnings << 'Missing "logo"' unless schema['logo']
+      end
+
+      {
+        index: idx,
+        type: type,
+        valid: errors.empty?,
+        errors: errors,
+        warnings: warnings,
+        raw: schema
+      }
+    end
+
+    def self.generate_template(type, params = {})
+      case type.to_s.downcase
+      when 'faq'
+        {
+          '@context' => 'https://schema.org',
+          '@type' => 'FAQPage',
+          'mainEntity' => [
+            {
+              '@type' => 'Question',
+              'name' => params[:question] || 'What is PackingLog?',
+              'acceptedAnswer' => {
+                '@type' => 'Answer',
+                'text' => params[:answer] || 'PackingLog is a free moving box and inventory management system.'
+              }
+            }
+          ]
+        }
+      when 'software', 'app'
+        {
+          '@context' => 'https://schema.org',
+          '@type' => 'SoftwareApplication',
+          'name' => params[:name] || 'PackingLog',
+          'applicationCategory' => params[:category] || 'UtilitiesApplication',
+          'operatingSystem' => 'Web, iOS, Android',
+          'offers' => {
+            '@type' => 'Offer',
+            'price' => '0',
+            'priceCurrency' => 'USD'
+          }
+        }
+      else
+        {
+          '@context' => 'https://schema.org',
+          '@type' => 'Organization',
+          'name' => params[:name] || 'PackingLog',
+          'url' => params[:url] || 'https://packinglog.com'
+        }
+      end
+    end
+  end
+end

data/lib/gsc/serp_preview.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module GSC
+  class SerpPreview
+    attr_reader :url, :data
+
+    def initialize(url)
+      @url = url.to_s.strip
+    end
+
+    def generate
+      pa = GSC::PageAnalyzer.new(@url)
+      @data = pa.fetch_and_analyze
+
+      title = @data.dig(:title, :text) || 'Untitled Page'
+      desc = @data.dig(:meta_description, :text) || 'No meta description found.'
+      canonical = @data.dig(:canonical, :url) || @url
+
+      # SERP pixel calculation approximation:
+      # ~10px per character average for Arial 18px title
+      title_chars = title.length
+      is_truncated = title_chars > 60
+
+      desktop_title = is_truncated ? "#{title[0..56]}..." : title
+      desktop_snippet = desc.length > 155 ? "#{desc[0..152]}..." : desc
+
+      og = @data[:open_graph] || {}
+      twitter = @data[:twitter_card] || {}
+
+      {
+        url: @url,
+        canonical: canonical,
+        title: title,
+        meta_description: desc,
+        truncation_risk: is_truncated,
+        desktop_serp: {
+          title: desktop_title,
+          snippet: desktop_snippet,
+          breadcrumb: format_breadcrumb(canonical)
+        },
+        social: {
+          og_title: og['og:title'] || title,
+          og_description: og['og:description'] || desc,
+          og_image: og['og:image'],
+          twitter_card: twitter['twitter:card'] || 'summary_large_image'
+        }
+      }
+    end
+
+    private
+
+    def format_breadcrumb(url_str)
+      uri = URI.parse(url_str) rescue nil
+      return url_str unless uri && uri.host
+
+      domain = uri.host.sub(/^www\./, '')
+      parts = uri.path.split('/').reject(&:empty?)
+      if parts.empty?
+        "https://#{domain}"
+      else
+        "https://#{domain} > #{parts.join(' > ')}"
+      end
+    end
+  end
+end

data/lib/gsc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GSC
-  VERSION = '2.0.2'
+  VERSION = '2.1.0'
 end

data/lib/gsc.rb

@@ -26,7 +26,20 @@ require_relative 'gsc/keywords_everywhere'
 require_relative 'gsc/prompts'
 require_relative 'gsc/page_analyzer'
 require_relative 'gsc/site_crawler'
+require_relative 'gsc/google_suggest'
+require_relative 'gsc/open_page_rank'
+require_relative 'gsc/page_speed'
+require_relative 'gsc/page_comparator'
+require_relative 'gsc/content_gap'
+require_relative 'gsc/internal_links'
+require_relative 'gsc/schema_validator'
+require_relative 'gsc/llms_generator'
+require_relative 'gsc/serp_preview'
+require_relative 'gsc/network_tracer'
+require_relative 'gsc/robots_checker'
+require_relative 'gsc/backlinks_manager'
 require_relative 'gsc/command_registry'
+require_relative 'gsc/cli_advanced'
 require_relative 'gsc/cli'
 
 # Top-level aliases for compatibility
@@ -36,3 +49,16 @@ KeywordsEverywhere = GSC::KeywordsEverywhere unless defined?(KeywordsEverywhere)
 Prompts            = GSC::Prompts unless defined?(Prompts)
 PageAnalyzer       = GSC::PageAnalyzer unless defined?(PageAnalyzer)
 SiteCrawler        = GSC::SiteCrawler unless defined?(SiteCrawler)
+
+GoogleSuggest      = GSC::GoogleSuggest unless defined?(GoogleSuggest)
+OpenPageRank       = GSC::OpenPageRank unless defined?(OpenPageRank)
+PageSpeed          = GSC::PageSpeed unless defined?(PageSpeed)
+PageComparator     = GSC::PageComparator unless defined?(PageComparator)
+ContentGap         = GSC::ContentGap unless defined?(ContentGap)
+InternalLinks      = GSC::InternalLinks unless defined?(InternalLinks)
+SchemaValidator    = GSC::SchemaValidator unless defined?(SchemaValidator)
+LlmsGenerator      = GSC::LlmsGenerator unless defined?(LlmsGenerator)
+SerpPreview        = GSC::SerpPreview unless defined?(SerpPreview)
+NetworkTracer      = GSC::NetworkTracer unless defined?(NetworkTracer)
+RobotsChecker      = GSC::RobotsChecker unless defined?(RobotsChecker)
+BacklinksManager   = GSC::BacklinksManager unless defined?(BacklinksManager)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gsc-cli
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - ApollosWave LLC
@@ -28,6 +28,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- AUTH.md
+- FUNDING.md
 - LICENSE
 - README.md
 - bin/gsc
@@ -35,16 +37,29 @@ files:
 - lib/gsc.rb
 - lib/gsc/api.rb
 - lib/gsc/auth.rb
+- lib/gsc/backlinks_manager.rb
 - lib/gsc/cli.rb
+- lib/gsc/cli_advanced.rb
 - lib/gsc/client.rb
 - lib/gsc/color.rb
 - lib/gsc/command_registry.rb
 - lib/gsc/config.rb
+- lib/gsc/content_gap.rb
+- lib/gsc/google_suggest.rb
 - lib/gsc/google_trends.rb
+- lib/gsc/internal_links.rb
 - lib/gsc/keyword_planner.rb
 - lib/gsc/keywords_everywhere.rb
+- lib/gsc/llms_generator.rb
+- lib/gsc/network_tracer.rb
+- lib/gsc/open_page_rank.rb
 - lib/gsc/page_analyzer.rb
+- lib/gsc/page_comparator.rb
+- lib/gsc/page_speed.rb
 - lib/gsc/prompts.rb
+- lib/gsc/robots_checker.rb
+- lib/gsc/schema_validator.rb
+- lib/gsc/serp_preview.rb
 - lib/gsc/site_crawler.rb
 - lib/gsc/sitemap_loader.rb
 - lib/gsc/version.rb
@@ -57,7 +72,7 @@ metadata:
   documentation_uri: https://github.com/ApollosWave/gsc-cli#readme
   bug_tracker_uri: https://github.com/ApollosWave/gsc-cli/issues
   changelog_uri: https://github.com/ApollosWave/gsc-cli/blob/main/README.md
-  funding_uri: https://superspeedapp.com/?utm_source=rubygems&utm_medium=gem_sidebar&utm_campaign=gsc-cli
+  funding_uri: https://github.com/ApollosWave/gsc-cli#-sponsorship--backing
 rdoc_options: []
 require_paths:
 - lib