appydave-tools 0.70.0 → 0.71.0

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

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module Jump
+      # Search provides fuzzy search across location metadata
+      #
+      # Scoring algorithm based on match type:
+      # - Exact key match: 100 points
+      # - Key contains term: 50 points
+      # - Brand/client alias match: 40 points
+      # - Tag match: 30 points
+      # - Type match: 20 points
+      # - Description contains: 10 points
+      # - Path contains: 5 points
+      #
+      # @example Basic search
+      #   search = Search.new(config)
+      #   results = search.search('appydave ruby')
+      #   results[:success]  # => true
+      #   results[:results]  # => Array of scored location hashes
+      class Search
+        SCORE_EXACT_KEY = 100
+        SCORE_KEY_CONTAINS = 50
+        SCORE_BRAND_CLIENT_ALIAS = 40
+        SCORE_TAG_MATCH = 30
+        SCORE_TYPE_MATCH = 20
+        SCORE_DESCRIPTION_CONTAINS = 10
+        SCORE_PATH_CONTAINS = 5
+
+        attr_reader :config
+
+        def initialize(config)
+          @config = config
+        end
+
+        # Search for locations matching query terms
+        #
+        # @param query [String] Space-separated search terms
+        # @return [Hash] Search results with success, count, and results
+        def search(query)
+          terms = parse_query(query)
+
+          return empty_result if terms.empty?
+
+          scored_locations = config.locations.map do |location|
+            score = calculate_score(location, terms)
+            next if score.zero?
+
+            location_to_result(location, score)
+          end.compact
+
+          # Sort by score descending, then by key alphabetically
+          sorted = scored_locations.sort_by { |r| [-r[:score], r[:key]] }
+
+          # Add index numbers
+          sorted.each_with_index { |result, i| result[:index] = i + 1 }
+
+          {
+            success: true,
+            count: sorted.size,
+            results: sorted
+          }
+        end
+
+        # Get a location by exact key
+        #
+        # @param key [String] Exact key to find
+        # @return [Hash] Result with success and result/error
+        def get(key)
+          location = config.find(key)
+
+          if location
+            {
+              success: true,
+              result: location_to_result(location, SCORE_EXACT_KEY)
+            }
+          else
+            suggestions = find_suggestions(key)
+            {
+              success: false,
+              error: 'Location not found',
+              code: 'NOT_FOUND',
+              suggestion: suggestions.empty? ? nil : "Did you mean: #{suggestions.join(', ')}?"
+            }
+          end
+        end
+
+        # List all locations
+        #
+        # @return [Hash] All locations with success and count
+        def list
+          results = config.locations.map.with_index(1) do |location, index|
+            result = location_to_result(location, 0)
+            result[:index] = index
+            result
+          end
+
+          {
+            success: true,
+            count: results.size,
+            results: results
+          }
+        end
+
+        private
+
+        def parse_query(query)
+          return [] if query.nil? || query.strip.empty?
+
+          query.downcase.split(/\s+/).reject(&:empty?)
+        end
+
+        def empty_result
+          {
+            success: true,
+            count: 0,
+            results: []
+          }
+        end
+
+        def calculate_score(location, terms)
+          total_score = 0
+
+          terms.each do |term|
+            total_score += score_for_term(location, term)
+          end
+
+          total_score
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def score_for_term(location, term)
+          score = 0
+
+          # Exact key match
+          if location.key == term
+            score += SCORE_EXACT_KEY
+          elsif location.key&.include?(term)
+            score += SCORE_KEY_CONTAINS
+          end
+
+          # Brand/client alias match
+          score += SCORE_BRAND_CLIENT_ALIAS if brand_alias_match?(location.brand, term)
+          score += SCORE_BRAND_CLIENT_ALIAS if client_alias_match?(location.client, term)
+
+          # Tag match
+          score += SCORE_TAG_MATCH if location.tags.any? { |tag| tag.downcase == term }
+
+          # Type match
+          score += SCORE_TYPE_MATCH if location.type&.downcase == term
+
+          # Description contains
+          score += SCORE_DESCRIPTION_CONTAINS if location.description&.downcase&.include?(term)
+
+          # Path contains
+          score += SCORE_PATH_CONTAINS if location.path&.downcase&.include?(term)
+
+          score
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def brand_alias_match?(brand_key, term)
+          return false unless brand_key
+
+          return true if brand_key.downcase == term
+
+          brand_info = config.brands[brand_key]
+          return false unless brand_info
+
+          aliases = brand_info['aliases'] || brand_info[:aliases] || []
+          aliases.any? { |a| a.downcase == term }
+        end
+
+        def client_alias_match?(client_key, term)
+          return false unless client_key
+
+          return true if client_key.downcase == term
+
+          client_info = config.clients[client_key]
+          return false unless client_info
+
+          aliases = client_info['aliases'] || client_info[:aliases] || []
+          aliases.any? { |a| a.downcase == term }
+        end
+
+        def location_to_result(location, score)
+          {
+            key: location.key,
+            path: expand_path(location.path),
+            jump: location.jump,
+            brand: location.brand,
+            client: location.client,
+            type: location.type,
+            tags: location.tags,
+            description: location.description,
+            score: score
+          }.compact
+        end
+
+        def expand_path(path)
+          return path unless path
+
+          File.expand_path(path)
+        end
+
+        def find_suggestions(key)
+          return [] unless key
+
+          # Find keys that are similar (contain or start with same letters)
+          config.locations
+                .map(&:key)
+                .select { |k| similar?(k, key) }
+                .first(3)
+        end
+
+        def similar?(candidate, query)
+          # Simple similarity: shares first 2 chars or contains query
+          return true if candidate.start_with?(query[0..1])
+          return true if candidate.include?(query)
+          return true if query.include?(candidate)
+
+          # Levenshtein-like: at least 50% chars in common
+          common = (candidate.chars & query.chars).size
+          common >= [candidate.length, query.length].min * 0.5
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/subtitle_processor/transcript.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module SubtitleProcessor
+      # Convert SRT to plain text transcript
+      # Strips timestamps and indices, keeping only the spoken text
+      class Transcript
+        attr_reader :content
+
+        def initialize(file_path: nil, srt_content: nil)
+          if file_path && srt_content
+            raise ArgumentError, 'You cannot provide both a file path and an SRT content stream.'
+          elsif file_path.nil? && srt_content.nil?
+            raise ArgumentError, 'You must provide either a file path or an SRT content stream.'
+          end
+
+          @content = if file_path
+                       File.read(file_path, encoding: 'UTF-8')
+                     else
+                       srt_content
+                     end
+        end
+
+        # Convert SRT to plain text transcript
+        # @param paragraph_gap [Integer] Number of newlines between subtitle blocks (default: 1 = single newline)
+        # @return [String] Plain text transcript
+        def extract(paragraph_gap: 1)
+          parser = Join::SRTParser.new
+          subtitles = parser.parse(@content)
+
+          separator = "\n" * paragraph_gap
+          subtitles.map(&:text).join(separator)
+        end
+
+        # Write transcript to file
+        # @param output_file [String] Path to output file
+        # @param paragraph_gap [Integer] Number of newlines between subtitle blocks
+        def write(output_file, paragraph_gap: 1)
+          transcript = extract(paragraph_gap: paragraph_gap)
+          File.write(output_file, transcript, encoding: 'UTF-8')
+          puts "Transcript written to #{output_file}"
+        rescue Errno::EACCES
+          puts "Permission denied: Unable to write to #{output_file}"
+        rescue StandardError => e
+          puts "An error occurred while writing to the file: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Appydave
   module Tools
