gsc-cli 2.0.2 → 2.2.0

data/lib/gsc/backlinks_manager.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'csv'
+require 'fileutils'
+require 'json'
+
+module GSC
+  class BacklinksManager
+    attr_reader :domain, :storage_file
+
+    def initialize(domain)
+      @domain = clean_domain(domain)
+      @domain_dir = File.join(Dir.home, '.config', 'gsc', 'domains', @domain)
+      FileUtils.mkdir_p(@domain_dir)
+      @storage_file = File.join(@domain_dir, 'backlinks.json')
+    end
+
+    def load_data
+      return { 'sources' => [], 'targets' => [], 'updated_at' => nil } unless File.exist?(@storage_file)
+
+      JSON.parse(File.read(@storage_file, encoding: 'UTF-8'))
+    rescue StandardError
+      { 'sources' => [], 'targets' => [], 'updated_at' => nil }
+    end
+
+    def save_data(data)
+      data['updated_at'] = Time.now.utc.iso8601
+      File.write(@storage_file, JSON.pretty_generate(data))
+    end
+
+    def import_csv(content)
+      data = load_data
+      lines = content.to_s.strip.lines
+
+      return { error: 'Empty content' } if lines.empty?
+
+      # Detect header
+      header = lines.first.downcase
+      if header.include?('top linking sites') || header.include?('root domain')
+        # Sources CSV
+        sources = []
+        CSV.parse(content, headers: true, skip_blanks: true) do |row|
+          domain_name = row['Top linking sites'] || row['Site'] || row[0]
+          links_count = (row['Target pages'] || row['Links'] || row[1] || '1').to_s.gsub(',', '').to_i
+          sources << { 'domain' => domain_name.to_s.strip, 'links_count' => links_count } if domain_name
+        end
+        data['sources'] = sources
+      else
+        # Target pages CSV
+        targets = []
+        CSV.parse(content, headers: true, skip_blanks: true) do |row|
+          target_url = row['Target page'] || row['Page'] || row[0]
+          incoming = (row['Incoming links'] || row['Links'] || row[1] || '1').to_s.gsub(',', '').to_i
+          targets << { 'target_url' => target_url.to_s.strip, 'incoming_count' => incoming } if target_url
+        end
+        data['targets'] = targets
+      end
+
+      save_data(data)
+      {
+        status: 'success',
+        sources_count: data['sources'].length,
+        targets_count: data['targets'].length,
+        updated_at: data['updated_at']
+      }
+    rescue StandardError => e
+      { error: "Failed to parse CSV: #{e.message}" }
+    end
+
+    def summary(target_page: nil)
+      data = load_data
+      sources = data['sources'] || []
+      targets = data['targets'] || []
+
+      filtered_targets = target_page ? targets.select { |t| t['target_url'].include?(target_page) } : targets
+
+      {
+        domain: @domain,
+        total_referring_domains: sources.length,
+        total_external_links: sources.sum { |s| s['links_count'] || 0 },
+        top_referring_domains: sources.sort_by { |s| -(s['links_count'] || 0) }.first(15),
+        top_target_pages: filtered_targets.sort_by { |t| -(t['incoming_count'] || 0) }.first(15),
+        updated_at: data['updated_at']
+      }
+    end
+
+    private
+
+    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/brand_segmenter.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module GSC
+  class BrandSegmenter
+    attr_reader :brand_tokens
+
+    # Suffixes to strip when deriving brand name from domain (e.g., exampleapp -> example)
+    STRIP_SUFFIXES = %w[app apps io co tech hq get try official shop store ltd inc net org].freeze
+
+    def initialize(domain: nil, custom_brand: nil)
+      @brand_tokens = resolve_tokens(domain, custom_brand)
+    end
+
+    def brand?(query)
+      return false if @brand_tokens.empty? || query.to_s.strip.empty?
+
+      q = normalize(query)
+      # Check exact token containment or multi-word phrase containment
+      @brand_tokens.any? do |token|
+        token_clean = normalize(token)
+        q.include?(token_clean) || q.gsub(/\s+/, '').include?(token_clean.gsub(/\s+/, ''))
+      end
+    end
+
+    def segment(rows)
+      brand_rows = []
+      non_brand_rows = []
+
+      rows.each do |row|
+        q = row[:query] || row['query'] || ''
+        if brand?(q)
+          brand_rows << row
+        else
+          non_brand_rows << row
+        end
+      end
+
+      {
+        brand: brand_rows,
+        non_brand: non_brand_rows,
+        summary: calculate_summary(brand_rows, non_brand_rows)
+      }
+    end
+
+    private
+
+    def normalize(str)
+      str.to_s.downcase.gsub(/[^a-z0-9\s]/, ' ').squeeze(' ').strip
+    end
+
+    def resolve_tokens(domain, custom_brand)
+      tokens = []
+
+      if custom_brand && !custom_brand.to_s.strip.empty?
+        cb = normalize(custom_brand)
+        tokens << cb
+        tokens << cb.gsub(/\s+/, '')
+        cb.split(/\s+/).each do |w|
+          tokens << w if w.length >= 4 && !%w[pro app apps the inc llc ltd corp].include?(w)
+        end
+      end
+
+      if domain && !domain.to_s.strip.empty?
+        # Clean domain
+        clean_dom = domain.to_s.sub(/^https?:\/\//i, '').sub(/^sc-domain:/i, '').split('/').first.to_s.downcase
+        parts = clean_dom.split('.')
+        # Main apex stem (e.g., exampleapp from exampleapp.com)
+        stem = parts.first || ''
+        
+        tokens << stem unless stem.empty?
+
+        # Try stripping known suffixes
+        STRIP_SUFFIXES.each do |suffix|
+          if stem.end_with?(suffix) && stem.length > (suffix.length + 3)
+            base = stem[0...-suffix.length]
+            tokens << base
+            # Add spaced variant if it looks compound (e.g. quickcart -> quick cart)
+            tokens << base.sub(/(super|pack|cart|speed|quick|auto|mega|hyper)/i, '\1 ').strip
+          end
+        end
+
+        # Also add compound space variations
+        tokens << stem.sub(/(super|pack|cart|speed|quick|auto|mega|hyper)/i, '\1 ').strip
+      end
+
+      tokens.map { |t| normalize(t) }.reject { |t| t.length < 3 }.uniq
+    end
+
+    def calculate_summary(brand_rows, non_brand_rows)
+      total_rows = brand_rows.size + non_brand_rows.size
+      
+      b_clicks = brand_rows.sum { |r| r[:clicks] || r['clicks'] || 0 }
+      b_imp = brand_rows.sum { |r| r[:impressions] || r['impressions'] || 0 }
+      b_ctr = b_imp > 0 ? (b_clicks.to_f / b_imp * 100).round(2) : 0.0
+      b_pos = if b_imp > 0
+                (brand_rows.sum { |r| (r[:position] || r['position'] || 0.0).to_f * (r[:impressions] || r['impressions'] || 0).to_f } / b_imp.to_f).round(1)
+              elsif brand_rows.any?
+                (brand_rows.sum { |r| (r[:position] || r['position'] || 0.0).to_f } / brand_rows.size).round(1)
+              else
+                0.0
+              end
+
+      nb_clicks = non_brand_rows.sum { |r| r[:clicks] || r['clicks'] || 0 }
+      nb_imp = non_brand_rows.sum { |r| r[:impressions] || r['impressions'] || 0 }
+      nb_ctr = nb_imp > 0 ? (nb_clicks.to_f / nb_imp * 100).round(2) : 0.0
+      nb_pos = if nb_imp > 0
+                 (non_brand_rows.sum { |r| (r[:position] || r['position'] || 0.0).to_f * (r[:impressions] || r['impressions'] || 0).to_f } / nb_imp.to_f).round(1)
+               elsif non_brand_rows.any?
+                 (non_brand_rows.sum { |r| (r[:position] || r['position'] || 0.0).to_f } / non_brand_rows.size).round(1)
+               else
+                 0.0
+               end
+
+      total_clicks = b_clicks + nb_clicks
+      total_imp = b_imp + nb_imp
+
+      {
+        total_queries: total_rows,
+        brand: {
+          queries_count: brand_rows.size,
+          clicks: b_clicks,
+          impressions: b_imp,
+          ctr: b_ctr,
+          avg_position: b_pos,
+          click_share: total_clicks > 0 ? (b_clicks.to_f / total_clicks * 100).round(1) : 0.0,
+          impression_share: total_imp > 0 ? (b_imp.to_f / total_imp * 100).round(1) : 0.0
+        },
+        non_brand: {
+          queries_count: non_brand_rows.size,
+          clicks: nb_clicks,
+          impressions: nb_imp,
+          ctr: nb_ctr,
+          avg_position: nb_pos,
+          click_share: total_clicks > 0 ? (nb_clicks.to_f / total_clicks * 100).round(1) : 0.0,
+          impression_share: total_imp > 0 ? (nb_imp.to_f / total_imp * 100).round(1) : 0.0
+        }
+      }
+    end
+  end
+end