i18n-context-generator 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfe865e8057b9ad9e5a239beca369736c430b118ba138ebbb2696be2d1c64af3
-  data.tar.gz: 7669dbee58f5030654eb40115db899d650b3bcfa379738c48242dbac2a59e0dc
+  metadata.gz: 8e8761f1cd9b514b6d8de047f23dd3439770039e5c96d639468a3be93db28730
+  data.tar.gz: 739ded1c82976fcbd7756a8363a6e667a6bce6641c0544b0cee5482c16355b73
 SHA512:
-  metadata.gz: 6c544f04ecabc25b2d6e2e196f1aeb7b0d0dd0bfa17be8ad57bef46e02d4e4741ffd2c6187d7e36acbccdedd9826a963d3ef4fb70825a988b55b11b76c030465
-  data.tar.gz: 8878af77894c57dbdc169bed6ae982889698b3121dca6bbc59c0af9099c520e272145ef9d1324d184dba9af5cf218d7cb7b9965b4369b8ac3a3c55d0a4e461c1
+  metadata.gz: 0bc26c4fe73b9fc8e17d273ce6f471e23f5febde0419ed8eb8c02570a36c945a287e95c85af15ebf02d8a001ee95d46e950a7b4129e4f4f9bf5e483f205b3371
+  data.tar.gz: 934d026c57e651fa81ae2c436c49ea41bfcf8498c1ce888090c022a82837f31a21d6cb669c4d22a39ebc2e9cee4ac5ae5d578bf26b1978703ad1112a7030762e

data/lib/i18n_context_generator/cli.rb

@@ -36,6 +36,8 @@ module I18nContextGenerator
     option :provider, aliases: '-p', enum: %w[anthropic openai], desc: 'LLM provider (default: anthropic)'
     option :model, aliases: '-m', desc: 'LLM model to use'
     option :keys, aliases: '-k', desc: 'Filter keys (comma-separated patterns, supports * wildcard)'
+    option :discovery_mode, type: :string, enum: %w[auto translations source],
+                            desc: 'How to discover entries: auto, translations, or source (default: auto)'
     option :concurrency, type: :numeric, desc: 'Number of concurrent requests (default: 5)'
     option :dry_run, type: :boolean, desc: 'Show what would be processed without calling LLM'
     option :cache, type: :boolean, desc: 'Enable caching of LLM results'
@@ -101,8 +103,9 @@ module I18nContextGenerator
       return if options[:config] && File.exist?(options[:config])
 
       return if options[:translations]
+      return if options[:discovery_mode] == 'source' && options[:source]
 
-      say_error 'Error: --translations (-t) is required unless using a config file'
+      say_error 'Error: --translations (-t) is required unless using a config file or --discovery-mode source with --source'
       exit 1
     end
 
@@ -182,6 +185,8 @@ module I18nContextGenerator
 
         # Processing options
         processing:
+          # Discovery mode: auto, translations, or source
+          discovery_mode: auto
           concurrency: 5
           context_lines: 15
           max_matches_per_key: 3

data/lib/i18n_context_generator/config.rb

@@ -3,42 +3,44 @@
 module I18nContextGenerator
   # Holds all configuration for an extraction run, loaded from YAML config files and/or CLI options.
   class Config
-    attr_reader :translations, :source_paths, :ignore_patterns,
+    attr_reader :translations, :source_paths, :source_line_filter, :ignore_patterns,
                 :provider, :model, :concurrency, :context_lines,
                 :max_matches_per_key, :output_path, :output_format,
                 :no_cache, :dry_run, :key_filter, :write_back,
                 :swift_functions, :write_back_to_code, :diff_base, :context_prefix,
                 :context_mode, :start_key, :end_key, :include_file_paths,
-                :include_translation_comments, :redact_prompts
+                :include_translation_comments, :redact_prompts, :discovery_mode
 
     DEFAULT_CONTEXT_PREFIX = 'Context: '
     DEFAULT_CONTEXT_MODE = 'replace' # "replace" or "append"
 
     def initialize(**attrs)
-      @translations = attrs[:translations] || []
-      @source_paths = attrs[:source_paths] || ['.']
-      @ignore_patterns = attrs[:ignore_patterns] || []
-      @provider = attrs[:provider] || 'anthropic'
-      @model = attrs[:model]
-      @concurrency = attrs[:concurrency] || 5
-      @context_lines = attrs[:context_lines] || 15
-      @max_matches_per_key = attrs[:max_matches_per_key] || 3
-      @output_path = attrs.key?(:output_path) ? attrs[:output_path] : nil
-      @output_format = attrs[:output_format] || 'csv'
-      @no_cache = attrs.key?(:no_cache) ? attrs[:no_cache] : true
-      @dry_run = attrs[:dry_run] || false
-      @key_filter = attrs[:key_filter]
-      @write_back = attrs[:write_back] || false
-      @write_back_to_code = attrs[:write_back_to_code] || false
-      @swift_functions = attrs[:swift_functions] || default_swift_functions
-      @diff_base = attrs[:diff_base]
-      @context_prefix = attrs.key?(:context_prefix) ? attrs[:context_prefix] : DEFAULT_CONTEXT_PREFIX
-      @context_mode = attrs[:context_mode] || DEFAULT_CONTEXT_MODE
-      @start_key = attrs[:start_key]
-      @end_key = attrs[:end_key]
-      @include_file_paths = attrs.key?(:include_file_paths) ? attrs[:include_file_paths] : false
-      @include_translation_comments = attrs.key?(:include_translation_comments) ? attrs[:include_translation_comments] : true
-      @redact_prompts = attrs.key?(:redact_prompts) ? attrs[:redact_prompts] : true
+      @translations = fetch_defaulting_value(attrs, :translations, [])
+      @source_paths = fetch_defaulting_value(attrs, :source_paths, ['.'])
+      @source_line_filter = fetch_config_value(attrs, :source_line_filter, nil)
+      @ignore_patterns = fetch_defaulting_value(attrs, :ignore_patterns, [])
+      @provider = fetch_defaulting_value(attrs, :provider, 'anthropic')
+      @model = fetch_config_value(attrs, :model, nil)
+      @concurrency = fetch_defaulting_value(attrs, :concurrency, 5)
+      @context_lines = fetch_defaulting_value(attrs, :context_lines, 15)
+      @max_matches_per_key = fetch_defaulting_value(attrs, :max_matches_per_key, 3)
+      @output_path = fetch_config_value(attrs, :output_path, nil)
+      @output_format = fetch_defaulting_value(attrs, :output_format, 'csv')
+      @no_cache = fetch_boolean_value(attrs, :no_cache, true)
+      @dry_run = fetch_boolean_value(attrs, :dry_run, false)
+      @key_filter = fetch_config_value(attrs, :key_filter, nil)
+      @write_back = fetch_boolean_value(attrs, :write_back, false)
+      @write_back_to_code = fetch_boolean_value(attrs, :write_back_to_code, false)
+      @swift_functions = fetch_defaulting_value(attrs, :swift_functions, default_swift_functions)
+      @diff_base = fetch_config_value(attrs, :diff_base, nil)
+      @context_prefix = fetch_defaulting_value(attrs, :context_prefix, DEFAULT_CONTEXT_PREFIX)
+      @context_mode = fetch_defaulting_value(attrs, :context_mode, DEFAULT_CONTEXT_MODE)
+      @start_key = fetch_config_value(attrs, :start_key, nil)
+      @end_key = fetch_config_value(attrs, :end_key, nil)
+      @include_file_paths = fetch_boolean_value(attrs, :include_file_paths, false)
+      @include_translation_comments = fetch_boolean_value(attrs, :include_translation_comments, true)
+      @redact_prompts = fetch_boolean_value(attrs, :redact_prompts, true)
+      @discovery_mode = fetch_defaulting_value(attrs, :discovery_mode, 'auto')
     end
 
     def default_swift_functions
@@ -65,6 +67,7 @@ module I18nContextGenerator
         concurrency: yaml.dig('processing', 'concurrency') || 5,
         context_lines: yaml.dig('processing', 'context_lines') || 15,
         max_matches_per_key: yaml.dig('processing', 'max_matches_per_key') || 3,
+        discovery_mode: yaml.dig('processing', 'discovery_mode') || 'auto',
         output_path: yaml.dig('output', 'path'),
         output_format: yaml.dig('output', 'format') || 'csv',
         write_back: yaml.dig('output', 'write_back') || false,