-    VERSION = '0.70.0'
+    VERSION = '0.71.0'
   end
 end

data/lib/appydave/tools/zsh_history/command.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module ZshHistory
+      # Represents a single command from ZSH history
+      Command = Struct.new(
+        :timestamp,      # Integer - Unix timestamp from history
+        :datetime,       # Time - Parsed datetime
+        :text,           # String - Full command text (multi-line joined)
+        :is_multiline,   # Boolean - Was this a continuation command?
+        :category,       # Symbol - :wanted, :unwanted, :unsure
+        :raw_lines,      # Array<String> - Original lines from file
+        :matched_pattern, # String - Pattern that matched (for verbose output)
+        keyword_init: true
+      ) do
+        def formatted_datetime(format = '%Y-%m-%d %H:%M:%S')
+          datetime&.strftime(format) || 'unknown'
+        end
+
+        def to_history_format
+          # Reconstruct in ZSH history format for writing back
+          raw_lines.join("\n")
+        end
+      end
+
+      # Result of filtering operations
+      FilterResult = Struct.new(
+        :wanted,    # Array<Command>
+        :unwanted,  # Array<Command>
+        :unsure,    # Array<Command>
+        :stats,     # Hash - { total:, wanted:, unwanted:, unsure: }
+        keyword_init: true
+      )
+    end
+  end
+end

