appydave-tools 0.83.0 → 0.85.0

data/lib/appydave/tools/app_context/app_finder.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Appydave
+  module Tools
+    module AppContext
+      # Queries locations.json to find app files via context.globs.json patterns.
+      #
+      # Follows the same find/find_meta pattern as BrainQuery and OmiQuery.
+      class AppQuery
+        def initialize(options, jump_config: nil)
+          @options = options
+          @jump_config = jump_config
+        end
+
+        # Return absolute file paths matching the query
+        def find
+          return [] unless @options.query?
+
+          apps = resolve_apps
+          return [] if apps.empty?
+
+          apps.flat_map { |app| expand_app(app) }.uniq.sort
+        end
+
+        # Return structured metadata about the query results
+        def find_meta
+          return [] unless @options.query?
+
+          apps = resolve_apps
+          return [] if apps.empty?
+
+          apps.map { |app| build_meta(app) }
+        end
+
+        # List all available glob names for a specific app
+        def list_globs(app_name)
+          location = find_location(app_name)
+          return [] unless location
+
+          loader = build_loader(location)
+          return [] unless loader.available?
+
+          loader.available_names
+        end
+
+        # List all apps that have context.globs.json
+        def list_apps
+          jump_config.locations
+                     .select { |loc| File.exist?(File.join(expand_path(loc.path), 'context.globs.json')) }
+                     .map do |loc|
+                       loader = build_loader(loc)
+                       {
+                         'key' => loc.key,
+                         'path' => expand_path(loc.path),
+                         'pattern' => loader.pattern,
+                         'glob_count' => loader.globs.size
+                       }
+                     end
+        end
+
+        private
+
+        def jump_config
+          @jump_config ||= Jump::Config.new
+        end
+
+        # Resolve app names to Location objects
+        def resolve_apps
+          if @options.pattern_filter
+            resolve_by_pattern(@options.pattern_filter)
+          else
+            @options.app_names.flat_map { |name| resolve_app(name) }.compact.uniq(&:key)
+          end
+        end
+
+        # 4-tier app resolution
+        def resolve_app(name)
+          name_down = name.downcase
+
+          # Tier 1: exact key match
+          loc = jump_config.find(name_down)
+          return [loc] if loc
+
+          # Tier 2: jump alias match
+          loc = jump_config.locations.find { |l| l.jump&.downcase == name_down }
+          return [loc] if loc
+
+          # Tier 3: substring match on key
+          matches = jump_config.locations.select { |l| l.key.downcase.include?(name_down) }
+          return matches unless matches.empty?
+
+          # Tier 4: substring match on description
+          jump_config.locations.select { |l| l.description&.downcase&.include?(name_down) }
+        end
+
+        def resolve_by_pattern(pattern)
+          jump_config.locations.select do |loc|
+            loader = build_loader(loc)
+            loader.available? && loader.pattern&.downcase == pattern.downcase
+          end
+        end
+
+        def expand_app(location)
+          loader = build_loader(location)
+          return [] unless loader.available?
+
+          glob_names = @options.glob_names
+          return [] if glob_names.empty?
+
+          loader.expand(glob_names)
+        end
+
+        def build_meta(location)
+          loader = build_loader(location)
+          glob_names = @options.glob_names
+          file_count = loader.available? && glob_names.any? ? loader.expand(glob_names).size : 0
+
+          resolved_from = glob_names.map { |n| describe_resolution(loader, n) }.join(', ')
+
+          {
+            'app' => location.key,
+            'path' => expand_path(location.path),
+            'pattern' => loader.pattern,
+            'matched_globs' => resolve_glob_names(loader, glob_names),
+            'resolved_from' => resolved_from,
+            'file_count' => file_count
+          }
+        end
+
+        def build_loader(location)
+          GlobsLoader.new(expand_path(location.path))
+        end
+
+        def expand_path(path)
+          File.expand_path(path)
+        end
+
+        def find_location(app_name)
+          results = resolve_app(app_name)
+          results&.first
+        end
+
+        # Describe how a glob name was resolved (for meta output)
+        def describe_resolution(loader, name)
+          name = name.strip.downcase
+          return "#{name} (glob)" if loader.globs.key?(name)
+          return "#{name} (alias)" if loader.aliases.key?(name)
+          return "#{name} (composite)" if loader.composites.key?(name)
+
+          "#{name} (fuzzy)"
+        end
+
+        # Resolve glob names to their constituent direct glob names
+        def resolve_glob_names(loader, names)
+          return [] unless loader.available?
+
+          names.flat_map do |name|
+            name = name.strip.downcase
+            if loader.globs.key?(name)
+              [name]
+            elsif loader.aliases.key?(name)
+              loader.aliases[name]
+            elsif loader.composites.key?(name)
+              members = loader.composites[name]
+              members == ['*'] ? loader.globs.keys : members
+            else # rubocop:disable Lint/DuplicateBranch
+              [name]
+            end
+          end.uniq
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/app_context/globs_loader.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Appydave
+  module Tools
+    module AppContext
+      # Loads and resolves named glob patterns from a context.globs.json file.
+      #
+      # Resolution is 3-tier:
+      #   1. Direct glob name  — "services" → globs["services"]
+      #   2. Alias match       — "backend"  → aliases["backend"] → ["services", "routes"]
+      #   3. Composite match   — "understand" → composites["understand"] → ["context", "docs", ...]
+      class GlobsLoader
+        attr_reader :project_path, :data
+
+        def initialize(project_path)
+          @project_path = project_path
+          @data = load_globs_file
+        end
+
+        def available?
+          !data.nil?
+        end
+
+        def globs
+          data&.fetch('globs', {}) || {}
+        end
+
+        def aliases
+          data&.fetch('aliases', {}) || {}
+        end
+
+        def composites
+          data&.fetch('composites', {}) || {}
+        end
+
+        def pattern
+          data&.fetch('pattern', nil)
+        end
+
+        def project_name
+          data&.fetch('project', nil)
+        end
+
+        # List all available glob names (direct + aliases + composites)
+        def available_names
+          names = globs.keys.map { |k| { name: k, type: 'glob' } }
+          names += aliases.keys.map { |k| { name: k, type: 'alias' } }
+          names += composites.keys.map { |k| { name: k, type: 'composite' } }
+          names
+        end
+
+        # Resolve a single name through the 3-tier hierarchy.
+        # Returns an array of raw glob patterns (strings).
+        def resolve(name)
+          name = name.strip.downcase
+
+          # Tier 1: direct glob name
+          return globs[name] if globs.key?(name)
+
+          # Tier 2: alias → list of glob names
+          return aliases[name].flat_map { |glob_name| globs[glob_name] || [] } if aliases.key?(name)
+
+          # Tier 3: composite → list of glob names (or "*" for all)
+          if composites.key?(name)
+            members = composites[name]
+            return globs.values.flatten if members == ['*']
+
+            return members.flat_map { |glob_name| resolve_single_glob(glob_name) }
+          end
+
+          # Tier 4: substring fallback
+          match = find_substring_match(name)
+          return resolve(match) if match
+
+          []
+        end
+
+        # Resolve multiple names, expand globs against the filesystem, return absolute paths.
+        def expand(names)
+          patterns = names.flat_map { |name| resolve(name) }.uniq
+
+          patterns.flat_map { |pat| Dir.glob(File.join(project_path, pat)) }
+                  .select { |f| File.file?(f) }
+                  .uniq
+                  .sort
+        end
+
+        private
+
+        def globs_file_path
+          File.join(project_path, 'context.globs.json')
+        end
+
+        def load_globs_file
+          path = globs_file_path
+          return nil unless File.exist?(path)
+
+          JSON.parse(File.read(path))
+        rescue JSON::ParserError
+          nil
+        end
+
+        def resolve_single_glob(glob_name)
+          globs[glob_name] || []
+        end
+
+        def find_substring_match(name)
+          all_names = globs.keys + aliases.keys + composites.keys
+          all_names.find { |n| n.include?(name) }
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/app_context/options.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module AppContext
+      # Options struct for app context query tool
+      class Options
+        attr_accessor :app_names, :glob_names, :pattern_filter,
+                      :meta, :list, :list_apps,
+                      :debug_level
+
+        def initialize
+          @app_names = []
+          @glob_names = []
+          @pattern_filter = nil
+          @meta = false
+          @list = false
+          @list_apps = false
+          @debug_level = 'none'
+        end
+
+        def query?
+          app_names.any? || !pattern_filter.nil?
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/brain_context/options.rb

