luciq-cli 0.1.0 → 0.3.0

data/lib/luciq/commands/query.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'luciq/api/client'
+require 'luciq/config'
+require 'luciq/commands/query_arguments'
+
+module Luciq
+  module Commands
+    # Read/query commands. Each public method maps one-to-one to an MCP tool:
+    # it builds that tool's arguments from typed CLI flags (see QueryArguments)
+    # and proxies to the MCP server's CLI endpoint.
+    class Query
+      include QueryArguments
+
+      def initialize(options = {})
+        @options = options
+        @client = API::Client.new
+      end
+
+      # --- Crashes -----------------------------------------------------------
+      def crashes_list
+        execute('list_crashes') { base_args.merge(page_args, sort_args, filters_arg(crash_filters)) }
+      end
+
+      def crash_show(number)
+        execute('crash_details') { base_args.merge(number: number) }
+      end
+
+      def crash_patterns(number)
+        pattern = { pattern_key: @options[:pattern_key], sort_by: @options[:sort_by],
+                    direction: @options[:direction] }.compact
+        execute('crash_patterns') do
+          base_args.merge(number: number).merge(pattern).merge(filters_arg(raw_filters))
+        end
+      end
+
+      def crash_diagnostics(number)
+        execute('crash_diagnostics') { base_args.merge(number: number) }
+      end
+
+      def app_hangs
+        execute('list_app_hangs') { base_args.merge(page_args, sort_args, filters_arg(hang_filters)) }
+      end
+
+      def occurrence_tokens(number)
+        cursor = { current_token: @options[:current_token], direction: @options[:direction] }.compact
+        execute('list_occurrences_tokens') do
+          base_args.merge(number: number).merge(cursor).merge(filters_arg(raw_filters))
+        end
+      end
+
+      def occurrence_details(number, ulid)
+        execute('get_occurrence_details') { base_args.merge(number: number, ulid: ulid) }
+      end
+
+      # --- Bugs --------------------------------------------------------------
+      def bugs_list
+        execute('list_bugs') { base_args.merge(page_args, sort_args, filters_arg(bug_filters)) }
+      end
+
+      def bug_show(number)
+        execute('bug_details') { base_args.merge(number: number) }
+      end
+
+      def bug_update(number)
+        execute('update_bug') { base_args.merge(number: number).merge(bug_update_changes) }
+      end
+
+      # --- APM ---------------------------------------------------------------
+      def apm_groups
+        execute('apm_list_groups') do
+          base_args.merge({ metric: @options[:metric] }.compact, page_args)
+                   .merge(apm_sort_arg, filters_arg(raw_filters))
+        end
+      end
+
+      def apm_group
+        group = { metric: @options[:metric], group_uuid: @options[:group_uuid],
+                  group_url: @options[:group_url], method: @options[:method] }.compact
+        views = @options[:views] ? json_arg(:views, @options[:views]) : { views: ['summary'] }
+        execute('apm_group_view') do
+          base_args.merge(group).merge(views, filters_arg(raw_filters))
+        end
+      end
+
+      def apm_occurrence
+        selector = { metric: @options[:metric], selector: @options[:selector],
+                     group_uuid: @options[:group_uuid], group_url: @options[:group_url],
+                     method: @options[:method], token: @options[:token],
+                     current_token: @options[:current_token],
+                     direction: @options[:direction], limit: @options[:limit] }.compact
+        execute('apm_occurrence') { base_args.merge(selector).merge(filters_arg(raw_filters)) }
+      end
+
+      def apm_funnel_events
+        params = { event_type: @options[:event_type], q: @options[:q], limit: @options[:limit] }.compact
+        execute('apm_funnel_events') { base_args.merge(params) }
+      end
+
+      def apm_funnel_create
+        execute('apm_funnel_write') do
+          base_args.merge(operation: 'create', name: @options[:name]).merge(json_arg(:events, @options[:events]))
+        end
+      end
+
+      def apm_funnel_update
+        changes = { ulid: @options[:ulid], name: @options[:name] }.compact
+        execute('apm_funnel_write') do
+          base_args.merge(operation: 'update').merge(changes, json_arg(:events, @options[:events]))
+        end
+      end
+
+      def apm_funnel_delete
+        execute('apm_funnel_write') { base_args.merge(operation: 'delete', ulid: @options[:ulid]) }
+      end
+
+      # --- Reviews -----------------------------------------------------------
+      def reviews_list
+        execute('list_reviews') do
+          base_args.merge(page_args, sort_dir_args).merge(filters_arg(review_filters))
+        end
+      end
+
+      # --- Surveys -----------------------------------------------------------
+      def surveys_list
+        execute('list_surveys') { base_args.merge(page_args, filters_arg(survey_filters)) }
+      end
+
+      def survey_show(id)
+        page = { page: @options[:page] }.compact
+        execute('survey_details') { base_args.merge(id: id).merge(page, filters_arg(raw_filters)) }
+      end
+
+      # --- Applications & health --------------------------------------------
+      def apps_list
+        execute('list_applications') { page_args.merge({ platform: @options[:platform] }.compact) }
+      end
+
+      def insights
+        execute('app_insights') { base_args.merge(filters_arg(raw_filters)) }
+      end
+
+      # --- Issues ------------------------------------------------------------
+      def issues_list
+        top = { top_issues: @options[:top_issues] }.compact
+        execute('list_issues') do
+          base_args.merge({ limit: @options[:limit] }.compact, sort_dir_args, top)
+                   .merge(json_arg(:pagination, @options[:pagination]), filters_arg(raw_filters))
+        end
+      end
+
+      # --- Opportunities -----------------------------------------------------
+      def opportunities_list
+        execute('list_opportunities') { base_args.merge(page_args, filters_arg(opportunity_filters)) }
+      end
+
+      def opportunity_show(id)
+        execute('opportunity_details') { base_args.merge(id: id) }
+      end
+
+      # --- Alerts (rules) ----------------------------------------------------
+      def alerts_list
+        execute('read_alerts') { base_args.merge(action: 'list').merge(sort_dir_args) }
+      end
+
+      def alert_show(ulid)
+        execute('read_alerts') { base_args.merge(action: 'details', ulid: ulid) }
+      end
+
+      def alerts_init
+        execute('read_alerts') { base_args.merge(action: 'init') }
+      end
+
+      def alert_create
+        execute('write_alerts') { alert_payload.merge(base_args).merge(action: 'create') }
+      end
+
+      def alert_update(ulid)
+        execute('write_alerts') { alert_payload.merge(base_args).merge(action: 'update', ulid: ulid) }
+      end
+
+      def alert_delete(ulid)
+        execute('write_alerts') { base_args.merge(action: 'delete', ulid: ulid) }
+      end
+
+      # --- Incidents (triggered alerts) --------------------------------------
+      def incidents_list
+        execute('read_incidents') do
+          base_args.merge(action: 'list').merge(page_args, sort_dir_args, filters_arg(incident_filters))
+        end
+      end
+
+      def incident_show(ulid)
+        execute('read_incidents') { base_args.merge(action: 'details', ulid: ulid) }
+      end
+
+      def incident_resolve(ulid)
+        execute('write_incidents') { base_args.merge(action: 'resolve', ulid: ulid) }
+      end
+
+      def incident_reopen(ulid)
+        execute('write_incidents') { base_args.merge(action: 'reopen', ulid: ulid) }
+      end
+
+      private
+
+      def execute(tool_name)
+        ensure_authenticated!
+        print_result(@client.invoke_tool(tool_name, yield))
+      rescue StandardError => e
+        puts "✗ #{e.message}"
+        exit 1
+      end
+
+      def ensure_authenticated!
+        return if Config.load_token
+
+        puts '✗ Not authenticated. Run: luciq login'
+        exit 1
+      end
+
+      def print_result(response)
+        puts(response.is_a?(String) ? response : JSON.pretty_generate(response))
+      end
+    end
+  end
+end