@@ -105,6 +108,7 @@ module I18nContextGenerator
         concurrency: options[:concurrency] || 5,
         context_lines: 15,
         max_matches_per_key: 3,
+        discovery_mode: options[:discovery_mode] || 'auto',
         output_path: options[:output],
         output_format: options[:format] || 'csv',
         no_cache: options[:cache].nil? || !options[:cache],
@@ -170,6 +174,20 @@ module I18nContextGenerator
 
     private
 
+    def fetch_config_value(attrs, key, default)
+      attrs.key?(key) ? attrs[key] : default
+    end
+
+    def fetch_defaulting_value(attrs, key, default)
+      attrs.key?(key) ? (attrs[key] || default) : default
+    end
+
+    def fetch_boolean_value(attrs, key, default)
+      return default unless attrs.key?(key)
+
+      attrs[key].nil? ? default : attrs[key]
+    end
+
     def merge_cli_scalar_options(options)
       scalar_mappings = {
         key_filter: :keys,
@@ -178,6 +196,7 @@ module I18nContextGenerator
         provider: :provider,
         model: :model,
         concurrency: :concurrency,
+        discovery_mode: :discovery_mode,
         diff_base: :diff_base,
         context_prefix: :context_prefix,
         context_mode: :context_mode,

data/lib/i18n_context_generator/context_extractor/run_logging.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  class ContextExtractor
+    # Small logging helpers to keep the main extractor focused on orchestration.
+    module RunLogging
+      private
+
+      def log_empty_entries_message
+        if @config.diff_base && translation_backed_discovery?
+          puts "No changed translation keys found since #{@config.diff_base}."
+        elsif @config.diff_base && source_discovery_filtered_by_diff?
+          puts "No changed source localization entries found since #{@config.diff_base}."
+        else
+          puts "No #{entry_label_for_logging} found."
+        end
+      end
+
+      def log_loaded_entries(count)
+        puts "Loaded #{count} #{entry_label_for_logging}"
+        puts "(filtered to changes since #{@config.diff_base})" if @config.diff_base && translation_backed_discovery?
+        puts "(filtered to source changes since #{@config.diff_base})" if source_discovery_filtered_by_diff?
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/context_extractor/source_filters.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  class ContextExtractor
+    # Helpers for filtering source-discovered entries without narrowing the full
+    # source search scope used later for context lookup.
+    module SourceFilters
+      private
+
+      def source_discovery?
+        !translation_backed_discovery?
+      end
+
+      def source_discovery_filtered_by_diff?
+        source_discovery? && @config.diff_base && @config.source_line_filter.nil?
+      end
+
+      def filter_source_entries(entries)
+        line_filter = source_line_filter
+        return entries if line_filter.nil?
+        return [] if line_filter.empty?
+
+        entries.select do |entry|
+          line_filter.fetch(entry.file.to_s, Set.new).include?(entry.line)
+        end
+      end
+
+      def source_line_filter
+        return @source_line_filter if defined?(@source_line_filter)
+
+        @source_line_filter =
+          if @config.source_line_filter
+            normalize_source_line_filter(@config.source_line_filter)
+          elsif @config.diff_base && source_discovery?
+            GitDiff.new(base_ref: @config.diff_base).changed_lines(@config.source_paths)
+          end
+      end
+
+      def normalize_source_line_filter(filter)
+        filter.each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |(file, lines), normalized_filter|
+          next if file.nil?
+
+          normalized_lines = Array(lines).filter_map { |line| Integer(line, exception: false) }
+          next if normalized_lines.empty?
+
+          normalized_filter[file.to_s].merge(normalized_lines)
+        end
+      end
+
+      def result_locations_for(entry, matches)
+        source_location = entry.metadata&.dig(:source_location)
+        return [source_location] if source_location
+
+        matches.map { |m| "#{m.file}:#{m.line}" }
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/context_extractor.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'context_extractor/source_filters'
+require_relative 'context_extractor/run_logging'
+
 module I18nContextGenerator
   # Main orchestrator that parses translation files, searches source code for usages,
   # sends context to the LLM, and writes results via the configured writer.
   class ContextExtractor
     include Writers::Helpers
+    include SourceFilters
+    include RunLogging
 
     # Result for a single translation key
     ExtractionResult = Data.define(:key, :text, :description, :source_file, :ui_element, :tone,
@@ -45,22 +50,17 @@ module I18nContextGenerator
     def run
       PlatformValidator.new(@config).validate!
 
-      entries = load_translations
+      entries = load_entries
       entries = filter_entries(entries) if @config.key_filter
-      entries = filter_by_diff(entries) if @config.diff_base
+      entries = filter_by_diff(entries) if @config.diff_base && translation_backed_discovery?
       entries = filter_by_range(entries) if @config.start_key || @config.end_key
 
       if entries.empty?
-        if @config.diff_base
-          puts "No changed translation keys found since #{@config.diff_base}."
-        else
-          puts 'No translation entries found.'
-        end
+        log_empty_entries_message
         return
       end
 
-      puts "Loaded #{entries.size} translation keys"
-      puts "(filtered to changes since #{@config.diff_base})" if @config.diff_base
+      log_loaded_entries(entries.size)
 
       if @config.dry_run
         puts "\nDry run - would process these keys:"
@@ -102,7 +102,9 @@ module I18nContextGenerator
     end
 
     def load_translations
-      @config.translations.uniq.flat_map do |path|
+      return @load_translations if defined?(@load_translations)
+
+      @load_translations = @config.translations.uniq.flat_map do |path|
         unless File.exist?(path)
           warn "Translation file not found: #{path}"
           next []
@@ -113,6 +115,67 @@ module I18nContextGenerator
       end
     end
 
+    def load_entries
+      case normalized_discovery_mode
+      when 'source'
+        load_source_entries
+      when 'translations'
+        load_translations
+      else
+        auto_discovery_entries
+      end
+    end
+
+    def auto_discovery_entries
+      return load_source_entries if @config.translations.empty?
+
+      load_translations
+    end
+
+    def load_source_entries
+      translation_lookup = load_translation_lookup
+      discovered_entries = filter_source_entries(searcher.discover_localization_entries)
+
+      discovered_entries.map do |entry|
+        hydrated_entry = translation_lookup[entry.key]
+        translation_comment = hydrated_entry&.metadata&.dig(:comment)
+        source_comment = entry.comment
+        metadata = {}
+        metadata[:comment] = translation_comment || source_comment if translation_comment || source_comment
+        metadata[:source_location] = "#{entry.file}:#{entry.line}"
+
+        Parsers::TranslationEntry.new(
+          key: entry.key,
+          text: hydrated_entry&.text || entry.text || entry.key,
+          source_file: hydrated_entry&.source_file,
+          metadata: metadata
+        )
+      end
+    end
+
+    def load_translation_lookup
+      return @load_translation_lookup if defined?(@load_translation_lookup)
+
+      @load_translation_lookup = load_translations.each_with_object({}) do |entry, lookup|
+        lookup[entry.key] ||= entry
+      end
+    end
+
+    def normalized_discovery_mode
+      @config.discovery_mode.to_s.downcase
+    end
+
+    def translation_backed_discovery?
+      return true if normalized_discovery_mode == 'translations'
+      return false if normalized_discovery_mode == 'source'
+
+      @config.translations.any?
+    end
+
+    def entry_label_for_logging
+      translation_backed_discovery? ? 'translation keys' : 'source localization entries'
+    end
+
     def filter_entries(entries)
       patterns = @config.key_filter.split(',').map do |pattern|
         escaped = Regexp.escape(pattern.strip).gsub('\*', '.*')
@@ -277,7 +340,7 @@ module I18nContextGenerator
         ui_element: llm_result.ui_element,
         tone: llm_result.tone,
         max_length: llm_result.max_length,
-        locations: matches.map { |m| "#{m.file}:#{m.line}" },
+        locations: result_locations_for(entry, matches),
         error: llm_result.error
       )
 

data/lib/i18n_context_generator/git_diff.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'open3'
+require 'pathname'
 
 module I18nContextGenerator
   # Parses git diff to extract changed translation keys
@@ -18,7 +19,7 @@ module I18nContextGenerator
       translation_paths.each do |path|
         next unless File.exist?(path)
 
-        diff_output = git_diff_for_file(path)
+        diff_output = git_diff_for_path(path)
         next if diff_output.empty?
 
         keys.merge(extract_keys_from_diff(diff_output, path))
@@ -27,9 +28,23 @@ module I18nContextGenerator
       keys
     end
 
+    # Get changed line numbers in source files since the base ref.
+    # @param source_paths [Array<String>] paths to source files or directories
+    # @return [Hash{String => Set<Integer>}] changed line numbers keyed by file path
+    def changed_lines(source_paths)
+      source_paths.each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |path, line_map|
+        next unless File.exist?(path)
+
+        diff_output = git_diff_for_path(path)
+        next if diff_output.empty?
+
+        merge_line_maps!(line_map, extract_changed_lines(diff_output, path))
+      end
+    end
+
     # Check if we're in a git repository
     def self.available?
-      system('git rev-parse --git-dir > /dev/null 2>&1')
+      system('git', 'rev-parse', '--git-dir', out: File::NULL, err: File::NULL)
     end
 
     # Check if the base ref exists
@@ -39,7 +54,7 @@ module I18nContextGenerator
 
     private
 
-    def git_diff_for_file(path)
+    def git_diff_for_path(path)
       # Run git from the directory containing the file so the correct repo is used
       dir = File.directory?(path) ? path : File.dirname(path)
       pathspec = File.directory?(path) ? '.' : File.basename(path)
@@ -48,6 +63,54 @@ module I18nContextGenerator
       status.success? ? stdout : ''
     end
 
+    def extract_changed_lines(diff_output, path)
+      changed_lines = Hash.new { |h, k| h[k] = Set.new }
+      current_file = File.file?(path) ? path : nil
+      file_line = nil
+
+      diff_output.each_line do |line|
+        if (match = line.match(%r{^\+\+\+ b/(.+)$}))
+          current_file = resolve_diff_file_path(path, match[1])
+          next
+        end
+
+        if (hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/))
+          file_line = hunk[1].to_i
+          next
+        end
+
+        next if line.start_with?('diff ', 'index ', '--- ', '+++ ', '\\')
+        next if file_line.nil? || current_file.nil?
+
+        if line.start_with?('+')
+          changed_lines[current_file] << file_line
+          file_line += 1
+        elsif line.start_with?('-')
+          next
+        else
+          file_line += 1
+        end
+      end
+
+      changed_lines
+    end
+
+    def resolve_diff_file_path(path, diff_file_path)
+      return Pathname.new(path).cleanpath.to_s if File.file?(path)
+
+      normalized_path = path.to_s.sub(%r{/\z}, '')
+      return Pathname.new(diff_file_path).cleanpath.to_s if normalized_path.empty? || normalized_path == '.'
+      return Pathname.new(diff_file_path).cleanpath.to_s if diff_file_path == normalized_path || diff_file_path.start_with?("#{normalized_path}/")
+
+      Pathname.new(File.join(normalized_path, diff_file_path)).cleanpath.to_s
+    end
+
+    def merge_line_maps!(target, source)
+      source.each do |file, lines|
+        target[file].merge(lines)
+      end
+    end
+
     def extract_keys_from_diff(diff_output, path)
       ext = File.extname(path).downcase
 

