appydave-tools 0.74.1 → 0.75.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef8315540ea80d07de1a6eba6733c1be84e21caaa4251dbb60e9a2207abf9758
-  data.tar.gz: 3a386ab9c8b399ceca1056f20fae6543bc534ddf37a7d104363acc09ad694e48
+  metadata.gz: e45ff57b507a705f826281a7d361abf0724d719eaf1c1ba4795198f3a4551a7f
+  data.tar.gz: edfc8fcdb775c290d9c59a588215de3e2c613075ee49332836bf19de92a5126b
 SHA512:
-  metadata.gz: 70af1beaa0539e9a71ffb1e4435ffe1afad1da73cfbbe4f16c780110684975fdbf3de5602e7cc5b9bd226404158d0f24aee5126186b3821235b782508bc9150b
-  data.tar.gz: 6e06cc27ccebd7d49ba9831f3e9f1345f96bc0ffce681fc56be6a08799a32d828b8c68e32633d74a99b397a1a7bde699c89a5077745439ccbc9f3c8cf3e2af2e
+  metadata.gz: d5d45772ed9304ac22cca51417c0d48b0d176d824933feaafbc4a34c50ff8585bbce93a4f423ecadc39ac64aeca5e0e2724556a1407c428a318fa86926a65899
+  data.tar.gz: ab16611805c302aeb6fe1930e3502d4330cb00833bd282e2631e9cbb25f6fc179eb66c7e6cd4535a89005cd743cc0db6c3e9eaaaeea0a22c671274e5b6f9b43d

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.74.1](https://github.com/appydave/appydave-tools/compare/v0.74.0...v0.74.1) (2026-02-04)
+
+
+### Bug Fixes
+
+* remove redundant rubocop disable comments blocking CI ([0aa8956](https://github.com/appydave/appydave-tools/commit/0aa89561f229488c01c2a9467c829ac3a8851e72))
+
 # [0.74.0](https://github.com/appydave/appydave-tools/compare/v0.73.0...v0.74.0) (2025-12-18)
 
 

data/lib/appydave/tools/jump/cli.rb

@@ -241,16 +241,25 @@ module Appydave
 
         def run_report(args)
           format = format_option(args)
+          limit = extract_option(args, '--limit')&.to_i
+          skip_unassigned = !args.delete('--include-unassigned')
           report_type = args.shift
           filter = args.first
 
           unless report_type
-            output.puts 'Usage: jump report <type> [filter]'
+            output.puts 'Usage: jump report <type> [filter] [--limit N] [--include-unassigned]'
             output.puts 'Types: categories, brands, clients, types, tags, by-brand, by-client, by-type, by-tag, summary'
             return EXIT_INVALID_INPUT
           end
 
-          cmd = Commands::Report.new(load_config, report_type, filter: filter, path_validator: path_validator)
+          cmd = Commands::Report.new(
+            load_config,
+            report_type,
+            filter: filter,
+            limit: limit,
+            skip_unassigned: skip_unassigned,
+            path_validator: path_validator
+          )
           result = cmd.run
 
           format_output(result, format)
@@ -577,7 +586,7 @@ module Appydave
           output.puts <<~HELP
             jump report - Generate reports
 
-            Usage: jump report <type> [filter]
+            Usage: jump report <type> [filter] [--limit N] [--include-unassigned]
 
             Report Types:
               categories    List all category definitions
@@ -591,9 +600,15 @@ module Appydave
               by-tag        Group locations by tag
               summary       Overview of all data
 
+            Options:
+              --limit N               Limit output to top N items/groups
+              --include-unassigned    Show unassigned groups (hidden by default)
+
             Examples:
               jump report brands
-              jump report by-brand appydave
+              jump report tags --limit 20
+              jump report by-brand --include-unassigned
+              jump report by-client appydave --limit 5
               jump report tags --format json
           HELP
         end

data/lib/appydave/tools/jump/commands/report.rb

@@ -12,12 +12,14 @@ module Appydave
             summary
           ].freeze
 
-          attr_reader :report_type, :filter
+          attr_reader :report_type, :filter, :limit, :skip_unassigned
 
-          def initialize(config, report_type, filter: nil, path_validator: PathValidator.new, **options)
-            super(config, path_validator: path_validator, **options)
+          def initialize(config, report_type, **options)
+            super(config, path_validator: options[:path_validator] || PathValidator.new, **options)
             @report_type = report_type
-            @filter = filter
+            @filter = options[:filter]
+            @limit = options[:limit]
+            @skip_unassigned = options.fetch(:skip_unassigned, true)
           end
 
           def run
@@ -96,10 +98,15 @@ module Appydave
               { type: type, location_count: count }
             end
 
+            sorted = types.sort_by { |t| -t[:location_count] }
+            limited = limit ? sorted.take(limit) : sorted
+
             success_result(
               report: 'types',
-              count: types.size,
-              results: types.sort_by { |t| -t[:location_count] }
+              count: limited.size,
+              total_count: types.size,
+              results: limited,
+              truncated: limit && types.size > limit
             )
           end
 
@@ -113,37 +120,51 @@ module Appydave
               { tag: tag, location_count: count }
             end
 
+            sorted = tags.sort_by { |t| -t[:location_count] }
+            limited = limit ? sorted.take(limit) : sorted
+
             success_result(
               report: 'tags',
-              count: tags.size,
-              results: tags.sort_by { |t| -t[:location_count] }
+              count: limited.size,
+              total_count: tags.size,
+              results: limited,
+              truncated: limit && tags.size > limit
             )
           end
 
           def report_by_brand
             grouped = group_by_field(:brand, filter)
+            grouped = apply_group_filters(grouped)
             success_result(
               report: 'by-brand',
               filter: filter,
-              groups: grouped
+              groups: grouped,
+              limit: limit,
+              skip_unassigned: skip_unassigned
             )
           end
 
           def report_by_client
             grouped = group_by_field(:client, filter)
+            grouped = apply_group_filters(grouped)
             success_result(
               report: 'by-client',
               filter: filter,
-              groups: grouped
+              groups: grouped,
+              limit: limit,
+              skip_unassigned: skip_unassigned
             )
           end
 
           def report_by_type
             grouped = group_by_field(:type, filter)
+            grouped = apply_group_filters(grouped)
             success_result(
               report: 'by-type',
               filter: filter,
-              groups: grouped
+              groups: grouped,
+              limit: limit,
+              skip_unassigned: skip_unassigned
             )
           end
 
@@ -158,10 +179,15 @@ module Appydave
               end
             end
 
+            grouped = grouped.sort_by { |_, locs| -locs.size }.to_h
+            grouped = apply_group_filters(grouped)
+
             success_result(
               report: 'by-tag',
               filter: filter,
-              groups: grouped.sort_by { |_, locs| -locs.size }.to_h
+              groups: grouped,
+              limit: limit,
+              skip_unassigned: skip_unassigned
             )
           end
 
@@ -207,6 +233,24 @@ module Appydave
               description: location.description
             }.compact
           end
+
+          def apply_group_filters(grouped)
+            # Remove unassigned group if skip_unassigned is true
+            grouped = grouped.reject { |key, _| key == 'unassigned' } if skip_unassigned
+
+            # Apply limit to each group (limit items per group)
+            if limit
+              grouped.transform_values do |locations|
+                {
+                  items: locations.take(limit),
+                  total: locations.size,
+                  truncated: locations.size > limit
+                }
+              end
+            else
+              grouped
+            end
+          end
         end
       end
     end

data/lib/appydave/tools/jump/formatters/base.rb

@@ -26,6 +26,10 @@ module Appydave
             data[:results] || []
           end
 
+          def groups
+            data[:groups] || {}
+          end
+
           def success?
             data[:success]
           end

data/lib/appydave/tools/jump/formatters/table_formatter.rb

@@ -26,7 +26,12 @@ module Appydave
           def format
             return format_error unless success?
             return format_info if info_result?
+            return format_summary if summary_result?
+            return format_groups unless groups.empty?
             return format_empty if results.empty?
+            return format_definition_report if definition_report?
+            return format_count_report if count_report?
+            return format_category_report if category_report?
 
             format_results
           end
@@ -41,13 +46,47 @@ module Appydave
           end
 
           def format_empty
-            colorize('No locations found.', :yellow)
+            message = case data[:report]
+                      when 'brands'
+                        'No brands defined in config.'
+                      when 'clients'
+                        'No clients defined in config.'
+                      else
+                        'No locations found.'
+                      end
+
+            colorize(message, :yellow)
           end
 
           def info_result?
             data.key?(:config_path)
           end
 
+          def summary_result?
+            data.key?(:total_locations) && data.key?(:by_type)
+          end
+
+          def count_report?
+            return false if results.empty?
+
+            first = results.first
+            first.key?(:location_count) && (first.key?(:tag) || first.key?(:type))
+          end
+
+          def definition_report?
+            return false if results.empty?
+
+            first = results.first
+            first.key?(:key) && first.key?(:description) && first.key?(:aliases) && first.key?(:location_count)
+          end
+
+          def category_report?
+            return false if results.empty?
+
+            first = results.first
+            first.key?(:name) && first.key?(:description) && first.key?(:values)
+          end
+
           def format_info
             [
               format_info_header,
@@ -84,6 +123,103 @@ module Appydave
             ]
           end
 
+          def format_summary
+            lines = []
+            lines << colorize('Jump Locations Summary', :bold)
+            lines << ''
+            lines << "#{colorize('Total Locations:', :cyan)} #{data[:total_locations]}"
+            lines << ''
+
+            # By Type
+            lines << colorize('By Type:', :bold)
+            data[:by_type].sort_by { |_, count| -count }.each do |type, count|
+              lines << "  #{pad(type, 15)} #{colorize(count.to_s.rjust(3), :green)}"
+            end
+            lines << ''
+
+            # By Brand
+            lines << colorize('By Brand:', :bold)
+            data[:by_brand].sort_by { |_, count| -count }.each do |brand, count|
+              lines << "  #{pad(brand, 15)} #{colorize(count.to_s.rjust(3), :green)}"
+            end
+            lines << ''
+
+            # By Client
+            lines << colorize('By Client:', :bold)
+            data[:by_client].sort_by { |_, count| -count }.each do |client, count|
+              lines << "  #{pad(client, 15)} #{colorize(count.to_s.rjust(3), :green)}"
+            end
+
+            lines.join("\n")
+          end
+
+          def format_definition_report
+            lines = []
+            report_type = data[:report] || 'items'
+
+            lines << colorize("#{report_type.capitalize} Definitions", :bold)
+            lines << header_separator
+            lines << ''
+
+            results.each do |item|
+              lines << colorize(item[:key], :cyan)
+              lines << "  #{item[:description]}" if item[:description]
+              lines << "  Aliases: #{item[:aliases].join(', ')}" if item[:aliases]&.any?
+              lines << "  Locations: #{colorize(item[:location_count].to_s, :green)}"
+              lines << ''
+            end
+
+            lines << colorize("Total: #{count} #{report_type}", :dim)
+
+            lines.join("\n")
+          end
+
+          def format_count_report
+            lines = []
+            report_type = data[:report] || 'items'
+
+            lines << colorize("#{report_type.capitalize} Report", :bold)
+            lines << header_separator
+            lines << ''
+
+            results.each do |item|
+              name = item[:tag] || item[:type] || 'unknown'
+              count = item[:location_count] || 0
+              lines << "#{pad(name, 20)} #{colorize(count.to_s.rjust(4), :green)}"
+            end
+
+            lines << ''
+
+            # Show truncation message if data was limited
+            if data[:truncated]
+              total = data[:total_count] || data[:count]
+              shown = results.size
+              remaining = total - shown
+              lines << colorize("Showing top #{shown} of #{total} (#{remaining} more)", :dim)
+            else
+              lines << colorize("Total: #{data[:total_count] || count} #{report_type}", :dim)
+            end
+
+            lines.join("\n")
+          end
+
+          def format_category_report
+            lines = []
+
+            lines << colorize('Location Categories', :bold)
+            lines << header_separator
+            lines << ''
+
+            results.each do |category|
+              lines << colorize(category[:name], :cyan)
+              lines << "  #{category[:description]}" if category[:description]
+              lines << "  Values: #{category[:values].join(', ')}" if category[:values]
+              lines << ''
+            end
+
+            lines.join("\n")
+          end
+
           def format_results
             lines = []
 
@@ -103,6 +239,51 @@ module Appydave
             lines.join("\n")
           end
 
+          def format_groups
+            lines = []
+            total_locations = 0
+            total_groups = 0
+
+            groups.each do |group_name, group_data|
+              # Handle both old format (array) and new format (hash with items/total/truncated)
+              locations, total_in_group, truncated = if group_data.is_a?(Hash) && group_data.key?(:items)
+                                                       [group_data[:items], group_data[:total], group_data[:truncated]]
+                                                     else
+                                                       [group_data, group_data.length, false]
+                                                     end
+
+              next if locations.empty?
+
+              # Group header
+              lines << ''
+              lines << colorize("#{group_name.upcase} (#{total_in_group} location#{'s' unless total_in_group == 1})", :bold)
+              lines << header_separator
+
+              # Add index to each location for display
+              locations.each_with_index do |location, idx|
+                location[:index] = idx + 1
+                lines << format_row(location)
+              end
+
+              # Show truncation message if group was limited
+              if truncated
+                remaining = total_in_group - locations.length
+                lines << colorize("  ... and #{remaining} more", :dim)
+              end
+
+              total_locations += total_in_group
+              total_groups += 1
+            end
+
+            # Footer
+            lines << ''
+            footer = "Total: #{total_locations} location(s) in #{total_groups} group(s)"
+            footer += ' (unassigned hidden)' if data[:skip_unassigned]
+            lines << colorize(footer, :dim)
+
+            lines.join("\n")
+          end
+
           def format_header
             cols = [
               pad('#', 3),

data/lib/appydave/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Appydave
   module Tools
-    VERSION = '0.74.1'
+    VERSION = '0.75.0'
   end
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appydave-tools",
-  "version": "0.74.1",
+  "version": "0.75.0",
   "description": "AppyDave YouTube Automation Tools",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appydave-tools
 version: !ruby/object:Gem::Version
-  version: 0.74.1
+  version: 0.75.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-04 00:00:00.000000000 Z
+date: 2026-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel