rogiq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e6164cbe6a3fe5aeec2b3602d8c2401c552cb4d08ee8160d044bdf0296e17a9
+  data.tar.gz: c80152ab3a4191dc0991f178bcc60a94f2aa359cc176e5d16989e47a078e410a
+SHA512:
+  metadata.gz: 8320cbe572bbfc5e54405e1a4e9967bfe900d0902bdf2c417c7dbb65c2aabde043fb87ed425c7e2c79d0cf9cc1e377212e3a4bacaf8a47652822cfb8020f2597
+  data.tar.gz: 61c8fb1e700c98086f848086d33c1de7046181128f6857d4b05b30183dc152dc299766ab3abff5e73559a7d12cda5b3eb7e5e81ad9c226e761b6deaa57981e5e

data/exe/rogiq

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "rogiq/version"
+
+argv = ARGV.dup
+if %w[version -v --version].include?(argv.first)
+  puts RogIQ::VERSION
+  exit 0
+end
+
+force_local = ENV["ROGIQ_LOCAL"].to_s == "1" || argv.delete("--local")
+
+require "rogiq/config_store"
+
+first = argv.first
+auth_cmds = %w[login logout whoami use]
+
+if auth_cmds.include?(first)
+  require "rogiq/commands/auth"
+  RogIQ::Commands::Auth.start(argv)
+elsif !force_local && RogIQ::ConfigStore.remote_available?
+  require "rogiq/remote_cli"
+  RogIQ::RemoteCLI.start(argv)
+else
+  require "rogiq/rails_loader"
+  require "rogiq/formatters"
+  require "rogiq/helpers"
+  require "rogiq/commands/base"
+  require "rogiq/commands/status"
+  require "rogiq/commands/queue"
+  require "rogiq/commands/jobs"
+  require "rogiq/commands/clients"
+  require "rogiq/commands/accounts"
+  require "rogiq/commands/billing_stripe"
+  require "rogiq/commands/billing"
+  require "rogiq/commands/ai"
+  require "rogiq/commands/seo_audit"
+  require "rogiq/commands/seo"
+  require "rogiq/commands/content"
+  require "rogiq/commands/diagnose"
+  require "rogiq/commands/security"
+  require "rogiq/commands/sync"
+  require "rogiq/cli"
+  RogIQ::CLI.start(argv)
+end

data/lib/rogiq/cli.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module RogIQ
+  class CLI < Thor
+    package_name "RogIQ"
+
+    desc "version", "Print rogiq version"
+    map %w[--version -v] => :version
+    def version
+      puts RogIQ::VERSION
+    end
+
+    desc "status SUBCOMMAND ...", "System health / queues / DB / Redis / AI config"
+    subcommand "status", RogIQ::Commands::Status
+
+    desc "queue SUBCOMMAND ...", "Solid Queue operations"
+    subcommand "queue", RogIQ::Commands::Queue
+
+    desc "jobs SUBCOMMAND ...", "Inspect and manage failed Solid Queue jobs"
+    subcommand "jobs", RogIQ::Commands::Jobs
+
+    desc "clients SUBCOMMAND ...", "Client lookup and settings"
+    subcommand "clients", RogIQ::Commands::Clients
+
+    desc "accounts SUBCOMMAND ...", "Accounts, subscriptions, usage"
+    subcommand "accounts", RogIQ::Commands::Accounts
+
+    desc "ai SUBCOMMAND ...", "AI usage, models, jobs"
+    subcommand "ai", RogIQ::Commands::AI
+
+    desc "seo SUBCOMMAND ...", "SEO module, audits, keywords"
+    subcommand "seo", RogIQ::Commands::SEO
+
+    desc "billing SUBCOMMAND ...", "Coins, invoices, Stripe catalog, usage overages"
+    subcommand "billing", RogIQ::Commands::Billing
+
+    desc "content SUBCOMMAND ...", "Content pipeline & healing"
+    subcommand "content", RogIQ::Commands::Content
+
+    desc "diagnose SUBCOMMAND ...", "Targeted diagnostics"
+    subcommand "diagnose", RogIQ::Commands::Diagnose
+
+    desc "security SUBCOMMAND ...", "Brakeman, bundler-audit, security_policy rake"
+    subcommand "security", RogIQ::Commands::Security
+
+    desc "sync SUBCOMMAND ...", "Postman, Stripe catalog, WordPress, integrations"
+    subcommand "sync", RogIQ::Commands::Sync
+  end
+end