data/lib/luciq/commands/query_arguments.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Luciq
+  module Commands
+    # Translates CLI flags (@options) into the argument/filter hashes the MCP
+    # tools expect. Mixed into Commands::Query; kept separate so the command
+    # dispatch stays thin and the flag→argument mapping is easy to test.
+    module QueryArguments
+      CRASH_STATUS_IDS = { 'open' => 1, 'closed' => 2, 'in_progress' => 3 }.freeze
+      BUG_STATUS_IDS   = { 'new' => 1, 'closed' => 2, 'in_progress' => 3 }.freeze
+      BUG_PRIORITY_IDS = { 'na' => -1, 'trivial' => 1, 'minor' => 2, 'major' => 3, 'blocker' => 4 }.freeze
+
+      private
+
+      def base_args
+        { slug: @options[:slug], mode: @options[:mode] }
+      end
+
+      def page_args
+        { offset: @options[:offset], limit: @options[:limit] }.compact
+      end
+
+      def sort_args
+        { sort_by: @options[:sort_by], direction: @options[:direction] }.compact
+      end
+
+      def sort_dir_args
+        { sort_by: @options[:sort_by], sort_direction: @options[:sort_direction] }.compact
+      end
+
+      def apm_sort_arg
+        return {} unless @options[:sort]
+
+        { sort: [parse_json(@options[:sort], '--sort')] }
+      end
+
+      def crash_filters
+        f = raw_filters
+        ids = map_ids(CRASH_STATUS_IDS, @options[:status])
+        f['status_id'] = ids unless ids.empty?
+        f['platform'] = Array(@options[:platform]) if @options[:platform]
+        f['type'] = Array(@options[:type]) if @options[:type]
+        f['app_versions'] = Array(@options[:app_version]) if @options[:app_version]
+        f
+      end
+
+      def hang_filters
+        f = raw_filters
+        ids = map_ids(CRASH_STATUS_IDS, @options[:status])
+        f['status_id'] = ids unless ids.empty?
+        f['platform'] = Array(@options[:platform]) if @options[:platform]
+        f['app_versions'] = Array(@options[:app_version]) if @options[:app_version]
+        f
+      end
+
+      def bug_filters
+        f = raw_filters
+        ids = map_ids(BUG_STATUS_IDS, @options[:status])
+        f['status_id'] = ids unless ids.empty?
+        pri = map_ids(BUG_PRIORITY_IDS, @options[:priority])
+        f['priority_id'] = pri unless pri.empty?
+        f['app_version'] = Array(@options[:app_version]) if @options[:app_version]
+        f
+      end
+
+      def review_filters
+        f = raw_filters
+        f['rating'] = Array(@options[:rating]).map(&:to_i) if @options[:rating]
+        f['country'] = Array(@options[:country]) if @options[:country]
+        f['os'] = Array(@options[:os]) if @options[:os]
+        f
+      end
+
+      def survey_filters
+        f = raw_filters
+        f['type'] = Array(@options[:type]).map(&:to_i) if @options[:type]
+        f['status'] = Array(@options[:status]).map(&:to_i) if @options[:status]
+        f
+      end
+
+      def opportunity_filters
+        f = raw_filters
+        f['status'] = Array(@options[:status]) if @options[:status]
+        f['priority'] = Array(@options[:priority]) if @options[:priority]
+        f['team_id'] = @options[:team_id] if @options[:team_id]
+        f
+      end
+
+      def incident_filters
+        f = raw_filters
+        f['status'] = Array(@options[:status]) if @options[:status]
+        f['type'] = Array(@options[:type]) if @options[:type]
+        f
+      end
+
+      # Top-level (non-filter) changes for `bugs update`.
+      def bug_update_changes
+        action = bug_duplicate_action
+        if action && (@options[:status] || @options[:priority])
+          raise 'Duplicate marking cannot be combined with --status/--priority'
+        end
+        if @options[:clear_tags] && @options[:tag_action]
+          raise '--clear-tags cannot be combined with --tag-action (--clear-tags already replaces with an empty set)'
+        end
+
+        changes = {
+          status_id: map_one(BUG_STATUS_IDS, @options[:status]),
+          priority_id: map_one(BUG_PRIORITY_IDS, @options[:priority]),
+          tags: (@options[:clear_tags] ? [] : @options[:tags]),
+          action: action,
+          original_bug_number: @options[:duplicate_of]
+        }.compact
+
+        if changes.empty?
+          raise 'Provide at least one change (--status/--priority/--tags/--clear-tags/--duplicate-of/--action)'
+        end
+
+        # tag_action only modifies how --tags is applied; on its own it is not a change
+        if @options[:clear_tags]
+          changes[:tag_action] = 'replace'
+        elsif @options[:tag_action]
+          changes[:tag_action] = @options[:tag_action]
+        end
+
+        changes
+      end
+
+      def bug_duplicate_action
+        return @options[:action] if @options[:action]
+
+        'mark_as_duplicate' if @options[:duplicate_of]
+      end
+
+      def filters_arg(filters)
+        filters.empty? ? {} : { filters: filters }
+      end
+
+      def json_arg(key, raw)
+        return {} if raw.nil?
+
+        { key => parse_json(raw, "--#{key}") }
+      end
+
+      def raw_filters
+        return {} unless @options[:filters]
+
+        parsed = parse_json(@options[:filters], '--filters')
+        raise '--filters must be a JSON object' unless parsed.is_a?(Hash)
+
+        parsed
+      end
+
+      def alert_payload
+        return {} unless @options[:payload]
+
+        parsed = parse_json(@options[:payload], '--payload')
+        raise '--payload must be a JSON object' unless parsed.is_a?(Hash)
+
+        parsed.transform_keys(&:to_sym)
+      end
+
+      def parse_json(str, label)
+        JSON.parse(str)
+      rescue JSON::ParserError => e
+        raise "Invalid #{label} JSON: #{e.message}"
+      end
+
+      def map_ids(mapping, values)
+        Array(values).filter_map { |v| mapping[v] }
+      end
+
+      def map_one(mapping, value)
+        value && mapping[value]
+      end
+    end
+  end
+end

data/lib/luciq/commands/upload.rb

@@ -5,33 +5,83 @@ require 'luciq/api/client'
 module Luciq
   module Commands
     class Upload
+      ALLOWED_ARCHITECTURES = %w[armeabi-v7a arm64-v8a x86 x86_64].freeze
+
       def initialize(options = {})
         @options = options
         @client = API::Client.new
       end
 
+      def ios_dsym(file_path)
+        run_upload('ios-dsym', file_path, 'iOS dSYM file', format: :zip)
+      end
+
       def android_mapping(file_path)
+        run_upload('android-mapping', file_path, 'Android mapping file')
+      end
+
+      def android_ndk(file_path)
+        run_upload('android-ndk', file_path, 'Android NDK .so files', format: :zip, arch: true)
+      end
+
+      def react_native_ios_dsym(file_path)
+        run_upload('react-native-ios-dsym', file_path, 'React Native iOS dSYM', format: :zip)
+      end
+
+      def react_native_ios_sourcemap(file_path)
+        run_upload('react-native-ios-sourcemap', file_path, 'React Native iOS source map', format: :sourcemap)
+      end
+
+      def react_native_android_mapping(file_path)
+        run_upload('react-native-android-mapping', file_path, 'React Native Android mapping file')
+      end
+
+      def react_native_android_sourcemap(file_path)
+        run_upload('react-native-android-sourcemap', file_path, 'React Native Android source map', format: :sourcemap)
+      end
+
+      def react_native_ndk(file_path)
+        run_upload('react-native-ndk', file_path, 'React Native NDK .so files', format: :zip, arch: true)
+      end
+
+      def flutter_ios_dsym(file_path)
+        run_upload('flutter-ios-dsym', file_path, 'Flutter iOS dSYM', format: :zip)
+      end
+
+      def flutter_ios_sourcemap(file_path)
+        run_upload('flutter-ios-sourcemap', file_path, 'Flutter iOS Dart sourcemap', format: :zip)
+      end
+
+      def flutter_android_mapping(file_path)
+        run_upload('flutter-android-mapping', file_path, 'Flutter Android mapping file')
+      end
+
+      def flutter_android_sourcemap(file_path)
+        run_upload('flutter-android-sourcemap', file_path, 'Flutter Android Dart sourcemap', format: :zip)
+      end
+
+      def flutter_ndk(file_path)
+        run_upload('flutter-ndk', file_path, 'Flutter NDK .so files', format: :zip, arch: true)
+      end
+
+      private
+
+      def run_upload(command, file_path, label, format: nil, arch: false)
         validate_file!(file_path)
-        validate_zip_extension!(file_path)
+        validate_format!(file_path, format)
+        validate_arch! if arch
 
-        puts "Uploading Android mapping file: #{File.basename(file_path)}"
+        puts "Uploading #{label}: #{File.basename(file_path)}"
         puts
 
-        @client.upload_android_mapping(
-          file_path: file_path,
-          app_token: @options[:app_token],
-          version_code: @options[:version_code],
-          version_name: @options[:version_name]
-        )
+        @client.upload(command, file_path, @options)
 
-        puts '✓ Android mapping file uploaded successfully!'
+        puts "✓ #{label} uploaded successfully!"
       rescue StandardError => e
         puts "✗ Upload failed: #{e.message}"
         exit 1
       end
 
-      private
-
       def validate_file!(file_path)
         unless File.exist?(file_path)
           puts "✗ File not found: #{file_path}"
@@ -44,11 +94,32 @@ module Luciq
         exit 1
       end
 
+      def validate_format!(file_path, format)
+        case format
+        when :zip then validate_zip_extension!(file_path)
+        when :sourcemap then validate_sourcemap_extension!(file_path)
+        end
+      end
+
       def validate_zip_extension!(file_path)
         return if file_path.downcase.end_with?('.zip')
 
         puts "✗ File must be a .zip archive: #{file_path}"
-        puts '  The ZIP should contain a single text file.'
+        exit 1
+      end
+
+      def validate_sourcemap_extension!(file_path)
+        return if file_path.downcase.end_with?('.json', '.txt')
+
+        puts "✗ Source map must be a .json or .txt file: #{file_path}"
+        exit 1
+      end
+
+      def validate_arch!
+        return if ALLOWED_ARCHITECTURES.include?(@options[:arch])
+
+        puts "✗ Invalid architecture: #{@options[:arch]}"
+        puts "  Allowed values: #{ALLOWED_ARCHITECTURES.join(', ')}"
         exit 1
       end
     end

data/lib/luciq/config.rb

@@ -11,7 +11,8 @@ module Luciq
       end
 
       def load_token
-        ENV['LUCIQ_AUTH_TOKEN'] || load_value('token')
+        token = ENV['LUCIQ_AUTH_TOKEN'] || load_value('token')
+        token unless token.to_s.strip.empty?
       end
 
       def save_token(token)