rogiq 0.1.0

data/lib/rogiq/commands/clients.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Clients < RogIQ::Commands::Base
+      desc "list", "List recent clients"
+      method_option :limit, type: :numeric, default: 25, aliases: "-n", desc: "Max records"
+      method_option :search, type: :string, desc: "Filter by name (ILIKE)"
+      def list
+        RogIQ.load_rails!
+        scope = ::Client.order(created_at: :desc)
+        scope = scope.where("name ILIKE ?", "%#{options[:search]}%") if options[:search].present?
+        rows = scope.limit(options[:limit]).map do |c|
+          slug = c.account&.slug
+          [c.id, c.name, slug, c.research_ready, c.created_at.iso8601]
+        end
+        fmt.output(headers: %w[id name account_slug research_ready created_at], rows: rows)
+      end
+
+      desc "show IDENTIFIER", "Show client by uuid or name"
+      def show(identifier)
+        RogIQ.load_rails!
+        c = RogIQ::Helpers.resolve_client(identifier)
+        unless c
+          fmt.error_msg("Client not found: #{identifier}")
+          exit 1
+        end
+
+        payload = {
+          id: c.id,
+          name: c.name,
+          account_id: c.account_id,
+          account_slug: c.account&.slug,
+          website: c.website,
+          industry: c.industry,
+          research_ready: c.research_ready,
+          onboarding_stage: c.try(:onboarding_stage),
+          onboarding_version: c.try(:onboarding_version),
+          created_at: c.created_at,
+          updated_at: c.updated_at
+        }
+        fmt.output(payload)
+      end
+
+      desc "research_status IDENTIFIER", "Print client_settings research_status JSON"
+      map "research-status" => :research_status
+      def research_status(identifier)
+        RogIQ.load_rails!
+        c = RogIQ::Helpers.resolve_client(identifier)
+        unless c
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        row = c.client_settings.find_by(setting_key: "research_status")
+        fmt.output(row ? row.setting_value : {})
+      end
+
+      desc "settings IDENTIFIER", "List all client_settings rows"
+      def settings(identifier)
+        RogIQ.load_rails!
+        c = RogIQ::Helpers.resolve_client(identifier)
+        unless c
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        rows = c.client_settings.order(:setting_key).map do |s|
+          val = s.setting_value
+          preview = val.is_a?(Hash) ? val.to_json.truncate(120) : val.to_s.truncate(120)
+          [s.setting_key, preview]
+        end
+        fmt.output(headers: %w[setting_key value_preview], rows: rows)
+      end
+
+      desc "onboarding IDENTIFIER", "Latest onboarding evaluation / version summary"
+      def onboarding(identifier)
+        RogIQ.load_rails!
+        c = RogIQ::Helpers.resolve_client(identifier)
+        unless c
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        ev = c.onboarding_evaluations.order(created_at: :desc).first
+        ver = c.onboarding_versions.order(created_at: :desc).first
+        fmt.output(
+          {
+            client_id: c.id,
+            latest_evaluation: ev&.attributes,
+            latest_version: ver&.attributes
+          }.compact
+        )
+      end
+
+      desc "subdomain IDENTIFIER", "Account slug (white-label) + custom domains if any"
+      def subdomain(identifier)
+        RogIQ.load_rails!
+        c = RogIQ::Helpers.resolve_client(identifier)
+        unless c
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        acc = c.account
+        domains = acc ? ::CustomDomain.where(account_id: acc.id).limit(50).pluck(:domain, :status, :verified_at) : []
+        fmt.output(
+          {
+            account_slug: acc&.slug,
+            account_id: acc&.id,
+            custom_domains: domains.map { |d, st, v| { domain: d, status: st, verified_at: v } }
+          }
+        )
+      end
+    end
+  end
+end

