gsc-cli 2.0.0

data/lib/gsc/google_trends.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module GSC
+class GoogleTrends
+  TRENDS_HOST = 'trends.google.com'
+
+  def self.normalize_time(time_str)
+    case time_str.to_s.strip.downcase
+    when '5y', '5-y', 'past-5-years', '5years' then 'today 5-y'
+    when '12m', '1y', 'past-12-months', '12months', '1year' then 'today 12-m'
+    when '3m', 'past-3-months', '3months' then 'today 3-m'
+    when '1m', 'past-month', '30d' then 'today 1-m'
+    when '7d', 'past-week' then 'now 7-d'
+    when '1d', '24h', 'today' then 'now 1-d'
+    when 'all' then 'all'
+    else
+      time_str.to_s.strip.empty? ? 'today 5-y' : time_str.to_s.strip
+    end
+  end
+
+  def self.render_sparkline(values, max_points: 36)
+    return '' if values.nil? || values.empty?
+    bucketed = if values.size > max_points
+                 chunk_size = (values.size.to_f / max_points).ceil
+                 values.each_slice(chunk_size).map { |slice| (slice.sum.to_f / slice.size).round }
+               else
+                 values
+               end
+    min_val = bucketed.min.to_f
+    max_val = bucketed.max.to_f
+    range = max_val - min_val
+    range = 1.0 if range.zero?
+    sparks = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"]
+    bucketed.map do |v|
+      idx = [((v - min_val) / range * (sparks.length - 1)).round, sparks.length - 1].min
+      sparks[idx]
+    end.join
+  end
+
+  def self.fetch(keyword, geo: 'US', time: '5y')
+    http = Net::HTTP.new(TRENDS_HOST, 443)
+    http.use_ssl = true
+    http.open_timeout = 10
+    http.read_timeout = 25
+
+    init_req = Net::HTTP::Get.new('/trends/explore')
+    init_req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    init_res = http.request(init_req)
+    cookies = init_res.get_fields('set-cookie')&.map { |c| c.split(';').first }&.join('; ')
+
+    norm_time = normalize_time(time)
+    clean_geo = geo.to_s.upcase == 'WORLDWIDE' ? '' : geo.to_s.strip
+    req_obj = {
+      comparisonItem: [{ keyword: keyword, geo: clean_geo, time: norm_time }],
+      category: 0,
+      property: ''
+    }
+    explore_path = '/trends/api/explore?hl=en-US&tz=-180&req=' + URI.encode_www_form_component(JSON.generate(req_obj))
+    explore_req = Net::HTTP::Get.new(explore_path)
+    explore_req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    explore_req['Accept'] = 'application/json, text/plain, */*'
+    explore_req['Referer'] = 'https://trends.google.com/trends/explore'
+    explore_req['Cookie'] = cookies if cookies
+
+    explore_res = http.request(explore_req)
+    return { ok: false, error: "Google Trends Explore API error (HTTP #{explore_res.code})" } unless explore_res.is_a?(Net::HTTPSuccess)
+
+    raw_exp = explore_res.body.to_s
+    clean_body = raw_exp.index('{') ? raw_exp[raw_exp.index('{')..] : raw_exp
+    explore_data = JSON.parse(clean_body) rescue nil
+    widgets = explore_data&.dig('widgets') || []
+
+    ts_widget = widgets.find { |w| w['id'] == 'TIMESERIES' }
+    geo_widget = widgets.find { |w| w['id'] == 'GEO_MAP' }
+    queries_widget = widgets.find { |w| w['id'] == 'RELATED_QUERIES' }
+
+    timeline = []
+    if ts_widget
+      ts_path = '/trends/api/widgetdata/multiline?hl=en-US&tz=-180&req=' + URI.encode_www_form_component(JSON.generate(ts_widget['request'])) + '&token=' + ts_widget['token']
+      ts_req = Net::HTTP::Get.new(ts_path)
+      ts_req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+      ts_req['Accept'] = 'application/json, text/plain, */*'
+      ts_req['Referer'] = 'https://trends.google.com/trends/explore'
+      ts_req['Cookie'] = cookies if cookies
+      ts_res = http.request(ts_req)
+      if ts_res.is_a?(Net::HTTPSuccess)
+        raw_ts = ts_res.body.to_s
+        ts_clean = raw_ts.index('{') ? raw_ts[raw_ts.index('{')..] : raw_ts
+        ts_data = JSON.parse(ts_clean) rescue {}
+        timeline = ts_data.dig('default', 'timelineData') || []
+      end
+    end
+
+    regions = []
+    if geo_widget
+      geo_path = '/trends/api/widgetdata/comparedgeo?hl=en-US&tz=-180&req=' + URI.encode_www_form_component(JSON.generate(geo_widget['request'])) + '&token=' + geo_widget['token']
+      geo_req = Net::HTTP::Get.new(geo_path)
+      geo_req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+      geo_req['Referer'] = 'https://trends.google.com/trends/explore'
+      geo_req['Cookie'] = cookies if cookies
+      geo_res = http.request(geo_req)
+      if geo_res.is_a?(Net::HTTPSuccess)
+        raw_geo = geo_res.body.to_s
+        geo_clean = raw_geo.index('{') ? raw_geo[raw_geo.index('{')..] : raw_geo
+        geo_data = JSON.parse(geo_clean) rescue {}
+        raw_regions = geo_data.dig('default', 'geoMapData') || []
+        regions = raw_regions.map do |r|
+          { name: r['geoName'], score: (r['value']&.first || 0) }
+        end.sort_by { |r| -r[:score] }.reject { |r| r[:score].zero? }
+      end
+    end
+
+    top_queries = []
+    rising_queries = []
+    if queries_widget
+      q_path = '/trends/api/widgetdata/relatedsearches?hl=en-US&tz=-180&req=' + URI.encode_www_form_component(JSON.generate(queries_widget['request'])) + '&token=' + queries_widget['token']
+      q_req = Net::HTTP::Get.new(q_path)
+      q_req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+      q_req['Accept'] = 'application/json, text/plain, */*'
+      q_req['Referer'] = 'https://trends.google.com/trends/explore'
+      q_req['Cookie'] = cookies if cookies
+      q_res = http.request(q_req)
+      if q_res.is_a?(Net::HTTPSuccess)
+        raw_q = q_res.body.to_s
+        q_clean = raw_q.index('{') ? raw_q[raw_q.index('{')..] : raw_q
+        q_data = JSON.parse(q_clean) rescue {}
+        ranked = q_data.dig('default', 'rankedList') || []
+        top_queries = (ranked.first&.dig('rankedKeyword') || []).map do |q|
+          { query: q['query'], score: q['value'] }
+        end
+        rising_queries = (ranked.last&.dig('rankedKeyword') || []).map do |q|
+          { query: q['query'], growth: q['formattedValue'] }
+        end
+      end
+    end
+
+    points = timeline.map do |pt|
+      {
+        date: pt['formattedTime'] || pt['formattedAxisTime'],
+        score: (pt['value']&.first || 0)
+      }
+    end
+
+    scores = points.map { |p| p[:score] }
+    peak_val = scores.max || 0
+    peak_pt = points.find { |p| p[:score] == peak_val }
+    curr_val = scores.last || 0
+
+    split = [points.size / 5, 4].max
+    baseline = points.first(split).map { |p| p[:score] }.sum.to_f / split
+    recent   = points.last(split).map { |p| p[:score] }.sum.to_f / split
+    growth_pct = baseline > 0 ? (((recent - baseline) / baseline) * 100).round : 0
+
+    velocity_badge = if growth_pct >= 250
+                       "+#{growth_pct}% 🚀 (Explosive Breakout)"
+                     elsif growth_pct >= 80
+                       "+#{growth_pct}% 🔥 (Strong Surging)"
+                     elsif growth_pct >= 15
+                       "+#{growth_pct}% 📈 (Growing Demand)"
+                     elsif growth_pct >= -15
+                       "#{growth_pct}% ⚖️ (Stable Demand)"
+                     else
+                       "#{growth_pct}% 📉 (Cooling / Declining)"
+                     end
+
+    {
+      ok: true,
+      keyword: keyword,
+      geo: clean_geo.empty? ? 'Worldwide' : clean_geo,
+      time: norm_time,
+      peak_score: peak_val,
+      peak_date: peak_pt ? peak_pt[:date] : nil,
+      current_score: curr_val,
+      growth_pct: growth_pct,
+      velocity_badge: velocity_badge,
+      sparkline: render_sparkline(scores),
+      points_count: points.size,
+      regions: regions.first(10),
+      top_queries: top_queries.first(8),
+      rising_queries: rising_queries.first(8),
+      points: points
+    }
+  rescue StandardError => e
+    { ok: false, error: e.message }
+  end
+end
+end

data/lib/gsc/keyword_planner.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module GSC
+class KeywordPlanner
+  SUGGEST_HOST = 'suggestqueries.google.com'
+
+  def self.calculate_opportunity(volume, competition)
+    vol = [volume.to_i, 0].max
+    comp = [[competition.to_f, 0.0].max, 1.0].min
+    return 0 if vol.zero?
+
+    log_vol = Math.log10(vol + 10)
+    vol_score = [log_vol * 10.0, 50.0].min
+    comp_score = (1.0 - comp) * 50.0
+    (vol_score + comp_score).round
+  end
+
+  def self.classify_intent(query)
+    q = query.to_s.downcase
+    if q =~ /\b(how|what|why|guide|tips|symptoms|remedies|causes|when|is it|can i)\b/
+      'Informational'
+    elsif q =~ /\b(best|review|reviews|top|vs|compare|alternative|alternatives|cost|pricing)\b/
+      'Commercial'
+    elsif q =~ /\b(buy|order|hire|cheap|service|services|near me|discount|coupon|deal|store|shop)\b/
+      'Transactional'
+    else
+      'Navigational'
+    end
+  end
+
+  def self.fetch_suggest(seed, country: 'us')
+    encoded = URI.encode_www_form_component(seed)
+    uri = URI("https://#{SUGGEST_HOST}/complete/search?client=chrome&hl=en&gl=#{country}&q=#{encoded}")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.open_timeout = 5
+    http.read_timeout = 10
+    req = Net::HTTP::Get.new(uri)
+    req['User-Agent'] = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    res = http.request(req)
+    return [] unless res.is_a?(Net::HTTPSuccess)
+    data = JSON.parse(res.body) rescue nil
+    (data && data[1].is_a?(Array)) ? data[1] : []
+  rescue StandardError
+    []
+  end
+
+  def self.expand(seed, country: 'us', limit: 50)
+    queries = []
+    queries.concat(fetch_suggest(seed, country: country))
+
+    modifiers = [
+      "how to #{seed}",
+      "best #{seed}",
+      "#{seed} reviews",
+      "#{seed} vs",
+      "#{seed} alternatives",
+      "cheap #{seed}",
+      "#{seed} near me"
+    ]
+    modifiers.each do |mod|
+      queries.concat(fetch_suggest(mod, country: country))
+    end
+
+    %w[a b c d f h m p s t w].each do |char|
+      queries.concat(fetch_suggest("#{seed} #{char}", country: country))
+    end
+
+    clean_list = queries.map(&:strip).reject(&:empty?).uniq.first(limit)
+    clean_list.map do |q|
+      {
+        keyword: q,
+        intent: classify_intent(q)
+      }
+    end
+  end
+
+def self.render_sparkline(values, max_points: 12)
+  return "" if values.nil? || values.empty?
+  sparks = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"]
+  vals = values.last(max_points)
+  min_val = vals.min.to_f
+  max_val = vals.max.to_f
+  range = max_val - min_val
+  if range <= 0
+    return sparks[3] * vals.length
+  end
+  vals.map do |v|
+    idx = [((v - min_val) / range * (sparks.length - 1)).round, sparks.length - 1].min
+    sparks[idx]
+  end.join
+end
+
+def self.read_clipboard
+  if RUBY_PLATFORM =~ /darwin/i
+    `pbpaste 2>/dev/null`
+  elsif system('which xclip > /dev/null 2>&1')
+    `xclip -selection clipboard -o 2>/dev/null`
+  elsif system('which wl-paste > /dev/null 2>&1')
+    `wl-paste 2>/dev/null`
+  else
+    nil
+  end
+end
+
+def self.import_file(source)
+  src_str = source.to_s.strip
+  raw_text = if ['clipboard', 'clip', 'paste', 'pbpaste'].include?(src_str.downcase)
+               txt = read_clipboard
+               raise "Clipboard is empty or could not be read. Copy a table from Keywords Everywhere and run: gsc import clip" if txt.nil? || txt.strip.empty?
+               txt
+             elsif src_str == '-'
+               $stdin.read
+             else
+               raise "File does not exist: #{src_str}" unless File.exist?(src_str)
+               File.read(src_str, encoding: 'UTF-8')
+             end
+
+  raw_lines = raw_text.lines.map(&:strip).reject(&:empty?)
+  raise "Import content is empty." if raw_lines.empty?
+
+
+  sample = raw_lines.find { |l| l =~ /keyword/i } || raw_lines.first
+  delim = if sample.count("\t") > 2
+            "\t"
+          elsif sample.count(',') > 2
+            ','
+          elsif sample.include?('|')
+            '|'
+          else
+            "\t"
+          end
+
+  header_idx = raw_lines.find_index { |l| l =~ /keyword|query/i } || 0
+  header_line = raw_lines[header_idx]
+  headers = header_line.split(delim).map { |h| h.strip.gsub(/[`*"]/, '') }
+
+  kw_col   = headers.find_index { |h| h =~ /^(keyword|query|search query)$/i } || 0
+  vol_col  = headers.find_index { |h| h =~ /(search volume|avg.*monthly searches|volume)/i }
+  cpc_col  = headers.find_index { |h| h =~ /(cpc|top of page bid)/i }
+  comp_col = headers.find_index { |h| h =~ /^(competition|competition \(indexed value\))$/i }
+  tier_col = headers.find_index { |h| h =~ /(tier|competition level)/i }
+  trend_col = headers.find_index { |h| h =~ /(trend.*%|three month change|yoy)/i }
+
+  # Detect any month columns (e.g. from Keywords Everywhere 12-month export)
+  month_cols = {}
+  headers.each_with_index do |h, idx|
+    if h =~ /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+\d{4}$/i || h =~ /^\d{4}[-\/]\d{2}$/
+      month_cols[h] = idx
+    end
+  end
+
+  data_rows = raw_lines[(header_idx + 1)..]
+  results = []
+  seen = {}
+
+  data_rows.each do |line|
+    next if line =~ /^\|?[- :|]+\|?$/
+
+    parts = line.split(delim).map { |p| p.strip.gsub(/[`*"]/, '') }
+    kw = parts[kw_col]
+    next if kw.nil? || kw.empty? || kw =~ /^(keyword|query|---|===)$/i
+    next if kw.downcase == 'keyword'
+
+    vol = vol_col ? parts[vol_col].to_s.gsub(/[,+ ]/, '').to_i : 0
+    cpc_raw = cpc_col ? parts[cpc_col].to_s.strip : '$0.00'
+    comp = comp_col ? parts[comp_col].to_s.to_f : 0.0
+    comp_tier = tier_col ? parts[tier_col].to_s.strip : nil
+    if comp_tier.nil? || comp_tier.empty?
+      comp_tier = if comp < 0.30 then 'Low'
+                  elsif comp < 0.70 then 'Medium'
+                  else 'High'
+                  end
+    end
+    trend = trend_col ? parts[trend_col].to_s.sub(/%/, '').to_i : 0
+    opp_score = calculate_opportunity(vol, comp)
+    intent = classify_intent(kw)
+
+    history = {}
+    month_cols.each do |m_name, c_idx|
+      m_val = parts[c_idx].to_s.gsub(/[,+ ]/, '')
+      history[m_name] = m_val.to_i unless m_val.empty?
+    end
+
+    kw_key = kw.downcase.strip
+    if seen[kw_key]
+      existing = seen[kw_key]
+      if vol > existing[:volume]
+        existing[:volume] = vol
+        existing[:cpc] = cpc_raw if cpc_raw != '$0.00'
+        existing[:competition] = comp
+        existing[:competition_tier] = comp_tier
+        existing[:trend_pct] = trend
+        existing[:opportunity_score] = opp_score
+      end
+      existing[:monthly_history] = history.merge(existing[:monthly_history] || {}) unless history.empty?
+    else
+      entry = {
+        keyword: kw,
+        volume: vol,
+        cpc: cpc_raw,
+        competition: comp,
+        competition_tier: comp_tier,
+        trend_pct: trend,
+        opportunity_score: opp_score,
+        intent: intent
+      }
+if !history.empty?
+  entry[:monthly_history] = history
+  entry[:sparkline] = render_sparkline(history.values)
+end
+      seen[kw_key] = entry
+      results << entry
+    end
+  end
+
+  results.sort_by { |r| [-r[:opportunity_score], -r[:volume]] }
+end
+
+  def self.correlate_with_gsc(keywords, api, site_url, days: 30)
+    return keywords if api.nil? || site_url.nil?
+
+    res = api.query_analytics(site_url, days: days, dimensions: ['query'], row_limit: 5000)
+    return keywords unless res[:ok]
+
+    gsc_map = {}
+    (res.dig(:data, 'rows') || []).each do |r|
+      q = r['keys'].first.to_s.downcase.strip
+      gsc_map[q] = {
+        clicks: r['clicks'],
+        impressions: r['impressions'],
+        ctr: (r['ctr'] * 100).round(1),
+        position: r['position'].round(1)
+      }
+    end
+
+    keywords.map do |kw_item|
+      item = kw_item.dup
+      q = item[:keyword].to_s.downcase.strip
+      if gsc_map[q]
+        g = gsc_map[q]
+        pos = g[:position]
+        status = if pos <= 3.0 then "🏆 Top 3 (Pos #{pos})"
+                 elsif pos <= 10.0 then "🥇 Page 1 (Pos #{pos})"
+                 elsif pos <= 20.0 then "🎯 Striking Distance (Pos #{pos})"
+                 else "🔍 Deep SERP (Pos #{pos})"
+                 end
+        item[:gsc] = g.merge(status: status)
+      else
+        item[:gsc] = { clicks: 0, impressions: 0, ctr: 0.0, position: 0.0, status: '🚀 Untargeted' }
+      end
+      item
+    end
+  end
+end
+end

data/lib/gsc/keywords_everywhere.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module GSC
+class KeywordsEverywhere
+  API_HOST = "api.keywordseverywhere.com"
+
+  def self.api_key
+    Config.keywords_everywhere_api_key
+  end
+
+  def self.check_account(key = nil)
+    k = (key && !key.to_s.strip.empty?) ? key.to_s.strip : api_key
+    return { ok: false, error: "Keywords Everywhere API key not configured. Run: gsc connect ke" } if k.nil? || k.empty?
+
+    uri = URI("https://#{API_HOST}/v1/account/credits")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.open_timeout = 6
+    http.read_timeout = 12
+
+    req = Net::HTTP::Get.new(uri)
+    req["Authorization"] = "Bearer #{k}"
+    req["Accept"] = "application/json"
+    req["User-Agent"] = "gsc-cli/#{GSC::VERSION}"
+
+    res = http.request(req)
+    parsed = begin
+               JSON.parse(res.body)
+             rescue StandardError
+               res.body
+             end
+
+    if res.is_a?(Net::HTTPSuccess)
+      # Keywords Everywhere /v1/account/credits returns an array with remaining credits as the only element: [ 95597755 ]
+      # Some endpoints or proxies may return a Hash: {"credits": 95597755}
+      credits = if parsed.is_a?(Array)
+                  parsed.first.is_a?(Hash) ? (parsed.first["credits"] || parsed.first["data"] || 0) : parsed.first.to_i
+                elsif parsed.is_a?(Hash)
+                  parsed["credits"] || parsed["data"] || parsed["credits_left"] || 0
+                else
+                  parsed.to_i
+                end
+      credits = credits.first if credits.is_a?(Array)
+      { ok: true, credits: credits.to_i }
+    else
+      err_msg = if parsed.is_a?(Hash)
+                  parsed["message"] || parsed["error"] || parsed["description"] || "HTTP #{res.code}"
+                elsif parsed.is_a?(Array)
+                  parsed.map { |x| x.is_a?(Hash) ? (x["message"] || x["error"]) : x.to_s }.join(", ")
+                else
+                  "HTTP #{res.code}: #{parsed}"
+                end
+      { ok: false, error: err_msg }
+    end
+  rescue StandardError => e
+    { ok: false, error: e.message }
+  end
+
+  def self.fetch_data(keywords, country: "us", currency: "usd", data_source: "gkp", key: nil)
+    k = (key && !key.to_s.strip.empty?) ? key.to_s.strip : api_key
+    return { ok: false, error: "Keywords Everywhere API key not configured. Run: gsc connect ke" } if k.nil? || k.empty?
+
+    kw_list = Array(keywords).map(&:to_s).map(&:strip).reject(&:empty?).uniq
+    return { ok: true, count: 0, data: [] } if kw_list.empty?
+
+    results = []
+    # Batch up to 100 keywords per request
+    kw_list.each_slice(100) do |slice|
+      uri = URI("https://#{API_HOST}/v1/get_keyword_data")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 10
+      http.read_timeout = 30
+
+      req = Net::HTTP::Post.new(uri)
+      req["Authorization"] = "Bearer #{k}"
+      req["Accept"] = "application/json"
+      req["User-Agent"] = "gsc-cli/#{GSC::VERSION}"
+      req["Content-Type"] = "application/x-www-form-urlencoded"
+
+      form = {
+        "country" => country.to_s.downcase,
+        "currency" => currency.to_s.downcase,
+        "dataSource" => data_source.to_s.downcase
+      }
+      base_encoded = URI.encode_www_form(form)
+      kw_params = slice.map { |kw| "kw[]=#{URI.encode_www_form_component(kw)}" }.join("&")
+      req.body = "#{base_encoded}&#{kw_params}"
+
+      res = http.request(req)
+      parsed = begin
+                 JSON.parse(res.body)
+               rescue StandardError
+                 res.body
+               end
+
+      if res.is_a?(Net::HTTPSuccess)
+        raw_items = if parsed.is_a?(Hash)
+                      parsed["data"] || []
+                    elsif parsed.is_a?(Array)
+                      parsed
+                    else
+                      []
+                    end
+
+        raw_items.each do |item|
+          next unless item.is_a?(Hash)
+          vol = item["vol"].to_i
+          cpc_val = (item["cpc"].is_a?(Hash) ? item.dig("cpc", "value") : item["cpc"]).to_f
+          currency_sym = (item["cpc"].is_a?(Hash) ? item.dig("cpc", "currency") : "$") || "$"
+          comp = item["competition"].to_f
+          trend = item["trend"] || []
+          opp_score = KeywordPlanner.calculate_opportunity(vol, comp)
+          intent = KeywordPlanner.classify_intent(item["keyword"])
+
+          results << {
+            keyword: item["keyword"],
+            volume: vol,
+            cpc: cpc_val,
+            currency: currency_sym,
+            competition: comp,
+            opportunity_score: opp_score,
+            intent: intent,
+            trend: trend
+          }
+        end
+      else
+        err = if parsed.is_a?(Hash)
+                parsed["message"] || parsed["error"] || "HTTP #{res.code}"
+              elsif parsed.is_a?(Array)
+                parsed.map { |x| x.is_a?(Hash) ? (x["message"] || x["error"]) : x.to_s }.join(", ")
+              else
+                "HTTP #{res.code}"
+              end
+        return { ok: false, error: "Keywords Everywhere API error: #{err}" }
+      end
+    end
+
+    { ok: true, count: results.size, data: results }
+  rescue StandardError => e
+    { ok: false, error: e.message }
+  end
+end
+end