rogiq 0.1.0

data/lib/rogiq/commands/seo_audit.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class SEOAudit < RogIQ::Commands::Base
+      desc "run CLIENT", "Create audit run + enqueue SeoModule::AuditKickoffJob"
+      map run: :kickoff
+      def kickoff(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        settings = ::ClientSeoModuleSetting.find_or_create_by!(client_id: client.id)
+        seed = client.website.presence
+        if seed.blank?
+          fmt.error_msg("Client needs a website URL for audit seed")
+          exit 1
+        end
+
+        audit_run = client.client_seo_module_audit_runs.create!(
+          status: "pending",
+          max_pages: settings.crawl_max_pages,
+          seed_url: seed.to_s.strip,
+          started_at: Time.current
+        )
+        ::SeoModule::AuditKickoffJob.perform_later(audit_run.id)
+        fmt.success("Audit run #{audit_run.id} enqueued.")
+        fmt.output(id: audit_run.id, status: audit_run.status, seed_url: audit_run.seed_url)
+      end
+
+      desc "status CLIENT", "Latest SEO module audit runs"
+      def status(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        runs = client.client_seo_module_audit_runs.order(created_at: :desc).limit(15)
+        rows = runs.map do |r|
+          [r.id, r.status, r.seed_url.to_s.truncate(60), r.created_at.iso8601]
+        end
+        fmt.output(headers: %w[id status seed_url created_at], rows: rows)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/status.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module RogIQ
+  module Commands
+    class Status < RogIQ::Commands::Base
+      default_task :dashboard
+
+      desc "dashboard", "System health (default: full dashboard)"
+      method_option :ping, type: :boolean, default: false, desc: "HTTP GET /up only (no Rails boot)"
+      method_option :queues, type: :boolean, default: false, desc: "Solid Queue breakdown by queue name"
+      method_option :db, type: :boolean, default: false, desc: "Database connectivity + schema version"
+      method_option :redis, type: :boolean, default: false, desc: "Redis ping (REDIS_URL)"
+      method_option :ai, type: :boolean, default: false, desc: "AI provider env configuration"
+      method_option :host, type: :string, default: nil, desc: "Base URL for --ping (default ROGIQ_HEALTH_URL or http://127.0.0.1:3000)"
+
+      def dashboard
+        return ping_only if options[:ping]
+
+        subset = options[:queues] || options[:db] || options[:redis] || options[:ai]
+        return dashboard_partial if subset
+
+        dashboard_full
+      end
+
+      private
+
+      def ping_only
+        host_opt = options[:host].to_s.strip
+        base = if host_opt.empty?
+          ENV.fetch("ROGIQ_HEALTH_URL", "http://127.0.0.1:3000").chomp("/")
+        else
+          host_opt.chomp("/")
+        end
+        uri = URI("#{base}/up")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 3
+        http.read_timeout = 5
+        req_path = uri.path.to_s
+        req_path = "/" if req_path.empty?
+        res = http.request_get(req_path)
+        payload = { url: uri.to_s, code: res.code, body: res.body.to_s[0, 200] }
+        fmt.output(payload)
+        exit(res.code.to_i >= 400 ? 1 : 0)
+      rescue StandardError => e
+        fmt.error_msg("Ping failed: #{e.message}")
+        exit 1
+      end
+
+      def dashboard_partial
+        RogIQ.load_rails!
+        rows = []
+        headers = %w[check status detail]
+
+        if options[:queues]
+          rows.concat(queue_rows)
+        end
+        if options[:db]
+          rows << db_row
+        end
+        if options[:redis]
+          rows << redis_row
+        end
+        if options[:ai]
+          rows << ai_row
+        end
+
+        fmt.output(headers: headers, rows: rows)
+      end
+
+      def dashboard_full
+        RogIQ.load_rails!
+        headers = %w[check status detail]
+        rows = []
+        rows << db_row
+        rows << redis_row
+        rows << ai_row
+        rows << queue_summary_row
+        rows.concat(queue_rows) if solid_queue_tables?
+
+        fmt.output(headers: headers, rows: rows)
+
+        host = ENV.fetch("ROGIQ_HEALTH_URL", "http://127.0.0.1:3000").chomp("/")
+        ping_http("#{host}/health", "HTTP /health")
+        ping_http("#{host}/up", "HTTP /up")
+      end
+
+      def ping_http(url, label)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 2
+        http.read_timeout = 3
+        res = http.request_get(uri.path)
+        fmt.say("#{label}: #{res.code}")
+      rescue StandardError => e
+        fmt.warn_msg("#{label}: unreachable (#{e.message})")
+      end
+
+      def db_row
+        ver = ActiveRecord::Base.connection.select_value(
+          "SELECT MAX(version) FROM schema_migrations"
+        )
+        ["database", "ok", "migration=#{ver}"]
+      rescue StandardError => e
+        ["database", "error", e.message.to_s[0, 120]]
+      end
+
+      def redis_row
+        url = ENV["REDIS_URL"].presence
+        return ["redis", "skipped", "REDIS_URL not set"] unless url
+
+        require "redis"
+        r = Redis.new(url: url)
+        pong = r.ping
+        info = r.info("memory") rescue {}
+        used = info["used_memory_human"]
+        ["redis", pong || "ok", "memory=#{used}"]
+      rescue LoadError
+        ["redis", "skipped", "redis gem"]
+      rescue StandardError => e
+        ["redis", "error", e.message.to_s[0, 120]]
+      end
+
+      def ai_row
+        openai = ENV["OPENAI_API_KEY"].present?
+        anthropic = ENV["ANTHROPIC_API_KEY"].present?
+        detail = "openai=#{openai} anthropic=#{anthropic}"
+        ready = defined?(AIEngine) && AIEngine.ready?
+        ["ai_engine", ready ? "ready" : "not_ready", detail]
+      rescue StandardError => e
+        ["ai_engine", "error", e.message.to_s[0, 120]]
+      end
+
+      def queue_summary_row
+        return ["solid_queue", "n/a", "tables missing"] unless solid_queue_tables?
+
+        r = SolidQueue::ReadyExecution.count
+        s = SolidQueue::ScheduledExecution.count
+        f = SolidQueue::FailedExecution.count
+        c = SolidQueue::ClaimedExecution.count
+        ["solid_queue", "ok", "ready=#{r} scheduled=#{s} failed=#{f} claimed=#{c}"]
+      rescue StandardError => e
+        ["solid_queue", "error", e.message.to_s[0, 120]]
+      end
+
+      def queue_rows
+        return [] unless solid_queue_tables?
+
+        SolidQueue::Job.group(:queue_name).count.sort.map do |name, cnt|
+          paused = SolidQueue::Queue.find_by_name(name).paused?
+          ["queue:#{name}", paused ? "paused" : "active", "jobs=#{cnt}"]
+        end
+      rescue StandardError => e
+        [["queues", "error", e.message.to_s[0, 120]]]
+      end
+
+      def solid_queue_tables?
+        ActiveRecord::Base.connection.data_source_exists?("solid_queue_jobs")
+      end
+    end
+  end
+end

data/lib/rogiq/commands/sync.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Sync < RogIQ::Commands::Base
+      desc "postman", "rails postman:sync"
+      def postman
+        RogIQ.load_rails!
+        Rails.application.load_tasks
+        Rake::Task["postman:sync"].invoke
+      end
+
+      desc "stripe", "rake stripe:ensure_subscription_prices"
+      def stripe
+        RogIQ.load_rails!
+        Rails.application.load_tasks
+        Rake::Task["stripe:ensure_subscription_prices"].invoke
+      end
+
+      desc "wordpress CLIENT", "Enqueue WordPress taxonomies + authors sync jobs"
+      def wordpress(identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        ::Integrations::SyncWordpressTaxonomiesJob.perform_later(
+          account_id: client.account_id,
+          client_id: client.id
+        )
+        ::Integrations::SyncWordpressAuthorsJob.perform_later(
+          account_id: client.account_id,
+          client_id: client.id
+        )
+        fmt.success("WordPress sync jobs enqueued for client #{client.id}.")
+      end
+
+      desc "integrations CLIENT", "Enqueue Integrations::SyncJob for each client integration"
+      def integrations(identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        ids = client.integrations.pluck(:id)
+        if ids.empty?
+          fmt.warn_msg("No integrations linked to this client.")
+          return
+        end
+
+        ids.each { |iid| ::Integrations::SyncJob.perform_later(iid) }
+        fmt.success("Enqueued #{ids.size} Integrations::SyncJob(s).")
+      end
+    end
+  end
+end

data/lib/rogiq/config_store.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module RogIQ
+  module ConfigStore
+    DIR = File.join(Dir.home, ".rogiq").freeze
+    PATH = File.join(DIR, "config.yml").freeze
+
+    module_function
+
+    def load
+      return {} unless File.file?(PATH)
+
+      YAML.safe_load(File.read(PATH), permitted_classes: [ Symbol, Time ]) || {}
+    rescue Psych::SyntaxError
+      {}
+    end
+
+    def save(hash)
+      FileUtils.mkdir_p(DIR)
+      File.write(PATH, YAML.dump(stringify_keys(hash)))
+    end
+
+    def merge!(attrs)
+      save(load.merge(stringify_keys(attrs)))
+    end
+
+    def clear!
+      FileUtils.rm_f(PATH)
+    end
+
+    def remote_available?
+      h = load
+      !h["token"].to_s.strip.empty? && !h["api_base_url"].to_s.strip.empty?
+    end
+
+    def api_base_url
+      v = load["api_base_url"].to_s.strip
+      v.empty? ? nil : v
+    end
+
+    def token
+      v = load["token"].to_s.strip
+      v.empty? ? nil : v
+    end
+
+    def account_id
+      v = load["account_id"]
+      s = v.to_s.strip
+      s.empty? ? nil : s
+    end
+
+    def stringify_keys(hash)
+      hash.to_h.transform_keys(&:to_s)
+    end
+  end
+end

data/lib/rogiq/formatters.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require "date"
+
+module RogIQ
+  class Formatters
+    attr_reader :format, :quiet
+
+    def initialize(format: "table", quiet: false)
+      @format = format.to_s
+      @quiet = quiet
+    end
+
+    def say(msg = "")
+      Kernel.puts(msg) unless quiet
+    end
+
+    def success(msg)
+      say(colorize(msg, "\e[32m"))
+    end
+
+    def warn_msg(msg)
+      say(colorize(msg, "\e[33m"))
+    end
+
+    def error_msg(msg)
+      $stderr.puts(colorize(msg, "\e[31m"))
+    end
+
+    def output(data)
+      if data.is_a?(Hash) && data[:headers] && data[:rows]
+        return table(data[:headers], data[:rows]) if format != "json"
+
+        STDOUT.puts(JSON.pretty_generate({ headers: data[:headers], rows: data[:rows] }))
+        return
+      end
+
+      if format == "json"
+        STDOUT.puts(JSON.pretty_generate(jsonify(data)))
+        return
+      end
+
+      case data
+      when Hash
+        say(JSON.pretty_generate(jsonify(data)))
+      when String
+        say(data)
+      else
+        say(data.inspect)
+      end
+    end
+
+    def jsonify(obj)
+      case obj
+      when Hash
+        obj.transform_values { |v| jsonify(v) }
+      when Array
+        obj.map { |v| jsonify(v) }
+      when Time, DateTime
+        obj.iso8601
+      when Date
+        obj.iso8601
+      else
+        if obj.respond_to?(:iso8601)
+          obj.iso8601
+        else
+          obj
+        end
+      end
+    end
+
+    def table(headers, rows)
+      return if quiet
+
+      rows = rows.map { |r| r.map(&:to_s) }
+      widths = headers.each_with_index.map do |h, i|
+        [h.to_s.length, *rows.map { |r| r[i].to_s.length }].max
+      end
+
+      sep = widths.map { |w| "-" * w }.join("-+-")
+      header_line = headers.each_with_index.map { |h, i| h.to_s.ljust(widths[i]) }.join(" | ")
+      say(header_line)
+      say(sep)
+      rows.each do |row|
+        say(row.each_with_index.map { |cell, i| cell.to_s.ljust(widths[i]) }.join(" | "))
+      end
+    end
+
+    def confirm!(prompt, yes: false)
+      return true if yes
+
+      print("#{prompt} [y/N] ")
+      $stdin.gets.to_s.strip.downcase.start_with?("y")
+    end
+
+    def colorize(str, code)
+      return str unless $stdout.tty?
+
+      "#{code}#{str}\e[0m"
+    end
+  end
+end

data/lib/rogiq/helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Helpers
+    module_function
+
+    UUID_RE = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+    def uuid?(value)
+      value.to_s.match?(UUID_RE)
+    end
+
+    def resolve_client(identifier)
+      RogIQ.load_rails!
+      s = identifier.to_s.strip
+      return nil if s.blank?
+
+      if uuid?(s)
+        ::Client.find_by(id: s)
+      else
+        ::Client.find_by("LOWER(name) = ?", s.downcase) ||
+          ::Client.joins(:account).find_by("LOWER(accounts.slug) = ?", s.downcase) ||
+          ::Client.find_by(id: s)
+      end
+    end
+
+    def resolve_account(identifier)
+      RogIQ.load_rails!
+      s = identifier.to_s.strip
+      return nil if s.blank?
+
+      if uuid?(s)
+        ::Account.find_by(id: s)
+      else
+        ::Account.find_by("LOWER(slug) = ?", s.downcase) ||
+          ::Account.find_by("LOWER(name) = ?", s.downcase) ||
+          ::Account.find_by(id: s)
+      end
+    end
+
+    def fmt_from_options(options)
+      RogIQ::Formatters.new(format: options[:format] || options["format"], quiet: options[:quiet] || options["quiet"])
+    end
+
+    def with_saved_argv(new_argv)
+      old = ARGV.dup
+      ARGV.replace(new_argv)
+      yield
+    ensure
+      ARGV.replace(old)
+    end
+  end
+end

data/lib/rogiq/http_api.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module RogIQ
+  class HttpApi
+    class Error < StandardError
+      attr_reader :status, :body
+
+      def initialize(message, status: nil, body: nil)
+        super(message)
+        @status = status
+        @body = body
+      end
+    end
+
+    def self.from_config!
+      base = RogIQ::ConfigStore.api_base_url
+      token = RogIQ::ConfigStore.token
+      raise Error, "Not logged in. Run: rogiq login" if base.nil? || token.nil?
+
+      new(base: base, token: token, account_id: RogIQ::ConfigStore.account_id)
+    end
+
+    def initialize(base:, token:, account_id: nil)
+      @base = base.to_s.chomp("/")
+      @token = token
+      @account_id = account_id
+    end
+
+    def get(path, query = {})
+      request(Net::HTTP::Get, path, query: query)
+    end
+
+    def post(path, body = nil, query: {})
+      request(Net::HTTP::Post, path, query: query, body: body)
+    end
+
+    private
+
+    def request(method_class, path, query: {}, body: nil)
+      p = path.start_with?("/") ? path : "/#{path}"
+      uri = URI.parse("#{@base}#{p}")
+      uri.query = URI.encode_www_form(query.compact) if query.any?
+
+      req = method_class.new(uri)
+      req["Authorization"] = "Bearer #{@token}"
+      req["Accept"] = "application/json"
+      if body
+        req["Content-Type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+      aid = @account_id.to_s.strip
+      req["X-Account-ID"] = aid unless aid.empty?
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 15
+      http.read_timeout = 120
+      res = http.request(req)
+      payload = parse_json_body(res)
+
+      return payload if res.is_a?(Net::HTTPSuccess)
+
+      msg = [ payload["error"], payload["message"] ].map { |x| x.to_s.strip }.reject(&:empty?).first
+      msg ||= "HTTP #{res.code}"
+      raise Error.new(msg.to_s, status: res.code.to_i, body: payload)
+    end
+
+    def parse_json_body(res)
+      b = res.body.to_s.strip
+      return {} if b.empty?
+
+      JSON.parse(b)
+    rescue JSON::ParserError
+      { "error" => b[0, 300] }
+    end
+  end
+end

data/lib/rogiq/rails_loader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RogIQ
+  # Boots the Rails application (api/) once. Safe to call multiple times.
+  def self.load_rails!
+    return if defined?(Rails) && Rails.application&.initialized?
+
+    root = api_root
+    Dir.chdir(root) do
+      require File.join(root, "config/environment")
+    end
+  end
+
+  def self.api_root
+    File.expand_path("../..", __dir__)
+  end
+
+  # Monorepo root (parent of +api/+).
+  def self.repo_root
+    File.expand_path("../../..", __dir__)
+  end
+end

data/lib/rogiq/remote/accounts.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rogiq/remote/command_base"
+
+module RogIQ
+  module Remote
+    class Accounts < RogIQ::Remote::CommandBase
+      desc "list", "List accounts"
+      method_option :search, type: :string
+      method_option :limit, type: :numeric, default: 40, aliases: "-n"
+      def list
+        q = { limit: options[:limit] }
+        q[:search] = options[:search] unless options[:search].to_s.strip.empty?
+        emit(api.get("/api/v1/cli/accounts/list", q))
+      end
+
+      desc "show IDENTIFIER", "Account by id, slug, or name"
+      def show(identifier)
+        emit(api.get("/api/v1/cli/accounts/show", { identifier: identifier }))
+      end
+
+      desc "usage IDENTIFIER", "Usage meters, wallet, open overages"
+      def usage(identifier)
+        emit(api.get("/api/v1/cli/accounts/usage", { identifier: identifier }))
+      end
+
+      desc "subscription IDENTIFIER", "Subscription + plan summary"
+      def subscription(identifier)
+        emit(api.get("/api/v1/cli/accounts/subscription", { identifier: identifier }))
+      end
+
+      desc "users IDENTIFIER", "Active account users + roles"
+      def users(identifier)
+        emit(api.get("/api/v1/cli/accounts/users", { identifier: identifier }))
+      end
+    end
+  end
+end

data/lib/rogiq/remote/ai.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rogiq/remote/command_base"
+
+module RogIQ
+  module Remote
+    class Ai < RogIQ::Remote::CommandBase
+      desc "status", "AI engine readiness + provider keys"
+      def status
+        emit(api.get("/api/v1/cli/ai/status"))
+      end
+
+      desc "cost", "Roll up AI usage cost (ai_usage_daily)"
+      method_option :days, type: :numeric, default: 30
+      method_option :account, type: :string, desc: "Account id or slug"
+      def cost
+        q = { days: options[:days] }
+        q[:account] = options[:account] unless options[:account].to_s.strip.empty?
+        emit(api.get("/api/v1/cli/ai/cost", q))
+      end
+
+      desc "models", "List AIModelConfig rows"
+      method_option :limit, type: :numeric, default: 100
+      def models
+        emit(api.get("/api/v1/cli/ai/models", { limit: options[:limit] }))
+      end
+
+      desc "sync", "Enqueue AiModelSyncJob"
+      method_option :yes, type: :boolean, default: false, aliases: "-y"
+      def sync
+        unless options[:yes]
+          exit 1 unless yes?("Enqueue AiModelSyncJob?")
+        end
+
+        emit(api.post("/api/v1/cli/ai/sync", { confirm: true }))
+      end
+
+      desc "health_check", "Enqueue AiModelHealthCheckJob"
+      map "health-check" => :health_check
+      method_option :yes, type: :boolean, default: false, aliases: "-y"
+      def health_check
+        unless options[:yes]
+          exit 1 unless yes?("Enqueue AiModelHealthCheckJob?")
+        end
+
+        emit(api.post("/api/v1/cli/ai/health_check", { confirm: true }))
+      end
+    end
+  end
+end