contextizer 0.1.1

data/exe/contextizer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "contextizer"
+
+Contextizer::CLI.start(ARGV)

data/lib/contextizer/analyzer.rb

@@ -0,0 +1,33 @@
+# 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

data/lib/contextizer/analyzers/base.rb

@@ -0,0 +1,34 @@
+# 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

data/lib/contextizer/analyzers/java_script_analyzer.rb

@@ -0,0 +1,30 @@
+# 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

data/lib/contextizer/analyzers/python_analyzer.rb

@@ -0,0 +1,39 @@
+# 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

data/lib/contextizer/analyzers/ruby_analyzer.rb

@@ -0,0 +1,40 @@
+# 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

data/lib/contextizer/cli.rb

@@ -0,0 +1,70 @@
+# 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)
+
+      command_string = "contextizer #{ARGV.join(" ")}"
+      context = Collector.call(
+        config: config,
+        target_path: path,
+        command: command_string
+      )
+
+      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

data/lib/contextizer/collector.rb

@@ -0,0 +1,57 @@
+# 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:, command:)
+      new(config: config, target_path: target_path, command: command).call
+    end
+
+    def initialize(config:, target_path:, command:)
+      @config = config
+      @target_path = target_path
+      @command = command
+      @context = Context.new(
+        target_path: target_path,
+        command: @command
+      )
+    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

data/lib/contextizer/configuration.rb

@@ -0,0 +1,61 @@
+# 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

data/lib/contextizer/context.rb

@@ -0,0 +1,22 @@
+# 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,
+    :command,
+    :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

data/lib/contextizer/providers/base/file_system.rb

@@ -0,0 +1,60 @@
+# 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

data/lib/contextizer/providers/base/git.rb

@@ -0,0 +1,25 @@
+# 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

data/lib/contextizer/providers/base/project_name.rb

@@ -0,0 +1,33 @@
+# 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

data/lib/contextizer/providers/base_provider.rb

@@ -0,0 +1,13 @@
+# 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

data/lib/contextizer/providers/javascript/packages.rb

@@ -0,0 +1,33 @@
+# 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

data/lib/contextizer/providers/ruby/gems.rb

@@ -0,0 +1,29 @@
+# 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

data/lib/contextizer/providers/ruby/project_info.rb

@@ -0,0 +1,45 @@
+# 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

data/lib/contextizer/remote_repo_handler.rb

@@ -0,0 +1,23 @@
+# 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

data/lib/contextizer/renderers/base.rb

@@ -0,0 +1,12 @@
+# 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