data/lib/i18n_context_generator/searcher/source_discovery.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module I18nContextGenerator
+  class Searcher
+    # Source-discovery helpers used for source-first extraction runs.
+    module SourceDiscovery
+      IOS_SINGLE_LINE_DISCOVERY_PATTERNS = [
+        /NSLocalizedString\s*\(\s*@?["'](?<key>[^"']+)["'](?:.*?comment:\s*["'](?<comment>(?:\\.|[^"'\\])*)["'])?/,
+        /String\s*\(\s*localized:\s*["'](?<key>[^"']+)["'](?:.*?comment:\s*["'](?<comment>(?:\\.|[^"'\\])*)["'])?/,
+        /LocalizedStringKey\s*\(\s*["'](?<key>[^"']+)["']\s*\)/,
+        /:\s*LocalizedStringKey\s*=\s*["'](?<key>[^"']+)["']/,
+        /Text\s*\(\s*["'](?<key>[^"']+)["']/,
+        /["'](?<key>[^"']+)["']\.localized\b/
+      ].freeze
+
+      IOS_MULTILINE_DISCOVERY_PATTERNS = [
+        /NSLocalizedString\s*\(\s*@?["'](?<key>[^"']+)["'](?:(?:(?!\)\s*[),]?)[\s\S])*?comment:\s*["'](?<comment>(?:\\.|[^"'\\])*)["'])?/,
+        /String\s*\(\s*localized:\s*["'](?<key>[^"']+)["'](?:(?:(?!\)\s*[),]?)[\s\S])*?comment:\s*["'](?<comment>(?:\\.|[^"'\\])*)["'])?/,
+        /Text\s*\(\s*LocalizedStringKey\s*\(\s*["'](?<key>[^"']+)["']\s*\)\s*\)/
+      ].freeze
+
+      ANDROID_DISCOVERY_PATTERN = %r{
+        R\.string\.(\w+)\b|
+        @string/([\w.]+)\b|
+        [(\s,=]string\.(\w+)\b
+      }x
+
+      def discover_localization_entries
+        entries = discover_files.flat_map do |file|
+          discover_entries_in_file(file)
+        end
+
+        deduplicate_discovered_entries(entries)
+      end
+
+      private
+
+      def discover_entries_in_file(file)
+        case platform_for_file(file)
+        when :ios
+          discover_ios_entries(file)
+        when :android
+          discover_android_entries(file)
+        else
+          []
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR => e
+        warn "Warning: Could not read #{file}: #{e.message}" if $VERBOSE
+        []
+      rescue ArgumentError => e
+        return [] if e.message.include?('invalid byte sequence')
+
+        raise
+      end
+
+      def deduplicate_discovered_entries(entries)
+        entries.each_with_object({}) do |entry, deduplicated_entries|
+          existing_entry = deduplicated_entries[entry.key]
+          if existing_entry.nil?
+            deduplicated_entries[entry.key] = entry
+            next
+          end
+
+          next if !existing_entry.comment.to_s.empty? || entry.comment.to_s.empty?
+
+          deduplicated_entries[entry.key] = entry
+        end.values
+      end
+
+      def platform_for_file(file)
+        case File.extname(file).downcase
+        when '.swift', '.m', '.mm', '.h'
+          :ios
+        when '.kt', '.java'
+          :android
+        when '.xml'
+          file.include?('/res/') ? :android : nil
+        end
+      end
+
+      def discover_ios_entries(file)
+        lines = cached_file_lines(file)
+        entries = []
+        index = 0
+
+        while index < lines.length
+          line = lines[index]
+          next_index, discovered_entry = extract_ios_entry(lines, file, index, line)
+          entries << discovered_entry if discovered_entry
+          index = next_index || (index + 1)
+        end
+
+        entries
+      end
+
+      def extract_ios_entry(lines, file, index, line)
+        if (entry = extract_ios_single_line_entry(file, index, line))
+          return [index + 1, entry]
+        end
+
+        return extract_ios_multiline_entry(lines, file, index) if IOS_FUNCTION_OPENERS.any? { |opener| opener.match?(line) }
+
+        [index + 1, nil]
+      end
+
+      def extract_ios_single_line_entry(file, index, line)
+        pattern = IOS_SINGLE_LINE_DISCOVERY_PATTERNS.find { |candidate| candidate.match?(line) }
+        return unless pattern
+
+        build_ios_discovered_entry(file, index, pattern.match(line))
+      end
+
+      def extract_ios_multiline_entry(lines, file, start_index, lookahead: 8)
+        end_index = [lines.length - 1, start_index + lookahead].min
+        snippet = lines[start_index..end_index].join("\n")
+        pattern = IOS_MULTILINE_DISCOVERY_PATTERNS.find { |candidate| candidate.match?(snippet) }
+        return [start_index + 1, nil] unless pattern
+
+        match = pattern.match(snippet)
+        key_line_index = locate_key_line(lines, start_index, end_index, match[:key])
+
+        [
+          (key_line_index || start_index) + 1,
+          build_ios_discovered_entry(file, key_line_index || start_index, match)
+        ]
+      end
+
+      def build_ios_discovered_entry(file, index, match)
+        key = match[:key]
+        return if key.nil? || key.empty?
+
+        text = match.names.include?('text') ? match[:text] : nil
+        comment = match.names.include?('comment') ? unescape_source_string(match[:comment]) : nil
+        text = unescape_source_string(text) if text
+
+        DiscoveredLocalization.new(
+          key: key,
+          file: file,
+          line: index + 1,
+          text: text,
+          comment: comment
+        )
+      end
+
+      def locate_key_line(lines, start_index, end_index, key)
+        (start_index..end_index).find do |index|
+          lines[index].include?("\"#{key}\"") || lines[index].include?("@\"#{key}\"")
+        end
+      end
+
+      def discover_android_entries(file)
+        lines = cached_file_lines(file)
+        entries = []
+
+        lines.each_with_index do |line, index|
+          entries.concat(extract_android_entries_from_line(file, index, line))
+        end
+
+        entries
+      end
+
+      def extract_android_entries_from_line(file, index, line)
+        line.scan(ANDROID_DISCOVERY_PATTERN).filter_map do |captures|
+          key = captures.compact.first
+          next if key.nil? || key.empty?
+
+          DiscoveredLocalization.new(
+            key: key,
+            file: file,
+            line: index + 1
+          )
+        end
+      end
+
+      def unescape_source_string(text)
+        return if text.nil?
+
+        text
+          .gsub('\\"', '"')
+          .gsub("\\'", "'")
+          .gsub('\\\\', '\\')
+          .gsub('\\n', "\n")
+          .gsub('\\t', "\t")
+      end
+    end
+  end
+end

data/lib/i18n_context_generator/searcher.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 require 'find'
+require_relative 'searcher/source_discovery'
 
 module I18nContextGenerator
   # Finds where translation keys are used in iOS and Android source code.
   class Searcher
+    include SourceDiscovery
+
     # Represents a code match with surrounding context
     Match = Data.define(:file, :line, :match_line, :context, :enclosing_scope) do
       def initialize(file:, line:, match_line: '', context: '', enclosing_scope: nil)
@@ -12,6 +15,13 @@ module I18nContextGenerator
       end
     end
 
+    # Represents a localization entry discovered directly from source code.
+    DiscoveredLocalization = Data.define(:key, :file, :line, :text, :comment) do
+      def initialize(key:, file:, line:, text: nil, comment: nil)
+        super
+      end
+    end
+
     # Patterns that indicate false positive matches (not actual localization usage)
     FALSE_POSITIVE_PATTERNS = [
       /==\s*["']/,             # String comparisons like == "yes"
@@ -367,6 +377,8 @@ module I18nContextGenerator
         "String\\s*\\(\\s*localized:\\s*[\"']#{escaped}[\"']",
         # LocalizedStringKey("key") - SwiftUI
         "LocalizedStringKey\\s*\\(\\s*[\"']#{escaped}[\"']",
+        # Direct assignment to a LocalizedStringKey-typed value
+        "LocalizedStringKey\\s*=\\s*[\"']#{escaped}[\"']",
         # Text("key") - SwiftUI (when using localized strings)
         "Text\\s*\\(\\s*[\"']#{escaped}[\"']",
         # .localized extension pattern

data/lib/i18n_context_generator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module I18nContextGenerator
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: i18n-context-generator
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Automattic
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -152,6 +152,8 @@ files:
 - lib/i18n_context_generator/cli.rb
 - lib/i18n_context_generator/config.rb
 - lib/i18n_context_generator/context_extractor.rb
+- lib/i18n_context_generator/context_extractor/run_logging.rb
+- lib/i18n_context_generator/context_extractor/source_filters.rb
 - lib/i18n_context_generator/git_diff.rb
 - lib/i18n_context_generator/llm/anthropic.rb
 - lib/i18n_context_generator/llm/client.rb
@@ -163,6 +165,7 @@ files:
 - lib/i18n_context_generator/parsers/yaml_parser.rb
 - lib/i18n_context_generator/platform_validator.rb
 - lib/i18n_context_generator/searcher.rb
+- lib/i18n_context_generator/searcher/source_discovery.rb
 - lib/i18n_context_generator/version.rb
 - lib/i18n_context_generator/writers/android_xml_writer.rb
 - lib/i18n_context_generator/writers/csv_writer.rb