@@ -34,11 +34,15 @@ module Appydave
         @tokens = false
         @base_dir = Dir.pwd
 
-        @omi_dir = File.expand_path('~/dev/raw-intake/omi')
+        configured_omi = read_setting('omi-directory-path')
+        @omi_dir = configured_omi || File.expand_path('~/dev/raw-intake/omi')
       end
 
       def brains_root
-        @brains_root ||= File.expand_path('~/dev/ad/brains')
+        @brains_root ||= begin
+          configured = read_setting('brains-root-path')
+          configured || File.expand_path('~/dev/ad/brains')
+        end
       end
 
       def brains_index_path
@@ -52,6 +56,19 @@ module Appydave
       def omi_query?
         omi
       end
+
+      private
+
+      # Read a path value from settings config, expanding ~ if set.
+      # Returns nil if config is unavailable or key is absent/blank.
+      def read_setting(key)
+        value = Appydave::Tools::Configuration::Config.settings.get(key)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        File.expand_path(value)
+      rescue StandardError
+        nil
+      end
     end
   end
 end

data/lib/appydave/tools/configuration/example_installer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Configuration
+      # Installs bundled example configuration files into the user's config directory.
+      #
+      # Example files live at config/examples/*.example.json inside the gem.
+      # Each file is installed without the `.example` segment in its name so that
+      # `settings.example.json` becomes `settings.json` in the target directory.
+      #
+      # Files are never overwritten — existing files are skipped and reported.
+      #
+      # @example Install all examples
+      #   result = ExampleInstaller.new.install
+      #   result[:installed] #=> ["settings.json", "locations.json"]
+      #   result[:skipped]   #=> []
+      class ExampleInstaller
+        EXAMPLES_PATH = File.expand_path('../../../../config/examples', __dir__)
+
+        # @param target_path [String, nil] Directory to install into.
+        #   Defaults to the active Config.config_path (~/.config/appydave).
+        def initialize(target_path: nil)
+          @target_path = target_path || Config.config_path
+        end
+
+        # Install all bundled example files that do not yet exist.
+        #
+        # @return [Hash] with keys :installed (Array<String>) and :skipped (Array<String>)
+        def install
+          FileUtils.mkdir_p(@target_path)
+          results = { installed: [], skipped: [] }
+
+          example_files.each do |src|
+            dest = destination_for(src)
+            basename = File.basename(dest)
+
+            if File.exist?(dest)
+              results[:skipped] << basename
+            else
+              FileUtils.cp(src, dest)
+              results[:installed] << basename
+            end
+          end
+
+          results
+        end
+
+        # List the filenames that would be installed (target names, not source names).
+        #
+        # @return [Array<String>]
+        def available
+          example_files.map { |f| target_name(f) }
+        end
+
+        private
+
+        def example_files
+          Dir.glob(File.join(EXAMPLES_PATH, '*.example.*')).sort
+        end
+
+        def destination_for(src)
+          File.join(@target_path, target_name(src))
+        end
+
+        def target_name(src)
+          File.basename(src).sub('.example', '')
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/configuration/models/settings_config.rb