data/lib/rogiq/commands/content.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Content < RogIQ::Commands::Base
+      desc "status CLIENT", "ContentItem counts by state"
+      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
+
+        counts = ::ContentItem.where(client_id: client.id).group(:state).count.sort_by { |_, n| -n }
+        fmt.output(headers: %w[state count], rows: counts.to_a)
+      end
+
+      desc "heal CLIENT", "Enqueue DataHealingOrchestratorJob"
+      def heal(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        ::DataHealingOrchestratorJob.perform_later(client_id: client.id, account_id: client.account_id)
+        fmt.success("DataHealingOrchestratorJob enqueued for client #{client.id}.")
+      end
+
+      desc "publish_queue", "Scheduled content publications (future)"
+      map "publish-queue" => :publish_queue
+      method_option :limit, type: :numeric, default: 40
+      def publish_queue
+        RogIQ.load_rails!
+        rows = ::ContentPublication.where(status: "scheduled")
+          .where("scheduled_at > ?", Time.current)
+          .order(:scheduled_at)
+          .limit(options[:limit])
+          .map do |p|
+            [
+              p.id,
+              p.account_id,
+              p.title.to_s.truncate(50),
+              p.scheduled_at&.iso8601,
+              p.platform
+            ]
+          end
+        fmt.output(headers: %w[id account_id title scheduled_at platform], rows: rows)
+      end
+
+      desc "failed CLIENT", "Content items in failed or rejected state"
+      method_option :limit, type: :numeric, default: 30
+      def failed(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        rows = ::ContentItem.where(client_id: client.id, state: %w[failed rejected])
+          .order(updated_at: :desc)
+          .limit(options[:limit])
+          .map { |i| [i.id, i.title.to_s.truncate(60), i.state, i.updated_at.iso8601] }
+        fmt.output(headers: %w[id title state updated_at], rows: rows)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/diagnose.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Diagnose < RogIQ::Commands::Base
+      desc "search_insights [CLIENT]", "Run diagnose_search_insights.rb (global DB report; client optional)"
+      map "search-insights" => :search_insights
+      def search_insights(*)
+        RogIQ.load_rails!
+        load File.join(RogIQ.repo_root, "diagnose_search_insights.rb")
+      end
+
+      desc "genius CLIENT", "Run debug_genius_mode_goals.rb for a client id/name"
+      def genius(identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        RogIQ::Helpers.with_saved_argv([ client.id.to_s ]) do
+          load File.join(RogIQ.repo_root, "debug_genius_mode_goals.rb")
+        end
+      end
+
+      desc "subdomain CLIENT", "DNS/API checks using account slug (diagnose_subdomain_issues.rb)"
+      def subdomain(identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(identifier)
+        unless client&.account&.slug
+          fmt.error_msg("Client or account slug not found")
+          exit 1
+        end
+
+        RogIQ::Helpers.with_saved_argv([ client.account.slug ]) do
+          load File.join(RogIQ.repo_root, "diagnose_subdomain_issues.rb")
+        end
+      end
+
+      desc "emergency CLIENT", "Emergency client diagnostic (jobs, research status, settings)"
+      def emergency(identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        fmt.say("\n" + "=" * 80)
+        fmt.say("EMERGENCY DIAGNOSTIC: #{client.name} (#{client.id})")
+        fmt.say("=" * 80)
+
+        fmt.say("\n1. CLIENT DATA")
+        fmt.say("  Name:           #{client.name}")
+        fmt.say("  Website:        #{client.website.presence || "EMPTY"}")
+        fmt.say("  Research Ready: #{client.research_ready}")
+        fmt.say("  Description:    #{client.description.present? ? client.description[0, 100] + "…" : "EMPTY"}")
+        fmt.say("  Primary Color:  #{client.primary_color || "EMPTY"}")
+        fmt.say("  Created:        #{client.created_at} (#{((Time.current - client.created_at) / 60).round} min ago)")
+
+        fmt.say("\n2. RESEARCH STATUS")
+        research = client.client_settings.find_by(setting_key: "research_status")
+        if research
+          v = research.setting_value
+          fmt.say("  Status:  #{v["status"]}")
+          fmt.say("  Website: #{v["website"] || "none"}")
+          fmt.say("  Updated: #{v["updated_at"]}")
+        else
+          fmt.say("  NO RESEARCH STATUS — after_create callback may not have run")
+        end
+
+        fmt.say("\n3. SOLID QUEUE JOBS FOR THIS CLIENT")
+        jobs = ::SolidQueue::Job.where("arguments::text LIKE ?", "%#{client.id}%").order(created_at: :desc)
+        if jobs.empty?
+          fmt.say("  NO JOBS FOUND — callback not firing, SolidQueue not configured, or DB issue")
+        else
+          fmt.say("  Found #{jobs.count} job record(s):")
+          jobs.group_by(&:class_name).each do |name, list|
+            fmt.say("  #{name} (#{list.size} run(s)):")
+            list.first(3).each do |job|
+              status = job.finished_at ? "FINISHED" : (job.failed_at ? "FAILED" : "PENDING")
+              fmt.say("    #{status} — created #{job.created_at}, finished #{job.finished_at || "—"}")
+            end
+          end
+        end
+
+        fmt.say("\n4. KEY SETTINGS PRESENCE")
+        important = %w[website_content ai_insights onboarding_processed_data]
+        present = client.client_settings.pluck(:setting_key)
+        important.each do |key|
+          fmt.say("  #{key}: #{present.include?(key) ? "present" : "MISSING"}")
+        end
+
+        fmt.say("\n" + "=" * 80)
+        fmt.say("END DIAGNOSTIC")
+        fmt.say("=" * 80)
+      end
+
+      desc "zeitwerk", "Run zeitwerk:check with RAILS_ENV=production"
+      def zeitwerk
+        api = RogIQ.api_root
+        ok = system({ "RAILS_ENV" => "production" }, "bundle", "exec", "rails", "zeitwerk:check", chdir: api)
+        exit(ok ? 0 : 1)
+      end
+
+      desc "pinecone", "Pinecone configuration summary"
+      def pinecone
+        RogIQ.load_rails!
+        if defined?(Rails.configuration.ai_engine)
+          cfg = Rails.configuration.ai_engine
+          fmt.output(
+            pinecone_enabled: cfg.try(:pinecone_enabled),
+            pinecone_index_name: cfg.try(:pinecone_index_name),
+            api_key_present: ENV["PINECONE_API_KEY"].present?
+          )
+        else
+          fmt.output(pinecone: "Rails.configuration.ai_engine not defined")
+        end
+      end
+
+      desc "migrations", "Pending migrations?"
+      def migrations
+        RogIQ.load_rails!
+        pending = ActiveRecord::Base.connection.pool.migration_context.pending_migration_versions
+        fmt.output(
+          pending_count: pending.size,
+          pending_versions: pending
+        )
+        exit(pending.any? ? 1 : 0)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/jobs.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Jobs < RogIQ::Commands::Base
+      desc "list", "Summarize Solid Queue job states"
+      method_option :failed, type: :boolean, default: false, desc: "Only failed executions (recent)"
+      method_option :class, type: :string, desc: "Filter by Active Job class name"
+      method_option :limit, type: :numeric, default: 50, desc: "Max rows for --failed list"
+      def list
+        RogIQ.load_rails!
+        unless ActiveRecord::Base.connection.data_source_exists?("solid_queue_jobs")
+          fmt.error_msg("solid_queue tables not present")
+          exit 1
+        end
+
+        if options[:failed]
+          scope = SolidQueue::FailedExecution.joins(:job).order("solid_queue_failed_executions.id DESC")
+          scope = scope.where(solid_queue_jobs: { class_name: options[:class] }) if options[:class].present?
+          rows = scope.limit(options[:limit]).map do |fe|
+            job = fe.job
+            msg = fe.error.is_a?(Hash) ? fe.error["message"] : fe.error.to_s
+            [fe.id, job&.class_name, msg.to_s.truncate(80)]
+          end
+          fmt.output(headers: %w[failed_execution_id class_name error_preview], rows: rows)
+        else
+          unfinished = SolidQueue::Job.where(finished_at: nil).group(:class_name).count.sort_by { |_, n| -n }
+          fmt.output(
+            headers: %w[class_name unfinished_count],
+            rows: unfinished
+          )
+          fmt.say("") unless options[:quiet]
+          fmt.output(
+            {
+              ready: SolidQueue::ReadyExecution.count,
+              scheduled: SolidQueue::ScheduledExecution.count,
+              failed: SolidQueue::FailedExecution.count,
+              claimed: SolidQueue::ClaimedExecution.count
+            }
+          )
+        end
+      end
+
+      desc "detail ID", "Show full error / metadata for a failed execution or job id"
+      map "inspect" => :detail
+      def detail(id)
+        RogIQ.load_rails!
+        fe = find_failed_execution(id)
+        unless fe
+          fmt.error_msg("Failed execution not found for id=#{id}")
+          exit 1
+        end
+
+        job = fe.job
+        payload = {
+          failed_execution_id: fe.id,
+          job_id: job&.id,
+          class_name: job&.class_name,
+          queue_name: job&.queue_name,
+          created_at: job&.created_at,
+          error: fe.error,
+          arguments: job&.arguments
+        }
+        fmt.output(payload)
+      end
+
+      desc "retry ID", "Retry a single failed execution (by failed_execution.id or job.id)"
+      map "retry" => :retry_one
+      def retry_one(id)
+        RogIQ.load_rails!
+        fe = find_failed_execution(id)
+        unless fe
+          fmt.error_msg("Failed execution not found for id=#{id}")
+          exit 1
+        end
+        fe.retry
+        fmt.success("Retried job #{fe.job_id}")
+      end
+
+      desc "discard ID", "Discard a failed execution without retry"
+      map "discard" => :discard_one
+      method_option :yes, type: :boolean, default: false, aliases: "-y", desc: "Skip confirmation"
+      def discard_one(id)
+        RogIQ.load_rails!
+        fe = find_failed_execution(id)
+        unless fe
+          fmt.error_msg("Failed execution not found for id=#{id}")
+          exit 1
+        end
+
+        unless fmt.confirm!("Discard failed execution #{fe.id} (job #{fe.job_id})?", yes: options[:yes])
+          fmt.warn_msg("Aborted.")
+          return
+        end
+
+        fe.discard
+        fmt.success("Discarded.")
+      end
+
+      desc "tail", "Poll failed executions every 3 seconds (Ctrl+C to stop)"
+      method_option :interval, type: :numeric, default: 3, desc: "Seconds between polls"
+      def tail
+        RogIQ.load_rails!
+        last_id = SolidQueue::FailedExecution.maximum(:id).to_i
+        fmt.success("Watching SolidQueue::FailedExecution after id=#{last_id}…")
+        loop do
+          sleep options[:interval]
+          rows = SolidQueue::FailedExecution.where("id > ?", last_id).order(:id)
+          rows.each do |fe|
+            last_id = fe.id
+            job = fe.job
+            msg = fe.error.is_a?(Hash) ? fe.error["message"] : fe.error
+            fmt.say("[#{fe.id}] #{job&.class_name}: #{msg}")
+          end
+        end
+      end
+
+      private
+
+      def find_failed_execution(id)
+        SolidQueue::FailedExecution.find_by(id: id) ||
+          SolidQueue::FailedExecution.find_by(job_id: id)
+      end
+    end
+  end
+end

data/lib/rogiq/commands/queue.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Queue < RogIQ::Commands::Base
+      desc "stats", "Solid Queue counts (ready, scheduled, failed, claimed)"
+      method_option :by_class, type: :boolean, default: false, desc: "Break down unfinished jobs by Active Job class (--by-class)"
+      def stats
+        RogIQ.load_rails!
+        unless solid_queue_tables?
+          fmt.error_msg("solid_queue tables not present")
+          exit 1
+        end
+
+        if options[:by_class]
+          rows = SolidQueue::Job.where(finished_at: nil).group(:class_name).count.sort_by { |_, n| -n }
+          fmt.output(headers: %w[class_name unfinished_jobs], rows: rows.to_a)
+        else
+          payload = {
+            ready: SolidQueue::ReadyExecution.count,
+            scheduled: SolidQueue::ScheduledExecution.count,
+            failed: SolidQueue::FailedExecution.count,
+            claimed: SolidQueue::ClaimedExecution.count,
+            blocked: defined?(SolidQueue::BlockedExecution) ? SolidQueue::BlockedExecution.count : nil
+          }.compact
+          fmt.output(payload)
+        end
+      end
+
+      desc "flush", "Discard failed executions (--class optional)"
+      method_option :class, type: :string, required: false, desc: "Limit to this Active Job class name"
+      method_option :yes, type: :boolean, default: false, aliases: "-y", desc: "Skip confirmation"
+      def flush
+        RogIQ.load_rails!
+        scope = SolidQueue::FailedExecution.joins(:job)
+        scope = scope.where(solid_queue_jobs: { class_name: options[:class] }) if options[:class].present?
+
+        n = scope.count
+        if n.zero?
+          fmt.success("No failed executions to discard.")
+          return
+        end
+
+        unless fmt.confirm!("Discard #{n} failed execution(s)?", yes: options[:yes])
+          fmt.warn_msg("Aborted.")
+          return
+        end
+
+        discarded = 0
+        scope.find_each do |fe|
+          fe.discard
+          discarded += 1
+        end
+        fmt.success("Discarded #{discarded} failed execution(s).")
+      end
+
+      desc "retry_all", "Retry all failed jobs (optionally scoped with --class)"
+      map "retry-all" => :retry_all
+      method_option :class, type: :string, required: false, desc: "Only this Active Job class"
+      method_option :yes, type: :boolean, default: false, aliases: "-y", desc: "Skip confirmation"
+      def retry_all
+        RogIQ.load_rails!
+        scope = SolidQueue::FailedExecution.joins(:job)
+        scope = scope.where(solid_queue_jobs: { class_name: options[:class] }) if options[:class].present?
+        jobs = scope.includes(:job).map(&:job).uniq
+        if jobs.empty?
+          fmt.success("Nothing to retry.")
+          return
+        end
+
+        unless fmt.confirm!("Retry #{jobs.size} failed job(s)?", yes: options[:yes])
+          fmt.warn_msg("Aborted.")
+          return
+        end
+
+        SolidQueue::FailedExecution.retry_all(jobs)
+        fmt.success("Retried #{jobs.size} job(s).")
+      end
+
+      desc "pause", "Pause a Solid Queue queue by name"
+      def pause(queue_name)
+        RogIQ.load_rails!
+        SolidQueue::Queue.find_by_name(queue_name).pause
+        fmt.success("Paused queue #{queue_name}")
+      end
+
+      desc "resume", "Resume a paused Solid Queue queue"
+      def resume(queue_name)
+        RogIQ.load_rails!
+        SolidQueue::Queue.find_by_name(queue_name).resume
+        fmt.success("Resumed queue #{queue_name}")
+      end
+
+      desc "drain", "Clear ready/scheduled/blocked (dangerous; wraps queue:drain rake task semantics)"
+      method_option :yes, type: :boolean, default: false, aliases: "-y", desc: "Skip confirmation"
+      def drain
+        RogIQ.load_rails!
+        unless fmt.confirm!("Clear ready, scheduled, and blocked executions?", yes: options[:yes])
+          fmt.warn_msg("Aborted.")
+          return
+        end
+
+        Rails.application.load_tasks
+        Rake::Task["queue:drain"].invoke
+        fmt.success("Drain complete.")
+      end
+
+      private
+
+      def solid_queue_tables?
+        ActiveRecord::Base.connection.data_source_exists?("solid_queue_jobs")
+      end
+    end
+  end
+end

data/lib/rogiq/commands/security.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class Security < RogIQ::Commands::Base
+      desc "scan", "Run Brakeman (requires dev/test Gemfile group)"
+      def scan
+        api = RogIQ.api_root
+        brakeman = File.join(api, "bin", "brakeman")
+        cmd = File.exist?(brakeman) ? [ brakeman.to_s, "-q" ] : %w[bundle exec brakeman -q]
+        ok = system(*cmd, chdir: api)
+        unless ok
+          fmt.error_msg("Brakeman failed or gem not available in this bundle group.")
+          exit 1
+        end
+      end
+
+      desc "audit", "Run bundler-audit"
+      def audit
+        api = RogIQ.api_root
+        ok = system("bundle", "exec", "bundle-audit", "check", chdir: api)
+        exit(ok ? 0 : 1)
+      end
+
+      desc "policy", "rake security_policy:diagnose"
+      def policy
+        RogIQ.load_rails!
+        Rails.application.load_tasks
+        Rake::Task["security_policy:diagnose"].invoke
+      end
+    end
+  end
+end

data/lib/rogiq/commands/seo.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RogIQ
+  module Commands
+    class SEO < RogIQ::Commands::Base
+      desc "audit SUBCOMMAND ...", "SEO audit (run, status)"
+      subcommand "audit", RogIQ::Commands::SEOAudit
+
+      desc "keywords CLIENT", "Track keywords for client"
+      def keywords(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        rows = client.client_seo_track_keywords.order(:sort_order, :keyword).limit(200).map do |k|
+          [k.keyword, k.sort_order, k.source]
+        end
+        fmt.output(headers: %w[keyword sort_order source], rows: rows)
+      end
+
+      desc "insights CLIENT", "Search insights counts"
+      def insights(client_identifier)
+        RogIQ.load_rails!
+        client = RogIQ::Helpers.resolve_client(client_identifier)
+        unless client
+          fmt.error_msg("Client not found")
+          exit 1
+        end
+
+        scope = ::SearchInsight.where(client_id: client.id)
+        fmt.output(
+          total: scope.count,
+          by_status: scope.group(:status).count
+        )
+      end
+
+      desc "zeitwerk", "Run zeitwerk:check in production mode"
+      def zeitwerk
+        fmt.warn_msg("Running zeitwerk:check with RAILS_ENV=production …")
+        api = RogIQ.api_root
+        ok = system({ "RAILS_ENV" => "production" }, "bundle", "exec", "rails", "zeitwerk:check", chdir: api)
+        exit(ok ? 0 : 1)
+      end
+    end
+  end
+end