exa-ai 0.5.0 → 0.6.1

data/lib/exa/cli/formatters/enrichment_formatter.rb

@@ -9,9 +9,11 @@ module Exa
           when "json"
             JSON.generate(enrichment.to_h)
           when "pretty"
-            JSON.pretty_generate(enrichment.to_h)
+            format_as_pretty(enrichment)
           when "text"
             format_as_text(enrichment)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(enrichment.to_h)
           else
             raise ArgumentError, "Unknown output format: #{output_format}"
           end
@@ -22,14 +24,41 @@ module Exa
           when "json"
             JSON.generate(collection.to_h)
           when "pretty"
-            JSON.pretty_generate(collection.to_h)
+            format_collection_as_pretty(collection)
           when "text"
             format_collection_as_text(collection)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(collection.to_h)
           else
             raise ArgumentError, "Unknown output format: #{output_format}"
           end
         end
 
+        def self.format_as_pretty(enrichment)
+          lines = []
+          lines << "Enrichment ID: #{enrichment.id}"
+          lines << "Webset ID:     #{enrichment.webset_id}" if enrichment.webset_id
+          lines << "Status:        #{enrichment.status}"
+          lines << "Title:         #{enrichment.title}" if enrichment.title
+          lines << "Description:   #{enrichment.description}" if enrichment.description
+          lines << "Format:        #{enrichment.format}" if enrichment.format
+
+          if enrichment.options && !enrichment.options.empty?
+            lines << ""
+            lines << "Options (#{enrichment.options.length}):"
+            enrichment.options.each do |option|
+              lines << "  • #{option['label']}" if option['label']
+            end
+          end
+
+          lines << ""
+          lines << "Created:       #{enrichment.created_at}" if enrichment.created_at
+          lines << "Updated:       #{enrichment.updated_at}" if enrichment.updated_at
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_pretty
+
         def self.format_as_text(enrichment)
           lines = []
           lines << "Enrichment: #{enrichment.id}"
@@ -53,6 +82,33 @@ module Exa
         end
         private_class_method :format_as_text
 
+        def self.format_collection_as_pretty(collection)
+          lines = []
+          lines << "Enrichments (#{collection.data.length} items)"
+          lines << ""
+
+          collection.data.each_with_index do |enr, idx|
+            lines << "" if idx > 0  # Blank line between enrichments
+
+            lines << "Enrichment ID: #{enr['id']}"
+            lines << "Webset ID:     #{enr['websetId']}" if enr['websetId']
+            lines << "Status:        #{enr['status']}"
+            lines << "Title:         #{enr['title']}" if enr['title']
+            lines << "Description:   #{enr['description']}" if enr['description']
+            lines << "Format:        #{enr['format']}" if enr['format']
+            lines << "Created:       #{enr['createdAt']}" if enr['createdAt']
+            lines << "Updated:       #{enr['updatedAt']}" if enr['updatedAt']
+          end
+
+          if collection.has_more
+            lines << ""
+            lines << "Next Cursor:   #{collection.next_cursor}"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_pretty
+
         def self.format_collection_as_text(collection)
           lines = ["Enrichments (#{collection.data.length} items):"]
           collection.data.each do |enr|

