gsc-cli 2.1.0 → 2.2.2

data/lib/gsc/cli/landing_roi.rb

@@ -0,0 +1,308 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+require_relative '../landing_roi'
+require_relative '../color'
+
+module GSC
+  class CLI
+    module LandingRoi
+      module_function
+
+      def run(command, target, extra, options, api = nil, site_url = nil, hostname = nil)
+        analyzer = GSC::LandingRoi.new(
+          aov: options[:aov] || 75.0,
+          conv_rate: options[:conv_rate] ? (options[:conv_rate].to_f / (options[:conv_rate].to_f > 1.0 ? 100.0 : 1.0)) : 0.025,
+          benchmark_bounce: options[:benchmark] || 45.0,
+          cpc: options[:cpc] || 1.50
+        )
+
+        # Mode A: Standalone URL parameter inspection / modeling
+        if target && target =~ %r{^https?://}
+          clicks = (options[:clicks] || 0).to_i
+          impressions = (options[:impressions] || 0).to_i
+          position = (options[:position] || 0.0).to_f
+          ctr = (options[:ctr] || (impressions.positive? ? ((clicks.to_f / impressions) * 100.0).round(2) : 0.0)).to_f
+
+          # If live GSC API is connected and no manual CLI overrides given, fetch live page metrics
+          if api && site_url && clicks.zero? && impressions.zero?
+            begin
+              page_res = api.query_analytics(site_url, days: options[:days] || 28, dimensions: ['page'], page_filter: target, row_limit: 5)
+              if page_res[:ok] && (row = (page_res.dig(:data, 'rows') || []).first)
+                clicks = row['clicks'] || 0
+                impressions = row['impressions'] || 0
+                ctr = ((row['ctr'] || 0) * 100.0).round(2)
+                position = (row['position'] || 0).round(1)
+              end
+            rescue StandardError
+            end
+          end
+
+          bounce_rate = (options[:bounce] || options[:bounce_rate])&.to_f
+          duration = options[:duration]&.to_f
+          ga4_found = false
+
+          # If live GA4 API is connected and no manual bounce override given, fetch live page engagement
+          if api && (bounce_rate.nil? || duration.nil?)
+            host_to_use = hostname || (URI.parse(target).host rescue nil)
+            property_id = options[:property] || (Config.ga4_property_id(host_to_use) rescue nil)
+            if property_id
+              norm_path = Base.normalize_path(target)
+              begin
+                ga4_res = api.query_ga4_report(property_id, days: options[:days] || 28, limit: 150, organic_only: options[:organic], hostname: host_to_use)
+                if ga4_res[:ok]
+                  (ga4_res.dig(:data, 'rows') || []).each do |r|
+                    path_val = r.dig('dimensionValues', 0, 'value') || ''
+                    if Base.normalize_path(path_val) == norm_path
+                      bounce_rate ||= r.dig('metricValues', 3, 'value').to_f
+                      duration ||= r.dig('metricValues', 4, 'value').to_f
+                      ga4_found = true
+                      break
+                    end
+                  end
+                end
+              rescue StandardError
+              end
+            end
+          end
+
+          bounce_rate ||= 50.0
+          duration ||= 45.0
+
+          page = {
+            url: target,
+            clicks: clicks,
+            impressions: impressions,
+            position: position,
+            ctr: ctr,
+            sessions: (options[:sessions] || clicks).to_i,
+            bounce_rate: bounce_rate.round(1),
+            duration: duration.round(1)
+          }
+          report = analyzer.analyze_pages([page])
+          if options[:json]
+            puts JSON.pretty_generate(report)
+          else
+            render_roi_report(report, options, hostname || target, has_ga4: ga4_found)
+          end
+          return
+        end
+
+        # Mode B: Domain-level Search Console & GA4 correlation
+        unless api && site_url
+          if options[:json]
+            puts JSON.pretty_generate({ error: 'Search Console credentials required for domain-level landing ROI. Run gsc setup or gsc connect.' })
+          else
+            puts Color.red("⚠️ Authentication required: Connect Google Search Console credentials with `gsc setup` or `gsc connect` to analyze domain landing page ROI.")
+            puts "   Or model a specific landing page directly: `gsc landing-roi https://example.com/page --clicks 1000 --bounce 75`"
+          end
+          return
+        end
+
+        # Live GSC Data Acquisition
+        gsc_res = api.query_analytics(site_url, days: options[:days] || 28, dimensions: ['page'], row_limit: 100)
+        gsc_rows = gsc_res[:ok] ? (gsc_res.dig(:data, 'rows') || []) : []
+
+        if gsc_rows.empty?
+          if options[:json]
+            puts JSON.pretty_generate({ error: 'No GSC landing page data returned' })
+          else
+            puts Color.red("⚠️ No search performance data found for #{site_url}")
+          end
+          return
+        end
+
+        # Check GA4 Data
+        property_id = options[:property] || (Config.ga4_property_id(hostname) rescue nil)
+        ga4_index = {}
+
+        if property_id
+          ga4_res = api.query_ga4_report(property_id, days: options[:days] || 28, limit: 150, organic_only: options[:organic], hostname: (options[:all_hosts] ? nil : hostname), site_only: options[:site_only]) rescue { ok: false }
+          if ga4_res[:ok]
+            (ga4_res.dig(:data, 'rows') || []).each do |r|
+              path_val = r.dig('dimensionValues', 0, 'value') || '/'
+              norm = Base.normalize_path(path_val)
+              sessions = r.dig('metricValues', 0, 'value').to_i
+              bounce   = r.dig('metricValues', 3, 'value').to_f
+              dur      = r.dig('metricValues', 4, 'value').to_f
+              ga4_index[norm] = { sessions: sessions, bounce_rate: bounce, duration: dur }
+            end
+          end
+        end
+
+        # Merge Pages
+        merged_pages = gsc_rows.map do |row|
+          full_url = row['keys'][0]
+          norm = Base.normalize_path(full_url)
+          clicks = row['clicks'].to_i
+          imp = row['impressions'].to_i
+          pos = row['position'].to_f.round(1)
+          ctr = (row['ctr'].to_f * 100.0).round(2)
+
+          ga4_data = ga4_index[norm]
+          if ga4_data
+            sessions = ga4_data[:sessions]
+            bounce = ga4_data[:bounce_rate]
+            duration = ga4_data[:duration]
+          else
+            sessions = clicks
+            bounce = nil # Will use heuristic
+            duration = 60.0
+          end
+
+          {
+            url: full_url,
+            clicks: clicks,
+            impressions: imp,
+            position: pos,
+            ctr: ctr,
+            sessions: sessions,
+            bounce_rate: bounce,
+            duration: duration
+          }
+        end
+
+        report = analyzer.analyze_pages(merged_pages)
+
+        if options[:json]
+          puts JSON.pretty_generate(report)
+          return
+        end
+
+        render_roi_report(report, options, hostname || site_url, has_ga4: !property_id.nil?)
+
+        if options[:csv]
+          csv_rows = report[:pages].map do |p|
+            [
+              p[:url],
+              p[:clicks],
+              "#{p[:bounce_rate]}%",
+              p[:duration_seconds],
+              p[:pehi_score],
+              p[:quadrant].to_s.upcase,
+              p[:lost_visitors],
+              "$#{p[:monthly_revenue_leak]}",
+              "$#{p[:annual_revenue_leak]}",
+              "$#{p[:actual_revenue_est]}",
+              p[:prescriptions].first
+            ]
+          end
+          Base.write_csv(
+            options[:csv],
+            %w[URL Clicks BounceRate DurationSeconds PEHIScore Quadrant LostVisitors MonthlyLeak AnnualLeak ActualRevenueEst TopFix],
+            csv_rows
+          )
+          puts Color.cyan("📁 Exported Landing Page ROI Report to #{options[:csv]}")
+        end
+      end
+
+      def render_roi_report(report, options, target_name, has_ga4: true)
+        puts "\n" + Color.cyan("╔" + "═" * 78 + "╗")
+        puts Color.cyan("║") + Color.bold("   💰 LANDING PAGE ECONOMIC EFFICIENCY & REVENUE LEAKAGE AUDIT              ") + Color.cyan("║")
+        customized = options[:aov] || options[:conv_rate] || options[:benchmark]
+        param_label = customized ? Color.green("(Custom Model)") : Color.gray("(Defaults: override with --aov, --conv-rate, --benchmark)")
+        puts Color.gray("  Economic Model:   ") + Color.dim("AOV: $#{report[:assumptions][:aov]} | Conv: #{report[:assumptions][:conv_rate_pct]}% | Target Bounce: #{report[:assumptions][:benchmark_bounce_pct]}% ") + param_label
+        puts Color.gray("  Leakage Formula:  ") + Color.dim("Excess Bounce (Actual % - Target %) × Clicks × Conv Rate × AOV")
+        unless has_ga4
+          puts Color.yellow("  ⚠️  GA4 Notice:    No GA4 property linked; using position-correlated bounce rate heuristics.")
+          puts Color.gray("                    Link GA4 with ") + Color.cyan("gsc config set-ga4 <id>") + Color.gray(" for exact analytics.")
+        end
+        puts Color.cyan("─" * 80)
+
+        # Financial Summary Cards
+        leak_color = report[:total_monthly_leak] > 1000.0 ? Color::RED : Color::YELLOW
+        puts "\n" + Color.bold("💵 MACRO REVENUE IMPACT:")
+        puts "   • Monthly Revenue Hemorrhage: " + Color.c("$#{report[:total_monthly_leak].to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse}", leak_color, Color::BOLD)
+        puts "   • Annualized Revenue at Risk:  " + Color.c("$#{report[:total_annual_leak].to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse}", leak_color, Color::BOLD)
+        puts "   • Total Search Visitors Lost:  " + Color.red(report[:total_lost_visitors].to_s) + Color.gray(" (Excess bounce over benchmark)")
+        puts "   • Total Clicks Analyzed:       #{report[:total_clicks]} across #{report[:total_pages]} landing pages"
+
+        if report[:total_clicks].zero?
+          puts "\n" + Color.yellow("  ℹ️  Why is Revenue Leakage $0.0?")
+          puts "     • Google Search Console recorded 0 organic search clicks for this URL in this period."
+          puts "     • Revenue leakage calculates money lost from active visitors who landed and bounced."
+          puts "     • Since 0 visitors arrived, 0 visitors bounced (0 clicks × Conv Rate × AOV = $0.0)."
+          puts "\n  💡 " + Color.bold("Want to forecast potential revenue or model traffic scenarios?")
+          puts "     Pass #{Color.cyan('--clicks <N>')} to simulate traffic (and optional #{Color.cyan('--bounce <%>')}):"
+          sample_clicks = 1000
+          sample_aov = report[:assumptions][:aov]
+          sample_cvr = (report[:assumptions][:conv_rate_pct] / 100.0).round(3)
+          puts "     Example: #{Color.cyan("gsc landing-roi #{target_name} --clicks #{sample_clicks} --bounce 50 --aov #{sample_aov} --conv-rate #{sample_cvr}")}"
+        elsif report[:total_monthly_leak].zero?
+          puts "\n  🛡️  " + Color.green("HEALTHY BOUNCE RATE: Audited landing pages are currently performing at or better than your #{report[:assumptions][:benchmark_bounce_pct]}% target benchmark.")
+          puts Color.gray("     Your top traffic pages (like Homepage at 0.9% bounce) retain visitors efficiently, so zero revenue is leaking over benchmark.")
+        end
+
+        # Strategic Quadrant Breakdown
+        q = report[:quadrants] || {}
+        puts "\n" + Color.bold("📊 STRATEGIC QUADRANT MATRIX:")
+        puts "   • 💎 Cash Cow Pages (High Clicks, Low Bounce):     #{Color.green(q[:cash_cows].to_s)} pages"
+        puts "   • 🚨 Revenue Leakers (High Clicks, High Bounce):   #{Color.red(q[:revenue_leakers].to_s)} pages (Top Fix Targets)"
+        puts "   • ⭐ Hidden Gems (Page 2, High Conversion/Time):  #{Color.cyan(q[:hidden_gems].to_s)} pages (Push to Top 3)"
+        puts "   • 💤 Dormant / Low-Traffic Pages:                 #{Color.gray(q[:zombies].to_s)} pages (Needs organic search clicks first)"
+
+        # Top Pages Table
+        limit = options[:limit] || 15
+        display_pages = report[:pages].first(limit)
+
+        puts "\n" + Color.bold("🔍 TOP LANDING PAGES BY REVENUE LEAKAGE:")
+        puts Color.dim("   " + "Landing Page Path".ljust(35) + "Clicks".rjust(7) + "Bounce".rjust(8) + "PEHI".rjust(7) + "Mo. Leak".rjust(11) + "  Quadrant Status")
+        puts Color.cyan("─" * 80)
+
+        display_pages.each do |p|
+          clean_path = p[:url].sub(%r{^https?://[^/]+}, '')
+          clean_path = '/' if clean_path.empty?
+          url_str = clean_path.length > 33 ? (clean_path[0..30] + '..') : clean_path
+          clicks_str = p[:clicks].to_s.rjust(7)
+
+          b_str = "#{p[:bounce_rate]}%".rjust(8)
+          b_colored = if p[:bounce_rate] >= 65.0
+                        Color.red(b_str)
+                      elsif p[:bounce_rate] <= 40.0
+                        Color.green(b_str)
+                      else
+                        Color.yellow(b_str)
+                      end
+
+          pehi_str = "#{p[:pehi_score]}/100".rjust(7)
+          pehi_colored = if p[:pehi_score] >= 70
+                           Color.green(pehi_str)
+                         elsif p[:pehi_score] <= 40
+                           Color.red(pehi_str)
+                         else
+                           Color.yellow(pehi_str)
+                         end
+
+          leak_str = "$#{p[:monthly_revenue_leak]}".rjust(11)
+          leak_colored = p[:monthly_revenue_leak] > 0 ? Color.red(leak_str) : Color.green(leak_str)
+
+          quad_badge = case p[:quadrant]
+                       when :cash_cow then Color.green("[CASH COW]")
+                       when :revenue_leaker then Color.red("[LEAKER]")
+                       when :hidden_gem then Color.cyan("[HIDDEN GEM]")
+                       else
+                         p[:clicks].zero? ? Color.gray("[DORMANT: 0 CLICKS]") : Color.gray("[LOW TRAFFIC]")
+                       end
+
+          puts "   #{url_str.ljust(35)}#{clicks_str}#{b_colored}#{pehi_colored}#{leak_colored}  #{quad_badge}"
+
+          if p[:prescriptions] && p[:prescriptions].any? && p[:monthly_revenue_leak] > 0
+            puts "      ↳ " + Color.yellow(p[:prescriptions].first.to_s)
+          end
+        end
+
+        puts "\n" + Color.bold("📖 METRIC DEFINITIONS & QUICK GUIDE:")
+        puts Color.gray("   • PEHI (Page Economic Health Index 0–100): Composite score of visitor engagement and traffic potential.")
+        puts Color.gray("   • 💎 [CASH COW]:   High traffic, low bounce rate (protect and maintain current organic rankings).")
+        puts Color.gray("   • 🚨 [LEAKER]:     High traffic, above-benchmark bounce rate (highest priority CRO targets).")
+        puts Color.gray("   • ⭐ [HIDDEN GEM]: High engagement, ranking on page 2 (add internal links to push into Top 3).")
+        puts Color.gray("   • 💤 [DORMANT]:    0–24 search clicks in GSC. Focus on rankings before CRO, or test with --clicks <N>.")
+
+
+        puts Color.cyan("═" * 80) + "\n"
+      end
+    end
+  end
+end

data/lib/gsc/cli/low_ctr.rb

@@ -0,0 +1,213 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+require_relative '../low_ctr_rewriter'
+require_relative '../color'
+
+module GSC
+  class CLI
+    module LowCtr
+      module_function
+
+      def run(command, target, extra, options, api = nil, site_url = nil, hostname = nil)
+        # Mode A: Single query or specific target URL provided without needing GSC API
+        if target && !target.strip.empty? && (target =~ %r{^https?://} || (target !~ /\.(com|org|net|io|app|co|dev|store)$/ && !api))
+          handle_standalone_target(target, options)
+        else
+          # Mode B: Domain-wide Search Console audit
+          handle_domain_audit(api, site_url, hostname, target, options)
+        end
+      end
+
+      def handle_standalone_target(target, options)
+        brand = (options[:brand_name] || (options[:brand].is_a?(String) ? options[:brand] : nil) || '').to_s.strip
+        is_url = target =~ %r{^https?://}
+
+        if is_url
+          # Specific URL: fetch title & synthesize
+          rewriter = GSC::LowCtrRewriter.new([], options.merge(brand_name: brand, fetch_live_titles: true))
+          title_info = rewriter.send(:fetch_page_title_info, target)
+          primary_query = rewriter.send(:extract_slug_topic, target)
+          brand = rewriter.send(:extract_brand_from_url, target) if brand.empty?
+          hooks = rewriter.synthesize_three_hooks(primary_query, brand, target, title_info[:title])
+          meta = rewriter.synthesize_meta_description(primary_query, brand)
+
+          data = {
+            url: target,
+            primary_query: primary_query,
+            current_title: title_info[:title],
+            current_pixel_width: title_info[:pixel_width],
+            current_char_count: title_info[:char_count],
+            truncated: title_info[:truncated],
+            suggested_rewrites: hooks,
+            suggested_meta: meta,
+            html_title: "<title>#{hooks.first[:title]}</title>",
+            html_meta: "<meta name=\"description\" content=\"#{meta}\">"
+          }
+        else
+          # Keyword phrase
+          brand = 'Brand' if brand.empty?
+          hooks = GSC::LowCtrRewriter.generate_title_hooks(target, brand)
+          meta = GSC::LowCtrRewriter.generate_meta_description(target, brand)
+
+          data = {
+            query: target,
+            brand: brand,
+            suggested_rewrites: hooks,
+            suggested_meta: meta,
+            html_title: "<title>#{hooks.first[:title]}</title>",
+            html_meta: "<meta name=\"description\" content=\"#{meta}\">"
+          }
+        end
+
+        if options[:json]
+          puts JSON.pretty_generate(data)
+          return
+        end
+
+        puts "\n" + Color.cyan("=" * 80)
+        puts Color.bold("  LOW-CTR HIGH-IMPRESSION TITLE REWRITER")
+        puts Color.cyan("=" * 80)
+        if is_url
+          puts Color.gray("  Target URL:    ") + Color.bold(target)
+          puts Color.gray("  Detected Query:") + Color.yellow(" \"#{data[:primary_query]}\"")
+          puts Color.gray("  Current Title: ") + Color.dim("#{data[:current_title]} (#{data[:current_char_count]} chars / #{data[:current_pixel_width]}px)")
+          if data[:truncated]
+            puts Color.red("  ⚠️ Current title exceeds 560px and is TRUNCATED on Google SERP!")
+          end
+        else
+          puts Color.gray("  Target Query:  ") + Color.bold("\"#{target}\"")
+          puts Color.gray("  Brand Token:   ") + Color.yellow(brand)
+        end
+        puts Color.cyan("-" * 80)
+
+        puts "\n" + Color.bold("🏷️  3 HIGH-CONVERTING HOOK TITLE REWRITES (Guaranteed < 560px SERP Safe):")
+        data[:suggested_rewrites].each_with_index do |hook, idx|
+          fit_badge = hook[:fits_serp] ? Color.green("✓ SERP Safe (#{hook[:pixel_width]}px)") : Color.red("Over limit")
+          puts "\n  #{idx + 1}. #{Color.bold(hook[:type])}:"
+          puts "     #{Color.c(hook[:title], Color::YELLOW, Color::BOLD)}"
+          puts "     #{Color.gray("Width: #{hook[:char_count]} chars / #{hook[:pixel_width]}px | [#{fit_badge}]")}"
+          puts "     #{Color.dim("↳ #{hook[:rationale]}")}"
+        end
+
+        puts "\n" + Color.bold("📝 HIGH-CTR META DESCRIPTION (140–155 chars):")
+        puts "   #{Color.white(data[:suggested_meta])}"
+
+        puts "\n" + Color.bold("💻 1-CLICK HTML SNIPPET:")
+        puts "   #{Color.dim(data[:html_title])}"
+        puts "   #{Color.dim(data[:html_meta])}"
+        puts "\n" + Color.cyan("=" * 80) + "\n"
+      end
+
+      def handle_domain_audit(api, site_url, hostname, target, options)
+        domain = target || hostname || (site_url ? site_url.sub(%r{^https?://}, '').sub(%r{/$}, '') : 'Current Domain')
+        days = (options[:days] || 28).to_i
+        min_imp = (options[:min_imp] || options[:min_impressions] || 50).to_i
+        cpc = (options[:cpc] || 1.50).to_f
+
+        puts Color.cyan("⚡ Scanning GSC Performance data for #{Color.bold(domain)} (Past #{days} days, Min #{min_imp} imp)...") unless options[:json]
+
+        rows = []
+        if api && site_url
+          begin
+            res = api.query_analytics(
+              site_url,
+              days: days,
+              dimensions: %w[query page],
+              row_limit: 5000
+            )
+            rows = res.dig(:data, 'rows') || [] if res[:ok]
+          rescue StandardError => e
+            puts Color.yellow("⚠️ Note: Live Search Console query returned an error: #{e.message}") unless options[:json]
+          end
+        end
+
+        analysis = GSC::LowCtrRewriter.analyze(rows, options.merge(min_imp: min_imp, cpc: cpc))
+
+        if options[:json]
+          puts JSON.pretty_generate(analysis)
+          return
+        end
+
+        if analysis[:pages].empty?
+          puts "\n" + Color.green("✅ No severe CTR underperformers found! Your ranking pages meet or exceed SERP benchmarks.")
+          puts Color.gray("💡 Tip: Lower --min-imp (e.g. gsc low-ctr --min-imp 20) or adjust --days 90 to scan deeper.")
+          return
+        end
+
+        puts "\n" + Color.cyan("╔" + "═" * 78 + "╗")
+        puts Color.cyan("║") + Color.bold("   📉 LOW-CTR HIGH-IMPRESSION TITLE REWRITER (TRAFFIC LEAK RECOVERY)         ") + Color.cyan("║")
+        puts Color.cyan("╚" + "═" * 78 + "╝")
+        puts Color.gray("  Domain:             ") + Color.bold(domain)
+        puts Color.gray("  Leaking Pages:      ") + Color.c(analysis[:total_leaking_pages].to_s, Color::YELLOW, Color::BOLD) + Color.gray(" pages ranking on Page 1-2 with low CTR")
+        puts Color.gray("  Monthly Lost Clicks:") + Color.c("-#{analysis[:total_monthly_lost_clicks]} clicks/month", Color::RED, Color::BOLD) + Color.gray(" leaking due to unclickable titles")
+        puts Color.gray("  Monthly Value Lost: ") + Color.c("-$#{analysis[:estimated_monthly_value_lost]} / month", Color::RED, Color::BOLD) + Color.gray(" (@ $#{cpc} CPC estimate)")
+        rec = analysis[:projected_recovery]
+        puts Color.gray("  Projected Recovery: ") + Color.c("+#{rec[:realistic_50pct]} clicks/mo (50% fix)", Color::GREEN, Color::BOLD) + Color.gray(" | ") + Color.c("+#{rec[:full_parity_100pct]} clicks/mo (100% parity)", Color::GREEN, Color::BOLD)
+        puts Color.cyan("─" * 80)
+
+        analysis[:pages].each_with_index do |p, idx|
+          sev_badge = case p[:severity]
+                      when :critical then Color.c(" [CRITICAL LEAK] ", Color::RED, Color::BOLD)
+                      when :high     then Color.c(" [HIGH LEAK] ", Color::YELLOW, Color::BOLD)
+                      else                Color.cyan(" [MODERATE] ")
+                      end
+
+          path = p[:url].sub(%r{^https?://[^/]+}, '')
+          path = '/' if path.empty?
+
+          puts "\n#{Color.bold("#{idx + 1}. #{path}")} #{sev_badge}"
+          puts "   #{Color.gray("Full URL:")} #{p[:url]}"
+          puts "   #{Color.gray("Primary Intent:")} #{Color.c("\"#{p[:primary_query]}\"", Color::YELLOW, Color::BOLD)}"
+          if p[:secondary_queries].any?
+            puts "   #{Color.gray("Also Ranking for:")} #{Color.dim(p[:secondary_queries].join(', '))}"
+          end
+          puts "   #{Color.gray("Metrics:")} Pos #{Color.bold(p[:position].to_s)} | #{p[:impressions]} imp | #{p[:clicks]} clicks | #{Color.red("Actual CTR: #{p[:actual_ctr]}%")} vs #{Color.green("Expected: #{p[:expected_ctr]}%")}"
+          puts "   #{Color.gray("Hemorrhage:")} #{Color.c("-#{p[:lost_clicks]} lost clicks/mo", Color::RED, Color::BOLD)} (~$#{p[:lost_revenue]}/mo lost)"
+
+          curr_trunc = p[:current_truncated] ? Color.red(" (⚠️ Truncated in Google SERP >560px)") : Color.green(" (Fits SERP)")
+          puts "   #{Color.gray("Current Title:")} #{Color.dim(p[:current_title].to_s)}#{curr_trunc}"
+
+          puts "\n   #{Color.bold("🏷️  Suggested 3 Hook Title Rewrites (SERP Safe < 560px):")}"
+          p[:suggested_rewrites].each do |h|
+            puts "      • [#{h[:type]}]: #{Color.c(h[:title], Color::YELLOW, Color::BOLD)} #{Color.gray("(#{h[:pixel_width]}px)")}"
+          end
+
+          puts "   #{Color.bold("📝 Suggested Meta Hook:")}"
+          puts "      #{Color.white(p[:suggested_meta])}"
+
+          puts "   #{Color.bold("💻 HTML Snippet:")}"
+          puts "      #{Color.dim(p[:code_snippets][:html_title])}"
+          puts Color.cyan("   " + "·" * 74)
+        end
+
+        if options[:csv]
+          csv_rows = analysis[:pages].map do |p|
+            [
+              p[:url],
+              p[:primary_query],
+              p[:position],
+              p[:impressions],
+              p[:clicks],
+              p[:actual_ctr],
+              p[:expected_ctr],
+              p[:lost_clicks],
+              p[:lost_revenue],
+              p[:suggested_rewrites][0]&.dig(:title),
+              p[:suggested_rewrites][1]&.dig(:title),
+              p[:suggested_rewrites][2]&.dig(:title),
+              p[:suggested_meta]
+            ]
+          end
+          headers = %w[URL PrimaryQuery Position Impressions Clicks ActualCTR ExpectedCTR LostClicks LostRevenueUSD HookTitle1 HookTitle2 HookTitle3 MetaDescription]
+          Base.write_csv(options[:csv], headers, csv_rows)
+          puts Color.cyan("\n📁 Exported #{analysis[:pages].size} title rewrites to #{options[:csv]}")
+        end
+
+        puts "\n💡 #{Color.bold("Execution Tip:")} Update title tags for the top 3 critical leaking pages first. Google typically re-indexes and reflects new CTR within 48 to 72 hours!\n\n"
+      end
+    end
+  end
+end

data/lib/gsc/cli/mobile_parity.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+require_relative '../mobile_parity'
+require_relative '../color'
+
+module GSC
+  class CLI
+    module MobileParity
+      module_function
+
+      def run(command, target, extra, options, api = nil, site_url = nil, hostname = nil)
+        target_domain = target || hostname || (Config.default_domain rescue nil)
+        if target_domain.nil? || target_domain.to_s.strip.empty?
+          if options[:json]
+            puts JSON.pretty_generate({ error: 'Target domain required. Example: gsc mobile-parity mysite.com or gsc use mysite.com' })
+          else
+            puts Color.c("❌ Error: Target domain required. Example: gsc mobile-parity mysite.com or gsc use mysite.com", Color::RED, Color::BOLD)
+          end
+          return
+        end
+        target_domain = target_domain.sub(%r{^https?://}, '').sub(%r{/.*$}, '')
+
+        # Resolve verified GSC property URL if authenticated
+        resolved_site = site_url
+        if api && (!resolved_site || (target && target != hostname))
+          resolved_site = "sc-domain:#{target_domain}"
+        end
+
+        puts "📱 Auditing Mobile vs Desktop SERP parity and responsive penalties for #{Color.cyan(target_domain)}..." unless options[:json]
+
+        res = GSC::MobileParity.audit(options.merge(site_url: resolved_site), api, target_domain)
+
+        if options[:json]
+          puts JSON.pretty_generate(res)
+          return
+        end
+
+        render_terminal(res)
+
+        if options[:csv]
+          export_csv(res, options[:csv])
+        end
+      end
+
+      def render_terminal(res)
+        t = res[:traffic_distribution]
+
+        puts "\n#{Color.bold("═══════════════════════════════════════════════════════════════════════════")}"
+        puts "#{Color.bold("📱 MOBILE VS DESKTOP SERP PARITY & RESPONSIVE AUDITOR")}"
+        puts "#{Color.bold("═══════════════════════════════════════════════════════════════════════════")}"
+
+        if res[:total_queries_analyzed].zero?
+          puts "  • Mobile Parity Health:           [ #{Color.gray('N/A')} ] Insufficient Data (0 Queries Analyzed)"
+          puts "  • Device Traffic Split:           0.0% Mobile | 0.0% Desktop (No click data)"
+          puts "  • Total Analyzed Queries:         0 keywords"
+          puts "  • Critical Mobile Demotions:      0"
+          puts "  • Moderate Mobile Lags:           0"
+          puts "  • Estimated Lost Mobile Clicks:   0"
+          puts "#{Color.bold("───────────────────────────────────────────────────────────────────────────")}\n"
+          puts "  ℹ️  No cross-device query disparity data found for #{res[:domain]}."
+          puts "     Search Console has not recorded mobile vs desktop impressions meeting the threshold (min 5 impressions)."
+          puts "     Try expanding the date window: #{Color.cyan("gsc mobile-parity #{res[:domain]} --days 90")}"
+          puts "\n#{Color.bold("═══════════════════════════════════════════════════════════════════════════")}\n"
+          return
+        end
+
+        grade_color = case res[:grade]
+                      when 'A' then Color.green(res[:grade])
+                      when 'B' then Color.cyan(res[:grade])
+                      when 'C' then Color.yellow(res[:grade])
+                      else Color.red(res[:grade])
+                      end
+
+        puts "  • Mobile Parity Health:           [ #{Color.bold(grade_color)} ] #{res[:health_score]}/100 Health Score"
+        puts "  • Device Traffic Split:           #{Color.bold(t[:mobile_share_pct].to_s + "% Mobile")} | #{t[:desktop_share_pct]}% Desktop"
+        puts "  • Total Analyzed Queries:         #{Color.bold(res[:total_queries_analyzed].to_s)} keywords"
+        puts "  • Critical Mobile Demotions:      #{res[:critical_suppression_count] > 0 ? Color.red(res[:critical_suppression_count].to_s) : Color.green("0")}"
+        puts "  • Moderate Mobile Lags:           #{res[:moderate_suppression_count] > 0 ? Color.yellow(res[:moderate_suppression_count].to_s) : Color.green("0")}"
+        puts "  • Estimated Lost Mobile Clicks:   #{res[:total_estimated_lost_mobile_clicks] > 0 ? Color.red("~" + res[:total_estimated_lost_mobile_clicks].to_s + " clicks/mo") : Color.green("0")}"
+        puts "#{Color.bold("───────────────────────────────────────────────────────────────────────────")}\n"
+
+        puts "#{Color.bold("CROSS-DEVICE SERP RANKINGS & DISPARITY MATRIX:")}\n\n"
+        printf " %-30s %-10s %-10s %-8s %-12s %s\n", "Search Query", "Desktop", "Mobile", "Gap", "Lost Clicks", "Status"
+        puts " -----------------------------------------------------------------------------------------"
+
+        res[:disparities].each do |d|
+          q_str = d[:query].length > 28 ? "#{d[:query][0..25]}..." : d[:query]
+          status_str = case d[:status]
+                       when :critical_suppression then Color.red("🚨 CRITICAL")
+                       when :moderate_suppression then Color.yellow("⚠️ LAG")
+                       when :mobile_advantaged    then Color.cyan("📱 FAVORED")
+                       else Color.green("✅ PARITY")
+                       end
+
+          gap_sign = d[:pos_gap] > 0 ? "+#{d[:pos_gap]}" : d[:pos_gap].to_s
+
+          printf " %-30s Pos %-6s Pos %-6s %-8s %-12s %s\n",
+                 q_str,
+                 d[:desktop][:position],
+                 d[:mobile][:position],
+                 gap_sign,
+                 d[:lost_clicks] > 0 ? "~#{d[:lost_clicks]} clicks" : "-",
+                 status_str
+
+          if d[:diagnosis] && d[:status] != :parity
+            puts "    #{Color.yellow("↳")} #{d[:diagnosis]}"
+          end
+        end
+
+        puts "\n#{Color.bold("───────────────────────────────────────────────────────────────────────────")}"
+
+        if res[:priority_remediations].any?
+          puts "#{Color.bold("PRIORITY TECHNICAL RESPONSIVE REMEDIATIONS:")}"
+          res[:priority_remediations].each_with_index do |rem, idx|
+            puts "  #{idx + 1}. 🛠️ #{rem}"
+          end
+          puts
+        end
+
+        puts "#{Color.bold("═══════════════════════════════════════════════════════════════════════════")}\n"
+      end
+
+      def export_csv(res, file_path)
+        headers = %w[Query Status PositionGap CTRGap LostClicks DesktopPos DesktopClicks DesktopCTR MobilePos MobileClicks MobileCTR Diagnosis Remediation]
+        rows = res[:disparities].map do |d|
+          [
+            d[:query],
+            d[:status].to_s,
+            d[:pos_gap],
+            d[:ctr_gap],
+            d[:lost_clicks],
+            d[:desktop][:position],
+            d[:desktop][:clicks],
+            d[:desktop][:ctr],
+            d[:mobile][:position],
+            d[:mobile][:clicks],
+            d[:mobile][:ctr],
+            d[:diagnosis],
+            d[:remediation]
+          ]
+        end
+        Base.write_csv(file_path, headers, rows)
+        puts Color.cyan("📁 Successfully exported Mobile Parity audit to #{file_path}")
+      end
+    end
+  end
+end