contextizer 0.1.1

data/contextizer_2025-09-01_2223.md

@@ -0,0 +1,2538 @@
+# Contextizer Report
+
+## Meta Context
+- **Project:** contextizer
+- **Type:** Gem
+- **Version:** 0.1.0
+- **Extracted At:** 2025-09-01T19:23:39Z
+
+### Command
+```bash
+contextizer extract --git-url https://github.com/alexander-s-f/contextizer
+```
+
+### Git Info
+- **Branch:** `master`
+- **Commit:** `a8b51c67`
+
+### Key Ruby Dependencies
+Not found.
+
+### Key JS Dependencies
+Not found.
+
+---
+### File Structure
+<details>
+<summary>Click to view file tree</summary>
+
+```text
+contextizer/
+├── CHANGELOG.md
+├── CODE_OF_CONDUCT.md
+├── README.md
+├── config
+│   └── default.yml
+├── contextizer.gemspec
+└── lib
+    ├── contextizer
+    │   ├── analyzer.rb
+    │   ├── analyzers
+    │   │   ├── base.rb
+    │   │   ├── java_script_analyzer.rb
+    │   │   ├── python_analyzer.rb
+    │   │   └── ruby_analyzer.rb
+    │   ├── cli.rb
+    │   ├── collector.rb
+    │   ├── configuration.rb
+    │   ├── context.rb
+    │   ├── providers
+    │   │   ├── base
+    │   │   │   ├── file_system.rb
+    │   │   │   ├── git.rb
+    │   │   │   └── project_name.rb
+    │   │   ├── base_provider.rb
+    │   │   ├── javascript
+    │   │   │   └── packages.rb
+    │   │   └── ruby
+    │   │       ├── gems.rb
+    │   │       └── project_info.rb
+    │   ├── remote_repo_handler.rb
+    │   ├── renderers
+    │   │   ├── base.rb
+    │   │   └── markdown.rb
+    │   ├── version.rb
+    │   └── writer.rb
+    └── contextizer.rb
+```
+
+</details>
+
+---
+#### File: `lib/contextizer/analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  class Analyzer
+    SPECIALISTS = Analyzers.constants.map do |const|
+      Analyzers.const_get(const)
+    end.select { |const| const.is_a?(Class) && const < Analyzers::Base }
+
+    def self.call(target_path:)
+      new(target_path: target_path).analyze
+    end
+
+    def initialize(target_path:)
+      @target_path = target_path
+    end
+
+    def analyze
+      results = SPECIALISTS.map do |specialist_class|
+        specialist_class.call(target_path: @target_path)
+      end.compact
+
+      return { language: :unknown, framework: nil, scores: {} } if results.empty?
+
+      best_result = results.max_by { |result| result[:score] }
+
+      {
+        language: best_result[:language],
+        framework: best_result[:framework],
+        scores: results.map { |r| [r[:language], r[:score]] }.to_h
+      }
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/base.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class Base
+      def self.call(target_path:)
+        new(target_path: target_path).analyze
+      end
+
+      def initialize(target_path:)
+        @target_path = Pathname.new(target_path)
+        @score = 0
+      end
+
+      def analyze
+        raise NotImplementedError, "#{self.class.name} must implement #analyze"
+      end
+
+      protected
+
+      def check_signal(signal)
+        path = @target_path.join(signal[:path])
+        case signal[:type]
+        when :file
+          @target_path.glob(signal[:path]).any?
+        when :dir
+          path.directory?
+        else
+          false
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/java_script_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class JavaScriptAnalyzer < Base
+      LANGUAGE = :javascript
+
+      SIGNALS = [
+        { type: :file, path: "package.json", weight: 5 },
+        { type: :dir,  path: "node_modules", weight: 10 },
+        { type: :file, path: "webpack.config.js", weight: 5 },
+        { type: :file, path: "vite.config.js", weight: 5 }
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {}.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: nil,
+          score: @score
+        }
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/python_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class PythonAnalyzer < Base
+      LANGUAGE = :python
+
+      SIGNALS = [
+        { type: :file, path: "requirements.txt", weight: 10 },
+        { type: :file, path: "pyproject.toml", weight: 10 },
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {
+        # rails: [{ type: :file, path: "bin/rails", weight: 15 }]
+      }.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: detect_framework,
+          score: @score
+        }
+      end
+
+      private
+
+      def detect_framework
+        (FRAMEWORK_SIGNALS || {}).each do |fw, signals|
+          return fw if signals.any? { |signal| check_signal(signal) }
+        end
+        nil
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/ruby_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class RubyAnalyzer < Base
+      LANGUAGE = :ruby
+
+      SIGNALS = [
+        { type: :file, path: "Gemfile", weight: 10 },
+        { type: :file, path: "*.gemspec", weight: 20 },
+        { type: :dir,  path: "app/controllers", weight: 5 }
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {
+        rails: [{ type: :file, path: "bin/rails", weight: 15 }]
+      }.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: detect_framework,
+          score: @score
+        }
+      end
+
+      private
+
+      def detect_framework
+        (FRAMEWORK_SIGNALS || {}).each do |fw, signals|
+          return fw if signals.any? { |signal| check_signal(signal) }
+        end
+        nil
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/cli.rb`
+```ruby
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+
+module Contextizer
+  class CLI < Thor
+    desc "extract [TARGET_PATH]", "Extracts project context into a single file."
+    option :git_url,
+           type: :string,
+           desc: "URL of a remote git repository to analyze instead of a local path."
+    option :output,
+           aliases: "-o",
+           type: :string,
+           desc: "Output file path (overrides config)."
+    option :format,
+           aliases: "-f",
+           type: :string,
+           desc: "Output format (e.g., markdown, json)."
+
+    RENDERER_MAPPING = {
+      "markdown" => Renderers::Markdown
+    }.freeze
+
+    def extract(target_path = ".")
+      if options[:git_url]
+        RemoteRepoHandler.handle(options[:git_url]) do |remote_path|
+          run_extraction(remote_path)
+        end
+      else
+        run_extraction(target_path)
+      end
+    end
+
+    private
+
+    def run_extraction(path)
+      cli_options = options.transform_keys(&:to_s).compact
+      config = Configuration.load(cli_options)
+
+      context = Collector.call(config: config, target_path: path)
+
+      renderer = RENDERER_MAPPING[config.format]
+      raise Error, "Unsupported format: '#{config.format}'" unless renderer
+
+      rendered_output = renderer.call(context: context)
+
+      destination_path = resolve_output_path(config.output, context)
+      Writer.call(content: rendered_output, destination: destination_path)
+
+      puts "\nContextizer: Extraction complete! ✨"
+    end
+
+    def resolve_output_path(path_template, context)
+      timestamp = Time.now.strftime("%Y-%m-%d_%H%M")
+      project_name = context.metadata.dig(:project, :type) == "Gem" ? context.project_name : "project"
+
+
+      path_template
+        .gsub("{profile}", "default")
+        .gsub("{timestamp}", timestamp)
+        .gsub("{project_name}", project_name)
+    end
+  end
+end
+```
+
+---
+#### File: `lib/contextizer/collector.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  class Collector
+    BASE_PROVIDERS = [
+      Providers::Base::ProjectName,
+      Providers::Base::Git,
+      Providers::Base::FileSystem
+    ].freeze
+
+    LANGUAGE_MODULES = {
+      ruby: Providers::Ruby,
+      javascript: Providers::JavaScript
+    }.freeze
+
+    def self.call(config:, target_path:)
+      new(config: config, target_path: target_path).call
+    end
+
+    def initialize(config:, target_path:)
+      @config = config
+      @target_path = target_path
+      @context = Context.new(target_path: target_path)
+    end
+
+    def call
+      stack = Analyzer.call(target_path: @target_path)
+      @context.metadata[:stack] = stack
+
+      BASE_PROVIDERS.each do |provider_class|
+        provider_class.call(context: @context, config: @config)
+      end
+
+      language_module = LANGUAGE_MODULES[stack[:language]]
+      run_language_providers(language_module) if language_module
+
+      puts "Collector: Collection complete. Found #{@context.files.count} files."
+      @context
+    end
+
+    private
+
+    def run_language_providers(language_module)
+      puts "Collector: Running '#{language_module.name.split('::').last}' providers..."
+      language_module.constants.each do |const_name|
+        provider_class = language_module.const_get(const_name)
+        if provider_class.is_a?(Class) && provider_class < Providers::BaseProvider
+          provider_class.call(context: @context, config: @config)
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/configuration.rb`
+```ruby
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Contextizer
+  class Configuration
+    # CLI options > Project Config > Default Config
+    def self.load(cli_options = {})
+      default_config_path = Pathname.new(__dir__).join("../../config/default.yml")
+      default_config = YAML.load_file(default_config_path)
+
+      project_config_path = find_project_config
+      project_config = project_config_path ? YAML.load_file(project_config_path) : {}
+
+      merged_config = deep_merge(default_config, project_config)
+      merged_config = deep_merge(merged_config, cli_options)
+
+      new(merged_config)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def method_missing(name, *args, &block)
+      key = name.to_s
+      if @options.key?(key)
+        @options[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @options.key?(name.to_s) || super
+    end
+
+    def self.find_project_config(path = Dir.pwd)
+      path = Pathname.new(path)
+      loop do
+        config_file = path.join(".contextizer.yml")
+        return config_file if config_file.exist?
+        break if path.root?
+
+        path = path.parent
+      end
+      nil
+    end
+
+    def self.deep_merge(hash1, hash2)
+      hash1.merge(hash2) do |key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/context.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  # A value object that holds all the collected information about a project.
+  # This object is the result of the Collector phase and the input for the Renderer phase.
+  Context = Struct.new(
+    :project_name,
+    :target_path,
+    :timestamp,
+    :metadata,     # Hash for data from providers like Git, Gems, etc.
+    :files,        # Array of file objects { path:, content: }
+    keyword_init: true
+  ) do
+    def initialize(*)
+      super
+      self.metadata ||= {}
+      self.files ||= []
+      self.timestamp ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/file_system.rb`
+```ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+module Contextizer
+  module Providers
+    module Base
+      class FileSystem < BaseProvider
+        def self.call(context:, config:)
+          new(context: context, config: config).collect_files
+        end
+
+        def initialize(context:, config:)
+          @context = context
+          @config = config.settings["filesystem"]
+          @target_path = Pathname.new(context.target_path)
+        end
+
+        def collect_files
+          file_paths = find_matching_files
+
+          file_paths.each do |path|
+            content = read_file_content(path)
+            next unless content
+
+            @context.files << {
+              path: path.relative_path_from(@target_path).to_s,
+              content: content
+            }
+          end
+        end
+
+        private
+
+        def find_matching_files
+          patterns = @config["components"].values.flatten.map do |pattern|
+            (@target_path / pattern).to_s
+          end
+
+          all_files = Dir.glob(patterns)
+
+          exclude_patterns = @config["exclude"].map do |pattern|
+            (@target_path / pattern).to_s
+          end
+
+          all_files.reject do |file|
+            exclude_patterns.any? { |pattern| File.fnmatch?(pattern, file) }
+          end.map { |file| Pathname.new(file) }
+        end
+
+        def read_file_content(path)
+          path.read
+        rescue Errno::ENOENT, IOError => e
+          warn "Warning: Could not read file #{path}: #{e.message}"
+          nil
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/git.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Base
+      class Git < BaseProvider
+        def self.call(context:, config:)
+          context.metadata[:git] = fetch_git_info(context.target_path)
+          @config = config
+        end
+
+        def self.fetch_git_info(path)
+          Dir.chdir(path) do
+            {
+              branch: `git rev-parse --abbrev-ref HEAD`.strip,
+              commit: `git rev-parse HEAD`.strip[0, 8]
+            }
+          end
+        rescue StandardError
+          { branch: "N/A", commit: "N/A" }
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/project_name.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Base
+      class ProjectName < BaseProvider
+        def self.call(context:, config:)
+          context.project_name = detect_project_name(context.target_path)
+        end
+
+        private
+
+        def self.detect_project_name(path)
+          git_name = name_from_git_remote(path)
+          return git_name if git_name
+
+          File.basename(path)
+        end
+
+        def self.name_from_git_remote(path)
+          return nil unless Dir.exist?(File.join(path, ".git"))
+
+          Dir.chdir(path) do
+            remote_url = `git remote get-url origin`.strip
+            remote_url.split("/").last.sub(/\.git$/, "")
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base_provider.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    class BaseProvider
+      # @param context [Contextizer::Context] The context object to be populated.
+      # @param config [Contextizer::Configuration] The overall configuration.
+      def self.call(context:, config:)
+        raise NotImplementedError, "#{self.name} must implement the .call method"
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/javascript/packages.rb`
+```ruby
+# frozen_string_literal: true
+require "json"
+
+module Contextizer
+  module Providers
+    module JavaScript
+      class Packages < BaseProvider
+        def self.call(context:, config:)
+          package_json_path = File.join(context.target_path, "package.json")
+          return unless File.exist?(package_json_path)
+
+          context.metadata[:packages] = parse_packages(package_json_path)
+        end
+
+        private
+
+        def self.parse_packages(path)
+          begin
+            file = File.read(path)
+            data = JSON.parse(file)
+            {
+              dependencies: data["dependencies"] || {},
+              dev_dependencies: data["devDependencies"] || {}
+            }
+          rescue JSON::ParserError => e
+            puts "Warning: Could not parse package.json: #{e.message}"
+            {}
+          end
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/ruby/gems.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Ruby
+      class Gems < BaseProvider
+        def self.call(context:, config:)
+          key_gems = config.settings.dig("gems", "key_gems")
+          return if key_gems.nil? || key_gems.empty?
+
+          gemfile_lock = File.join(context.target_path, "Gemfile.lock")
+          return unless File.exist?(gemfile_lock)
+
+          context.metadata[:gems] = parse_gemfile_lock(gemfile_lock, key_gems)
+        end
+
+        def self.parse_gemfile_lock(path, key_gems)
+          found_gems = {}
+          content = File.read(path)
+          key_gems.each do |gem_name|
+            match = content.match(/^\s{4}#{gem_name}\s\((.+?)\)/)
+            found_gems[gem_name] = match[1] if match
+          end
+          found_gems
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/ruby/project_info.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Ruby
+      class ProjectInfo < BaseProvider
+        def self.call(context:, config:)
+          project_info = detect_project_info(context.target_path)
+          context.metadata[:project] = project_info
+        end
+
+
+        def self.detect_project_info(path)
+          if Dir.glob(File.join(path, "*.gemspec")).any?
+            return { type: "Gem", version: detect_gem_version(path) }
+          end
+
+          if File.exist?(File.join(path, "bin", "rails"))
+            return { type: "Rails", version: detect_rails_version(path) }
+          end
+
+          { type: "Directory", version: "N/A" }
+        end
+
+        def self.detect_gem_version(path)
+          version_file = Dir.glob(File.join(path, "lib", "**", "version.rb")).first
+          return "N/A" unless version_file
+
+          content = File.read(version_file)
+          match = content.match(/VERSION\s*=\s*["'](.+?)["']/)
+          match ? match[1] : "N/A"
+        end
+
+        def self.detect_rails_version(path)
+          gemfile_lock = File.join(path, "Gemfile.lock")
+          return "N/A" unless File.exist?(gemfile_lock)
+
+          content = File.read(gemfile_lock)
+          match = content.match(/^\s{4}rails\s\((.+?)\)/)
+          match ? match[1] : "N/A"
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/remote_repo_handler.rb`
+```ruby
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+
+module Contextizer
+  class RemoteRepoHandler
+    def self.handle(url)
+      Dir.mktmpdir("contextizer-clone-") do |temp_path|
+        puts "Cloning #{url} into temporary directory..."
+
+        success = system("git clone --depth 1 #{url} #{temp_path}")
+
+        if success
+          puts "Cloning successful."
+          yield(temp_path)
+        else
+          puts "Error: Failed to clone repository."
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/renderers/base.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Renderers
+    class Base
+      # @param context [Contextizer::Context] The context object to be rendered.
+      def self.call(context:)
+        raise NotImplementedError, "#{self.name} must implement the .call method"
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/renderers/markdown.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Renderers
+    class Markdown < Base
+      def self.call(context:)
+        new(context: context).render
+      end
+
+      def initialize(context:)
+        @context = context
+      end
+
+      def render
+        [
+          render_header,
+          render_file_tree,
+          render_files
+        ].join("\n---\n")
+      end
+
+      private
+
+      def render_header
+        project_info = @context.metadata[:project] || {}
+        git_info = @context.metadata[:git] || {}
+        gem_info = (@context.metadata[:gems] || {}).map { |n, v| "- **#{n}:** #{v}" }.join("\n")
+
+        packages = @context.metadata[:packages] || {}
+        pkg_info = (packages[:dependencies] || {}).map { |n, v| "- **#{n}:** #{v}" }.join("\n")
+
+        <<~HEADER
+          # Contextizer Report
+
+          ## Meta Context
+          - **Project:** #{@context.project_name}
+          - **Type:** #{project_info[:type]}
+          - **Version:** #{project_info[:version]}
+          - **Extracted At:** #{@context.timestamp}
+
+          ### Git Info
+          - **Branch:** `#{git_info[:branch]}`
+          - **Commit:** `#{git_info[:commit]}`
+
+          ### Key Ruby Dependencies
+          #{gem_info.empty? ? "Not found." : gem_info}
+
+          ### Key JS Dependencies
+          #{pkg_info.empty? ? "Not found." : pkg_info}
+        HEADER
+      end
+
+      def render_file_tree
+        paths = @context.files.map { |f| f[:path] }
+        tree_hash = build_path_hash(paths)
+        tree_string = format_tree_node(tree_hash).join("\n")
+
+        <<~TREE
+          ### File Structure
+          <details>
+          <summary>Click to view file tree</summary>
+
+          ```text
+          #{@context.project_name}/
+          #{tree_string}
+          ```
+
+          </details>
+        TREE
+      end
+
+      def build_path_hash(paths)
+        paths.each_with_object({}) do |path, hash|
+          path.split("/").reduce(hash) do |level, part|
+            level[part] ||= {}
+          end
+        end
+      end
+
+      def format_tree_node(node, prefix = "")
+        output = []
+        children = node.keys.sort
+        children.each_with_index do |key, index|
+          is_last = (index == children.length - 1)
+          connector = is_last ? "└── " : "├── "
+          output << "#{prefix}#{connector}#{key}"
+
+          if node[key].any?
+            new_prefix = prefix + (is_last ? "    " : "│   ")
+            output.concat(format_tree_node(node[key], new_prefix))
+          end
+        end
+        output
+      end
+
+      def render_files
+        @context.files.map do |file|
+          lang = File.extname(file[:path]).delete(".")
+          lang = "ruby" if lang == "rb"
+          lang = "ruby" if lang == "gemspec"
+          lang = "javascript" if lang == "js"
+
+          <<~FILE_BLOCK
+            #### File: `#{file[:path]}`
+            ```#{lang}
+            #{file[:content]}
+            ```
+          FILE_BLOCK
+        end.join("\n---\n")
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/version.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  VERSION = "0.1.0"
+end
+
+```
+
+---
+#### File: `lib/contextizer/writer.rb`
+```ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Contextizer
+  class Writer
+    def self.call(content:, destination:)
+      path = Pathname.new(destination)
+      puts "[Contextizer] Writer: Saving report to #{path}..."
+
+      FileUtils.mkdir_p(path.dirname)
+      File.write(path, content)
+
+      puts "[Contextizer] Writer: Report saved successfully."
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer.rb`
+```ruby
+# frozen_string_literal: true
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "cli" => "CLI",
+  "javascript" => "JavaScript",
+)
+loader.setup
+
+require_relative "contextizer/version"
+
+module Contextizer
+  class Error < StandardError; end
+  # ...
+end
+
+loader.eager_load
+
+```
+
+---
+#### File: `config/default.yml`
+```yml
+# config/default.yml
+# Gem's default configuration. DO NOT EDIT.
+# Create a .contextizer.yml in your project to override.
+
+# Default output path.
+# Placeholders: {profile}, {timestamp}, {project_name}
+#output: "tmp/contextizer/{profile}_{timestamp}.md"
+output: "{project_name}_{timestamp}.md"
+
+# Default rendering format.
+format: "markdown"
+
+# Provider settings.
+providers:
+  git: true
+  filesystem: true
+  gems: true
+  project_info: true
+  # Framework-specific providers are disabled by default.
+  # They will be auto-enabled if the environment is detected.
+  rails_routes: "auto"
+  rails_schema: "auto"
+
+# Settings for specific providers.
+settings:
+  gems:
+    key_gems:
+      - rails
+      - devise
+      - sidekiq
+      - rspec-rails
+      - pg
+  filesystem:
+    # Default component definitions for a typical Ruby/Rails project.
+    components:
+      models: "app/models/**/*.rb"
+      views: "app/views/**/*.{erb,haml,slim,arb}"
+      controllers: "app/controllers/**/*.rb"
+      services: "app/services/**/*.rb"
+      lib: "lib/**/*.rb"
+      config: "config/**/*.{rb,yml}"
+      gem: # For gem development
+        - "*.gemspec"
+        - "lib/**/*.rb"
+        - "README.md"
+        - "CHANGELOG.md"
+      documentation: "*.md"
+    # Files/directories to exclude globally.
+    exclude:
+      - "tmp/**/*"
+      - "log/**/*"
+      - "node_modules/**/*"
+      - ".git/**/*"
+```
+
+---
+#### File: `contextizer.gemspec`
+```ruby
+# frozen_string_literal: true
+
+require_relative "lib/contextizer/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "contextizer"
+  spec.version = Contextizer::VERSION
+  spec.authors = ["Alexander"]
+  spec.email = ["alexander.s.fokin@gmail.com"]
+
+  spec.summary = "A tool to extract and package project context."
+  spec.description = "Contextizer is a tool to extract and package project context."
+  spec.homepage = "https://github.com/alexander-s-f/contextizer"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the "allowed_push_host"
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  spec.metadata["allowed_push_host"] = "http://mygemserver.com"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  gemspec = File.basename(__FILE__)
+  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL) do |ls|
+    ls.readlines("\x0", chomp: true).reject do |f|
+      (f == gemspec) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_dependency "thor", "~> 1.3"
+  spec.add_dependency "zeitwerk", "~> 2.6"
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  class Analyzer
+    SPECIALISTS = Analyzers.constants.map do |const|
+      Analyzers.const_get(const)
+    end.select { |const| const.is_a?(Class) && const < Analyzers::Base }
+
+    def self.call(target_path:)
+      new(target_path: target_path).analyze
+    end
+
+    def initialize(target_path:)
+      @target_path = target_path
+    end
+
+    def analyze
+      results = SPECIALISTS.map do |specialist_class|
+        specialist_class.call(target_path: @target_path)
+      end.compact
+
+      return { language: :unknown, framework: nil, scores: {} } if results.empty?
+
+      best_result = results.max_by { |result| result[:score] }
+
+      {
+        language: best_result[:language],
+        framework: best_result[:framework],
+        scores: results.map { |r| [r[:language], r[:score]] }.to_h
+      }
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/base.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class Base
+      def self.call(target_path:)
+        new(target_path: target_path).analyze
+      end
+
+      def initialize(target_path:)
+        @target_path = Pathname.new(target_path)
+        @score = 0
+      end
+
+      def analyze
+        raise NotImplementedError, "#{self.class.name} must implement #analyze"
+      end
+
+      protected
+
+      def check_signal(signal)
+        path = @target_path.join(signal[:path])
+        case signal[:type]
+        when :file
+          @target_path.glob(signal[:path]).any?
+        when :dir
+          path.directory?
+        else
+          false
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/java_script_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class JavaScriptAnalyzer < Base
+      LANGUAGE = :javascript
+
+      SIGNALS = [
+        { type: :file, path: "package.json", weight: 5 },
+        { type: :dir,  path: "node_modules", weight: 10 },
+        { type: :file, path: "webpack.config.js", weight: 5 },
+        { type: :file, path: "vite.config.js", weight: 5 }
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {}.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: nil,
+          score: @score
+        }
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/python_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class PythonAnalyzer < Base
+      LANGUAGE = :python
+
+      SIGNALS = [
+        { type: :file, path: "requirements.txt", weight: 10 },
+        { type: :file, path: "pyproject.toml", weight: 10 },
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {
+        # rails: [{ type: :file, path: "bin/rails", weight: 15 }]
+      }.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: detect_framework,
+          score: @score
+        }
+      end
+
+      private
+
+      def detect_framework
+        (FRAMEWORK_SIGNALS || {}).each do |fw, signals|
+          return fw if signals.any? { |signal| check_signal(signal) }
+        end
+        nil
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/analyzers/ruby_analyzer.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Analyzers
+    class RubyAnalyzer < Base
+      LANGUAGE = :ruby
+
+      SIGNALS = [
+        { type: :file, path: "Gemfile", weight: 10 },
+        { type: :file, path: "*.gemspec", weight: 20 },
+        { type: :dir,  path: "app/controllers", weight: 5 }
+      ].freeze
+
+      FRAMEWORK_SIGNALS = {
+        rails: [{ type: :file, path: "bin/rails", weight: 15 }]
+      }.freeze
+
+      def analyze
+        SIGNALS.each { |signal| @score += signal[:weight] if check_signal(signal) }
+
+        return nil if @score.zero?
+
+        {
+          language: LANGUAGE,
+          framework: detect_framework,
+          score: @score
+        }
+      end
+
+      private
+
+      def detect_framework
+        (FRAMEWORK_SIGNALS || {}).each do |fw, signals|
+          return fw if signals.any? { |signal| check_signal(signal) }
+        end
+        nil
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/cli.rb`
+```ruby
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+
+module Contextizer
+  class CLI < Thor
+    desc "extract [TARGET_PATH]", "Extracts project context into a single file."
+    option :git_url,
+           type: :string,
+           desc: "URL of a remote git repository to analyze instead of a local path."
+    option :output,
+           aliases: "-o",
+           type: :string,
+           desc: "Output file path (overrides config)."
+    option :format,
+           aliases: "-f",
+           type: :string,
+           desc: "Output format (e.g., markdown, json)."
+
+    RENDERER_MAPPING = {
+      "markdown" => Renderers::Markdown
+    }.freeze
+
+    def extract(target_path = ".")
+      if options[:git_url]
+        RemoteRepoHandler.handle(options[:git_url]) do |remote_path|
+          run_extraction(remote_path)
+        end
+      else
+        run_extraction(target_path)
+      end
+    end
+
+    private
+
+    def run_extraction(path)
+      cli_options = options.transform_keys(&:to_s).compact
+      config = Configuration.load(cli_options)
+
+      context = Collector.call(config: config, target_path: path)
+
+      renderer = RENDERER_MAPPING[config.format]
+      raise Error, "Unsupported format: '#{config.format}'" unless renderer
+
+      rendered_output = renderer.call(context: context)
+
+      destination_path = resolve_output_path(config.output, context)
+      Writer.call(content: rendered_output, destination: destination_path)
+
+      puts "\nContextizer: Extraction complete! ✨"
+    end
+
+    def resolve_output_path(path_template, context)
+      timestamp = Time.now.strftime("%Y-%m-%d_%H%M")
+      project_name = context.metadata.dig(:project, :type) == "Gem" ? context.project_name : "project"
+
+
+      path_template
+        .gsub("{profile}", "default")
+        .gsub("{timestamp}", timestamp)
+        .gsub("{project_name}", project_name)
+    end
+  end
+end
+```
+
+---
+#### File: `lib/contextizer/collector.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  class Collector
+    BASE_PROVIDERS = [
+      Providers::Base::ProjectName,
+      Providers::Base::Git,
+      Providers::Base::FileSystem
+    ].freeze
+
+    LANGUAGE_MODULES = {
+      ruby: Providers::Ruby,
+      javascript: Providers::JavaScript
+    }.freeze
+
+    def self.call(config:, target_path:)
+      new(config: config, target_path: target_path).call
+    end
+
+    def initialize(config:, target_path:)
+      @config = config
+      @target_path = target_path
+      @context = Context.new(target_path: target_path)
+    end
+
+    def call
+      stack = Analyzer.call(target_path: @target_path)
+      @context.metadata[:stack] = stack
+
+      BASE_PROVIDERS.each do |provider_class|
+        provider_class.call(context: @context, config: @config)
+      end
+
+      language_module = LANGUAGE_MODULES[stack[:language]]
+      run_language_providers(language_module) if language_module
+
+      puts "Collector: Collection complete. Found #{@context.files.count} files."
+      @context
+    end
+
+    private
+
+    def run_language_providers(language_module)
+      puts "Collector: Running '#{language_module.name.split('::').last}' providers..."
+      language_module.constants.each do |const_name|
+        provider_class = language_module.const_get(const_name)
+        if provider_class.is_a?(Class) && provider_class < Providers::BaseProvider
+          provider_class.call(context: @context, config: @config)
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/configuration.rb`
+```ruby
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Contextizer
+  class Configuration
+    # CLI options > Project Config > Default Config
+    def self.load(cli_options = {})
+      default_config_path = Pathname.new(__dir__).join("../../config/default.yml")
+      default_config = YAML.load_file(default_config_path)
+
+      project_config_path = find_project_config
+      project_config = project_config_path ? YAML.load_file(project_config_path) : {}
+
+      merged_config = deep_merge(default_config, project_config)
+      merged_config = deep_merge(merged_config, cli_options)
+
+      new(merged_config)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    def method_missing(name, *args, &block)
+      key = name.to_s
+      if @options.key?(key)
+        @options[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      @options.key?(name.to_s) || super
+    end
+
+    def self.find_project_config(path = Dir.pwd)
+      path = Pathname.new(path)
+      loop do
+        config_file = path.join(".contextizer.yml")
+        return config_file if config_file.exist?
+        break if path.root?
+
+        path = path.parent
+      end
+      nil
+    end
+
+    def self.deep_merge(hash1, hash2)
+      hash1.merge(hash2) do |key, old_val, new_val|
+        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+          deep_merge(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/context.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  # A value object that holds all the collected information about a project.
+  # This object is the result of the Collector phase and the input for the Renderer phase.
+  Context = Struct.new(
+    :project_name,
+    :target_path,
+    :timestamp,
+    :metadata,     # Hash for data from providers like Git, Gems, etc.
+    :files,        # Array of file objects { path:, content: }
+    keyword_init: true
+  ) do
+    def initialize(*)
+      super
+      self.metadata ||= {}
+      self.files ||= []
+      self.timestamp ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/file_system.rb`
+```ruby
+# frozen_string_literal: true
+
+require "pathname"
+
+module Contextizer
+  module Providers
+    module Base
+      class FileSystem < BaseProvider
+        def self.call(context:, config:)
+          new(context: context, config: config).collect_files
+        end
+
+        def initialize(context:, config:)
+          @context = context
+          @config = config.settings["filesystem"]
+          @target_path = Pathname.new(context.target_path)
+        end
+
+        def collect_files
+          file_paths = find_matching_files
+
+          file_paths.each do |path|
+            content = read_file_content(path)
+            next unless content
+
+            @context.files << {
+              path: path.relative_path_from(@target_path).to_s,
+              content: content
+            }
+          end
+        end
+
+        private
+
+        def find_matching_files
+          patterns = @config["components"].values.flatten.map do |pattern|
+            (@target_path / pattern).to_s
+          end
+
+          all_files = Dir.glob(patterns)
+
+          exclude_patterns = @config["exclude"].map do |pattern|
+            (@target_path / pattern).to_s
+          end
+
+          all_files.reject do |file|
+            exclude_patterns.any? { |pattern| File.fnmatch?(pattern, file) }
+          end.map { |file| Pathname.new(file) }
+        end
+
+        def read_file_content(path)
+          path.read
+        rescue Errno::ENOENT, IOError => e
+          warn "Warning: Could not read file #{path}: #{e.message}"
+          nil
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/git.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Base
+      class Git < BaseProvider
+        def self.call(context:, config:)
+          context.metadata[:git] = fetch_git_info(context.target_path)
+          @config = config
+        end
+
+        def self.fetch_git_info(path)
+          Dir.chdir(path) do
+            {
+              branch: `git rev-parse --abbrev-ref HEAD`.strip,
+              commit: `git rev-parse HEAD`.strip[0, 8]
+            }
+          end
+        rescue StandardError
+          { branch: "N/A", commit: "N/A" }
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base/project_name.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Base
+      class ProjectName < BaseProvider
+        def self.call(context:, config:)
+          context.project_name = detect_project_name(context.target_path)
+        end
+
+        private
+
+        def self.detect_project_name(path)
+          git_name = name_from_git_remote(path)
+          return git_name if git_name
+
+          File.basename(path)
+        end
+
+        def self.name_from_git_remote(path)
+          return nil unless Dir.exist?(File.join(path, ".git"))
+
+          Dir.chdir(path) do
+            remote_url = `git remote get-url origin`.strip
+            remote_url.split("/").last.sub(/\.git$/, "")
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/base_provider.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    class BaseProvider
+      # @param context [Contextizer::Context] The context object to be populated.
+      # @param config [Contextizer::Configuration] The overall configuration.
+      def self.call(context:, config:)
+        raise NotImplementedError, "#{self.name} must implement the .call method"
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/javascript/packages.rb`
+```ruby
+# frozen_string_literal: true
+require "json"
+
+module Contextizer
+  module Providers
+    module JavaScript
+      class Packages < BaseProvider
+        def self.call(context:, config:)
+          package_json_path = File.join(context.target_path, "package.json")
+          return unless File.exist?(package_json_path)
+
+          context.metadata[:packages] = parse_packages(package_json_path)
+        end
+
+        private
+
+        def self.parse_packages(path)
+          begin
+            file = File.read(path)
+            data = JSON.parse(file)
+            {
+              dependencies: data["dependencies"] || {},
+              dev_dependencies: data["devDependencies"] || {}
+            }
+          rescue JSON::ParserError => e
+            puts "Warning: Could not parse package.json: #{e.message}"
+            {}
+          end
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/ruby/gems.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Ruby
+      class Gems < BaseProvider
+        def self.call(context:, config:)
+          key_gems = config.settings.dig("gems", "key_gems")
+          return if key_gems.nil? || key_gems.empty?
+
+          gemfile_lock = File.join(context.target_path, "Gemfile.lock")
+          return unless File.exist?(gemfile_lock)
+
+          context.metadata[:gems] = parse_gemfile_lock(gemfile_lock, key_gems)
+        end
+
+        def self.parse_gemfile_lock(path, key_gems)
+          found_gems = {}
+          content = File.read(path)
+          key_gems.each do |gem_name|
+            match = content.match(/^\s{4}#{gem_name}\s\((.+?)\)/)
+            found_gems[gem_name] = match[1] if match
+          end
+          found_gems
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/providers/ruby/project_info.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Providers
+    module Ruby
+      class ProjectInfo < BaseProvider
+        def self.call(context:, config:)
+          project_info = detect_project_info(context.target_path)
+          context.metadata[:project] = project_info
+        end
+
+
+        def self.detect_project_info(path)
+          if Dir.glob(File.join(path, "*.gemspec")).any?
+            return { type: "Gem", version: detect_gem_version(path) }
+          end
+
+          if File.exist?(File.join(path, "bin", "rails"))
+            return { type: "Rails", version: detect_rails_version(path) }
+          end
+
+          { type: "Directory", version: "N/A" }
+        end
+
+        def self.detect_gem_version(path)
+          version_file = Dir.glob(File.join(path, "lib", "**", "version.rb")).first
+          return "N/A" unless version_file
+
+          content = File.read(version_file)
+          match = content.match(/VERSION\s*=\s*["'](.+?)["']/)
+          match ? match[1] : "N/A"
+        end
+
+        def self.detect_rails_version(path)
+          gemfile_lock = File.join(path, "Gemfile.lock")
+          return "N/A" unless File.exist?(gemfile_lock)
+
+          content = File.read(gemfile_lock)
+          match = content.match(/^\s{4}rails\s\((.+?)\)/)
+          match ? match[1] : "N/A"
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/remote_repo_handler.rb`
+```ruby
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+
+module Contextizer
+  class RemoteRepoHandler
+    def self.handle(url)
+      Dir.mktmpdir("contextizer-clone-") do |temp_path|
+        puts "Cloning #{url} into temporary directory..."
+
+        success = system("git clone --depth 1 #{url} #{temp_path}")
+
+        if success
+          puts "Cloning successful."
+          yield(temp_path)
+        else
+          puts "Error: Failed to clone repository."
+        end
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/renderers/base.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Renderers
+    class Base
+      # @param context [Contextizer::Context] The context object to be rendered.
+      def self.call(context:)
+        raise NotImplementedError, "#{self.name} must implement the .call method"
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/renderers/markdown.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  module Renderers
+    class Markdown < Base
+      def self.call(context:)
+        new(context: context).render
+      end
+
+      def initialize(context:)
+        @context = context
+      end
+
+      def render
+        [
+          render_header,
+          render_file_tree,
+          render_files
+        ].join("\n---\n")
+      end
+
+      private
+
+      def render_header
+        project_info = @context.metadata[:project] || {}
+        git_info = @context.metadata[:git] || {}
+        gem_info = (@context.metadata[:gems] || {}).map { |n, v| "- **#{n}:** #{v}" }.join("\n")
+
+        packages = @context.metadata[:packages] || {}
+        pkg_info = (packages[:dependencies] || {}).map { |n, v| "- **#{n}:** #{v}" }.join("\n")
+
+        <<~HEADER
+          # Contextizer Report
+
+          ## Meta Context
+          - **Project:** #{@context.project_name}
+          - **Type:** #{project_info[:type]}
+          - **Version:** #{project_info[:version]}
+          - **Extracted At:** #{@context.timestamp}
+
+          ### Git Info
+          - **Branch:** `#{git_info[:branch]}`
+          - **Commit:** `#{git_info[:commit]}`
+
+          ### Key Ruby Dependencies
+          #{gem_info.empty? ? "Not found." : gem_info}
+
+          ### Key JS Dependencies
+          #{pkg_info.empty? ? "Not found." : pkg_info}
+        HEADER
+      end
+
+      def render_file_tree
+        paths = @context.files.map { |f| f[:path] }
+        tree_hash = build_path_hash(paths)
+        tree_string = format_tree_node(tree_hash).join("\n")
+
+        <<~TREE
+          ### File Structure
+          <details>
+          <summary>Click to view file tree</summary>
+
+          ```text
+          #{@context.project_name}/
+          #{tree_string}
+          ```
+
+          </details>
+        TREE
+      end
+
+      def build_path_hash(paths)
+        paths.each_with_object({}) do |path, hash|
+          path.split("/").reduce(hash) do |level, part|
+            level[part] ||= {}
+          end
+        end
+      end
+
+      def format_tree_node(node, prefix = "")
+        output = []
+        children = node.keys.sort
+        children.each_with_index do |key, index|
+          is_last = (index == children.length - 1)
+          connector = is_last ? "└── " : "├── "
+          output << "#{prefix}#{connector}#{key}"
+
+          if node[key].any?
+            new_prefix = prefix + (is_last ? "    " : "│   ")
+            output.concat(format_tree_node(node[key], new_prefix))
+          end
+        end
+        output
+      end
+
+      def render_files
+        @context.files.map do |file|
+          lang = File.extname(file[:path]).delete(".")
+          lang = "ruby" if lang == "rb"
+          lang = "ruby" if lang == "gemspec"
+          lang = "javascript" if lang == "js"
+
+          <<~FILE_BLOCK
+            #### File: `#{file[:path]}`
+            ```#{lang}
+            #{file[:content]}
+            ```
+          FILE_BLOCK
+        end.join("\n---\n")
+      end
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer/version.rb`
+```ruby
+# frozen_string_literal: true
+
+module Contextizer
+  VERSION = "0.1.0"
+end
+
+```
+
+---
+#### File: `lib/contextizer/writer.rb`
+```ruby
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Contextizer
+  class Writer
+    def self.call(content:, destination:)
+      path = Pathname.new(destination)
+      puts "[Contextizer] Writer: Saving report to #{path}..."
+
+      FileUtils.mkdir_p(path.dirname)
+      File.write(path, content)
+
+      puts "[Contextizer] Writer: Report saved successfully."
+    end
+  end
+end
+
+```
+
+---
+#### File: `lib/contextizer.rb`
+```ruby
+# frozen_string_literal: true
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "cli" => "CLI",
+  "javascript" => "JavaScript",
+)
+loader.setup
+
+require_relative "contextizer/version"
+
+module Contextizer
+  class Error < StandardError; end
+  # ...
+end
+
+loader.eager_load
+
+```
+
+---
+#### File: `README.md`
+```md
+# Contextizer
+
+**Contextizer** is a versatile command-line tool for extracting, analyzing, and packaging the context of any software project. It scans a codebase, gathers key metadata (language, framework, dependencies, git status), and aggregates the source code into a single, easy-to-digest Markdown report.
+
+It's the perfect tool for:
+-   Preparing context for analysis by Large Language Models (LLMs).
+-   Quickly onboarding a new developer to a project.
+-   Archiving a project snapshot for a code review.
+-   Creating comprehensive bug reports.
+
+---
+
+## Key Features
+
+* **Polyglot by Design:** Automatically detects a project's primary language and framework (Ruby/Rails, JavaScript, etc.) using a smart "signals and weights" system.
+* **Plug-and-Play Architecture:** Easily extendable to support new languages and frameworks by adding new "Analyzers" and "Providers".
+* **Rich Metadata Collection:** Extracts Git information (branch, commit), key dependencies (`Gemfile`, `package.json`), and the project's structure.
+* **Remote Repository Analysis:** Can clone and analyze any public Git repository directly from a URL, no manual cloning required.
+* **Flexible Configuration:** Controlled via a simple YAML file (`.contextizer.yml`) in your project's root, allowing you to fine-tune the data collection process.
+* **Clean & Readable Reports:** Generates a single Markdown file with a visual file tree, project metadata, and syntax-highlighted source code.
+
+---
+
+## Installation
+
+### Standalone (Recommended)
+
+Install the gem globally to use it in any project on your system:
+
+```bash
+gem install contextizer
+```
+
+### As a Project Dependency (Bundler)
+
+Add it to your project's `Gemfile` within the `:development` group:
+
+```ruby
+# Gemfile
+group :development do
+  gem 'contextizer'
+end
+```
+
+Then, execute:
+
+```bash
+bundle install
+```
+
+---
+
+## Usage
+
+### Analyzing a Local Project
+
+Navigate to your project's root directory and run:
+
+```bash
+contextizer extract
+```
+
+The report will be saved in the current directory by default.
+
+### Analyzing a Remote Git Repository
+
+Use the `--git-url` option to analyze any public repository:
+
+```bash
+contextizer extract --git-url https://github.com/rails/rails
+```
+
+### Common Options
+
+- `[TARGET_PATH]`: (Optional) The path to the directory to analyze. Defaults to the current directory.
+- `--git-url URL`: The URL of a remote Git repository to analyze.
+- `-o, --output PATH`: The destination path for the final report file.
+- `-f, --format FORMAT`: The output format (currently supports `markdown`).
+
+---
+
+## ⚙️ Configuration
+
+To customize Contextizer for your project, create a `.contextizer.yml` file in its root directory.
+
+The tool uses a three-tiered configuration system with the following priority:
+
+CLI Options > .contextizer.yml > Gem Defaults
+
+### Example `.contextizer.yml`
+
+YAML
+
+```
+# .contextizer.yml
+
+# Path to save the report.
+# Available placeholders: {project_name}, {timestamp}
+output: "docs/context/{project_name}_{timestamp}.md"
+
+# Settings for specific providers
+settings:
+  # Settings for the Ruby gems provider
+  gems:
+    key_gems: # List your project's most important gems here
+      - rails
+      - devise
+      - sidekiq
+      - rspec-rails
+      - pg
+      - pundit
+
+  # Settings for the filesystem provider
+  filesystem:
+    # Specify which files and directories to include in the report
+    components:
+      models: "app/models/**/*.rb"
+      controllers: "app/controllers/**/*.rb"
+      services: "app/services/**/*.rb"
+      javascript: "app/javascript/**/*.js"
+      config:
+        - "config/routes.rb"
+        - "config/application.rb"
+      documentation:
+        - "README.md"
+        - "CONTRIBUTING.md"
+
+    # Global exclusion patterns
+    exclude:
+      - "tmp/**/*"
+      - "log/**/*"
+      - "node_modules/**/*"
+      - ".git/**/*"
+      - "vendor/**/*"
+```
+
+---
+
+## Extensibility (Adding a New Language)
+
+Thanks to the plug-and-play architecture, adding support for a new language is straightforward:
+
+1. **Create a Specialist Analyzer**: Add a new file in `lib/contextizer/analyzers/` that detects the language based on its characteristic files and directories.
+2. **Create Providers**: Add a new directory in `lib/contextizer/providers/` with providers that extract language-specific information (e.g., dependencies from a `pom.xml` file for Java).
+
+The main `Analyzer` and `Collector` will automatically discover and use your new components.
+
+---
+
+## Contributing
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Add some feature'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new Pull Request.
+
+
+---
+
+## License
+
+This project is released under the MIT License.
+
+```
+
+---
+#### File: `CHANGELOG.md`
+```md
+## [Unreleased]
+
+## [0.1.0] - 2025-08-31
+
+- Initial release
+
+```
+
+---
+#### File: `CHANGELOG.md`
+```md
+## [Unreleased]
+
+## [0.1.0] - 2025-08-31
+
+- Initial release
+
+```
+
+---
+#### File: `CODE_OF_CONDUCT.md`
+```md
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
+
+```
+
+---
+#### File: `README.md`
+```md
+# Contextizer
+
+**Contextizer** is a versatile command-line tool for extracting, analyzing, and packaging the context of any software project. It scans a codebase, gathers key metadata (language, framework, dependencies, git status), and aggregates the source code into a single, easy-to-digest Markdown report.
+
+It's the perfect tool for:
+-   Preparing context for analysis by Large Language Models (LLMs).
+-   Quickly onboarding a new developer to a project.
+-   Archiving a project snapshot for a code review.
+-   Creating comprehensive bug reports.
+
+---
+
+## Key Features
+
+* **Polyglot by Design:** Automatically detects a project's primary language and framework (Ruby/Rails, JavaScript, etc.) using a smart "signals and weights" system.
+* **Plug-and-Play Architecture:** Easily extendable to support new languages and frameworks by adding new "Analyzers" and "Providers".
+* **Rich Metadata Collection:** Extracts Git information (branch, commit), key dependencies (`Gemfile`, `package.json`), and the project's structure.
+* **Remote Repository Analysis:** Can clone and analyze any public Git repository directly from a URL, no manual cloning required.
+* **Flexible Configuration:** Controlled via a simple YAML file (`.contextizer.yml`) in your project's root, allowing you to fine-tune the data collection process.
+* **Clean & Readable Reports:** Generates a single Markdown file with a visual file tree, project metadata, and syntax-highlighted source code.
+
+---
+
+## Installation
+
+### Standalone (Recommended)
+
+Install the gem globally to use it in any project on your system:
+
+```bash
+gem install contextizer
+```
+
+### As a Project Dependency (Bundler)
+
+Add it to your project's `Gemfile` within the `:development` group:
+
+```ruby
+# Gemfile
+group :development do
+  gem 'contextizer'
+end
+```
+
+Then, execute:
+
+```bash
+bundle install
+```
+
+---
+
+## Usage
+
+### Analyzing a Local Project
+
+Navigate to your project's root directory and run:
+
+```bash
+contextizer extract
+```
+
+The report will be saved in the current directory by default.
+
+### Analyzing a Remote Git Repository
+
+Use the `--git-url` option to analyze any public repository:
+
+```bash
+contextizer extract --git-url https://github.com/rails/rails
+```
+
+### Common Options
+
+- `[TARGET_PATH]`: (Optional) The path to the directory to analyze. Defaults to the current directory.
+- `--git-url URL`: The URL of a remote Git repository to analyze.
+- `-o, --output PATH`: The destination path for the final report file.
+- `-f, --format FORMAT`: The output format (currently supports `markdown`).
+
+---
+
+## ⚙️ Configuration
+
+To customize Contextizer for your project, create a `.contextizer.yml` file in its root directory.
+
+The tool uses a three-tiered configuration system with the following priority:
+
+CLI Options > .contextizer.yml > Gem Defaults
+
+### Example `.contextizer.yml`
+
+YAML
+
+```
+# .contextizer.yml
+
+# Path to save the report.
+# Available placeholders: {project_name}, {timestamp}
+output: "docs/context/{project_name}_{timestamp}.md"
+
+# Settings for specific providers
+settings:
+  # Settings for the Ruby gems provider
+  gems:
+    key_gems: # List your project's most important gems here
+      - rails
+      - devise
+      - sidekiq
+      - rspec-rails
+      - pg
+      - pundit
+
+  # Settings for the filesystem provider
+  filesystem:
+    # Specify which files and directories to include in the report
+    components:
+      models: "app/models/**/*.rb"
+      controllers: "app/controllers/**/*.rb"
+      services: "app/services/**/*.rb"
+      javascript: "app/javascript/**/*.js"
+      config:
+        - "config/routes.rb"
+        - "config/application.rb"
+      documentation:
+        - "README.md"
+        - "CONTRIBUTING.md"
+
+    # Global exclusion patterns
+    exclude:
+      - "tmp/**/*"
+      - "log/**/*"
+      - "node_modules/**/*"
+      - ".git/**/*"
+      - "vendor/**/*"
+```
+
+---
+
+## Extensibility (Adding a New Language)
+
+Thanks to the plug-and-play architecture, adding support for a new language is straightforward:
+
+1. **Create a Specialist Analyzer**: Add a new file in `lib/contextizer/analyzers/` that detects the language based on its characteristic files and directories.
+2. **Create Providers**: Add a new directory in `lib/contextizer/providers/` with providers that extract language-specific information (e.g., dependencies from a `pom.xml` file for Java).
+
+The main `Analyzer` and `Collector` will automatically discover and use your new components.
+
+---
+
+## Contributing
+
+1. Fork the repository.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Add some feature'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new Pull Request.
+
+
+---
+
+## License
+
+This project is released under the MIT License.
+
+```