data/lib/exa/cli/formatters/import_formatter.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Exa
+  module CLI
+    module Formatters
+      class ImportFormatter
+        def self.format(import, output_format)
+          case output_format
+          when "json"
+            JSON.generate(import.to_h)
+          when "pretty"
+            format_as_pretty(import)
+          when "text"
+            format_as_text(import)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(import.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_collection(collection, output_format)
+          case output_format
+          when "json"
+            JSON.generate(collection.to_h)
+          when "pretty"
+            format_collection_as_pretty(collection)
+          when "text"
+            format_collection_as_text(collection)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(collection.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_as_pretty(import)
+          lines = []
+          lines << "Import ID:     #{import.id}"
+          lines << "Status:        #{import.status}"
+          lines << "Title:         #{import.title}" if import.title
+          lines << "Format:        #{import.format}" if import.format
+
+          if import.entity
+            entity_type = import.entity['type'] || import.entity[:type]
+            lines << "Entity Type:   #{entity_type}" if entity_type
+          end
+
+          lines << "Count:         #{import.count}" if import.count
+
+          if import.failed?
+            lines << ""
+            lines << "Failure:"
+            lines << "  Reason:      #{import.failed_reason}" if import.failed_reason
+            lines << "  Message:     #{import.failed_message}" if import.failed_message
+            lines << "  Failed At:   #{import.failed_at}" if import.failed_at
+          end
+
+          if import.upload_url
+            lines << ""
+            lines << "Upload:"
+            lines << "  URL:         #{import.upload_url}"
+            lines << "  Valid Until: #{import.upload_valid_until}" if import.upload_valid_until
+          end
+
+          lines << ""
+          lines << "Created:       #{import.created_at}" if import.created_at
+          lines << "Updated:       #{import.updated_at}" if import.updated_at
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_pretty
+
+        def self.format_as_text(import)
+          lines = []
+          lines << "Import: #{import.id}"
+          lines << "Status: #{import.status}"
+          lines << "Title: #{import.title}" if import.title
+          lines << "Format: #{import.format}" if import.format
+
+          if import.entity
+            entity_type = import.entity['type'] || import.entity[:type]
+            lines << "Entity Type: #{entity_type}" if entity_type
+          end
+
+          lines << "Count: #{import.count}" if import.count
+
+          if import.failed?
+            lines << "\nFailure Details:"
+            lines << "  Reason: #{import.failed_reason}" if import.failed_reason
+            lines << "  Message: #{import.failed_message}" if import.failed_message
+            lines << "  Failed At: #{import.failed_at}" if import.failed_at
+          end
+
+          if import.upload_url
+            lines << "\nUpload:"
+            lines << "  URL: #{import.upload_url}"
+            lines << "  Valid Until: #{import.upload_valid_until}" if import.upload_valid_until
+          end
+
+          lines << "\nCreated: #{import.created_at}" if import.created_at
+          lines << "Updated: #{import.updated_at}" if import.updated_at
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_text
+
+        def self.format_collection_as_pretty(collection)
+          lines = []
+          lines << "Imports (#{collection.data.length} items)"
+          lines << ""
+
+          collection.data.each_with_index do |imp, idx|
+            lines << "" if idx > 0  # Blank line between imports
+
+            lines << "Import ID:     #{imp.id}"
+            lines << "Status:        #{imp.status}"
+            lines << "Title:         #{imp.title}" if imp.title
+            lines << "Format:        #{imp.format}" if imp.format
+            lines << "Entity Type:   #{imp.entity['type']}" if imp.entity && imp.entity['type']
+            lines << "Count:         #{imp.count}" if imp.count
+            lines << "Created:       #{imp.created_at}" if imp.created_at
+            lines << "Updated:       #{imp.updated_at}" if imp.updated_at
+
+            if imp.status == 'failed'
+              lines << "Failed Reason: #{imp.failed_reason}" if imp.failed_reason
+            end
+          end
+
+          if collection.has_more
+            lines << ""
+            lines << "Next Cursor:   #{collection.next_cursor}"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_pretty
+
+        def self.format_collection_as_text(collection)
+          lines = ["Imports (#{collection.data.length} items):"]
+          collection.data.each do |imp|
+            lines << "\n  #{imp.id}"
+            lines << "  Status: #{imp.status}"
+            lines << "  Title: #{imp.title}" if imp.title
+            lines << "  Count: #{imp.count}" if imp.count
+          end
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_text
+      end
+    end
+  end
+end

data/lib/exa/cli/formatters/monitor_formatter.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Exa
+  module CLI
+    module Formatters
+      class MonitorFormatter
+        def self.format(monitor, output_format)
+          case output_format
+          when "json"
+            JSON.generate(monitor.to_h)
+          when "pretty"
+            format_as_pretty(monitor)
+          when "text"
+            format_as_text(monitor)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(monitor.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_collection(collection, output_format)
+          case output_format
+          when "json"
+            JSON.generate(collection.to_h)
+          when "pretty"
+            format_collection_as_pretty(collection)
+          when "text"
+            format_collection_as_text(collection)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(collection.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_as_pretty(monitor)
+          lines = []
+          lines << "Monitor ID:    #{monitor.id}"
+          lines << "Webset ID:     #{monitor.webset_id}" if monitor.webset_id
+          lines << "Status:        #{monitor.status}"
+
+          if monitor.cadence
+            lines << ""
+            lines << "Cadence:"
+            lines << "  Cron:        #{monitor.cadence['cron']}" if monitor.cadence['cron']
+            lines << "  Timezone:    #{monitor.cadence['timezone']}" if monitor.cadence['timezone']
+          end
+
+          if monitor.behavior
+            lines << ""
+            lines << "Behavior:"
+            lines << "  Type:        #{monitor.behavior['type']}" if monitor.behavior['type']
+            lines << "  Query:       #{monitor.behavior['query']}" if monitor.behavior['query']
+            lines << "  Count:       #{monitor.behavior['count']}" if monitor.behavior['count']
+          end
+
+          lines << ""
+          lines << "Created:       #{monitor.created_at}" if monitor.created_at
+          lines << "Updated:       #{monitor.updated_at}" if monitor.updated_at
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_pretty
+
+        def self.format_as_text(monitor)
+          lines = []
+          lines << "Monitor: #{monitor.id}"
+          lines << "Webset: #{monitor.webset_id}" if monitor.webset_id
+          lines << "Status: #{monitor.status}"
+
+          if monitor.cadence
+            lines << "\nCadence:"
+            lines << "  Cron: #{monitor.cadence['cron']}" if monitor.cadence['cron']
+            lines << "  Timezone: #{monitor.cadence['timezone']}" if monitor.cadence['timezone']
+          end
+
+          if monitor.behavior
+            lines << "\nBehavior:"
+            lines << "  Type: #{monitor.behavior['type']}" if monitor.behavior['type']
+            lines << "  Query: #{monitor.behavior['query']}" if monitor.behavior['query']
+            lines << "  Count: #{monitor.behavior['count']}" if monitor.behavior['count']
+          end
+
+          lines << "\nCreated: #{monitor.created_at}" if monitor.created_at
+          lines << "Updated: #{monitor.updated_at}" if monitor.updated_at
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_text
+
+        def self.format_collection_as_pretty(collection)
+          lines = []
+          lines << "Monitors (#{collection.data.length} items)"
+          lines << ""
+
+          collection.data.each_with_index do |mon, idx|
+            lines << "" if idx > 0  # Blank line between monitors
+
+            lines << "Monitor ID:    #{mon['id']}"
+            lines << "Webset ID:     #{mon['websetId']}" if mon['websetId']
+            lines << "Status:        #{mon['status']}"
+
+            if mon['cadence']
+              lines << "Cron:          #{mon['cadence']['cron']}" if mon['cadence']['cron']
+              lines << "Timezone:      #{mon['cadence']['timezone']}" if mon['cadence']['timezone']
+            end
+
+            if mon['behavior']
+              lines << "Query:         #{mon['behavior']['query']}" if mon['behavior']['query']
+            end
+
+            lines << "Created:       #{mon['createdAt']}" if mon['createdAt']
+            lines << "Updated:       #{mon['updatedAt']}" if mon['updatedAt']
+          end
+
+          if collection.has_more
+            lines << ""
+            lines << "Next Cursor:   #{collection.next_cursor}"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_pretty
+
+        def self.format_collection_as_text(collection)
+          lines = ["Monitors (#{collection.data.length} items):"]
+          collection.data.each do |mon|
+            lines << "\n  #{mon['id']}"
+            lines << "  Status: #{mon['status']}"
+            lines << "  Webset: #{mon['websetId']}" if mon['websetId']
+          end
+
+          if collection.has_more
+            lines << "\nMore available (cursor: #{collection.next_cursor})"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_text
+      end
+    end
+  end
+end

data/lib/exa/cli/formatters/monitor_run_formatter.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Exa
+  module CLI
+    module Formatters
+      class MonitorRunFormatter
+        def self.format(monitor_run, output_format)
+          case output_format
+          when "json"
+            JSON.generate(monitor_run.to_h)
+          when "pretty"
+            format_as_pretty(monitor_run)
+          when "text"
+            format_as_text(monitor_run)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(monitor_run.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_collection(collection, output_format)
+          case output_format
+          when "json"
+            JSON.generate(collection.to_h)
+          when "pretty"
+            format_collection_as_pretty(collection)
+          when "text"
+            format_collection_as_text(collection)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(collection.to_h)
+          else
+            raise ArgumentError, "Unknown output format: #{output_format}"
+          end
+        end
+
+        def self.format_as_pretty(monitor_run)
+          lines = []
+          lines << "Monitor Run ID: #{monitor_run.id}"
+          lines << "Monitor ID:     #{monitor_run.monitor_id}" if monitor_run.monitor_id
+          lines << "Status:         #{monitor_run.status}"
+
+          lines << ""
+          lines << "Created:        #{monitor_run.created_at}" if monitor_run.created_at
+          lines << "Updated:        #{monitor_run.updated_at}" if monitor_run.updated_at
+          lines << "Completed:      #{monitor_run.completed_at}" if monitor_run.completed_at
+
+          if monitor_run.failed?
+            lines << ""
+            lines << "Failed:         #{monitor_run.failed_at}" if monitor_run.failed_at
+            lines << "Reason:         #{monitor_run.failed_reason}" if monitor_run.failed_reason
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_pretty
+
+        def self.format_as_text(monitor_run)
+          lines = []
+          lines << "Monitor Run: #{monitor_run.id}"
+          lines << "Monitor: #{monitor_run.monitor_id}" if monitor_run.monitor_id
+          lines << "Status: #{monitor_run.status}"
+
+          lines << "\nCreated: #{monitor_run.created_at}" if monitor_run.created_at
+          lines << "Updated: #{monitor_run.updated_at}" if monitor_run.updated_at
+          lines << "Completed: #{monitor_run.completed_at}" if monitor_run.completed_at
+
+          if monitor_run.failed?
+            lines << "Failed: #{monitor_run.failed_at}" if monitor_run.failed_at
+            lines << "Reason: #{monitor_run.failed_reason}" if monitor_run.failed_reason
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_as_text
+
+        def self.format_collection_as_pretty(collection)
+          lines = []
+          lines << "Monitor Runs (#{collection.data.length} items)"
+          lines << ""
+
+          collection.data.each_with_index do |run, idx|
+            lines << "" if idx > 0  # Blank line between runs
+
+            lines << "Monitor Run ID: #{run['id']}"
+            lines << "Monitor ID:     #{run['monitorId']}" if run['monitorId']
+            lines << "Status:         #{run['status']}"
+            lines << "Created:        #{run['createdAt']}" if run['createdAt']
+            lines << "Updated:        #{run['updatedAt']}" if run['updatedAt']
+            lines << "Completed:      #{run['completedAt']}" if run['completedAt']
+
+            if run['status'] == 'failed'
+              lines << "Failed:         #{run['failedAt']}" if run['failedAt']
+              lines << "Reason:         #{run['failedReason']}" if run['failedReason']
+            end
+          end
+
+          if collection.has_more
+            lines << ""
+            lines << "Next Cursor:    #{collection.next_cursor}"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_pretty
+
+        def self.format_collection_as_text(collection)
+          lines = ["Monitor Runs (#{collection.data.length} items):"]
+          collection.data.each do |run|
+            lines << "\n  #{run['id']}"
+            lines << "  Status: #{run['status']}"
+            lines << "  Completed: #{run['completedAt']}" if run['completedAt']
+            lines << "  Failed: #{run['failedReason']}" if run['failedReason']
+          end
+
+          if collection.has_more
+            lines << "\nMore available (cursor: #{collection.next_cursor})"
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_text
+      end
+    end
+  end
+end

data/lib/exa/cli/formatters/research_formatter.rb

@@ -10,6 +10,8 @@ module Exa
             format_task_pretty(task, show_events: show_events)
           when "text"
             format_task_text(task, show_events: show_events)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(task.to_h)
           else
             JSON.pretty_generate(task.to_h)
           end
@@ -23,6 +25,8 @@ module Exa
             format_list_pretty(list)
           when "text"
             format_list_text(list)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(list.to_h)
           else
             JSON.pretty_generate(list.to_h)
           end

data/lib/exa/cli/formatters/search_formatter.rb

@@ -12,6 +12,8 @@ module Exa
             format_pretty(result)
           when "text"
             format_text(result)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(result.to_h)
           else
             JSON.pretty_generate(result.to_h)
           end

data/lib/exa/cli/formatters/webset_formatter.rb

@@ -12,6 +12,8 @@ module Exa
             JSON.pretty_generate(webset.to_h)
           when "text"
             format_as_text(webset)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(webset.to_h)
           else
             raise ArgumentError, "Unknown output format: #{output_format}"
           end
@@ -22,9 +24,11 @@ module Exa
           when "json"
             JSON.generate(collection.to_h)
           when "pretty"
-            JSON.pretty_generate(collection.to_h)
+            format_collection_as_pretty(collection)
           when "text"
             format_collection_as_text(collection)
+          when "toon"
+            Exa::CLI::Base.encode_as_toon(collection.to_h)
           else
             raise ArgumentError, "Unknown output format: #{output_format}"
           end
@@ -62,6 +66,66 @@ module Exa
           lines.join("\n")
         end
         private_class_method :format_collection_as_text
+
+        def self.format_collection_as_pretty(collection)
+          lines = []
+
+          # Header with count and pagination info
+          header = "Websets (#{collection.data.length} items)"
+          header += " - Page #{collection.has_more ? '1 of many' : '1 of 1'}" if collection.data.any?
+          lines << header
+
+          if collection.has_more
+            lines << "Next Cursor:   #{collection.next_cursor}"
+          end
+
+          lines << ""
+
+          # Format each webset
+          collection.data.each_with_index do |ws, idx|
+            lines << "" if idx > 0  # Blank line between websets
+
+            lines << "Webset ID:     #{ws['id']}"
+            lines << "Status:        #{ws['status']}"
+            lines << "Title:         #{ws['title']}" if ws['title']
+            lines << "External ID:   #{ws['externalId']}" if ws['externalId']
+            lines << "Created:       #{ws['createdAt']}" if ws['createdAt']
+            lines << "Updated:       #{ws['updatedAt']}" if ws['updatedAt']
+
+            # Searches
+            if ws['searches'] && !ws['searches'].empty?
+              lines << ""
+              lines << "Searches (#{ws['searches'].length}):"
+              ws['searches'].each do |search|
+                status_indicator = case search['status']
+                                   when 'completed' then '✓'
+                                   when 'running' then '→'
+                                   when 'failed' then '✗'
+                                   else '•'
+                                   end
+                lines << "  #{status_indicator} #{search['query']} (#{search['status']})" if search['query']
+              end
+            end
+
+            # Enrichments
+            if ws['enrichments'] && !ws['enrichments'].empty?
+              lines << "Enrichments:   #{ws['enrichments'].length}"
+            end
+
+            # Monitors
+            if ws['monitors'] && !ws['monitors'].empty?
+              lines << "Monitors:      #{ws['monitors'].length}"
+            end
+
+            # Imports
+            if ws['imports'] && !ws['imports'].empty?
+              lines << "Imports:       #{ws['imports'].length}"
+            end
+          end
+
+          lines.join("\n")
+        end
+        private_class_method :format_collection_as_pretty
       end
     end
   end