data/lib/appydave/tools/zsh_history/config.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module ZshHistory
+      # Loads zsh_history configuration from ~/.config/appydave/zsh_history/
+      #
+      # Directory structure:
+      #   ~/.config/appydave/zsh_history/
+      #     config.txt                    # default_profile=crash-recovery
+      #     base_exclude.txt              # Always excluded (typos, output lines)
+      #     profiles/
+      #       crash-recovery/
+      #         exclude.txt               # Profile-specific excludes
+      #         include.txt               # Profile-specific includes
+      #
+      # Pattern files: One regex pattern per line, # for comments, blank lines ignored
+      #
+      class Config
+        DEFAULT_CONFIG_PATH = File.expand_path('~/.config/appydave/zsh_history')
+
+        attr_reader :config_path, :profile_name
+
+        def initialize(config_path: nil, profile: nil)
+          @config_path = config_path || DEFAULT_CONFIG_PATH
+          @profile_name = profile || default_profile
+        end
+
+        # Returns merged exclude patterns (base + profile)
+        def exclude_patterns
+          patterns = load_base_exclude
+          patterns += load_profile_patterns('exclude') if profile_name
+          patterns.empty? ? nil : patterns
+        end
+
+        # Returns profile include patterns
+        def include_patterns
+          patterns = load_profile_patterns('include')
+          patterns.empty? ? nil : patterns
+        end
+
+        # Check if config directory exists
+        def configured?
+          Dir.exist?(config_path)
+        end
+
+        # Check if specific profile exists
+        def profile_exists?(name = profile_name)
+          return false unless name
+
+          profile_path = File.join(config_path, 'profiles', name)
+          Dir.exist?(profile_path)
+        end
+
+        # List available profiles
+        def available_profiles
+          profiles_dir = File.join(config_path, 'profiles')
+          return [] unless Dir.exist?(profiles_dir)
+
+          Dir.children(profiles_dir)
+             .select { |f| File.directory?(File.join(profiles_dir, f)) }
+             .sort
+        end
+
+        # Get default profile from config.txt
+        def default_profile
+          config_file = File.join(config_path, 'config.txt')
+          return nil unless File.exist?(config_file)
+
+          File.readlines(config_file).each do |line|
+            line = line.strip
+            next if line.empty? || line.start_with?('#')
+
+            key, value = line.split('=', 2)
+            return value.strip if key.strip == 'default_profile'
+          end
+
+          nil
+        end
+
+        # Create default config structure with example files
+        def self.create_default_config(config_path = DEFAULT_CONFIG_PATH)
+          FileUtils.mkdir_p(config_path)
+          FileUtils.mkdir_p(File.join(config_path, 'profiles', 'crash-recovery'))
+
+          # Create config.txt
+          write_if_missing(File.join(config_path, 'config.txt'), <<~CONFIG)
+            # ZSH History Configuration
+            # Set default profile (used when --profile not specified)
+            default_profile=crash-recovery
+          CONFIG
+
+          # Create base_exclude.txt
+          write_if_missing(File.join(config_path, 'base_exclude.txt'), <<~PATTERNS)
+            # Base exclude patterns - always applied
+            # These are noise in ANY scenario
+
+            # Typos and single-letter commands
+            ^[a-z]$
+            ^[a-z]{2}$
+
+            # Output lines accidentally captured
+            ^\\[\\d+\\]
+            ^zsh: command not found
+            ^X Process completed
+            ^Coverage report
+            ^Line Coverage:
+            ^Finished in \\d
+            ^\\d+ examples, \\d+ failures
+
+            # Process listing output
+            ^davidcruwys\\s+\\d+
+          PATTERNS
+
+          # Create crash-recovery profile
+          profile_path = File.join(config_path, 'profiles', 'crash-recovery')
+
+          write_if_missing(File.join(profile_path, 'exclude.txt'), <<~PATTERNS)
+            # Crash Recovery - Exclude patterns
+            # Navigation and quick-check commands (noise when finding what you were working on)
+
+            # Basic navigation
+            ^ls$
+            ^ls -
+            ^pwd$
+            ^clear$
+            ^exit$
+            ^x$
+            ^cd$
+            ^cd -$
+            ^cd \\.\\.
+            ^\\.\\.
+
+            # Git quick checks (not actual work)
+            ^git status$
+            ^git diff$
+            ^git log$
+            ^git pull$
+            ^gs$
+            ^gd$
+            ^gl$
+
+            # History and lookups
+            ^h$
+            ^history
+            ^which
+            ^type
+
+            # File viewing
+            ^cat
+            ^head
+            ^tail
+            ^echo \\$
+          PATTERNS
+
+          write_if_missing(File.join(profile_path, 'include.txt'), <<~PATTERNS)
+            # Crash Recovery - Include patterns
+            # Commands that represent actual work
+
+            # Jump aliases (navigation to projects)
+            ^j[a-z]
+
+            # Tools
+            ^dam
+            ^vat
+            ^claude
+            ^c-sonnet
+
+            # JavaScript/Node
+            ^bun run
+            ^bun dev$
+            ^bun web:
+            ^bun worker:
+            ^bun convex:
+            ^npm run
+
+            # Ruby
+            ^rake
+            ^bundle
+
+            # Git commits (actual work, not checks)
+            ^git commit
+            ^git push
+            ^git add
+            ^gac
+            ^kfeat
+            ^kfix
+
+            # Docker
+            ^docker
+            ^docker-compose
+
+            # Package installation
+            ^brew install
+            ^gem install
+            ^npm install
+          PATTERNS
+
+          config_path
+        end
+
+        class << self
+          private
+
+          def write_if_missing(path, content)
+            return if File.exist?(path)
+
+            File.write(path, content)
+          end
+        end
+
+        private
+
+        def load_base_exclude
+          load_patterns_file(File.join(config_path, 'base_exclude.txt'))
+        end
+
+        def load_profile_patterns(type)
+          return [] unless profile_name
+
+          file_path = File.join(config_path, 'profiles', profile_name, "#{type}.txt")
+          load_patterns_file(file_path)
+        end
+
+        def load_patterns_file(file_path)
+          return [] unless File.exist?(file_path)
+
+          File.readlines(file_path)
+              .map(&:strip)
+              .reject { |line| line.empty? || line.start_with?('#') }
+        end
+      end
+    end
+  end
+end