@@ -42,6 +42,18 @@ module Appydave
             get('current_user')
           end
 
+          # Path to the root brains directory (second-brain knowledge base)
+          # Configure via settings.json key: brains-root-path
+          def brains_root_path
+            get('brains-root-path')
+          end
+
+          # Path to the OMI wearable transcripts directory
+          # Configure via settings.json key: omi-directory-path
+          def omi_directory_path
+            get('omi-directory-path')
+          end
+
           def print
             log.subheading 'Settings Configuration'
 

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

@@ -54,6 +54,8 @@ module Appydave
             run_remove(args)
           when 'validate'
             run_validate(args)
+          when 'query'
+            run_query(args)
           when 'report'
             run_report(args)
           when 'generate'
@@ -128,6 +130,35 @@ module Appydave
           exit_code_for(result)
         end
 
+        def run_query(args)
+          meta_mode = args.delete('--meta')
+
+          find_terms = extract_multi_option(args, '--find')
+          type_filter = extract_option(args, '--type')
+          brand_filter = extract_option(args, '--brand')
+          args.delete('--path-only')
+
+          cmd = Commands::Query.new(
+            load_config,
+            find: find_terms,
+            type: type_filter,
+            brand: brand_filter
+          )
+          result = cmd.run
+
+          if result[:success]
+            if meta_mode
+              format_output(result, 'json')
+            else
+              format_output(result, 'paths')
+            end
+          else
+            warn result[:error]
+          end
+
+          exit_code_for(result)
+        end
+
         def run_get(args)
           format = format_option(args)
           key = args.first
@@ -350,6 +381,20 @@ module Appydave
           attrs
         end
 
+        def extract_multi_option(args, flag)
+          values = []
+          loop do
+            index = args.index(flag)
+            break unless index
+
+            value = args[index + 1]
+            args.delete_at(index + 1)
+            args.delete_at(index)
+            values << value if value
+          end
+          values
+        end
+
         def extract_option(args, flag)
           index = args.index(flag)
           return nil unless index
