appydave-tools 0.70.0 → 0.71.0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Generate command creates shell aliases and help content
+        class Generate < Base
+          VALID_TARGETS = %w[aliases help all].freeze
+
+          attr_reader :target, :output_path, :output_dir
+
+          # rubocop:disable Metrics/ParameterLists
+          def initialize(config, target, output_path: nil, output_dir: nil, path_validator: PathValidator.new, **options)
+            super(config, path_validator: path_validator, **options)
+            @target = target
+            @output_path = output_path
+            @output_dir = output_dir
+          end
+          # rubocop:enable Metrics/ParameterLists
+
+          def run
+            unless VALID_TARGETS.include?(target)
+              return error_result(
+                "Unknown generate target: #{target}",
+                code: 'INVALID_INPUT',
+                suggestion: "Valid targets: #{VALID_TARGETS.join(', ')}"
+              )
+            end
+
+            send("generate_#{target}")
+          end
+
+          private
+
+          def generate_aliases
+            content = build_aliases_content
+            write_or_return(content, output_path, 'aliases-jump.zsh')
+          end
+
+          def generate_help
+            content = build_help_content
+            write_or_return(content, output_path, 'jump-help.txt')
+          end
+
+          def generate_all
+            aliases_content = build_aliases_content
+            help_content = build_help_content
+
+            if output_dir
+              aliases_path = File.join(output_dir, 'aliases-jump.zsh')
+              help_path = File.join(output_dir, 'data', 'jump-help.txt')
+
+              FileUtils.mkdir_p(File.dirname(aliases_path))
+              FileUtils.mkdir_p(File.dirname(help_path))
+
+              File.write(aliases_path, aliases_content)
+              File.write(help_path, help_content)
+
+              success_result(
+                message: 'Generated all files',
+                files: [aliases_path, help_path]
+              )
+            else
+              success_result(
+                aliases: aliases_content,
+                help: help_content
+              )
+            end
+          end
+
+          def build_aliases_content
+            lines = []
+            lines << '# Jump Location Aliases'
+            lines << "# Generated by: jump generate aliases (#{Time.now.strftime('%Y-%m-%d %H:%M')})"
+            lines << '# Source: ~/.config/appydave/locations.json'
+            lines << ''
+            lines << '# Usage: source this file in your .zshrc'
+            lines << '#   source ~/.oh-my-zsh/custom/aliases-jump.zsh'
+            lines << ''
+
+            # Group by brand/client
+            grouped = group_locations_for_aliases
+
+            grouped.each do |group_name, locations|
+              lines << "# #{group_name}"
+              locations.each do |loc|
+                path = path_validator.expand(loc.path)
+                desc = loc.description ? "  # #{loc.description}" : ''
+                lines << "alias #{loc.jump}=\"cd '#{path}'\"#{desc}"
+              end
+              lines << ''
+            end
+
+            lines.join("\n")
+          end
+
+          def build_help_content
+            lines = []
+            lines << '# Jump Location Help'
+            lines << "# Generated: #{Time.now.strftime('%Y-%m-%d %H:%M')}"
+            lines << ''
+
+            # Format for fzf/ah integration
+            config.locations.each do |loc|
+              path = path_validator.expand(loc.path)
+              brand_client = loc.brand || loc.client || ''
+              type = loc.type || ''
+              desc = loc.description || ''
+
+              # Format: jump_alias | path | brand/client | type | description
+              lines << "#{loc.jump}\t#{path}\t#{brand_client}\t#{type}\t#{desc}"
+            end
+
+            lines.join("\n")
+          end
+
+          def group_locations_for_aliases
+            grouped = {}
+
+            config.locations.each do |loc|
+              group = loc.brand || loc.client || 'Other'
+              grouped[group] ||= []
+              grouped[group] << loc
+            end
+
+            # Sort groups and locations within groups
+            grouped.sort.to_h.transform_values do |locs|
+              locs.sort_by(&:key)
+            end
+          end
+
+          def write_or_return(content, path, default_filename)
+            if path
+              FileUtils.mkdir_p(File.dirname(path))
+              File.write(path, content)
+              success_result(
+                message: "Generated #{default_filename}",
+                path: path,
+                lines: content.lines.count
+              )
+            else
+              success_result(
+                content: content,
+                lines: content.lines.count
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Remove command deletes a location entry
+        class Remove < Base
+          attr_reader :key, :force
+
+          def initialize(config, key, force: false, path_validator: PathValidator.new, **options)
+            super(config, path_validator: path_validator, **options)
+            @key = key
+            @force = force
+          end
+
+          def run
+            # Validate key exists
+            location = config.find(key)
+            unless location
+              suggestions = find_suggestions(key)
+              suggestion = suggestions.empty? ? nil : "Did you mean: #{suggestions.join(', ')}?"
+              return error_result("Location '#{key}' not found", code: 'NOT_FOUND', suggestion: suggestion)
+            end
+
+            # Require --force
+            unless force
+              return error_result(
+                "Use --force to confirm removal of '#{key}'",
+                code: 'CONFIRMATION_REQUIRED'
+              )
+            end
+
+            # Remove
+            config.remove(key)
+            config.save
+
+            success_result(
+              message: "Location '#{key}' removed successfully",
+              removed: location.to_h
+            )
+          rescue ArgumentError => e
+            error_result(e.message, code: 'NOT_FOUND')
+          end
+
+          private
+
+          def find_suggestions(query)
+            config.locations
+                  .map(&:key)
+                  .select { |k| k.include?(query) || query.include?(k) || k.start_with?(query[0..1]) }
+                  .first(3)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Report command generates various reports about locations
+        class Report < Base
+          VALID_REPORTS = %w[
+            categories brands clients types tags
+            by-brand by-client by-type by-tag
+            summary
+          ].freeze
+
+          attr_reader :report_type, :filter
+
+          def initialize(config, report_type, filter: nil, path_validator: PathValidator.new, **options)
+            super(config, path_validator: path_validator, **options)
+            @report_type = report_type
+            @filter = filter
+          end
+
+          def run
+            unless VALID_REPORTS.include?(report_type)
+              return error_result(
+                "Unknown report type: #{report_type}",
+                code: 'INVALID_INPUT',
+                suggestion: "Valid types: #{VALID_REPORTS.join(', ')}"
+              )
+            end
+
+            send("report_#{report_type.gsub('-', '_')}")
+          end
+
+          private
+
+          def report_categories
+            categories = config.categories.map do |name, info|
+              {
+                name: name,
+                description: info['description'] || info[:description],
+                values: info['values'] || info[:values] || []
+              }
+            end
+
+            success_result(
+              report: 'categories',
+              count: categories.size,
+              results: categories
+            )
+          end
+
+          def report_brands
+            brands = config.brands.map do |key, info|
+              location_count = config.locations.count { |loc| loc.brand == key }
+              {
+                key: key,
+                description: info['description'] || info[:description],
+                aliases: info['aliases'] || info[:aliases] || [],
+                location_count: location_count
+              }
+            end
+
+            success_result(
+              report: 'brands',
+              count: brands.size,
+              results: brands.sort_by { |b| -b[:location_count] }
+            )
+          end
+
+          def report_clients
+            clients = config.clients.map do |key, info|
+              location_count = config.locations.count { |loc| loc.client == key }
+              {
+                key: key,
+                description: info['description'] || info[:description],
+                aliases: info['aliases'] || info[:aliases] || [],
+                location_count: location_count
+              }
+            end
+
+            success_result(
+              report: 'clients',
+              count: clients.size,
+              results: clients.sort_by { |c| -c[:location_count] }
+            )
+          end
+
+          def report_types
+            type_counts = Hash.new(0)
+            config.locations.each do |loc|
+              type_counts[loc.type || 'untyped'] += 1
+            end
+
+            types = type_counts.map do |type, count|
+              { type: type, location_count: count }
+            end
+
+            success_result(
+              report: 'types',
+              count: types.size,
+              results: types.sort_by { |t| -t[:location_count] }
+            )
+          end
+
+          def report_tags
+            tag_counts = Hash.new(0)
+            config.locations.each do |loc|
+              loc.tags.each { |tag| tag_counts[tag] += 1 }
+            end
+
+            tags = tag_counts.map do |tag, count|
+              { tag: tag, location_count: count }
+            end
+
+            success_result(
+              report: 'tags',
+              count: tags.size,
+              results: tags.sort_by { |t| -t[:location_count] }
+            )
+          end
+
+          def report_by_brand
+            grouped = group_by_field(:brand, filter)
+            success_result(
+              report: 'by-brand',
+              filter: filter,
+              groups: grouped
+            )
+          end
+
+          def report_by_client
+            grouped = group_by_field(:client, filter)
+            success_result(
+              report: 'by-client',
+              filter: filter,
+              groups: grouped
+            )
+          end
+
+          def report_by_type
+            grouped = group_by_field(:type, filter)
+            success_result(
+              report: 'by-type',
+              filter: filter,
+              groups: grouped
+            )
+          end
+
+          def report_by_tag
+            grouped = {}
+            config.locations.each do |loc|
+              loc.tags.each do |tag|
+                next if filter && tag != filter
+
+                grouped[tag] ||= []
+                grouped[tag] << location_summary(loc)
+              end
+            end
+
+            success_result(
+              report: 'by-tag',
+              filter: filter,
+              groups: grouped.sort_by { |_, locs| -locs.size }.to_h
+            )
+          end
+
+          def report_summary
+            success_result(
+              report: 'summary',
+              total_locations: config.locations.size,
+              total_brands: config.brands.size,
+              total_clients: config.clients.size,
+              by_type: count_by_field(:type),
+              by_brand: count_by_field(:brand),
+              by_client: count_by_field(:client),
+              config_info: config.info
+            )
+          end
+
+          def group_by_field(field, filter_value)
+            grouped = {}
+            config.locations.each do |loc|
+              value = loc.send(field) || 'unassigned'
+              next if filter_value && value != filter_value
+
+              grouped[value] ||= []
+              grouped[value] << location_summary(loc)
+            end
+            grouped.sort_by { |_, locs| -locs.size }.to_h
+          end
+
+          def count_by_field(field)
+            counts = Hash.new(0)
+            config.locations.each do |loc|
+              value = loc.send(field) || 'unassigned'
+              counts[value] += 1
+            end
+            counts.sort_by { |_, count| -count }.to_h
+          end
+
+          def location_summary(location)
+            {
+              key: location.key,
+              path: location.path,
+              jump: location.jump,
+              description: location.description
+            }.compact
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Update command modifies an existing location entry
+        class Update < Base
+          attr_reader :key, :attrs
+
+          def initialize(config, key, attrs, path_validator: PathValidator.new, **options)
+            super(config, path_validator: path_validator, **options)
+            @key = key
+            @attrs = attrs
+          end
+
+          def run
+            # Validate key exists
+            return error_result("Location '#{key}' not found", code: 'NOT_FOUND') unless config.key_exists?(key)
+
+            # Validate path if provided
+            @path_warning = "Warning: Path '#{attrs[:path]}' does not exist" if attrs[:path] && !path_validator.exists?(attrs[:path])
+
+            # Update
+            config.update(key, attrs)
+            config.save
+
+            updated = config.find(key)
+            result = success_result(
+              message: "Location '#{key}' updated successfully",
+              location: updated.to_h
+            )
+            result[:warning] = @path_warning if @path_warning
+            result
+          rescue ArgumentError => e
+            error_result(e.message, code: 'INVALID_INPUT')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Validate command checks if location paths exist
+        class Validate < Base
+          attr_reader :key
+
+          def initialize(config, key: nil, path_validator: PathValidator.new, **options)
+            super(config, path_validator: path_validator, **options)
+            @key = key
+          end
+
+          def run
+            locations_to_validate = if key
+                                      location = config.find(key)
+                                      return error_result("Location '#{key}' not found", code: 'NOT_FOUND') unless location
+
+                                      [location]
+                                    else
+                                      config.locations
+                                    end
+
+            results = locations_to_validate.map do |loc|
+              {
+                key: loc.key,
+                path: loc.path,
+                expanded_path: path_validator.expand(loc.path),
+                valid: path_validator.exists?(loc.path),
+                jump: loc.jump
+              }
+            end
+
+            valid_count = results.count { |r| r[:valid] }
+            invalid_count = results.count { |r| !r[:valid] }
+
+            # Update validation timestamp
+            config.touch_validated
+            config.save
+
+            success_result(
+              count: results.size,
+              valid_count: valid_count,
+              invalid_count: invalid_count,
+              results: results
+            )
+          end
+        end
+      end
+    end
+  end
+end