data/lib/rogiq/commands/accounts.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Accounts < RogIQ::Commands::Base
+      desc "list", "List accounts"
+      method_option :search, type: :string, desc: "Filter name or slug (ILIKE)"
+      method_option :limit, type: :numeric, default: 40, aliases: "-n"
+      def list
+        RogIQ.load_rails!
+        scope = ::Account.order(created_at: :desc)
+        if options[:search].present?
+          q = "%#{options[:search]}%"
+          scope = scope.where("name ILIKE ? OR slug ILIKE ?", q, q)
+        end
+        rows = scope.limit(options[:limit]).map do |a|
+          [a.id, a.name, a.slug, a.status, a.account_type]
+        end
+        fmt.output(headers: %w[id name slug status account_type], rows: rows)
+      end
+
+      desc "show IDENTIFIER", "Account detail by id, slug, or name"
+      def show(identifier)
+        RogIQ.load_rails!
+        a = RogIQ::Helpers.resolve_account(identifier)
+        unless a
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        fmt.output(
+          id: a.id,
+          name: a.name,
+          slug: a.slug,
+          status: a.status,
+          account_type: a.account_type,
+          billing_status: a.try(:billing_status),
+          created_at: a.created_at
+        )
+      end
+
+      desc "usage IDENTIFIER", "Usage meters, coin wallet, open overages"
+      def usage(identifier)
+        RogIQ.load_rails!
+        a = RogIQ::Helpers.resolve_account(identifier)
+        unless a
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        meters = ::UsageMeter.where(account_id: a.id).order(period_end: :desc).limit(20).map do |m|
+          {
+            metric_type: m.metric_type,
+            period_start: m.period_start,
+            period_end: m.period_end,
+            current_value: m.current_value
+          }
+        end
+        wallet = a.rogue_coin_wallet
+        overages = a.usage_overages.status_pending.limit(20)
+
+        fmt.output(
+          account_id: a.id,
+          rogue_coin_balance: wallet&.balance,
+          rogue_coin_lifetime_spent: wallet&.lifetime_spent,
+          usage_meters: meters,
+          open_overages: overages.map do |o|
+            {
+              id: o.id,
+              metric: o.metric_type,
+              overage_amount: o.overage_amount,
+              total_charge: o.total_charge.to_f,
+              status: o.status,
+              created_at: o.created_at
+            }
+          end
+        )
+      end
+
+      desc "subscription IDENTIFIER", "Subscription + plan summary"
+      def subscription(identifier)
+        RogIQ.load_rails!
+        a = RogIQ::Helpers.resolve_account(identifier)
+        unless a
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        sub = a.subscription
+        plan = sub&.subscription_plan
+        fmt.output(
+          account_id: a.id,
+          subscription: sub&.slice(:id, :status, :trial_ends_at, :current_period_start, :current_period_end, :cancel_at_period_end),
+          plan: plan&.slice(:id, :name, :slug)
+        )
+      end
+
+      desc "users IDENTIFIER", "Active account users + roles"
+      def users(identifier)
+        RogIQ.load_rails!
+        a = RogIQ::Helpers.resolve_account(identifier)
+        unless a
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        rows = a.account_users.includes(:user, :role).where(status: "active").map do |au|
+          [au.user&.email, au.role&.name, au.status]
+        end
+        fmt.output(headers: %w[email role status], rows: rows)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/ai.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class AI < RogIQ::Commands::Base
+      desc "status", "AI engine readiness + provider keys"
+      def status
+        RogIQ.load_rails!
+        payload = {
+          openai_key_present: ENV["OPENAI_API_KEY"].present?,
+          anthropic_key_present: ENV["ANTHROPIC_API_KEY"].present?,
+          ai_engine_ready: defined?(AIEngine) && AIEngine.ready?,
+          available_providers: (defined?(AIEngine) ? AIEngine.available_providers : [])
+        }
+        if defined?(Rails.configuration.ai_engine)
+          cfg = Rails.configuration.ai_engine
+          payload[:openai_enabled] = cfg.try(:openai_enabled)
+          payload[:anthropic_enabled] = cfg.try(:anthropic_enabled)
+        end
+        fmt.output(payload)
+      end
+
+      desc "cost", "Roll up AI usage cost from ai_usage_daily"
+      method_option :days, type: :numeric, default: 30, desc: "Lookback window (days)"
+      method_option :account, type: :string, desc: "Limit to account id or slug"
+      def cost
+        RogIQ.load_rails!
+        start_date = options[:days].to_i.days.ago.to_date
+        scope = ::AIUsageDaily.where("usage_date >= ?", start_date)
+        if options[:account].present?
+          acc = RogIQ::Helpers.resolve_account(options[:account])
+          unless acc
+            fmt.error_msg("Account not found")
+            exit 1
+          end
+          scope = scope.where(account_id: acc.id)
+        end
+
+        rows = scope.group(:provider, :model).sum(:total_cost).sort_by { |_, v| -v.to_f }.first(50)
+        fmt.output(headers: %w[provider model total_cost], rows: rows.map { |(p, m), t| [p, m, t.to_f.round(6)] })
+        total = scope.sum(:total_cost)
+        fmt.say("Total (period): #{total.to_f.round(6)}") unless options[:quiet]
+      end
+
+      desc "sync", "Enqueue AiModelSyncJob"
+      def sync
+        RogIQ.load_rails!
+        ::AiModelSyncJob.perform_later
+        fmt.success("AiModelSyncJob enqueued.")
+      end
+
+      desc "health_check", "Enqueue AiModelHealthCheckJob"
+      map "health-check" => :health_check
+      def health_check
+        RogIQ.load_rails!
+        ::AiModelHealthCheckJob.perform_later
+        fmt.success("AiModelHealthCheckJob enqueued.")
+      end
+
+      desc "models", "List AIModelConfig rows"
+      method_option :limit, type: :numeric, default: 100
+      def models
+        RogIQ.load_rails!
+        rows = ::AIModelConfig.order(:sort_order, :display_name).limit(options[:limit]).map do |m|
+          [m.model_key, m.provider, m.display_name, m.enabled, m.available?]
+        end
+        fmt.output(headers: %w[model_key provider display_name enabled available], rows: rows)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/auth.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+require "thor"
+
+require "rogiq/config_store"
+require "rogiq/formatters"
+require "rogiq/http_api"
+
+module RogIQ
+  module Commands
+    class Auth < Thor
+      class_option :format,
+                   aliases: "-f",
+                   type: :string,
+                   default: "table",
+                   enum: %w[table json],
+                   desc: "Output format"
+
+      desc "login", "Sign in and save a CLI API token to ~/.rogiq/config.yml"
+      method_option :api,
+                    type: :string,
+                    default: nil,
+                    desc: "API base URL (default #{ENV.fetch('ROGIQ_API_URL', 'https://api.rogiq.ai')})"
+      def login
+        fmt = RogIQ::Formatters.new(format: options[:format])
+        base = options[:api].to_s.strip
+        base = ENV["ROGIQ_API_URL"].to_s.strip if base.empty?
+        base = ask("API base URL:", default: "https://api.rogiq.ai") if base.empty?
+        base = base.to_s.chomp("/")
+        email = ask("Email:")
+        password = ask("Password:", echo: false)
+
+        headers = { "Content-Type" => "application/json", "Accept" => "application/json" }
+        res, jwt = post_login(base, headers, email, password)
+        json = JSON.parse(res.body)
+
+        if json["mfa_required"]
+          mfa_token = json["mfa_token"]
+          code = ask("MFA code:")
+          remember = ask("Remember this device for 30 days? (y/N):").downcase.start_with?("y")
+          res, jwt = post_mfa_verify(base, headers, mfa_token, code, remember)
+          json = JSON.parse(res.body)
+        end
+
+        unless jwt
+          fmt.error_msg(error_message(res))
+          exit 1
+        end
+
+        accounts = json["accounts"] || []
+        account_id = pick_account_id(fmt, accounts)
+        token_payload = mint_cli_token(base, jwt, account_id, headers)
+        plain = token_payload["token"]
+        unless plain
+          err = token_payload["error"] || token_payload["errors"]
+          fmt.error_msg("Could not create API token: #{err || token_payload.inspect}")
+          exit 1
+        end
+
+        RogIQ::ConfigStore.save(
+          "api_base_url" => base,
+          "token" => plain,
+          "account_id" => account_id,
+          "email" => email
+        )
+
+        fmt.success("Saved credentials to #{RogIQ::ConfigStore::PATH}")
+        out = token_payload.reject { |k, _| k.to_s == "token" }
+        out["token_saved"] = true
+        fmt.output(out)
+      rescue RogIQ::HttpApi::Error => e
+        fmt.error_msg(e.message)
+        exit 1
+      end
+
+      desc "logout", "Remove saved CLI credentials"
+      def logout
+        RogIQ::ConfigStore.clear!
+        puts "Removed #{RogIQ::ConfigStore::PATH}"
+      end
+
+      desc "whoami", "Print current user from /api/v1/me"
+      def whoami
+        fmt = RogIQ::Formatters.new(format: options[:format])
+        api = RogIQ::HttpApi.from_config!
+        data = api.get("/api/v1/me")
+        fmt.output(data)
+      rescue RogIQ::HttpApi::Error => e
+        fmt.error_msg(e.message)
+        exit 1
+      end
+
+      desc "use ACCOUNT_ID", "Set default X-Account-ID header for CLI requests"
+      def use(account_id)
+        RogIQ::ConfigStore.merge!("account_id" => account_id.to_s)
+        puts "Default account_id=#{account_id}"
+      end
+
+      private
+
+      def pick_account_id(fmt, accounts)
+        accounts = Array(accounts)
+        if accounts.empty?
+          return ask("Account ID (required for API token):").to_s.strip
+        end
+        return accounts.first["id"].to_s if accounts.size == 1
+
+        fmt.say("Accounts:")
+        accounts.each_with_index do |a, i|
+          fmt.say("  [#{i + 1}] #{a['name']} (id=#{a['id']})")
+        end
+        loop do
+          n = ask("Choose account number (1-#{accounts.size}):")
+          i = n.to_i
+          if i >= 1 && i <= accounts.size
+            return accounts[i - 1]["id"].to_s
+          end
+
+          fmt.warn_msg("Enter a number between 1 and #{accounts.size}")
+        end
+      end
+
+      def post_login(base, headers, email, password)
+        uri = URI.parse("#{base}/api/v1/auth/login")
+        req = Net::HTTP::Post.new(uri)
+        headers.each { |k, v| req[k] = v }
+        req.body = JSON.generate(user: { email: email, password: password })
+        response_for(uri, req)
+      end
+
+      def post_mfa_verify(base, headers, mfa_token, code, remember)
+        uri = URI.parse("#{base}/api/v1/auth/mfa/verify")
+        req = Net::HTTP::Post.new(uri)
+        headers.each { |k, v| req[k] = v }
+        req.body = JSON.generate(mfa_token: mfa_token, code: code, remember_me: remember)
+        response_for(uri, req)
+      end
+
+      def mint_cli_token(base, jwt, account_id, headers)
+        uri = URI.parse("#{base}/api/v1/api_tokens")
+        req = Net::HTTP::Post.new(uri)
+        headers.each { |k, v| req[k] = v }
+        req["Authorization"] = "Bearer #{jwt}"
+        aid = account_id.to_s.strip
+        req["X-Account-ID"] = aid unless aid.empty?
+        req.body = JSON.generate(api_token: { name: "RogIQ CLI", purpose: "cli" })
+        res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.open_timeout = 15
+          http.read_timeout = 60
+          http.request(req)
+        end
+        body = res.body.to_s
+        parsed =
+          begin
+            body.strip.empty? ? {} : JSON.parse(body)
+          rescue JSON::ParserError
+            { "error" => body[0, 300] }
+          end
+
+        return parsed.merge("error" => "HTTP #{res.code}") unless res.is_a?(Net::HTTPSuccess)
+
+        parsed
+      end
+
+      def response_for(uri, req)
+        res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.open_timeout = 15
+          http.read_timeout = 60
+          http.request(req)
+        end
+        jwt = extract_jwt(res)
+        [ res, jwt ]
+      end
+
+      def extract_jwt(res)
+        raw = res["Authorization"] || res["authorization"]
+        return nil if raw.nil? || raw.to_s.strip.empty?
+
+        raw.split(" ", 2).last
+      end
+
+      def error_message(res)
+        json = JSON.parse(res.body)
+        [ json["error"], json["message"] ].map { |x| x.to_s.strip }.reject(&:empty?).first || "HTTP #{res.code}"
+      rescue JSON::ParserError
+        "HTTP #{res.code}: #{res.body.to_s[0, 200]}"
+      end
+    end
+  end
+end

data/lib/rogiq/commands/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module RogIQ
+  module Commands
+    class Base < Thor
+      class_option :format,
+                   aliases: "-f",
+                   type: :string,
+                   default: "table",
+                   enum: %w[table json],
+                   desc: "Output format"
+      class_option :quiet,
+                   type: :boolean,
+                   default: false,
+                   desc: "Suppress non-error output"
+
+      no_tasks do
+        def fmt
+          @fmt ||= RogIQ::Formatters.new(format: options[:format], quiet: options[:quiet])
+        end
+      end
+    end
+  end
+end

data/lib/rogiq/commands/billing.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "billing_stripe"
+
+module RogIQ
+  module Commands
+    class Billing < RogIQ::Commands::Base
+      desc "coins ACCOUNT", "Rogue coin wallet + recent transactions"
+      def coins(identifier)
+        RogIQ.load_rails!
+        account = RogIQ::Helpers.resolve_account(identifier)
+        unless account
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        w = account.rogue_coin_wallet
+        unless w
+          fmt.output(wallet: nil, message: "No RogueCoinWallet for account")
+          return
+        end
+
+        txs = w.transactions.order(created_at: :desc).limit(25).map do |t|
+          [t.created_at.iso8601, t.transaction_type, t.amount, t.description.to_s.truncate(60)]
+        end
+        fmt.output(
+          account_id: account.id,
+          balance: w.balance,
+          lifetime_purchased: w.lifetime_purchased,
+          lifetime_spent: w.lifetime_spent,
+          recent_transactions: txs
+        )
+      end
+
+      desc "overages", "Pending usage overages (all accounts)"
+      method_option :limit, type: :numeric, default: 50
+      def overages
+        RogIQ.load_rails!
+        rows = ::UsageOverage.status_pending.includes(:account).order(created_at: :desc).limit(options[:limit]).map do |o|
+          [
+            o.id,
+            o.account&.name,
+            o.metric_type,
+            o.total_charge.to_f,
+            o.created_at.iso8601
+          ]
+        end
+        fmt.output(headers: %w[id account metric total_charge created_at], rows: rows)
+      end
+
+      desc "stripe SUBCOMMAND", "Stripe catalog (sync)"
+      subcommand "stripe", RogIQ::Commands::BillingStripe
+
+      desc "summary", "Enqueue Billing::DailyBillingSummaryJob (Slack)"
+      method_option :date, type: :string, desc: "YYYY-MM-DD (default yesterday)"
+      def summary
+        RogIQ.load_rails!
+        date = options[:date].present? ? Date.parse(options[:date]) : nil
+        ::Billing::DailyBillingSummaryJob.perform_later(date: date)
+        fmt.success("Billing::DailyBillingSummaryJob enqueued.")
+      end
+
+      desc "invoices ACCOUNT", "Recent invoices"
+      method_option :limit, type: :numeric, default: 20
+      def invoices(identifier)
+        RogIQ.load_rails!
+        account = RogIQ::Helpers.resolve_account(identifier)
+        unless account
+          fmt.error_msg("Account not found")
+          exit 1
+        end
+
+        rows = account.invoices.order(created_at: :desc).limit(options[:limit]).map do |inv|
+          [
+            inv.id,
+            inv.invoice_number,
+            inv.status,
+            inv.total.to_f,
+            inv.striven_invoice_id,
+            inv.created_at.iso8601
+          ]
+        end
+        fmt.output(
+          headers: %w[id invoice_number status total striven_invoice_id created_at],
+          rows: rows
+        )
+      end
+    end
+  end
+end

data/lib/rogiq/commands/billing_stripe.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class BillingStripe < RogIQ::Commands::Base
+      desc "sync", "Run rake stripe:ensure_subscription_prices"
+      def sync
+        RogIQ.load_rails!
+        Rails.application.load_tasks
+        Rake::Task["stripe:ensure_subscription_prices"].invoke
+        fmt.success("stripe:ensure_subscription_prices complete.")
+      end
+    end
+  end
+end