@@ -407,6 +452,7 @@ module Appydave
               search <terms>        Fuzzy search across all location metadata
               get <key>             Get location by exact key
               list                  List all locations
+              query                 Scriptable location lookup (pipeline-friendly)
 
             CRUD Operations:
               add                   Add a new location
@@ -445,6 +491,8 @@ module Appydave
           topic = args.first
 
           case topic
+          when 'query'
+            show_query_help
           when 'search'
             show_search_help
           when 'add'
@@ -464,6 +512,36 @@ module Appydave
           end
         end
 
+        def show_query_help
+          output.puts <<~HELP
+            jump query - Scriptable location lookup (pipeline-friendly)
+
+            Usage: jump query [--find <term>] [--type <type>] [--brand <brand>] [--path-only|--meta]
+
+            Filters (all are AND-combined):
+              --find <term>     Match term against key, name, brand, type, tags, description
+                                Repeat for AND logic: --find appydave --find ruby
+              --type <type>     Filter by location type (e.g. tool, gem, product)
+              --brand <brand>   Filter by brand (e.g. appydave, flivideo)
+
+            Output modes:
+              (default)         One path per line — pipeable (same as --path-only)
+              --path-only       Explicit path-per-line mode
+              --meta            JSON array with key, path, description, type, brand, status
+
+            Exit codes:
+              0                 Matches found
+              1                 No matches (NOT_FOUND)
+
+            Examples:
+              jump query --find flivideo
+              jump query --find flivideo --meta
+              jump query --type tool
+              jump query --find appydave --type tool
+              jump query --find flivideo | xargs llm_context -b
+          HELP
+        end
+
         def show_search_help
           output.puts <<~HELP
             jump search - Fuzzy search locations

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      module Commands
+        # Query command provides scriptable location lookup
+        #
+        # Designed for pipeline use — default output is bare paths, one per line.
+        # Use --meta for structured JSON output.
+        #
+        # @example Find by term
+        #   cmd = Commands::Query.new(config, find: ['flivideo'])
+        #   result = cmd.run
+        #   result[:results]  # => Array of matching location hashes
+        #
+        # @example Filter by type
+        #   cmd = Commands::Query.new(config, type: 'product')
+        #   result = cmd.run
+        class Query < Base
+          attr_reader :find_terms, :type_filter, :brand_filter
+
+          def initialize(config, **options)
+            super
+            @find_terms  = Array(options[:find]).map { |t| t.to_s.downcase.strip }.reject(&:empty?)
+            @type_filter = normalize_option(options[:type])
+            @brand_filter = normalize_option(options[:brand])
+          end
+
+          def run
+            matches = config.locations.select { |loc| matches?(loc) }
+
+            if matches.empty?
+              return error_result(
+                'No locations found matching the given criteria',
+                code: 'NOT_FOUND'
+              )
+            end
+
+            results = matches.map.with_index(1) do |location, index|
+              location_to_result(location, index)
+            end
+
+            success_result(
+              count: results.size,
+              results: results
+            )
+          end
+
+          private
+
+          def matches?(location)
+            return false if type_filter && location.type&.downcase != type_filter
+            return false if brand_filter && location.brand&.downcase != brand_filter
+            return false unless find_terms_match?(location)
+
+            true
+          end
+
+          def find_terms_match?(location)
+            return true if find_terms.empty?
+
+            # All find terms must match (AND logic) — each term matches if it appears
+            # in any of the searchable fields of the location
+            find_terms.all? { |term| term_matches_location?(term, location) }
+          end
+
+          def term_matches_location?(term, location)
+            fields = [
+              location.key,
+              location.type,
+              location.brand,
+              location.client,
+              location.description,
+              location.path
+            ].compact.map(&:downcase)
+
+            tag_fields = location.tags.map(&:downcase)
+
+            fields.any? { |f| f.include?(term) } || tag_fields.any? { |t| t.include?(term) }
+          end
+
+          def normalize_option(value)
+            return nil unless value
+
+            value.to_s.downcase.strip
+          end
+
+          def location_to_result(location, index)
+            {
+              index: index,
+              key: location.key,
+              path: expand_path(location.path),
+              description: location.description,
+              type: location.type,
+              brand: location.brand,
+              client: location.client,
+              tags: location.tags,
+              status: 'active'
+            }.compact
+          end
+
+          def expand_path(path)
+            return path unless path
+
+            File.expand_path(path)
+          end
+        end
+      end
+    end
+  end
+end